1use crate::log_err::LogErr as _;
4use super::{AdminError, PageForm};
5use crate::locale::Locale;
6use crate::media::Media;
7use crate::page::Page;
8use crate::page_type::find_handler;
9use crate::page_type_model::PageType;
10use crate::tree_ops::NewPage;
11use axum::extract::{Form, Path, Query, State};
12use axum::http::{header, HeaderMap, HeaderValue};
13use axum::response::{Html, IntoResponse, Redirect, Response};
14use axum::Json;
15use rustango::core::Column as _;
16use rustango::extractors::Tenant;
17use rustango::messages::Level as MsgLevel;
18use rustango::sql::{transaction_pool, FetcherPool as _, FetcherTx as _};
19use serde::Deserialize;
20use std::sync::OnceLock;
21use tera::Context;
22use crate::security_log::Entry as SecurityEntry;
23
24fn messages_secret() -> &'static [u8] {
28 static SECRET: OnceLock<Vec<u8>> = OnceLock::new();
29 SECRET.get_or_init(|| crate::signing::derived_key("rcms:flash"))
30}
31
32async fn sanitized_extension_form(
42 handler: &dyn crate::page_type::PageTypeHandler,
43 pool: &rustango::sql::Pool,
44 page_id: i64,
45 form_map: &std::collections::HashMap<String, String>,
46) -> std::collections::HashMap<String, String> {
47 let mut out = form_map.clone();
48 if let Ok(widgets) = handler.widgets(pool, page_id).await {
49 for w in widgets {
50 if w.kind == crate::widget::WidgetKind::RichText {
51 if let Some(raw) = out.get(&w.name) {
52 let cleaned = crate::markdown::sanitize_html(raw);
53 out.insert(w.name.clone(), cleaned);
54 }
55 }
56 }
57 }
58 out
59}
60
61const PREVIEW_TOKEN_TTL_SECS: i64 = 3600;
65
66pub(crate) fn render_with_csrf(
80 state: &super::AdminState,
81 headers: &HeaderMap,
82 template: &str,
83 ctx: &mut Context,
84) -> Result<Response, AdminError> {
85 let user_pref = ctx
91 .get("user_lang_pref")
92 .and_then(|v| v.as_str())
93 .map(str::to_owned);
94 let tenant_default = super::i18n::tenant_default_locale();
95 let lang = super::i18n::negotiate(
96 headers.get(header::COOKIE).and_then(|v| v.to_str().ok()),
97 headers
98 .get(header::ACCEPT_LANGUAGE)
99 .and_then(|v| v.to_str().ok()),
100 user_pref.as_deref(),
101 tenant_default.as_deref(),
102 );
103 let lang_dir = rustango::i18n::text_direction(&lang);
104 ctx.insert("LANG", &lang);
105 ctx.insert("LANG_DIR", lang_dir);
106 let csrf_cookie = rustango::forms::csrf::stamp_into_context(headers, ctx);
107 let msg_clear = rustango::messages::stamp_into_context(messages_secret(), headers, ctx);
108 let html = state.tera.render(template, ctx)?;
109 let mut resp = Html(html).into_response();
110 if let Some(c) = csrf_cookie {
111 if let Ok(v) = HeaderValue::from_str(&c) {
112 resp.headers_mut().append(header::SET_COOKIE, v);
113 }
114 }
115 if let Some(c) = msg_clear {
116 if let Ok(v) = HeaderValue::from_str(&c) {
117 resp.headers_mut().append(header::SET_COOKIE, v);
118 }
119 }
120 Ok(resp)
121}
122
123fn redirect_named_with_message(
131 name: &'static str,
132 level: MsgLevel,
133 body: &str,
134 headers: &HeaderMap,
135) -> Result<Response, AdminError> {
136 let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
137 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
138 let body = super::i18n::tr(headers, body, &[]);
141 Ok(rustango::messages::redirect_with_message(
142 messages_secret(),
143 headers,
144 level,
145 &body,
146 &url,
147 ))
148}
149
150fn redirect_named_with_message_args(
157 name: &'static str,
158 level: MsgLevel,
159 key: &str,
160 args: &[(&str, &str)],
161 headers: &HeaderMap,
162) -> Result<Response, AdminError> {
163 let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
164 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
165 let body = super::i18n::tr(headers, key, args);
166 Ok(rustango::messages::redirect_with_message(
167 messages_secret(),
168 headers,
169 level,
170 &body,
171 &url,
172 ))
173}
174
175fn redirect_named_with_message_plural(
180 name: &'static str,
181 level: MsgLevel,
182 key: &str,
183 n: i64,
184 args: &[(&str, &str)],
185 headers: &HeaderMap,
186) -> Result<Response, AdminError> {
187 let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
188 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
189 let body = super::i18n::tr_plural(headers, key, n, args);
190 Ok(rustango::messages::redirect_with_message(
191 messages_secret(),
192 headers,
193 level,
194 &body,
195 &url,
196 ))
197}
198
199fn redirect_named_with_params_and_message_plural(
202 name: &'static str,
203 params: &[(&str, String)],
204 level: MsgLevel,
205 key: &str,
206 n: i64,
207 args: &[(&str, &str)],
208 headers: &HeaderMap,
209) -> Result<Response, AdminError> {
210 let owned: std::collections::HashMap<String, String> = params
211 .iter()
212 .map(|(k, v)| ((*k).to_owned(), v.clone()))
213 .collect();
214 let url = rustango::urls::reverse_owned(name, &owned)
215 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
216 let body = super::i18n::tr_plural(headers, key, n, args);
217 Ok(rustango::messages::redirect_with_message(
218 messages_secret(),
219 headers,
220 level,
221 &body,
222 &url,
223 ))
224}
225
226fn unauthorized_no_session() -> Response {
244 unauthorized_no_session_for(None)
245}
246
247fn unauthorized_no_session_for(headers: Option<&HeaderMap>) -> Response {
252 let wants_json = headers
253 .map(|h| {
254 let accept = h
255 .get(header::ACCEPT)
256 .and_then(|v| v.to_str().ok())
257 .unwrap_or("");
258 if accept.contains("application/json") {
259 return true;
260 }
261 h.get("x-requested-with")
262 .and_then(|v| v.to_str().ok())
263 .is_some_and(|v| v.eq_ignore_ascii_case("XMLHttpRequest"))
264 })
265 .unwrap_or(false);
266 let t = |key: &str| -> String {
269 match headers {
270 Some(h) => super::i18n::tr(h, key, &[]),
271 None => key.to_owned(),
272 }
273 };
274 if wants_json {
275 let payload = serde_json::json!({
276 "error": "session_expired",
277 "message": t("Sign in again to keep uploading."),
278 "login_url": "/login?next=/cms-admin/",
279 });
280 return (
281 axum::http::StatusCode::UNAUTHORIZED,
282 [(axum::http::header::CONTENT_TYPE, "application/json")],
283 serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
284 )
285 .into_response();
286 }
287 let lang = headers
288 .map(|h| {
289 super::i18n::negotiate(
290 h.get(header::COOKIE).and_then(|v| v.to_str().ok()),
291 h.get(header::ACCEPT_LANGUAGE).and_then(|v| v.to_str().ok()),
292 None,
293 super::i18n::tenant_default_locale().as_deref(),
294 )
295 })
296 .unwrap_or_else(|| "en".to_owned());
297 let dir = rustango::i18n::text_direction(&lang);
298 const STYLE: &str = r#"<style>
299body{font:14px/1.5 -apple-system,system-ui,sans-serif;color:#222;background:#fafafa;margin:0;padding:48px 20px}
300.box{max-width:560px;margin:0 auto;padding:32px;background:#fff;border-radius:12px;box-shadow:0 2px 8px rgba(0,0,0,.08)}
301h1{font-size:18px;margin:0 0 12px}
302p{margin:0 0 12px;color:#444}
303ul{margin:0 0 12px;padding-left:20px;color:#444}
304li{margin:4px 0}
305a{color:#1565c0}
306</style>"#;
307 let mut body = String::with_capacity(STYLE.len() + 1024);
308 body.push_str("<!doctype html>\n<html lang=\"");
309 body.push_str(&crate::forms::render::html_escape(&lang));
310 body.push_str("\" dir=\"");
311 body.push_str(dir);
312 body.push_str("\"><head><meta charset=\"utf-8\"><title>");
313 body.push_str(&crate::forms::render::html_escape(&t("Session expired")));
314 body.push_str(" — ");
315 body.push_str(&crate::forms::render::html_escape(&t("CMS Admin")));
316 body.push_str("</title>");
317 body.push_str(STYLE);
318 body.push_str("</head><body><div class=\"box\">\n<h1>");
319 body.push_str(&crate::forms::render::html_escape(&t(
320 "Your session has expired",
321 )));
322 body.push_str("</h1>\n<p>");
323 body.push_str(&crate::forms::render::html_escape(&t(
324 "The form couldn't be saved because your admin session decoded as anonymous. The most likely causes:",
325 )));
326 body.push_str("</p>\n<ul>\n<li>");
327 body.push_str(&crate::forms::render::html_escape(&t(
328 "Your login session expired or was signed out from another tab.",
329 )));
330 body.push_str("</li>\n<li>");
331 body.push_str(&crate::forms::render::html_escape(&t(
332 "The cookie was issued for a different tenant slug.",
333 )));
334 body.push_str("</li>\n<li>");
335 body.push_str(&crate::forms::render::html_escape(&t(
336 "On sqlite/mysql builds the framework's tenant session store may not be wired up yet (see issue #259).",
337 )));
338 body.push_str("</li>\n</ul>\n<p><a href=\"/login?next=/cms-admin/\">");
339 body.push_str(&crate::forms::render::html_escape(&t("Sign back in")));
340 body.push_str("</a>");
341 body.push_str(&crate::forms::render::html_escape(&t(
342 ", then re-submit the form.",
343 )));
344 body.push_str("</p>\n</div></body></html>");
345 (
346 axum::http::StatusCode::UNAUTHORIZED,
347 [(axum::http::header::CONTENT_TYPE, "text/html; charset=utf-8")],
348 body,
349 )
350 .into_response()
351}
352
353pub(crate) fn redirect_named_with_params_and_message(
356 name: &'static str,
357 params: &[(&str, String)],
358 level: MsgLevel,
359 body: &str,
360 headers: &HeaderMap,
361) -> Result<Response, AdminError> {
362 let owned: std::collections::HashMap<String, String> = params
363 .iter()
364 .map(|(k, v)| ((*k).to_owned(), v.clone()))
365 .collect();
366 let url = rustango::urls::reverse_owned(name, &owned)
367 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
368 let body = super::i18n::tr(headers, body, &[]);
370 Ok(rustango::messages::redirect_with_message(
371 messages_secret(),
372 headers,
373 level,
374 &body,
375 &url,
376 ))
377}
378
379pub(crate) fn redirect_named_with_params_and_message_args(
383 name: &'static str,
384 params: &[(&str, String)],
385 level: MsgLevel,
386 key: &str,
387 args: &[(&str, &str)],
388 headers: &HeaderMap,
389) -> Result<Response, AdminError> {
390 let owned: std::collections::HashMap<String, String> = params
391 .iter()
392 .map(|(k, v)| ((*k).to_owned(), v.clone()))
393 .collect();
394 let url = rustango::urls::reverse_owned(name, &owned)
395 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
396 let body = super::i18n::tr(headers, key, args);
397 Ok(rustango::messages::redirect_with_message(
398 messages_secret(),
399 headers,
400 level,
401 &body,
402 &url,
403 ))
404}
405
406fn redirect_after_page_save(
421 action: &str,
422 page_id: i64,
423 parent_id: Option<i64>,
424 body: &str,
425 headers: &HeaderMap,
426) -> Result<Response, AdminError> {
427 let url = match action {
428 "continue" => rustango::urls::reverse_owned(
429 "rcms-admin:pages:edit",
430 &std::iter::once(("id".to_owned(), page_id.to_string())).collect(),
431 )
432 .map_err(|e| AdminError::Validation(format!("url reversal of `pages:edit` failed: {e}")))?,
433 "addanother" => {
434 let base =
435 rustango::urls::reverse("rcms-admin:pages:new", &std::collections::HashMap::new())
436 .map_err(|e| {
437 AdminError::Validation(format!("url reversal of `pages:new` failed: {e}"))
438 })?;
439 match parent_id {
440 Some(pid) => format!("{base}?parent={pid}"),
441 None => base,
442 }
443 }
444 _ => rustango::urls::reverse("rcms-admin:pages:list", &std::collections::HashMap::new())
445 .map_err(|e| {
446 AdminError::Validation(format!("url reversal of `pages:list` failed: {e}"))
447 })?,
448 };
449 Ok(rustango::messages::redirect_with_message(
450 messages_secret(),
451 headers,
452 MsgLevel::Success,
453 body,
454 &url,
455 ))
456}
457
458pub(crate) fn user_email(u: &rustango::tenancy::auth::User) -> String {
462 u.email
463 .as_deref()
464 .map(str::trim)
465 .filter(|e| !e.is_empty())
466 .or_else(|| u.data.get("email").and_then(|v| v.as_str()).map(str::trim))
467 .unwrap_or("")
468 .to_owned()
469}
470
471pub async fn add_chrome(
488 ctx: &mut Context,
489 tenant: &Tenant,
490 active_tab: &str,
491 session_user: Option<&rustango::tenancy::auth::User>,
492) {
493 add_chrome_sync(ctx, tenant, active_tab);
494 if let Some(user) = session_user {
495 add_user_chrome(ctx, user, tenant.pool()).await;
496 }
497 add_branding_urls(ctx, tenant).await;
499}
500
501pub(crate) async fn add_branding_urls(ctx: &mut Context, tenant: &Tenant) {
509 let mut site_name = tenant.org.display_name.clone();
512 if let Ok(Some(row)) = crate::site_setting::get(tenant.pool(), "branding").await {
513 if let Some(n) = row.value_json.get("site_name").and_then(|v| v.as_str()).filter(|n| !n.trim().is_empty()) {
514 n.trim().clone_into(&mut site_name);
515 }
516 let is_set = |key: &str| {
517 row.value_json
518 .get(key)
519 .and_then(|v| v.as_str())
520 .is_some_and(|s| !s.is_empty())
521 };
522 if is_set("logo_storage_key") {
523 ctx.insert("branding_logo_url", "/__cms-branding/logo");
524 }
525 if is_set("favicon_storage_key") {
526 ctx.insert("branding_favicon_url", "/__cms-branding/favicon");
527 }
528 }
529 ctx.insert("site_name", &site_name);
530}
531
532fn add_chrome_sync(ctx: &mut Context, tenant: &Tenant, active_tab: &str) {
537 ctx.insert("active_tab", active_tab);
538 ctx.insert("tenant_slug", &tenant.org.slug);
539 ctx.insert("LANG", "en");
543 ctx.insert("LANG_DIR", "ltr");
544 ctx.insert(
546 "ui_locales",
547 &super::i18n::UI_LOCALES
548 .iter()
549 .map(|(c, n)| serde_json::json!({ "code": c, "name": n }))
550 .collect::<Vec<_>>(),
551 );
552 let brand = tenant
553 .org
554 .brand_name
555 .clone()
556 .filter(|s| !s.is_empty())
557 .unwrap_or_else(|| tenant.org.display_name.clone());
558 ctx.insert("brand_name", &brand);
559 ctx.insert("user_timezone", "");
563 static DEFAULT_TZ: std::sync::OnceLock<String> = std::sync::OnceLock::new();
570 let tenant_default_tz = DEFAULT_TZ
571 .get_or_init(|| crate::config::var("DEFAULT_TIMEZONE").unwrap_or_default())
572 .clone();
573 ctx.insert("tenant_default_timezone", &tenant_default_tz);
574
575 let mut by_section: std::collections::BTreeMap<String, Vec<serde_json::Value>> =
580 std::collections::BTreeMap::new();
581 for handler in super::admin_page::registered_admin_pages() {
582 let section = handler.section().label().to_owned();
583 by_section
584 .entry(section)
585 .or_default()
586 .push(serde_json::json!({
587 "slug": handler.slug(),
588 "label": handler.label(),
589 "icon": handler.icon(),
590 "sort_order": handler.sort_order(),
591 }));
592 }
593 for items in by_section.values_mut() {
594 items.sort_by(|a, b| {
595 let ao = a.get("sort_order").and_then(|v| v.as_i64()).unwrap_or(100);
596 let bo = b.get("sort_order").and_then(|v| v.as_i64()).unwrap_or(100);
597 ao.cmp(&bo).then_with(|| {
598 a.get("label")
599 .and_then(|v| v.as_str())
600 .unwrap_or("")
601 .cmp(b.get("label").and_then(|v| v.as_str()).unwrap_or(""))
602 })
603 });
604 }
605 ctx.insert("extra_admin_pages_by_section", &by_section);
606 let reports_nav: Vec<serde_json::Value> = super::report::registered_reports()
611 .iter()
612 .map(|r| {
613 serde_json::json!({
614 "slug": r.slug(),
615 "title": r.title(),
616 "icon": r.icon(),
617 })
618 })
619 .collect();
620 ctx.insert("registered_reports", &reports_nav);
621 let plugin_menu_items: Vec<serde_json::Value> = crate::hooks::admin_menu_items()
624 .into_iter()
625 .map(|i| {
626 serde_json::json!({
627 "key": i.key,
628 "label": i.label,
629 "icon": i.icon,
630 "href": i.href,
631 })
632 })
633 .collect();
634 ctx.insert("plugin_admin_menu_items", &plugin_menu_items);
635 let help_menu_items: Vec<serde_json::Value> = crate::hooks::help_menu_items()
638 .into_iter()
639 .map(|i| {
640 serde_json::json!({
641 "key": i.key,
642 "label": i.label,
643 "icon": i.icon,
644 "href": i.href,
645 })
646 })
647 .collect();
648 ctx.insert("help_menu_items", &help_menu_items);
649 ctx.insert("admin_css_blobs", &crate::hooks::admin_css());
652 ctx.insert("admin_js_blobs", &crate::hooks::admin_js());
653 ctx.insert("sidebar_gating", &false);
658 ctx.insert("user_is_superuser", &false);
659 ctx.insert(
660 "allowed_resources",
661 &std::collections::HashSet::<String>::new(),
662 );
663}
664
665pub(crate) async fn add_user_chrome(
680 ctx: &mut Context,
681 user: &rustango::tenancy::auth::User,
682 pool: &rustango::sql::Pool,
683) {
684 let user_timezone = user
685 .data
686 .get("timezone")
687 .and_then(serde_json::Value::as_str)
688 .unwrap_or("")
689 .to_owned();
690 ctx.insert("user_timezone", &user_timezone);
691 if let Some(pref) = user
695 .data
696 .get("admin_lang")
697 .and_then(serde_json::Value::as_str)
698 .filter(|s| super::i18n::is_ui_locale(s))
699 {
700 ctx.insert("user_lang_pref", pref);
701 }
702 ctx.insert("user_is_superuser", &user.is_superuser);
703 ctx.insert("user_username", &user.username);
704 let display_name = user
709 .data
710 .get("display_name")
711 .and_then(serde_json::Value::as_str)
712 .filter(|s| !s.is_empty())
713 .unwrap_or(&user.username)
714 .to_owned();
715 ctx.insert("user_display_name", &display_name);
716 let has_avatar = user
717 .data
718 .get("avatar_path")
719 .and_then(serde_json::Value::as_str)
720 .map(|s| !s.is_empty())
721 .unwrap_or(false);
722 if has_avatar {
723 let uid = user.id.get().copied().unwrap_or(0);
724 ctx.insert("user_avatar_url", &format!("/__cms-avatar/{uid}"));
725 }
726 let codenames = if user.is_superuser {
727 std::collections::HashSet::<String>::new()
730 } else {
731 let uid = user.id.get().copied().unwrap_or(0);
732 crate::permissions::user_codenames(pool, uid)
733 .await
734 .unwrap_or_default()
735 };
736 ctx.insert("allowed_resources", &codenames);
737 ctx.insert("sidebar_gating", &true);
738}
739
740pub async fn collections_list(
744 State(state): State<super::AdminState>,
745 tenant: Tenant,
746 headers: HeaderMap,
747 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
748) -> Result<Response, AdminError> {
749 let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
750 .order_by(&[("parent_id", false), ("sort_order", false), ("name", false)])
751 .fetch(tenant.pool())
752 .await?;
753 let by_id: std::collections::HashMap<i64, &crate::media::MediaCollection> = collections
756 .iter()
757 .filter_map(|c| c.id.get().copied().map(|id| (id, c)))
758 .collect();
759 fn depth(
760 c: &crate::media::MediaCollection,
761 by_id: &std::collections::HashMap<i64, &crate::media::MediaCollection>,
762 cache: &mut std::collections::HashMap<i64, i32>,
763 ) -> i32 {
764 let id = c.id.get().copied().unwrap_or_default();
765 if let Some(d) = cache.get(&id) {
766 return *d;
767 }
768 let d = match c.parent_id {
769 None => 0,
770 Some(pid) => match by_id.get(&pid) {
771 Some(parent) => depth(parent, by_id, cache) + 1,
772 None => 0,
773 },
774 };
775 cache.insert(id, d);
776 d
777 }
778 let media: Vec<Media> = Media::objects().fetch(tenant.pool()).await?;
780 let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
781 for m in &media {
782 if let Some(cid) = m.collection_id {
783 *counts.entry(cid).or_insert(0) += 1;
784 }
785 }
786 let mut depth_cache: std::collections::HashMap<i64, i32> = std::collections::HashMap::new();
787 let rows: Vec<serde_json::Value> = collections
788 .iter()
789 .map(|c| {
790 let id = c.id.get().copied().unwrap_or_default();
791 serde_json::json!({
792 "id": id,
793 "name": c.name,
794 "parent_id": c.parent_id,
795 "parent_name": c.parent_id.and_then(|pid| by_id.get(&pid)).map(|p| p.name.clone()),
798 "sort_order": c.sort_order,
799 "depth": depth(c, &by_id, &mut depth_cache),
800 "media_count": counts.get(&id).copied().unwrap_or(0),
801 "created_at": c.created_at.get().copied(),
802 })
803 })
804 .collect();
805
806 let mut ctx = Context::new();
807 add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
808 add_admin_theme(&mut ctx, tenant.pool()).await;
809 ctx.insert("collections", &rows);
810 render_with_csrf(
811 &state,
812 &headers,
813 "rcms_admin/collections_list.html",
814 &mut ctx,
815 )
816}
817
818#[derive(Debug, Deserialize)]
820pub struct CollectionForm {
821 pub name: String,
822 #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
823 pub parent_id: Option<i64>,
824 #[serde(default)]
825 pub sort_order: Option<i32>,
826}
827
828pub async fn collections_create(
830 State(_state): State<super::AdminState>,
831 tenant: Tenant,
832 headers: HeaderMap,
833 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
834 Form(form): Form<CollectionForm>,
835) -> Result<Response, AdminError> {
836 let name = form.name.trim().to_owned();
837 if name.is_empty() {
838 return Err(AdminError::Validation(
839 "Collection name is required.".to_owned(),
840 ));
841 }
842 let mut row = crate::media::MediaCollection {
843 id: rustango::sql::Auto::Unset,
844 name: name.clone(),
845 parent_id: form.parent_id,
846 sort_order: form.sort_order.unwrap_or(100),
847 created_at: rustango::sql::Auto::Unset,
848 };
849 row.insert_pool(tenant.pool()).await?;
850 redirect_named_with_message_args(
851 "rcms-admin:media:collections",
852 MsgLevel::Success,
853 "Collection “{name}” created.",
854 &[("name", name.as_str())],
855 &headers,
856 )
857}
858
859pub async fn collections_edit(
863 State(_state): State<super::AdminState>,
864 tenant: Tenant,
865 headers: HeaderMap,
866 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
867 Path(id): Path<i64>,
868 Form(form): Form<CollectionForm>,
869) -> Result<Response, AdminError> {
870 let mut row = crate::media::MediaCollection::objects()
871 .where_(crate::media::MediaCollection::id.eq(id))
872 .first(tenant.pool())
873 .await?
874 .ok_or(AdminError::NotFound(id))?;
875 let name = form.name.trim().to_owned();
876 if name.is_empty() {
877 return Err(AdminError::Validation(
878 "Collection name is required.".to_owned(),
879 ));
880 }
881 if form.parent_id == Some(id) {
884 return Err(AdminError::Validation(
885 "A collection cannot be its own parent.".to_owned(),
886 ));
887 }
888 row.name = name;
889 row.parent_id = form.parent_id;
890 if let Some(so) = form.sort_order {
891 row.sort_order = so;
892 }
893 row.save_pool(tenant.pool()).await?;
894 redirect_named_with_message(
895 "rcms-admin:media:collections",
896 MsgLevel::Success,
897 "Collection saved.",
898 &headers,
899 )
900}
901
902pub async fn collections_delete(
907 State(_state): State<super::AdminState>,
908 tenant: Tenant,
909 headers: HeaderMap,
910 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
911 Path(id): Path<i64>,
912) -> Result<Response, AdminError> {
913 let row = crate::media::MediaCollection::objects()
914 .where_(crate::media::MediaCollection::id.eq(id))
915 .first(tenant.pool())
916 .await?
917 .ok_or(AdminError::NotFound(id))?;
918 let parent = row.parent_id;
919 let name = row.name.clone();
920 for mut child in crate::media::MediaCollection::objects()
922 .where_(crate::media::MediaCollection::parent_id.eq(Some(id)))
923 .fetch(tenant.pool())
924 .await?
925 {
926 child.parent_id = parent;
927 child.save_pool(tenant.pool()).await?;
928 }
929 for mut m in Media::objects()
932 .where_(Media::collection_id.eq(Some(id)))
933 .fetch(tenant.pool())
934 .await?
935 {
936 m.collection_id = None;
937 m.save_pool(tenant.pool()).await?;
938 }
939 row.delete_pool(tenant.pool()).await?;
940 redirect_named_with_message_args(
941 "rcms-admin:media:collections",
942 MsgLevel::Success,
943 "Collection “{name}” deleted. Children re-parented; media moved to Uncategorized.",
944 &[("name", name.as_str())],
945 &headers,
946 )
947}
948
949use crate::category::model::{self as category_model, Category, CategoryError};
961
962fn category_tree_redirect(
964 slug: &str,
965 headers: &HeaderMap,
966 level: MsgLevel,
967 key: &str,
968 args: &[(&str, &str)],
969) -> Result<Response, AdminError> {
970 let body = super::i18n::tr(headers, key, args);
971 let url = format!("/cms-admin/taxonomies/{slug}");
972 Ok(rustango::messages::redirect_with_message(
973 messages_secret(),
974 headers,
975 level,
976 &body,
977 &url,
978 ))
979}
980
981fn opt_i64_from_form(form: &std::collections::HashMap<String, String>, key: &str) -> Option<i64> {
982 form.get(key)
983 .map(|s| s.trim())
984 .filter(|s| !s.is_empty())
985 .and_then(|s| s.parse::<i64>().ok())
986}
987
988fn category_base_widgets(
992 cat: Option<&Category>,
993 parent_opts: Vec<(String, String)>,
994) -> Vec<crate::widget::Widget> {
995 use crate::widget::{Widget, WidgetKind};
996 let mut opts = vec![(String::new(), "— none (top level) —".to_owned())];
997 opts.extend(parent_opts);
998 vec![
999 Widget::new(WidgetKind::Text, "name", "Name")
1000 .required()
1001 .with_value(cat.map(|c| c.name.clone()).unwrap_or_default()),
1002 Widget::new(WidgetKind::Text, "slug", "Slug")
1003 .with_help("URL identifier — auto-generated from the name if left blank.")
1004 .with_value(cat.map(|c| c.slug.clone()).unwrap_or_default()),
1005 Widget::new(WidgetKind::Textarea, "description", "Description")
1006 .with_value(cat.map(|c| c.description.clone()).unwrap_or_default()),
1007 Widget::new(
1008 WidgetKind::MediaPicker,
1009 "featured_image_id",
1010 "Featured image",
1011 )
1012 .with_value(
1013 cat.and_then(|c| c.featured_image_id)
1014 .map(|i| i.to_string())
1015 .unwrap_or_default(),
1016 ),
1017 Widget::new(WidgetKind::MediaPicker, "thumbnail_id", "Thumbnail").with_value(
1018 cat.and_then(|c| c.thumbnail_id)
1019 .map(|i| i.to_string())
1020 .unwrap_or_default(),
1021 ),
1022 Widget::new(WidgetKind::Select, "parent_id", "Parent")
1023 .with_options(opts)
1024 .with_help("Nest this category under another (siblings share a parent).")
1025 .with_value(
1026 cat.and_then(|c| c.parent_id)
1027 .map(|i| i.to_string())
1028 .unwrap_or_default(),
1029 ),
1030 ]
1031}
1032
1033async fn category_parent_options(
1037 pool: &rustango::sql::Pool,
1038 taxonomy_id: i64,
1039 exclude: Option<i64>,
1040) -> Result<Vec<(String, String)>, AdminError> {
1041 let cats = category_model::all_in_taxonomy(pool, taxonomy_id)
1042 .await
1043 .map_err(|e| AdminError::Validation(e.to_string()))?;
1044 Ok(cats
1045 .iter()
1046 .filter(|c| c.id.get().copied() != exclude)
1047 .map(|c| {
1048 let indent = "— ".repeat((c.depth.max(1) - 1) as usize);
1049 (
1050 c.id.get().copied().unwrap_or_default().to_string(),
1051 format!("{indent}{}", c.name),
1052 )
1053 })
1054 .collect())
1055}
1056
1057pub async fn taxonomies_index(
1059 State(state): State<super::AdminState>,
1060 tenant: Tenant,
1061 headers: HeaderMap,
1062 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1063) -> Result<Response, AdminError> {
1064 let taxes = crate::category::taxonomies(tenant.pool())
1065 .await
1066 .map_err(|e| AdminError::Validation(e.to_string()))?;
1067 let all_cats: Vec<Category> = Category::objects().fetch(tenant.pool()).await?;
1068 let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
1069 for c in &all_cats {
1070 *counts.entry(c.taxonomy_id).or_insert(0) += 1;
1071 }
1072 let rows: Vec<serde_json::Value> = taxes
1073 .iter()
1074 .map(|t| {
1075 serde_json::json!({
1076 "slug": t.slug,
1077 "verbose_name": t.verbose_name,
1078 "icon": if t.icon.is_empty() { "sell".to_owned() } else { t.icon.clone() },
1079 "description": t.description,
1080 "hierarchical": t.hierarchical,
1081 "count": counts.get(&t.id.get().copied().unwrap_or_default()).copied().unwrap_or(0),
1082 })
1083 })
1084 .collect();
1085 let mut ctx = Context::new();
1086 add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1087 add_admin_theme(&mut ctx, tenant.pool()).await;
1088 ctx.insert("taxonomies", &rows);
1089 render_with_csrf(
1090 &state,
1091 &headers,
1092 "rcms_admin/taxonomies_list.html",
1093 &mut ctx,
1094 )
1095}
1096
1097pub async fn category_tree(
1099 State(state): State<super::AdminState>,
1100 tenant: Tenant,
1101 headers: HeaderMap,
1102 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1103 Path(slug): Path<String>,
1104) -> Result<Response, AdminError> {
1105 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1106 .await
1107 .map_err(|e| AdminError::Validation(e.to_string()))?
1108 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1109 let cats =
1110 category_model::all_in_taxonomy(tenant.pool(), tax.id.get().copied().unwrap_or_default())
1111 .await
1112 .map_err(|e| AdminError::Validation(e.to_string()))?;
1113 let rows: Vec<serde_json::Value> = cats
1114 .iter()
1115 .map(|c| {
1116 serde_json::json!({
1117 "id": c.id.get().copied(),
1118 "name": c.name,
1119 "slug": c.slug,
1120 "description": c.description,
1121 "depth": c.depth,
1122 "thumbnail_id": c.thumbnail_id,
1123 "featured_image_id": c.featured_image_id,
1124 })
1125 })
1126 .collect();
1127 let mut ctx = Context::new();
1128 add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1129 add_admin_theme(&mut ctx, tenant.pool()).await;
1130 ctx.insert("taxonomy_slug", &tax.slug);
1131 ctx.insert("taxonomy_name", &tax.verbose_name);
1132 ctx.insert("categories", &rows);
1133 render_with_csrf(&state, &headers, "rcms_admin/category_tree.html", &mut ctx)
1134}
1135
1136pub async fn category_new_form(
1138 State(state): State<super::AdminState>,
1139 tenant: Tenant,
1140 headers: HeaderMap,
1141 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1142 Path(slug): Path<String>,
1143) -> Result<Response, AdminError> {
1144 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1145 .await
1146 .map_err(|e| AdminError::Validation(e.to_string()))?
1147 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1148 let tid = tax.id.get().copied().unwrap_or_default();
1149 let mut fields = if tax.hierarchical {
1150 category_base_widgets(
1151 None,
1152 category_parent_options(tenant.pool(), tid, None).await?,
1153 )
1154 } else {
1155 let mut w = category_base_widgets(None, Vec::new());
1157 w.pop();
1158 w
1159 };
1160 let _ = &mut fields;
1162 let mut ctx = Context::new();
1163 add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1164 add_admin_theme(&mut ctx, tenant.pool()).await;
1165 ctx.insert("taxonomy_slug", &tax.slug);
1166 ctx.insert("taxonomy_name", &tax.verbose_name);
1167 ctx.insert("mode", "new");
1168 ctx.insert("fields", &fields);
1169 render_with_csrf(&state, &headers, "rcms_admin/category_form.html", &mut ctx)
1170}
1171
1172pub async fn category_create(
1174 State(_state): State<super::AdminState>,
1175 tenant: Tenant,
1176 headers: HeaderMap,
1177 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1178 Path(slug): Path<String>,
1179 Form(form): Form<std::collections::HashMap<String, String>>,
1180) -> Result<Response, AdminError> {
1181 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1182 .await
1183 .map_err(|e| AdminError::Validation(e.to_string()))?
1184 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1185 let tid = tax.id.get().copied().unwrap_or_default();
1186 let new = category_model::NewCategory {
1187 name: form
1188 .get("name")
1189 .cloned()
1190 .unwrap_or_default()
1191 .trim()
1192 .to_owned(),
1193 slug: form.get("slug").cloned().unwrap_or_default(),
1194 description: form.get("description").cloned().unwrap_or_default(),
1195 featured_image_id: opt_i64_from_form(&form, "featured_image_id"),
1196 thumbnail_id: opt_i64_from_form(&form, "thumbnail_id"),
1197 parent_id: opt_i64_from_form(&form, "parent_id"),
1198 };
1199 if new.name.is_empty() {
1200 return category_tree_redirect(
1201 &slug,
1202 &headers,
1203 MsgLevel::Error,
1204 "Category name is required.",
1205 &[],
1206 );
1207 }
1208 match category_model::create(tenant.pool(), tid, new).await {
1209 Ok(cat) => {
1210 let id = cat.id.get().copied().unwrap_or_default();
1211 let body = super::i18n::tr(
1212 &headers,
1213 "Category “{name}” created.",
1214 &[("name", cat.name.as_str())],
1215 );
1216 let url = format!("/cms-admin/taxonomies/{slug}/categories/{id}/edit");
1217 Ok(rustango::messages::redirect_with_message(
1218 messages_secret(),
1219 &headers,
1220 MsgLevel::Success,
1221 &body,
1222 &url,
1223 ))
1224 }
1225 Err(e) => category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]),
1226 }
1227}
1228
1229pub async fn category_edit_form(
1231 State(state): State<super::AdminState>,
1232 tenant: Tenant,
1233 headers: HeaderMap,
1234 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1235 Path((slug, id)): Path<(String, i64)>,
1236 Query(q): Query<EditQuery>,
1237) -> Result<Response, AdminError> {
1238 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1239 .await
1240 .map_err(|e| AdminError::Validation(e.to_string()))?
1241 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1242 let tid = tax.id.get().copied().unwrap_or_default();
1243 let cat = Category::objects()
1244 .where_(Category::id.eq(id))
1245 .where_(Category::taxonomy_id.eq(tid))
1246 .first(tenant.pool())
1247 .await?
1248 .ok_or(AdminError::NotFound(id))?;
1249 let mut fields = if tax.hierarchical {
1250 category_base_widgets(
1251 Some(&cat),
1252 category_parent_options(tenant.pool(), tid, Some(id)).await?,
1253 )
1254 } else {
1255 let mut w = category_base_widgets(Some(&cat), Vec::new());
1256 w.pop();
1257 w
1258 };
1259 if let Some(handler) = crate::category::find_handler(&slug) {
1261 if let Ok(ext) = handler.ext_widgets(tenant.pool(), id).await {
1262 fields.extend(ext);
1263 }
1264 }
1265 let mut ctx = Context::new();
1266 add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1267 add_admin_theme(&mut ctx, tenant.pool()).await;
1268 ctx.insert("taxonomy_slug", &tax.slug);
1269 ctx.insert("taxonomy_name", &tax.verbose_name);
1270 ctx.insert("mode", "edit");
1271 ctx.insert("category_id", &id);
1272 ctx.insert("fields", &fields);
1273 let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
1276 .where_(crate::locale::Locale::active.eq(true))
1277 .order_by(&[("sort_order", false), ("code", false)])
1278 .fetch(tenant.pool())
1279 .await?;
1280 let editing_locale = q
1281 .locale
1282 .as_deref()
1283 .filter(|c| !c.is_empty())
1284 .and_then(|code| locales.iter().find(|l| l.code == code && !l.is_default).cloned());
1285 if let Some(loc) = &editing_locale {
1286 let lid = loc.id.get().copied().unwrap_or_default();
1287 let mut existing = crate::category_translation::fetch_for_categories(tenant.pool(), &[id], lid)
1288 .await
1289 .unwrap_or_default();
1290 ctx.insert("translation_mode", &true);
1291 ctx.insert("editing_locale", loc);
1292 ctx.insert("category_name", &cat.name);
1293 ctx.insert("tr_name", &existing.remove(&id).and_then(|mut f| f.remove("name")).unwrap_or_default());
1294 }
1295 ctx.insert("locales", &locales);
1296 render_with_csrf(&state, &headers, "rcms_admin/category_form.html", &mut ctx)
1297}
1298
1299pub async fn category_translate_submit(
1303 State(_state): State<super::AdminState>,
1304 tenant: Tenant,
1305 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1306 Path((slug, id)): Path<(String, i64)>,
1307 Query(q): Query<EditQuery>,
1308 Form(form): Form<std::collections::HashMap<String, String>>,
1309) -> Result<Response, AdminError> {
1310 use crate::category_translation::{CategoryTranslation, TRANSLATABLE_FIELDS};
1311 let code = q
1312 .locale
1313 .as_deref()
1314 .filter(|c| !c.is_empty())
1315 .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
1316 let locale = crate::locale::Locale::objects()
1317 .where_(crate::locale::Locale::code.eq(code.to_owned()))
1318 .where_(crate::locale::Locale::active.eq(true))
1319 .where_(crate::locale::Locale::is_default.eq(false))
1320 .first(tenant.pool())
1321 .await?
1322 .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
1323 let locale_id = locale.id.get().copied().unwrap_or_default();
1324 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1325 .await
1326 .map_err(|e| AdminError::Validation(e.to_string()))?
1327 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1328 Category::objects()
1329 .where_(Category::id.eq(id))
1330 .where_(Category::taxonomy_id.eq(tax.id.get().copied().unwrap_or_default()))
1331 .first(tenant.pool())
1332 .await?
1333 .ok_or(AdminError::NotFound(id))?;
1334 rustango::atomic!(tenant.pool(), |tx| {
1335 let mut guard = tx.lock().await?;
1336 let tx = &mut *guard;
1337 for field in TRANSLATABLE_FIELDS {
1338 let Some(value) = form.get(&format!("tr__{field}")) else {
1339 continue;
1340 };
1341 let value = value.trim().to_owned();
1342 let existing: Vec<CategoryTranslation> = CategoryTranslation::objects()
1343 .where_(CategoryTranslation::category_id.eq(id))
1344 .where_(CategoryTranslation::locale_id.eq(locale_id))
1345 .where_(CategoryTranslation::field_path.eq(field.to_owned()))
1346 .fetch_tx(tx)
1347 .await?;
1348 if value.is_empty() {
1349 for row in existing {
1350 row.delete_tx(tx).await?;
1351 }
1352 } else if let Some(mut row) = existing.into_iter().next() {
1353 row.value = value;
1354 row.save_tx(tx).await?;
1355 } else {
1356 let mut row = CategoryTranslation {
1357 id: rustango::sql::Auto::Unset,
1358 category_id: id,
1359 locale_id,
1360 field_path: field.to_owned(),
1361 value,
1362 updated_at: rustango::sql::Auto::Unset,
1363 };
1364 row.save_tx(tx).await?;
1365 }
1366 }
1367 Ok::<_, rustango::sql::ExecError>(())
1368 })
1369 .await?;
1370 Ok(Redirect::to(&format!("/cms-admin/taxonomies/{slug}/categories/{id}/edit?locale={code}")).into_response())
1371}
1372
1373pub async fn category_update(
1375 State(_state): State<super::AdminState>,
1376 tenant: Tenant,
1377 headers: HeaderMap,
1378 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1379 Path((slug, id)): Path<(String, i64)>,
1380 Form(form): Form<std::collections::HashMap<String, String>>,
1381) -> Result<Response, AdminError> {
1382 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1383 .await
1384 .map_err(|e| AdminError::Validation(e.to_string()))?
1385 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1386 let tid = tax.id.get().copied().unwrap_or_default();
1387 let new = category_model::NewCategory {
1388 name: form
1389 .get("name")
1390 .cloned()
1391 .unwrap_or_default()
1392 .trim()
1393 .to_owned(),
1394 slug: form.get("slug").cloned().unwrap_or_default(),
1395 description: form.get("description").cloned().unwrap_or_default(),
1396 featured_image_id: opt_i64_from_form(&form, "featured_image_id"),
1397 thumbnail_id: opt_i64_from_form(&form, "thumbnail_id"),
1398 parent_id: opt_i64_from_form(&form, "parent_id"),
1399 };
1400 if new.name.is_empty() {
1401 return category_tree_redirect(
1402 &slug,
1403 &headers,
1404 MsgLevel::Error,
1405 "Category name is required.",
1406 &[],
1407 );
1408 }
1409 let new_parent = new.parent_id;
1410 if let Err(e) = category_model::update(tenant.pool(), tid, id, new).await {
1411 return category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]);
1412 }
1413 if let Err(e) = category_model::move_to(tenant.pool(), tid, id, new_parent).await {
1416 return category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]);
1417 }
1418 if let Some(handler) = crate::category::find_handler(&slug) {
1420 if let Err(e) = handler.save_ext(tenant.pool(), id, &form).await {
1421 tracing::warn!(category_id = id, error = %e, "category extension save failed");
1422 }
1423 }
1424 category_tree_redirect(&slug, &headers, MsgLevel::Success, "Category saved.", &[])
1425}
1426
1427pub async fn category_delete(
1429 State(_state): State<super::AdminState>,
1430 tenant: Tenant,
1431 headers: HeaderMap,
1432 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1433 Path((slug, id)): Path<(String, i64)>,
1434) -> Result<Response, AdminError> {
1435 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1436 .await
1437 .map_err(|e| AdminError::Validation(e.to_string()))?
1438 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1439 let tid = tax.id.get().copied().unwrap_or_default();
1440 match category_model::delete(tenant.pool(), tid, id, false).await {
1441 Ok(_) => {
1442 category_tree_redirect(&slug, &headers, MsgLevel::Success, "Category deleted.", &[])
1443 }
1444 Err(CategoryError::HasChildren(_, n)) => {
1445 let n = n.to_string();
1446 category_tree_redirect(
1447 &slug,
1448 &headers,
1449 MsgLevel::Error,
1450 "Can't delete a category with {count} child categor(ies) — delete or move them first.",
1451 &[("count", n.as_str())],
1452 )
1453 }
1454 Err(e) => category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]),
1455 }
1456}
1457
1458async fn ensure_builder_access(
1470 tenant: &Tenant,
1471 user: Option<&rustango::tenancy::auth::User>,
1472) -> Option<Response> {
1473 super::codename_gate(tenant, user, "cms_page_type.build").await
1474}
1475
1476pub async fn page_type_build_form(
1478 State(state): State<super::AdminState>,
1479 tenant: Tenant,
1480 headers: HeaderMap,
1481 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1482 Path(id): Path<i64>,
1483) -> Result<Response, AdminError> {
1484 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1485 return Ok(r);
1486 }
1487 let pt = crate::page_type_model::PageType::objects()
1488 .where_(crate::page_type_model::PageType::id.eq(id))
1489 .first(tenant.pool())
1490 .await?
1491 .ok_or(AdminError::NotFound(id))?;
1492
1493 let draft = crate::page_builder::model::draft_for(tenant.pool(), id).await?;
1494 let published = crate::page_builder::model::published_for(tenant.pool(), id).await?;
1495 let doc_value = draft
1498 .as_ref()
1499 .map(|d| d.document.clone())
1500 .or_else(|| published.as_ref().map(|p| p.document.clone()))
1501 .unwrap_or_else(|| serde_json::json!({ "nodes": [] }));
1502 let schema_json =
1503 serde_json::to_string(&doc_value).unwrap_or_else(|_| "{\"nodes\":[]}".to_owned());
1504
1505 let components: Vec<serde_json::Value> =
1506 crate::page_builder::model::all_components(tenant.pool())
1507 .await?
1508 .iter()
1509 .map(|c| serde_json::json!({ "slug": c.slug, "label": c.label }))
1510 .collect();
1511 let components_json = serde_json::to_string(&components).unwrap_or_else(|_| "[]".to_owned());
1512 let versions: Vec<serde_json::Value> =
1513 crate::page_builder::model::list_versions(tenant.pool(), id)
1514 .await?
1515 .iter()
1516 .map(|v| {
1517 serde_json::json!({
1518 "version": v.version,
1519 "status": v.status,
1520 "updated_at": v.updated_at.get().copied(),
1521 })
1522 })
1523 .collect();
1524
1525 let is_ui_type = pt.app_label == "cms_ui";
1529 let page_count = if is_ui_type {
1530 Page::objects()
1531 .where_(Page::page_type_id.eq(id))
1532 .fetch(tenant.pool())
1533 .await
1534 .map(|v| v.len())
1535 .unwrap_or(0)
1536 } else {
1537 0
1538 };
1539
1540 let mut ctx = Context::new();
1541 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
1542 add_admin_theme(&mut ctx, tenant.pool()).await;
1543 ctx.insert("page_type_id", &id);
1544 ctx.insert("title", &pt.verbose_name);
1545 ctx.insert("schema_json", &schema_json);
1546 ctx.insert("build_url", &format!("/cms-admin/page-types/{id}/build"));
1547 ctx.insert(
1548 "publish_url",
1549 &format!("/cms-admin/page-types/{id}/build/publish"),
1550 );
1551 ctx.insert("delete_url", &format!("/cms-admin/page-types/{id}/delete"));
1552 ctx.insert("list_url", "/cms-admin/page-types");
1553 ctx.insert("components_json", &components_json);
1554 ctx.insert("versions", &versions);
1555 ctx.insert("has_unpublished", &draft.is_some());
1556 let translate_locales: Vec<crate::locale::Locale> = if published.is_some() {
1558 crate::locale::Locale::objects()
1559 .where_(crate::locale::Locale::active.eq(true))
1560 .where_(crate::locale::Locale::is_default.eq(false))
1561 .order_by(&[("sort_order", false), ("code", false)])
1562 .fetch(tenant.pool())
1563 .await?
1564 } else {
1565 Vec::new()
1566 };
1567 ctx.insert("translate_locales", &translate_locales);
1568 ctx.insert("translate_url", &format!("/cms-admin/page-types/{id}/translate"));
1569 ctx.insert("is_ui_type", &is_ui_type);
1570 ctx.insert("page_count", &page_count);
1571 ctx.insert("deletable", &(is_ui_type && page_count == 0));
1572 render_with_csrf(
1573 &state,
1574 &headers,
1575 "rcms_admin/page_type_builder.html",
1576 &mut ctx,
1577 )
1578}
1579
1580pub async fn page_type_translate_form(
1584 State(state): State<super::AdminState>,
1585 tenant: Tenant,
1586 headers: HeaderMap,
1587 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1588 Path(id): Path<i64>,
1589 Query(q): Query<EditQuery>,
1590) -> Result<Response, AdminError> {
1591 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1592 return Ok(r);
1593 }
1594 let pt = crate::page_type_model::PageType::objects()
1595 .where_(crate::page_type_model::PageType::id.eq(id))
1596 .first(tenant.pool())
1597 .await?
1598 .ok_or(AdminError::NotFound(id))?;
1599 let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
1600 let published = crate::page_builder::model::published_for(tenant.pool(), id).await?;
1601 let fields = published
1602 .as_ref()
1603 .map(|p| crate::page_builder::choice_i18n::choice_fields(&p.document, &locale.code))
1604 .unwrap_or_default();
1605 let mut ctx = Context::new();
1606 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
1607 add_admin_theme(&mut ctx, tenant.pool()).await;
1608 ctx.insert("title", &pt.verbose_name);
1609 ctx.insert("editing_locale", &locale);
1610 ctx.insert("choice_fields", &fields);
1611 ctx.insert("build_url", &format!("/cms-admin/page-types/{id}/build"));
1612 ctx.insert("translate_url", &format!("/cms-admin/page-types/{id}/translate"));
1613 render_with_csrf(&state, &headers, "rcms_admin/page_type_translate.html", &mut ctx)
1614}
1615
1616pub async fn page_type_translate_submit(
1620 State(_state): State<super::AdminState>,
1621 tenant: Tenant,
1622 headers: HeaderMap,
1623 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1624 Path(id): Path<i64>,
1625 Query(q): Query<EditQuery>,
1626 Form(form): Form<Vec<(String, String)>>,
1627) -> Result<Response, AdminError> {
1628 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1629 return Ok(r);
1630 }
1631 let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
1632 let labels: std::collections::HashMap<(String, String), String> = form
1633 .into_iter()
1634 .filter_map(|(k, v)| {
1635 let rest = k.strip_prefix("tr__")?;
1636 let (path, value) = rest.split_once("__")?;
1637 Some(((path.to_owned(), value.to_owned()), v))
1638 })
1639 .collect();
1640 for row in [
1641 crate::page_builder::model::published_for(tenant.pool(), id).await?,
1642 crate::page_builder::model::draft_for(tenant.pool(), id).await?,
1643 ]
1644 .into_iter()
1645 .flatten()
1646 {
1647 let mut row = row;
1648 if crate::page_builder::choice_i18n::set_choice_labels(&mut row.document, &locale.code, &labels) > 0 {
1649 row.save_pool(tenant.pool()).await?;
1650 }
1651 }
1652 let back = format!("/cms-admin/page-types/{id}/translate?locale={}", locale.code);
1653 Ok(rustango::messages::redirect_with_message(
1654 messages_secret(),
1655 &headers,
1656 MsgLevel::Success,
1657 &super::i18n::tr(&headers, "Translations saved.", &[]),
1658 &back,
1659 ))
1660}
1661
1662async fn translate_locale(tenant: &Tenant, code: Option<&str>) -> Result<crate::locale::Locale, AdminError> {
1665 let code = code
1666 .filter(|c| !c.is_empty())
1667 .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
1668 crate::locale::Locale::objects()
1669 .where_(crate::locale::Locale::code.eq(code.to_owned()))
1670 .where_(crate::locale::Locale::active.eq(true))
1671 .where_(crate::locale::Locale::is_default.eq(false))
1672 .first(tenant.pool())
1673 .await?
1674 .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))
1675}
1676
1677async fn parse_builder_submit(
1681 tenant: &Tenant,
1682 user: Option<&rustango::tenancy::auth::User>,
1683 id: i64,
1684 schema_str: &str,
1685) -> Result<Result<(crate::page_builder::Document, Vec<String>), Response>, AdminError> {
1686 if let Some(r) = ensure_builder_access(tenant, user).await {
1687 return Ok(Err(r));
1688 }
1689 let exists = crate::page_type_model::PageType::objects()
1691 .where_(crate::page_type_model::PageType::id.eq(id))
1692 .first(tenant.pool())
1693 .await?
1694 .is_some();
1695 if !exists {
1696 return Err(AdminError::NotFound(id));
1697 }
1698 let value: serde_json::Value = serde_json::from_str(schema_str)
1699 .map_err(|e| AdminError::Validation(format!("invalid schema JSON: {e}")))?;
1700 let doc = crate::page_builder::parse_schema(&value)
1701 .map_err(|e| AdminError::Validation(format!("invalid schema document: {e}")))?;
1702 let components = crate::page_builder::model::component_map(tenant.pool()).await?;
1703 let problems = crate::page_builder::validate_schema(&doc, &components);
1704 Ok(Ok((doc, problems)))
1705}
1706
1707pub async fn page_type_build_submit(
1710 State(_state): State<super::AdminState>,
1711 tenant: Tenant,
1712 headers: HeaderMap,
1713 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1714 Path(id): Path<i64>,
1715 Form(form): Form<FormBuildSubmit>,
1716) -> Result<Response, AdminError> {
1717 let (doc, problems) =
1718 match parse_builder_submit(&tenant, session_user.as_ref(), id, &form.schema).await? {
1719 Ok(v) => v,
1720 Err(resp) => return Ok(resp),
1721 };
1722 let document =
1723 serde_json::to_value(&doc).unwrap_or_else(|_| serde_json::json!({ "nodes": [] }));
1724 let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
1725 crate::page_builder::model::save_draft(tenant.pool(), id, document, created_by).await?;
1726 let (level, msg) = if problems.is_empty() {
1727 (MsgLevel::Success, "Draft saved.".to_owned())
1728 } else {
1729 (
1730 MsgLevel::Warning,
1731 format!("Draft saved with warnings: {}", problems.join(" ")),
1732 )
1733 };
1734 redirect_named_with_params_and_message(
1735 "rcms-admin:page-types:build",
1736 &[("id", id.to_string())],
1737 level,
1738 &msg,
1739 &headers,
1740 )
1741}
1742
1743pub async fn page_type_publish_submit(
1746 State(_state): State<super::AdminState>,
1747 tenant: Tenant,
1748 headers: HeaderMap,
1749 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1750 Path(id): Path<i64>,
1751 Form(form): Form<FormBuildSubmit>,
1752) -> Result<Response, AdminError> {
1753 let (doc, problems) =
1754 match parse_builder_submit(&tenant, session_user.as_ref(), id, &form.schema).await? {
1755 Ok(v) => v,
1756 Err(resp) => return Ok(resp),
1757 };
1758 let document =
1761 serde_json::to_value(&doc).unwrap_or_else(|_| serde_json::json!({ "nodes": [] }));
1762 let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
1763 crate::page_builder::model::save_draft(tenant.pool(), id, document, created_by).await?;
1764 if !problems.is_empty() {
1765 return redirect_named_with_params_and_message(
1766 "rcms-admin:page-types:build",
1767 &[("id", id.to_string())],
1768 MsgLevel::Error,
1769 &format!("Can't publish — fix these first: {}", problems.join(" ")),
1770 &headers,
1771 );
1772 }
1773 crate::page_builder::model::publish(tenant.pool(), id).await?;
1774 redirect_named_with_params_and_message(
1775 "rcms-admin:page-types:build",
1776 &[("id", id.to_string())],
1777 MsgLevel::Success,
1778 "Schema published — the page editor now uses this structure.",
1779 &headers,
1780 )
1781}
1782
1783pub(crate) async fn save_page_builder_values(
1792 pool: &rustango::sql::Pool,
1793 page_type_id: i64,
1794 page_id: i64,
1795 form_map: &std::collections::HashMap<String, String>,
1796) -> Result<(), rustango::sql::ExecError> {
1797 let Some(row) = crate::page_builder::model::published_for(pool, page_type_id).await? else {
1798 return Ok(());
1799 };
1800 let Ok(doc) = crate::page_builder::parse_schema(&row.document) else {
1801 return Ok(());
1802 };
1803 let components = crate::page_builder::model::component_map(pool).await?;
1804 let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
1805 crate::page_builder::values::save_from_form(pool, page_id, &compiled, form_map).await
1806}
1807
1808async fn save_type_content(
1812 pool: &rustango::sql::Pool,
1813 page_type: Option<&PageType>,
1814 page_type_id: i64,
1815 page_id: i64,
1816 form_map: &std::collections::HashMap<String, String>,
1817) -> Result<(), AdminError> {
1818 if let Some(handler) = page_type.and_then(|pt| find_handler(&pt.type_name)) {
1819 let ext_form = sanitized_extension_form(handler.as_ref(), pool, page_id, form_map).await;
1820 handler.save_extension(pool, page_id, &ext_form).await?;
1821 for spec in handler.inline_panels() {
1826 let rows = extract_inline_panel_rows(form_map, &spec);
1827 handler.save_inline_panel(pool, page_id, &spec.name, &rows).await?;
1828 }
1829 }
1830 save_page_builder_values(pool, page_type_id, page_id, form_map).await?;
1832 Ok(())
1833}
1834
1835async fn reindex_from_form(
1841 pool: &rustango::sql::Pool,
1842 org_slug: &str,
1843 page_id: i64,
1844 form_map: &std::collections::HashMap<String, String>,
1845) {
1846 let mut refs: Vec<crate::reference_index::Reference> = Vec::new();
1847 for (key, value) in form_map {
1848 let mut found = crate::reference_index::scan(value, key);
1852 refs.append(&mut found);
1853 }
1854 crate::task_queue::reindex_page(pool, org_slug, page_id, refs).await;
1855}
1856
1857#[allow(clippy::too_many_arguments)]
1863async fn insert_type_fields(
1864 ctx: &mut Context,
1865 tera: &tera::Tera,
1866 pool: &rustango::sql::Pool,
1867 handler: Option<&dyn crate::page_type::PageTypeHandler>,
1868 mut widgets: Vec<crate::widget::Widget>,
1869 page_id: i64,
1870 page_type_id: i64,
1871 held: Option<&std::collections::HashMap<String, String>>,
1872) {
1873 if let Some(form) = held {
1874 overlay_pending_widgets(&mut widgets, form);
1875 }
1876 for w in &mut widgets {
1882 if matches!(w.kind, crate::widget::WidgetKind::Custom) {
1883 if let Some(reg) = crate::widget::registry::find_custom_widget(&w.custom_name) {
1884 let mut sub = Context::new();
1885 sub.insert("w", &w);
1886 w.custom_html = tera.render(reg.template, &sub).unwrap_or_else(|e| {
1887 tracing::warn!(
1888 target: "rustango_cms::widget",
1889 custom_name = %w.custom_name,
1890 template = reg.template,
1891 error = %e,
1892 "custom widget template render failed",
1893 );
1894 String::new()
1895 });
1896 }
1897 }
1898 }
1899
1900 for w in &mut widgets {
1907 if matches!(w.kind, crate::widget::WidgetKind::Stream) {
1908 w.custom_html = crate::block::admin::render_stream_editor(w, tera);
1909 }
1910 }
1911 ctx.insert("extension_fields", &widgets);
1912
1913 if let Some((body_html, rules_json, upgraded)) =
1918 page_builder_editor_ctx(pool, tera, page_id, page_type_id, held).await
1919 {
1920 ctx.insert("builder_body_html", &body_html);
1921 ctx.insert("builder_rules_json", &rules_json);
1922 ctx.insert("builder_upgraded", &upgraded);
1923 }
1924
1925 let mut inline_panels: Vec<serde_json::Value> = Vec::new();
1929 if let Some(h) = handler {
1930 for spec in h.inline_panels() {
1931 let rows = h
1932 .load_inline_panel(pool, page_id, &spec.name)
1933 .await
1934 .unwrap_or_default();
1935 inline_panels.push(serde_json::json!({
1936 "spec": spec,
1937 "rows": rows,
1938 }));
1939 }
1940 }
1941 ctx.insert("inline_panels", &inline_panels);
1942}
1943
1944async fn page_builder_editor_ctx(
1948 pool: &rustango::sql::Pool,
1949 tera: &tera::Tera,
1950 page_id: i64,
1951 page_type_id: i64,
1952 held: Option<&std::collections::HashMap<String, String>>,
1953) -> Option<(String, String, bool)> {
1954 let row = crate::page_builder::model::published_for(pool, page_type_id)
1955 .await
1956 .ok()??;
1957 let doc = crate::page_builder::parse_schema(&row.document).ok()?;
1958 let components = crate::page_builder::model::component_map(pool)
1959 .await
1960 .unwrap_or_default();
1961 let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
1962 let (mut values, report) =
1963 crate::page_builder::values::load_upgraded(pool, page_id, &compiled)
1964 .await
1965 .unwrap_or_else(|_| (serde_json::json!({}), Default::default()));
1966 if let Some(form) = held {
1968 values = serde_json::Value::Object(crate::page_builder::values::build_values(&compiled, form));
1969 }
1970 let html =
1971 crate::page_builder::values::render_body(&compiled, &values, tera);
1972 let rules: Vec<serde_json::Value> = compiled
1974 .rules
1975 .iter()
1976 .map(|r| serde_json::json!({ "field": r.field, "rule": r.rule }))
1977 .collect();
1978 let rules_json = serde_json::to_string(&rules).unwrap_or_else(|_| "[]".to_owned());
1979 Some((html, rules_json, report.upgraded))
1980}
1981
1982pub async fn components_index(
1986 State(state): State<super::AdminState>,
1987 tenant: Tenant,
1988 headers: HeaderMap,
1989 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1990) -> Result<Response, AdminError> {
1991 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1992 return Ok(r);
1993 }
1994 let comps = crate::page_builder::model::all_components(tenant.pool()).await?;
1995 let mut rows = Vec::with_capacity(comps.len());
1996 for c in &comps {
1997 let refs = crate::page_builder::model::component_references(tenant.pool(), &c.slug)
1998 .await
1999 .unwrap_or_default();
2000 rows.push(serde_json::json!({
2001 "id": c.id.get().copied(),
2002 "slug": c.slug,
2003 "label": c.label,
2004 "icon": if c.icon.is_empty() { "extension".to_owned() } else { c.icon.clone() },
2005 "description": c.description,
2006 "version": c.version,
2007 "ref_count": refs.len(),
2008 }));
2009 }
2010 let mut ctx = Context::new();
2011 add_chrome(&mut ctx, &tenant, "components", session_user.as_ref()).await;
2012 add_admin_theme(&mut ctx, tenant.pool()).await;
2013 ctx.insert("components", &rows);
2014 ctx.insert("new_url", "/cms-admin/components/new");
2015 render_with_csrf(
2016 &state,
2017 &headers,
2018 "rcms_admin/components_list.html",
2019 &mut ctx,
2020 )
2021}
2022
2023#[allow(clippy::too_many_arguments)]
2025async fn render_component_builder(
2026 state: &super::AdminState,
2027 headers: &HeaderMap,
2028 tenant: &Tenant,
2029 user: Option<&rustango::tenancy::auth::User>,
2030 id: Option<i64>,
2031 slug: &str,
2032 label: &str,
2033 icon: &str,
2034 description: &str,
2035 schema_json: &str,
2036 error: Option<&str>,
2037) -> Result<Response, AdminError> {
2038 let mut ctx = Context::new();
2039 add_chrome(&mut ctx, tenant, "components", user).await;
2040 add_admin_theme(&mut ctx, tenant.pool()).await;
2041 ctx.insert("component_id", &id);
2042 ctx.insert("slug", slug);
2043 ctx.insert("label", label);
2044 ctx.insert("icon", icon);
2045 ctx.insert("description", description);
2046 ctx.insert("schema_json", schema_json);
2047 ctx.insert("is_edit", &id.is_some());
2048 let save_url = match id {
2049 Some(cid) => format!("/cms-admin/components/{cid}/edit"),
2050 None => "/cms-admin/components/new".to_owned(),
2051 };
2052 ctx.insert("save_url", &save_url);
2053 ctx.insert("list_url", "/cms-admin/components");
2054 if let Some(e) = error {
2055 ctx.insert("error", e);
2056 }
2057 render_with_csrf(
2058 state,
2059 headers,
2060 "rcms_admin/component_builder.html",
2061 &mut ctx,
2062 )
2063}
2064
2065pub async fn component_new_form(
2067 State(state): State<super::AdminState>,
2068 tenant: Tenant,
2069 headers: HeaderMap,
2070 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2071) -> Result<Response, AdminError> {
2072 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2073 return Ok(r);
2074 }
2075 render_component_builder(
2076 &state,
2077 &headers,
2078 &tenant,
2079 session_user.as_ref(),
2080 None,
2081 "",
2082 "",
2083 "",
2084 "",
2085 "{\"nodes\":[]}",
2086 None,
2087 )
2088 .await
2089}
2090
2091pub async fn component_edit_form(
2093 State(state): State<super::AdminState>,
2094 tenant: Tenant,
2095 headers: HeaderMap,
2096 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2097 Path(id): Path<i64>,
2098) -> Result<Response, AdminError> {
2099 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2100 return Ok(r);
2101 }
2102 let c = crate::page_builder::model::component_by_id(tenant.pool(), id)
2103 .await?
2104 .ok_or(AdminError::NotFound(id))?;
2105 let doc: crate::page_builder::schema::ComponentDoc =
2107 serde_json::from_value(c.document.clone()).unwrap_or_default();
2108 let schema_json =
2109 serde_json::to_string(&serde_json::json!({ "nodes": doc.children })).unwrap_or_default();
2110 render_component_builder(
2111 &state,
2112 &headers,
2113 &tenant,
2114 session_user.as_ref(),
2115 Some(id),
2116 &c.slug,
2117 &c.label,
2118 &c.icon,
2119 &c.description,
2120 &schema_json,
2121 None,
2122 )
2123 .await
2124}
2125
2126fn parse_component_doc(
2129 schema_str: &str,
2130) -> Result<crate::page_builder::schema::ComponentDoc, String> {
2131 let value: serde_json::Value =
2132 serde_json::from_str(schema_str).map_err(|e| format!("invalid schema JSON: {e}"))?;
2133 let doc = crate::page_builder::parse_schema(&value)
2134 .map_err(|e| format!("invalid schema document: {e}"))?;
2135 let cdoc = crate::page_builder::schema::ComponentDoc {
2136 label_format: None,
2137 children: doc.nodes,
2138 };
2139 let problems = crate::page_builder::schema::validate_component(&cdoc);
2140 if problems.is_empty() {
2141 Ok(cdoc)
2142 } else {
2143 Err(problems.join(" "))
2144 }
2145}
2146
2147pub async fn component_create(
2149 State(state): State<super::AdminState>,
2150 tenant: Tenant,
2151 headers: HeaderMap,
2152 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2153 Form(form): Form<FormComponentSubmit>,
2154) -> Result<Response, AdminError> {
2155 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2156 return Ok(r);
2157 }
2158 let slug = crate::forms::schema::slugify_key(&form.slug);
2159 let checked: Result<crate::page_builder::schema::ComponentDoc, String> =
2161 if !crate::forms::schema::is_valid_key(&slug) {
2162 Err(
2163 "Slug is invalid — use letters/digits/underscores, starting with a letter."
2164 .to_owned(),
2165 )
2166 } else if form.label.trim().is_empty() {
2167 Err("Label is required.".to_owned())
2168 } else {
2169 parse_component_doc(&form.schema)
2170 };
2171 let msg: Option<String> = match checked {
2173 Ok(cdoc) => {
2174 let document = serde_json::to_value(&cdoc).unwrap_or_else(|_| serde_json::json!({}));
2175 match crate::page_builder::model::create_component(
2176 tenant.pool(),
2177 &slug,
2178 form.label.trim(),
2179 form.icon.trim(),
2180 form.description.trim(),
2181 document,
2182 )
2183 .await
2184 {
2185 Ok(_) => {
2186 return redirect_named_with_message(
2187 "rcms-admin:components:index",
2188 MsgLevel::Success,
2189 "Component created.",
2190 &headers,
2191 )
2192 }
2193 Err(_) => Some(format!(
2194 "Could not create — a component with slug `{slug}` may already exist."
2195 )),
2196 }
2197 }
2198 Err(e) => Some(e),
2199 };
2200 render_component_builder(
2201 &state,
2202 &headers,
2203 &tenant,
2204 session_user.as_ref(),
2205 None,
2206 &form.slug,
2207 &form.label,
2208 &form.icon,
2209 &form.description,
2210 &form.schema,
2211 msg.as_deref(),
2212 )
2213 .await
2214}
2215
2216pub async fn component_update(
2218 State(state): State<super::AdminState>,
2219 tenant: Tenant,
2220 headers: HeaderMap,
2221 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2222 Path(id): Path<i64>,
2223 Form(form): Form<FormComponentSubmit>,
2224) -> Result<Response, AdminError> {
2225 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2226 return Ok(r);
2227 }
2228 let existing = crate::page_builder::model::component_by_id(tenant.pool(), id)
2229 .await?
2230 .ok_or(AdminError::NotFound(id))?;
2231 if form.label.trim().is_empty() {
2232 return render_component_builder(
2233 &state,
2234 &headers,
2235 &tenant,
2236 session_user.as_ref(),
2237 Some(id),
2238 &existing.slug,
2239 &form.label,
2240 &form.icon,
2241 &form.description,
2242 &form.schema,
2243 Some("Label is required."),
2244 )
2245 .await;
2246 }
2247 let cdoc = match parse_component_doc(&form.schema) {
2248 Ok(d) => d,
2249 Err(e) => {
2250 return render_component_builder(
2251 &state,
2252 &headers,
2253 &tenant,
2254 session_user.as_ref(),
2255 Some(id),
2256 &existing.slug,
2257 &form.label,
2258 &form.icon,
2259 &form.description,
2260 &form.schema,
2261 Some(&e),
2262 )
2263 .await
2264 }
2265 };
2266 let document = serde_json::to_value(&cdoc).unwrap_or_else(|_| serde_json::json!({}));
2267 crate::page_builder::model::update_component(
2268 tenant.pool(),
2269 id,
2270 form.label.trim(),
2271 form.icon.trim(),
2272 form.description.trim(),
2273 document,
2274 )
2275 .await?;
2276 redirect_named_with_message(
2277 "rcms-admin:components:index",
2278 MsgLevel::Success,
2279 "Component saved — referencing page types pick it up on next open.",
2280 &headers,
2281 )
2282}
2283
2284pub async fn component_delete(
2286 State(_state): State<super::AdminState>,
2287 tenant: Tenant,
2288 headers: HeaderMap,
2289 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2290 Path(id): Path<i64>,
2291) -> Result<Response, AdminError> {
2292 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2293 return Ok(r);
2294 }
2295 let c = crate::page_builder::model::component_by_id(tenant.pool(), id)
2296 .await?
2297 .ok_or(AdminError::NotFound(id))?;
2298 let refs = crate::page_builder::model::component_references(tenant.pool(), &c.slug).await?;
2299 if !refs.is_empty() {
2300 let ids: Vec<i64> = refs.iter().map(|(pt, _)| *pt).collect();
2302 let pts: Vec<PageType> = PageType::objects()
2303 .where_(PageType::id.is_in(ids))
2304 .fetch(tenant.pool())
2305 .await
2306 .unwrap_or_default();
2307 let names: Vec<String> = pts.iter().map(|p| p.verbose_name.clone()).collect();
2308 let listed = if names.is_empty() {
2309 format!("{} page type(s)", refs.len())
2310 } else {
2311 names.join(", ")
2312 };
2313 return redirect_named_with_message(
2314 "rcms-admin:components:index",
2315 MsgLevel::Error,
2316 &format!("Can't delete `{}` — still used by: {listed}.", c.slug),
2317 &headers,
2318 );
2319 }
2320 crate::page_builder::model::delete_component(tenant.pool(), id).await?;
2321 redirect_named_with_message(
2322 "rcms-admin:components:index",
2323 MsgLevel::Success,
2324 "Component deleted.",
2325 &headers,
2326 )
2327}
2328
2329pub async fn page_type_new_form(
2333 State(state): State<super::AdminState>,
2334 tenant: Tenant,
2335 headers: HeaderMap,
2336 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2337) -> Result<Response, AdminError> {
2338 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2339 return Ok(r);
2340 }
2341 let mut ctx = Context::new();
2342 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2343 add_admin_theme(&mut ctx, tenant.pool()).await;
2344 ctx.insert("list_url", "/cms-admin/page-types");
2345 insert_workflow_choices(&mut ctx, tenant.pool()).await;
2346 render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx)
2347}
2348
2349async fn insert_workflow_choices(ctx: &mut Context, pool: &rustango::sql::Pool) {
2352 let names: Vec<String> = crate::workflow::Workflow::objects()
2353 .where_(crate::workflow::Workflow::active.eq(true))
2354 .order_by(&[("name", false)])
2355 .fetch(pool)
2356 .await
2357 .unwrap_or_default()
2358 .into_iter()
2359 .map(|w| w.name)
2360 .collect();
2361 ctx.insert("workflows", &names);
2362}
2363
2364fn type_list_json(raw: &str) -> serde_json::Value {
2367 serde_json::Value::Array(
2368 raw.split(',')
2369 .map(str::trim)
2370 .filter(|s| !s.is_empty())
2371 .map(|s| serde_json::Value::String(s.to_owned()))
2372 .collect(),
2373 )
2374}
2375
2376async fn ui_page_type(
2379 pool: &rustango::sql::Pool,
2380 id: i64,
2381) -> Result<Option<crate::page_type_model::PageType>, AdminError> {
2382 Ok(crate::page_type_model::PageType::objects()
2383 .where_(crate::page_type_model::PageType::id.eq(id))
2384 .first(pool)
2385 .await?
2386 .filter(|t| crate::page_type::find_handler(&t.type_name).is_none()))
2387}
2388
2389pub async fn page_type_edit_form(
2391 State(state): State<super::AdminState>,
2392 tenant: Tenant,
2393 headers: HeaderMap,
2394 Path(id): Path<i64>,
2395 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2396) -> Result<Response, AdminError> {
2397 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2398 return Ok(r);
2399 }
2400 let Some(pt) = ui_page_type(tenant.pool(), id).await? else {
2401 return Err(AdminError::NotFound(id));
2402 };
2403 let mut ctx = Context::new();
2404 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2405 add_admin_theme(&mut ctx, tenant.pool()).await;
2406 ctx.insert("list_url", "/cms-admin/page-types");
2407 ctx.insert("edit_id", &id);
2408 ctx.insert("form_verbose_name", &pt.verbose_name);
2409 ctx.insert("form_type_name", &pt.type_name);
2410 ctx.insert("form_allowed_parents", &pt.allowed_parents().join(", "));
2411 ctx.insert("form_allowed_children", &pt.allowed_children().join(", "));
2412 ctx.insert("form_workflow", &pt.workflow);
2413 insert_workflow_choices(&mut ctx, tenant.pool()).await;
2414 render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx)
2415}
2416
2417pub async fn page_type_update(
2420 tenant: Tenant,
2421 headers: HeaderMap,
2422 Path(id): Path<i64>,
2423 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2424 Form(form): Form<FormPageTypeCreate>,
2425) -> Result<Response, AdminError> {
2426 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2427 return Ok(r);
2428 }
2429 let Some(mut pt) = ui_page_type(tenant.pool(), id).await? else {
2430 return Err(AdminError::NotFound(id));
2431 };
2432 if form.verbose_name.trim().is_empty() {
2433 return Err(AdminError::Validation("Name is required.".to_owned()));
2434 }
2435 pt.verbose_name = form.verbose_name.trim().to_owned();
2436 pt.allowed_parent_types = type_list_json(&form.allowed_parents);
2437 pt.allowed_child_types = type_list_json(&form.allowed_children);
2438 pt.workflow = form.workflow.trim().to_owned();
2439 pt.save_pool(tenant.pool()).await?;
2440 redirect_named_with_message(
2441 "rcms-admin:page-types",
2442 MsgLevel::Success,
2443 "Page type settings saved.",
2444 &headers,
2445 )
2446}
2447
2448pub async fn page_type_create(
2452 State(state): State<super::AdminState>,
2453 tenant: Tenant,
2454 headers: HeaderMap,
2455 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2456 Form(form): Form<FormPageTypeCreate>,
2457) -> Result<Response, AdminError> {
2458 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2459 return Ok(r);
2460 }
2461 let ident_src = if form.type_name.trim().is_empty() {
2465 form.verbose_name.as_str()
2466 } else {
2467 form.type_name.as_str()
2468 };
2469 let slug = crate::forms::schema::slugify_key(ident_src);
2470 let err: Option<String> = if form.verbose_name.trim().is_empty() {
2471 Some("Name is required.".to_owned())
2472 } else if !crate::forms::schema::is_valid_key(&slug) {
2473 Some(
2474 "Identifier is invalid — use letters/digits/underscores, starting with a letter."
2475 .to_owned(),
2476 )
2477 } else if crate::page_type_model::PageType::objects()
2478 .where_(crate::page_type_model::PageType::type_name.eq(slug.clone()))
2479 .first(tenant.pool())
2480 .await?
2481 .is_some()
2482 || crate::page_type::find_handler(&slug).is_some()
2483 {
2484 Some(format!(
2485 "A page type with identifier `{slug}` already exists."
2486 ))
2487 } else {
2488 None
2489 };
2490 if let Some(msg) = err {
2491 let mut ctx = Context::new();
2492 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2493 add_admin_theme(&mut ctx, tenant.pool()).await;
2494 ctx.insert("list_url", "/cms-admin/page-types");
2495 ctx.insert("error", &msg);
2496 ctx.insert("form_verbose_name", &form.verbose_name);
2497 ctx.insert("form_type_name", &form.type_name);
2498 ctx.insert("form_allowed_parents", &form.allowed_parents);
2499 ctx.insert("form_allowed_children", &form.allowed_children);
2500 ctx.insert("form_workflow", &form.workflow);
2501 insert_workflow_choices(&mut ctx, tenant.pool()).await;
2502 return render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx);
2503 }
2504 let view_mode = crate::page_view::PageViewMode::parse(&form.view_mode);
2509 let default_template = if view_mode == crate::page_view::PageViewMode::Api {
2510 String::new()
2511 } else {
2512 crate::page_builder::DEFAULT_SCHEMA_TEMPLATE.to_owned()
2513 };
2514 let mut row = crate::page_type_model::PageType {
2515 id: rustango::sql::Auto::Unset,
2516 app_label: "cms_ui".to_owned(),
2517 type_name: slug.clone(),
2518 verbose_name: form.verbose_name.trim().to_owned(),
2519 default_template,
2520 view_mode: view_mode.as_str().to_owned(),
2521 is_creatable: true,
2522 allowed_parent_types: type_list_json(&form.allowed_parents),
2523 allowed_child_types: type_list_json(&form.allowed_children),
2524 workflow: form.workflow.trim().to_owned(),
2525 created_at: rustango::sql::Auto::Unset,
2526 updated_at: rustango::sql::Auto::Unset,
2527 };
2528 row.insert_pool(tenant.pool()).await?;
2529 let new_id = row.id.get().copied().unwrap_or_default();
2530 let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
2532 crate::page_builder::model::save_draft(
2533 tenant.pool(),
2534 new_id,
2535 serde_json::json!({ "nodes": [] }),
2536 created_by,
2537 )
2538 .await
2539 .log_warn("empty builder draft not seeded");
2540 redirect_named_with_params_and_message(
2541 "rcms-admin:page-types:build",
2542 &[("id", new_id.to_string())],
2543 MsgLevel::Success,
2544 "Page type created — design its body, then Publish.",
2545 &headers,
2546 )
2547}
2548
2549pub async fn page_type_delete(
2552 State(_state): State<super::AdminState>,
2553 tenant: Tenant,
2554 headers: HeaderMap,
2555 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2556 Path(id): Path<i64>,
2557) -> Result<Response, AdminError> {
2558 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2559 return Ok(r);
2560 }
2561 let pt = crate::page_type_model::PageType::objects()
2562 .where_(crate::page_type_model::PageType::id.eq(id))
2563 .first(tenant.pool())
2564 .await?
2565 .ok_or(AdminError::NotFound(id))?;
2566 if pt.app_label != "cms_ui" {
2568 return redirect_named_with_message(
2569 "rcms-admin:page-types",
2570 MsgLevel::Error,
2571 "Only UI-created page types can be deleted.",
2572 &headers,
2573 );
2574 }
2575 let page_count = Page::objects()
2576 .where_(Page::page_type_id.eq(id))
2577 .fetch(tenant.pool())
2578 .await
2579 .map(|v| v.len())
2580 .unwrap_or(0);
2581 if page_count > 0 {
2582 return redirect_named_with_message(
2583 "rcms-admin:page-types",
2584 MsgLevel::Error,
2585 "Can't delete — pages still use this type. Delete or move them first.",
2586 &headers,
2587 );
2588 }
2589 for row in crate::page_builder::model::list_versions(tenant.pool(), id)
2591 .await
2592 .unwrap_or_default()
2593 {
2594 row.delete_pool(tenant.pool()).await.log_warn("page-builder schema version not deleted");
2595 }
2596 pt.delete_pool(tenant.pool()).await?;
2597 redirect_named_with_message(
2598 "rcms-admin:page-types",
2599 MsgLevel::Success,
2600 "Page type deleted.",
2601 &headers,
2602 )
2603}
2604
2605fn translation_canonical_html(widget_tag: &str, canonical: &str) -> String {
2609 if widget_tag == "richtext" && !canonical.trim().is_empty() {
2610 crate::markdown::sanitize_html(canonical)
2611 } else {
2612 String::new()
2613 }
2614}
2615
2616async fn builder_translation_groups(
2622 tenant: &Tenant,
2623 page_id: i64,
2624 page_type_id: i64,
2625 existing: &std::collections::HashMap<String, String>,
2626) -> (Vec<serde_json::Value>, std::collections::HashSet<String>) {
2627 let mut paths = std::collections::HashSet::new();
2628 let Ok(Some(row)) =
2629 crate::page_builder::model::published_for(tenant.pool(), page_type_id).await
2630 else {
2631 return (Vec::new(), paths);
2632 };
2633 let Ok(doc) = crate::page_builder::parse_schema(&row.document) else {
2634 return (Vec::new(), paths);
2635 };
2636 let components = crate::page_builder::model::component_map(tenant.pool())
2637 .await
2638 .unwrap_or_default();
2639 let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
2640 let (values, _) = crate::page_builder::values::load_upgraded(tenant.pool(), page_id, &compiled)
2641 .await
2642 .unwrap_or_else(|_| (serde_json::json!({}), Default::default()));
2643 let leaves = crate::page_builder::values::builder_translatable_leaves(&compiled, &values);
2644 let mut groups: Vec<serde_json::Value> = Vec::new();
2646 let mut cur = String::new();
2647 for leaf in &leaves {
2648 paths.insert(leaf.path.clone());
2649 let rowv = serde_json::json!({
2650 "path": leaf.path,
2651 "widget_kind": leaf.widget_kind.as_tag(),
2652 "field_label": leaf.field_label,
2653 "canonical": leaf.canonical_text,
2654 "canonical_html": translation_canonical_html(leaf.widget_kind.as_tag(), &leaf.canonical_text),
2655 "value": existing.get(&leaf.path).cloned().unwrap_or_default(),
2656 });
2657 if leaf.block_id != cur {
2658 cur.clone_from(&leaf.block_id);
2659 groups.push(serde_json::json!({
2660 "block_type": leaf.block_type,
2661 "block_label": leaf.block_label,
2662 "block_id": leaf.block_id,
2663 "depth": leaf.depth,
2664 "leaves": [rowv],
2665 }));
2666 } else if let Some(arr) = groups
2667 .last_mut()
2668 .and_then(|g| g.get_mut("leaves"))
2669 .and_then(|v| v.as_array_mut())
2670 {
2671 arr.push(rowv);
2672 }
2673 }
2674 (groups, paths)
2675}
2676
2677pub async fn media_bulk_move_collection(
2681 State(_state): State<super::AdminState>,
2682 tenant: Tenant,
2683 headers: HeaderMap,
2684 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
2685 Form(form): Form<Vec<(String, String)>>,
2686) -> Result<Response, AdminError> {
2687 let target: Option<i64> = form
2688 .iter()
2689 .find(|(k, _)| k == "collection_id")
2690 .and_then(|(_, v)| v.parse::<i64>().ok())
2691 .filter(|id| *id > 0);
2692 let ids: Vec<i64> = form
2693 .iter()
2694 .filter(|(k, _)| k == "ids" || k == "id")
2695 .filter_map(|(_, v)| v.parse::<i64>().ok())
2696 .collect();
2697 let kind = form
2698 .iter()
2699 .find(|(k, _)| k == "kind")
2700 .map(|(_, v)| v.clone())
2701 .unwrap_or_else(|| "image".to_owned());
2702 let mut touched = 0;
2703 for id in ids {
2704 if let Some(mut m) = Media::objects()
2705 .where_(Media::id.eq(id))
2706 .first(tenant.pool())
2707 .await?
2708 {
2709 m.collection_id = target;
2710 m.save_pool(tenant.pool()).await?;
2711 touched += 1;
2712 }
2713 }
2714 let redirect_url = if kind == "document" {
2715 "rcms-admin:documents:list"
2716 } else {
2717 "rcms-admin:media:list"
2718 };
2719 let dest = match target {
2720 Some(id) => format!("to collection #{id}"),
2721 None => "to Uncategorized".to_owned(),
2722 };
2723 redirect_named_with_message_plural(
2724 redirect_url,
2725 MsgLevel::Success,
2726 "Moved {count} item(s) {dest}.",
2727 touched as i64,
2728 &[("count", &touched.to_string()), ("dest", &dest)],
2729 &headers,
2730 )
2731}
2732
2733pub async fn collection_permissions_form(
2737 State(state): State<super::AdminState>,
2738 tenant: Tenant,
2739 headers: HeaderMap,
2740 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2741 Path(id): Path<i64>,
2742) -> Result<Response, AdminError> {
2743 let collection = crate::media::MediaCollection::objects()
2744 .where_(crate::media::MediaCollection::id.eq(id))
2745 .first(tenant.pool())
2746 .await?
2747 .ok_or(AdminError::NotFound(id))?;
2748 let roles: Vec<rustango::tenancy::permissions::Role> =
2749 rustango::tenancy::permissions::Role::objects()
2750 .order_by(&[("name", false)])
2751 .fetch(tenant.pool())
2752 .await?;
2753 let grants: Vec<crate::permissions::CollectionPermission> =
2754 crate::permissions::CollectionPermission::objects()
2755 .where_(crate::permissions::CollectionPermission::collection_id.eq(id))
2756 .fetch(tenant.pool())
2757 .await?;
2758 let granted: std::collections::HashSet<(i64, String)> = grants
2759 .iter()
2760 .map(|g| (g.role_id, g.permission.clone()))
2761 .collect();
2762 let actions: Vec<&str> = crate::permissions::Action::all()
2763 .iter()
2764 .map(|a| a.as_str())
2765 .collect();
2766 let perm_grid: Vec<serde_json::Value> = roles
2767 .iter()
2768 .map(|r| {
2769 let rid = r.id.get().copied().unwrap_or_default();
2770 let row_cells: Vec<serde_json::Value> = actions
2771 .iter()
2772 .map(|a| {
2773 serde_json::json!({
2774 "action": a,
2775 "granted": granted.contains(&(rid, (*a).to_owned())),
2776 })
2777 })
2778 .collect();
2779 serde_json::json!({
2780 "role_id": rid,
2781 "role_name": r.name,
2782 "role_description": r.description,
2783 "cells": row_cells,
2784 })
2785 })
2786 .collect();
2787
2788 let mut ctx = Context::new();
2789 add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
2790 add_admin_theme(&mut ctx, tenant.pool()).await;
2791 ctx.insert("collection_id", &id);
2792 ctx.insert("collection_name", &collection.name);
2793 ctx.insert("perm_actions", &actions);
2794 ctx.insert("perm_grid", &perm_grid);
2795
2796 let restriction = crate::collection_view_restriction::direct_for_collection(tenant.pool(), id)
2799 .await
2800 .unwrap_or_default();
2801 let restriction_kind = restriction
2802 .as_ref()
2803 .map(|r| r.kind.clone())
2804 .unwrap_or_else(|| "none".to_owned());
2805 let restriction_groups: std::collections::HashSet<i64> = restriction
2806 .as_ref()
2807 .map(|r| r.parsed_groups().into_iter().collect())
2808 .unwrap_or_default();
2809 let restriction_has_password = restriction
2810 .as_ref()
2811 .map(|r| !r.password_hash.is_empty())
2812 .unwrap_or(false);
2813 let role_options: Vec<serde_json::Value> = roles
2814 .iter()
2815 .map(|r| {
2816 let rid = r.id.get().copied().unwrap_or_default();
2817 serde_json::json!({
2818 "id": rid,
2819 "name": r.name,
2820 "selected": restriction_groups.contains(&rid),
2821 })
2822 })
2823 .collect();
2824 let restriction_codenames: Vec<String> = restriction
2826 .as_ref()
2827 .map(|r| r.parsed_codenames())
2828 .unwrap_or_default();
2829 let restriction_codenames_str = restriction_codenames.join(",");
2830 let codename_choices: Vec<serde_json::Value> = super::resources::membership_codenames()
2831 .into_iter()
2832 .map(|(codename, label)| {
2833 serde_json::json!({
2834 "codename": codename,
2835 "label": label,
2836 "checked": restriction_codenames.contains(&codename),
2837 })
2838 })
2839 .collect();
2840 ctx.insert("restriction_kind", &restriction_kind);
2841 ctx.insert("restriction_has_password", &restriction_has_password);
2842 ctx.insert("restriction_roles", &role_options);
2843 ctx.insert("restriction_codenames_str", &restriction_codenames_str);
2844 ctx.insert("restriction_codename_choices", &codename_choices);
2845
2846 render_with_csrf(
2847 &state,
2848 &headers,
2849 "rcms_admin/collection_permissions.html",
2850 &mut ctx,
2851 )
2852}
2853
2854#[derive(Deserialize)]
2856pub struct CollectionPrivacyForm {
2857 pub kind: String,
2858 #[serde(default)]
2859 pub password: String,
2860 #[serde(default)]
2861 pub group_ids: String,
2862 #[serde(default)]
2865 pub codenames: String,
2866}
2867
2868pub async fn collection_privacy_submit(
2872 State(_state): State<super::AdminState>,
2873 tenant: Tenant,
2874 headers: HeaderMap,
2875 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
2876 Path(id): Path<i64>,
2877 Form(form): Form<CollectionPrivacyForm>,
2878) -> Result<Response, AdminError> {
2879 use rustango::sql::Auto;
2880 let existing =
2881 crate::collection_view_restriction::direct_for_collection(tenant.pool(), id).await?;
2882 if form.kind == "none" {
2883 if let Some(row) = existing {
2884 row.delete_pool(tenant.pool()).await?;
2885 return redirect_named_with_params_and_message(
2886 "rcms-admin:media:collection-permissions",
2887 &[("id", id.to_string())],
2888 MsgLevel::Success,
2889 "Removed view restriction — collection is now public.",
2890 &headers,
2891 );
2892 }
2893 return redirect_named_with_params_and_message(
2894 "rcms-admin:media:collection-permissions",
2895 &[("id", id.to_string())],
2896 MsgLevel::Info,
2897 "No restriction to remove.",
2898 &headers,
2899 );
2900 }
2901 let Some(kind) = crate::collection_view_restriction::RestrictionKind::parse(&form.kind) else {
2902 return Err(AdminError::Validation(format!(
2903 "unknown restriction kind `{}`",
2904 form.kind
2905 )));
2906 };
2907 let password_hash = match kind {
2908 crate::collection_view_restriction::RestrictionKind::Password => {
2909 if form.password.is_empty() {
2910 if let Some(row) = &existing {
2911 if row.kind == kind.as_str() {
2912 row.password_hash.clone()
2913 } else {
2914 return redirect_named_with_params_and_message(
2915 "rcms-admin:media:collection-permissions",
2916 &[("id", id.to_string())],
2917 MsgLevel::Error,
2918 "Password is required when switching the restriction kind to password.",
2919 &headers,
2920 );
2921 }
2922 } else {
2923 return redirect_named_with_params_and_message(
2924 "rcms-admin:media:collection-permissions",
2925 &[("id", id.to_string())],
2926 MsgLevel::Error,
2927 "Password is required for password-protected collections.",
2928 &headers,
2929 );
2930 }
2931 } else {
2932 crate::passwords::hash(&form.password).await
2933 .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?
2934 }
2935 }
2936 _ => String::new(),
2937 };
2938 let group_ids: Vec<i64> = if matches!(
2939 kind,
2940 crate::collection_view_restriction::RestrictionKind::Groups
2941 ) {
2942 form.group_ids
2943 .split(',')
2944 .filter_map(|s| s.trim().parse::<i64>().ok())
2945 .collect()
2946 } else {
2947 Vec::new()
2948 };
2949 let group_json = serde_json::json!(group_ids);
2950 let codenames: Vec<String> = if matches!(
2951 kind,
2952 crate::collection_view_restriction::RestrictionKind::Permission
2953 ) {
2954 form.codenames
2955 .split(',')
2956 .map(str::trim)
2957 .filter(|s| !s.is_empty())
2958 .map(str::to_owned)
2959 .collect()
2960 } else {
2961 Vec::new()
2962 };
2963 let codenames_json = serde_json::json!(codenames);
2964 match existing {
2965 Some(mut row) => {
2966 row.kind = kind.as_str().to_owned();
2967 row.password_hash = password_hash;
2968 row.group_ids = group_json;
2969 row.codenames = codenames_json;
2970 row.save_pool(tenant.pool()).await?;
2971 }
2972 None => {
2973 let mut row = crate::collection_view_restriction::CollectionViewRestriction {
2974 id: Auto::Unset,
2975 collection_id: id,
2976 kind: kind.as_str().to_owned(),
2977 password_hash,
2978 group_ids: group_json,
2979 codenames: codenames_json,
2980 created_at: Auto::Unset,
2981 updated_at: Auto::Unset,
2982 };
2983 row.insert_pool(tenant.pool()).await?;
2984 }
2985 }
2986 redirect_named_with_params_and_message(
2987 "rcms-admin:media:collection-permissions",
2988 &[("id", id.to_string())],
2989 MsgLevel::Success,
2990 "Collection privacy updated. New requests to /__media__/<spec>/<id> will enforce it.",
2991 &headers,
2992 )
2993}
2994
2995pub async fn collection_permissions_submit(
3000 State(_state): State<super::AdminState>,
3001 tenant: Tenant,
3002 Path(collection_id): Path<i64>,
3003 axum::Json(payload): axum::Json<PagePermissionsPayload>,
3004) -> Result<Response, AdminError> {
3005 use rustango::sql::Auto;
3006 let valid_actions: std::collections::HashSet<&str> = crate::permissions::Action::all()
3007 .iter()
3008 .map(|a| a.as_str())
3009 .collect();
3010 let want: std::collections::BTreeSet<(i64, String)> = payload
3011 .grants
3012 .iter()
3013 .filter(|g| valid_actions.contains(g.action.as_str()))
3014 .map(|g| (g.role_id, g.action.clone()))
3015 .collect();
3016
3017 let existing: Vec<crate::permissions::CollectionPermission> =
3018 crate::permissions::CollectionPermission::objects()
3019 .where_(crate::permissions::CollectionPermission::collection_id.eq(collection_id))
3020 .fetch(tenant.pool())
3021 .await?;
3022 let have: std::collections::BTreeSet<(i64, String)> = existing
3023 .iter()
3024 .map(|p| (p.role_id, p.permission.clone()))
3025 .collect();
3026
3027 for p in &existing {
3028 let key = (p.role_id, p.permission.clone());
3029 if !want.contains(&key) {
3030 p.clone().delete_pool(tenant.pool()).await?;
3031 }
3032 }
3033 for (role_id, action) in &want {
3034 if !have.contains(&(*role_id, action.clone())) {
3035 let mut row = crate::permissions::CollectionPermission {
3036 id: Auto::Unset,
3037 collection_id,
3038 role_id: *role_id,
3039 permission: action.clone(),
3040 created_at: Auto::Unset,
3041 };
3042 row.insert_pool(tenant.pool()).await?;
3043 }
3044 }
3045 Ok(axum::http::StatusCode::NO_CONTENT.into_response())
3046}
3047
3048#[derive(Debug, Deserialize)]
3052pub struct PagePermissionsPayload {
3053 pub grants: Vec<PagePermissionGrant>,
3054}
3055#[derive(Debug, Deserialize)]
3056pub struct PagePermissionGrant {
3057 pub role_id: i64,
3058 pub action: String,
3059}
3060
3061pub async fn page_permissions_submit(
3066 State(_state): State<super::AdminState>,
3067 tenant: Tenant,
3068 Path(page_id): Path<i64>,
3069 axum::Json(payload): axum::Json<PagePermissionsPayload>,
3070) -> Result<Response, AdminError> {
3071 use rustango::sql::Auto;
3072 let valid_actions: std::collections::HashSet<&str> = crate::permissions::Action::all()
3073 .iter()
3074 .map(|a| a.as_str())
3075 .collect();
3076 let want: std::collections::BTreeSet<(i64, String)> = payload
3077 .grants
3078 .iter()
3079 .filter(|g| valid_actions.contains(g.action.as_str()))
3080 .map(|g| (g.role_id, g.action.clone()))
3081 .collect();
3082
3083 let existing: Vec<crate::permissions::PagePermission> =
3084 crate::permissions::PagePermission::objects()
3085 .where_(crate::permissions::PagePermission::page_id.eq(page_id))
3086 .fetch(tenant.pool())
3087 .await?;
3088 let have: std::collections::BTreeSet<(i64, String)> = existing
3089 .iter()
3090 .map(|p| (p.role_id, p.permission.clone()))
3091 .collect();
3092
3093 for p in &existing {
3095 let key = (p.role_id, p.permission.clone());
3096 if !want.contains(&key) {
3097 p.clone().delete_pool(tenant.pool()).await?;
3098 }
3099 }
3100 for (role_id, action) in &want {
3102 if !have.contains(&(*role_id, action.clone())) {
3103 let mut row = crate::permissions::PagePermission {
3104 id: Auto::Unset,
3105 page_id,
3106 role_id: *role_id,
3107 permission: action.clone(),
3108 created_at: Auto::Unset,
3109 };
3110 row.insert_pool(tenant.pool()).await?;
3111 }
3112 }
3113
3114 Ok(axum::http::StatusCode::NO_CONTENT.into_response())
3115}
3116
3117fn render_extra_tabs(
3123 specs: Vec<crate::page_type::TabSpec>,
3124 tera: &std::sync::Arc<tera::Tera>,
3125 base_ctx: &Context,
3126 headers: &HeaderMap,
3127) -> Vec<serde_json::Value> {
3128 use crate::page_type::TabBody;
3129 specs
3130 .into_iter()
3131 .map(|spec| {
3132 let html = match spec.body {
3133 TabBody::Html(s) => s,
3134 TabBody::Template { path, context } => {
3135 let mut tab_ctx = base_ctx.clone();
3136 for (k, v) in context {
3137 tab_ctx.insert(&k, &v);
3138 }
3139 tera.render(&path, &tab_ctx).unwrap_or_else(|e| {
3140 format!(
3141 r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3142 <span class="rcms-flash-body"><strong>{label}</strong> {failed} <code>{path}</code>: {e}</span>
3143</div>"#,
3144 label = tera::escape_html(&super::i18n::tr(headers, "Tab template error:", &[])),
3145 failed = tera::escape_html(&super::i18n::tr(headers, "failed to render", &[])),
3146 path = tera::escape_html(&path),
3147 e = tera::escape_html(&e.to_string()),
3148 )
3149 })
3150 }
3151 TabBody::Widgets(widgets) => {
3152 let mut ctx = Context::new();
3153 ctx.insert("widgets", &widgets);
3154 tera.render("rcms_admin/_widget_group.html", &ctx)
3155 .unwrap_or_else(|e| {
3156 format!(
3157 r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3158 <span class="rcms-flash-body"><strong>{label}</strong> {e}</span>
3159</div>"#,
3160 label = tera::escape_html(&super::i18n::tr(headers, "Widget-group tab error:", &[])),
3161 e = tera::escape_html(&e.to_string()),
3162 )
3163 })
3164 }
3165 TabBody::Group { heading, help, layout, widgets } => {
3166 let mut ctx = Context::new();
3171 ctx.insert("widgets", &widgets);
3172 let inner = tera
3173 .render("rcms_admin/_widget_group.html", &ctx)
3174 .unwrap_or_else(|e| {
3175 format!(
3176 r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3177 <span class="rcms-flash-body"><strong>{label}</strong> {e}</span>
3178</div>"#,
3179 label = tera::escape_html(&super::i18n::tr(headers, "Panel-group tab error:", &[])),
3180 e = tera::escape_html(&e.to_string()),
3181 )
3182 });
3183 let help_html = if help.is_empty() {
3184 String::new()
3185 } else {
3186 format!(
3187 r#"<p class="rcms-hint rcms-panel-group-help">{}</p>"#,
3188 tera::escape_html(&help),
3189 )
3190 };
3191 format!(
3192 r#"<fieldset class="rcms-panel-group rcms-panel-group--{layout}">
3193 <legend>{heading}</legend>
3194 {help_html}
3195 <div class="rcms-panel-group-body">{inner}</div>
3196</fieldset>"#,
3197 layout = layout.class_suffix(),
3198 heading = tera::escape_html(&heading),
3199 help_html = help_html,
3200 inner = inner,
3201 )
3202 }
3203 TabBody::Help { content } => {
3204 format!(
3207 r#"<div class="rcms-panel-help">{content}</div>"#,
3208 content = content,
3209 )
3210 }
3211 };
3212 serde_json::json!({
3213 "name": spec.name,
3214 "label": spec.label,
3215 "icon": spec.icon,
3216 "badge": spec.badge,
3217 "html": html,
3218 })
3219 })
3220 .collect()
3221}
3222
3223pub async fn admin_page_dispatch(
3228 State(state): State<super::AdminState>,
3229 tenant: Tenant,
3230 headers: HeaderMap,
3231 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3232 Path(slug): Path<String>,
3233) -> Result<Response, AdminError> {
3234 match super::admin_page::find_admin_page(&slug) {
3235 Some(handler) => Ok(handler
3236 .render(super::admin_page::AdminPageCtx {
3237 tera: &state.tera,
3238 tenant: &tenant,
3239 headers: &headers,
3240 user: session_user.as_ref(),
3241 })
3242 .await),
3243 None => Err(AdminError::NotFound(0)),
3244 }
3245}
3246
3247pub(crate) async fn add_admin_theme(ctx: &mut Context, pool: &rustango::sql::Pool) {
3252 let mut admin_default: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3255 .where_(crate::theme::Theme::is_admin_default.eq(true))
3256 .fetch(pool)
3257 .await
3258 .unwrap_or_default();
3259 let theme = if let Some(t) = admin_default.pop() {
3260 t
3261 } else {
3262 let mut any: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3263 .where_(crate::theme::Theme::is_default.eq(true))
3264 .fetch(pool)
3265 .await
3266 .unwrap_or_default();
3267 match any.pop() {
3268 Some(t) => t,
3269 None => {
3270 let mut first: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3271 .order_by(&[("name", false)])
3272 .fetch(pool)
3273 .await
3274 .unwrap_or_default();
3275 let Some(t) = first.pop() else {
3276 ctx.insert("theme_css", &String::new());
3279 ctx.insert("theme_slug", &String::new());
3280 ctx.insert("theme_default_mode", &"light");
3281 ctx.insert("theme_font_url", &String::new());
3282 return;
3283 };
3284 t
3285 }
3286 }
3287 };
3288 let theme_id = theme.id.get().copied().unwrap_or_default();
3289 let brand_colors: Vec<crate::theme::BrandColor> = crate::theme::BrandColor::objects()
3290 .where_(crate::theme::BrandColor::theme_id.eq(theme_id))
3291 .order_by(&[("sort_order", false)])
3292 .fetch(pool)
3293 .await
3294 .unwrap_or_default();
3295 let css = crate::theme::emit_css(&theme, &brand_colors);
3296 ctx.insert("theme_css", &css);
3297 ctx.insert("theme_slug", &theme.slug);
3298 ctx.insert("theme_name", &theme.name);
3299 ctx.insert("theme_default_mode", &theme.default_mode);
3300 ctx.insert("theme_font_url", &theme.font_url);
3301}
3302
3303#[derive(Debug, Deserialize)]
3305pub struct ListQuery {
3306 #[serde(default)]
3309 pub parent: Option<i64>,
3310 #[serde(default)]
3314 pub q: Option<String>,
3315 #[serde(default)]
3318 pub r#type: Option<String>,
3319 #[serde(default)]
3321 pub status: Option<String>,
3322}
3323
3324pub async fn page_list(
3335 State(state): State<super::AdminState>,
3336 tenant: Tenant,
3337 headers: HeaderMap,
3338 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3339 Query(q): Query<ListQuery>,
3340) -> Result<Response, AdminError> {
3341 match crate::page::run_schedule_sweep_with_mailer(
3345 tenant.pool(),
3346 state.mailer.as_deref(),
3347 &state.mailer_from,
3348 &tenant.org.slug,
3349 )
3350 .await
3351 {
3352 Ok(result) if !result.changed_urls.is_empty() => {
3355 crate::task_queue::purge_urls(
3356 state.cache_invalidator.clone(),
3357 tenant.org.slug.clone(),
3358 result.changed_urls,
3359 )
3360 .await;
3361 }
3362 Ok(_) => {}
3363 Err(e) => tracing::warn!(target: "rustango_cms::admin", error = %e, "schedule sweep failed"),
3364 }
3365
3366 let all_pages: Vec<Page> = Page::objects()
3372 .order_by(&[("path", false), ("sort_order", false)])
3373 .fetch(tenant.pool())
3374 .await?;
3375
3376 let by_id: std::collections::HashMap<i64, &Page> = all_pages
3378 .iter()
3379 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
3380 .collect();
3381
3382 let parent_page: Option<&Page> = q.parent.and_then(|pid| by_id.get(&pid).copied());
3384
3385 let mut breadcrumbs: Vec<serde_json::Value> = Vec::new();
3387 if let Some(mut cur) = parent_page {
3388 breadcrumbs.push(serde_json::json!({
3389 "id": cur.id.get().copied(),
3390 "title": cur.title.clone(),
3391 }));
3392 while let Some(ppid) = cur.parent_id {
3393 if let Some(p) = by_id.get(&ppid).copied() {
3394 breadcrumbs.push(serde_json::json!({
3395 "id": p.id.get().copied(),
3396 "title": p.title.clone(),
3397 }));
3398 cur = p;
3399 } else {
3400 break;
3401 }
3402 }
3403 breadcrumbs.reverse();
3404 }
3405
3406 let search_query =
3410 q.q.as_deref()
3411 .map(str::trim)
3412 .filter(|s| !s.is_empty())
3413 .map(str::to_owned);
3414 let status_filter = q
3415 .status
3416 .as_deref()
3417 .map(str::trim)
3418 .filter(|s| !s.is_empty())
3419 .map(str::to_owned);
3420 let type_filter_slug = q
3421 .r#type
3422 .as_deref()
3423 .map(str::trim)
3424 .filter(|s| !s.is_empty())
3425 .map(str::to_owned);
3426
3427 let viewer_user_id: Option<i64> = session_user
3433 .as_ref()
3434 .filter(|u| u.active)
3435 .and_then(|u| u.id.get().copied());
3436 let viewer_is_superuser = session_user.as_ref().is_some_and(|u| u.is_superuser);
3437 let permission_filter_enabled = viewer_user_id.is_some() && !viewer_is_superuser;
3438 let viewable_ids: Option<std::collections::HashSet<i64>> = match viewer_user_id {
3439 Some(uid) if permission_filter_enabled => {
3440 let pages: Vec<(i64, Option<i64>)> = all_pages
3441 .iter()
3442 .filter_map(|p| p.id.get().copied().map(|id| (id, p.parent_id)))
3443 .collect();
3444 Some(
3445 crate::permissions::viewable_page_ids(tenant.pool(), uid, &pages)
3446 .await
3447 .unwrap_or_default(),
3448 )
3449 }
3450 _ => None,
3451 };
3452
3453 let fts_rank: Option<std::collections::HashMap<i64, usize>> = match search_query.as_deref() {
3458 Some(q) => crate::search::search_page_ids_all_statuses(tenant.pool(), q, 1000)
3459 .await
3460 .map(|ids| ids.iter().enumerate().map(|(i, id)| (*id, i)).collect()),
3461 None => None,
3462 };
3463 let visible: Vec<&Page> = if search_query.is_some()
3464 || status_filter.is_some()
3465 || type_filter_slug.is_some()
3466 {
3467 let q_lower = search_query.as_deref().map(str::to_lowercase);
3469 let prefetch_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3473 let type_id_by_slug: std::collections::HashMap<String, i64> = prefetch_types
3474 .iter()
3475 .filter_map(|t| t.id.get().copied().map(|id| (t.type_name.clone(), id)))
3476 .collect();
3477 let type_id_filter = type_filter_slug
3478 .as_deref()
3479 .and_then(|s| type_id_by_slug.get(s).copied());
3480 all_pages
3481 .iter()
3482 .filter(|p| {
3483 let matches_search = match &q_lower {
3489 None => true,
3490 Some(needle) => {
3491 fts_rank.as_ref().is_some_and(|rank| {
3492 p.id.get().copied().is_some_and(|id| rank.contains_key(&id))
3493 }) || p.title.to_lowercase().contains(needle)
3494 || p.slug.to_lowercase().contains(needle)
3495 || p.url_path.to_lowercase().contains(needle)
3496 }
3497 };
3498 let matches_status = match &status_filter {
3499 None => true,
3500 Some(s) => p.status == *s,
3501 };
3502 let matches_type = match type_id_filter {
3503 None => true,
3504 Some(id) => p.page_type_id == id,
3505 };
3506 matches_search && matches_status && matches_type
3507 })
3508 .collect()
3509 } else {
3510 all_pages
3512 .iter()
3513 .filter(|p| p.parent_id == q.parent)
3514 .collect()
3515 };
3516 let visible_before_permission_filter = visible.len();
3520 let visible: Vec<&Page> = match &viewable_ids {
3523 None => visible,
3524 Some(set) => visible
3525 .into_iter()
3526 .filter(|p| p.id.get().copied().is_some_and(|id| set.contains(&id)))
3527 .collect(),
3528 };
3529 let visible: Vec<&Page> = if let Some(rank) = &fts_rank {
3532 let mut v = visible;
3533 v.sort_by_key(|p| {
3534 p.id.get()
3535 .copied()
3536 .and_then(|id| rank.get(&id).copied())
3537 .unwrap_or(usize::MAX)
3538 });
3539 v
3540 } else {
3541 visible
3542 };
3543 let is_search_mode =
3544 search_query.is_some() || status_filter.is_some() || type_filter_slug.is_some();
3545 let empty_filtered = is_search_mode && visible.is_empty();
3552 let empty_hidden_by_perms = !is_search_mode
3553 && visible.is_empty()
3554 && visible_before_permission_filter > 0
3555 && permission_filter_enabled;
3556
3557 let mut child_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
3559 for p in &all_pages {
3560 if let Some(ppid) = p.parent_id {
3561 *child_counts.entry(ppid).or_insert(0) += 1;
3562 }
3563 }
3564
3565 let types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3566 let type_map: std::collections::HashMap<i64, String> = types
3567 .iter()
3568 .filter_map(|t| t.id.get().copied().map(|id| (id, t.verbose_name.clone())))
3569 .collect();
3570
3571 let live_urls = build_live_url_map(&all_pages);
3572
3573 let ancestors_for = |p: &Page| -> Vec<serde_json::Value> {
3577 let mut chain: Vec<serde_json::Value> = Vec::new();
3578 let mut cur_parent = p.parent_id;
3579 while let Some(pid) = cur_parent {
3580 match by_id.get(&pid).copied() {
3581 Some(ancestor) => {
3582 chain.push(serde_json::json!({
3583 "id": ancestor.id.get().copied(),
3584 "title": ancestor.title.clone(),
3585 }));
3586 cur_parent = ancestor.parent_id;
3587 }
3588 None => break,
3589 }
3590 }
3591 chain.reverse();
3592 chain
3593 };
3594
3595 let rows: Vec<serde_json::Value> = visible
3596 .iter()
3597 .map(|p| {
3598 let id = p.id.get().copied();
3599 let ancestors = if is_search_mode {
3600 ancestors_for(p)
3601 } else {
3602 Vec::new()
3603 };
3604 serde_json::json!({
3605 "id": id,
3606 "title": p.title,
3607 "slug": p.slug,
3608 "path": p.path,
3609 "url_path": p.url_path,
3610 "status": p.status,
3611 "page_type_id": p.page_type_id,
3612 "go_live_at": p.go_live_at,
3613 "expire_at": p.expire_at,
3614 "updated_at": p.updated_at.get().copied(),
3615 "published_at": p.published_at,
3616 "locale_variant_of": p.locale_variant_of,
3617 "alias_of": p.alias_of,
3618 "child_count": id.and_then(|i| child_counts.get(&i).copied()).unwrap_or(0),
3619 "ancestors": ancestors,
3620 })
3621 })
3622 .collect();
3623
3624 let mut ctx = Context::new();
3625 add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3626 add_admin_theme(&mut ctx, tenant.pool()).await;
3627 ctx.insert("rows", &rows);
3628 ctx.insert("type_map", &type_map);
3629 ctx.insert("creatable_types", &allowed_root_types(&types));
3631 ctx.insert("live_urls", &live_urls);
3632 ctx.insert("breadcrumbs", &breadcrumbs);
3633 ctx.insert("parent_id", &q.parent);
3634 ctx.insert("parent_title", &parent_page.map(|p| p.title.clone()));
3635 ctx.insert("search_query", &search_query);
3636 ctx.insert("status_filter", &status_filter);
3637 ctx.insert("type_filter", &type_filter_slug);
3638 ctx.insert("is_search_mode", &is_search_mode);
3639 ctx.insert("empty_filtered", &empty_filtered);
3640 ctx.insert("empty_hidden_by_perms", &empty_hidden_by_perms);
3641 let mut type_slugs: Vec<(String, String)> = types
3644 .iter()
3645 .map(|t| (t.type_name.clone(), t.verbose_name.clone()))
3646 .collect();
3647 type_slugs.sort_by(|a, b| a.1.cmp(&b.1));
3648 ctx.insert("type_choices", &type_slugs);
3649
3650 let move_choices: Vec<serde_json::Value> = all_pages
3656 .iter()
3657 .map(|p| {
3658 let indent = "—".repeat(p.depth.max(1) as usize - 1);
3659 let label = if indent.is_empty() {
3660 p.title.clone()
3661 } else {
3662 format!("{indent} {}", p.title)
3663 };
3664 serde_json::json!({
3665 "id": p.id.get().copied(),
3666 "label": label,
3667 "path": p.path.clone(),
3668 })
3669 })
3670 .collect();
3671 ctx.insert("move_choices", &move_choices);
3672 ctx.insert(
3675 "plugin_page_listing_buttons",
3676 &crate::hooks::page_listing_buttons_raw(),
3677 );
3678 let plugin_bulk_actions: Vec<serde_json::Value> = crate::hooks::bulk_actions_for("cms_page")
3680 .into_iter()
3681 .map(|a| {
3682 serde_json::json!({
3683 "key": a.key,
3684 "label": a.label,
3685 "icon": a.icon,
3686 "danger": a.danger,
3687 "confirm_message": a.confirm_message,
3688 "action_url": a.action_url,
3689 })
3690 })
3691 .collect();
3692 ctx.insert("plugin_bulk_actions", &plugin_bulk_actions);
3693 let copy_locales: Vec<Locale> = Locale::objects()
3696 .where_(Locale::active.eq(true))
3697 .order_by(&[("sort_order", false), ("code", false)])
3698 .fetch(tenant.pool())
3699 .await
3700 .unwrap_or_default()
3701 .into_iter()
3702 .filter(|l| !l.is_default)
3703 .collect();
3704 ctx.insert("copy_locales", ©_locales);
3705 render_with_csrf(&state, &headers, "rcms_admin/page_list.html", &mut ctx)
3706}
3707
3708fn extract_inline_panel_rows(
3725 form: &std::collections::HashMap<String, String>,
3726 spec: &crate::page_type::InlinePanelSpec,
3727) -> Vec<serde_json::Map<String, serde_json::Value>> {
3728 let mut by_idx: std::collections::BTreeMap<usize, serde_json::Map<String, serde_json::Value>> =
3729 std::collections::BTreeMap::new();
3730 let prefix = format!("inline__{}__", spec.name);
3731 for (key, value) in form {
3732 let Some(rest) = key.strip_prefix(&prefix) else {
3733 continue;
3734 };
3735 let Some((idx_str, field_name)) = rest.split_once("__") else {
3736 continue;
3737 };
3738 let Ok(idx) = idx_str.parse::<usize>() else {
3739 continue;
3740 };
3741 if field_name == "__deleted" && value == "1" {
3742 by_idx.remove(&idx);
3743 let mut row = serde_json::Map::new();
3747 row.insert("__deleted".to_owned(), serde_json::Value::Bool(true));
3748 by_idx.insert(idx, row);
3749 continue;
3750 }
3751 if !spec.fields.iter().any(|f| f.name == field_name) {
3752 continue;
3753 }
3754 let row = by_idx.entry(idx).or_default();
3755 if row.contains_key("__deleted") {
3756 continue;
3757 }
3758 row.insert(
3759 field_name.to_owned(),
3760 serde_json::Value::String(value.clone()),
3761 );
3762 }
3763 by_idx
3764 .into_iter()
3765 .filter_map(|(_, row)| {
3766 if row.contains_key("__deleted") {
3767 None
3768 } else {
3769 Some(row)
3770 }
3771 })
3772 .collect()
3773}
3774
3775fn build_live_url_map(pages: &[Page]) -> std::collections::HashMap<String, String> {
3776 let mut by_id: std::collections::HashMap<String, String> = std::collections::HashMap::new();
3777 for p in pages {
3778 let Some(pid) = p.id.get().copied() else {
3779 continue;
3780 };
3781 let url = match p.parent_id {
3782 None => {
3783 if p.slug.is_empty() {
3784 "/".to_owned()
3785 } else {
3786 format!("/{}", p.slug)
3787 }
3788 }
3789 Some(parent_id) => {
3790 let parent_url = by_id
3791 .get(&parent_id.to_string())
3792 .cloned()
3793 .unwrap_or_else(|| "/".to_owned());
3794 if p.slug.is_empty() {
3795 parent_url
3796 } else if parent_url == "/" {
3797 format!("/{}", p.slug)
3798 } else {
3799 format!("{}/{}", parent_url, p.slug)
3800 }
3801 }
3802 };
3803 by_id.insert(pid.to_string(), url);
3806 }
3807 by_id
3808}
3809
3810#[derive(Debug, Deserialize)]
3825pub struct NewQuery {
3826 #[serde(default)]
3827 pub parent: Option<i64>,
3828 #[serde(default, rename = "type")]
3829 pub type_id: Option<i64>,
3830}
3831
3832pub async fn page_new_form(
3833 State(state): State<super::AdminState>,
3834 tenant: Tenant,
3835 headers: HeaderMap,
3836 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3837 Query(q): Query<NewQuery>,
3838) -> Result<Response, AdminError> {
3839 let all_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3840
3841 let (parent, allowed_types) = match q.parent {
3842 Some(pid) => {
3843 let parent_row = Page::objects()
3844 .where_(Page::id.eq(pid))
3845 .first(tenant.pool())
3846 .await?
3847 .ok_or(AdminError::NotFound(pid))?;
3848 let allowed = allowed_children_for(&parent_row, &all_types);
3849 (Some(parent_row), allowed)
3850 }
3851 None => (None, allowed_root_types(&all_types)),
3853 };
3854
3855 let Some(type_id) = q.type_id else {
3857 #[derive(serde::Serialize)]
3862 struct PickerType<'a> {
3863 id: i64,
3864 type_name: &'a str,
3865 verbose_name: &'a str,
3866 icon: Option<&'static str>,
3867 description: Option<&'static str>,
3868 }
3869 let allowed_enriched: Vec<PickerType<'_>> = allowed_types
3870 .iter()
3871 .map(|t| {
3872 let handler = find_handler(&t.type_name);
3873 PickerType {
3874 id: t.id.get().copied().unwrap_or_default(),
3875 type_name: t.type_name.as_str(),
3876 verbose_name: t.verbose_name.as_str(),
3877 icon: handler.as_ref().and_then(|h| h.icon()),
3878 description: handler.as_ref().and_then(|h| h.description()),
3879 }
3880 })
3881 .collect();
3882
3883 let mut ctx = Context::new();
3884 add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3885 add_admin_theme(&mut ctx, tenant.pool()).await;
3886 ctx.insert("parent", &parent);
3887 ctx.insert("allowed_types", &allowed_enriched);
3888 return render_with_csrf(
3889 &state,
3890 &headers,
3891 "rcms_admin/page_type_picker.html",
3892 &mut ctx,
3893 );
3894 };
3895
3896 let chosen_type = allowed_types
3901 .iter()
3902 .find(|t| t.id.get().copied() == Some(type_id))
3903 .cloned()
3904 .ok_or_else(|| {
3905 AdminError::Validation(format!(
3906 "page type {type_id} is not creatable under the chosen parent"
3907 ))
3908 })?;
3909
3910 let mut page_seed = empty_page_form_values();
3911 if let Some(obj) = page_seed.as_object_mut() {
3912 obj.insert("page_type_id".to_owned(), serde_json::json!(type_id));
3913 }
3914
3915 let mut ctx = Context::new();
3916 add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3917 add_admin_theme(&mut ctx, tenant.pool()).await;
3918 ctx.insert("mode", "new");
3919 ctx.insert("parent", &parent);
3920 ctx.insert("chosen_type", &chosen_type);
3921 ctx.insert("page", &page_seed);
3922 let review_required = !session_user.as_ref().is_some_and(|u| u.is_superuser)
3923 && crate::workflow::review_workflow_for_type(tenant.pool(), type_id).await?.is_some();
3924 ctx.insert("review_required", &review_required);
3925 ctx.insert("extra_tabs", &Vec::<crate::page_type::TabSpec>::new());
3929 let handler = find_handler(&chosen_type.type_name);
3932 let widgets = match &handler {
3933 Some(h) => h.widgets(tenant.pool(), 0).await.unwrap_or_default(),
3934 None => Vec::new(),
3935 };
3936 insert_type_fields(&mut ctx, &state.tera, tenant.pool(), handler.as_deref(), widgets, 0, type_id, None).await;
3937 ctx.insert(
3941 "picker_options",
3942 &crate::block::admin::picker_options(&state.tera),
3943 );
3944 ctx.insert("page_tags", &Vec::<String>::new());
3945 ctx.insert("page_tags_csv", "");
3946 ctx.insert("all_tags", &Vec::<serde_json::Value>::new());
3947 insert_category_choices(&mut ctx, tenant.pool(), None).await;
3948 render_with_csrf(&state, &headers, "rcms_admin/page_form.html", &mut ctx)
3949}
3950
3951pub(crate) fn slugify(raw: &str) -> String {
3960 let mut out = String::with_capacity(raw.len());
3961 let mut last_hyphen = true;
3962 for ch in raw.chars() {
3963 let c = ch.to_ascii_lowercase();
3964 if c.is_ascii_alphanumeric() {
3965 out.push(c);
3966 last_hyphen = false;
3967 } else if !last_hyphen {
3968 out.push('-');
3969 last_hyphen = true;
3970 }
3971 }
3972 while out.ends_with('-') {
3973 out.pop();
3974 }
3975 if out.len() > 60 {
3976 out.truncate(60);
3977 while out.ends_with('-') {
3978 out.pop();
3979 }
3980 }
3981 out
3982}
3983
3984pub(crate) async fn dedup_slug_under_parent(
3993 pool: &rustango::sql::Pool,
3994 parent_id: Option<i64>,
3995 candidate: &str,
3996) -> Result<String, AdminError> {
3997 let taken: std::collections::HashSet<String> = {
3998 let q = Page::objects();
3999 let rows = match parent_id {
4000 Some(pid) => q.where_(Page::parent_id.eq(pid)).fetch(pool).await?,
4001 None => q.where_(Page::parent_id.is_null()).fetch(pool).await?,
4002 };
4003 rows.into_iter().map(|p| p.slug).collect()
4004 };
4005
4006 if !taken.contains(candidate) {
4007 return Ok(candidate.to_owned());
4008 }
4009 let with_copy = format!("{candidate}-copy");
4010 if !taken.contains(&with_copy) {
4011 return Ok(with_copy);
4012 }
4013 for n in 2..50_u32 {
4014 let trial = format!("{candidate}-copy-{n}");
4015 if !taken.contains(&trial) {
4016 return Ok(trial);
4017 }
4018 }
4019 Err(AdminError::Validation(format!(
4020 "could not find a free slug for “{candidate}” after 50 -copy attempts"
4021 )))
4022}
4023
4024async fn front_page_taken(pool: &rustango::sql::Pool) -> Result<bool, AdminError> {
4026 use rustango::sql::CounterPool as _;
4027 let n = Page::objects()
4028 .where_(Page::parent_id.is_null())
4029 .where_(Page::slug.eq(String::new()))
4030 .count(pool)
4031 .await?;
4032 Ok(n > 0)
4033}
4034
4035async fn insert_category_choices(ctx: &mut tera::Context, pool: &rustango::sql::Pool, page_id: Option<i64>) {
4038 let (groups, checked) = match crate::category::assign::editor_groups(pool, page_id).await {
4039 Ok(v) => v,
4040 Err(e) => {
4041 tracing::warn!(error = %e, "category choices not loaded; the field is hidden");
4042 Default::default()
4043 }
4044 };
4045 ctx.insert("category_groups", &groups);
4046 ctx.insert("page_category_ids", &checked);
4047}
4048
4049pub async fn page_new_submit(
4054 State(_state): State<super::AdminState>,
4055 tenant: Tenant,
4056 headers: HeaderMap,
4057 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
4058 Form(form_map): Form<std::collections::HashMap<String, String>>,
4059) -> Result<Response, AdminError> {
4060 let form: PageForm = serde_urlencoded::from_str(
4063 &serde_urlencoded::to_string(&form_map).unwrap_or_default(),
4064 )
4065 .map_err(|e| AdminError::Validation(format!("page form: {e}")))?;
4066 if form.parent_id.is_none() {
4072 let types = PageType::objects().fetch(tenant.pool()).await?;
4073 if let Some(row) = types
4074 .iter()
4075 .find(|t| t.id.get().copied() == Some(form.page_type_id))
4076 {
4077 let parents = row.allowed_parents();
4078 if !parents.is_empty() {
4079 return Err(AdminError::Validation(format!(
4080 "`{}` can't be a root page — it may only be created under: {}",
4081 row.type_name,
4082 parents.join(", ")
4083 )));
4084 }
4085 }
4086 }
4087
4088 let mut effective_slug = if !form.slug.trim().is_empty() {
4092 slugify(&form.slug)
4093 } else if form.parent_id.is_none() && !front_page_taken(tenant.pool()).await? {
4094 String::new()
4095 } else {
4096 slugify(&form.title)
4097 };
4098 if !effective_slug.is_empty() {
4099 effective_slug =
4100 dedup_slug_under_parent(tenant.pool(), form.parent_id, &effective_slug).await?;
4101 }
4102
4103 let intended = derive_scheduled_status(form.parsed_status().as_str(), form.parsed_go_live_at());
4108 let mut held_back: Option<String> = None;
4109 if let Some(user) = session_user.as_ref().filter(|u| !u.is_superuser) {
4110 if crate::page::PageStatus::str_goes_live(crate::page::PageStatus::Draft.as_str(), &intended) {
4111 let uid = user.id.get().copied().unwrap_or_default();
4112 let req = super::route_perms::Requirement {
4113 codename: "cms_page.publish".to_owned(),
4114 page: form.parent_id.map(|pid| (pid, crate::permissions::Action::Publish)),
4115 };
4116 if let Some(wf) = crate::workflow::review_workflow_for_type(tenant.pool(), form.page_type_id).await? {
4117 held_back = Some(super::i18n::tr(
4118 &headers,
4119 "Saved as a draft: pages of this type go live after review (“{workflow}”). Click Submit for review.",
4120 &[("workflow", wf.name.as_str())],
4121 ));
4122 } else if !super::route_perms::allows_id(tenant.pool(), uid, false, &req).await {
4123 held_back = Some(super::i18n::tr(
4124 &headers,
4125 "Saved as a draft: you don't have permission to publish pages here.",
4126 &[],
4127 ));
4128 }
4129 }
4130 }
4131
4132 let new = NewPage::new(
4133 form.page_type_id,
4134 form.title.clone(),
4135 effective_slug.clone(),
4136 )
4137 .with_status(if held_back.is_some() { crate::page::PageStatus::Draft } else { form.parsed_status() })
4138 .with_seo(form.seo_title.clone(), form.seo_description.clone());
4139
4140 let mut page = match form.parent_id {
4141 Some(pid) => {
4142 let parent = Page::objects()
4143 .where_(Page::id.eq(pid))
4144 .first(tenant.pool())
4145 .await?
4146 .ok_or(AdminError::NotFound(pid))?;
4147 Page::create_child(&tenant, &parent, new).await?
4148 }
4149 None => Page::create_root(&tenant, new).await?,
4150 };
4151
4152 page.robots_index = form.parsed_robots_index();
4155 page.sitemap_priority = form.parsed_sitemap_priority();
4156 page.theme_id = form.theme_id.flatten();
4157 page.go_live_at = if held_back.is_some() { None } else { form.parsed_go_live_at() };
4160 page.expire_at = form.parsed_expire_at();
4161 page.status = derive_scheduled_status(&page.status, page.go_live_at);
4162 page.show_in_menus = form.parsed_show_in_menus();
4163 page.preview_path = form.preview_path.trim().to_owned();
4164 page.template_override = form.template_override.trim().to_owned();
4165 page.og_title = form.og_title.clone();
4167 page.og_description = form.og_description.clone();
4168 page.og_image_media_id = form.og_image_media_id;
4169 if let Some(tc) = form.twitter_card.as_deref() {
4170 if matches!(tc, "summary" | "summary_large_image") {
4171 page.twitter_card = tc.to_owned();
4172 }
4173 }
4174 page.save_pool(tenant.pool()).await?;
4175 let new_id = page.id.get().copied().unwrap_or_default();
4176 if let Some(raw) = form.tags.as_deref().filter(|t| !t.trim().is_empty()) {
4179 let names: Vec<String> = raw.split(',').map(str::to_owned).collect();
4180 crate::page_tag::replace_tags(tenant.pool(), new_id, &names).await?;
4181 }
4182 crate::category::assign::save_from_form(tenant.pool(), new_id, form.categories.as_deref()).await?;
4183 let page_type: Option<PageType> = PageType::objects()
4184 .where_(PageType::id.eq(page.page_type_id))
4185 .first(tenant.pool())
4186 .await?;
4187 save_type_content(tenant.pool(), page_type.as_ref(), page.page_type_id, new_id, &form_map).await?;
4188
4189 crate::revision::capture(tenant.pool(), &page, None)
4192 .await
4193 .log_warn("revision not captured; the history has a gap");
4194 reindex_from_form(tenant.pool(), &tenant.org.slug, new_id, &form_map).await;
4195
4196 let message = held_back.unwrap_or_else(|| {
4199 super::i18n::tr(&headers, "Created page “{title}”.", &[("title", page.title.as_str())])
4200 });
4201 redirect_after_page_save(
4202 &form.action,
4203 page.id.get().copied().unwrap_or_default(),
4204 page.parent_id,
4205 &message,
4206 &headers,
4207 )
4208}
4209
4210#[derive(Debug, Deserialize, Default)]
4215pub struct EditQuery {
4216 #[serde(default)]
4217 pub locale: Option<String>,
4218}
4219
4220pub async fn page_edit_form(
4221 State(state): State<super::AdminState>,
4222 tenant: Tenant,
4223 headers: HeaderMap,
4224 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
4225 Path(id): Path<i64>,
4226 Query(q): Query<EditQuery>,
4227) -> Result<Response, AdminError> {
4228 let page = Page::objects()
4229 .where_(Page::id.eq(id))
4230 .first(tenant.pool())
4231 .await?
4232 .ok_or(AdminError::NotFound(id))?;
4233
4234 if let Some(source_id) = page.alias_of {
4239 return redirect_named_with_params_and_message_args(
4240 "rcms-admin:pages:edit",
4241 &[("id", source_id.to_string())],
4242 MsgLevel::Info,
4243 "Editing the source — alias “{title}” shares content with this row.",
4244 &[("title", page.title.as_str())],
4245 &headers,
4246 );
4247 }
4248
4249 let locales: Vec<Locale> = Locale::objects()
4251 .where_(Locale::active.eq(true))
4252 .order_by(&[("is_default", false), ("code", false)])
4253 .fetch(tenant.pool())
4254 .await?;
4255 let editing_locale: Option<Locale> = match q.locale.as_deref() {
4256 Some(code) if !code.is_empty() => locales.iter().find(|l| l.code == code).cloned(),
4257 _ => None,
4258 };
4259 let translation_mode = editing_locale
4260 .as_ref()
4261 .map(|l| !l.is_default)
4262 .unwrap_or(false);
4263 let pending = crate::pending_change::for_page(tenant.pool(), id).await?;
4264 let existing_translations = if translation_mode {
4265 let lid = editing_locale
4266 .as_ref()
4267 .and_then(|l| l.id.get().copied())
4268 .unwrap_or(0);
4269 crate::translation::fetch_for(tenant.pool(), id, lid)
4270 .await
4271 .unwrap_or_default()
4272 } else {
4273 std::collections::HashMap::new()
4274 };
4275
4276 let themes_for_picker: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
4278 .order_by(&[("name", false)])
4279 .fetch(tenant.pool())
4280 .await?;
4281
4282 let chosen_type: PageType = PageType::objects()
4288 .where_(PageType::id.eq(page.page_type_id))
4289 .first(tenant.pool())
4290 .await?
4291 .ok_or_else(|| {
4292 AdminError::Validation(format!(
4293 "page_type_id {} on cms_page row has no cms_page_type row",
4294 page.page_type_id
4295 ))
4296 })?;
4297
4298 let ancestors = page.ancestors(tenant.pool()).await.unwrap_or_default();
4300 let mut segments: Vec<&str> = ancestors
4301 .iter()
4302 .filter(|a| !a.slug.is_empty())
4303 .map(|a| a.slug.as_str())
4304 .collect();
4305 if !page.slug.is_empty() {
4306 segments.push(page.slug.as_str());
4307 }
4308 let live_url = if segments.is_empty() {
4309 "/".to_owned()
4310 } else {
4311 format!("/{}", segments.join("/"))
4312 };
4313
4314 let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
4323 .where_(crate::revision::Revision::page_id.eq(id))
4324 .order_by(&[("sequence", true)]) .limit(20)
4326 .fetch(tenant.pool())
4327 .await?;
4328
4329 let core_fields = ["title", "seo_title", "seo_description"];
4334 let core_translations: std::collections::HashMap<String, String> = core_fields
4335 .iter()
4336 .map(|f| {
4337 (
4338 (*f).to_owned(),
4339 existing_translations.get(*f).cloned().unwrap_or_default(),
4340 )
4341 })
4342 .collect();
4343 let mut extra_translations: Vec<(String, String)> = existing_translations
4344 .iter()
4345 .filter(|(k, _)| !core_fields.contains(&k.as_str()))
4346 .map(|(k, v)| (k.clone(), v.clone()))
4347 .collect();
4348 extra_translations.sort_by(|a, b| a.0.cmp(&b.0));
4349
4350 let mut ctx = Context::new();
4351 add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
4352 add_admin_theme(&mut ctx, tenant.pool()).await;
4353 ctx.insert("mode", "edit");
4354 ctx.insert("parent", &Option::<Page>::None);
4355 ctx.insert("chosen_type", &chosen_type);
4356 ctx.insert("page", &page);
4357 ctx.insert("live_url", &live_url);
4358 let site_preview_base = match crate::preview_url::configured_base(tenant.pool()).await {
4371 Ok(base) => base,
4372 Err(e) => {
4373 tracing::warn!(
4374 target: "rustango_cms::admin",
4375 error = %e,
4376 "headless preview setting lookup failed",
4377 );
4378 None
4379 }
4380 };
4381 let headless_preview_url = if site_preview_base.is_some() || !page.preview_path.trim().is_empty()
4384 {
4385 let token = crate::preview_token::mint(
4386 &tenant.org.slug,
4387 id,
4388 chrono::Utc::now().timestamp() + PREVIEW_TOKEN_TTL_SECS,
4389 );
4390 crate::preview_url::for_page(
4391 site_preview_base.as_deref(),
4392 &page.preview_path,
4393 &token,
4394 id,
4395 &page.url_path,
4396 )
4397 } else {
4398 None
4399 };
4400 ctx.insert("headless_preview_url", &headless_preview_url);
4401 let ancestor_crumbs: Vec<serde_json::Value> = ancestors
4404 .iter()
4405 .map(|a| serde_json::json!({ "id": a.id.get().copied(), "title": a.title }))
4406 .collect();
4407 ctx.insert("ancestors", &ancestor_crumbs);
4408 ctx.insert(
4409 "parent_crumb",
4410 &ancestors
4411 .last()
4412 .map(|a| serde_json::json!({ "id": a.id.get().copied(), "title": a.title })),
4413 );
4414 ctx.insert(
4417 "plugin_page_action_menu_items",
4418 &crate::hooks::page_action_menu_items(id),
4419 );
4420 ctx.insert(
4422 "plugin_page_header_buttons",
4423 &crate::hooks::page_header_buttons(id),
4424 );
4425 let is_subscribed = match session_user.as_ref().and_then(|u| u.id.get().copied()) {
4429 Some(uid) => crate::page_subscription::is_subscribed(tenant.pool(), id, uid)
4430 .await
4431 .unwrap_or(false),
4432 None => false,
4433 };
4434 ctx.insert("is_subscribed", &is_subscribed);
4435 let page_tags: Vec<String> = crate::page_tag::tags_for_page(tenant.pool(), id)
4437 .await
4438 .unwrap_or_default()
4439 .into_iter()
4440 .map(|t| t.name)
4441 .collect();
4442 let page_tags_csv = page_tags.join(", ");
4443 ctx.insert("page_tags", &page_tags);
4444 ctx.insert("page_tags_csv", &page_tags_csv);
4445 let all_tags = crate::page_tag::all_tags(tenant.pool())
4446 .await
4447 .unwrap_or_default()
4448 .into_iter()
4449 .map(|(name, count)| serde_json::json!({ "name": name, "count": count }))
4450 .collect::<Vec<_>>();
4451 ctx.insert("all_tags", &all_tags);
4452 insert_category_choices(&mut ctx, tenant.pool(), Some(id)).await;
4453 let usage =
4457 crate::reference_index::usage_summary(tenant.pool(), crate::reference_index::KIND_PAGE, id)
4458 .await;
4459 ctx.insert("usage", &usage);
4460
4461 let a11y_violations = crate::a11y::check_page(&page, None);
4467 let (a11y_errors, a11y_warnings, a11y_infos) = crate::a11y::count_by_severity(&a11y_violations);
4468 ctx.insert("a11y_violations", &a11y_violations);
4469 ctx.insert("a11y_errors", &a11y_errors);
4470 ctx.insert("a11y_warnings", &a11y_warnings);
4471 ctx.insert("a11y_infos", &a11y_infos);
4472 let mut content_findings = crate::content_checks::run_all(&page);
4475 if content_findings.iter().any(|f| f.code == "missing_og_image")
4478 && crate::meta_tags::fallback_share_image(tenant.pool(), &page).await.is_some()
4479 {
4480 content_findings.retain(|f| f.code != "missing_og_image");
4481 }
4482 let (content_errors, content_warnings, content_infos) =
4483 crate::content_checks::count_by_severity(&content_findings);
4484 ctx.insert("content_findings", &content_findings);
4485 ctx.insert("content_errors", &content_errors);
4486 ctx.insert("content_warnings", &content_warnings);
4487 ctx.insert("content_infos", &content_infos);
4488 ctx.insert("revisions", &revisions);
4489
4490 let log_entries = crate::page_log::for_page(tenant.pool(), id, Some(100))
4494 .await
4495 .unwrap_or_default();
4496 let log_user_ids: std::collections::BTreeSet<i64> =
4497 log_entries.iter().filter_map(|e| e.actor_id).collect();
4498 let log_users: std::collections::HashMap<i64, String> = if log_user_ids.is_empty() {
4499 std::collections::HashMap::new()
4500 } else {
4501 rustango::tenancy::auth::User::objects()
4502 .where_(
4503 rustango::tenancy::auth::User::id
4504 .is_in(log_user_ids.into_iter().collect::<Vec<_>>()),
4505 )
4506 .fetch(tenant.pool())
4507 .await
4508 .unwrap_or_default()
4509 .into_iter()
4510 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
4511 .collect()
4512 };
4513 let log_view: Vec<serde_json::Value> = log_entries
4514 .iter()
4515 .map(|e| {
4516 serde_json::json!({
4517 "id": e.id.get().copied(),
4518 "action": e.action,
4519 "actor_id": e.actor_id,
4520 "actor_username": e.actor_id.and_then(|uid| log_users.get(&uid).cloned()),
4521 "message": e.message,
4522 "created_at": e.created_at.get().copied(),
4523 })
4524 })
4525 .collect();
4526 ctx.insert("page_log", &log_view);
4527
4528 ctx.insert("locales", &locales);
4529 ctx.insert("editing_locale", &editing_locale);
4530 ctx.insert("translation_mode", &translation_mode);
4531 ctx.insert("core_translations", &core_translations);
4532 ctx.insert("extra_translations", &extra_translations);
4533 ctx.insert("themes_for_picker", &themes_for_picker);
4534
4535 let resolved_handler: Option<Box<dyn crate::page_type::PageTypeHandler>> =
4545 find_handler(&chosen_type.type_name);
4546
4547 let preview_mode = {
4555 let kind = crate::page_view::kind_for(&chosen_type);
4556 let template_renders = !chosen_type.default_template.trim().is_empty()
4557 && state
4558 .tera
4559 .get_template_names()
4560 .any(|n| n == chosen_type.default_template);
4561 if kind.serves_json() && !kind.serves_html() {
4562 "json"
4563 } else if template_renders {
4564 "html"
4565 } else {
4566 "none"
4567 }
4568 };
4569 ctx.insert("preview_mode", preview_mode);
4570
4571 let raw_widgets: Vec<crate::widget::Widget> = match &resolved_handler {
4577 Some(h) => h.widgets(tenant.pool(), id).await.unwrap_or_default(),
4578 None => Vec::new(),
4579 };
4580
4581 let content_metrics =
4586 crate::metrics::analyze(&crate::metrics::collect_widget_text(&raw_widgets));
4587 ctx.insert("content_metrics", &content_metrics);
4588
4589 if translation_mode {
4596 let mut stream_translations: Vec<serde_json::Value> = Vec::new();
4597 let mut leaf_paths: std::collections::HashSet<String> = std::collections::HashSet::new();
4598 for w in &raw_widgets {
4599 if !matches!(w.kind, crate::widget::WidgetKind::Stream) {
4600 continue;
4601 }
4602 let base: serde_json::Value = serde_json::from_str(&w.value)
4603 .unwrap_or_else(|_| serde_json::Value::Array(Vec::new()));
4604 let leaves = crate::block::translate::collect_translatable_leaves(&w.name, &base);
4605 if leaves.is_empty() {
4606 continue;
4607 }
4608 let mut groups: Vec<serde_json::Value> = Vec::new();
4609 let mut cur_id = String::new();
4610 for leaf in &leaves {
4611 leaf_paths.insert(leaf.path.clone());
4612 let row = serde_json::json!({
4613 "path": leaf.path,
4614 "widget_kind": leaf.widget_kind.as_tag(),
4615 "field_label": leaf.field_label,
4616 "canonical": leaf.canonical_text,
4617 "canonical_html": translation_canonical_html(leaf.widget_kind.as_tag(), &leaf.canonical_text),
4618 "value": existing_translations.get(&leaf.path).cloned().unwrap_or_default(),
4619 });
4620 if leaf.block_id != cur_id {
4621 cur_id.clone_from(&leaf.block_id);
4622 groups.push(serde_json::json!({
4623 "block_type": leaf.block_type,
4624 "block_label": leaf.block_label,
4625 "block_id": leaf.block_id,
4626 "depth": leaf.depth,
4627 "leaves": [row],
4628 }));
4629 } else if let Some(arr) = groups
4630 .last_mut()
4631 .and_then(|g| g.get_mut("leaves"))
4632 .and_then(|v| v.as_array_mut())
4633 {
4634 arr.push(row);
4635 }
4636 }
4637 stream_translations.push(serde_json::json!({ "field": w.name, "label": w.label, "groups": groups }));
4638 }
4639 let field_rows: Vec<serde_json::Value> = raw_widgets
4645 .iter()
4646 .filter(|w| {
4647 use crate::widget::WidgetKind as K;
4648 matches!(w.kind, K::Text | K::Textarea | K::Markdown | K::RichText)
4649 && !w.name.starts_with(crate::page_builder::compile::FIELD_PREFIX)
4650 })
4651 .map(|w| {
4652 leaf_paths.insert(w.name.clone());
4653 serde_json::json!({
4654 "path": w.name,
4655 "widget_kind": w.kind.as_tag(),
4656 "field_label": w.label,
4657 "canonical": w.value,
4658 "canonical_html": translation_canonical_html(w.kind.as_tag(), &w.value),
4659 "value": existing_translations.get(&w.name).cloned().unwrap_or_default(),
4660 })
4661 })
4662 .collect();
4663 if !field_rows.is_empty() {
4664 stream_translations.insert(
4665 0,
4666 serde_json::json!({
4667 "field": "fields",
4668 "label": super::i18n::tr(&headers, "Fields", &[]),
4669 "groups": [{
4670 "block_type": "fields",
4671 "block_label": "",
4672 "block_id": "fields",
4673 "depth": 0,
4674 "leaves": field_rows,
4675 }],
4676 }),
4677 );
4678 }
4679 let (builder_groups, builder_paths) =
4683 builder_translation_groups(&tenant, id, page.page_type_id, &existing_translations)
4684 .await;
4685 if !builder_groups.is_empty() {
4686 leaf_paths.extend(builder_paths);
4687 stream_translations
4688 .push(serde_json::json!({
4689 "field": "builder",
4690 "label": super::i18n::tr(&headers, "Fields", &[]),
4691 "groups": builder_groups,
4692 }));
4693 }
4694 extra_translations.retain(|(k, _)| !leaf_paths.contains(k));
4698 ctx.insert("stream_translations", &stream_translations);
4699 ctx.insert("extra_translations", &extra_translations);
4700 }
4701
4702 let display_fields: Vec<crate::page_type::DisplayField> = match &resolved_handler {
4707 Some(h) => h
4708 .display_fields(tenant.pool(), id)
4709 .await
4710 .unwrap_or_default(),
4711 None => Vec::new(),
4712 };
4713 ctx.insert("display_fields", &display_fields);
4714
4715 let mut raw_extra_tabs: Vec<crate::page_type::TabSpec> = match &resolved_handler {
4719 Some(h) => h.extra_tabs(tenant.pool(), id).await.unwrap_or_default(),
4720 None => Vec::new(),
4721 };
4722
4723 let all_roles: Vec<rustango::tenancy::permissions::Role> =
4727 rustango::tenancy::permissions::Role::objects()
4728 .order_by(&[("name", false)])
4729 .fetch(tenant.pool())
4730 .await
4731 .unwrap_or_default();
4732
4733 {
4737 let grants: Vec<crate::permissions::PagePermission> =
4738 crate::permissions::PagePermission::objects()
4739 .where_(crate::permissions::PagePermission::page_id.eq(id))
4740 .fetch(tenant.pool())
4741 .await
4742 .unwrap_or_default();
4743 let granted: std::collections::HashSet<(i64, String)> = grants
4745 .iter()
4746 .map(|g| (g.role_id, g.permission.clone()))
4747 .collect();
4748 let actions: Vec<&str> = crate::permissions::Action::all()
4749 .iter()
4750 .map(|a| a.as_str())
4751 .collect();
4752 let perm_grid: Vec<serde_json::Value> = all_roles
4753 .iter()
4754 .map(|r| {
4755 let rid = r.id.get().copied().unwrap_or_default();
4756 let row_cells: Vec<serde_json::Value> = actions
4757 .iter()
4758 .map(|a| {
4759 serde_json::json!({
4760 "action": a,
4761 "granted": granted.contains(&(rid, (*a).to_owned())),
4762 })
4763 })
4764 .collect();
4765 serde_json::json!({
4766 "role_id": rid,
4767 "role_name": r.name,
4768 "role_description": r.description,
4769 "cells": row_cells,
4770 })
4771 })
4772 .collect();
4773 let perm_tab = crate::page_type::TabSpec::template(
4774 "permissions",
4775 "Permissions",
4776 "rcms_admin/_permissions_tab.html",
4777 )
4778 .with_icon("admin_panel_settings")
4779 .with_context_value(
4780 "perm_actions",
4781 serde_json::to_value(&actions).unwrap_or_default(),
4782 )
4783 .with_context_value(
4784 "perm_grid",
4785 serde_json::to_value(&perm_grid).unwrap_or_default(),
4786 )
4787 .with_context_value("perm_page_id", serde_json::Value::Number(id.into()));
4788 raw_extra_tabs.insert(0, perm_tab);
4789 }
4790 let extra_tabs: Vec<serde_json::Value> =
4798 render_extra_tabs(raw_extra_tabs, &state.tera, &ctx, &headers);
4799 ctx.insert("extra_tabs", &extra_tabs);
4800
4801 let pending_form = pending.as_ref().filter(|_| !translation_mode).map(crate::pending_change::PendingChange::form_map);
4803 insert_type_fields(
4804 &mut ctx,
4805 &state.tera,
4806 tenant.pool(),
4807 resolved_handler.as_deref(),
4808 raw_widgets,
4809 id,
4810 page.page_type_id,
4811 pending_form.as_ref(),
4812 )
4813 .await;
4814
4815 ctx.insert(
4819 "picker_options",
4820 &crate::block::admin::picker_options(&state.tera),
4821 );
4822
4823 let mut lock_banner: Option<serde_json::Value> = None;
4830 let mut lock_owned_by_me = false;
4831 let reviewing_elsewhere = match session_user.as_ref() {
4832 Some(u) => read_only_under_review(tenant.pool(), id, u).await?,
4833 None => false,
4834 };
4835 if let Some(viewer_id) = session_user
4836 .as_ref()
4837 .and_then(|u| u.id.get().copied())
4838 .filter(|_| !reviewing_elsewhere)
4839 {
4840 match crate::lock::acquire(tenant.pool(), id, viewer_id, false).await {
4841 Ok(crate::lock::AcquireOutcome::Acquired(_)) => {
4842 lock_owned_by_me = true;
4843 }
4844 Ok(crate::lock::AcquireOutcome::Held(other)) => {
4845 let holder_name = rustango::tenancy::auth::User::objects()
4846 .where_(rustango::tenancy::auth::User::id.eq(other.user_id))
4847 .fetch(tenant.pool())
4848 .await
4849 .ok()
4850 .and_then(|v| v.into_iter().next())
4851 .map(|u| u.username)
4852 .unwrap_or_else(|| format!("user#{}", other.user_id));
4853 lock_banner = Some(serde_json::json!({
4854 "holder_username": holder_name,
4855 "holder_id": other.user_id,
4856 "acquired_at": other.acquired_at.get().copied(),
4857 "expires_at": other.expires_at,
4858 }));
4859 }
4860 Err(e) => {
4861 tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "lock acquire failed");
4862 }
4863 }
4864 }
4865 ctx.insert("lock_banner", &lock_banner);
4866 ctx.insert("lock_owned_by_me", &lock_owned_by_me);
4867 ctx.insert("lock_heartbeat_secs", &crate::lock::HEARTBEAT_INTERVAL_SECS);
4868
4869 let workflow_slug: Option<String> = chosen_type.workflow_name();
4878 let mut workflow_ctx: Option<serde_json::Value> = None;
4879 let mut workflow_state_ctx: Option<serde_json::Value> = None;
4880 let mut workflow_current_task_ctx: Option<serde_json::Value> = None;
4881 let mut workflow_history_ctx: Vec<serde_json::Value> = Vec::new();
4882 let mut workflow_viewer_can_decide = false;
4883 if let Some(slug) = workflow_slug.as_deref() {
4884 let workflow = crate::workflow::find_by_name(tenant.pool(), slug)
4885 .await
4886 .unwrap_or(None);
4887 if let Some(wf) = workflow {
4888 let wf_id = wf.id.get().copied().unwrap_or_default();
4889 let tasks = crate::workflow::tasks_for(tenant.pool(), wf_id)
4890 .await
4891 .unwrap_or_default();
4892 workflow_ctx = Some(serde_json::json!({
4893 "id": wf_id,
4894 "name": wf.name,
4895 "description": wf.description,
4896 "task_count": tasks.len(),
4897 }));
4898 if let Some(state_row) = crate::workflow::latest_state_for_page(tenant.pool(), id)
4902 .await
4903 .unwrap_or(None)
4904 {
4905 let state_id = state_row.id.get().copied().unwrap_or_default();
4906 if let Some(current) = state_row
4908 .current_task_id
4909 .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
4910 {
4911 workflow_current_task_ctx = Some(serde_json::json!({
4912 "id": current.id.get().copied(),
4913 "name": current.name,
4914 "role_id": current.role_id,
4915 }));
4916 if let Some(viewer) = session_user.as_ref() {
4917 let viewer_id = viewer.id.get().copied().unwrap_or_default();
4918 workflow_viewer_can_decide = viewer.is_superuser
4919 || user_is_in_role(tenant.pool(), viewer_id, current.role_id)
4920 .await
4921 .unwrap_or(false);
4922 }
4923 }
4924 workflow_state_ctx = Some(serde_json::json!({
4925 "id": state_id,
4926 "status": state_row.status,
4927 "requested_by": state_row.requested_by,
4928 "requested_at": state_row.requested_at.get().copied(),
4929 "finished_at": state_row.finished_at,
4930 }));
4931 if let Ok(history) = crate::workflow::history_for_page(tenant.pool(), id).await {
4933 let reviewer_ids: Vec<i64> =
4935 history.iter().filter_map(|h| h.decided_by).collect();
4936 let reviewers: std::collections::HashMap<i64, String> =
4937 if reviewer_ids.is_empty() {
4938 std::collections::HashMap::new()
4939 } else {
4940 rustango::tenancy::auth::User::objects()
4941 .where_(rustango::tenancy::auth::User::id.is_in(reviewer_ids))
4942 .fetch(tenant.pool())
4943 .await
4944 .unwrap_or_default()
4945 .into_iter()
4946 .filter_map(|u| u.id.get().copied().map(|uid| (uid, u.username)))
4947 .collect()
4948 };
4949 let task_name_by_id: std::collections::HashMap<i64, String> = tasks
4950 .iter()
4951 .filter_map(|t| t.id.get().copied().map(|tid| (tid, t.name.clone())))
4952 .collect();
4953 workflow_history_ctx = history
4954 .iter()
4955 .map(|h| {
4956 serde_json::json!({
4957 "task_name": task_name_by_id
4958 .get(&h.task_id)
4959 .cloned()
4960 .unwrap_or_else(|| format!("task #{}", h.task_id)),
4961 "status": h.status,
4962 "comment": h.comment,
4963 "decided_by_username": h
4964 .decided_by
4965 .and_then(|uid| reviewers.get(&uid).cloned()),
4966 "decided_at": h.decided_at,
4967 })
4968 })
4969 .collect();
4970 }
4971 }
4972 }
4973 }
4974 let workflow_locked = workflow_state_ctx
4980 .as_ref()
4981 .and_then(|s| s.get("status"))
4982 .and_then(|v| v.as_str())
4983 .map(|s| s == crate::workflow::WorkflowStatus::InProgress.as_str())
4984 .unwrap_or(false)
4985 && !workflow_viewer_can_decide;
4986 ctx.insert("workflow_slug", &workflow_slug);
4987 ctx.insert("workflow", &workflow_ctx);
4988 ctx.insert("workflow_state", &workflow_state_ctx);
4989 ctx.insert("workflow_current_task", &workflow_current_task_ctx);
4990 ctx.insert("workflow_history", &workflow_history_ctx);
4991 ctx.insert("workflow_viewer_can_decide", &workflow_viewer_can_decide);
4992 ctx.insert("workflow_locked", &workflow_locked);
4993 let review_required = !session_user.as_ref().is_some_and(|u| u.is_superuser)
4994 && crate::workflow::review_workflow_for_type(tenant.pool(), page.page_type_id).await?.is_some();
4995 ctx.insert("review_required", &review_required);
4996 if let (Some(held), Some(form)) = (pending.as_ref(), pending_form.as_ref()) {
4997 ctx.insert("page", &overlay_pending_page(&page, form));
4998 let by = match held.created_by {
4999 Some(uid) => rustango::tenancy::auth::User::objects()
5000 .where_(rustango::tenancy::auth::User::id.eq(uid))
5001 .first(tenant.pool())
5002 .await?
5003 .map(|u| u.username),
5004 None => None,
5005 };
5006 ctx.insert(
5007 "pending_change",
5008 &serde_json::json!({ "by": by, "updated_at": held.updated_at.get().copied() }),
5009 );
5010 }
5011
5012 let view_restriction = crate::view_restriction::direct_for_page(tenant.pool(), id)
5014 .await
5015 .unwrap_or(None);
5016 let restriction_kind = view_restriction
5017 .as_ref()
5018 .map(|r| r.kind.clone())
5019 .unwrap_or_else(|| "none".to_owned());
5020 let restriction_groups = view_restriction
5021 .as_ref()
5022 .map(|r| r.parsed_groups())
5023 .unwrap_or_default();
5024 let restriction_groups_str = restriction_groups
5025 .iter()
5026 .map(i64::to_string)
5027 .collect::<Vec<_>>()
5028 .join(",");
5029 let role_choices: Vec<serde_json::Value> = all_roles
5032 .iter()
5033 .map(|r| {
5034 serde_json::json!({
5035 "id": r.id.get().copied(),
5036 "name": r.name,
5037 "checked": r.id.get().copied().is_some_and(|rid| restriction_groups.contains(&rid)),
5038 })
5039 })
5040 .collect();
5041 let restriction_codenames = view_restriction
5043 .as_ref()
5044 .map(|r| r.parsed_codenames())
5045 .unwrap_or_default();
5046 let restriction_codenames_str = restriction_codenames.join(",");
5047 let codename_choices: Vec<serde_json::Value> = super::resources::membership_codenames()
5048 .into_iter()
5049 .map(|(codename, label)| {
5050 serde_json::json!({
5051 "codename": codename,
5052 "label": label,
5053 "checked": restriction_codenames.contains(&codename),
5054 })
5055 })
5056 .collect();
5057 ctx.insert("restriction_kind", &restriction_kind);
5058 ctx.insert("restriction_groups_str", &restriction_groups_str);
5059 ctx.insert("restriction_role_choices", &role_choices);
5060 ctx.insert("restriction_codenames_str", &restriction_codenames_str);
5061 ctx.insert("restriction_codename_choices", &codename_choices);
5062 ctx.insert(
5063 "restriction_has_password",
5064 &view_restriction
5065 .as_ref()
5066 .map(|r| !r.password_hash.is_empty())
5067 .unwrap_or(false),
5068 );
5069
5070 let threads = crate::comment::threads_for_page(tenant.pool(), id)
5076 .await
5077 .unwrap_or_default();
5078 let thread_ids: Vec<i64> = threads.iter().filter_map(|c| c.id.get().copied()).collect();
5079 let replies_by_thread = crate::comment::replies_for_threads(tenant.pool(), &thread_ids)
5080 .await
5081 .unwrap_or_default();
5082 let mut comment_user_ids: std::collections::BTreeSet<i64> =
5083 threads.iter().map(|c| c.author_id).collect();
5084 for replies in replies_by_thread.values() {
5085 for r in replies {
5086 comment_user_ids.insert(r.author_id);
5087 }
5088 }
5089 let comment_users: std::collections::HashMap<i64, String> = if comment_user_ids.is_empty() {
5090 std::collections::HashMap::new()
5091 } else {
5092 rustango::tenancy::auth::User::objects()
5093 .where_(rustango::tenancy::auth::User::id.is_in(comment_user_ids.iter().copied()))
5094 .fetch(tenant.pool())
5095 .await
5096 .unwrap_or_default()
5097 .into_iter()
5098 .filter_map(|u| u.id.get().copied().map(|uid| (uid, u.username)))
5099 .collect()
5100 };
5101 let comment_threads: Vec<serde_json::Value> = threads
5102 .iter()
5103 .map(|c| {
5104 let tid = c.id.get().copied().unwrap_or_default();
5105 let replies = replies_by_thread.get(&tid).cloned().unwrap_or_default();
5106 let rendered_replies: Vec<serde_json::Value> = replies
5107 .iter()
5108 .map(|r| {
5109 serde_json::json!({
5110 "id": r.id.get().copied(),
5111 "author_username": comment_users.get(&r.author_id).cloned(),
5112 "body": r.body,
5113 "created_at": r.created_at.get().copied(),
5114 })
5115 })
5116 .collect();
5117 serde_json::json!({
5118 "id": tid,
5119 "field_path": c.field_path,
5120 "author_username": comment_users.get(&c.author_id).cloned(),
5121 "body": c.body,
5122 "created_at": c.created_at.get().copied(),
5123 "resolved_at": c.resolved_at,
5124 "replies": rendered_replies,
5125 "reply_count": replies.len(),
5126 })
5127 })
5128 .collect();
5129 ctx.insert("comment_threads", &comment_threads);
5130 ctx.insert(
5131 "comment_open_count",
5132 &comment_threads
5133 .iter()
5134 .filter(|t| t.get("resolved_at").map(|v| v.is_null()).unwrap_or(true))
5135 .count(),
5136 );
5137 ctx.insert(
5138 "comment_resolved_count",
5139 &comment_threads
5140 .iter()
5141 .filter(|t| t.get("resolved_at").map(|v| !v.is_null()).unwrap_or(false))
5142 .count(),
5143 );
5144 ctx.insert(
5146 "comment_field_choices",
5147 &serde_json::json!([
5148 {"value": "title", "label": "Title"},
5149 {"value": "slug", "label": "Slug"},
5150 {"value": "seo_title", "label": "SEO title"},
5151 {"value": "seo_description", "label": "SEO description"},
5152 {"value": "body", "label": "Body / stream content"},
5153 {"value": "general", "label": "General — whole page"},
5154 ]),
5155 );
5156
5157 render_with_csrf(&state, &headers, "rcms_admin/page_form.html", &mut ctx)
5158}
5159
5160pub async fn page_autosave_submit(
5174 State(_state): State<super::AdminState>,
5175 tenant: Tenant,
5176 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
5177 Path(id): Path<i64>,
5178 Form(form_map): Form<std::collections::HashMap<String, String>>,
5179) -> Result<Response, AdminError> {
5180 use rustango::sql::FetcherPool as _;
5181 let mut page = Page::objects()
5182 .where_(Page::id.eq(id))
5183 .first(tenant.pool())
5184 .await?
5185 .ok_or(AdminError::NotFound(id))?;
5186 if let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) {
5191 if let Ok(Some(lock)) = crate::lock::current(tenant.pool(), id).await {
5192 if lock.user_id != viewer_id {
5193 return Ok((axum::http::StatusCode::CONFLICT, "locked").into_response());
5194 }
5195 }
5196 }
5197 if page.status != crate::page::PageStatus::Draft.as_str() {
5202 return Ok((axum::http::StatusCode::NO_CONTENT, "").into_response());
5203 }
5204 if let Some(u) = session_user.as_ref() {
5205 if read_only_under_review(tenant.pool(), id, u).await? {
5206 return Ok((axum::http::StatusCode::CONFLICT, "under review").into_response());
5207 }
5208 }
5209 if let Some(v) = form_map.get("title") {
5216 page.title = v.clone();
5217 }
5218 if let Some(v) = form_map.get("seo_title") {
5219 page.seo_title = v.clone();
5220 }
5221 if let Some(v) = form_map.get("seo_description") {
5222 page.seo_description = v.clone();
5223 }
5224 let posted_status = form_map.get("status").cloned();
5228 page.save_pool(tenant.pool()).await?;
5229 let pts: Vec<PageType> = PageType::objects()
5231 .where_(PageType::id.eq(page.page_type_id))
5232 .fetch(tenant.pool())
5233 .await?;
5234 if let Some(pt) = pts.into_iter().next() {
5235 if let Some(handler) = find_handler(&pt.type_name) {
5236 let ext_form =
5237 sanitized_extension_form(handler.as_ref(), tenant.pool(), id, &form_map).await;
5238 handler.save_extension(tenant.pool(), id, &ext_form).await?;
5239 }
5240 }
5241 save_page_builder_values(tenant.pool(), page.page_type_id, id, &form_map).await?;
5243 let by = session_user.as_ref().and_then(|u| u.id.get().copied());
5246 if let Ok(mut rev) = crate::revision::capture(tenant.pool(), &page, by).await {
5247 if let serde_json::Value::Object(ref mut map) = rev.snapshot {
5251 map.insert("__autosave".to_owned(), serde_json::Value::Bool(true));
5252 if let Some(status) = posted_status {
5253 map.insert(
5254 "__autosave_posted_status".to_owned(),
5255 serde_json::Value::String(status),
5256 );
5257 }
5258 rev.save_pool(tenant.pool()).await.log_warn("autosave revision not stored");
5259 }
5260 }
5261 Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
5262}
5263
5264const PENDING_TEXT_KEYS: &[&str] = &[
5275 "title",
5276 "slug",
5277 "seo_title",
5278 "seo_description",
5279 "og_title",
5280 "og_description",
5281 "preview_path",
5282];
5283
5284fn overlay_pending_page(
5287 page: &Page,
5288 form: &std::collections::HashMap<String, String>,
5289) -> serde_json::Value {
5290 let mut value = serde_json::to_value(page).unwrap_or_default();
5291 if let Some(obj) = value.as_object_mut() {
5292 for key in PENDING_TEXT_KEYS {
5293 if let Some(v) = form.get(*key) {
5294 obj.insert((*key).to_owned(), serde_json::Value::String(v.clone()));
5295 }
5296 }
5297 }
5298 value
5299}
5300
5301fn overlay_pending_widgets(
5304 widgets: &mut [crate::widget::Widget],
5305 form: &std::collections::HashMap<String, String>,
5306) {
5307 for w in widgets {
5308 match form.get(&w.name) {
5309 Some(v) => w.value.clone_from(v),
5310 None if matches!(w.kind, crate::widget::WidgetKind::Boolean) => w.value.clear(),
5311 None => {}
5312 }
5313 }
5314}
5315
5316const PAGE_FORM_CANONICAL_KEYS: &[&str] = &[
5317 "title",
5318 "slug",
5319 "status",
5320 "seo_title",
5321 "seo_description",
5322 "robots_index",
5323 "sitemap_priority",
5324 "parent_id",
5325 "theme_id",
5326 "go_live_at",
5328 "expire_at",
5329 "show_in_menus",
5331 "preview_path",
5333 "template_override",
5335 "og_title",
5337 "og_description",
5338 "og_image_media_id",
5339 "twitter_card",
5340 "tags",
5342];
5343
5344pub(crate) struct PageEditActor {
5348 pub id: i64,
5349 pub username: String,
5350 pub is_superuser: bool,
5351}
5352
5353pub(crate) enum PageEditRefusal {
5357 WorkflowReview { task_name: String },
5359 LockedBy { holder: String },
5361 ArchivedUnpublish,
5363 PublishDenied,
5366 ReviewRequired { workflow: String },
5369}
5370
5371pub(crate) struct PageEditOutcome {
5373 pub page: Page,
5374 pub redirects_created: usize,
5375 pub reapproval_kicked: bool,
5376 pub held_for_review: bool,
5378}
5379
5380#[allow(clippy::too_many_arguments)]
5393pub(crate) async fn apply_page_edit(
5394 pool: &rustango::sql::Pool,
5395 org_slug: &str,
5396 invalidator: &std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator>,
5397 mailer: Option<&dyn rustango::email::Mailer>,
5398 mailer_from: &str,
5399 notify: bool,
5400 id: i64,
5401 form_map: &std::collections::HashMap<String, String>,
5402 actor: Option<&PageEditActor>,
5403) -> Result<Result<PageEditOutcome, PageEditRefusal>, AdminError> {
5404 if let Some(actor) = actor {
5410 if let Some(active) = crate::workflow::active_state_for_page(pool, id).await? {
5411 if active.status == crate::workflow::WorkflowStatus::InProgress.as_str()
5412 && !actor.is_superuser
5413 {
5414 let tasks = crate::workflow::tasks_for(pool, active.workflow_id).await?;
5415 if let Some(current_task) = active
5416 .current_task_id
5417 .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
5418 {
5419 if !user_is_in_role(pool, actor.id, current_task.role_id).await? {
5420 return Ok(Err(PageEditRefusal::WorkflowReview {
5421 task_name: current_task.name.clone(),
5422 }));
5423 }
5424 }
5425 }
5426 }
5427 }
5428
5429 if let Some(actor) = actor {
5436 match crate::lock::current(pool, id).await {
5437 Ok(Some(lock)) if lock.user_id != actor.id => {
5438 let holder = rustango::tenancy::auth::User::objects()
5439 .where_(rustango::tenancy::auth::User::id.eq(lock.user_id))
5440 .fetch(pool)
5441 .await
5442 .ok()
5443 .and_then(|v| v.into_iter().next())
5444 .map(|u| u.username)
5445 .unwrap_or_else(|| format!("user#{}", lock.user_id));
5446 return Ok(Err(PageEditRefusal::LockedBy { holder }));
5447 }
5448 _ => {}
5449 }
5450 }
5451
5452 let canonical_keys = PAGE_FORM_CANONICAL_KEYS;
5464 let mut canonical_only: std::collections::HashMap<&str, String> = form_map
5465 .iter()
5466 .filter(|(k, _)| canonical_keys.contains(&k.as_str()))
5467 .map(|(k, v)| (k.as_str(), v.clone()))
5468 .collect();
5469
5470 let mut page = Page::objects()
5471 .where_(Page::id.eq(id))
5472 .first(pool)
5473 .await?
5474 .ok_or(AdminError::NotFound(id))?;
5475
5476 let frozen_type_id = page.page_type_id.to_string();
5480 canonical_only.insert("page_type_id", frozen_type_id);
5481 let canonical_view: std::collections::HashMap<&str, &str> = canonical_only
5482 .iter()
5483 .map(|(k, v)| (*k, v.as_str()))
5484 .collect();
5485 let form: PageForm = serde_urlencoded::from_str(
5486 &serde_urlencoded::to_string(&canonical_view).unwrap_or_default(),
5487 )
5488 .map_err(|e| AdminError::Validation(format!("canonical form: {e}")))?;
5489
5490 if let Some(actor) = actor.filter(|a| !a.is_superuser) {
5495 if page.status == crate::page::PageStatus::Published.as_str() {
5496 if let Some(wf) = crate::workflow::review_workflow_for_type(pool, page.page_type_id)
5497 .await?
5498 .filter(|wf| wf.require_reapproval_on_edit)
5499 {
5500 crate::pending_change::hold(pool, id, form_map, Some(actor.id)).await?;
5501 let mut started = false;
5502 if crate::workflow::active_state_for_page(pool, id).await?.is_none() {
5503 let tasks =
5504 crate::workflow::tasks_for(pool, wf.id.get().copied().unwrap_or_default())
5505 .await?;
5506 crate::workflow::submit_for_review(pool, id, &wf, &tasks, actor.id).await?;
5507 started = true;
5508 }
5509 return Ok(Ok(PageEditOutcome {
5510 page,
5511 redirects_created: 0,
5512 reapproval_kicked: started,
5513 held_for_review: true,
5514 }));
5515 }
5516 }
5517 }
5518
5519 page.title = form.title.clone();
5520 let new_slug = if form.slug.trim().is_empty() {
5525 String::new()
5526 } else {
5527 slugify(&form.slug)
5528 };
5529 let slug_changed = page.slug != new_slug;
5530 if slug_changed && !new_slug.is_empty() {
5531 let sibling = Page::objects()
5532 .where_(Page::slug.eq(new_slug.clone()))
5533 .where_(Page::id.ne(id));
5534 let sibling = match page.parent_id {
5535 Some(pid) => sibling.where_(Page::parent_id.eq(pid)),
5536 None => sibling.where_(Page::parent_id.is_null()),
5537 };
5538 if sibling.first(pool).await?.is_some() {
5539 return Err(AdminError::Validation(format!(
5540 "another page under the same parent already uses the slug “{new_slug}”"
5541 )));
5542 }
5543 }
5544 let old_url_path = page.url_path.clone();
5548 page.slug = new_slug;
5549 let was_published = page.status == crate::page::PageStatus::Published.as_str();
5552 let was_archived = page.status == crate::page::PageStatus::Archived.as_str();
5556 let old_status = page.status.clone();
5557 page.status = form.parsed_status().as_str().to_owned();
5559 page.seo_title = form.seo_title.clone();
5560 page.seo_description = form.seo_description.clone();
5561 page.robots_index = form.parsed_robots_index();
5562 page.sitemap_priority = form.parsed_sitemap_priority();
5563 if let Some(theme_id) = form.theme_id {
5566 page.theme_id = theme_id;
5567 }
5568 let new_go_live = form.parsed_go_live_at();
5571 if page.go_live_at != new_go_live {
5572 page.notification_pre_published_sent = false;
5573 }
5574 page.go_live_at = new_go_live;
5575 page.expire_at = form.parsed_expire_at();
5576 page.status = derive_scheduled_status(&page.status, page.go_live_at);
5581 page.show_in_menus = form.parsed_show_in_menus();
5582 page.preview_path = form.preview_path.trim().to_owned();
5583 page.template_override = form.template_override.trim().to_owned();
5584 if page.status == crate::page::PageStatus::Published.as_str() {
5590 let now = chrono::Utc::now();
5591 if page.published_at.is_none() {
5592 page.published_at = Some(now);
5593 }
5594 page.last_published_at = Some(now);
5595 }
5596 if was_archived && page.status == crate::page::PageStatus::Draft.as_str() {
5600 return Ok(Err(PageEditRefusal::ArchivedUnpublish));
5601 }
5602 if let Some(actor) = actor {
5608 if crate::page::PageStatus::str_goes_live(&old_status, &page.status) {
5609 if !actor.is_superuser {
5614 if let Some(wf) = crate::workflow::review_workflow_for_type(pool, page.page_type_id).await? {
5615 return Ok(Err(PageEditRefusal::ReviewRequired { workflow: wf.name }));
5616 }
5617 }
5618 let req = super::route_perms::Requirement {
5619 codename: "cms_page.publish".to_owned(),
5620 page: Some((id, crate::permissions::Action::Publish)),
5621 };
5622 if !super::route_perms::allows_id(pool, actor.id, actor.is_superuser, &req).await {
5623 return Ok(Err(PageEditRefusal::PublishDenied));
5624 }
5625 }
5626 }
5627 page.og_title = form.og_title.clone();
5629 page.og_description = form.og_description.clone();
5630 page.og_image_media_id = form.og_image_media_id;
5631 if let Some(tc) = form.twitter_card.as_deref() {
5632 if matches!(tc, "summary" | "summary_large_image") {
5633 page.twitter_card = tc.to_owned();
5634 }
5635 }
5636
5637 if slug_changed {
5642 let parent_url_path = match page.parent_id {
5643 None => None,
5644 Some(pid) => Page::objects()
5645 .where_(Page::id.eq(pid))
5646 .first(pool)
5647 .await?
5648 .map(|p| p.url_path),
5649 };
5650 page.url_path = crate::tree_ops::compute_url_path(parent_url_path.as_deref(), &page.slug);
5651 }
5652 let new_url_path = page.url_path.clone();
5653
5654 let invalidator = invalidator.clone();
5661 let tenant_slug = org_slug.to_owned();
5662 let purge_new = new_url_path.clone();
5663 let purge_old = old_url_path.clone();
5664 let (page, descendant_urls) = crate::tree_ops::atomic_tree(pool, move |tx| {
5665 Box::pin(async move {
5666 page.save_tx(tx).await?;
5667 let descendants: Vec<Page> = if slug_changed {
5668 crate::tree_ops::cascade_url_path_to_descendants(tx, &page).await?;
5669 Page::objects()
5670 .where_(Page::path.like(crate::tree::descendants_like(&page.path)))
5671 .where_(Page::path.ne(page.path.clone()))
5672 .fetch_tx(tx)
5673 .await?
5674 } else {
5675 Vec::new()
5676 };
5677 if slug_changed {
5681 let public = |p: &Page| matches!(p.status.as_str(), "published" | "archived");
5682 let mut moves = Vec::with_capacity(1 + descendants.len());
5683 if public(&page) {
5684 moves.push((page.id.get().copied().unwrap_or_default(), purge_old.clone(), purge_new.clone()));
5685 }
5686 for d in descendants.iter().filter(|d| public(d)) {
5687 if let Some(old) = crate::redirect::rebase_path(&d.url_path, &purge_new, &purge_old) {
5688 moves.push((d.id.get().copied().unwrap_or_default(), old, d.url_path.clone()));
5689 }
5690 }
5691 crate::redirect::record_renames_tx(tx, &moves).await?;
5692 }
5693 let descendant_urls: Vec<String> = descendants.into_iter().map(|d| d.url_path).collect();
5694 let mut urls = Vec::with_capacity(2 + descendant_urls.len());
5695 urls.push(purge_new.clone());
5696 if slug_changed && purge_old != purge_new && !purge_old.is_empty() {
5697 urls.push(purge_old);
5698 }
5699 urls.extend(descendant_urls.iter().cloned());
5700 crate::cache_invalidate::invalidate_urls_on_commit(invalidator, tenant_slug, urls);
5701 Ok((page, descendant_urls))
5702 })
5703 })
5704 .await?;
5705 if let Some(tags_raw) = form_map.get("tags") {
5717 let names: Vec<String> = if tags_raw.is_empty() {
5718 Vec::new()
5719 } else {
5720 tags_raw.split(',').map(|s| s.to_owned()).collect()
5721 };
5722 crate::page_tag::replace_tags(pool, id, &names).await?;
5723 }
5724 crate::category::assign::save_from_form(
5726 pool,
5727 id,
5728 form_map.get(crate::category::assign::FORM_KEY).map(String::as_str),
5729 )
5730 .await?;
5731 let pt_opt: Option<PageType> = PageType::objects()
5732 .where_(PageType::id.eq(page.page_type_id))
5733 .first(pool)
5734 .await?;
5735 save_type_content(pool, pt_opt.as_ref(), page.page_type_id, id, form_map).await?;
5736
5737 crate::revision::capture(pool, &page, actor.map(|a| a.id))
5740 .await
5741 .log_warn("revision not captured; the history has a gap");
5742
5743 reindex_from_form(pool, org_slug, id, form_map).await;
5744
5745 crate::task_queue::sync_page_search(org_slug, &page).await;
5749
5750 let actor_id = actor.map(|a| a.id);
5752 if page.status == crate::page::PageStatus::Published.as_str() {
5753 crate::hooks::fire_after_publish_page(&page);
5754 if notify {
5756 let actor_name = actor.map(|a| a.username.as_str());
5757 crate::page_subscription::notify_publish(
5758 mailer,
5759 mailer_from,
5760 pool,
5761 org_slug,
5762 page.id.get().copied().unwrap_or_default(),
5763 &page.title,
5764 &page.url_path,
5765 actor_name,
5766 )
5767 .await;
5768 }
5769 crate::page_log::record_or_warn(
5771 pool,
5772 id,
5773 crate::page_log::ACTION_PUBLISH,
5774 actor_id,
5775 format!("Published “{}”.", page.title),
5776 None,
5777 )
5778 .await;
5779 } else {
5780 crate::page_log::record_or_warn(
5782 pool,
5783 id,
5784 crate::page_log::ACTION_EDIT,
5785 actor_id,
5786 format!("Edited “{}”.", page.title),
5787 Some(serde_json::json!({ "status": page.status })),
5788 )
5789 .await;
5790 }
5791
5792
5793 let mut redirects_created = 0usize;
5798 if slug_changed && old_url_path != new_url_path && !old_url_path.is_empty() {
5799 let new_prefix = if new_url_path == "/" {
5806 String::new()
5807 } else {
5808 new_url_path.clone()
5809 };
5810 let old_prefix = if old_url_path == "/" {
5811 String::new()
5812 } else {
5813 old_url_path.clone()
5814 };
5815 let mut pairs: Vec<(String, String)> = vec![(old_url_path.clone(), new_url_path.clone())];
5816 for new_d in &descendant_urls {
5817 if let Some(suffix) = new_d.strip_prefix(new_prefix.as_str()) {
5818 let old_d = format!("{old_prefix}{suffix}");
5819 if old_d != *new_d {
5820 pairs.push((old_d, new_d.clone()));
5821 }
5822 }
5823 }
5824 let now = chrono::Utc::now().to_rfc3339();
5830 for (old_path, new_path) in pairs {
5831 let existing: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
5833 .where_(crate::redirect::Redirect::from_path.eq(old_path.clone()))
5834 .fetch(pool)
5835 .await
5836 .unwrap_or_default();
5837 if let Some(mut r) = existing.into_iter().next() {
5838 if r.to_path != new_path {
5841 r.to_path = new_path.clone();
5842 r.is_permanent = true;
5843 r.note = format!("auto-updated on page rename at {now}");
5844 if r.from_page_id.is_none() {
5847 r.from_page_id = Some(id);
5848 }
5849 r.save_pool(pool).await.log_warn("redirect not linked to its source page");
5850 }
5851 continue;
5852 }
5853 let stale_chain: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
5857 .where_(crate::redirect::Redirect::to_path.eq(old_path.clone()))
5858 .fetch(pool)
5859 .await
5860 .unwrap_or_default();
5861 for mut r in stale_chain {
5862 if r.from_path == new_path {
5866 r.delete_pool(pool)
5867 .await
5868 .log_warn("self-redirect left after a rename back not deleted");
5869 continue;
5870 }
5871 r.to_path = new_path.clone();
5872 r.note = format!("auto-chained on page rename at {now}");
5873 r.save_pool(pool).await.log_warn("redirect chain not updated after a rename");
5874 }
5875 let mut row = crate::redirect::Redirect {
5877 id: rustango::sql::Auto::Unset,
5878 from_path: old_path,
5879 to_path: new_path,
5880 is_permanent: true,
5881 note: format!("auto-created on page rename at {now}"),
5882 hit_count: 0,
5883 overrides_live: false,
5884 from_page_id: Some(id),
5887 to_page_id: None,
5888 is_active: true,
5889 disabled_reason: String::new(),
5890 last_hit_at: None,
5891 created_at: rustango::sql::Auto::Unset,
5892 updated_at: rustango::sql::Auto::Unset,
5893 };
5894 if row.insert_pool(pool).await.is_ok() {
5895 redirects_created += 1;
5896 }
5897 }
5898 }
5899
5900 let mut reapproval_kicked = false;
5914 if let (Some(viewer_id), Some(pt)) = (actor.map(|a| a.id), pt_opt.as_ref()) {
5915 if let Some(slug) = pt.workflow_name() {
5916 if let Some(workflow) = crate::workflow::find_by_name(pool, &slug).await? {
5917 if workflow.require_reapproval_on_edit
5918 && crate::workflow::active_state_for_page(pool, id)
5919 .await?
5920 .is_none()
5921 && crate::workflow::has_prior_approval(pool, id).await?
5922 {
5923 let tasks = crate::workflow::tasks_for(
5924 pool,
5925 workflow.id.get().copied().unwrap_or_default(),
5926 )
5927 .await?;
5928 if !tasks.is_empty() {
5929 crate::workflow::submit_for_review(
5930 pool, id, &workflow, &tasks, viewer_id,
5931 )
5932 .await?;
5933 reapproval_kicked = true;
5934 }
5935 }
5936 }
5937 }
5938 }
5939
5940 let _ = (&new_url_path, slug_changed, &old_url_path, &descendant_urls);
5944 if was_published && page.status != crate::page::PageStatus::Published.as_str() {
5948 match crate::redirect::disable_for_page(
5949 pool,
5950 id,
5951 &format!("Linked page “{}” was unpublished", page.title),
5952 )
5953 .await
5954 {
5955 Ok(0) => {}
5956 Ok(n) => {
5957 tracing::info!(
5958 page_id = id,
5959 disabled = n,
5960 "disabled redirects for unpublished page"
5961 );
5962 }
5963 Err(e) => {
5964 tracing::warn!(page_id = id, error = %e, "failed to disable redirects for unpublished page");
5965 }
5966 }
5967 }
5968
5969 if actor.is_some() {
5972 crate::pending_change::discard(pool, id).await?;
5973 }
5974
5975 Ok(Ok(PageEditOutcome {
5976 page,
5977 redirects_created,
5978 reapproval_kicked,
5979 held_for_review: false,
5980 }))
5981}
5982
5983pub async fn page_edit_submit(
5984 State(_state): State<super::AdminState>,
5985 tenant: Tenant,
5986 headers: HeaderMap,
5987 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
5988 Path(id): Path<i64>,
5989 Form(form_map): Form<std::collections::HashMap<String, String>>,
5990) -> Result<Response, AdminError> {
5991 let actor = session_user.as_ref().map(|u| PageEditActor {
5992 id: u.id.get().copied().unwrap_or_default(),
5993 username: u.username.clone(),
5994 is_superuser: u.is_superuser,
5995 });
5996 let outcome = apply_page_edit(
5997 tenant.pool(),
5998 &tenant.org.slug,
5999 &_state.cache_invalidator,
6000 _state.mailer.as_deref(),
6001 &_state.mailer_from,
6002 true,
6003 id,
6004 &form_map,
6005 actor.as_ref(),
6006 )
6007 .await?;
6008 let PageEditOutcome {
6009 page,
6010 redirects_created,
6011 reapproval_kicked,
6012 held_for_review,
6013 } = match outcome {
6014 Ok(o) => o,
6015 Err(PageEditRefusal::WorkflowReview { task_name }) => {
6016 return redirect_named_with_params_and_message_args(
6017 "rcms-admin:pages:edit",
6018 &[("id", id.to_string())],
6019 MsgLevel::Error,
6020 "Couldn't save — page is under review on “{name}”. Only reviewers of that step can edit during review.",
6021 &[("name", task_name.as_str())],
6022 &headers,
6023 );
6024 }
6025 Err(PageEditRefusal::LockedBy { holder }) => {
6026 return redirect_named_with_params_and_message_args(
6027 "rcms-admin:pages:edit",
6028 &[("id", id.to_string())],
6029 MsgLevel::Error,
6030 "Couldn't save — “{holder}” is editing this page right now. Force-unlock to take over.",
6031 &[("holder", holder.as_str())],
6032 &headers,
6033 );
6034 }
6035 Err(PageEditRefusal::ArchivedUnpublish) => {
6036 return redirect_named_with_params_and_message_args(
6037 "rcms-admin:pages:edit",
6038 &[("id", id.to_string())],
6039 MsgLevel::Error,
6040 "Can't unpublish an archived page. Set it back to Published to unarchive, or delete it after unarchiving.",
6041 &[],
6042 &headers,
6043 );
6044 }
6045 Err(PageEditRefusal::PublishDenied) => {
6046 return redirect_named_with_params_and_message(
6047 "rcms-admin:pages:edit",
6048 &[("id", id.to_string())],
6049 MsgLevel::Error,
6050 "You don't have permission to publish this page — save it as a draft or submit it for review.",
6051 &headers,
6052 );
6053 }
6054 Err(PageEditRefusal::ReviewRequired { workflow }) => {
6055 return redirect_named_with_params_and_message_args(
6056 "rcms-admin:pages:edit",
6057 &[("id", id.to_string())],
6058 MsgLevel::Error,
6059 "Pages of this type go live after review (“{workflow}”). Save it as a draft and click Submit for review.",
6060 &[("workflow", workflow.as_str())],
6061 &headers,
6062 );
6063 }
6064 };
6065 if held_for_review {
6066 return redirect_after_page_save(
6067 form_map.get("_action").map_or("save", String::as_str),
6068 id,
6069 page.parent_id,
6070 &super::i18n::tr(
6071 &headers,
6072 "Your changes to “{title}” wait for review. Visitors see the live page until they are approved.",
6073 &[("title", page.title.as_str())],
6074 ),
6075 &headers,
6076 );
6077 }
6078 let mut message = if redirects_created > 0 {
6079 let count = redirects_created.to_string();
6080 super::i18n::tr_plural(
6081 &headers,
6082 "Saved “{title}”. Auto-created {count} redirect(s) from the old URL(s).",
6083 redirects_created as i64,
6084 &[("title", page.title.as_str()), ("count", count.as_str())],
6085 )
6086 } else {
6087 super::i18n::tr(
6088 &headers,
6089 "Saved “{title}”.",
6090 &[("title", page.title.as_str())],
6091 )
6092 };
6093 if reapproval_kicked {
6094 message.push(' ');
6095 message.push_str(&super::i18n::tr(
6096 &headers,
6097 "Workflow restarted — page enters review again.",
6098 &[],
6099 ));
6100 }
6101 redirect_after_page_save(
6102 form_map.get("_action").map_or("save", String::as_str),
6103 id,
6104 page.parent_id,
6105 &message,
6106 &headers,
6107 )
6108}
6109
6110pub(crate) async fn upsert_page_translations(
6126 pool: &rustango::sql::Pool,
6127 page_id: i64,
6128 locale_id: i64,
6129 updates: Vec<(String, String)>,
6130) -> Result<(), rustango::sql::ExecError> {
6131 rustango::atomic!(pool, |tx| {
6132 let mut guard = tx.lock().await?;
6133 let tx = &mut *guard;
6134 for (path, value) in updates {
6135 if value.is_empty() {
6136 let rows: Vec<crate::translation::Translation> =
6137 crate::translation::Translation::objects()
6138 .where_(crate::translation::Translation::page_id.eq(page_id))
6139 .where_(crate::translation::Translation::locale_id.eq(locale_id))
6140 .where_(crate::translation::Translation::field_path.eq(path.clone()))
6141 .fetch_tx(tx)
6142 .await?;
6143 for row in rows {
6144 row.delete_tx(tx).await?;
6145 }
6146 } else {
6147 let existing: Vec<crate::translation::Translation> =
6148 crate::translation::Translation::objects()
6149 .where_(crate::translation::Translation::page_id.eq(page_id))
6150 .where_(crate::translation::Translation::locale_id.eq(locale_id))
6151 .where_(crate::translation::Translation::field_path.eq(path.clone()))
6152 .fetch_tx(tx)
6153 .await?;
6154 if let Some(mut row) = existing.into_iter().next() {
6155 row.value = value;
6156 row.save_tx(tx).await?;
6157 } else {
6158 let mut row = crate::translation::Translation {
6159 id: rustango::sql::Auto::Unset,
6160 page_id,
6161 locale_id,
6162 field_path: path,
6163 value,
6164 updated_at: rustango::sql::Auto::Unset,
6165 };
6166 row.save_tx(tx).await?;
6167 }
6168 }
6169 }
6170 Ok::<_, rustango::sql::ExecError>(())
6171 })
6172 .await
6173}
6174
6175pub async fn page_translate_submit(
6176 State(_state): State<super::AdminState>,
6177 tenant: Tenant,
6178 Path(id): Path<i64>,
6179 Query(q): Query<EditQuery>,
6180 Form(form): Form<std::collections::HashMap<String, String>>,
6181) -> Result<Response, AdminError> {
6182 let code = q
6183 .locale
6184 .as_deref()
6185 .filter(|c| !c.is_empty())
6186 .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
6187 let locale = Locale::objects()
6188 .where_(Locale::code.eq(code.to_owned()))
6189 .where_(Locale::active.eq(true))
6190 .first(tenant.pool())
6191 .await?
6192 .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
6193 if locale.is_default {
6194 return Ok((
6195 axum::http::StatusCode::BAD_REQUEST,
6196 "cannot translate INTO the default locale; canonical content lives on cms_page",
6197 )
6198 .into_response());
6199 }
6200 let locale_id = locale
6201 .id
6202 .get()
6203 .copied()
6204 .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
6205 let _page = Page::objects()
6207 .where_(Page::id.eq(id))
6208 .first(tenant.pool())
6209 .await?
6210 .ok_or(AdminError::NotFound(id))?;
6211
6212 let mut updates: Vec<(String, String)> = Vec::new();
6216 for (k, v) in &form {
6217 if let Some(path) = k.strip_prefix("tr__") {
6218 if path.is_empty() {
6219 continue;
6220 }
6221 updates.push((path.to_owned(), v.clone()));
6222 }
6223 }
6224 let new_path = form
6225 .get("new_field_path")
6226 .map(|s| s.trim().to_owned())
6227 .unwrap_or_default();
6228 if !new_path.is_empty() {
6229 let new_value = form.get("new_field_value").cloned().unwrap_or_default();
6230 if let Ok(path) = crate::translation::validate_field_path(&new_path) {
6233 updates.push((path, new_value));
6234 }
6235 }
6236
6237 upsert_page_translations(tenant.pool(), id, locale_id, updates).await?;
6238
6239 let page = Page::objects()
6242 .where_(Page::id.eq(id))
6243 .first(tenant.pool())
6244 .await?
6245 .ok_or(AdminError::NotFound(id))?;
6246 let _ = (page, &code);
6250
6251 Ok(Redirect::to(&format!("/cms-admin/pages/{id}/edit?locale={code}")).into_response())
6252}
6253
6254pub async fn page_delete_submit(
6257 State(_state): State<super::AdminState>,
6258 tenant: Tenant,
6259 headers: HeaderMap,
6260 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6261 Path(id): Path<i64>,
6262) -> Result<Response, AdminError> {
6263 let page = Page::objects()
6264 .where_(Page::id.eq(id))
6265 .first(tenant.pool())
6266 .await?
6267 .ok_or(AdminError::NotFound(id))?;
6268
6269 if page.status == crate::page::PageStatus::Archived.as_str() {
6273 return redirect_named_with_message_args(
6274 "rcms-admin:pages:list",
6275 MsgLevel::Error,
6276 "Can't delete “{title}” while archived — unarchive it first.",
6277 &[("title", page.title.as_str())],
6278 &headers,
6279 );
6280 }
6281
6282 let child_count: Vec<Page> = Page::objects()
6283 .where_(Page::parent_id.eq(id))
6284 .fetch(tenant.pool())
6285 .await?;
6286 if !child_count.is_empty() {
6287 let count = child_count.len().to_string();
6288 return redirect_named_with_message_plural(
6289 "rcms-admin:pages:list",
6290 MsgLevel::Error,
6291 "Can't delete “{title}” — it has {count} child page(s). Delete or move them first.",
6292 child_count.len() as i64,
6293 &[("title", page.title.as_str()), ("count", count.as_str())],
6294 &headers,
6295 );
6296 }
6297
6298 let serving_hosts = crate::site::hosts_for_root(tenant.pool(), id).await?;
6304 if !serving_hosts.is_empty() {
6305 let hosts = serving_hosts.join(", ");
6306 return redirect_named_with_message_args(
6307 "rcms-admin:pages:list",
6308 MsgLevel::Error,
6309 "Can't delete “{title}” — it is the root served by {hosts}. Change that on the Sites screen first.",
6310 &[("title", page.title.as_str()), ("hosts", hosts.as_str())],
6311 &headers,
6312 );
6313 }
6314
6315 let aliases: Vec<Page> = Page::objects()
6322 .where_(Page::alias_of.eq(id))
6323 .fetch(tenant.pool())
6324 .await?;
6325 let alias_count = aliases.len();
6326 let title = page.title.clone();
6327 let url_path = page.url_path.clone();
6328
6329 let invalidator = _state.cache_invalidator.clone();
6337 let tenant_slug = tenant.org.slug.clone();
6338 let purge_url = url_path.clone();
6339 rustango::atomic!(tenant.pool(), |tx| {
6340 let mut guard = tx.lock().await?;
6341 let tx = &mut *guard;
6342 for mut alias in aliases {
6343 alias.alias_of = None;
6344 alias.title = page.title.clone();
6345 alias.seo_title = page.seo_title.clone();
6346 alias.seo_description = page.seo_description.clone();
6347 alias.status = page.status.clone();
6348 alias.published_at = page.published_at;
6349 alias.last_published_at = page.last_published_at;
6350 alias.theme_id = page.theme_id;
6351 alias.show_in_menus = page.show_in_menus;
6352 alias.save_tx(tx).await?;
6353 }
6354 crate::page_delete::clear_page_references_tx(tx, id).await?;
6357 page.delete_tx(tx).await?;
6358 crate::cache_invalidate::invalidate_urls_on_commit(
6359 invalidator,
6360 tenant_slug,
6361 vec![purge_url],
6362 );
6363 Ok(())
6364 })
6365 .await?;
6366 crate::task_queue::remove_page_search(&tenant.org.slug, id).await;
6369 if let Err(e) = crate::redirect::disable_for_page(
6372 tenant.pool(),
6373 id,
6374 &format!("Linked page “{title}” was deleted"),
6375 )
6376 .await
6377 {
6378 tracing::warn!(page_id = id, error = %e, "failed to disable redirects for deleted page");
6379 }
6380 if alias_count > 0 {
6381 redirect_named_with_message_plural(
6382 "rcms-admin:pages:list",
6383 MsgLevel::Success,
6384 "Deleted “{title}”. Promoted {count} alias(es) to standalone page(s) with the source's last content.",
6385 alias_count as i64,
6386 &[("title", title.as_str()), ("count", &alias_count.to_string())],
6387 &headers,
6388 )
6389 } else {
6390 redirect_named_with_message_args(
6391 "rcms-admin:pages:list",
6392 MsgLevel::Success,
6393 "Deleted “{title}”.",
6394 &[("title", title.as_str())],
6395 &headers,
6396 )
6397 }
6398}
6399
6400#[derive(Debug, Deserialize)]
6407pub struct MoveForm {
6408 pub new_parent: i64,
6412}
6413
6414pub async fn page_move_submit(
6418 State(_state): State<super::AdminState>,
6419 tenant: Tenant,
6420 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6421 Path(id): Path<i64>,
6422 Form(form): Form<MoveForm>,
6423) -> Result<Response, AdminError> {
6424 let mut page = Page::objects()
6425 .where_(Page::id.eq(id))
6426 .first(tenant.pool())
6427 .await?
6428 .ok_or(AdminError::NotFound(id))?;
6429 let new_parent: Option<Page> = if form.new_parent > 0 {
6430 Page::objects()
6431 .where_(Page::id.eq(form.new_parent))
6432 .first(tenant.pool())
6433 .await?
6434 } else {
6435 None
6436 };
6437 let old_url_path = page.url_path.clone();
6438 let old_descendant_urls: Vec<String> =
6439 page.descendants(tenant.pool()).await?.into_iter().map(|d| d.url_path).collect();
6440 page.move_to(&tenant, new_parent.as_ref()).await?;
6442 let new_url_path = page.url_path.clone();
6443
6444 let mut urls = old_descendant_urls;
6448 urls.push(old_url_path.clone());
6449 urls.push(new_url_path.clone());
6450 urls.extend(page.descendants(tenant.pool()).await?.into_iter().map(|d| d.url_path));
6451 let invalidator = _state.cache_invalidator.clone();
6452 let tenant_slug = tenant.org.slug.clone();
6453 rustango::__private_runtime::tokio::spawn(async move {
6454 crate::task_queue::purge_urls(invalidator, tenant_slug, urls).await;
6455 });
6456
6457 let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6459 crate::page_log::record_or_warn(
6460 tenant.pool(),
6461 id,
6462 crate::page_log::ACTION_MOVE,
6463 actor_id,
6464 format!(
6465 "Moved “{}” from {old_url_path} to {new_url_path}.",
6466 page.title
6467 ),
6468 Some(serde_json::json!({
6469 "old_url_path": old_url_path,
6470 "new_url_path": new_url_path,
6471 "new_parent_id": form.new_parent,
6472 })),
6473 )
6474 .await;
6475
6476 Ok((axum::http::StatusCode::OK, "ok").into_response())
6477}
6478
6479pub async fn page_clone_submit(
6497 State(state): State<super::AdminState>,
6498 tenant: Tenant,
6499 headers: HeaderMap,
6500 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6501 Path(id): Path<i64>,
6502) -> Result<Response, AdminError> {
6503 let source = Page::objects()
6504 .where_(Page::id.eq(id))
6505 .first(tenant.pool())
6506 .await?
6507 .ok_or(AdminError::NotFound(id))?;
6508
6509 let title = format!("{} (copy)", source.title);
6510 let base_slug = source.slug.trim_matches('-').to_owned();
6511 let slug = unique_sibling_slug(
6512 tenant.pool(),
6513 source.parent_id,
6514 &format!("{base_slug}-copy"),
6515 )
6516 .await?;
6517
6518 let new = crate::tree_ops::NewPage::new(source.page_type_id, title, slug)
6519 .with_status(crate::page::PageStatus::Draft)
6520 .with_seo(source.seo_title.clone(), source.seo_description.clone());
6521
6522 let clone = match source.parent_id {
6523 Some(pid) => {
6524 let parent = Page::objects()
6525 .where_(Page::id.eq(pid))
6526 .first(tenant.pool())
6527 .await?
6528 .ok_or(AdminError::NotFound(pid))?;
6529 Page::create_child(&tenant, &parent, new).await?
6530 }
6531 None => Page::create_root(&tenant, new).await?,
6532 };
6533 let new_id = clone.id.get().copied().unwrap_or_default();
6534
6535 let mut form = crate::page_form::prefill(tenant.pool(), &source).await;
6540 form.insert("title".into(), clone.title.clone());
6541 form.insert("slug".into(), clone.slug.clone());
6542 form.insert(
6543 "status".into(),
6544 crate::page::PageStatus::Draft.as_str().to_owned(),
6545 );
6546 form.remove("go_live_at");
6547 form.remove("expire_at");
6548 let actor = session_user.as_ref().map(|u| PageEditActor {
6549 id: u.id.get().copied().unwrap_or_default(),
6550 username: u.username.clone(),
6551 is_superuser: u.is_superuser,
6552 });
6553 let saved = apply_page_edit(
6554 tenant.pool(),
6555 &tenant.org.slug,
6556 &state.cache_invalidator,
6557 None,
6558 "",
6559 false,
6560 new_id,
6561 &form,
6562 actor.as_ref(),
6563 )
6564 .await?;
6565 if saved.is_err() {
6566 return Err(AdminError::Validation(
6568 "the copy was created but its content could not be saved".to_owned(),
6569 ));
6570 }
6571 let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6575 crate::page_log::record_or_warn(
6576 tenant.pool(),
6577 new_id,
6578 crate::page_log::ACTION_COPY,
6579 actor_id,
6580 format!("Cloned from “{}” (page #{id}).", source.title),
6581 Some(serde_json::json!({ "source_page_id": id })),
6582 )
6583 .await;
6584 crate::page_log::record_or_warn(
6585 tenant.pool(),
6586 id,
6587 crate::page_log::ACTION_COPY,
6588 actor_id,
6589 format!("Cloned to new draft page #{new_id}."),
6590 Some(serde_json::json!({ "clone_page_id": new_id })),
6591 )
6592 .await;
6593 redirect_named_with_params_and_message_args(
6594 "rcms-admin:pages:edit",
6595 &[("id", new_id.to_string())],
6596 MsgLevel::Success,
6597 "Cloned “{title}” as a draft. Review before publishing.",
6598 &[("title", source.title.as_str())],
6599 &headers,
6600 )
6601}
6602
6603#[derive(Deserialize)]
6609pub struct PrivacyForm {
6610 pub kind: String,
6611 #[serde(default)]
6612 pub password: String,
6613 #[serde(default)]
6614 pub group_ids: String,
6615 #[serde(default)]
6618 pub codenames: String,
6619}
6620
6621pub async fn page_privacy_submit(
6622 State(_state): State<super::AdminState>,
6623 tenant: Tenant,
6624 headers: HeaderMap,
6625 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6626 Path(id): Path<i64>,
6627 Form(form): Form<PrivacyForm>,
6628) -> Result<Response, AdminError> {
6629 use rustango::sql::Auto;
6630 let existing = crate::view_restriction::direct_for_page(tenant.pool(), id).await?;
6631 if form.kind == "none" {
6632 if let Some(row) = existing {
6633 row.delete_pool(tenant.pool()).await?;
6634 return redirect_named_with_params_and_message(
6635 "rcms-admin:pages:edit",
6636 &[("id", id.to_string())],
6637 MsgLevel::Success,
6638 "Removed view restriction — page is now public.",
6639 &headers,
6640 );
6641 }
6642 return redirect_named_with_params_and_message(
6643 "rcms-admin:pages:edit",
6644 &[("id", id.to_string())],
6645 MsgLevel::Info,
6646 "No restriction to remove.",
6647 &headers,
6648 );
6649 }
6650 let Some(kind) = crate::view_restriction::RestrictionKind::parse(&form.kind) else {
6651 return Err(AdminError::Validation(format!(
6652 "unknown restriction kind `{}`",
6653 form.kind
6654 )));
6655 };
6656 let password_hash = match kind {
6657 crate::view_restriction::RestrictionKind::Password => {
6658 if form.password.is_empty() {
6663 if let Some(row) = &existing {
6664 if row.kind == kind.as_str() {
6665 row.password_hash.clone()
6666 } else {
6667 return redirect_named_with_params_and_message(
6668 "rcms-admin:pages:edit",
6669 &[("id", id.to_string())],
6670 MsgLevel::Error,
6671 "Password is required when switching the restriction kind to password.",
6672 &headers,
6673 );
6674 }
6675 } else {
6676 return redirect_named_with_params_and_message(
6677 "rcms-admin:pages:edit",
6678 &[("id", id.to_string())],
6679 MsgLevel::Error,
6680 "Password is required for password-protected pages.",
6681 &headers,
6682 );
6683 }
6684 } else {
6685 crate::passwords::hash(&form.password).await
6686 .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?
6687 }
6688 }
6689 _ => String::new(),
6690 };
6691 let group_ids: Vec<i64> = if matches!(kind, crate::view_restriction::RestrictionKind::Groups) {
6692 form.group_ids
6693 .split(',')
6694 .filter_map(|s| s.trim().parse::<i64>().ok())
6695 .collect()
6696 } else {
6697 Vec::new()
6698 };
6699 let group_json = serde_json::json!(group_ids);
6700 let codenames: Vec<String> =
6701 if matches!(kind, crate::view_restriction::RestrictionKind::Permission) {
6702 form.codenames
6703 .split(',')
6704 .map(str::trim)
6705 .filter(|s| !s.is_empty())
6706 .map(str::to_owned)
6707 .collect()
6708 } else {
6709 Vec::new()
6710 };
6711 let codenames_json = serde_json::json!(codenames);
6712 match existing {
6713 Some(mut row) => {
6714 row.kind = kind.as_str().to_owned();
6715 row.password_hash = password_hash;
6716 row.group_ids = group_json;
6717 row.codenames = codenames_json;
6718 row.save_pool(tenant.pool()).await?;
6719 }
6720 None => {
6721 let mut row = crate::view_restriction::PageViewRestriction {
6722 id: Auto::Unset,
6723 page_id: id,
6724 kind: kind.as_str().to_owned(),
6725 password_hash,
6726 group_ids: group_json,
6727 codenames: codenames_json,
6728 created_at: Auto::Unset,
6729 updated_at: Auto::Unset,
6730 };
6731 row.insert_pool(tenant.pool()).await?;
6732 }
6733 }
6734 redirect_named_with_params_and_message_args(
6735 "rcms-admin:pages:edit",
6736 &[("id", id.to_string())],
6737 MsgLevel::Success,
6738 match kind {
6739 crate::view_restriction::RestrictionKind::Login => "Only signed-in people can see this page now.",
6740 crate::view_restriction::RestrictionKind::Groups => "Only the chosen roles can see this page now.",
6741 crate::view_restriction::RestrictionKind::Permission => "Only people with the chosen permissions can see this page now.",
6742 crate::view_restriction::RestrictionKind::Password => "This page asks for a password now.",
6743 },
6744 &[],
6745 &headers,
6746 )
6747}
6748
6749#[derive(Debug, Deserialize)]
6754pub struct CommentNewForm {
6755 pub field_path: String,
6756 pub body: String,
6757}
6758
6759pub async fn comment_new_submit(
6760 State(_state): State<super::AdminState>,
6761 tenant: Tenant,
6762 headers: HeaderMap,
6763 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6764 Path(id): Path<i64>,
6765 Form(form): Form<CommentNewForm>,
6766) -> Result<Response, AdminError> {
6767 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6768 return Ok(unauthorized_no_session());
6769 };
6770 let body = form.body.trim();
6771 let field_path = form.field_path.trim();
6772 if body.is_empty() || field_path.is_empty() {
6773 return redirect_named_with_params_and_message(
6774 "rcms-admin:pages:edit",
6775 &[("id", id.to_string())],
6776 MsgLevel::Warning,
6777 "Comment body and field are both required.",
6778 &headers,
6779 );
6780 }
6781 let mut row = crate::comment::Comment {
6782 id: rustango::sql::Auto::Unset,
6783 page_id: id,
6784 field_path: field_path.to_owned(),
6785 author_id: viewer_id,
6786 body: body.to_owned(),
6787 resolved_at: None,
6788 resolved_by: None,
6789 created_at: rustango::sql::Auto::Unset,
6790 };
6791 row.insert_pool(tenant.pool()).await?;
6792 redirect_named_with_params_and_message(
6793 "rcms-admin:pages:edit",
6794 &[("id", id.to_string())],
6795 MsgLevel::Success,
6796 "Comment posted.",
6797 &headers,
6798 )
6799}
6800
6801#[derive(Debug, Deserialize)]
6802pub struct CommentReplyForm {
6803 pub body: String,
6804}
6805
6806pub async fn comment_reply_submit(
6807 State(_state): State<super::AdminState>,
6808 tenant: Tenant,
6809 headers: HeaderMap,
6810 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6811 Path((id, comment_id)): Path<(i64, i64)>,
6812 Form(form): Form<CommentReplyForm>,
6813) -> Result<Response, AdminError> {
6814 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6815 return Ok(unauthorized_no_session());
6816 };
6817 let body = form.body.trim();
6818 if body.is_empty() {
6819 return redirect_named_with_params_and_message(
6820 "rcms-admin:pages:edit",
6821 &[("id", id.to_string())],
6822 MsgLevel::Warning,
6823 "Reply body is required.",
6824 &headers,
6825 );
6826 }
6827 let mut row = crate::comment::CommentReply {
6828 id: rustango::sql::Auto::Unset,
6829 comment_id,
6830 author_id: viewer_id,
6831 body: body.to_owned(),
6832 created_at: rustango::sql::Auto::Unset,
6833 };
6834 row.insert_pool(tenant.pool()).await?;
6835 redirect_named_with_params_and_message(
6836 "rcms-admin:pages:edit",
6837 &[("id", id.to_string())],
6838 MsgLevel::Success,
6839 "Reply posted.",
6840 &headers,
6841 )
6842}
6843
6844pub async fn comment_resolve_submit(
6845 State(_state): State<super::AdminState>,
6846 tenant: Tenant,
6847 headers: HeaderMap,
6848 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6849 Path((id, comment_id)): Path<(i64, i64)>,
6850) -> Result<Response, AdminError> {
6851 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6852 return Ok(unauthorized_no_session());
6853 };
6854 let mut row = crate::comment::Comment::objects()
6855 .where_(crate::comment::Comment::id.eq(comment_id))
6856 .where_(crate::comment::Comment::page_id.eq(id))
6857 .first(tenant.pool())
6858 .await?
6859 .ok_or(AdminError::NotFound(comment_id))?;
6860 row.resolved_at = Some(chrono::Utc::now());
6861 row.resolved_by = Some(viewer_id);
6862 row.save_pool(tenant.pool()).await?;
6863 redirect_named_with_params_and_message(
6864 "rcms-admin:pages:edit",
6865 &[("id", id.to_string())],
6866 MsgLevel::Success,
6867 "Comment resolved.",
6868 &headers,
6869 )
6870}
6871
6872pub async fn comment_reopen_submit(
6873 State(_state): State<super::AdminState>,
6874 tenant: Tenant,
6875 headers: HeaderMap,
6876 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6877 Path((id, comment_id)): Path<(i64, i64)>,
6878) -> Result<Response, AdminError> {
6879 let mut row = crate::comment::Comment::objects()
6880 .where_(crate::comment::Comment::id.eq(comment_id))
6881 .where_(crate::comment::Comment::page_id.eq(id))
6882 .first(tenant.pool())
6883 .await?
6884 .ok_or(AdminError::NotFound(comment_id))?;
6885 row.resolved_at = None;
6886 row.resolved_by = None;
6887 row.save_pool(tenant.pool()).await?;
6888 redirect_named_with_params_and_message(
6889 "rcms-admin:pages:edit",
6890 &[("id", id.to_string())],
6891 MsgLevel::Info,
6892 "Comment reopened.",
6893 &headers,
6894 )
6895}
6896
6897pub async fn page_alias_submit(
6911 State(state): State<super::AdminState>,
6912 tenant: Tenant,
6913 headers: HeaderMap,
6914 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6915 Path(id): Path<i64>,
6916) -> Result<Response, AdminError> {
6917 let source = Page::objects()
6918 .where_(Page::id.eq(id))
6919 .first(tenant.pool())
6920 .await?
6921 .ok_or(AdminError::NotFound(id))?;
6922
6923 if let Some(src_id) = source.alias_of {
6927 let src_id_str = src_id.to_string();
6928 return redirect_named_with_params_and_message_args(
6929 "rcms-admin:pages:edit",
6930 &[("id", id.to_string())],
6931 MsgLevel::Error,
6932 "Can't alias an alias — point your new alias at the underlying source page (#{source_id}) instead.",
6933 &[("source_id", src_id_str.as_str())],
6934 &headers,
6935 );
6936 }
6937
6938 let base_slug = source.slug.trim_matches('-').to_owned();
6939 let slug = unique_sibling_slug(
6940 tenant.pool(),
6941 source.parent_id,
6942 &if base_slug.is_empty() {
6943 "alias".to_owned()
6944 } else {
6945 format!("{base_slug}-alias")
6946 },
6947 )
6948 .await?;
6949
6950 let new = crate::tree_ops::NewPage::new(source.page_type_id, source.title.clone(), slug)
6954 .with_status(crate::page::PageStatus::Draft)
6955 .with_seo(source.seo_title.clone(), source.seo_description.clone());
6956
6957 let mut alias = match source.parent_id {
6958 Some(pid) => {
6959 let parent = Page::objects()
6960 .where_(Page::id.eq(pid))
6961 .first(tenant.pool())
6962 .await?
6963 .ok_or(AdminError::NotFound(pid))?;
6964 Page::create_child(&tenant, &parent, new).await?
6965 }
6966 None => Page::create_root(&tenant, new).await?,
6967 };
6968 alias.alias_of = Some(id);
6969 alias.status = source.status.clone();
6974 alias.published_at = source.published_at;
6975 alias.last_published_at = source.last_published_at;
6976 alias.theme_id = source.theme_id;
6977 alias.show_in_menus = source.show_in_menus;
6978 alias.save_pool(tenant.pool()).await?;
6979
6980 crate::revision::capture(tenant.pool(), &alias, None)
6981 .await
6982 .log_warn("revision not captured; the history has a gap");
6983 let new_id = alias.id.get().copied().unwrap_or_default();
6984 let _ = state;
6985 let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6987 crate::page_log::record_or_warn(
6988 tenant.pool(),
6989 new_id,
6990 crate::page_log::ACTION_ALIAS_CREATE,
6991 actor_id,
6992 format!("Alias of “{}” (page #{id}).", source.title),
6993 Some(serde_json::json!({ "alias_of": id })),
6994 )
6995 .await;
6996 crate::page_log::record_or_warn(
6997 tenant.pool(),
6998 id,
6999 crate::page_log::ACTION_ALIAS_CREATE,
7000 actor_id,
7001 format!("New alias #{new_id} pointing here."),
7002 Some(serde_json::json!({ "alias_page_id": new_id })),
7003 )
7004 .await;
7005 redirect_named_with_params_and_message_args(
7006 "rcms-admin:pages:list",
7007 &[],
7012 MsgLevel::Success,
7013 "Created alias of “{title}”. Edits to the source will propagate to every alias's URL.",
7014 &[("title", source.title.as_str())],
7015 &headers,
7016 )
7017}
7018
7019fn copy_fields_for(p: &Page) -> Vec<(&'static str, String)> {
7024 copy_translatable_fields(&p.title, &p.seo_title, &p.seo_description)
7025}
7026
7027fn copy_translatable_fields(
7031 title: &str,
7032 seo_title: &str,
7033 seo_description: &str,
7034) -> Vec<(&'static str, String)> {
7035 [
7036 ("title", title),
7037 ("seo_title", seo_title),
7038 ("seo_description", seo_description),
7039 ]
7040 .into_iter()
7041 .filter(|(_, v)| !v.trim().is_empty())
7042 .map(|(k, v)| (k, v.to_owned()))
7043 .collect()
7044}
7045
7046pub async fn page_bulk_submit(
7067 State(_state): State<super::AdminState>,
7068 tenant: Tenant,
7069 headers: HeaderMap,
7070 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7071 Form(form): Form<Vec<(String, String)>>,
7072) -> Result<Response, AdminError> {
7073 let action = form
7074 .iter()
7075 .find(|(k, _)| k == "action")
7076 .map(|(_, v)| v.clone())
7077 .unwrap_or_default();
7078 let ids: Vec<i64> = form
7079 .iter()
7080 .filter(|(k, _)| k == "ids" || k == "id")
7081 .filter_map(|(_, v)| v.parse::<i64>().ok())
7082 .collect();
7083 let new_parent_raw = form
7084 .iter()
7085 .find(|(k, _)| k == "new_parent")
7086 .and_then(|(_, v)| v.parse::<i64>().ok());
7087 let archive_cascade = form.iter().any(|(k, v)| {
7090 k == "archive_cascade" && matches!(v.as_str(), "1" | "on" | "subtree" | "true")
7091 });
7092
7093 if action.is_empty() || ids.is_empty() {
7094 return redirect_named_with_message(
7095 "rcms-admin:pages:list",
7096 MsgLevel::Warning,
7097 "Pick at least one row + an action before submitting.",
7098 &headers,
7099 );
7100 }
7101
7102 let pool = tenant.pool();
7107 let pages: Vec<Page> = {
7108 let mut out = Vec::with_capacity(ids.len());
7109 for id in &ids {
7110 if let Some(p) = Page::objects().where_(Page::id.eq(*id)).first(pool).await? {
7111 out.push(p);
7112 }
7113 }
7114 out
7115 };
7116 if pages.is_empty() {
7117 return redirect_named_with_message(
7118 "rcms-admin:pages:list",
7119 MsgLevel::Warning,
7120 "None of the selected ids matched a live page.",
7121 &headers,
7122 );
7123 }
7124
7125 let needs = match action.as_str() {
7128 "publish" | "unpublish" => crate::permissions::Action::Publish,
7129 "delete" => crate::permissions::Action::Delete,
7130 _ => crate::permissions::Action::Edit,
7131 };
7132 if let Some(user) = session_user.as_ref() {
7133 for p in &pages {
7134 let req = super::route_perms::Requirement {
7135 codename: format!("cms_page.{}", needs.as_str()),
7136 page: p.id.get().copied().map(|id| (id, needs)),
7137 };
7138 if !super::route_perms::allows(pool, user, &req).await {
7139 return redirect_named_with_message_args(
7140 "rcms-admin:pages:list",
7141 MsgLevel::Error,
7142 "You don't have permission to {action} “{title}”.",
7143 &[("action", action.as_str()), ("title", p.title.as_str())],
7144 &headers,
7145 );
7146 }
7147 }
7148 }
7149
7150 match action.as_str() {
7151 "publish" | "unpublish" => {
7152 let target = if action == "publish" {
7153 crate::page::PageStatus::Published
7154 } else {
7155 crate::page::PageStatus::Draft
7156 };
7157 let invalidator = _state.cache_invalidator.clone();
7158 let tenant_slug = tenant.org.slug.clone();
7159 let purge_urls: Vec<String> = pages.iter().map(|p| p.url_path.clone()).collect();
7160 let pages_for_tx = pages.clone();
7161 let touched = rustango::atomic!(pool, |tx| {
7165 let mut guard = tx.lock().await?;
7166 let tx = &mut *guard;
7167 let mut touched = 0usize;
7168 for mut p in pages_for_tx {
7169 if matches!(target, crate::page::PageStatus::Draft)
7173 && p.status == crate::page::PageStatus::Archived.as_str()
7174 {
7175 continue;
7176 }
7177 if p.status != target.as_str() {
7178 p.status = target.as_str().to_owned();
7179 if matches!(target, crate::page::PageStatus::Published) {
7180 let now = chrono::Utc::now();
7181 if p.published_at.is_none() {
7182 p.published_at = Some(now);
7183 }
7184 p.last_published_at = Some(now);
7186 }
7187 p.save_tx(tx).await?;
7188 touched += 1;
7189 }
7190 }
7191 crate::cache_invalidate::invalidate_urls_on_commit(
7192 invalidator,
7193 tenant_slug,
7194 purge_urls,
7195 );
7196 Ok::<usize, rustango::sql::ExecError>(touched)
7197 })
7198 .await?;
7199 for p in &pages {
7202 crate::revision::capture(pool, p, None)
7203 .await
7204 .log_warn("revision not captured; the history has a gap");
7205 }
7206 if !matches!(target, crate::page::PageStatus::Published) {
7210 for p in &pages {
7211 if p.status != crate::page::PageStatus::Published.as_str() {
7212 continue;
7213 }
7214 let pid = p.id.get().copied().unwrap_or_default();
7215 if let Err(e) = crate::redirect::disable_for_page(
7216 pool,
7217 pid,
7218 &format!("Linked page “{}” was unpublished", p.title),
7219 )
7220 .await
7221 {
7222 tracing::warn!(page_id = pid, error = %e, "failed to disable redirects for unpublished page");
7223 }
7224 }
7225 }
7226 if matches!(target, crate::page::PageStatus::Published) {
7228 for p in &pages {
7229 crate::hooks::fire_after_publish_page(p);
7230 }
7231 let actor = session_user.as_ref().map(|u| u.username.as_str());
7233 for p in &pages {
7234 crate::page_subscription::notify_publish(
7235 _state.mailer.as_deref(),
7236 &_state.mailer_from,
7237 pool,
7238 &tenant.org.slug,
7239 p.id.get().copied().unwrap_or_default(),
7240 &p.title,
7241 &p.url_path,
7242 actor,
7243 )
7244 .await;
7245 }
7246 }
7247 let already = (pages.len() - touched).to_string();
7248 let key = if action == "publish" {
7249 "Published {count} page(s) ({already} already in the target state)."
7250 } else {
7251 "Unpublished {count} page(s) ({already} already in the target state)."
7252 };
7253 redirect_named_with_message_plural(
7254 "rcms-admin:pages:list",
7255 MsgLevel::Success,
7256 key,
7257 touched as i64,
7258 &[("count", &touched.to_string()), ("already", already.as_str())],
7259 &headers,
7260 )
7261 }
7262 "delete" => {
7263 let archived_names: Vec<String> = pages
7268 .iter()
7269 .filter(|p| p.status == crate::page::PageStatus::Archived.as_str())
7270 .map(|p| format!("“{}”", p.title))
7271 .collect();
7272 if !archived_names.is_empty() {
7273 let list = archived_names.join(", ");
7274 return redirect_named_with_message_args(
7275 "rcms-admin:pages:list",
7276 MsgLevel::Error,
7277 "Can't delete archived page(s) {names} — unarchive them first.",
7278 &[("names", list.as_str())],
7279 &headers,
7280 );
7281 }
7282 let id_set: std::collections::HashSet<i64> =
7286 pages.iter().filter_map(|p| p.id.get().copied()).collect();
7287 let mut offenders: Vec<String> = Vec::new();
7288 for p in &pages {
7289 let pid = p.id.get().copied().unwrap_or_default();
7290 let children: Vec<Page> = Page::objects()
7291 .where_(Page::parent_id.eq(pid))
7292 .fetch(pool)
7293 .await?;
7294 let external_children = children
7298 .iter()
7299 .filter(|c| !id_set.contains(&c.id.get().copied().unwrap_or_default()))
7300 .count();
7301 if external_children > 0 {
7302 offenders.push(format!("#{pid} “{}” ({external_children})", p.title));
7303 }
7304 }
7305 if !offenders.is_empty() {
7306 let offenders_list = offenders.join(", ");
7307 return redirect_named_with_message_args(
7308 "rcms-admin:pages:list",
7309 MsgLevel::Error,
7310 "Bulk delete blocked — these page(s) still have external children: {offenders}.",
7311 &[("offenders", offenders_list.as_str())],
7312 &headers,
7313 );
7314 }
7315 let mut ordered = pages.clone();
7320 ordered.sort_by(|a, b| b.depth.cmp(&a.depth));
7321 let invalidator = _state.cache_invalidator.clone();
7322 let tenant_slug = tenant.org.slug.clone();
7323 let purge_urls: Vec<String> = pages.iter().map(|p| p.url_path.clone()).collect();
7327 rustango::atomic!(pool, |tx| {
7328 let mut guard = tx.lock().await?;
7329 let tx = &mut *guard;
7330 for p in &ordered {
7331 let pid = p.id.get().copied().unwrap_or_default();
7332 crate::page_delete::clear_page_references_tx(tx, pid).await?;
7333 }
7334 for p in ordered {
7335 p.delete_tx(tx).await?;
7336 }
7337 crate::cache_invalidate::invalidate_urls_on_commit(
7338 invalidator,
7339 tenant_slug,
7340 purge_urls,
7341 );
7342 Ok::<(), rustango::sql::ExecError>(())
7343 })
7344 .await?;
7345 for p in &pages {
7347 let pid = p.id.get().copied().unwrap_or_default();
7348 if let Err(e) = crate::redirect::disable_for_page(
7349 pool,
7350 pid,
7351 &format!("Linked page “{}” was deleted", p.title),
7352 )
7353 .await
7354 {
7355 tracing::warn!(page_id = pid, error = %e, "failed to disable redirects for deleted page");
7356 }
7357 }
7358 redirect_named_with_message_plural(
7359 "rcms-admin:pages:list",
7360 MsgLevel::Success,
7361 "Deleted {count} page(s).",
7362 pages.len() as i64,
7363 &[("count", &pages.len().to_string())],
7364 &headers,
7365 )
7366 }
7367 "move" => {
7368 let Some(new_parent_id) = new_parent_raw else {
7369 return redirect_named_with_message(
7370 "rcms-admin:pages:list",
7371 MsgLevel::Warning,
7372 "Bulk move requires a destination — pick a parent page.",
7373 &headers,
7374 );
7375 };
7376 let new_parent: Option<Page> = if new_parent_id > 0 {
7377 Page::objects()
7378 .where_(Page::id.eq(new_parent_id))
7379 .first(pool).await?
7380 } else {
7381 None
7382 };
7383 if let Some(np) = &new_parent {
7386 for p in &pages {
7387 if np.path.starts_with(&p.path) {
7388 return redirect_named_with_message_args(
7389 "rcms-admin:pages:list",
7390 MsgLevel::Error,
7391 "Can't move “{title}” under “{parent}” — destination is itself or a descendant.",
7392 &[("title", p.title.as_str()), ("parent", np.title.as_str())],
7393 &headers,
7394 );
7395 }
7396 }
7397 }
7398
7399 if let Some(np) = &new_parent {
7405 for p in &pages {
7406 if let Err(e) =
7407 crate::tree_ops::validate_child_placement(pool, np.page_type_id, p.page_type_id)
7408 .await
7409 {
7410 let err = e.to_string();
7411 return redirect_named_with_message_args(
7412 "rcms-admin:pages:list",
7413 MsgLevel::Error,
7414 "Move blocked — “{title}” can't live under “{parent}”: {error}",
7415 &[("title", p.title.as_str()), ("parent", np.title.as_str()), ("error", err.as_str())],
7416 &headers,
7417 );
7418 }
7419 }
7420 }
7421
7422 let mut to_move: Vec<(Page, Vec<Page>)> = Vec::with_capacity(pages.len());
7432 for p in pages.iter().cloned() {
7433 let subtree = p.descendants(pool).await?;
7434 to_move.push((p, subtree));
7435 }
7436 let moved = to_move.len();
7437 let invalidator = _state.cache_invalidator.clone();
7438 let tenant_slug = tenant.org.slug.clone();
7439 let np_for_tx = new_parent.clone();
7440 crate::tree_ops::atomic_tree(pool, move |tx| {
7441 Box::pin(async move {
7442 let mut purge: Vec<String> = Vec::new();
7443 for (mut p, subtree) in to_move {
7444 let old_url = p.url_path.clone();
7445 let descendant_old_urls: Vec<String> =
7446 subtree.iter().map(|d| d.url_path.clone()).collect();
7447 p.move_to_in_tx(np_for_tx.as_ref(), subtree, tx).await?;
7449 purge.push(old_url);
7450 purge.push(p.url_path.clone());
7451 purge.extend(descendant_old_urls);
7452 }
7453 crate::cache_invalidate::invalidate_urls_on_commit(
7454 invalidator,
7455 tenant_slug,
7456 purge,
7457 );
7458 Ok(())
7459 })
7460 })
7461 .await?;
7462 redirect_named_with_message_plural(
7463 "rcms-admin:pages:list",
7464 MsgLevel::Success,
7465 "Moved {count} page(s) under “{parent}”.",
7466 moved as i64,
7467 &[
7468 ("count", &moved.to_string()),
7469 (
7470 "parent",
7471 &new_parent.map(|p| p.title).unwrap_or_else(|| "Root".to_owned()),
7472 ),
7473 ],
7474 &headers,
7475 )
7476 }
7477 "copy-to-locale" => {
7478 let code = form
7483 .iter()
7484 .find(|(k, _)| k == "locale")
7485 .map(|(_, v)| v.as_str())
7486 .unwrap_or("");
7487 let locale = Locale::objects()
7488 .where_(Locale::code.eq(code.to_owned()))
7489 .where_(Locale::active.eq(true))
7490 .first(pool)
7491 .await?;
7492 let Some(locale) = locale.filter(|l| !l.is_default) else {
7493 return redirect_named_with_message(
7494 "rcms-admin:pages:list",
7495 MsgLevel::Warning,
7496 "Copy to locale needs a target locale (and not the default — canonical content already lives there).",
7497 &headers,
7498 );
7499 };
7500 let locale_id = locale.id.get().copied().unwrap_or_default();
7501 let pages_for_tx = pages.clone();
7502 let (seeded_pages, seeded_fields) = rustango::atomic!(pool, |tx| {
7503 let mut guard = tx.lock().await?;
7504 let tx = &mut *guard;
7505 let mut sp = 0usize;
7506 let mut sf = 0usize;
7507 for p in &pages_for_tx {
7508 let Some(pid) = p.id.get().copied() else {
7509 continue;
7510 };
7511 let existing: Vec<crate::translation::Translation> =
7514 crate::translation::Translation::objects()
7515 .where_(crate::translation::Translation::page_id.eq(pid))
7516 .where_(crate::translation::Translation::locale_id.eq(locale_id))
7517 .fetch_tx(tx)
7518 .await?;
7519 let have: std::collections::HashSet<String> =
7520 existing.into_iter().map(|t| t.field_path).collect();
7521 let mut touched = false;
7522 for (path, value) in copy_fields_for(p) {
7523 if have.contains(path) {
7524 continue;
7525 }
7526 let mut row = crate::translation::Translation {
7527 id: rustango::sql::Auto::Unset,
7528 page_id: pid,
7529 locale_id,
7530 field_path: path.to_owned(),
7531 value,
7532 updated_at: rustango::sql::Auto::Unset,
7533 };
7534 row.save_tx(tx).await?;
7535 sf += 1;
7536 touched = true;
7537 }
7538 if touched {
7539 sp += 1;
7540 }
7541 }
7542 Ok::<_, rustango::sql::ExecError>((sp, sf))
7543 })
7544 .await?;
7545 let fields = super::i18n::tr_plural(
7548 &headers,
7549 "{count} field(s)",
7550 seeded_fields as i64,
7551 &[("count", &seeded_fields.to_string())],
7552 );
7553 let pages_ph = super::i18n::tr_plural(
7554 &headers,
7555 "{count} page(s)",
7556 seeded_pages as i64,
7557 &[("count", &seeded_pages.to_string())],
7558 );
7559 redirect_named_with_message_args(
7560 "rcms-admin:pages:list",
7561 MsgLevel::Success,
7562 "Seeded {fields} across {pages} into “{locale}”. Existing translations were left untouched.",
7563 &[
7564 ("fields", fields.as_str()),
7565 ("pages", pages_ph.as_str()),
7566 ("locale", locale.name.as_str()),
7567 ],
7568 &headers,
7569 )
7570 }
7571 "archive" | "unarchive" => {
7572 let archive = action == "archive";
7578 let plan =
7579 crate::page::plan_archive(pool, &pages, archive, archive_cascade).await?;
7580 let invalidator = _state.cache_invalidator.clone();
7581 let tenant_slug = tenant.org.slug.clone();
7582 let purge = plan.changed_urls.clone();
7583 let flips = plan.to_flip.clone();
7584 let touched = rustango::atomic!(pool, |tx| {
7585 let mut guard = tx.lock().await?;
7586 let tx = &mut *guard;
7587 let mut n = 0usize;
7588 for mut p in flips {
7589 p.save_tx(tx).await?;
7590 n += 1;
7591 }
7592 crate::cache_invalidate::invalidate_urls_on_commit(
7593 invalidator,
7594 tenant_slug,
7595 purge,
7596 );
7597 Ok::<usize, rustango::sql::ExecError>(n)
7598 })
7599 .await?;
7600 for p in &plan.to_flip {
7604 crate::revision::capture(pool, p, None)
7605 .await
7606 .log_warn("revision not captured; the history has a gap");
7607 crate::task_queue::sync_page_search(&tenant.org.slug, p).await;
7608 }
7609 let key = if archive {
7610 "Archived {count} page(s)."
7611 } else {
7612 "Unarchived {count} page(s)."
7613 };
7614 redirect_named_with_message_plural(
7615 "rcms-admin:pages:list",
7616 MsgLevel::Success,
7617 key,
7618 touched as i64,
7619 &[("count", &touched.to_string())],
7620 &headers,
7621 )
7622 }
7623 other => Err(AdminError::Validation(format!(
7624 "unknown bulk action `{other}` (expected publish / unpublish / archive / unarchive / delete / move / copy-to-locale)"
7625 ))),
7626 }
7627}
7628
7629pub async fn page_lock_release(
7637 tenant: Tenant,
7638 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7639 Path(id): Path<i64>,
7640) -> Result<Response, AdminError> {
7641 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7642 return Ok(unauthorized_no_session());
7643 };
7644 crate::lock::release(tenant.pool(), id, viewer_id).await?;
7645 Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
7646}
7647
7648pub async fn page_unlock_submit(
7649 State(_state): State<super::AdminState>,
7650 tenant: Tenant,
7651 headers: HeaderMap,
7652 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7653 Path(id): Path<i64>,
7654) -> Result<Response, AdminError> {
7655 let released = crate::lock::force_release(tenant.pool(), id).await?;
7656 let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
7657 let message = if let Some(row) = released {
7658 let holder = rustango::tenancy::auth::User::objects()
7659 .where_(rustango::tenancy::auth::User::id.eq(row.user_id))
7660 .fetch(tenant.pool())
7661 .await
7662 .ok()
7663 .and_then(|v| v.into_iter().next())
7664 .map(|u| u.username)
7665 .unwrap_or_else(|| format!("user#{}", row.user_id));
7666 crate::page_log::record_or_warn(
7668 tenant.pool(),
7669 id,
7670 crate::page_log::ACTION_FORCE_UNLOCK,
7671 actor_id,
7672 format!("Force-unlocked — “{holder}” no longer holds the editor lock."),
7673 Some(serde_json::json!({ "previous_holder_user_id": row.user_id })),
7674 )
7675 .await;
7676 format!("Lock released — “{holder}” no longer holds the editor lock on this page.")
7677 } else {
7678 "Lock was already released.".to_owned()
7679 };
7680 redirect_named_with_params_and_message(
7681 "rcms-admin:pages:edit",
7682 &[("id", id.to_string())],
7683 MsgLevel::Success,
7684 &message,
7685 &headers,
7686 )
7687}
7688
7689pub async fn page_subscribe_submit(
7694 State(_state): State<super::AdminState>,
7695 tenant: Tenant,
7696 headers: HeaderMap,
7697 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7698 Path(id): Path<i64>,
7699) -> Result<Response, AdminError> {
7700 let Some(viewer) = session_user.as_ref() else {
7701 return Ok(unauthorized_no_session());
7702 };
7703 let viewer_id = viewer.id.get().copied().unwrap_or_default();
7704 crate::page_subscription::subscribe(tenant.pool(), id, viewer_id).await?;
7705 redirect_named_with_params_and_message(
7706 "rcms-admin:pages:edit",
7707 &[("id", id.to_string())],
7708 MsgLevel::Success,
7709 "Subscribed — you'll get an email when this page publishes.",
7710 &headers,
7711 )
7712}
7713
7714pub async fn page_unsubscribe_submit(
7717 State(_state): State<super::AdminState>,
7718 tenant: Tenant,
7719 headers: HeaderMap,
7720 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7721 Path(id): Path<i64>,
7722) -> Result<Response, AdminError> {
7723 let Some(viewer) = session_user.as_ref() else {
7724 return Ok(unauthorized_no_session());
7725 };
7726 let viewer_id = viewer.id.get().copied().unwrap_or_default();
7727 crate::page_subscription::unsubscribe(tenant.pool(), id, viewer_id).await?;
7728 redirect_named_with_params_and_message(
7729 "rcms-admin:pages:edit",
7730 &[("id", id.to_string())],
7731 MsgLevel::Success,
7732 "Unsubscribed — you won't get future publish notifications for this page.",
7733 &headers,
7734 )
7735}
7736
7737async fn read_only_under_review(
7742 pool: &rustango::sql::Pool,
7743 page_id: i64,
7744 user: &rustango::tenancy::auth::User,
7745) -> Result<bool, AdminError> {
7746 if user.is_superuser {
7747 return Ok(false);
7748 }
7749 let Some(state) = crate::workflow::active_state_for_page(pool, page_id).await? else {
7750 return Ok(false);
7751 };
7752 if state.status != crate::workflow::WorkflowStatus::InProgress.as_str() {
7753 return Ok(false);
7754 }
7755 let tasks = crate::workflow::tasks_for(pool, state.workflow_id).await?;
7756 let Some(task) = state
7757 .current_task_id
7758 .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
7759 else {
7760 return Ok(false);
7761 };
7762 let uid = user.id.get().copied().unwrap_or_default();
7763 Ok(!user_is_in_role(pool, uid, task.role_id).await?)
7764}
7765
7766#[derive(Debug, Deserialize)]
7777pub struct HeartbeatQuery {
7778 #[serde(default)]
7779 pub is_editing: Option<String>,
7780}
7781
7782pub async fn page_lock_heartbeat(
7783 State(_state): State<super::AdminState>,
7784 tenant: Tenant,
7785 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7786 Path(id): Path<i64>,
7787 Query(q): Query<HeartbeatQuery>,
7788) -> Result<Response, AdminError> {
7789 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7790 return Ok(unauthorized_no_session());
7791 };
7792
7793 let is_editing = q.is_editing.as_deref() == Some("1");
7796 if let Err(e) = crate::editing_session::touch(tenant.pool(), id, viewer_id, is_editing).await {
7797 tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "editing-session touch failed (continuing)");
7798 }
7799 if rand::random::<u8>() < 5 {
7802 crate::editing_session::gc_stale(tenant.pool())
7803 .await
7804 .log_warn("stale editing sessions not collected");
7805 }
7806
7807 if let Some(u) = session_user.as_ref() {
7809 if read_only_under_review(tenant.pool(), id, u).await? {
7810 return Ok((axum::http::StatusCode::NO_CONTENT, "").into_response());
7811 }
7812 }
7813 match crate::lock::acquire(tenant.pool(), id, viewer_id, false).await {
7814 Ok(crate::lock::AcquireOutcome::Acquired(_)) => {
7815 Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
7816 }
7817 Ok(crate::lock::AcquireOutcome::Held(_)) => Ok((
7818 axum::http::StatusCode::CONFLICT,
7819 "lock held by another editor",
7820 )
7821 .into_response()),
7822 Err(e) => {
7823 tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "lock heartbeat failed");
7824 Err(e.into())
7825 }
7826 }
7827}
7828
7829pub async fn page_sessions_json(
7833 State(_state): State<super::AdminState>,
7834 tenant: Tenant,
7835 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7836 Path(id): Path<i64>,
7837) -> Result<Response, AdminError> {
7838 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7839 return Ok(unauthorized_no_session());
7840 };
7841 let others = crate::editing_session::others_on_page(tenant.pool(), id, viewer_id)
7842 .await
7843 .unwrap_or_default();
7844 if others.is_empty() {
7845 return Ok(([(header::CONTENT_TYPE, "application/json")], "[]").into_response());
7846 }
7847 let user_ids: Vec<i64> = others.iter().map(|s| s.user_id).collect();
7849 let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
7850 .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
7851 .fetch(tenant.pool())
7852 .await
7853 .unwrap_or_default();
7854 let username_by_id: std::collections::HashMap<i64, String> = users
7855 .into_iter()
7856 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
7857 .collect();
7858 let payload: Vec<serde_json::Value> = others
7859 .iter()
7860 .map(|s| {
7861 serde_json::json!({
7862 "user_id": s.user_id,
7863 "username": username_by_id.get(&s.user_id).cloned(),
7864 "last_seen_at": s.last_seen_at,
7865 "is_editing": s.is_editing,
7866 })
7867 })
7868 .collect();
7869 let body = serde_json::to_string(&payload).unwrap_or_else(|_| "[]".to_owned());
7870 Ok(([(header::CONTENT_TYPE, "application/json")], body).into_response())
7871}
7872
7873async fn unique_sibling_slug(
7877 pool: &rustango::sql::Pool,
7878 parent_id: Option<i64>,
7879 desired: &str,
7880) -> Result<String, AdminError> {
7881 use rustango::core::Column as _;
7882 let qs = Page::objects().order_by(&[("slug", false)]);
7883 let siblings: Vec<Page> = match parent_id {
7884 Some(pid) => qs.where_(Page::parent_id.eq(pid)).fetch(pool).await?,
7885 None => qs.where_(Page::parent_id.is_null()).fetch(pool).await?,
7886 };
7887 let taken: std::collections::HashSet<String> = siblings.into_iter().map(|p| p.slug).collect();
7888 if !taken.contains(desired) {
7889 return Ok(desired.to_owned());
7890 }
7891 for n in 2..=100 {
7892 let candidate = format!("{desired}-{n}");
7893 if !taken.contains(&candidate) {
7894 return Ok(candidate);
7895 }
7896 }
7897 Err(AdminError::Validation(
7898 "Could not allocate a unique slug for the clone — over 100 siblings share the same base."
7899 .to_owned(),
7900 ))
7901}
7902
7903pub async fn page_revert_submit(
7912 State(_state): State<super::AdminState>,
7913 tenant: Tenant,
7914 headers: HeaderMap,
7915 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7916 Path((id, rev_id)): Path<(i64, i64)>,
7917) -> Result<Response, AdminError> {
7918 let mut page = Page::objects()
7919 .where_(Page::id.eq(id))
7920 .first(tenant.pool())
7921 .await?
7922 .ok_or(AdminError::NotFound(id))?;
7923 let rev = crate::revision::Revision::objects()
7924 .where_(crate::revision::Revision::id.eq(rev_id))
7925 .where_(crate::revision::Revision::page_id.eq(id))
7926 .first(tenant.pool())
7927 .await?
7928 .ok_or(AdminError::NotFound(rev_id))?;
7929
7930 let snapshot: Page = match serde_json::from_value(rev.snapshot.clone()) {
7935 Ok(p) => p,
7936 Err(e) => {
7937 return Ok((
7938 axum::http::StatusCode::BAD_REQUEST,
7939 format!("revision snapshot could not be decoded: {e}"),
7940 )
7941 .into_response());
7942 }
7943 };
7944
7945 let old_url_path = page.url_path.clone();
7946 page.title = snapshot.title;
7947 page.page_type_id = snapshot.page_type_id;
7948 page.status = snapshot.status;
7949 page.published_at = snapshot.published_at;
7950 page.go_live_at = snapshot.go_live_at;
7951 page.expire_at = snapshot.expire_at;
7952 page.seo_title = snapshot.seo_title;
7953 page.seo_description = snapshot.seo_description;
7954 page.robots_index = snapshot.robots_index;
7955 page.sitemap_priority = snapshot.sitemap_priority;
7956
7957 let mut tx = transaction_pool(tenant.pool()).await?;
7958 page.save_tx(&mut tx).await?;
7959 tx.commit().await?;
7960 crate::revision::capture(tenant.pool(), &page, None)
7961 .await
7962 .log_warn("revision not captured; the history has a gap");
7963
7964 let _ = old_url_path; let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
7967 crate::page_log::record_or_warn(
7968 tenant.pool(),
7969 id,
7970 crate::page_log::ACTION_RESTORE,
7971 actor_id,
7972 format!("Reverted to revision #{}.", rev.sequence),
7973 Some(serde_json::json!({ "revision_id": rev_id, "sequence": rev.sequence })),
7974 )
7975 .await;
7976 let sequence_str = rev.sequence.to_string();
7977 redirect_named_with_params_and_message_args(
7978 "rcms-admin:pages:edit",
7979 &[("id", id.to_string())],
7980 MsgLevel::Success,
7981 "Reverted to revision #{sequence}.",
7982 &[("sequence", sequence_str.as_str())],
7983 &headers,
7984 )
7985}
7986
7987fn stamp_no_cache(mut response: Response) -> Response {
7996 let h = response.headers_mut();
7997 h.insert(
7998 header::CACHE_CONTROL,
7999 HeaderValue::from_static("no-store, no-cache, must-revalidate, max-age=0"),
8000 );
8001 h.insert(header::PRAGMA, HeaderValue::from_static("no-cache"));
8002 h.insert(header::EXPIRES, HeaderValue::from_static("0"));
8003 h.insert(header::VARY, HeaderValue::from_static("*"));
8006 h.insert(
8009 header::X_FRAME_OPTIONS,
8010 HeaderValue::from_static("SAMEORIGIN"),
8011 );
8012 response
8013}
8014
8015async fn inject_axe_into_preview(response: Response) -> Response {
8028 let is_html = response
8030 .headers()
8031 .get(header::CONTENT_TYPE)
8032 .and_then(|v| v.to_str().ok())
8033 .is_some_and(|ct| ct.to_ascii_lowercase().contains("text/html"));
8034 if !is_html {
8035 return response;
8036 }
8037 let (parts, body) = response.into_parts();
8038 let bytes = match axum::body::to_bytes(body, 4 * 1024 * 1024).await {
8041 Ok(b) => b,
8042 Err(_) => {
8043 return (
8046 axum::http::StatusCode::INTERNAL_SERVER_ERROR,
8047 "preview body read failed",
8048 )
8049 .into_response();
8050 }
8051 };
8052 let body_str = match std::str::from_utf8(&bytes) {
8053 Ok(s) => s,
8054 Err(_) => {
8055 return axum::http::Response::from_parts(parts, axum::body::Body::from(bytes));
8057 }
8058 };
8059 let new_body = inject_axe_into_body_str(body_str);
8060 let mut resp = axum::http::Response::from_parts(parts, axum::body::Body::from(new_body));
8063 resp.headers_mut().remove(header::CONTENT_LENGTH);
8064 resp
8065}
8066
8067fn inject_axe_into_body_str(body: &str) -> String {
8074 let v = super::cms_asset_version();
8078 let scripts = format!(
8079 "<script src=\"/cms-admin/static/vendor/axe-core.min.js?v={v}\" defer></script>\n\
8080 <script src=\"/cms-admin/static/cms-preview-guard.js?v={v}\" defer></script>\n\
8081 <script src=\"/cms-admin/static/cms-axe-preview.js?v={v}\" defer></script>\n"
8082 );
8083 let lower = body.to_ascii_lowercase();
8084 if let Some(idx) = lower.rfind("</body>") {
8085 let mut out = String::with_capacity(body.len() + scripts.len());
8086 out.push_str(&body[..idx]);
8087 out.push_str(&scripts);
8088 out.push_str(&body[idx..]);
8089 out
8090 } else {
8091 let mut out = String::with_capacity(body.len() + scripts.len());
8092 out.push_str(body);
8093 out.push_str(&scripts);
8094 out
8095 }
8096}
8097
8098#[cfg(test)]
8099mod axe_injection_tests {
8100 use super::inject_axe_into_body_str;
8101
8102 #[test]
8103 fn splices_before_lowercase_body_close() {
8104 let html = "<html><body><h1>hi</h1></body></html>";
8105 let out = inject_axe_into_body_str(html);
8106 assert!(out.contains("axe-core.min.js"), "axe script missing: {out}");
8107 assert!(
8108 out.contains("cms-axe-preview.js"),
8109 "glue script missing: {out}"
8110 );
8111 assert!(
8112 out.contains("cms-preview-guard.js"),
8113 "preview-guard script missing: {out}"
8114 );
8115 let close = out.find("</body>").expect("body close kept");
8117 assert!(
8118 out[..close].contains("axe-core.min.js"),
8119 "axe script should be before </body>: {out}"
8120 );
8121 assert!(
8122 out[..close].contains("cms-axe-preview.js"),
8123 "glue script should be before </body>: {out}"
8124 );
8125 }
8126
8127 #[test]
8128 fn splices_before_uppercase_body_close() {
8129 let html = "<HTML><BODY><h1>hi</h1></BODY></HTML>";
8130 let out = inject_axe_into_body_str(html);
8131 let close = out.find("</BODY>").expect("uppercase body close kept");
8134 assert!(out[..close].contains("axe-core.min.js"));
8135 }
8136
8137 #[test]
8138 fn appends_when_no_body_close() {
8139 let html = "<html><h1>hi</h1>";
8140 let out = inject_axe_into_body_str(html);
8141 assert!(out.contains("cms-axe-preview.js?v="));
8144 assert!(out.trim_end().ends_with("defer></script>"));
8145 assert!(out.contains("axe-core.min.js"));
8146 assert!(out.starts_with("<html><h1>hi</h1>"));
8148 }
8149
8150 #[test]
8151 fn uses_rfind_for_nested_body_close_text() {
8152 let html = "<html><body><pre>literal: </body></pre></body></html>";
8156 let out = inject_axe_into_body_str(html);
8157 let close = out.rfind("</body>").unwrap();
8158 assert!(out[..close].contains("axe-core.min.js"));
8159 assert!(out.contains("literal: </body>"));
8161 }
8162
8163 #[test]
8164 fn empty_body_renders_clean() {
8165 let out = inject_axe_into_body_str("");
8166 assert!(out.contains("axe-core.min.js"));
8168 assert!(out.contains("cms-axe-preview.js"));
8169 }
8170}
8171
8172#[derive(serde::Deserialize, Default)]
8176pub struct PreviewLocaleQuery {
8177 #[serde(default)]
8178 locale: Option<String>,
8179 #[serde(default)]
8186 format: Option<String>,
8187}
8188
8189fn preview_tera(state: &super::AdminState, tenant: &Tenant) -> std::sync::Arc<tera::Tera> {
8204 crate::tenant_templates::installed()
8205 .map(|tt| tt.for_tenant(&tenant.org.slug))
8206 .unwrap_or_else(|| state.tera.clone())
8207}
8208
8209pub async fn page_preview(
8215 State(state): State<super::AdminState>,
8216 tenant: Tenant,
8217 Path(id): Path<i64>,
8218 axum::extract::Query(q): axum::extract::Query<PreviewLocaleQuery>,
8219) -> Result<Response, AdminError> {
8220 let page = Page::objects()
8221 .where_(Page::id.eq(id))
8222 .first(tenant.pool())
8223 .await?
8224 .ok_or(AdminError::NotFound(id))?;
8225 let response = crate::render::render(
8226 &tenant,
8227 &preview_tera(&state, &tenant),
8228 &page,
8229 "",
8230 "",
8233 q.locale.as_deref(),
8234 None,
8235 None,
8236 )
8237 .await;
8238 Ok(stamp_no_cache(inject_axe_into_preview(response).await))
8242}
8243
8244pub async fn page_preview_token(
8250 tenant: Tenant,
8251 Path(id): Path<i64>,
8252) -> Result<Response, AdminError> {
8253 let exists = Page::objects()
8254 .where_(Page::id.eq(id))
8255 .first(tenant.pool())
8256 .await?
8257 .is_some();
8258 if !exists {
8259 return Err(AdminError::NotFound(id));
8260 }
8261 let expires = chrono::Utc::now().timestamp() + PREVIEW_TOKEN_TTL_SECS;
8264 let token = crate::preview_token::mint(&tenant.org.slug, id, expires);
8265 Ok(Json(serde_json::json!({
8266 "token": token,
8267 "expires_at": expires,
8268 "api_path": format!("/api/v2/pages/{id}/?preview_token={token}"),
8269 }))
8270 .into_response())
8271}
8272
8273pub async fn page_preview_draft(
8278 State(state): State<super::AdminState>,
8279 tenant: Tenant,
8280 Path(id): Path<i64>,
8281 axum::extract::Query(q): axum::extract::Query<PreviewLocaleQuery>,
8282 headers: HeaderMap,
8283 Form(form_map): Form<std::collections::HashMap<String, String>>,
8284) -> Result<Response, AdminError> {
8285 let mut page = Page::objects()
8286 .where_(Page::id.eq(id))
8287 .first(tenant.pool())
8288 .await?
8289 .ok_or(AdminError::NotFound(id))?;
8290
8291 if let Some(v) = form_map.get("title") {
8295 page.title = v.clone();
8296 }
8297 if let Some(v) = form_map.get("slug") {
8298 page.slug = v.clone();
8299 }
8300 if let Some(v) = form_map
8301 .get("page_type_id")
8302 .and_then(|s| s.parse::<i64>().ok())
8303 {
8304 page.page_type_id = v;
8305 }
8306 if let Some(v) = form_map.get("status") {
8307 page.status = v.clone();
8308 }
8309 if let Some(v) = form_map.get("seo_title") {
8310 page.seo_title = v.clone();
8311 }
8312 if let Some(v) = form_map.get("seo_description") {
8313 page.seo_description = v.clone();
8314 }
8315 page.robots_index = form_map
8317 .get("robots_index")
8318 .map(|v| matches!(v.as_str(), "on" | "true" | "1"))
8319 .unwrap_or(page.robots_index);
8320 if let Some(v) = form_map
8321 .get("sitemap_priority")
8322 .and_then(|s| s.parse::<f32>().ok())
8323 {
8324 page.sitemap_priority = v;
8325 }
8326 if let Some(raw) = form_map.get("theme_id") {
8327 page.theme_id = if raw.is_empty() || raw == "0" {
8328 None
8329 } else {
8330 raw.parse::<i64>().ok()
8331 };
8332 }
8333
8334 let accept = crate::page_view::parse_accept(
8339 headers
8340 .get(axum::http::header::ACCEPT)
8341 .and_then(|v| v.to_str().ok()),
8342 );
8343 let force_json = q.format.as_deref() == Some("json");
8344 let response = crate::render::render_preview(
8345 &tenant,
8346 &preview_tera(&state, &tenant),
8347 &page,
8348 "",
8349 "",
8351 q.locale.as_deref(),
8352 &form_map,
8353 accept,
8354 force_json,
8355 )
8356 .await;
8357 Ok(stamp_no_cache(inject_axe_into_preview(response).await))
8361}
8362
8363#[derive(Debug, Deserialize, Default)]
8372pub struct LibraryListQuery {
8373 #[serde(default)]
8376 pub r#type: Option<String>,
8377 #[serde(default)]
8379 pub folder: Option<String>,
8380 #[serde(default)]
8383 pub q: Option<String>,
8384 #[serde(default)]
8386 pub page: Option<u32>,
8387 #[serde(default)]
8390 pub per_page: Option<usize>,
8391 #[serde(flatten)]
8394 pub raw_filters: std::collections::HashMap<String, String>,
8395}
8396
8397pub async fn library_list(
8398 State(state): State<super::AdminState>,
8399 tenant: Tenant,
8400 headers: HeaderMap,
8401 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8402 Query(q): Query<LibraryListQuery>,
8403 axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
8404) -> Result<Response, AdminError> {
8405 let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8410 .order_by(&[("type_name", false)])
8411 .fetch(tenant.pool())
8412 .await?
8413 .into_iter()
8414 .filter(|t| t.type_name != "form")
8415 .collect();
8416 let all_snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
8417 .fetch(tenant.pool())
8418 .await?;
8419 let mut counts_by_type: std::collections::HashMap<String, i64> =
8420 std::collections::HashMap::new();
8421 for s in &all_snippets {
8422 *counts_by_type.entry(s.type_name.clone()).or_default() += 1;
8423 }
8424
8425 let mut ctx = Context::new();
8426 add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8427 add_admin_theme(&mut ctx, tenant.pool()).await;
8428 ctx.insert("query_string", &raw_query.unwrap_or_default());
8431 ctx.insert("types", &types);
8432 ctx.insert("counts_by_type", &counts_by_type);
8433
8434 let Some(type_name) = q.r#type.as_deref().filter(|s| !s.is_empty()) else {
8436 ctx.insert("mode", "overview");
8437 return render_with_csrf(&state, &headers, "rcms_admin/library_list.html", &mut ctx);
8438 };
8439
8440 let handler = crate::library::find_handler(type_name);
8443 let list_display = handler
8444 .as_ref()
8445 .map(|h| h.list_display())
8446 .unwrap_or_else(|| {
8447 vec![
8448 crate::library::ListColumn::Field {
8449 column: "title",
8450 label: "Title",
8451 },
8452 crate::library::ListColumn::Field {
8453 column: "slug",
8454 label: "Slug",
8455 },
8456 crate::library::ListColumn::Field {
8457 column: "updated_at",
8458 label: "Updated",
8459 },
8460 ]
8461 });
8462 let search_fields = handler
8463 .as_ref()
8464 .map(|h| h.search_fields())
8465 .unwrap_or_else(|| vec!["title", "slug"]);
8466 let filter_keys = handler
8467 .as_ref()
8468 .map(|h| h.list_filter())
8469 .unwrap_or_default();
8470
8471 let folder = crate::snippet::normalize_folder(q.folder.as_deref().unwrap_or(""));
8475 let child_folders = crate::snippet::child_folders(tenant.pool(), &folder)
8476 .await
8477 .unwrap_or_default();
8478
8479 let mut filtered: Vec<crate::snippet::Snippet> = all_snippets
8483 .iter()
8484 .filter(|s| s.type_name == type_name && s.folder_path == folder)
8485 .filter(|s| handler.as_ref().map(|h| h.can_view(s)).unwrap_or(true))
8486 .cloned()
8487 .collect();
8488
8489 let search_q = q.q.as_deref().map(|s| s.trim()).filter(|s| !s.is_empty());
8491 if let Some(needle) = search_q {
8492 let needle_lower = needle.to_lowercase();
8493 filtered.retain(|s| {
8494 search_fields.iter().any(|field| {
8495 let hay = match *field {
8496 "title" => s.title.to_lowercase(),
8497 "slug" => s.slug.to_lowercase(),
8498 "body_markdown" => s.body_markdown.to_lowercase(),
8499 other => s
8500 .data
8501 .get(other)
8502 .and_then(serde_json::Value::as_str)
8503 .map(str::to_lowercase)
8504 .unwrap_or_default(),
8505 };
8506 hay.contains(&needle_lower)
8507 })
8508 });
8509 }
8510
8511 let mut active_filters: std::collections::HashMap<String, String> =
8514 std::collections::HashMap::new();
8515 for (k, v) in &q.raw_filters {
8516 if let Some(stripped) = k.strip_prefix("filter_") {
8517 if !v.is_empty() {
8518 active_filters.insert(stripped.to_owned(), v.clone());
8519 }
8520 }
8521 }
8522 if !active_filters.is_empty() {
8523 filtered.retain(|s| {
8524 active_filters.iter().all(|(key, want)| {
8525 let got = s
8526 .data
8527 .get(key)
8528 .map(|v| match v {
8529 serde_json::Value::String(s) => s.clone(),
8530 other => other.to_string(),
8531 })
8532 .unwrap_or_default();
8533 got == *want
8534 })
8535 });
8536 }
8537
8538 let filter_options: std::collections::HashMap<String, Vec<String>> = filter_keys
8540 .iter()
8541 .map(|k| {
8542 let mut opts: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
8543 for s in &all_snippets {
8544 if s.type_name != type_name {
8545 continue;
8546 }
8547 if let Some(v) = s.data.get(*k) {
8548 let s = match v {
8549 serde_json::Value::String(s) => s.clone(),
8550 other => other.to_string(),
8551 };
8552 if !s.is_empty() {
8553 opts.insert(s);
8554 }
8555 }
8556 }
8557 ((*k).to_owned(), opts.into_iter().collect())
8558 })
8559 .collect();
8560
8561 let total = filtered.len();
8567 let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
8568 let paginator = rustango::pagination::Paginator::new(total, page_size);
8569 let requested_page = q.page.unwrap_or(1).max(1) as i64;
8570 let page_obj = paginator.get_page(requested_page);
8571 let page = page_obj.number;
8572 let total_pages = paginator.num_pages().max(1);
8573 let page_rows: Vec<crate::snippet::Snippet> = if total == 0 {
8574 Vec::new()
8575 } else {
8576 let start = page_obj.start_index().saturating_sub(1);
8577 let end = page_obj.end_index();
8578 filtered[start..end].to_vec()
8579 };
8580
8581 let column_headers: Vec<serde_json::Value> = list_display
8585 .iter()
8586 .map(|c| {
8587 serde_json::json!({
8588 "key": c.key(),
8589 "label": c.label(),
8590 })
8591 })
8592 .collect();
8593 let rows_html: Vec<serde_json::Value> = page_rows
8594 .iter()
8595 .map(|row| {
8596 let cells: Vec<String> = list_display
8597 .iter()
8598 .map(|c| render_list_cell(c, row, handler.as_deref()))
8599 .collect();
8600 serde_json::json!({
8601 "id": row.id.get().copied().unwrap_or_default(),
8602 "slug": row.slug,
8603 "cells": cells,
8604 })
8605 })
8606 .collect();
8607
8608 let active_filters_json: Vec<serde_json::Value> = active_filters
8609 .iter()
8610 .map(|(k, v)| serde_json::json!({ "key": k, "value": v }))
8611 .collect();
8612
8613 let bulk_actions: Vec<serde_json::Value> = handler
8616 .as_ref()
8617 .map(|h| h.bulk_actions())
8618 .unwrap_or_default()
8619 .iter()
8620 .map(serialize_bulk_action)
8621 .collect();
8622 let row_actions: Vec<serde_json::Value> = handler
8623 .as_ref()
8624 .map(|h| h.row_actions())
8625 .unwrap_or_default()
8626 .iter()
8627 .map(serialize_bulk_action)
8628 .collect();
8629
8630 let plugin_bulk_actions: Vec<serde_json::Value> = crate::hooks::bulk_actions_for("cms_snippet")
8632 .into_iter()
8633 .map(|a| {
8634 serde_json::json!({
8635 "key": a.key,
8636 "label": a.label,
8637 "icon": a.icon,
8638 "danger": a.danger,
8639 "confirm_message": a.confirm_message,
8640 "action_url": a.action_url,
8641 })
8642 })
8643 .collect();
8644
8645 let folder_tree_paths = crate::snippet::folder_tree_for_type(tenant.pool(), type_name)
8650 .await
8651 .unwrap_or_default();
8652 let folder_tree: Vec<serde_json::Value> = folder_tree_paths
8653 .iter()
8654 .map(|p| {
8655 let depth = p.matches('/').count(); let display = if p.is_empty() {
8657 "Root".to_owned()
8658 } else {
8659 p.trim_end_matches('/')
8661 .rsplit('/')
8662 .next()
8663 .unwrap_or("")
8664 .to_owned()
8665 };
8666 serde_json::json!({
8667 "path": p,
8668 "name": display,
8669 "depth": depth,
8670 "active": *p == folder,
8671 })
8672 })
8673 .collect();
8674
8675 ctx.insert("mode", "type");
8676 ctx.insert("active_type", type_name);
8677 ctx.insert("folder", &folder);
8678 ctx.insert("child_folders", &child_folders);
8679 ctx.insert("folder_tree", &folder_tree);
8680 ctx.insert("column_headers", &column_headers);
8681 ctx.insert("rows", &rows_html);
8682 ctx.insert("plugin_bulk_actions", &plugin_bulk_actions);
8683 ctx.insert("page", &page);
8684 ctx.insert("total_pages", &total_pages);
8685 ctx.insert(
8688 "pagination",
8689 &crate::admin::pagination::context(page as i64, page_size, total),
8690 );
8691 ctx.insert("total", &total);
8692 ctx.insert("page_size", &page_size);
8693 ctx.insert("search_q", &search_q.unwrap_or(""));
8694 ctx.insert("filter_keys", &filter_keys);
8695 ctx.insert("filter_options", &filter_options);
8696 ctx.insert("active_filters", &active_filters_json);
8697 ctx.insert("bulk_actions", &bulk_actions);
8698 ctx.insert("row_actions", &row_actions);
8699 render_with_csrf(&state, &headers, "rcms_admin/library_list.html", &mut ctx)
8700}
8701
8702fn serialize_bulk_action(a: &crate::library::BulkAction) -> serde_json::Value {
8704 use crate::library::BulkActionStyle;
8705 let style_class = match a.style {
8706 BulkActionStyle::Primary => "btn",
8707 BulkActionStyle::Outlined => "btn btn-outlined",
8708 BulkActionStyle::Danger => "btn btn-danger",
8709 };
8710 serde_json::json!({
8711 "name": a.name,
8712 "label": a.label,
8713 "icon": a.icon,
8714 "confirm_message": a.confirm_message,
8715 "style_class": style_class,
8716 })
8717}
8718
8719pub async fn library_bulk_submit(
8725 State(_state): State<super::AdminState>,
8726 tenant: Tenant,
8727 headers: HeaderMap,
8728 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
8729 Path(type_name): Path<String>,
8730 Form(form): Form<Vec<(String, String)>>,
8731) -> Result<Response, AdminError> {
8732 let action = form
8733 .iter()
8734 .find(|(k, _)| k == "action")
8735 .map(|(_, v)| v.clone())
8736 .unwrap_or_default();
8737 let ids: Vec<i64> = form
8738 .iter()
8739 .filter(|(k, _)| k == "ids" || k == "id")
8740 .filter_map(|(_, v)| v.parse::<i64>().ok())
8741 .collect();
8742 if action.is_empty() || ids.is_empty() {
8743 return redirect_named_with_message(
8744 "rcms-admin:library:list",
8745 MsgLevel::Warning,
8746 "Pick at least one row + a bulk action before submitting.",
8747 &headers,
8748 );
8749 }
8750 let Some(handler) = crate::library::find_handler(&type_name) else {
8751 return Err(AdminError::Validation(format!(
8752 "unknown library type `{type_name}`"
8753 )));
8754 };
8755 let declared: std::collections::HashSet<&'static str> = handler
8758 .bulk_actions()
8759 .iter()
8760 .chain(handler.row_actions().iter())
8761 .map(|a| a.name)
8762 .collect();
8763 if !declared.contains(action.as_str()) {
8764 return Err(AdminError::Validation(format!(
8765 "library type `{type_name}` doesn't declare bulk action `{action}`"
8766 )));
8767 }
8768 let touched = handler
8769 .handle_bulk_action(tenant.pool(), &action, &ids)
8770 .await?;
8771 let count = touched.to_string();
8772 redirect_named_with_message_plural(
8773 "rcms-admin:library:list",
8774 MsgLevel::Success,
8775 "{action}: touched {count} row(s) in `{type_name}`.",
8776 touched as i64,
8777 &[
8778 ("action", action.as_str()),
8779 ("count", count.as_str()),
8780 ("type_name", type_name.as_str()),
8781 ],
8782 &headers,
8783 )
8784}
8785
8786fn render_list_cell(
8792 col: &crate::library::ListColumn,
8793 row: &crate::snippet::Snippet,
8794 handler: Option<&dyn crate::library::LibraryTypeHandler>,
8795) -> String {
8796 use crate::library::{ListColumn, ListColumnKind};
8797 match col {
8798 ListColumn::Field { column, .. } => match *column {
8799 "id" => row.id.get().copied().unwrap_or_default().to_string(),
8800 "type_name" => html_escape(&row.type_name),
8801 "slug" => format!("<code>{}</code>", html_escape(&row.slug)),
8802 "folder_path" => html_escape(&row.folder_path),
8803 "title" => format!("<strong>{}</strong>", html_escape(&row.title)),
8804 "body_markdown" => {
8805 let preview: String = row.body_markdown.chars().take(80).collect();
8806 format!("<span>{}</span>", html_escape(&preview))
8807 }
8808 "created_at" => row
8809 .created_at
8810 .get()
8811 .map(|d| d.format("%Y-%m-%d").to_string())
8812 .unwrap_or_default(),
8813 "updated_at" => row
8814 .updated_at
8815 .get()
8816 .map(|d| d.format("%Y-%m-%d").to_string())
8817 .unwrap_or_default(),
8818 other => format!("<em>(unknown field: {})</em>", html_escape(other)),
8819 },
8820 ListColumn::JsonField { key, kind, .. } => {
8821 let val = row.data.get(*key);
8822 match (kind, val) {
8823 (ListColumnKind::Bool, Some(serde_json::Value::Bool(b))) => bool_checkbox_html(*b),
8824 (_, Some(serde_json::Value::Bool(b))) => bool_checkbox_html(*b),
8825 (ListColumnKind::Integer, Some(serde_json::Value::Number(n)))
8826 | (ListColumnKind::Float, Some(serde_json::Value::Number(n))) => {
8827 html_escape(&n.to_string())
8828 }
8829 (_, Some(serde_json::Value::String(s))) => html_escape(s),
8830 (_, Some(other)) => html_escape(&other.to_string()),
8831 (_, None) => String::new(),
8832 }
8833 }
8834 ListColumn::Method { name, .. } | ListColumn::Computed { name, .. } => handler
8835 .map(|h| h.render_cell(name, row))
8836 .unwrap_or_default(),
8837 }
8838}
8839
8840fn html_escape(s: &str) -> String {
8841 s.replace('&', "&")
8842 .replace('<', "<")
8843 .replace('>', ">")
8844 .replace('"', """)
8845}
8846
8847fn bool_checkbox_html(b: bool) -> String {
8848 if b {
8849 r#"<span class="material-symbols-rounded sm filled" style="color: var(--accent);" aria-label="true">check_box</span>"#.to_owned()
8850 } else {
8851 r#"<span class="material-symbols-rounded sm" style="color: var(--muted-2);" aria-label="false">check_box_outline_blank</span>"#.to_owned()
8852 }
8853}
8854
8855#[derive(Debug, Deserialize)]
8859pub struct SnippetNewQuery {
8860 #[serde(default)]
8861 pub r#type: Option<String>,
8862 #[serde(default)]
8863 pub folder: Option<String>,
8864}
8865
8866pub async fn snippet_new_form(
8867 State(state): State<super::AdminState>,
8868 tenant: Tenant,
8869 headers: HeaderMap,
8870 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8871 Query(q): Query<SnippetNewQuery>,
8872) -> Result<Response, AdminError> {
8873 let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8874 .order_by(&[("type_name", false)])
8875 .fetch(tenant.pool())
8876 .await?;
8877 let mut ctx = Context::new();
8878 add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8879 add_admin_theme(&mut ctx, tenant.pool()).await;
8880 ctx.insert("mode", "new");
8881 ctx.insert("types", &types);
8882 ctx.insert("preselect_type", &q.r#type.unwrap_or_default());
8883 let folder = q.folder.unwrap_or_default();
8884 ctx.insert(
8885 "snippet",
8886 &serde_json::json!({
8887 "type_name": "",
8888 "slug": "",
8889 "title": "",
8890 "body_markdown": "",
8891 "folder_path": folder,
8892 }),
8893 );
8894 render_with_csrf(&state, &headers, "rcms_admin/snippet_form.html", &mut ctx)
8895}
8896
8897pub async fn snippet_edit_form(
8898 State(state): State<super::AdminState>,
8899 tenant: Tenant,
8900 headers: HeaderMap,
8901 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8902 Path(id): Path<i64>,
8903 Query(q): Query<EditQuery>,
8904) -> Result<Response, AdminError> {
8905 let snippet = crate::snippet::Snippet::objects()
8906 .where_(crate::snippet::Snippet::id.eq(id))
8907 .first(tenant.pool())
8908 .await?
8909 .ok_or(AdminError::NotFound(id))?;
8910 if snippet.type_name == "form" {
8914 let url = rustango::urls::reverse_owned(
8915 "rcms-admin:forms:build",
8916 &std::collections::HashMap::from([("id".to_owned(), id.to_string())]),
8917 )
8918 .map_err(|e| AdminError::Validation(format!("url reversal failed: {e}")))?;
8919 return Ok(axum::response::Redirect::to(&url).into_response());
8920 }
8921 let handler = crate::library::find_handler(&snippet.type_name);
8926 if let Some(h) = handler.as_ref() {
8927 if !h.can_view(&snippet) {
8928 return Err(AdminError::NotFound(id));
8929 }
8930 }
8931 let read_only = handler
8932 .as_ref()
8933 .map(|h| !h.can_edit(&snippet))
8934 .unwrap_or(false);
8935 let can_delete = handler
8936 .as_ref()
8937 .map(|h| h.can_delete(&snippet))
8938 .unwrap_or(true);
8939 let template_path = handler
8942 .as_ref()
8943 .and_then(|h| h.edit_template())
8944 .unwrap_or("rcms_admin/snippet_form.html");
8945
8946 let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8947 .order_by(&[("type_name", false)])
8948 .fetch(tenant.pool())
8949 .await?;
8950 let mut ctx = Context::new();
8951 add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8952 add_admin_theme(&mut ctx, tenant.pool()).await;
8953 ctx.insert("mode", "edit");
8954 ctx.insert("types", &types);
8955 ctx.insert("snippet", &snippet);
8956 ctx.insert("read_only", &read_only);
8957 ctx.insert("can_delete", &can_delete);
8958 ctx.insert(
8962 "allows_element_template",
8963 &handler
8964 .as_ref()
8965 .map(|h| h.allows_element_template())
8966 .unwrap_or(false),
8967 );
8968 let revisions_enabled = handler.as_ref().is_some_and(|h| h.revisions_enabled());
8972 let preview_enabled = handler.as_ref().is_some_and(|h| h.preview_enabled());
8973 let revisions: Vec<crate::snippet::SnippetRevision> = if revisions_enabled {
8974 crate::snippet::revisions_for(tenant.pool(), id)
8975 .await
8976 .unwrap_or_default()
8977 } else {
8978 Vec::new()
8979 };
8980 ctx.insert("revisions_enabled", &revisions_enabled);
8981 ctx.insert("preview_enabled", &preview_enabled);
8982 ctx.insert("snippet_revisions", &revisions);
8983 let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
8987 .where_(crate::locale::Locale::active.eq(true))
8988 .order_by(&[("sort_order", false), ("code", false)])
8989 .fetch(tenant.pool())
8990 .await?;
8991 let editing_locale = q
8992 .locale
8993 .as_deref()
8994 .filter(|c| !c.is_empty())
8995 .and_then(|code| locales.iter().find(|l| l.code == code).cloned());
8996 let translation_mode = editing_locale.as_ref().is_some_and(|l| !l.is_default);
8997 let mut core_translations: std::collections::HashMap<String, String> =
8998 std::collections::HashMap::new();
8999 let mut extra_translations: Vec<(String, String)> = Vec::new();
9000 if translation_mode {
9001 let lid = editing_locale
9002 .as_ref()
9003 .and_then(|l| l.id.get().copied())
9004 .unwrap_or_default();
9005 let existing = crate::snippet_translation::fetch_for(tenant.pool(), id, lid)
9006 .await
9007 .unwrap_or_default();
9008 let core_keys = ["title", "body_markdown"];
9009 core_translations = core_keys
9010 .iter()
9011 .map(|k| {
9012 (
9013 (*k).to_owned(),
9014 existing.get(*k).cloned().unwrap_or_default(),
9015 )
9016 })
9017 .collect();
9018 extra_translations = existing
9019 .iter()
9020 .filter(|(k, _)| !core_keys.contains(&k.as_str()))
9021 .map(|(k, v)| (k.clone(), v.clone()))
9022 .collect();
9023 }
9024 ctx.insert("locales", &locales);
9025 ctx.insert("editing_locale", &editing_locale);
9026 ctx.insert("translation_mode", &translation_mode);
9027 ctx.insert("core_translations", &core_translations);
9028 ctx.insert("extra_translations", &extra_translations);
9029 render_with_csrf(&state, &headers, template_path, &mut ctx)
9030}
9031
9032pub async fn snippet_translate_submit(
9038 State(_state): State<super::AdminState>,
9039 tenant: Tenant,
9040 Path(id): Path<i64>,
9041 Query(q): Query<EditQuery>,
9042 Form(form): Form<std::collections::HashMap<String, String>>,
9043) -> Result<Response, AdminError> {
9044 use crate::snippet_translation::SnippetTranslation;
9045 let code = q
9046 .locale
9047 .as_deref()
9048 .filter(|c| !c.is_empty())
9049 .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
9050 let locale = crate::locale::Locale::objects()
9051 .where_(crate::locale::Locale::code.eq(code.to_owned()))
9052 .where_(crate::locale::Locale::active.eq(true))
9053 .first(tenant.pool())
9054 .await?
9055 .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
9056 if locale.is_default {
9057 return Ok((
9058 axum::http::StatusCode::BAD_REQUEST,
9059 "cannot translate INTO the default locale; canonical content lives on cms_snippet",
9060 )
9061 .into_response());
9062 }
9063 let locale_id = locale
9064 .id
9065 .get()
9066 .copied()
9067 .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
9068 let snippet = crate::snippet::Snippet::objects()
9070 .where_(crate::snippet::Snippet::id.eq(id))
9071 .first(tenant.pool())
9072 .await?
9073 .ok_or(AdminError::NotFound(id))?;
9074
9075 let mut updates: Vec<(String, String)> = Vec::new();
9077 for (k, v) in &form {
9078 if let Some(path) = k.strip_prefix("tr__") {
9079 if !path.is_empty() {
9080 updates.push((path.to_owned(), v.clone()));
9081 }
9082 }
9083 }
9084 let new_path_raw = form.get("new_field_path").map(String::as_str).unwrap_or("");
9085 if !new_path_raw.trim().is_empty() {
9086 if let Ok(path) = crate::snippet_translation::validate_field_path(new_path_raw) {
9089 let value = form.get("new_field_value").cloned().unwrap_or_default();
9090 updates.push((path, value));
9091 }
9092 }
9093
9094 rustango::atomic!(tenant.pool(), |tx| {
9096 let mut guard = tx.lock().await?;
9097 let tx = &mut *guard;
9098 for (path, value) in updates {
9099 let existing: Vec<SnippetTranslation> = SnippetTranslation::objects()
9100 .where_(SnippetTranslation::snippet_id.eq(id))
9101 .where_(SnippetTranslation::locale_id.eq(locale_id))
9102 .where_(SnippetTranslation::field_path.eq(path.clone()))
9103 .fetch_tx(tx)
9104 .await?;
9105 if value.is_empty() {
9106 for row in existing {
9107 row.delete_tx(tx).await?;
9108 }
9109 } else if let Some(mut row) = existing.into_iter().next() {
9110 row.value = value;
9111 row.save_tx(tx).await?;
9112 } else {
9113 let mut row = SnippetTranslation {
9114 id: rustango::sql::Auto::Unset,
9115 snippet_id: id,
9116 locale_id,
9117 field_path: path,
9118 value,
9119 updated_at: rustango::sql::Auto::Unset,
9120 };
9121 row.save_tx(tx).await?;
9122 }
9123 }
9124 Ok::<_, rustango::sql::ExecError>(())
9125 })
9126 .await?;
9127
9128 let back = if snippet.type_name == "form" {
9131 format!("/cms-admin/forms/{id}/build?locale={code}")
9132 } else {
9133 format!("/cms-admin/library/{id}/edit?locale={code}")
9134 };
9135 Ok(Redirect::to(&back).into_response())
9136}
9137
9138pub async fn snippet_revert_submit(
9142 State(_state): State<super::AdminState>,
9143 tenant: Tenant,
9144 headers: HeaderMap,
9145 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9146 Path((id, sequence)): Path<(i64, i32)>,
9147) -> Result<Response, AdminError> {
9148 let Some(rev) = crate::snippet::revision_by_sequence(tenant.pool(), id, sequence).await? else {
9149 return Err(AdminError::NotFound(id));
9150 };
9151 let mut snippet = crate::snippet::Snippet::objects()
9152 .where_(crate::snippet::Snippet::id.eq(id))
9153 .first(tenant.pool())
9154 .await?
9155 .ok_or(AdminError::NotFound(id))?;
9156 let snap = &rev.snapshot;
9159 if let Some(v) = snap.get("title").and_then(|v| v.as_str()) {
9160 snippet.title = v.to_owned();
9161 }
9162 if let Some(v) = snap.get("slug").and_then(|v| v.as_str()) {
9163 snippet.slug = v.to_owned();
9164 }
9165 if let Some(v) = snap.get("body_markdown").and_then(|v| v.as_str()) {
9166 snippet.body_markdown = v.to_owned();
9167 }
9168 if let Some(v) = snap.get("folder_path").and_then(|v| v.as_str()) {
9169 snippet.folder_path = v.to_owned();
9170 }
9171 if let Some(v) = snap.get("type_name").and_then(|v| v.as_str()) {
9172 snippet.type_name = v.to_owned();
9173 }
9174 if let Some(v) = snap.get("data") {
9175 snippet.data = v.clone();
9176 }
9177 snippet.save_pool(tenant.pool()).await?;
9178 if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9180 if handler.revisions_enabled() {
9181 let captured_by = session_user.as_ref().and_then(|u| u.id.get().copied());
9182 crate::snippet::capture_revision(tenant.pool(), &snippet, captured_by)
9183 .await
9184 .log_warn("revision not captured; the history has a gap");
9185 }
9186 }
9187 let sequence_str = sequence.to_string();
9188 redirect_named_with_params_and_message_args(
9189 "rcms-admin:library:edit",
9190 &[("id", id.to_string())],
9191 MsgLevel::Success,
9192 "Reverted to revision #{sequence}.",
9193 &[("sequence", sequence_str.as_str())],
9194 &headers,
9195 )
9196}
9197
9198pub async fn snippet_create_submit(
9199 State(_state): State<super::AdminState>,
9200 tenant: Tenant,
9201 headers: HeaderMap,
9202 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9203 Form(form): Form<std::collections::HashMap<String, String>>,
9204) -> Result<Response, AdminError> {
9205 let type_name = form.get("type_name").cloned().unwrap_or_default();
9206 let slug = form.get("slug").cloned().unwrap_or_default();
9207 let title = form.get("title").cloned().unwrap_or_default();
9208 let body = form.get("body_markdown").cloned().unwrap_or_default();
9209 let folder_path = form
9210 .get("folder_path")
9211 .map(|s| crate::snippet::normalize_folder(s))
9212 .unwrap_or_default();
9213 if type_name.is_empty() || slug.is_empty() || title.is_empty() {
9214 return Err(AdminError::Validation(
9215 "type, slug, and title are all required".to_owned(),
9216 ));
9217 }
9218 let mut row = crate::snippet::Snippet {
9219 id: rustango::sql::Auto::Unset,
9220 type_name,
9221 slug,
9222 folder_path,
9223 title,
9224 body_markdown: body,
9225 data: serde_json::Value::Object(serde_json::Map::new()),
9226 created_at: rustango::sql::Auto::Unset,
9227 updated_at: rustango::sql::Auto::Unset,
9228 };
9229 row.save_pool(tenant.pool()).await?;
9230 if row.type_name == "form" {
9233 let id = row.id.get().copied().unwrap_or_default();
9234 return redirect_named_with_params_and_message(
9235 "rcms-admin:forms:build",
9236 &[("id", id.to_string())],
9237 MsgLevel::Success,
9238 &super::i18n::tr(
9239 &headers,
9240 "Created snippet “{title}”.",
9241 &[("title", row.title.as_str())],
9242 ),
9243 &headers,
9244 );
9245 }
9246 redirect_named_with_message_args(
9247 "rcms-admin:library:list",
9248 MsgLevel::Success,
9249 "Created snippet “{title}”.",
9250 &[("title", row.title.as_str())],
9251 &headers,
9252 )
9253}
9254
9255pub async fn snippet_edit_submit(
9256 State(_state): State<super::AdminState>,
9257 tenant: Tenant,
9258 headers: HeaderMap,
9259 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9260 Path(id): Path<i64>,
9261 Form(form): Form<std::collections::HashMap<String, String>>,
9262) -> Result<Response, AdminError> {
9263 let mut snippet = crate::snippet::Snippet::objects()
9264 .where_(crate::snippet::Snippet::id.eq(id))
9265 .first(tenant.pool())
9266 .await?
9267 .ok_or(AdminError::NotFound(id))?;
9268 if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9272 if !handler.can_edit(&snippet) {
9273 return Err(AdminError::Validation(format!(
9274 "Library type `{}` denies edit on this row.",
9275 snippet.type_name
9276 )));
9277 }
9278 if let Err(errors) = handler.validate(&form) {
9281 let summary: Vec<String> = errors
9282 .into_iter()
9283 .map(|(field, msg)| format!("{field}: {msg}"))
9284 .collect();
9285 return Err(AdminError::Validation(summary.join("; ")));
9286 }
9287 }
9288 if let Some(v) = form.get("type_name") {
9289 if !v.is_empty() {
9290 snippet.type_name = v.clone();
9291 }
9292 }
9293 if let Some(v) = form.get("slug") {
9294 if !v.is_empty() {
9295 snippet.slug = v.clone();
9296 }
9297 }
9298 if let Some(v) = form.get("title") {
9299 snippet.title = v.clone();
9300 }
9301 if let Some(v) = form.get("body_markdown") {
9302 snippet.body_markdown = v.clone();
9303 }
9304 if let Some(v) = form.get("folder_path") {
9305 snippet.folder_path = crate::snippet::normalize_folder(v);
9306 }
9307 if crate::library::find_handler(&snippet.type_name)
9313 .is_some_and(|h| h.allows_element_template())
9314 {
9315 if let Some(v) = form.get("data__template") {
9316 crate::snippet::set_element_template(&mut snippet.data, v.trim());
9317 }
9318 }
9319 snippet.save_pool(tenant.pool()).await?;
9320 if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9324 if handler.revisions_enabled() {
9325 let captured_by = session_user.as_ref().and_then(|u| u.id.get().copied());
9326 if let Err(e) =
9327 crate::snippet::capture_revision(tenant.pool(), &snippet, captured_by).await
9328 {
9329 tracing::warn!(
9330 target: "rustango_cms::admin",
9331 snippet_id = id,
9332 type_name = %snippet.type_name,
9333 error = %e,
9334 "snippet revision capture failed",
9335 );
9336 }
9337 }
9338 }
9339 {
9341 let mut refs: Vec<crate::reference_index::Reference> = Vec::new();
9342 for (key, value) in &form {
9343 let mut found = crate::reference_index::scan(value, key);
9344 refs.append(&mut found);
9345 }
9346 if let Err(e) = crate::reference_index::reindex_source(
9347 tenant.pool(),
9348 crate::reference_index::KIND_SNIPPET,
9349 id,
9350 refs,
9351 )
9352 .await
9353 {
9354 tracing::warn!(
9355 target: "rustango_cms::reference_index",
9356 snippet_id = id, error = %e,
9357 "snippet reindex failed (best-effort)"
9358 );
9359 }
9360 }
9361 redirect_named_with_message_args(
9362 "rcms-admin:library:list",
9363 MsgLevel::Success,
9364 "Saved snippet “{title}”.",
9365 &[("title", snippet.title.as_str())],
9366 &headers,
9367 )
9368}
9369
9370pub async fn snippet_delete_submit(
9371 State(_state): State<super::AdminState>,
9372 tenant: Tenant,
9373 headers: HeaderMap,
9374 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9375 Path(id): Path<i64>,
9376) -> Result<Response, AdminError> {
9377 let snippet = crate::snippet::Snippet::objects()
9378 .where_(crate::snippet::Snippet::id.eq(id))
9379 .first(tenant.pool())
9380 .await?
9381 .ok_or(AdminError::NotFound(id))?;
9382 if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9384 if !handler.can_delete(&snippet) {
9385 return Err(AdminError::Validation(format!(
9386 "Library type `{}` denies delete on this row.",
9387 snippet.type_name
9388 )));
9389 }
9390 }
9391 let title = snippet.title.clone();
9392 let is_form = snippet.type_name == "form";
9393 snippet.delete_pool(tenant.pool()).await?;
9394 if is_form {
9396 let body = super::i18n::tr(&headers, "Deleted snippet “{title}”.", &[("title", title.as_str())]);
9397 return Ok(rustango::messages::redirect_with_message(
9398 messages_secret(),
9399 &headers,
9400 MsgLevel::Success,
9401 &body,
9402 "/cms-admin/forms",
9403 ));
9404 }
9405 redirect_named_with_message_args(
9406 "rcms-admin:library:list",
9407 MsgLevel::Success,
9408 "Deleted snippet “{title}”.",
9409 &[("title", title.as_str())],
9410 &headers,
9411 )
9412}
9413
9414fn parse_date_floor(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
9421 let raw = raw?.trim();
9422 if raw.is_empty() {
9423 return None;
9424 }
9425 chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d")
9426 .ok()
9427 .map(|d| {
9428 chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
9429 d.and_hms_opt(0, 0, 0).unwrap_or_default(),
9430 chrono::Utc,
9431 )
9432 })
9433}
9434
9435fn parse_date_ceil(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
9438 let raw = raw?.trim();
9439 if raw.is_empty() {
9440 return None;
9441 }
9442 chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d")
9443 .ok()
9444 .map(|d| {
9445 chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
9446 d.and_hms_opt(23, 59, 59).unwrap_or_default(),
9447 chrono::Utc,
9448 )
9449 })
9450}
9451
9452#[derive(Debug, Deserialize)]
9456pub struct MediaListQuery {
9457 #[serde(default)]
9459 pub page: Option<i64>,
9460 #[serde(default)]
9462 pub per_page: Option<usize>,
9463 #[serde(default)]
9465 pub collection: Option<i64>,
9466 #[serde(default)]
9469 pub q: Option<String>,
9470 #[serde(default)]
9472 pub from: Option<String>,
9473 #[serde(default)]
9476 pub to: Option<String>,
9477}
9478
9479#[derive(Debug, Deserialize)]
9486pub struct CropForm {
9487 pub crop_x: u32,
9488 pub crop_y: u32,
9489 pub crop_w: u32,
9490 pub crop_h: u32,
9491 pub mode: String,
9494}
9495
9496pub async fn media_crop_submit(
9506 State(_state): State<super::AdminState>,
9507 tenant: Tenant,
9508 headers: HeaderMap,
9509 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9510 Path(id): Path<i64>,
9511 Form(form): Form<CropForm>,
9512) -> Result<Response, AdminError> {
9513 use rustango::sql::Auto;
9514 let mut media = Media::objects()
9515 .where_(Media::id.eq(id))
9516 .first(tenant.pool())
9517 .await?
9518 .ok_or(AdminError::NotFound(id))?;
9519 if media.kind != "image" {
9520 return Err(AdminError::Validation(
9521 "Crop applies to images only.".to_owned(),
9522 ));
9523 }
9524
9525 let bytes = crate::media_storage::disk_for(&tenant.org.slug)
9526 .load(&crate::media_storage::key(
9527 &tenant.org.slug,
9528 &media.storage_key,
9529 ))
9530 .await
9531 .map_err(|e| AdminError::Validation(format!("read source: {e}")))?;
9532 let (cropped_bytes, out_mime) = crate::rendition::crop_image_off_runtime(
9533 bytes,
9534 media.mime.clone(),
9535 (form.crop_x, form.crop_y, form.crop_w, form.crop_h),
9536 )
9537 .await
9538 .map_err(AdminError::Validation)?;
9539
9540 let new_hash = {
9541 use sha2::Digest;
9542 let mut hasher = sha2::Sha256::new();
9543 hasher.update(&cropped_bytes);
9544 let digest = hasher.finalize();
9545 let mut hex = String::with_capacity(digest.len() * 2);
9546 for b in digest.iter() {
9547 hex.push_str(&format!("{b:02x}"));
9548 }
9549 hex
9550 };
9551
9552 match form.mode.as_str() {
9553 "apply" => {
9554 crate::media_storage::disk_for(&tenant.org.slug)
9558 .save(
9559 &crate::media_storage::key(&tenant.org.slug, &media.storage_key),
9560 &cropped_bytes,
9561 )
9562 .await
9563 .map_err(|e| AdminError::Validation(format!("write crop: {e}")))?;
9564 let old_hash = media.content_hash.clone();
9565 media.content_hash = new_hash;
9566 media.size = cropped_bytes.len() as i64;
9567 media.mime = out_mime;
9568 media.width = Some(form.crop_w as i32);
9569 media.height = Some(form.crop_h as i32);
9570 media.focal_point_x = None;
9572 media.focal_point_y = None;
9573 media.save_pool(tenant.pool()).await?;
9574
9575 for r in crate::rendition::MediaRendition::objects()
9579 .where_(crate::rendition::MediaRendition::content_hash.eq(old_hash))
9580 .fetch(tenant.pool())
9581 .await?
9582 {
9583 crate::media_storage::disk_for(&tenant.org.slug)
9584 .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
9585 .await
9586 .log_warn("stored file not deleted; the blob is orphaned");
9587 r.delete_pool(tenant.pool()).await?;
9588 }
9589 let crop_w = form.crop_w.to_string();
9590 let crop_h = form.crop_h.to_string();
9591 redirect_named_with_params_and_message_args(
9592 "rcms-admin:media:edit",
9593 &[("id", id.to_string())],
9594 MsgLevel::Success,
9595 "Crop applied. New dimensions {width}×{height}; renditions purged.",
9596 &[("width", crop_w.as_str()), ("height", crop_h.as_str())],
9597 &headers,
9598 )
9599 }
9600 "clone" => {
9601 let ext = match out_mime.as_str() {
9606 "image/jpeg" => "jpg",
9607 "image/webp" => "webp",
9608 _ => "png",
9609 };
9610 let new_key = format!("{}-crop-{}.{ext}", &new_hash[..16.min(new_hash.len())], id);
9611 crate::media_storage::disk_for(&tenant.org.slug)
9612 .save(
9613 &crate::media_storage::key(&tenant.org.slug, &new_key),
9614 &cropped_bytes,
9615 )
9616 .await
9617 .map_err(|e| AdminError::Validation(format!("write clone: {e}")))?;
9618
9619 let clone_title = if media.title.contains(" — crop") {
9620 media.title.clone()
9621 } else {
9622 format!("{} — crop", media.title)
9623 };
9624 let mut clone = Media {
9625 id: Auto::Unset,
9626 filename: format!(
9627 "{}.crop.{ext}",
9628 std::path::Path::new(&media.filename)
9629 .file_stem()
9630 .map(|s| s.to_string_lossy().to_string())
9631 .unwrap_or_else(|| "crop".to_owned())
9632 ),
9633 content_hash: new_hash,
9634 mime: out_mime,
9635 size: cropped_bytes.len() as i64,
9636 kind: "image".to_owned(),
9637 width: Some(form.crop_w as i32),
9638 height: Some(form.crop_h as i32),
9639 storage_key: new_key,
9640 title: clone_title,
9641 alt_text: media.alt_text.clone(),
9642 description: media.description.clone(),
9643 uploaded_by: media.uploaded_by,
9644 collection_id: media.collection_id,
9645 focal_point_x: None,
9646 focal_point_y: None,
9647 uploaded_at: Auto::Unset,
9648 };
9649 clone.insert_pool(tenant.pool()).await?;
9650 let new_id = clone.id.get().copied().unwrap_or_default();
9651 let new_id_str = new_id.to_string();
9652 let crop_w = form.crop_w.to_string();
9653 let crop_h = form.crop_h.to_string();
9654 redirect_named_with_params_and_message_args(
9655 "rcms-admin:media:edit",
9656 &[("id", new_id.to_string())],
9657 MsgLevel::Success,
9658 "Saved cropped clone as new media #{id} ({width}×{height}).",
9659 &[
9660 ("id", new_id_str.as_str()),
9661 ("width", crop_w.as_str()),
9662 ("height", crop_h.as_str()),
9663 ],
9664 &headers,
9665 )
9666 }
9667 other => Err(AdminError::Validation(format!(
9668 "Unknown crop mode `{other}` — expected `apply` or `clone`."
9669 ))),
9670 }
9671}
9672
9673pub async fn media_replace_submit(
9689 State(_state): State<super::AdminState>,
9690 tenant: Tenant,
9691 headers: HeaderMap,
9692 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9693 Path(id): Path<i64>,
9694 mut multipart: axum::extract::Multipart,
9695) -> Result<Response, AdminError> {
9696 use sha2::{Digest, Sha256};
9697
9698 let mut media = Media::objects()
9699 .where_(Media::id.eq(id))
9700 .first(tenant.pool())
9701 .await?
9702 .ok_or(AdminError::NotFound(id))?;
9703
9704 let mut filename = String::new();
9705 let mut bytes: Vec<u8> = Vec::new();
9706 while let Some(field) = multipart
9707 .next_field()
9708 .await
9709 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
9710 {
9711 if field.name().unwrap_or("") == "file" {
9712 if let Some(fname) = field.file_name() {
9713 filename = sanitize_filename(fname);
9714 }
9715 bytes = field
9716 .bytes()
9717 .await
9718 .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
9719 .to_vec();
9720 } else {
9721 let _ = field.bytes().await;
9722 }
9723 }
9724 if filename.is_empty() || bytes.is_empty() {
9725 return Err(AdminError::Upload("no file submitted".into()));
9726 }
9727
9728 let new_mime = mime_guess::from_path(&filename)
9729 .first_or_octet_stream()
9730 .essence_str()
9731 .to_owned();
9732 refuse_active_upload(&new_mime)?;
9733 let new_kind = Media::classify_mime(&new_mime).to_owned();
9736 if new_kind != media.kind {
9737 return Err(AdminError::Validation(format!(
9738 "Replacement kind `{new_kind}` does not match existing `{}` — replace must keep the media type.",
9739 media.kind
9740 )));
9741 }
9742
9743 let (stored, decoded_dims) =
9745 crate::rendition::strip_exif_off_runtime(bytes, new_mime.clone()).await;
9746 bytes = stored;
9747
9748 let mut hasher = Sha256::new();
9749 hasher.update(&bytes);
9750 let digest = hasher.finalize();
9751 let new_hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
9752 use std::fmt::Write as _;
9753 let _ = write!(acc, "{b:02x}");
9754 acc
9755 });
9756
9757 let new_storage_key = format!("{}-{}", &new_hash[..16.min(new_hash.len())], filename);
9758 crate::media_storage::disk_for(&tenant.org.slug)
9759 .save(
9760 &crate::media_storage::key(&tenant.org.slug, &new_storage_key),
9761 &bytes,
9762 )
9763 .await
9764 .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
9765
9766 let old_storage_key = media.storage_key.clone();
9767 let old_hash = media.content_hash.clone();
9768
9769 let (new_w, new_h): (Option<i32>, Option<i32>) = decoded_dims
9770 .map(|(w, h)| (Some(w as i32), Some(h as i32)))
9771 .unwrap_or((None, None));
9772
9773 media.filename = filename;
9774 media.storage_key = new_storage_key;
9775 media.content_hash = new_hash;
9776 media.mime = new_mime;
9777 media.size = bytes.len() as i64;
9778 media.width = new_w;
9779 media.height = new_h;
9780 media.save_pool(tenant.pool()).await?;
9781
9782 if old_storage_key != media.storage_key {
9786 crate::media_storage::disk_for(&tenant.org.slug)
9787 .delete(&crate::media_storage::key(
9788 &tenant.org.slug,
9789 &old_storage_key,
9790 ))
9791 .await
9792 .log_warn("stored file not deleted; the blob is orphaned");
9793 }
9794
9795 if old_hash != media.content_hash {
9798 for r in crate::rendition::MediaRendition::objects()
9799 .where_(crate::rendition::MediaRendition::content_hash.eq(old_hash))
9800 .fetch(tenant.pool())
9801 .await?
9802 {
9803 crate::media_storage::disk_for(&tenant.org.slug)
9804 .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
9805 .await
9806 .log_warn("stored file not deleted; the blob is orphaned");
9807 r.delete_pool(tenant.pool()).await?;
9808 }
9809 }
9810
9811 redirect_named_with_params_and_message(
9812 "rcms-admin:media:edit",
9813 &[("id", id.to_string())],
9814 MsgLevel::Success,
9815 "Replaced. Old renditions purged; every page referencing this image now serves the new bytes.",
9816 &headers,
9817 )
9818}
9819
9820async fn pages_referencing_media(
9832 pool: &rustango::sql::Pool,
9833 media_id: i64,
9834) -> Result<Vec<(i64, String, String, String)>, rustango::sql::ExecError> {
9835 let pages: Vec<Page> = Page::objects().fetch(pool).await?;
9836 let mut hits: Vec<(i64, String, String, String)> = Vec::new();
9837 for p in &pages {
9838 let page_id = p.id.get().copied().unwrap_or_default();
9839 if page_id == 0 {
9840 continue;
9841 }
9842 let mut ids = std::collections::BTreeSet::new();
9843 if let Ok(v) = serde_json::to_value(p) {
9845 harvest_media_ids(&v, &mut ids);
9846 }
9847 if let Ok(pts) = PageType::objects()
9850 .where_(PageType::id.eq(p.page_type_id))
9851 .fetch(pool)
9852 .await
9853 {
9854 if let Some(pt_row) = pts.into_iter().next() {
9855 if let Some(handler) = crate::page_type::find_handler(&pt_row.type_name) {
9856 if let Ok(ext) = handler.load_extension(pool, page_id).await {
9857 harvest_media_ids(&ext, &mut ids);
9858 }
9859 }
9860 }
9861 }
9862 if ids.contains(&media_id) {
9863 hits.push((
9864 page_id,
9865 p.title.clone(),
9866 p.url_path.clone(),
9867 p.status.clone(),
9868 ));
9869 }
9870 }
9871 Ok(hits)
9872}
9873
9874pub async fn media_edit_form(
9875 State(state): State<super::AdminState>,
9876 tenant: Tenant,
9877 headers: HeaderMap,
9878 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9879 Path(id): Path<i64>,
9880) -> Result<Response, AdminError> {
9881 let media = Media::objects()
9882 .where_(Media::id.eq(id))
9883 .first(tenant.pool())
9884 .await?
9885 .ok_or(AdminError::NotFound(id))?;
9886 if media.kind != "image" {
9887 return Err(AdminError::NotFound(id));
9888 }
9889 let usages = pages_referencing_media(tenant.pool(), id)
9891 .await
9892 .unwrap_or_default();
9893 let usage_rows: Vec<serde_json::Value> = usages
9894 .iter()
9895 .map(|(pid, title, url_path, status)| {
9896 serde_json::json!({
9897 "id": pid,
9898 "title": title,
9899 "url_path": url_path,
9900 "status": status,
9901 })
9902 })
9903 .collect();
9904 let mut ctx = Context::new();
9905 add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
9906 add_admin_theme(&mut ctx, tenant.pool()).await;
9907 ctx.insert(
9908 "media",
9909 &serde_json::json!({
9910 "id": media.id.get().copied(),
9911 "title": media.title,
9912 "filename": media.filename,
9913 "alt_text": media.alt_text,
9914 "description": media.description,
9915 "mime": media.mime,
9916 "size": media.size,
9917 "width": media.width,
9918 "height": media.height,
9919 "focal_point_x": media.focal_point_x,
9920 "focal_point_y": media.focal_point_y,
9921 "uploaded_at": media.uploaded_at.get().copied(),
9922 "content_hash": media.content_hash,
9926 }),
9927 );
9928 ctx.insert("usages", &usage_rows);
9929 ctx.insert("usage_count", &(usage_rows.len() as i64));
9930 render_with_csrf(&state, &headers, "rcms_admin/media_edit.html", &mut ctx)
9931}
9932
9933#[derive(Debug, Deserialize)]
9937pub struct MediaEditForm {
9938 pub title: String,
9939 pub alt_text: String,
9940 #[serde(default)]
9941 pub description: String,
9942 #[serde(default)]
9943 pub focal_point_x: Option<String>,
9944 #[serde(default)]
9945 pub focal_point_y: Option<String>,
9946}
9947
9948pub async fn media_edit_submit(
9953 State(_state): State<super::AdminState>,
9954 tenant: Tenant,
9955 headers: HeaderMap,
9956 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9957 Path(id): Path<i64>,
9958 Form(form): Form<MediaEditForm>,
9959) -> Result<Response, AdminError> {
9960 let mut media = Media::objects()
9961 .where_(Media::id.eq(id))
9962 .first(tenant.pool())
9963 .await?
9964 .ok_or(AdminError::NotFound(id))?;
9965 if media.kind != "image" {
9966 return Err(AdminError::NotFound(id));
9967 }
9968 media.title = form.title.trim().to_owned();
9969 media.alt_text = form.alt_text.trim().to_owned();
9970 media.description = form.description.trim().to_owned();
9971
9972 let parse_fraction = |raw: Option<&str>| -> Option<f32> {
9973 raw.map(str::trim)
9974 .filter(|s| !s.is_empty())
9975 .and_then(|s| s.parse::<f32>().ok())
9976 .map(|f| f.clamp(0.0, 1.0))
9977 };
9978 let new_x = parse_fraction(form.focal_point_x.as_deref());
9979 let new_y = parse_fraction(form.focal_point_y.as_deref());
9980 let focal_changed = media.focal_point_x != new_x || media.focal_point_y != new_y;
9981 media.focal_point_x = new_x;
9982 media.focal_point_y = new_y;
9983 media.save_pool(tenant.pool()).await?;
9984
9985 if focal_changed {
9988 let renditions: Vec<crate::rendition::MediaRendition> =
9989 crate::rendition::MediaRendition::objects()
9990 .where_(
9991 crate::rendition::MediaRendition::content_hash.eq(media.content_hash.clone()),
9992 )
9993 .fetch(tenant.pool())
9994 .await?;
9995 for r in renditions {
9996 crate::media_storage::disk_for(&tenant.org.slug)
9999 .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
10000 .await
10001 .log_warn("stored file not deleted; the blob is orphaned");
10002 r.delete_pool(tenant.pool()).await?;
10003 }
10004 }
10005 redirect_named_with_params_and_message(
10006 "rcms-admin:media:edit",
10007 &[("id", id.to_string())],
10008 MsgLevel::Success,
10009 if focal_changed {
10010 "Saved. Renditions purged — next request regenerates with the new focal point."
10011 } else {
10012 "Saved."
10013 },
10014 &headers,
10015 )
10016}
10017
10018fn json_contains_needle(value: &serde_json::Value, needle: &str) -> bool {
10023 match value {
10024 serde_json::Value::String(s) => {
10025 if s.to_lowercase().contains(needle) {
10026 return true;
10027 }
10028 let trimmed = s.trim_start();
10031 if trimmed.starts_with('[') || trimmed.starts_with('{') {
10032 if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(s) {
10033 return json_contains_needle(&parsed, needle);
10034 }
10035 }
10036 false
10037 }
10038 serde_json::Value::Array(arr) => arr.iter().any(|v| json_contains_needle(v, needle)),
10039 serde_json::Value::Object(map) => map.values().any(|v| json_contains_needle(v, needle)),
10040 _ => false,
10041 }
10042}
10043
10044fn harvest_media_ids(value: &serde_json::Value, out: &mut std::collections::BTreeSet<i64>) {
10057 use serde_json::Value;
10058 match value {
10059 Value::Object(map) => {
10060 for (key, child) in map {
10061 let is_media_key = key == "media_id" || key.ends_with("_media_id");
10062 if is_media_key {
10063 match child {
10064 Value::Number(n) => {
10065 if let Some(id) = n.as_i64() {
10066 if id > 0 {
10067 out.insert(id);
10068 }
10069 }
10070 }
10071 Value::String(s) => {
10072 if let Ok(id) = s.parse::<i64>() {
10073 if id > 0 {
10074 out.insert(id);
10075 }
10076 }
10077 }
10078 _ => harvest_media_ids(child, out),
10079 }
10080 } else {
10081 harvest_media_ids(child, out);
10082 }
10083 }
10084 }
10085 Value::Array(arr) => {
10086 for item in arr {
10087 harvest_media_ids(item, out);
10088 }
10089 }
10090 Value::String(s) => {
10091 let trimmed = s.trim_start();
10092 if trimmed.starts_with('[') || trimmed.starts_with('{') {
10093 if let Ok(parsed) = serde_json::from_str::<Value>(s) {
10094 harvest_media_ids(&parsed, out);
10095 }
10096 }
10097 }
10098 _ => {}
10099 }
10100}
10101
10102pub async fn media_unused_report(
10107 State(state): State<super::AdminState>,
10108 tenant: Tenant,
10109 headers: HeaderMap,
10110 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10111) -> Result<Response, AdminError> {
10112 let all_media: Vec<Media> = Media::objects()
10113 .order_by(&[("uploaded_at", true)])
10114 .fetch(tenant.pool())
10115 .await?;
10116 let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
10117
10118 let mut used: std::collections::BTreeSet<i64> = std::collections::BTreeSet::new();
10119
10120 for p in &pages {
10124 if let Ok(v) = serde_json::to_value(p) {
10125 harvest_media_ids(&v, &mut used);
10126 }
10127 }
10128
10129 for p in &pages {
10134 let page_id = p.id.get().copied().unwrap_or_default();
10135 let pt: Vec<crate::page_type_model::PageType> = crate::page_type_model::PageType::objects()
10138 .where_(crate::page_type_model::PageType::id.eq(p.page_type_id))
10139 .fetch(tenant.pool())
10140 .await?;
10141 let Some(pt_row) = pt.into_iter().next() else {
10142 continue;
10143 };
10144 let Some(handler) = crate::page_type::find_handler(&pt_row.type_name) else {
10145 continue;
10146 };
10147 if let Ok(ext_value) = handler.load_extension(tenant.pool(), page_id).await {
10148 harvest_media_ids(&ext_value, &mut used);
10149 }
10150 }
10151
10152 let unused: Vec<&Media> = all_media
10154 .iter()
10155 .filter(|m| m.id.get().copied().is_some_and(|id| !used.contains(&id)))
10156 .collect();
10157
10158 let unused_view: Vec<serde_json::Value> = unused
10159 .iter()
10160 .map(|m| {
10161 serde_json::json!({
10162 "id": m.id.get().copied(),
10163 "title": m.title,
10164 "filename": m.filename,
10165 "kind": m.kind,
10166 "mime": m.mime,
10167 "size": m.size,
10168 "uploaded_at": m.uploaded_at.get().copied(),
10169 "uploaded_by": m.uploaded_by,
10170 })
10171 })
10172 .collect();
10173
10174 let mut ctx = Context::new();
10175 add_chrome(&mut ctx, &tenant, "media-unused", session_user.as_ref()).await;
10176 add_admin_theme(&mut ctx, tenant.pool()).await;
10177 ctx.insert("unused", &unused_view);
10178 ctx.insert("total_media", &all_media.len());
10179 ctx.insert("used_count", &used.len());
10180 render_with_csrf(&state, &headers, "rcms_admin/media_unused.html", &mut ctx)
10181}
10182
10183pub async fn media_unused_bulk_delete(
10189 State(_state): State<super::AdminState>,
10190 tenant: Tenant,
10191 headers: HeaderMap,
10192 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
10193 Form(form): Form<Vec<(String, String)>>,
10194) -> Result<Response, AdminError> {
10195 use rustango::sql::Auto;
10196 let ids: Vec<i64> = form
10197 .iter()
10198 .filter(|(k, _)| k == "id" || k == "ids")
10199 .filter_map(|(_, v)| v.parse::<i64>().ok())
10200 .collect();
10201 let mut deleted = 0usize;
10202 for id in ids {
10203 let row = Media::objects()
10204 .where_(Media::id.eq(id))
10205 .first(tenant.pool())
10206 .await?;
10207 if let Some(m) = row {
10208 let _ = Auto::Unset::<i64>; m.delete_pool(tenant.pool()).await?;
10213 deleted += 1;
10214 }
10215 }
10216 redirect_named_with_message_plural(
10217 "rcms-admin:media:unused",
10218 MsgLevel::Success,
10219 "Deleted {count} unused media item(s).",
10220 deleted as i64,
10221 &[("count", &deleted.to_string())],
10222 &headers,
10223 )
10224}
10225
10226pub async fn media_list(
10228 State(state): State<super::AdminState>,
10229 tenant: Tenant,
10230 headers: HeaderMap,
10231 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10232 Query(q): Query<MediaListQuery>,
10233 axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
10234) -> Result<Response, AdminError> {
10235 if rand::random::<u8>() < 5 {
10239 if let Ok(unlinked) = crate::uploaded_file::gc_stale(tenant.pool()).await {
10240 for key in unlinked {
10241 crate::media_storage::disk_for(&tenant.org.slug)
10242 .delete(&crate::media_storage::key(&tenant.org.slug, &key))
10243 .await
10244 .log_warn("stored file not deleted; the blob is orphaned");
10245 }
10246 }
10247 }
10248 render_media_list(
10249 &state,
10250 &tenant,
10251 &headers,
10252 session_user.as_ref(),
10253 "image",
10254 q,
10255 raw_query,
10256 )
10257 .await
10258}
10259
10260pub async fn documents_list(
10262 State(state): State<super::AdminState>,
10263 tenant: Tenant,
10264 headers: HeaderMap,
10265 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10266 Query(q): Query<MediaListQuery>,
10267 axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
10268) -> Result<Response, AdminError> {
10269 render_media_list(
10270 &state,
10271 &tenant,
10272 &headers,
10273 session_user.as_ref(),
10274 "document",
10275 q,
10276 raw_query,
10277 )
10278 .await
10279}
10280
10281async fn render_media_list(
10284 state: &super::AdminState,
10285 tenant: &Tenant,
10286 headers: &HeaderMap,
10287 session_user: Option<&rustango::tenancy::auth::User>,
10288 kind: &str,
10289 filters: MediaListQuery,
10290 raw_query: Option<String>,
10291) -> Result<Response, AdminError> {
10292 let collection_filter = filters.collection;
10293 let search = filters
10294 .q
10295 .as_deref()
10296 .map(str::trim)
10297 .filter(|s| !s.is_empty())
10298 .map(str::to_lowercase);
10299 let from_filter = parse_date_floor(filters.from.as_deref());
10300 let to_filter = parse_date_ceil(filters.to.as_deref());
10301 let all: Vec<Media> = Media::objects()
10305 .order_by(&[("uploaded_at", true)])
10306 .fetch(tenant.pool())
10307 .await?;
10308 let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
10309 .order_by(&[("sort_order", false), ("name", false)])
10310 .fetch(tenant.pool())
10311 .await?;
10312
10313 let items: Vec<&Media> = all
10314 .iter()
10315 .filter(|m| {
10316 let kind_match = if kind == "image" {
10317 m.kind == "image"
10318 } else {
10319 m.kind != "image"
10320 };
10321 let collection_match = match collection_filter {
10322 None => true,
10323 Some(cid) => m.collection_id == Some(cid),
10324 };
10325 let search_match = match &search {
10326 None => true,
10327 Some(needle) => {
10328 m.title.to_lowercase().contains(needle)
10329 || m.filename.to_lowercase().contains(needle)
10330 || m.alt_text.to_lowercase().contains(needle)
10331 }
10332 };
10333 let date_match = m.uploaded_at.get().is_none_or(|when| {
10334 let after_from = from_filter.is_none_or(|floor| *when >= floor);
10335 let before_to = to_filter.is_none_or(|ceil| *when <= ceil);
10336 after_from && before_to
10337 });
10338 kind_match && collection_match && search_match && date_match
10339 })
10340 .collect();
10341
10342 let per_page = crate::admin::pagination::clamp_per_page(filters.per_page);
10347 let requested_page = filters.page.unwrap_or(1);
10348 let total_items = items.len();
10349 let pagination = crate::admin::pagination::context(requested_page, per_page, total_items);
10350 let current_page = pagination["page"].as_i64().unwrap_or(1);
10351 let skip = crate::admin::pagination::offset(current_page, per_page) as usize;
10352 let items: Vec<&Media> = items.into_iter().skip(skip).take(per_page).collect();
10353
10354 let mut counts: std::collections::HashMap<Option<i64>, i64> = std::collections::HashMap::new();
10358 for m in &all {
10359 let in_kind = if kind == "image" {
10360 m.kind == "image"
10361 } else {
10362 m.kind != "image"
10363 };
10364 if in_kind {
10365 *counts.entry(m.collection_id).or_insert(0) += 1;
10366 }
10367 }
10368
10369 let collections_view: Vec<serde_json::Value> = collections
10370 .iter()
10371 .map(|c| {
10372 let id = c.id.get().copied();
10373 serde_json::json!({
10374 "id": id,
10375 "name": c.name,
10376 "parent_id": c.parent_id,
10377 "count": id.and_then(|i| counts.get(&Some(i)).copied()).unwrap_or(0),
10378 })
10379 })
10380 .collect();
10381 let uncategorized_count = counts.get(&None).copied().unwrap_or(0);
10382
10383 let mut ctx = Context::new();
10384 let active_tab = if kind == "image" {
10385 "media"
10386 } else {
10387 "documents"
10388 };
10389 add_chrome(&mut ctx, tenant, active_tab, session_user).await;
10390 add_admin_theme(&mut ctx, tenant.pool()).await;
10391 ctx.insert("items", &items);
10392 ctx.insert("collections", &collections_view);
10393 ctx.insert("collection_filter", &collection_filter);
10394 ctx.insert("uncategorized_count", &uncategorized_count);
10395 ctx.insert("search_q", &filters.q);
10396 ctx.insert("date_from", &filters.from);
10397 ctx.insert("date_to", &filters.to);
10398 ctx.insert(
10399 "is_filtered",
10400 &(collection_filter.is_some()
10401 || search.is_some()
10402 || from_filter.is_some()
10403 || to_filter.is_some()),
10404 );
10405 ctx.insert("filtered_count", &total_items);
10407 ctx.insert("pagination", &pagination);
10408 ctx.insert(
10409 "kind_label",
10410 if kind == "image" {
10411 "Media (images)"
10412 } else {
10413 "Documents"
10414 },
10415 );
10416 ctx.insert(
10417 "upload_kind",
10418 if kind == "image" { "image" } else { "document" },
10419 );
10420 ctx.insert(
10421 "self_url",
10422 if kind == "image" {
10423 "/cms-admin/media"
10424 } else {
10425 "/cms-admin/documents"
10426 },
10427 );
10428 ctx.insert("query_string", &raw_query.unwrap_or_default());
10434 ctx.insert("qs_none", &serde_json::Value::Null);
10435 render_with_csrf(state, headers, "rcms_admin/media_list.html", &mut ctx)
10436}
10437
10438pub async fn media_upload_form(
10440 State(state): State<super::AdminState>,
10441 tenant: Tenant,
10442 headers: HeaderMap,
10443 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10444 Query(q): Query<UploadFormQuery>,
10445) -> Result<Response, AdminError> {
10446 let kind_label = if q.kind.as_deref() == Some("document") {
10447 "Documents"
10448 } else {
10449 "Media (images)"
10450 };
10451 let mut ctx = Context::new();
10452 add_chrome(
10453 &mut ctx,
10454 &tenant,
10455 if q.kind.as_deref() == Some("document") {
10456 "documents"
10457 } else {
10458 "media"
10459 },
10460 session_user.as_ref(),
10461 )
10462 .await;
10463 let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
10466 .order_by(&[("sort_order", false), ("name", false)])
10467 .fetch(tenant.pool())
10468 .await?;
10469 let collections_view: Vec<serde_json::Value> = collections
10470 .iter()
10471 .map(|c| {
10472 serde_json::json!({
10473 "id": c.id.get().copied(),
10474 "name": c.name,
10475 })
10476 })
10477 .collect();
10478 ctx.insert("collections", &collections_view);
10479 ctx.insert("kind_label", kind_label);
10480 ctx.insert("upload_kind", &q.kind.as_deref().unwrap_or("image"));
10481 render_with_csrf(&state, &headers, "rcms_admin/media_upload.html", &mut ctx)
10482}
10483
10484#[derive(Debug, Deserialize)]
10485pub struct UploadFormQuery {
10486 #[serde(default)]
10487 pub kind: Option<String>,
10488}
10489
10490pub async fn media_upload_staged(
10503 State(_state): State<super::AdminState>,
10504 tenant: Tenant,
10505 headers: HeaderMap,
10506 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10507 mut multipart: axum::extract::Multipart,
10508) -> Result<Response, AdminError> {
10509 use sha2::{Digest, Sha256};
10510 let Some(viewer) = session_user.as_ref() else {
10511 return Ok(unauthorized_no_session_for(Some(&headers)));
10517 };
10518 let viewer_id = viewer.id.get().copied().unwrap_or_default();
10519 let mut filename = String::new();
10520 let mut bytes: Vec<u8> = Vec::new();
10521 while let Some(field) = multipart
10522 .next_field()
10523 .await
10524 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
10525 {
10526 if field.name().unwrap_or("") == "file" {
10527 if let Some(fname) = field.file_name() {
10528 filename = sanitize_filename(fname);
10529 }
10530 bytes = field
10531 .bytes()
10532 .await
10533 .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
10534 .to_vec();
10535 } else {
10536 let _ = field.bytes().await;
10537 }
10538 }
10539 if filename.is_empty() || bytes.is_empty() {
10540 return Err(AdminError::Upload("no file submitted".into()));
10541 }
10542 let mut hasher = Sha256::new();
10543 hasher.update(&bytes);
10544 let digest = hasher.finalize();
10545 let hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
10546 use std::fmt::Write as _;
10547 let _ = write!(acc, "{b:02x}");
10548 acc
10549 });
10550 let mime = mime_guess::from_path(&filename)
10551 .first_or_octet_stream()
10552 .essence_str()
10553 .to_owned();
10554 refuse_active_upload(&mime)?;
10555 {
10564 use rustango::core::Column as _;
10565 use rustango::sql::FetcherPool as _;
10566 let existing: Vec<crate::media::Media> = crate::media::Media::objects()
10567 .where_(crate::media::Media::content_hash.eq(hash.clone()))
10568 .fetch(tenant.pool())
10569 .await
10570 .unwrap_or_default();
10571 if let Some(existing_media) = existing.into_iter().next() {
10572 let existing_id = existing_media.id.get().copied().unwrap_or_default();
10573 let payload = serde_json::json!({
10574 "id": null,
10575 "duplicate_of": existing_id,
10576 "duplicate_title": existing_media.title,
10577 "duplicate_filename": existing_media.filename,
10578 "filename": filename,
10579 "mime": existing_media.mime,
10580 "size": existing_media.size,
10581 });
10582 return Ok((
10583 [(axum::http::header::CONTENT_TYPE, "application/json")],
10584 serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
10585 )
10586 .into_response());
10587 }
10588 }
10589 let storage_key = format!("scratch/{}-{filename}", &hash[..16]);
10590 crate::media_storage::disk_for(&tenant.org.slug)
10591 .save(
10592 &crate::media_storage::key(&tenant.org.slug, &storage_key),
10593 &bytes,
10594 )
10595 .await
10596 .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
10597 let size = bytes.len() as i64;
10598 let row = crate::uploaded_file::create(
10599 tenant.pool(),
10600 viewer_id,
10601 storage_key,
10602 filename,
10603 mime,
10604 size,
10605 hash,
10606 )
10607 .await?;
10608 let payload = serde_json::json!({
10609 "id": row.id.get().copied().unwrap_or_default(),
10610 "filename": row.original_filename,
10611 "mime": row.mime,
10612 "size": row.size,
10613 });
10614 Ok((
10615 [(axum::http::header::CONTENT_TYPE, "application/json")],
10616 serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
10617 )
10618 .into_response())
10619}
10620
10621#[derive(Debug, Deserialize)]
10623pub struct StagedCommitItem {
10624 pub uploaded_file_id: i64,
10625 #[serde(default)]
10626 pub title: String,
10627 #[serde(default)]
10628 pub alt_text: String,
10629 #[serde(default)]
10630 pub collection_id: Option<i64>,
10631}
10632
10633#[derive(Debug, Deserialize)]
10638pub struct StagedCommitPayload {
10639 pub items: Vec<StagedCommitItem>,
10640}
10641
10642pub async fn media_upload_staged_commit(
10656 State(_state): State<super::AdminState>,
10657 tenant: Tenant,
10658 headers: HeaderMap,
10659 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10660 Json(payload): Json<StagedCommitPayload>,
10661) -> Result<Response, AdminError> {
10662 use rustango::sql::Auto;
10663 let Some(viewer) = session_user.as_ref() else {
10664 return Ok(unauthorized_no_session_for(Some(&headers)));
10666 };
10667 let viewer_id = viewer.id.get().copied().unwrap_or_default();
10668 let media_slug = tenant.org.slug.clone();
10669
10670 let mut committed: Vec<i64> = Vec::new();
10671 let mut failed: Vec<serde_json::Value> = Vec::new();
10672
10673 for item in payload.items {
10674 let result: Result<i64, String> = async {
10675 let row = crate::uploaded_file::get(tenant.pool(), item.uploaded_file_id)
10676 .await
10677 .map_err(|e| format!("lookup: {e}"))?
10678 .ok_or_else(|| "scratch row missing".to_owned())?;
10679 if row.user_id != viewer_id && !viewer.is_superuser {
10680 return Err("not your upload".to_owned());
10681 }
10682
10683 let scratch_key = crate::media_storage::key(&media_slug, &row.storage_key);
10684 let mut bytes = crate::media_storage::disk_for(&media_slug)
10685 .load(&scratch_key)
10686 .await
10687 .map_err(|e| format!("read scratch: {e}"))?;
10688
10689 let (stored, decoded_dims) =
10691 crate::rendition::strip_exif_off_runtime(bytes, row.mime.clone()).await;
10692 bytes = stored;
10693
10694 let final_key = format!(
10698 "{}-{}",
10699 &row.content_hash[..16.min(row.content_hash.len())],
10700 row.original_filename
10701 );
10702 crate::media_storage::disk_for(&media_slug)
10703 .save(&crate::media_storage::key(&media_slug, &final_key), &bytes)
10704 .await
10705 .map_err(|e| format!("write final: {e}"))?;
10706
10707 let kind = Media::classify_mime(&row.mime).to_owned();
10708 let (width, height): (Option<i32>, Option<i32>) = decoded_dims
10709 .map(|(w, h)| (Some(w as i32), Some(h as i32)))
10710 .unwrap_or((None, None));
10711
10712 let title = if item.title.trim().is_empty() {
10713 row.original_filename
10714 .rsplit_once('.')
10715 .map(|(stem, _)| stem.to_owned())
10716 .unwrap_or_else(|| row.original_filename.clone())
10717 } else {
10718 item.title.trim().to_owned()
10719 };
10720
10721 let mut media_row = Media {
10722 id: Auto::Unset,
10723 filename: row.original_filename.clone(),
10724 content_hash: row.content_hash.clone(),
10725 mime: row.mime.clone(),
10726 size: bytes.len() as i64,
10727 kind,
10728 width,
10729 height,
10730 storage_key: final_key,
10731 title,
10732 alt_text: item.alt_text.trim().to_owned(),
10733 description: String::new(),
10734 uploaded_by: Some(viewer_id),
10735 collection_id: item.collection_id,
10736 focal_point_x: None,
10737 focal_point_y: None,
10738 uploaded_at: Auto::Unset,
10739 };
10740 media_row
10741 .insert_pool(tenant.pool())
10742 .await
10743 .map_err(|e| format!("insert media: {e}"))?;
10744 let new_id = media_row.id.get().copied().unwrap_or_default();
10745
10746 crate::media_storage::disk_for(&media_slug)
10751 .delete(&scratch_key)
10752 .await
10753 .log_warn("stored file not deleted; the blob is orphaned");
10754 crate::uploaded_file::delete(tenant.pool(), item.uploaded_file_id)
10755 .await
10756 .map_err(|e| format!("delete scratch: {e}"))?;
10757 Ok(new_id)
10758 }
10759 .await;
10760
10761 match result {
10762 Ok(id) => committed.push(id),
10763 Err(e) => {
10764 failed.push(serde_json::json!({
10765 "uploaded_file_id": item.uploaded_file_id,
10766 "error": e,
10767 }));
10768 }
10769 }
10770 }
10771
10772 let body = serde_json::json!({
10773 "committed": committed,
10774 "failed": failed,
10775 });
10776 Ok((
10777 [(axum::http::header::CONTENT_TYPE, "application/json")],
10778 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
10779 )
10780 .into_response())
10781}
10782
10783pub async fn media_upload_staged_cancel(
10786 State(_state): State<super::AdminState>,
10787 tenant: Tenant,
10788 headers: HeaderMap,
10789 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10790 Path(id): Path<i64>,
10791) -> Result<Response, AdminError> {
10792 let Some(viewer) = session_user.as_ref() else {
10793 return Ok(unauthorized_no_session_for(Some(&headers)));
10795 };
10796 let viewer_id = viewer.id.get().copied().unwrap_or_default();
10797 let Some(row) = crate::uploaded_file::get(tenant.pool(), id).await? else {
10798 return Ok((axum::http::StatusCode::NOT_FOUND, "not found").into_response());
10799 };
10800 if row.user_id != viewer_id && !viewer.is_superuser {
10801 return Ok((axum::http::StatusCode::FORBIDDEN, "not your upload").into_response());
10802 }
10803 crate::media_storage::disk_for(&tenant.org.slug)
10804 .delete(&crate::media_storage::key(
10805 &tenant.org.slug,
10806 &row.storage_key,
10807 ))
10808 .await
10809 .log_warn("stored file not deleted; the blob is orphaned");
10810 crate::uploaded_file::delete(tenant.pool(), id).await?;
10811 Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
10812}
10813
10814fn refuse_active_upload(mime: &str) -> Result<(), AdminError> {
10820 let active = matches!(
10821 mime,
10822 "text/html"
10823 | "application/xhtml+xml"
10824 | "text/javascript"
10825 | "application/javascript"
10826 | "application/ecmascript"
10827 | "text/xml"
10828 | "application/xml"
10829 | "text/xsl"
10830 | "application/xslt+xml"
10831 );
10832 if active {
10833 return Err(AdminError::Upload(format!(
10834 "files of type {mime} can't be uploaded: a browser would run them as a page"
10835 )));
10836 }
10837 Ok(())
10838}
10839
10840#[allow(clippy::too_many_arguments)]
10850pub(crate) async fn store_media(
10851 pool: &rustango::sql::Pool,
10852 org_slug: &str,
10853 mut bytes: Vec<u8>,
10854 raw_filename: &str,
10855 title: Option<&str>,
10856 alt_text: &str,
10857 collection_id: Option<i64>,
10858 uploaded_by: Option<i64>,
10859 dedupe: bool,
10860) -> Result<Media, AdminError> {
10861 use rustango::sql::Auto;
10862 use sha2::{Digest, Sha256};
10863
10864 let filename = sanitize_filename(raw_filename);
10865 if filename.is_empty() || bytes.is_empty() {
10866 return Err(AdminError::Upload("no file submitted".into()));
10867 }
10868
10869 let mime = mime_guess::from_path(&filename)
10870 .first_or_octet_stream()
10871 .essence_str()
10872 .to_owned();
10873 refuse_active_upload(&mime)?;
10874 let kind = Media::classify_mime(&mime).to_owned();
10875
10876 let (stored, decoded_dims) = crate::rendition::strip_exif_off_runtime(bytes, mime.clone()).await;
10879 bytes = stored;
10880
10881 let mut hasher = Sha256::new();
10882 hasher.update(&bytes);
10883 let digest = hasher.finalize();
10884 let hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
10885 use std::fmt::Write as _;
10886 let _ = write!(acc, "{b:02x}");
10887 acc
10888 });
10889
10890 if dedupe {
10891 if let Some(existing) = Media::objects()
10892 .where_(Media::content_hash.eq(hash.clone()))
10893 .first(pool)
10894 .await?
10895 {
10896 return Ok(existing);
10897 }
10898 }
10899
10900 let storage_key = format!("{}-{}", &hash[..16], filename);
10902 crate::media_storage::disk_for(&org_slug)
10903 .save(&crate::media_storage::key(org_slug, &storage_key), &bytes)
10904 .await
10905 .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
10906
10907 let title = match title {
10908 Some(t) if !t.is_empty() => t.to_owned(),
10909 _ => filename
10910 .rsplit_once('.')
10911 .map(|(stem, _)| stem.to_owned())
10912 .unwrap_or_else(|| filename.clone()),
10913 };
10914
10915 let (width, height): (Option<i32>, Option<i32>) = decoded_dims
10918 .map(|(w, h)| (Some(w as i32), Some(h as i32)))
10919 .unwrap_or((None, None));
10920
10921 let mut row = Media {
10922 id: Auto::Unset,
10923 filename,
10924 content_hash: hash,
10925 mime,
10926 size: bytes.len() as i64,
10927 kind,
10928 width,
10929 height,
10930 storage_key,
10931 title,
10932 alt_text: alt_text.to_owned(),
10933 description: String::new(),
10934 uploaded_by,
10935 collection_id,
10936 focal_point_x: None,
10937 focal_point_y: None,
10938 uploaded_at: Auto::Unset,
10939 };
10940 row.insert_pool(pool).await?;
10941 Ok(row)
10942}
10943
10944pub async fn media_upload_submit(
10945 State(_state): State<super::AdminState>,
10946 tenant: Tenant,
10947 mut multipart: axum::extract::Multipart,
10948) -> Result<Response, AdminError> {
10949 let mut filename = String::new();
10950 let mut bytes: Vec<u8> = Vec::new();
10951 let mut title = String::new();
10952 let mut alt_text = String::new();
10953 let mut crop_x: Option<u32> = None;
10958 let mut crop_y: Option<u32> = None;
10959 let mut crop_w: Option<u32> = None;
10960 let mut crop_h: Option<u32> = None;
10961
10962 while let Some(field) = multipart
10963 .next_field()
10964 .await
10965 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
10966 {
10967 let name = field.name().unwrap_or("").to_owned();
10968 match name.as_str() {
10969 "file" => {
10970 if let Some(fname) = field.file_name() {
10971 filename = sanitize_filename(fname);
10972 }
10973 bytes = field
10974 .bytes()
10975 .await
10976 .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
10977 .to_vec();
10978 }
10979 "title" => {
10980 title = field
10981 .text()
10982 .await
10983 .map_err(|e| AdminError::Upload(format!("read title: {e}")))?;
10984 }
10985 "alt_text" => {
10986 alt_text = field
10987 .text()
10988 .await
10989 .map_err(|e| AdminError::Upload(format!("read alt_text: {e}")))?;
10990 }
10991 "crop_x" | "crop_y" | "crop_w" | "crop_h" => {
10992 let value = field
10993 .text()
10994 .await
10995 .map_err(|e| AdminError::Upload(format!("read {name}: {e}")))?;
10996 let parsed: Option<u32> = value.trim().parse().ok();
10997 match name.as_str() {
10998 "crop_x" => crop_x = parsed,
10999 "crop_y" => crop_y = parsed,
11000 "crop_w" => crop_w = parsed,
11001 "crop_h" => crop_h = parsed,
11002 _ => {}
11003 }
11004 }
11005 _ => {
11006 let _ = field.bytes().await;
11007 }
11008 }
11009 }
11010
11011 if filename.is_empty() || bytes.is_empty() {
11012 return Err(AdminError::Upload("no file submitted".into()));
11013 }
11014
11015 if let (Some(x), Some(y), Some(w), Some(h)) = (crop_x, crop_y, crop_w, crop_h) {
11019 if w > 0 && h > 0 {
11020 let detected_mime = mime_guess::from_path(&filename)
11021 .first_or_octet_stream()
11022 .essence_str()
11023 .to_owned();
11024 refuse_active_upload(&detected_mime)?;
11025 if detected_mime == "image/svg+xml" {
11026 return Err(AdminError::Validation(
11027 "Cropping SVG sources isn't supported; upload uncropped, then edit the markup."
11028 .to_owned(),
11029 ));
11030 }
11031 if detected_mime.starts_with("image/") {
11032 let (cropped, _out_mime) = crate::rendition::crop_image_off_runtime(
11033 bytes,
11034 detected_mime.clone(),
11035 (x, y, w, h),
11036 )
11037 .await
11038 .map_err(AdminError::Validation)?;
11039 bytes = cropped;
11040 }
11041 }
11042 }
11043
11044 let row = store_media(
11048 tenant.pool(),
11049 &tenant.org.slug,
11050 bytes,
11051 &filename,
11052 (!title.is_empty()).then_some(title.as_str()),
11053 &alt_text,
11054 None,
11055 None,
11056 false,
11057 )
11058 .await?;
11059
11060 let redirect = if row.kind == "image" {
11061 "/cms-admin/media"
11062 } else {
11063 "/cms-admin/documents"
11064 };
11065 Ok(Redirect::to(redirect).into_response())
11066}
11067
11068pub async fn media_delete_submit(
11070 State(_state): State<super::AdminState>,
11071 tenant: Tenant,
11072 Path(id): Path<i64>,
11073) -> Result<Response, AdminError> {
11074 let row = Media::objects()
11075 .where_(Media::id.eq(id))
11076 .first(tenant.pool())
11077 .await?
11078 .ok_or(AdminError::NotFound(id))?;
11079 crate::media_storage::disk_for(&tenant.org.slug)
11081 .delete(&crate::media_storage::key(
11082 &tenant.org.slug,
11083 &row.storage_key,
11084 ))
11085 .await
11086 .log_warn("stored file not deleted; the blob is orphaned");
11087 let redirect = if row.kind == "image" {
11088 "/cms-admin/media"
11089 } else {
11090 "/cms-admin/documents"
11091 };
11092 row.delete_pool(tenant.pool()).await?;
11093 Ok(Redirect::to(redirect).into_response())
11094}
11095
11096fn sanitize_filename(raw: &str) -> String {
11097 raw.chars()
11098 .map(|c| {
11099 if c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_') {
11100 c
11101 } else {
11102 '_'
11103 }
11104 })
11105 .collect()
11106}
11107
11108pub async fn model_admin_list(
11119 State(state): State<super::AdminState>,
11120 tenant: Tenant,
11121 headers: HeaderMap,
11122 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11123 Path(slug): Path<String>,
11124) -> Result<Response, AdminError> {
11125 let Some(ma) = super::model_admin::find(&slug) else {
11126 return Ok((axum::http::StatusCode::NOT_FOUND, "unknown model admin").into_response());
11127 };
11128 let rows_json = (ma.list_rows)(tenant.pool().clone()).await;
11129 let columns = super::model_admin::list_columns(ma.schema);
11130 let header_labels: Vec<&str> = columns.iter().map(|(_, l)| l.as_str()).collect();
11131 let body_rows: Vec<Vec<String>> = rows_json
11132 .iter()
11133 .map(|r| {
11134 columns
11135 .iter()
11136 .map(|(name, _)| super::model_admin::row_cell(r, name))
11137 .collect()
11138 })
11139 .collect();
11140 let mut ctx = Context::new();
11141 add_chrome(&mut ctx, &tenant, "model-admin", session_user.as_ref()).await;
11142 add_admin_theme(&mut ctx, tenant.pool()).await;
11143 ctx.insert("model_label", ma.label);
11144 ctx.insert("model_slug", &slug);
11145 ctx.insert("columns", &header_labels);
11146 ctx.insert("rows", &body_rows);
11147 ctx.insert("total", &body_rows.len());
11148 render_with_csrf(
11149 &state,
11150 &headers,
11151 "rcms_admin/model_admin_list.html",
11152 &mut ctx,
11153 )
11154}
11155
11156#[derive(serde::Deserialize, Default)]
11158pub struct ReportQuery {
11159 pub format: Option<String>,
11160}
11161
11162pub async fn report_view(
11166 State(state): State<super::AdminState>,
11167 tenant: Tenant,
11168 headers: HeaderMap,
11169 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11170 Path(slug): Path<String>,
11171 Query(q): Query<ReportQuery>,
11172) -> Result<Response, AdminError> {
11173 let Some(report) = super::report::find_report(&slug) else {
11174 return Ok((axum::http::StatusCode::NOT_FOUND, "unknown report").into_response());
11175 };
11176 let user_id = session_user.as_ref().and_then(|u| u.id.get().copied());
11177 let columns = report.columns();
11178 let rows = report.rows(tenant.pool(), user_id).await;
11179
11180 if q.format.as_deref() == Some("csv") {
11182 let mut out = String::with_capacity(128 + rows.len() * 64);
11183 let header: Vec<String> = columns.iter().map(|c| csv_escape(c.label)).collect();
11184 out.push_str(&header.join(","));
11185 out.push('\n');
11186 for row in &rows {
11187 let line: Vec<String> = columns
11188 .iter()
11189 .map(|c| csv_escape(&report_cell_string(row.get(c.key))))
11190 .collect();
11191 out.push_str(&line.join(","));
11192 out.push('\n');
11193 }
11194 return Ok(csv_response(&slug, &out));
11195 }
11196
11197 let header_labels: Vec<&str> = columns.iter().map(|c| c.label).collect();
11198 let view_rows: Vec<serde_json::Value> = rows
11199 .iter()
11200 .map(|row| {
11201 let cells: Vec<serde_json::Value> = columns
11202 .iter()
11203 .map(|c| {
11204 serde_json::json!({
11205 "kind": c.kind.as_str(),
11206 "value": report_cell_string(row.get(c.key)),
11207 })
11208 })
11209 .collect();
11210 serde_json::json!({
11211 "edit_url": row.get("edit_url").and_then(|v| v.as_str()),
11212 "cells": cells,
11213 })
11214 })
11215 .collect();
11216
11217 let mut ctx = Context::new();
11218 add_chrome(
11219 &mut ctx,
11220 &tenant,
11221 &format!("report:{slug}"),
11222 session_user.as_ref(),
11223 )
11224 .await;
11225 add_admin_theme(&mut ctx, tenant.pool()).await;
11226 ctx.insert("report_title", report.title());
11227 ctx.insert("report_slug", &slug);
11228 ctx.insert("report_description", &report.description());
11229 ctx.insert("columns", &header_labels);
11230 ctx.insert("rows", &view_rows);
11231 ctx.insert("total", &view_rows.len());
11232 render_with_csrf(&state, &headers, "rcms_admin/report.html", &mut ctx)
11233}
11234
11235pub async fn forms_list(
11244 State(state): State<super::AdminState>,
11245 tenant: Tenant,
11246 headers: HeaderMap,
11247 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11248) -> Result<Response, AdminError> {
11249 let pool = tenant.pool();
11250 let rows = forms_list_rows(pool).await?;
11251
11252 let mut ctx = Context::new();
11253 add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11254 add_admin_theme(&mut ctx, pool).await;
11255 ctx.insert("rows", &rows);
11256 ctx.insert("total", &rows.len());
11257 render_with_csrf(&state, &headers, "rcms_admin/forms_list.html", &mut ctx)
11258}
11259
11260pub(crate) async fn forms_list_rows(
11264 pool: &rustango::sql::Pool,
11265) -> Result<Vec<serde_json::Value>, AdminError> {
11266 let mut forms: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
11267 .where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
11268 .fetch(pool)
11269 .await?;
11270 forms.sort_by(|a, b| {
11272 b.updated_at
11273 .get()
11274 .cloned()
11275 .cmp(&a.updated_at.get().cloned())
11276 });
11277
11278 let entries: Vec<crate::forms::submit::FormEntry> = crate::forms::submit::FormEntry::objects()
11282 .fetch(pool)
11283 .await?;
11284 let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
11285 let mut last_at: std::collections::HashMap<i64, String> = std::collections::HashMap::new();
11286 for e in &entries {
11287 *counts.entry(e.form_snippet_id).or_default() += 1;
11288 if let Some(at) = e.submitted_at.get() {
11289 let s = at.format("%Y-%m-%d %H:%M").to_string();
11290 let slot = last_at.entry(e.form_snippet_id).or_default();
11291 if s > *slot {
11292 *slot = s;
11293 }
11294 }
11295 }
11296
11297 let rows: Vec<serde_json::Value> = forms
11298 .iter()
11299 .map(|s| {
11300 let id = s.id.get().copied().unwrap_or_default();
11301 let parsed = crate::forms::schema::parse(&s.data).unwrap_or_default();
11302 serde_json::json!({
11303 "id": id,
11304 "title": s.title,
11305 "slug": s.slug,
11306 "fields": parsed.field_count(),
11307 "submissions": counts.get(&id).copied().unwrap_or(0),
11308 "last_submission": last_at.get(&id).cloned().unwrap_or_default(),
11309 "updated_at": s.updated_at.get().map(|d| d.format("%Y-%m-%d").to_string()).unwrap_or_default(),
11310 "build_url": format!("/cms-admin/forms/{id}/build"),
11311 "submissions_url": format!("/cms-admin/forms/{id}/submissions"),
11312 "delete_url": format!("/cms-admin/library/{id}/delete"),
11313 })
11314 })
11315 .collect();
11316 Ok(rows)
11317}
11318
11319pub async fn form_build_form(
11323 State(state): State<super::AdminState>,
11324 tenant: Tenant,
11325 headers: HeaderMap,
11326 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11327 Path(id): Path<i64>,
11328 Query(q): Query<EditQuery>,
11329) -> Result<Response, AdminError> {
11330 let snippet = crate::snippet::Snippet::objects()
11331 .where_(crate::snippet::Snippet::id.eq(id))
11332 .first(tenant.pool())
11333 .await?
11334 .ok_or(AdminError::NotFound(id))?;
11335 if snippet.type_name != "form" {
11336 return Err(AdminError::NotFound(id));
11337 }
11338 let mut ctx = Context::new();
11339 add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11340 add_admin_theme(&mut ctx, tenant.pool()).await;
11341 ctx.insert("title", &snippet.title);
11342 ctx.insert("form_id", &id);
11343 ctx.insert("build_url", &format!("/cms-admin/forms/{id}/build"));
11344
11345 let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
11347 .where_(crate::locale::Locale::active.eq(true))
11348 .where_(crate::locale::Locale::is_default.eq(false))
11349 .fetch(tenant.pool())
11350 .await
11351 .unwrap_or_default();
11352 ctx.insert(
11353 "locales",
11354 &locales
11355 .iter()
11356 .map(|l| serde_json::json!({"code": l.code, "name": l.name}))
11357 .collect::<Vec<_>>(),
11358 );
11359
11360 if let Some(code) = q.locale.as_deref().filter(|c| !c.is_empty()) {
11363 if let Some(loc) = locales.iter().find(|l| l.code == code) {
11364 let lid = loc.id.get().copied().unwrap_or(0);
11365 let form = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11366 let leaves = crate::forms::schema::translatable_leaves(&form);
11367 let existing = crate::snippet_translation::fetch_for(tenant.pool(), id, lid)
11368 .await
11369 .unwrap_or_default();
11370 let mut groups: Vec<serde_json::Value> = Vec::new();
11373 for l in &leaves {
11374 let row = serde_json::json!({
11375 "path": l.path,
11376 "part": l.part,
11377 "n": l.n.to_string(),
11378 "canonical": l.text,
11379 "value": existing.get(&l.path).cloned().unwrap_or_default(),
11380 });
11381 let same = groups
11382 .last()
11383 .is_some_and(|g| g["name"].as_str() == Some(l.group.as_str()));
11384 if same {
11385 if let Some(arr) = groups
11386 .last_mut()
11387 .and_then(|g| g.get_mut("leaves"))
11388 .and_then(|v| v.as_array_mut())
11389 {
11390 arr.push(row);
11391 }
11392 } else {
11393 groups.push(serde_json::json!({ "name": l.group, "leaves": [row] }));
11394 }
11395 }
11396 ctx.insert("editing_locale", &loc.name);
11397 ctx.insert("editing_code", &code);
11398 ctx.insert("trans_groups", &groups);
11399 ctx.insert(
11400 "translate_url",
11401 &format!("/cms-admin/library/{id}/translate"),
11402 );
11403 return render_with_csrf(&state, &headers, "rcms_admin/form_translate.html", &mut ctx);
11404 }
11405 }
11406
11407 ctx.insert("list_url", "/cms-admin/forms");
11413 ctx.insert("publish_url", &format!("/cms-admin/forms/{id}/publish"));
11415 ctx.insert(
11416 "has_unpublished",
11417 &crate::forms::schema::has_unpublished_changes(&snippet.data),
11418 );
11419 let mut draft = crate::forms::schema::parse_draft(&snippet.data);
11420 draft.sanitize_rich_text();
11421 let schema_json = serde_json::to_string(&crate::forms::schema::to_value(&draft))
11422 .unwrap_or_else(|_| "{}".to_owned());
11423 ctx.insert("schema_json", &schema_json);
11424 render_with_csrf(&state, &headers, "rcms_admin/form_builder.html", &mut ctx)
11425}
11426
11427#[derive(Debug, Deserialize)]
11428pub struct FormBuildSubmit {
11429 pub schema: String,
11430}
11431
11432#[derive(Debug, Deserialize)]
11434pub struct FormPageTypeCreate {
11435 #[serde(default)]
11436 pub verbose_name: String,
11437 #[serde(default)]
11438 pub type_name: String,
11439 #[serde(default)]
11440 pub allowed_parents: String,
11441 #[serde(default)]
11442 pub allowed_children: String,
11443 #[serde(default)]
11447 pub view_mode: String,
11448 #[serde(default)]
11450 pub workflow: String,
11451}
11452
11453#[derive(Debug, Deserialize)]
11456pub struct FormComponentSubmit {
11457 #[serde(default)]
11458 pub slug: String,
11459 #[serde(default)]
11460 pub label: String,
11461 #[serde(default)]
11462 pub icon: String,
11463 #[serde(default)]
11464 pub description: String,
11465 #[serde(default)]
11466 pub schema: String,
11467}
11468
11469pub async fn form_preview(
11483 tenant: Tenant,
11484 Path(id): Path<i64>,
11485 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11486) -> Result<Response, AdminError> {
11487 let snippet = load_form_snippet(&tenant, id).await?;
11488 let form = crate::forms::schema::parse_draft(&snippet.data);
11489 Ok(render_form_preview(id, &form))
11490}
11491
11492pub async fn form_preview_draft(
11496 tenant: Tenant,
11497 Path(id): Path<i64>,
11498 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11499 Form(body): Form<FormBuildSubmit>,
11500) -> Result<Response, AdminError> {
11501 let snippet = load_form_snippet(&tenant, id).await?;
11502 let form = crate::forms::schema::parse_str(&body.schema)
11506 .unwrap_or_else(|_| crate::forms::schema::parse_draft(&snippet.data));
11507 Ok(render_form_preview(id, &form))
11508}
11509
11510async fn load_form_snippet(
11512 tenant: &Tenant,
11513 id: i64,
11514) -> Result<crate::snippet::Snippet, AdminError> {
11515 let snippet = crate::snippet::Snippet::objects()
11516 .where_(crate::snippet::Snippet::id.eq(id))
11517 .first(tenant.pool())
11518 .await?
11519 .ok_or(AdminError::NotFound(id))?;
11520 if snippet.type_name != "form" {
11521 return Err(AdminError::NotFound(id));
11522 }
11523 Ok(snippet)
11524}
11525
11526fn render_form_preview(id: i64, form: &crate::forms::schema::Form) -> Response {
11527 let inner = crate::forms::render::render_form_html(form, id, "");
11530 let html = format!(
11531 "<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\">\
11532 <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\
11533 <title>Form preview</title>\
11534 <style>body{{margin:0;padding:24px;font:14px/1.5 system-ui,sans-serif;}}</style>\
11535 </head><body>{inner}</body></html>"
11536 );
11537 stamp_no_cache(
11538 (
11539 [(
11540 axum::http::header::CONTENT_TYPE,
11541 axum::http::HeaderValue::from_static("text/html; charset=utf-8"),
11542 )],
11543 html,
11544 )
11545 .into_response(),
11546 )
11547}
11548
11549pub async fn form_build_submit(
11551 State(_state): State<super::AdminState>,
11552 tenant: Tenant,
11553 headers: HeaderMap,
11554 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11555 Path(id): Path<i64>,
11556 Form(form): Form<FormBuildSubmit>,
11557) -> Result<Response, AdminError> {
11558 let mut snippet = crate::snippet::Snippet::objects()
11559 .where_(crate::snippet::Snippet::id.eq(id))
11560 .first(tenant.pool())
11561 .await?
11562 .ok_or(AdminError::NotFound(id))?;
11563 if snippet.type_name != "form" {
11564 return Err(AdminError::NotFound(id));
11565 }
11566 let mut parsed = crate::forms::schema::parse_str(&form.schema)
11567 .map_err(|e| AdminError::Validation(format!("invalid form schema: {e}")))?;
11568 parsed.sanitize_rich_text();
11569 let mut warnings = crate::forms::schema::validate(&parsed);
11570 snippet.data = crate::forms::schema::save_draft_value(&snippet.data, &parsed);
11573 snippet.save_pool(tenant.pool()).await?;
11574 if let Err(e) = crate::notify::targets::sync_form_email(
11577 tenant.pool(),
11578 id,
11579 &snippet.title,
11580 &parsed.settings.notify_emails,
11581 )
11582 .await
11583 {
11584 tracing::warn!(
11585 target: "rustango_cms::notify",
11586 error = %e, form_id = id,
11587 "could not sync the form's email notification target"
11588 );
11589 warnings.push(format!("Email notifications are off: {e}."));
11590 }
11591 let (level, msg) = if warnings.is_empty() {
11592 (MsgLevel::Success, "Draft saved.".to_owned())
11593 } else {
11594 (
11595 MsgLevel::Warning,
11596 format!("Draft saved with warnings: {}", warnings.join(" ")),
11597 )
11598 };
11599 redirect_named_with_params_and_message(
11600 "rcms-admin:forms:build",
11601 &[("id", id.to_string())],
11602 level,
11603 &msg,
11604 &headers,
11605 )
11606}
11607
11608pub async fn form_publish_submit(
11611 State(_state): State<super::AdminState>,
11612 tenant: Tenant,
11613 headers: HeaderMap,
11614 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11615 Path(id): Path<i64>,
11616 Form(form): Form<FormBuildSubmit>,
11617) -> Result<Response, AdminError> {
11618 let mut snippet = crate::snippet::Snippet::objects()
11619 .where_(crate::snippet::Snippet::id.eq(id))
11620 .first(tenant.pool())
11621 .await?
11622 .ok_or(AdminError::NotFound(id))?;
11623 if snippet.type_name != "form" {
11624 return Err(AdminError::NotFound(id));
11625 }
11626 let mut parsed = crate::forms::schema::parse_str(&form.schema)
11627 .map_err(|e| AdminError::Validation(format!("invalid form schema: {e}")))?;
11628 parsed.sanitize_rich_text();
11629 snippet.data = crate::forms::schema::publish_value(&parsed);
11630 snippet.save_pool(tenant.pool()).await?;
11631 if let Some(h) = crate::library::find_handler(&snippet.type_name) {
11632 if h.revisions_enabled() {
11633 let uid = session_user.as_ref().and_then(|u| u.id.get().copied());
11634 crate::snippet::capture_revision(tenant.pool(), &snippet, uid)
11635 .await
11636 .log_warn("revision not captured; the history has a gap");
11637 }
11638 }
11639 redirect_named_with_params_and_message(
11640 "rcms-admin:forms:build",
11641 &[("id", id.to_string())],
11642 MsgLevel::Success,
11643 "Form published — the live form is now up to date.",
11644 &headers,
11645 )
11646}
11647
11648async fn load_form_submissions(
11652 pool: &rustango::sql::Pool,
11653 form_id: i64,
11654) -> Result<
11655 (
11656 crate::snippet::Snippet,
11657 Vec<(String, String)>,
11658 Vec<crate::forms::submit::FormEntry>,
11659 std::collections::HashMap<i64, String>,
11660 ),
11661 AdminError,
11662> {
11663 let snippet = crate::snippet::Snippet::objects()
11664 .where_(crate::snippet::Snippet::id.eq(form_id))
11665 .where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
11666 .first(pool)
11667 .await?
11668 .ok_or(AdminError::NotFound(form_id))?;
11669 let form = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11670 let columns: Vec<(String, String)> = form
11671 .fields()
11672 .filter(|f| f.field_type.collects_value() && !f.key.is_empty())
11673 .map(|f| {
11674 (
11675 f.key.clone(),
11676 if f.label.is_empty() {
11677 f.key.clone()
11678 } else {
11679 f.label.clone()
11680 },
11681 )
11682 })
11683 .collect();
11684 let entries: Vec<crate::forms::submit::FormEntry> = crate::forms::submit::FormEntry::objects()
11685 .where_(crate::forms::submit::FormEntry::form_snippet_id.eq(form_id))
11686 .order_by(&[("submitted_at", true)])
11687 .fetch(pool)
11688 .await?;
11689 let mut page_urls = std::collections::HashMap::new();
11691 let ids: Vec<i64> = entries
11692 .iter()
11693 .map(|e| e.source_page_id)
11694 .filter(|i| *i != 0)
11695 .collect();
11696 if !ids.is_empty() {
11697 if let Ok(pages) = crate::page::Page::objects().fetch(pool).await {
11698 for p in pages {
11699 if let Some(pid) = p.id.get().copied() {
11700 if ids.contains(&pid) {
11701 page_urls.insert(pid, p.url_path.clone());
11702 }
11703 }
11704 }
11705 }
11706 }
11707 Ok((snippet, columns, entries, page_urls))
11708}
11709
11710fn submission_cell(data: &serde_json::Value, key: &str) -> String {
11712 match data.get(key) {
11713 Some(serde_json::Value::Array(items)) => items
11714 .iter()
11715 .filter_map(|v| v.as_str().map(str::to_owned))
11716 .collect::<Vec<_>>()
11717 .join("; "),
11718 Some(serde_json::Value::String(s)) => s.clone(),
11719 Some(other) => other.to_string(),
11720 None => String::new(),
11721 }
11722}
11723
11724pub async fn form_submissions_list(
11727 State(state): State<super::AdminState>,
11728 tenant: Tenant,
11729 headers: HeaderMap,
11730 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11731 Path(id): Path<i64>,
11732) -> Result<Response, AdminError> {
11733 let (snippet, columns, entries, page_urls) = load_form_submissions(tenant.pool(), id).await?;
11734 let parsed = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11736 let file_keys: std::collections::HashSet<String> = parsed
11737 .fields()
11738 .filter(|f| matches!(f.field_type, crate::forms::schema::FieldType::File))
11739 .map(|f| f.key.clone())
11740 .collect();
11741 let rows: Vec<serde_json::Value> = entries
11742 .iter()
11743 .map(|e| {
11744 let cells: Vec<serde_json::Value> = columns
11745 .iter()
11746 .map(|(k, _)| {
11747 let v = submission_cell(&e.data_json, k);
11748 if file_keys.contains(k) && !v.is_empty() {
11749 let name = v.splitn(2, '-').nth(1).unwrap_or(&v).to_owned();
11751 serde_json::json!({
11752 "value": name,
11753 "url": format!("/cms-admin/forms/{id}/submissions/file/{v}"),
11754 })
11755 } else {
11756 serde_json::json!({ "value": v })
11757 }
11758 })
11759 .collect();
11760 serde_json::json!({
11761 "submitted_at": e
11764 .submitted_at
11765 .get()
11766 .map(|t| t.to_rfc3339_opts(chrono::SecondsFormat::Secs, true))
11767 .unwrap_or_default(),
11768 "submitted_at_text": e
11769 .submitted_at
11770 .get()
11771 .map(|t| t.format("%Y-%m-%d %H:%M UTC").to_string())
11772 .unwrap_or_default(),
11773 "ip": e.ip,
11774 "source_page": if e.source_page_id == 0 {
11775 serde_json::Value::Null
11776 } else {
11777 serde_json::json!({
11778 "id": e.source_page_id,
11779 "url": page_urls.get(&e.source_page_id).cloned().unwrap_or_default(),
11780 })
11781 },
11782 "cells": cells,
11783 })
11784 })
11785 .collect();
11786 let mut ctx = Context::new();
11787 add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11788 add_admin_theme(&mut ctx, tenant.pool()).await;
11789 ctx.insert("form_title", &snippet.title);
11790 ctx.insert("form_id", &id);
11791 ctx.insert("build_url", &format!("/cms-admin/forms/{id}/build"));
11792 ctx.insert(
11793 "csv_url",
11794 &format!("/cms-admin/forms/{id}/submissions/export.csv"),
11795 );
11796 ctx.insert(
11797 "columns",
11798 &columns.iter().map(|(_, l)| l).collect::<Vec<_>>(),
11799 );
11800 ctx.insert("rows", &rows);
11801 ctx.insert("total", &entries.len());
11802 render_with_csrf(
11803 &state,
11804 &headers,
11805 "rcms_admin/form_submissions.html",
11806 &mut ctx,
11807 )
11808}
11809
11810pub async fn form_submissions_csv(
11812 State(_state): State<super::AdminState>,
11813 tenant: Tenant,
11814 Path(id): Path<i64>,
11815) -> Result<Response, AdminError> {
11816 let (snippet, columns, entries, page_urls) = load_form_submissions(tenant.pool(), id).await?;
11817 let mut out = String::new();
11818 out.push_str("submitted_at,source_page,ip");
11819 for (_, label) in &columns {
11820 out.push(',');
11821 out.push_str(&csv_escape(label));
11822 }
11823 out.push('\n');
11824 for e in &entries {
11825 let when = e
11826 .submitted_at
11827 .get()
11828 .map(ToString::to_string)
11829 .unwrap_or_default();
11830 let src = if e.source_page_id == 0 {
11831 String::new()
11832 } else {
11833 page_urls
11834 .get(&e.source_page_id)
11835 .cloned()
11836 .unwrap_or_default()
11837 };
11838 out.push_str(&csv_escape(&when));
11839 out.push(',');
11840 out.push_str(&csv_escape(&src));
11841 out.push(',');
11842 out.push_str(&csv_escape(&e.ip));
11843 for (k, _) in &columns {
11844 out.push(',');
11845 out.push_str(&csv_escape(&submission_cell(&e.data_json, k)));
11846 }
11847 out.push('\n');
11848 }
11849 let filename = format!("submissions-{}.csv", snippet.slug);
11850 Ok(csv_response(&filename, &out))
11851}
11852
11853pub async fn form_submission_file(
11857 State(_state): State<super::AdminState>,
11858 tenant: Tenant,
11859 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11860 Path((_id, key)): Path<(i64, String)>,
11861) -> Result<Response, AdminError> {
11862 if key.contains('/') || key.contains('\\') || key.contains("..") || key.is_empty() {
11863 return Err(AdminError::NotFound(0));
11864 }
11865 let path = std::path::PathBuf::from("./var/form-uploads")
11866 .join(&tenant.org.slug)
11867 .join(&key);
11868 let bytes = std::fs::read(&path).map_err(|_| AdminError::NotFound(0))?;
11869 let mime = mime_guess::from_path(&key)
11870 .first_or_octet_stream()
11871 .essence_str()
11872 .to_owned();
11873 let download = key.splitn(2, '-').nth(1).unwrap_or(&key).to_owned();
11874 Ok((
11875 [
11876 (header::CONTENT_TYPE, mime),
11877 (
11878 header::CONTENT_DISPOSITION,
11879 format!("attachment; filename=\"{download}\""),
11880 ),
11881 ],
11882 bytes,
11883 )
11884 .into_response())
11885}
11886
11887#[derive(Debug, Deserialize)]
11888pub struct SetLangQuery {
11889 pub lang: String,
11890}
11891
11892pub async fn admin_set_language(
11898 tenant: Tenant,
11899 headers: HeaderMap,
11900 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11901 Form(q): Form<SetLangQuery>,
11902) -> Response {
11903 let lang = if super::i18n::is_ui_locale(&q.lang) {
11904 q.lang
11905 } else {
11906 "en".to_owned()
11907 };
11908 if let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) {
11912 persist_user_admin_lang(tenant.pool(), uid, &lang)
11913 .await
11914 .log_warn("admin language preference not saved");
11915 }
11916 let back = headers
11920 .get(header::REFERER)
11921 .and_then(|v| v.to_str().ok())
11922 .and_then(|r| match r.split_once("://") {
11923 Some((_, rest)) => rest.find('/').map(|i| &rest[i..]),
11924 None => Some(r),
11925 })
11926 .and_then(rustango::auth_decorators::safe_next)
11927 .unwrap_or_else(|| "/cms-admin/".to_owned());
11928 let cookie = format!(
11929 "{}={lang}; Path=/; SameSite=Lax; Max-Age=31536000",
11930 super::i18n::ADMIN_LANG_COOKIE
11931 );
11932 let mut resp = axum::response::Redirect::to(&back).into_response();
11933 if let Ok(v) = HeaderValue::from_str(&cookie) {
11934 resp.headers_mut().append(header::SET_COOKIE, v);
11935 }
11936 resp
11937}
11938
11939fn csv_escape(s: &str) -> String {
11943 if s.contains(',') || s.contains('"') || s.contains('\n') || s.contains('\r') {
11944 let mut out = String::with_capacity(s.len() + 2);
11945 out.push('"');
11946 for c in s.chars() {
11947 if c == '"' {
11948 out.push('"');
11949 }
11950 out.push(c);
11951 }
11952 out.push('"');
11953 out
11954 } else {
11955 s.to_owned()
11956 }
11957}
11958
11959fn report_cell_string(v: Option<&serde_json::Value>) -> String {
11962 match v {
11963 Some(serde_json::Value::String(s)) => s.clone(),
11964 None | Some(serde_json::Value::Null) => String::new(),
11965 Some(other) => other.to_string(),
11966 }
11967}
11968
11969pub async fn locale_list(
11970 State(state): State<super::AdminState>,
11971 tenant: Tenant,
11972 headers: HeaderMap,
11973 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11974) -> Result<Response, AdminError> {
11975 let items: Vec<Locale> = Locale::objects()
11976 .order_by(&[("sort_order", false), ("code", false)])
11977 .fetch(tenant.pool())
11978 .await?;
11979 let rows: Vec<serde_json::Value> = items
11984 .iter()
11985 .map(|l| {
11986 let info = rustango::i18n::locale_info(&l.code);
11987 let ui = super::i18n::is_ui_locale(&l.code);
11988 let mut v = serde_json::to_value(l).unwrap_or_default();
11989 v["support"] = serde_json::json!({
11990 "ui_translated": ui,
11991 "known": info.known,
11992 "display_name": info.display_name,
11993 "has_plural_rules": info.has_plural_rules,
11994 "is_rtl": info.is_rtl,
11995 "content_only": !ui,
11996 });
11997 v
11998 })
11999 .collect();
12000 let mut ctx = Context::new();
12001 add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
12002 add_admin_theme(&mut ctx, tenant.pool()).await;
12003 ctx.insert("items", &rows);
12004 render_with_csrf(&state, &headers, "rcms_admin/locale_list.html", &mut ctx)
12005}
12006
12007fn insert_known_locales(ctx: &mut Context) {
12013 let known: Vec<serde_json::Value> = rustango::i18n::known_locales()
12014 .map(|(code, name)| serde_json::json!({ "code": code, "name": name }))
12015 .collect();
12016 let meta: serde_json::Map<String, serde_json::Value> = rustango::i18n::known_locales()
12017 .map(|(code, _)| {
12018 let info = rustango::i18n::locale_info(code);
12019 (
12020 code.to_owned(),
12021 serde_json::json!({
12022 "ui": super::i18n::is_ui_locale(code),
12023 "is_rtl": info.is_rtl,
12024 "has_plural_rules": info.has_plural_rules,
12025 }),
12026 )
12027 })
12028 .collect();
12029 ctx.insert("known_locales", &known);
12030 ctx.insert("known_locales_meta", &serde_json::Value::Object(meta));
12031}
12032
12033pub async fn locale_new_form(
12034 State(state): State<super::AdminState>,
12035 tenant: Tenant,
12036 headers: HeaderMap,
12037 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12038) -> Result<Response, AdminError> {
12039 let mut ctx = Context::new();
12040 add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
12041 add_admin_theme(&mut ctx, tenant.pool()).await;
12042 insert_known_locales(&mut ctx);
12043 ctx.insert("mode", "new");
12044 ctx.insert(
12045 "locale",
12046 &serde_json::json!({
12047 "code": "",
12048 "name": "",
12049 "is_default": false,
12050 "active": true,
12051 "sort_order": 100,
12052 }),
12053 );
12054 render_with_csrf(&state, &headers, "rcms_admin/locale_form.html", &mut ctx)
12055}
12056
12057#[derive(Debug, Deserialize)]
12058pub struct LocaleForm {
12059 pub code: String,
12060 pub name: String,
12061 #[serde(default)]
12062 pub is_default: Option<String>,
12063 #[serde(default)]
12064 pub active: Option<String>,
12065 #[serde(default)]
12066 pub sort_order: Option<i32>,
12067}
12068
12069impl LocaleForm {
12070 fn parsed_default(&self) -> bool {
12071 self.is_default.is_some()
12072 }
12073 fn parsed_active(&self) -> bool {
12074 self.active.is_some()
12075 }
12076 fn parsed_sort_order(&self) -> i32 {
12077 self.sort_order.unwrap_or(100)
12078 }
12079}
12080
12081pub async fn locale_new_submit(
12082 State(_state): State<super::AdminState>,
12083 tenant: Tenant,
12084 headers: HeaderMap,
12085 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12086 Form(form): Form<LocaleForm>,
12087) -> Result<Response, AdminError> {
12088 use rustango::sql::Auto;
12089 let name = form.name.trim().to_owned();
12090 if name.is_empty() {
12091 return Err(AdminError::Validation(
12092 "Display name is required.".to_owned(),
12093 ));
12094 }
12095 let mut row = Locale {
12096 id: Auto::Unset,
12097 code: crate::locale::validate_code(&form.code).map_err(AdminError::Validation)?,
12098 name,
12099 is_default: form.parsed_default(),
12100 active: form.parsed_active(),
12101 sort_order: form.parsed_sort_order(),
12102 created_at: Auto::Unset,
12103 };
12104 if row.is_default {
12105 clear_default_flag(&tenant, None).await?;
12106 }
12107 row.insert_pool(tenant.pool()).await?;
12108 redirect_named_with_message_args(
12109 "rcms-admin:locales:list",
12110 MsgLevel::Success,
12111 "Added locale {name} ({code}).",
12112 &[("name", row.name.as_str()), ("code", row.code.as_str())],
12113 &headers,
12114 )
12115}
12116
12117pub async fn locale_edit_form(
12118 State(state): State<super::AdminState>,
12119 tenant: Tenant,
12120 headers: HeaderMap,
12121 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12122 Path(id): Path<i64>,
12123) -> Result<Response, AdminError> {
12124 let row = Locale::objects()
12125 .where_(Locale::id.eq(id))
12126 .first(tenant.pool())
12127 .await?
12128 .ok_or(AdminError::NotFound(id))?;
12129 let mut ctx = Context::new();
12130 add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
12131 add_admin_theme(&mut ctx, tenant.pool()).await;
12132 insert_known_locales(&mut ctx);
12133 ctx.insert("mode", "edit");
12134 ctx.insert("locale", &row);
12135 render_with_csrf(&state, &headers, "rcms_admin/locale_form.html", &mut ctx)
12136}
12137
12138pub async fn locale_edit_submit(
12139 State(_state): State<super::AdminState>,
12140 tenant: Tenant,
12141 headers: HeaderMap,
12142 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12143 Path(id): Path<i64>,
12144 Form(form): Form<LocaleForm>,
12145) -> Result<Response, AdminError> {
12146 let mut row = Locale::objects()
12147 .where_(Locale::id.eq(id))
12148 .first(tenant.pool())
12149 .await?
12150 .ok_or(AdminError::NotFound(id))?;
12151 let name = form.name.trim().to_owned();
12152 if name.is_empty() {
12153 return Err(AdminError::Validation(
12154 "Display name is required.".to_owned(),
12155 ));
12156 }
12157 row.code = crate::locale::validate_code(&form.code).map_err(AdminError::Validation)?;
12158 row.name = name;
12159 row.is_default = form.parsed_default();
12160 row.active = form.parsed_active();
12161 row.sort_order = form.parsed_sort_order();
12162 if row.is_default {
12163 clear_default_flag(&tenant, Some(id)).await?;
12164 }
12165 row.save_pool(tenant.pool()).await?;
12166 redirect_named_with_message_args(
12167 "rcms-admin:locales:list",
12168 MsgLevel::Success,
12169 "Saved locale {name} ({code}).",
12170 &[("name", row.name.as_str()), ("code", row.code.as_str())],
12171 &headers,
12172 )
12173}
12174
12175pub async fn locale_delete_submit(
12176 State(_state): State<super::AdminState>,
12177 tenant: Tenant,
12178 headers: HeaderMap,
12179 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12180 Path(id): Path<i64>,
12181) -> Result<Response, AdminError> {
12182 let row = Locale::objects()
12183 .where_(Locale::id.eq(id))
12184 .first(tenant.pool())
12185 .await?
12186 .ok_or(AdminError::NotFound(id))?;
12187 if row.is_default {
12188 return redirect_named_with_message(
12189 "rcms-admin:locales:list",
12190 MsgLevel::Error,
12191 "Cannot delete the default locale — promote another locale to default first.",
12192 &headers,
12193 );
12194 }
12195 let label = format!("{} ({})", row.name, row.code);
12196 let pages = crate::translation::Translation::objects()
12199 .where_(crate::translation::Translation::locale_id.eq(id))
12200 .compile_delete()
12201 .map_err(rustango::sql::ExecError::from)?;
12202 let snippets = crate::snippet_translation::SnippetTranslation::objects()
12203 .where_(crate::snippet_translation::SnippetTranslation::locale_id.eq(id))
12204 .compile_delete()
12205 .map_err(rustango::sql::ExecError::from)?;
12206 let menus = crate::menu_item_translation::MenuItemTranslation::objects()
12207 .where_(crate::menu_item_translation::MenuItemTranslation::locale_id.eq(id))
12208 .compile_delete()
12209 .map_err(rustango::sql::ExecError::from)?;
12210 let categories = crate::category_translation::CategoryTranslation::objects()
12211 .where_(crate::category_translation::CategoryTranslation::locale_id.eq(id))
12212 .compile_delete()
12213 .map_err(rustango::sql::ExecError::from)?;
12214 rustango::atomic!(tenant.pool(), |tx| {
12215 let mut guard = tx.lock().await?;
12216 let tx = &mut *guard;
12217 for q in [&pages, &snippets, &menus, &categories] {
12218 rustango::sql::delete_tx(tx, q).await?;
12219 }
12220 row.delete_tx(tx).await?;
12221 Ok::<_, rustango::sql::ExecError>(())
12222 })
12223 .await?;
12224 redirect_named_with_message_args(
12225 "rcms-admin:locales:list",
12226 MsgLevel::Success,
12227 "Deleted locale {label}.",
12228 &[("label", label.as_str())],
12229 &headers,
12230 )
12231}
12232
12233const SSO_KINDS: &[(&str, &str)] = &[
12245 ("google", "Google"),
12246 ("microsoft", "Microsoft"),
12247 ("github", "GitHub"),
12248 ("gitlab", "GitLab"),
12249 ("discord", "Discord"),
12250 ("oidc", "Generic OpenID Connect"),
12251];
12252
12253fn sso_provider_json(p: &rustango::admin::SsoProvider) -> serde_json::Value {
12256 serde_json::json!({
12257 "id": p.id.get().copied().unwrap_or_default(),
12258 "slug": p.slug,
12259 "label": p.label,
12260 "kind": p.kind,
12261 "issuer_url": p.issuer_url,
12262 "client_id": p.client_id,
12263 "has_secret": !p.client_secret.is_empty(),
12266 "enabled": p.enabled,
12267 "sort_order": p.sort_order,
12268 "scopes": p.scopes,
12269 })
12270}
12271
12272pub async fn sso_provider_list(
12273 State(state): State<super::AdminState>,
12274 tenant: Tenant,
12275 headers: HeaderMap,
12276 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12277) -> Result<Response, AdminError> {
12278 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12280 return Ok(redirect);
12281 }
12282 use rustango::sql::FetcherPool as _;
12283 let mut items: Vec<rustango::admin::SsoProvider> = rustango::admin::SsoProvider::objects()
12284 .fetch(tenant.pool())
12285 .await
12286 .unwrap_or_default();
12287 items.sort_by(|a, b| a.sort_order.cmp(&b.sort_order).then(a.slug.cmp(&b.slug)));
12288 let rows: Vec<serde_json::Value> = items.iter().map(sso_provider_json).collect();
12289 let mut ctx = Context::new();
12290 add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12291 add_admin_theme(&mut ctx, tenant.pool()).await;
12292 ctx.insert("items", &rows);
12293 render_with_csrf(
12294 &state,
12295 &headers,
12296 "rcms_admin/sso_provider_list.html",
12297 &mut ctx,
12298 )
12299}
12300
12301#[derive(Deserialize)]
12302pub struct SsoProviderForm {
12303 pub slug: String,
12304 pub label: String,
12305 pub kind: String,
12306 #[serde(default)]
12307 pub issuer_url: String,
12308 pub client_id: String,
12309 #[serde(default)]
12312 pub client_secret: String,
12313 #[serde(default)]
12314 pub scopes: String,
12315 #[serde(default)]
12316 pub enabled: Option<String>,
12317 #[serde(default)]
12318 pub sort_order: Option<i32>,
12319}
12320
12321impl SsoProviderForm {
12322 fn validated(&self) -> Result<ValidatedProvider, String> {
12324 let slug = self.slug.trim().to_lowercase();
12325 if slug.is_empty()
12326 || !slug
12327 .chars()
12328 .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
12329 {
12330 return Err(
12331 "Slug is required and may only contain letters, numbers, - and _.".to_owned(),
12332 );
12333 }
12334 let label = self.label.trim().to_owned();
12335 if label.is_empty() {
12336 return Err("Button label is required.".to_owned());
12337 }
12338 let kind = self.kind.trim().to_lowercase();
12339 if !SSO_KINDS.iter().any(|(k, _)| *k == kind) {
12340 return Err("Pick a provider type.".to_owned());
12341 }
12342 let client_id = self.client_id.trim().to_owned();
12343 if client_id.is_empty() {
12344 return Err("Client ID is required.".to_owned());
12345 }
12346 let issuer = self.issuer_url.trim().to_owned();
12347 if kind == "oidc" && issuer.is_empty() {
12348 return Err("A generic OpenID Connect provider needs an issuer URL.".to_owned());
12349 }
12350 let scopes = self.scopes.trim().to_owned();
12351 Ok(ValidatedProvider {
12352 slug,
12353 label,
12354 kind,
12355 issuer_url: (!issuer.is_empty()).then_some(issuer),
12356 client_id,
12357 scopes: (!scopes.is_empty()).then_some(scopes),
12358 enabled: self.enabled.is_some(),
12359 sort_order: self.sort_order.unwrap_or(0),
12360 })
12361 }
12362}
12363
12364struct ValidatedProvider {
12365 slug: String,
12366 label: String,
12367 kind: String,
12368 issuer_url: Option<String>,
12369 client_id: String,
12370 scopes: Option<String>,
12371 enabled: bool,
12372 sort_order: i32,
12373}
12374
12375fn render_sso_provider_form(ctx: &mut Context, mode: &str, provider: serde_json::Value) {
12376 let kinds: Vec<serde_json::Value> = SSO_KINDS
12377 .iter()
12378 .map(|(k, name)| serde_json::json!({ "key": k, "name": name }))
12379 .collect();
12380 ctx.insert("mode", mode);
12381 ctx.insert("kinds", &kinds);
12382 ctx.insert("provider", &provider);
12383}
12384
12385pub async fn sso_provider_new_form(
12386 State(state): State<super::AdminState>,
12387 tenant: Tenant,
12388 headers: HeaderMap,
12389 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12390) -> Result<Response, AdminError> {
12391 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12393 return Ok(redirect);
12394 }
12395 let mut ctx = Context::new();
12396 add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12397 add_admin_theme(&mut ctx, tenant.pool()).await;
12398 render_sso_provider_form(
12399 &mut ctx,
12400 "new",
12401 serde_json::json!({
12402 "slug": "", "label": "", "kind": "google", "issuer_url": null,
12403 "client_id": "", "has_secret": false, "scopes": null,
12404 "enabled": true, "sort_order": 0,
12405 }),
12406 );
12407 render_with_csrf(
12408 &state,
12409 &headers,
12410 "rcms_admin/sso_provider_form.html",
12411 &mut ctx,
12412 )
12413}
12414
12415async fn find_sso_provider(
12416 tenant: &Tenant,
12417 id: i64,
12418) -> Result<rustango::admin::SsoProvider, AdminError> {
12419 use rustango::sql::FetcherPool as _;
12420 rustango::admin::SsoProvider::objects()
12421 .filter("id", id)
12422 .fetch(tenant.pool())
12423 .await
12424 .map_err(|e| AdminError::Validation(format!("db: {e}")))?
12425 .into_iter()
12426 .next()
12427 .ok_or(AdminError::NotFound(id))
12428}
12429
12430pub async fn sso_provider_edit_form(
12431 State(state): State<super::AdminState>,
12432 tenant: Tenant,
12433 headers: HeaderMap,
12434 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12435 Path(id): Path<i64>,
12436) -> Result<Response, AdminError> {
12437 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12439 return Ok(redirect);
12440 }
12441 let row = find_sso_provider(&tenant, id).await?;
12442 let mut ctx = Context::new();
12443 add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12444 add_admin_theme(&mut ctx, tenant.pool()).await;
12445 render_sso_provider_form(&mut ctx, "edit", sso_provider_json(&row));
12446 render_with_csrf(
12447 &state,
12448 &headers,
12449 "rcms_admin/sso_provider_form.html",
12450 &mut ctx,
12451 )
12452}
12453
12454pub async fn sso_provider_new_submit(
12455 State(_state): State<super::AdminState>,
12456 tenant: Tenant,
12457 headers: HeaderMap,
12458 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12459 Form(form): Form<SsoProviderForm>,
12460) -> Result<Response, AdminError> {
12461 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12463 return Ok(redirect);
12464 }
12465 let v = form.validated().map_err(AdminError::Validation)?;
12466 let secret = form.client_secret.trim().to_owned();
12467 if secret.is_empty() {
12468 return Err(AdminError::Validation(
12469 "Client secret is required.".to_owned(),
12470 ));
12471 }
12472 let mut row = rustango::admin::SsoProvider {
12473 id: rustango::sql::Auto::Unset,
12474 slug: v.slug,
12475 label: v.label,
12476 kind: v.kind,
12477 issuer_url: v.issuer_url,
12478 client_id: v.client_id,
12479 client_secret: rustango::casts::Cast::new(secret),
12480 enabled: v.enabled,
12481 sort_order: v.sort_order,
12482 scopes: v.scopes,
12483 allow_email_link: false,
12484 created_at: rustango::sql::Auto::Unset,
12485 updated_at: rustango::sql::Auto::Unset,
12486 };
12487 row.insert_pool(tenant.pool()).await?;
12488 redirect_named_with_message_args(
12489 "rcms-admin:sso-providers:list",
12490 MsgLevel::Success,
12491 "Added SSO provider {label}.",
12492 &[("label", row.label.as_str())],
12493 &headers,
12494 )
12495}
12496
12497pub async fn sso_provider_edit_submit(
12498 State(_state): State<super::AdminState>,
12499 tenant: Tenant,
12500 headers: HeaderMap,
12501 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12502 Path(id): Path<i64>,
12503 Form(form): Form<SsoProviderForm>,
12504) -> Result<Response, AdminError> {
12505 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12507 return Ok(redirect);
12508 }
12509 let mut row = find_sso_provider(&tenant, id).await?;
12510 let v = form.validated().map_err(AdminError::Validation)?;
12511 row.slug = v.slug;
12512 row.label = v.label;
12513 row.kind = v.kind;
12514 row.issuer_url = v.issuer_url;
12515 row.client_id = v.client_id;
12516 let new_secret = form.client_secret.trim();
12519 if !new_secret.is_empty() {
12520 row.client_secret = rustango::casts::Cast::new(new_secret.to_owned());
12521 }
12522 row.enabled = v.enabled;
12523 row.sort_order = v.sort_order;
12524 row.scopes = v.scopes;
12525 row.save_pool(tenant.pool()).await?;
12526 redirect_named_with_message_args(
12527 "rcms-admin:sso-providers:list",
12528 MsgLevel::Success,
12529 "Saved SSO provider {label}.",
12530 &[("label", row.label.as_str())],
12531 &headers,
12532 )
12533}
12534
12535pub async fn sso_provider_delete_submit(
12536 State(_state): State<super::AdminState>,
12537 tenant: Tenant,
12538 headers: HeaderMap,
12539 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12540 Path(id): Path<i64>,
12541) -> Result<Response, AdminError> {
12542 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12544 return Ok(redirect);
12545 }
12546 let row = find_sso_provider(&tenant, id).await?;
12547 let label = row.label.clone();
12548 row.delete_pool(tenant.pool()).await?;
12549 redirect_named_with_message_args(
12550 "rcms-admin:sso-providers:list",
12551 MsgLevel::Success,
12552 "Deleted SSO provider {label}.",
12553 &[("label", label.as_str())],
12554 &headers,
12555 )
12556}
12557
12558async fn clear_default_flag(tenant: &Tenant, except: Option<i64>) -> Result<(), AdminError> {
12562 let rows: Vec<Locale> = Locale::objects()
12563 .where_(Locale::is_default.eq(true))
12564 .fetch(tenant.pool())
12565 .await?;
12566 for mut r in rows {
12567 if let (Some(skip), Some(id)) = (except, r.id.get().copied()) {
12568 if skip == id {
12569 continue;
12570 }
12571 }
12572 r.is_default = false;
12573 r.save_pool(tenant.pool()).await?;
12574 }
12575 Ok(())
12576}
12577
12578pub async fn workflows_list(
12583 State(state): State<super::AdminState>,
12584 tenant: Tenant,
12585 headers: HeaderMap,
12586 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12587) -> Result<Response, AdminError> {
12588 let items: Vec<crate::workflow::Workflow> = crate::workflow::Workflow::objects()
12589 .order_by(&[("name", false)])
12590 .fetch(tenant.pool())
12591 .await?;
12592 let all_tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12595 .fetch(tenant.pool())
12596 .await?;
12597 let mut task_counts: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
12598 for t in &all_tasks {
12599 *task_counts.entry(t.workflow_id).or_insert(0) += 1;
12600 }
12601 let rows: Vec<serde_json::Value> = items
12602 .iter()
12603 .map(|w| {
12604 let id = w.id.get().copied().unwrap_or_default();
12605 serde_json::json!({
12606 "id": id,
12607 "name": w.name,
12608 "description": w.description,
12609 "active": w.active,
12610 "require_reapproval_on_edit": w.require_reapproval_on_edit,
12611 "task_count": task_counts.get(&id).copied().unwrap_or(0),
12612 "created_at": w.created_at.get().copied(),
12613 })
12614 })
12615 .collect();
12616 let mut ctx = Context::new();
12617 add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12618 add_admin_theme(&mut ctx, tenant.pool()).await;
12619 ctx.insert("items", &rows);
12620 render_with_csrf(&state, &headers, "rcms_admin/workflow_list.html", &mut ctx)
12621}
12622
12623pub async fn workflow_new_form(
12624 State(state): State<super::AdminState>,
12625 tenant: Tenant,
12626 headers: HeaderMap,
12627 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12628) -> Result<Response, AdminError> {
12629 let mut ctx = Context::new();
12630 add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12631 add_admin_theme(&mut ctx, tenant.pool()).await;
12632 ctx.insert("mode", "new");
12633 ctx.insert(
12634 "workflow",
12635 &serde_json::json!({
12636 "name": "",
12637 "description": "",
12638 "active": true,
12639 "require_reapproval_on_edit": false,
12640 }),
12641 );
12642 ctx.insert("tasks", &Vec::<serde_json::Value>::new());
12643 ctx.insert("roles", &Vec::<serde_json::Value>::new());
12644 render_with_csrf(&state, &headers, "rcms_admin/workflow_form.html", &mut ctx)
12645}
12646
12647#[derive(Debug, Deserialize)]
12648pub struct WorkflowForm {
12649 pub name: String,
12650 #[serde(default)]
12651 pub description: String,
12652 #[serde(default)]
12653 pub active: Option<String>,
12654 #[serde(default)]
12655 pub require_reapproval_on_edit: Option<String>,
12656}
12657
12658impl WorkflowForm {
12659 fn parsed_active(&self) -> bool {
12660 self.active.is_some()
12661 }
12662 fn parsed_reapproval(&self) -> bool {
12663 self.require_reapproval_on_edit.is_some()
12664 }
12665}
12666
12667pub async fn workflow_new_submit(
12668 State(_state): State<super::AdminState>,
12669 tenant: Tenant,
12670 headers: HeaderMap,
12671 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12672 Form(form): Form<WorkflowForm>,
12673) -> Result<Response, AdminError> {
12674 use rustango::sql::Auto;
12675 let name = form.name.trim().to_owned();
12676 if name.is_empty() {
12677 return redirect_named_with_message(
12678 "rcms-admin:workflows:list",
12679 MsgLevel::Error,
12680 "Workflow name is required.",
12681 &headers,
12682 );
12683 }
12684 let mut row = crate::workflow::Workflow {
12685 id: Auto::Unset,
12686 name: name.clone(),
12687 description: form.description.trim().to_owned(),
12688 active: form.parsed_active(),
12689 require_reapproval_on_edit: form.parsed_reapproval(),
12690 created_at: Auto::Unset,
12691 updated_at: Auto::Unset,
12692 };
12693 row.insert_pool(tenant.pool()).await?;
12694 let id = row.id.get().copied().unwrap_or_default();
12695 redirect_named_with_params_and_message_args(
12696 "rcms-admin:workflows:edit",
12697 &[("id", id.to_string())],
12698 MsgLevel::Success,
12699 "Created workflow “{name}”. Add review steps below.",
12700 &[("name", name.as_str())],
12701 &headers,
12702 )
12703}
12704
12705pub async fn workflow_edit_form(
12706 State(state): State<super::AdminState>,
12707 tenant: Tenant,
12708 headers: HeaderMap,
12709 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12710 Path(id): Path<i64>,
12711) -> Result<Response, AdminError> {
12712 let row = crate::workflow::Workflow::objects()
12713 .where_(crate::workflow::Workflow::id.eq(id))
12714 .first(tenant.pool())
12715 .await?
12716 .ok_or(AdminError::NotFound(id))?;
12717 let tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12718 .where_(crate::workflow::WorkflowTask::workflow_id.eq(id))
12719 .order_by(&[("sort_order", false), ("id", false)])
12720 .fetch(tenant.pool())
12721 .await?;
12722 let roles: Vec<rustango::tenancy::permissions::Role> =
12725 rustango::tenancy::permissions::Role::objects()
12726 .order_by(&[("name", false)])
12727 .fetch(tenant.pool())
12728 .await?;
12729 let role_rows: Vec<serde_json::Value> = roles
12730 .iter()
12731 .map(|r| {
12732 serde_json::json!({
12733 "id": r.id.get().copied(),
12734 "name": r.name,
12735 })
12736 })
12737 .collect();
12738 let role_by_id: std::collections::HashMap<i64, String> = roles
12739 .iter()
12740 .filter_map(|r| r.id.get().copied().map(|id| (id, r.name.clone())))
12741 .collect();
12742 let task_rows: Vec<serde_json::Value> = tasks
12743 .iter()
12744 .map(|t| {
12745 serde_json::json!({
12746 "id": t.id.get().copied(),
12747 "name": t.name,
12748 "role_id": t.role_id,
12749 "role_name": role_by_id.get(&t.role_id).cloned().unwrap_or_default(),
12750 "sort_order": t.sort_order,
12751 "kind": t.kind,
12752 "webhook_url": t.webhook_url,
12753 })
12754 })
12755 .collect();
12756 let mut task_kinds: Vec<serde_json::Value> = crate::task_kind::registered_kinds()
12761 .iter()
12762 .map(|k| {
12763 serde_json::json!({
12764 "name": k.kind_name(),
12765 "verbose_name": k.verbose_name(),
12766 })
12767 })
12768 .collect();
12769 task_kinds.sort_by_key(|k| k["name"] != "group_approval");
12770 let kind_label = |name: &str| {
12771 crate::task_kind::registered_kinds()
12772 .iter()
12773 .find(|k| k.kind_name() == name)
12774 .map_or_else(|| name.to_owned(), |k| k.verbose_name().to_owned())
12775 };
12776 let task_rows: Vec<serde_json::Value> = task_rows
12777 .into_iter()
12778 .map(|mut t| {
12779 let label = kind_label(t["kind"].as_str().unwrap_or_default());
12780 t["kind_label"] = serde_json::Value::String(label);
12781 t
12782 })
12783 .collect();
12784 let mut ctx = Context::new();
12785 add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12786 add_admin_theme(&mut ctx, tenant.pool()).await;
12787 ctx.insert("mode", "edit");
12788 ctx.insert("workflow", &row);
12789 ctx.insert("tasks", &task_rows);
12790 ctx.insert("roles", &role_rows);
12791 ctx.insert("task_kinds", &task_kinds);
12792 render_with_csrf(&state, &headers, "rcms_admin/workflow_form.html", &mut ctx)
12793}
12794
12795pub async fn workflow_edit_submit(
12796 State(_state): State<super::AdminState>,
12797 tenant: Tenant,
12798 headers: HeaderMap,
12799 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12800 Path(id): Path<i64>,
12801 Form(form): Form<WorkflowForm>,
12802) -> Result<Response, AdminError> {
12803 let mut row = crate::workflow::Workflow::objects()
12804 .where_(crate::workflow::Workflow::id.eq(id))
12805 .first(tenant.pool())
12806 .await?
12807 .ok_or(AdminError::NotFound(id))?;
12808 let old_name = row.name.clone();
12809 row.name = form.name.trim().to_owned();
12810 row.description = form.description.trim().to_owned();
12811 row.active = form.parsed_active();
12812 row.require_reapproval_on_edit = form.parsed_reapproval();
12813 row.save_pool(tenant.pool()).await?;
12814 if old_name != row.name {
12817 crate::workflow::rebind_page_types(tenant.pool(), &old_name, &row.name).await?;
12818 }
12819 redirect_named_with_params_and_message_args(
12820 "rcms-admin:workflows:edit",
12821 &[("id", id.to_string())],
12822 MsgLevel::Success,
12823 "Saved workflow “{name}”.",
12824 &[("name", row.name.as_str())],
12825 &headers,
12826 )
12827}
12828
12829pub async fn workflow_delete_submit(
12830 State(_state): State<super::AdminState>,
12831 tenant: Tenant,
12832 headers: HeaderMap,
12833 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12834 Path(id): Path<i64>,
12835) -> Result<Response, AdminError> {
12836 let row = crate::workflow::Workflow::objects()
12837 .where_(crate::workflow::Workflow::id.eq(id))
12838 .first(tenant.pool())
12839 .await?
12840 .ok_or(AdminError::NotFound(id))?;
12841 let users: Vec<String> = crate::workflow::page_types_using(tenant.pool(), &row.name)
12843 .await?
12844 .into_iter()
12845 .map(|pt| pt.verbose_name)
12846 .collect();
12847 if !users.is_empty() {
12848 let types = users.join(", ");
12849 return redirect_named_with_message_args(
12850 "rcms-admin:workflows:list",
12851 MsgLevel::Error,
12852 "Can't delete “{title}” — the page types {types} use it. Choose another workflow for them first.",
12853 &[("title", row.name.as_str()), ("types", types.as_str())],
12854 &headers,
12855 );
12856 }
12857 let in_use: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
12861 .where_(crate::workflow::WorkflowState::workflow_id.eq(id))
12862 .fetch(tenant.pool())
12863 .await?;
12864 if !in_use.is_empty() {
12865 let count = in_use.len().to_string();
12866 return redirect_named_with_message_plural(
12867 "rcms-admin:workflows:list",
12868 MsgLevel::Error,
12869 "Can't delete “{title}” — {count} page(s) have history under it. Toggle Active off instead.",
12870 in_use.len() as i64,
12871 &[("title", row.name.as_str()), ("count", count.as_str())],
12872 &headers,
12873 );
12874 }
12875 let tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12877 .where_(crate::workflow::WorkflowTask::workflow_id.eq(id))
12878 .fetch(tenant.pool())
12879 .await?;
12880 for t in tasks {
12881 t.delete_pool(tenant.pool()).await?;
12882 }
12883 let name = row.name.clone();
12884 row.delete_pool(tenant.pool()).await?;
12885 redirect_named_with_message_args(
12886 "rcms-admin:workflows:list",
12887 MsgLevel::Success,
12888 "Deleted workflow “{name}”.",
12889 &[("name", name.as_str())],
12890 &headers,
12891 )
12892}
12893
12894#[derive(Debug, Deserialize)]
12895pub struct WorkflowTaskForm {
12896 pub name: String,
12897 pub role_id: i64,
12898 #[serde(default)]
12902 pub kind: Option<String>,
12903 #[serde(default)]
12904 pub webhook_url: Option<String>,
12905}
12906
12907pub async fn workflow_task_add(
12908 State(_state): State<super::AdminState>,
12909 tenant: Tenant,
12910 headers: HeaderMap,
12911 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12912 Path(workflow_id): Path<i64>,
12913 Form(form): Form<WorkflowTaskForm>,
12914) -> Result<Response, AdminError> {
12915 use rustango::sql::Auto;
12916 let name = form.name.trim().to_owned();
12917 if name.is_empty() {
12918 return redirect_named_with_params_and_message(
12919 "rcms-admin:workflows:edit",
12920 &[("id", workflow_id.to_string())],
12921 MsgLevel::Error,
12922 "Step name is required.",
12923 &headers,
12924 );
12925 }
12926 let existing: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12927 .where_(crate::workflow::WorkflowTask::workflow_id.eq(workflow_id))
12928 .order_by(&[("sort_order", true)]) .fetch(tenant.pool())
12930 .await?;
12931 let next_order = existing.first().map_or(10, |t| t.sort_order + 10);
12932 let kind = form
12933 .kind
12934 .as_deref()
12935 .map(str::trim)
12936 .filter(|s| !s.is_empty())
12937 .filter(|s| crate::task_kind::find(s).is_some())
12938 .unwrap_or("group_approval")
12939 .to_owned();
12940 let webhook_url = form
12941 .webhook_url
12942 .as_deref()
12943 .map(str::trim)
12944 .unwrap_or("")
12945 .to_owned();
12946 let mut row = crate::workflow::WorkflowTask {
12947 id: Auto::Unset,
12948 workflow_id,
12949 name: name.clone(),
12950 role_id: form.role_id,
12951 sort_order: next_order,
12952 kind,
12953 webhook_url,
12954 };
12955 row.insert_pool(tenant.pool()).await?;
12956 redirect_named_with_params_and_message_args(
12957 "rcms-admin:workflows:edit",
12958 &[("id", workflow_id.to_string())],
12959 MsgLevel::Success,
12960 "Added step “{name}”.",
12961 &[("name", name.as_str())],
12962 &headers,
12963 )
12964}
12965
12966pub async fn workflow_task_delete(
12967 State(_state): State<super::AdminState>,
12968 tenant: Tenant,
12969 headers: HeaderMap,
12970 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12971 Path((workflow_id, task_id)): Path<(i64, i64)>,
12972) -> Result<Response, AdminError> {
12973 let row = crate::workflow::WorkflowTask::objects()
12974 .where_(crate::workflow::WorkflowTask::id.eq(task_id))
12975 .where_(crate::workflow::WorkflowTask::workflow_id.eq(workflow_id))
12976 .first(tenant.pool())
12977 .await?
12978 .ok_or(AdminError::NotFound(task_id))?;
12979 let name = row.name.clone();
12980 row.delete_pool(tenant.pool()).await?;
12981 redirect_named_with_params_and_message_args(
12982 "rcms-admin:workflows:edit",
12983 &[("id", workflow_id.to_string())],
12984 MsgLevel::Success,
12985 "Removed step “{name}”.",
12986 &[("name", name.as_str())],
12987 &headers,
12988 )
12989}
12990
12991#[derive(Debug, Deserialize)]
13002pub struct WorkflowDecisionForm {
13003 #[serde(default)]
13004 pub comment: String,
13005 #[serde(default)]
13009 pub task_id: Option<i64>,
13010}
13011
13012fn step_already_decided(page_id: i64, headers: &HeaderMap) -> Result<Response, AdminError> {
13015 redirect_named_with_params_and_message(
13016 "rcms-admin:pages:edit",
13017 &[("id", page_id.to_string())],
13018 MsgLevel::Error,
13019 "That review step was already decided — check the page's current step before deciding again.",
13020 headers,
13021 )
13022}
13023
13024async fn user_is_in_role(
13025 pool: &rustango::sql::Pool,
13026 user_id: i64,
13027 role_id: i64,
13028) -> Result<bool, rustango::sql::ExecError> {
13029 use rustango::core::Column as _;
13030 use rustango::sql::FetcherPool as _;
13031 let rows: Vec<rustango::tenancy::permissions::UserRole> =
13032 rustango::tenancy::permissions::UserRole::objects()
13033 .where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
13034 .where_(rustango::tenancy::permissions::UserRole::role_id.eq(role_id))
13035 .fetch(pool)
13036 .await?;
13037 Ok(!rows.is_empty())
13038}
13039
13040pub async fn page_workflow_submit(
13041 State(_state): State<super::AdminState>,
13042 tenant: Tenant,
13043 headers: HeaderMap,
13044 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13045 Path(id): Path<i64>,
13046) -> Result<Response, AdminError> {
13047 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
13048 return Ok(unauthorized_no_session());
13049 };
13050 let page = Page::objects()
13051 .where_(Page::id.eq(id))
13052 .first(tenant.pool())
13053 .await?
13054 .ok_or(AdminError::NotFound(id))?;
13055 let pts: Vec<PageType> = PageType::objects()
13057 .where_(PageType::id.eq(page.page_type_id))
13058 .fetch(tenant.pool())
13059 .await?;
13060 let Some(pt) = pts.into_iter().next() else {
13061 return redirect_named_with_params_and_message(
13062 "rcms-admin:pages:edit",
13063 &[("id", id.to_string())],
13064 MsgLevel::Error,
13065 "Page type row not found.",
13066 &headers,
13067 );
13068 };
13069 let Some(slug) = pt.workflow_name() else {
13070 return redirect_named_with_params_and_message(
13071 "rcms-admin:pages:edit",
13072 &[("id", id.to_string())],
13073 MsgLevel::Error,
13074 "This page type isn't bound to a workflow — nothing to submit.",
13075 &headers,
13076 );
13077 };
13078 let Some(workflow) = crate::workflow::find_by_name(tenant.pool(), &slug).await? else {
13079 return redirect_named_with_params_and_message_args(
13080 "rcms-admin:pages:edit",
13081 &[("id", id.to_string())],
13082 MsgLevel::Error,
13083 "Workflow `{slug}` not found or inactive — ask an admin to enable it.",
13084 &[("slug", slug.as_str())],
13085 &headers,
13086 );
13087 };
13088 let tasks = crate::workflow::tasks_for(
13089 tenant.pool(),
13090 workflow.id.get().copied().unwrap_or_default(),
13091 )
13092 .await?;
13093 if tasks.is_empty() {
13094 return redirect_named_with_params_and_message(
13095 "rcms-admin:pages:edit",
13096 &[("id", id.to_string())],
13097 MsgLevel::Error,
13098 "Workflow has no review steps yet — ask an admin to add at least one step.",
13099 &headers,
13100 );
13101 }
13102 if let Some(active) = crate::workflow::active_state_for_page(tenant.pool(), id).await? {
13107 if active.status == crate::workflow::WorkflowStatus::InProgress.as_str() {
13108 return redirect_named_with_params_and_message(
13109 "rcms-admin:pages:edit",
13110 &[("id", id.to_string())],
13111 MsgLevel::Warning,
13112 "This page is already under review.",
13113 &headers,
13114 );
13115 }
13116 }
13117 crate::workflow::submit_for_review(tenant.pool(), id, &workflow, &tasks, viewer_id).await?;
13118 crate::lock::release(tenant.pool(), id, viewer_id)
13121 .await
13122 .log_warn("editor lock not released on submit");
13123
13124 crate::page_log::record_or_warn(
13126 tenant.pool(),
13127 id,
13128 crate::page_log::ACTION_WORKFLOW_SUBMIT,
13129 Some(viewer_id),
13130 format!(
13131 "Submitted for review — workflow “{}”, first step “{}”.",
13132 workflow.name, tasks[0].name
13133 ),
13134 Some(serde_json::json!({
13135 "workflow_id": workflow.id.get().copied(),
13136 "workflow_name": workflow.name,
13137 "first_task": tasks[0].name,
13138 })),
13139 )
13140 .await;
13141
13142 notify_workflow(
13145 _state.mailer.as_deref(),
13146 &_state.mailer_from,
13147 tenant.pool(),
13148 &tenant.org.slug,
13149 "submit",
13150 &workflow.name,
13151 &page.title,
13152 id,
13153 Some(&tasks[0].name),
13154 session_user.as_ref().map(|u| u.username.as_str()),
13155 None,
13156 WorkflowRecipients::Role(tasks[0].role_id),
13157 )
13158 .await;
13159
13160 redirect_named_with_params_and_message_args(
13161 "rcms-admin:pages:edit",
13162 &[("id", id.to_string())],
13163 MsgLevel::Success,
13164 "Submitted for review — first step: “{name}”.",
13165 &[("name", tasks[0].name.as_str())],
13166 &headers,
13167 )
13168}
13169
13170enum WorkflowRecipients {
13172 Role(i64),
13174 User(i64),
13177}
13178
13179#[allow(clippy::too_many_arguments)]
13184async fn notify_workflow(
13185 mailer: Option<&dyn rustango::email::Mailer>,
13186 from: &str,
13187 pool: &rustango::sql::Pool,
13188 tenant_slug: &str,
13189 event: &str,
13190 workflow_name: &str,
13191 page_title: &str,
13192 page_id: i64,
13193 task_name: Option<&str>,
13194 actor_username: Option<&str>,
13195 comment: Option<&str>,
13196 recipients: WorkflowRecipients,
13197) {
13198 let Some(mailer) = mailer else {
13199 return;
13200 };
13201 let kind = crate::notification_pref::pref_kind_for_workflow_event(event);
13205 let candidate_user_ids: Vec<i64> = match recipients {
13206 WorkflowRecipients::Role(role_id) => {
13207 crate::workflow_mail::role_member_user_ids(pool, role_id)
13208 .await
13209 .unwrap_or_default()
13210 }
13211 WorkflowRecipients::User(user_id) => vec![user_id],
13212 };
13213 let allowed_ids = crate::notification_pref::filter_enabled(pool, &candidate_user_ids, kind)
13214 .await
13215 .unwrap_or(candidate_user_ids);
13216 let mut pairs: Vec<(String, String)> = Vec::with_capacity(allowed_ids.len());
13217 for uid in allowed_ids {
13218 if let Ok(Some(pair)) = crate::workflow_mail::user_email(pool, uid, tenant_slug).await {
13219 pairs.push(pair);
13220 }
13221 }
13222 if pairs.is_empty() {
13223 return;
13224 }
13225 let (subject, body) = crate::workflow_mail::render_notification(
13226 event,
13227 workflow_name,
13228 page_title,
13229 page_id,
13230 task_name,
13231 actor_username,
13232 comment,
13233 );
13234 crate::workflow_mail::notify_many(mailer, from, &pairs, &subject, &body).await;
13235}
13236
13237pub async fn page_workflow_approve(
13238 State(_state): State<super::AdminState>,
13239 tenant: Tenant,
13240 headers: HeaderMap,
13241 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13242 Path(id): Path<i64>,
13243 Form(form): Form<WorkflowDecisionForm>,
13244) -> Result<Response, AdminError> {
13245 let Some(viewer) = session_user.as_ref() else {
13246 return Ok(unauthorized_no_session());
13247 };
13248 let viewer_id = viewer.id.get().copied().unwrap_or_default();
13249 let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13250 return redirect_named_with_params_and_message(
13251 "rcms-admin:pages:edit",
13252 &[("id", id.to_string())],
13253 MsgLevel::Error,
13254 "No active workflow on this page.",
13255 &headers,
13256 );
13257 };
13258 let tasks = crate::workflow::tasks_for(tenant.pool(), state.workflow_id).await?;
13259 let Some(current_task) = state
13260 .current_task_id
13261 .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
13262 else {
13263 return redirect_named_with_params_and_message(
13264 "rcms-admin:pages:edit",
13265 &[("id", id.to_string())],
13266 MsgLevel::Error,
13267 "Workflow has no current task — refresh the page.",
13268 &headers,
13269 );
13270 };
13271 if !viewer.is_superuser
13272 && !user_is_in_role(tenant.pool(), viewer_id, current_task.role_id).await?
13273 {
13274 return redirect_named_with_params_and_message_args(
13275 "rcms-admin:pages:edit",
13276 &[("id", id.to_string())],
13277 MsgLevel::Error,
13278 "Only members of the task's role can approve “{name}”.",
13279 &[("name", current_task.name.as_str())],
13280 &headers,
13281 );
13282 }
13283 if form.task_id.is_some_and(|t| current_task.id.get().copied() != Some(t)) {
13284 return step_already_decided(id, &headers);
13285 }
13286 let submitter_id = state.requested_by;
13289 let page_title: String = Page::objects()
13290 .where_(Page::id.eq(id))
13291 .fetch(tenant.pool())
13292 .await
13293 .ok()
13294 .and_then(|v| v.into_iter().next())
13295 .map(|p| p.title)
13296 .unwrap_or_else(|| format!("page #{id}"));
13297 let workflow_name: String = crate::workflow::Workflow::objects()
13298 .where_(crate::workflow::Workflow::id.eq(state.workflow_id))
13299 .fetch(tenant.pool())
13300 .await
13301 .ok()
13302 .and_then(|v| v.into_iter().next())
13303 .map(|w| w.name)
13304 .unwrap_or_else(|| "Workflow".to_owned());
13305 let outcome = crate::workflow::approve_current(
13306 tenant.pool(),
13307 &mut state,
13308 &tasks,
13309 viewer_id,
13310 &form.comment,
13311 )
13312 .await?;
13313 let msg = match outcome {
13314 crate::workflow::ApproveOutcome::AlreadyDecided => {
13315 return step_already_decided(id, &headers);
13316 }
13317 crate::workflow::ApproveOutcome::Advanced { next_task_id } => {
13318 let next = tasks
13319 .iter()
13320 .find(|t| t.id.get().copied() == Some(next_task_id));
13321 let next_name = next.map(|t| t.name.as_str()).unwrap_or("next step");
13322 if let Some(nt) = next {
13324 notify_workflow(
13325 _state.mailer.as_deref(),
13326 &_state.mailer_from,
13327 tenant.pool(),
13328 &tenant.org.slug,
13329 "approve_advance",
13330 &workflow_name,
13331 &page_title,
13332 id,
13333 Some(&nt.name),
13334 Some(&viewer.username),
13335 Some(&form.comment),
13336 WorkflowRecipients::Role(nt.role_id),
13337 )
13338 .await;
13339 }
13340 crate::page_log::record_or_warn(
13342 tenant.pool(),
13343 id,
13344 crate::page_log::ACTION_WORKFLOW_APPROVE,
13345 Some(viewer_id),
13346 format!(
13347 "Approved “{}” — advanced to “{next_name}”.",
13348 current_task.name
13349 ),
13350 Some(serde_json::json!({
13351 "outcome": "advanced",
13352 "task_name": current_task.name,
13353 "next_task_name": next_name,
13354 "comment": form.comment,
13355 })),
13356 )
13357 .await;
13358 format!("Approved “{}” — moved to “{next_name}”.", current_task.name)
13359 }
13360 crate::workflow::ApproveOutcome::Finished => {
13361 if let Some(pending) = crate::pending_change::for_page(tenant.pool(), id).await? {
13364 match apply_page_edit(
13365 tenant.pool(),
13366 &tenant.org.slug,
13367 &_state.cache_invalidator,
13368 _state.mailer.as_deref(),
13369 &_state.mailer_from,
13370 false,
13371 id,
13372 &pending.form_map(),
13373 None,
13374 )
13375 .await
13376 {
13377 Ok(Ok(_)) => crate::pending_change::discard(tenant.pool(), id).await?,
13378 Ok(Err(_)) | Err(_) => {
13379 tracing::warn!(page_id = id, "held change could not be applied on approval");
13380 }
13381 }
13382 }
13383 if let Some(mut page) = Page::objects()
13385 .where_(Page::id.eq(id))
13386 .first(tenant.pool())
13387 .await?
13388 {
13389 page.status = crate::page::PageStatus::Published.as_str().to_owned();
13390 let now = chrono::Utc::now();
13391 if page.published_at.is_none() {
13392 page.published_at = Some(now);
13393 }
13394 page.last_published_at = Some(now);
13396 page.save_pool(tenant.pool()).await?;
13397 crate::page::went_live_effects(&tenant.org.slug, &page).await;
13401 crate::task_queue::purge_urls(
13402 _state.cache_invalidator.clone(),
13403 tenant.org.slug.clone(),
13404 vec![page.url_path.clone()],
13405 )
13406 .await;
13407 crate::page_subscription::notify_publish(
13409 _state.mailer.as_deref(),
13410 &_state.mailer_from,
13411 tenant.pool(),
13412 &tenant.org.slug,
13413 id,
13414 &page.title,
13415 &page.url_path,
13416 Some(&viewer.username),
13417 )
13418 .await;
13419 }
13420 notify_workflow(
13422 _state.mailer.as_deref(),
13423 &_state.mailer_from,
13424 tenant.pool(),
13425 &tenant.org.slug,
13426 "approve_finish",
13427 &workflow_name,
13428 &page_title,
13429 id,
13430 Some(¤t_task.name),
13431 Some(&viewer.username),
13432 Some(&form.comment),
13433 WorkflowRecipients::User(submitter_id),
13434 )
13435 .await;
13436 crate::page_log::record_or_warn(
13439 tenant.pool(),
13440 id,
13441 crate::page_log::ACTION_WORKFLOW_APPROVE,
13442 Some(viewer_id),
13443 format!(
13444 "Approved “{}” — workflow complete; page auto-published.",
13445 current_task.name
13446 ),
13447 Some(serde_json::json!({
13448 "outcome": "finished",
13449 "task_name": current_task.name,
13450 "comment": form.comment,
13451 })),
13452 )
13453 .await;
13454 crate::page_log::record_or_warn(
13455 tenant.pool(),
13456 id,
13457 crate::page_log::ACTION_PUBLISH,
13458 Some(viewer_id),
13459 "Published via workflow approval.",
13460 Some(serde_json::json!({ "via": "workflow" })),
13461 )
13462 .await;
13463 format!(
13464 "Approved “{}” — workflow complete, page published.",
13465 current_task.name
13466 )
13467 }
13468 };
13469 redirect_named_with_params_and_message(
13470 "rcms-admin:pages:edit",
13471 &[("id", id.to_string())],
13472 MsgLevel::Success,
13473 &msg,
13474 &headers,
13475 )
13476}
13477
13478pub async fn page_workflow_reject(
13479 State(_state): State<super::AdminState>,
13480 tenant: Tenant,
13481 headers: HeaderMap,
13482 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13483 Path(id): Path<i64>,
13484 Form(form): Form<WorkflowDecisionForm>,
13485) -> Result<Response, AdminError> {
13486 let Some(viewer) = session_user.as_ref() else {
13487 return Ok(unauthorized_no_session());
13488 };
13489 let viewer_id = viewer.id.get().copied().unwrap_or_default();
13490 let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13491 return redirect_named_with_params_and_message(
13492 "rcms-admin:pages:edit",
13493 &[("id", id.to_string())],
13494 MsgLevel::Error,
13495 "No active workflow on this page.",
13496 &headers,
13497 );
13498 };
13499 let tasks = crate::workflow::tasks_for(tenant.pool(), state.workflow_id).await?;
13500 let Some(current_task) = state
13501 .current_task_id
13502 .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
13503 else {
13504 return redirect_named_with_params_and_message(
13505 "rcms-admin:pages:edit",
13506 &[("id", id.to_string())],
13507 MsgLevel::Error,
13508 "Workflow has no current task — refresh the page.",
13509 &headers,
13510 );
13511 };
13512 if !viewer.is_superuser
13513 && !user_is_in_role(tenant.pool(), viewer_id, current_task.role_id).await?
13514 {
13515 return redirect_named_with_params_and_message_args(
13516 "rcms-admin:pages:edit",
13517 &[("id", id.to_string())],
13518 MsgLevel::Error,
13519 "Only members of the task's role can reject “{name}”.",
13520 &[("name", current_task.name.as_str())],
13521 &headers,
13522 );
13523 }
13524 if form.task_id.is_some_and(|t| current_task.id.get().copied() != Some(t)) {
13525 return step_already_decided(id, &headers);
13526 }
13527 if form.comment.trim().is_empty() {
13528 return redirect_named_with_params_and_message(
13529 "rcms-admin:pages:edit",
13530 &[("id", id.to_string())],
13531 MsgLevel::Error,
13532 "Say what should change — the author sees it in the review history.",
13533 &headers,
13534 );
13535 }
13536 let submitter_id = state.requested_by;
13537 let workflow_id = state.workflow_id;
13538 if !crate::workflow::reject_current(tenant.pool(), &mut state, viewer_id, &form.comment).await? {
13539 return step_already_decided(id, &headers);
13540 }
13541 crate::page_log::record_or_warn(
13543 tenant.pool(),
13544 id,
13545 crate::page_log::ACTION_WORKFLOW_REJECT,
13546 Some(viewer_id),
13547 format!("Rejected “{}” — changes requested.", current_task.name),
13548 Some(serde_json::json!({
13549 "task_name": current_task.name,
13550 "comment": form.comment,
13551 })),
13552 )
13553 .await;
13554 let workflow_name: String = crate::workflow::Workflow::objects()
13556 .where_(crate::workflow::Workflow::id.eq(workflow_id))
13557 .fetch(tenant.pool())
13558 .await
13559 .ok()
13560 .and_then(|v| v.into_iter().next())
13561 .map(|w| w.name)
13562 .unwrap_or_else(|| "Workflow".to_owned());
13563 let page_title: String = Page::objects()
13564 .where_(Page::id.eq(id))
13565 .fetch(tenant.pool())
13566 .await
13567 .ok()
13568 .and_then(|v| v.into_iter().next())
13569 .map(|p| p.title)
13570 .unwrap_or_else(|| format!("page #{id}"));
13571 notify_workflow(
13572 _state.mailer.as_deref(),
13573 &_state.mailer_from,
13574 tenant.pool(),
13575 &tenant.org.slug,
13576 "reject",
13577 &workflow_name,
13578 &page_title,
13579 id,
13580 Some(¤t_task.name),
13581 Some(&viewer.username),
13582 Some(&form.comment),
13583 WorkflowRecipients::User(submitter_id),
13584 )
13585 .await;
13586 redirect_named_with_params_and_message_args(
13587 "rcms-admin:pages:edit",
13588 &[("id", id.to_string())],
13589 MsgLevel::Success,
13590 "Rejected “{name}” — page returned to author for changes.",
13591 &[("name", current_task.name.as_str())],
13592 &headers,
13593 )
13594}
13595
13596pub async fn page_workflow_cancel(
13597 State(_state): State<super::AdminState>,
13598 tenant: Tenant,
13599 headers: HeaderMap,
13600 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13601 Path(id): Path<i64>,
13602) -> Result<Response, AdminError> {
13603 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
13604 return Ok(unauthorized_no_session());
13605 };
13606 let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13607 return redirect_named_with_params_and_message(
13608 "rcms-admin:pages:edit",
13609 &[("id", id.to_string())],
13610 MsgLevel::Warning,
13611 "This page isn't currently under review.",
13612 &headers,
13613 );
13614 };
13615 let submitter_id = state.requested_by;
13616 let workflow_id = state.workflow_id;
13617 crate::workflow::cancel(tenant.pool(), &mut state, viewer_id).await?;
13618 crate::page_log::record_or_warn(
13620 tenant.pool(),
13621 id,
13622 crate::page_log::ACTION_WORKFLOW_CANCEL,
13623 Some(viewer_id),
13624 "Workflow cancelled.",
13625 Some(serde_json::json!({ "workflow_id": workflow_id })),
13626 )
13627 .await;
13628 let workflow_name: String = crate::workflow::Workflow::objects()
13632 .where_(crate::workflow::Workflow::id.eq(workflow_id))
13633 .fetch(tenant.pool())
13634 .await
13635 .ok()
13636 .and_then(|v| v.into_iter().next())
13637 .map(|w| w.name)
13638 .unwrap_or_else(|| "Workflow".to_owned());
13639 let page_title: String = Page::objects()
13640 .where_(Page::id.eq(id))
13641 .fetch(tenant.pool())
13642 .await
13643 .ok()
13644 .and_then(|v| v.into_iter().next())
13645 .map(|p| p.title)
13646 .unwrap_or_else(|| format!("page #{id}"));
13647 let actor_username = session_user.as_ref().map(|u| u.username.as_str());
13648 notify_workflow(
13649 _state.mailer.as_deref(),
13650 &_state.mailer_from,
13651 tenant.pool(),
13652 &tenant.org.slug,
13653 "cancel",
13654 &workflow_name,
13655 &page_title,
13656 id,
13657 None,
13658 actor_username,
13659 None,
13660 WorkflowRecipients::User(submitter_id),
13661 )
13662 .await;
13663 redirect_named_with_params_and_message(
13664 "rcms-admin:pages:edit",
13665 &[("id", id.to_string())],
13666 MsgLevel::Success,
13667 "Workflow cancelled.",
13668 &headers,
13669 )
13670}
13671
13672pub async fn page_log_csv(
13681 State(_state): State<super::AdminState>,
13682 tenant: Tenant,
13683 Path(id): Path<i64>,
13684) -> Result<Response, AdminError> {
13685 let entries = crate::page_log::for_page(tenant.pool(), id, None).await?;
13686 let user_ids: std::collections::BTreeSet<i64> =
13687 entries.iter().filter_map(|e| e.actor_id).collect();
13688 let users: std::collections::HashMap<i64, String> = if user_ids.is_empty() {
13689 std::collections::HashMap::new()
13690 } else {
13691 rustango::tenancy::auth::User::objects()
13692 .where_(
13693 rustango::tenancy::auth::User::id.is_in(user_ids.into_iter().collect::<Vec<_>>()),
13694 )
13695 .fetch(tenant.pool())
13696 .await?
13697 .into_iter()
13698 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
13699 .collect()
13700 };
13701
13702 let mut out = String::with_capacity(4096);
13703 out.push_str("timestamp,action,actor_id,actor_username,message,data_json\n");
13704 for e in entries {
13705 let ts = e
13706 .created_at
13707 .get()
13708 .map(|t| t.to_rfc3339())
13709 .unwrap_or_default();
13710 let actor_id = e.actor_id.map(|i| i.to_string()).unwrap_or_default();
13711 let actor_username = e
13712 .actor_id
13713 .and_then(|uid| users.get(&uid).cloned())
13714 .unwrap_or_default();
13715 out.push_str(&csv_escape(&ts));
13716 out.push(',');
13717 out.push_str(&csv_escape(&e.action));
13718 out.push(',');
13719 out.push_str(&csv_escape(&actor_id));
13720 out.push(',');
13721 out.push_str(&csv_escape(&actor_username));
13722 out.push(',');
13723 out.push_str(&csv_escape(&e.message));
13724 out.push(',');
13725 out.push_str(&csv_escape(&e.data_json));
13726 out.push('\n');
13727 }
13728
13729 let filename = format!("page-{id}-audit-log.csv");
13730 Ok((
13731 [
13732 (
13733 axum::http::header::CONTENT_TYPE,
13734 "text/csv; charset=utf-8".to_owned(),
13735 ),
13736 (
13737 axum::http::header::CONTENT_DISPOSITION,
13738 format!("attachment; filename=\"{filename}\""),
13739 ),
13740 ],
13741 out,
13742 )
13743 .into_response())
13744}
13745
13746#[derive(Debug, Deserialize)]
13754pub struct HistoryQuery {
13755 #[serde(default)]
13756 pub page_id: Option<i64>,
13757 #[serde(default)]
13758 pub user_id: Option<i64>,
13759 #[serde(default)]
13760 pub page: Option<u32>,
13761 #[serde(default)]
13763 pub per_page: Option<usize>,
13764}
13765
13766pub async fn history_page(
13772 State(state): State<super::AdminState>,
13773 tenant: Tenant,
13774 headers: HeaderMap,
13775 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13776 Query(q): Query<HistoryQuery>,
13777 axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
13778) -> Result<Response, AdminError> {
13779 let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
13780
13781 let mut revisions_query =
13785 crate::revision::Revision::objects().order_by(&[("created_at", true)]); if let Some(pid) = q.page_id {
13787 revisions_query = revisions_query.where_(crate::revision::Revision::page_id.eq(pid));
13788 }
13789 if let Some(uid) = q.user_id {
13790 revisions_query =
13791 revisions_query.where_(crate::revision::Revision::created_by.eq(Some(uid)));
13792 }
13793
13794 let all: Vec<crate::revision::Revision> = revisions_query.fetch(tenant.pool()).await?;
13800 let total = all.len();
13801 let paginator = rustango::pagination::Paginator::new(total, page_size);
13802 let page_obj = paginator.get_page(q.page.unwrap_or(1).max(1) as i64);
13803 let current_page = page_obj.number as u32;
13804 let has_next = page_obj.has_next();
13805 let has_prev = page_obj.has_previous();
13806 let revisions: Vec<crate::revision::Revision> = if total == 0 {
13807 Vec::new()
13808 } else {
13809 all[page_obj.start_index().saturating_sub(1)..page_obj.end_index()].to_vec()
13810 };
13811
13812 let page_ids: std::collections::BTreeSet<i64> = revisions.iter().map(|r| r.page_id).collect();
13814 let user_ids: std::collections::BTreeSet<i64> =
13815 revisions.iter().filter_map(|r| r.created_by).collect();
13816
13817 let pages: Vec<Page> = if page_ids.is_empty() {
13818 Vec::new()
13819 } else {
13820 Page::objects()
13821 .where_(Page::id.is_in(page_ids.iter().copied()))
13822 .fetch(tenant.pool())
13823 .await?
13824 };
13825 let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
13826 Vec::new()
13827 } else {
13828 rustango::tenancy::auth::User::objects()
13829 .where_(rustango::tenancy::auth::User::id.is_in(user_ids.iter().copied()))
13830 .fetch(tenant.pool())
13831 .await?
13832 };
13833
13834 let pages_by_id: std::collections::HashMap<i64, &Page> = pages
13835 .iter()
13836 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
13837 .collect();
13838 let users_by_id: std::collections::HashMap<i64, &rustango::tenancy::auth::User> = users
13839 .iter()
13840 .filter_map(|u| u.id.get().copied().map(|id| (id, u)))
13841 .collect();
13842
13843 let mut latest_seq_by_page: std::collections::HashMap<i64, i32> =
13848 std::collections::HashMap::new();
13849 for r in &all {
13850 let cur = latest_seq_by_page.entry(r.page_id).or_insert(r.sequence);
13851 if r.sequence > *cur {
13852 *cur = r.sequence;
13853 }
13854 }
13855 let mut by_page: std::collections::HashMap<i64, Vec<&crate::revision::Revision>> =
13861 std::collections::HashMap::new();
13862 for r in &all {
13863 by_page.entry(r.page_id).or_default().push(r);
13864 }
13865 let mut prev_by_id: std::collections::HashMap<i64, (i64, i32)> =
13866 std::collections::HashMap::new();
13867 for (_pid, mut list) in by_page {
13868 list.sort_by_key(|r| r.sequence);
13869 for window in list.windows(2) {
13870 let earlier = window[0];
13871 let later = window[1];
13872 if let (Some(later_id), Some(earlier_id)) =
13873 (later.id.get().copied(), earlier.id.get().copied())
13874 {
13875 prev_by_id.insert(later_id, (earlier_id, earlier.sequence));
13876 }
13877 }
13878 }
13879
13880 let rows: Vec<serde_json::Value> = revisions
13881 .iter()
13882 .map(|r| {
13883 let page = pages_by_id.get(&r.page_id);
13884 let user = r.created_by.and_then(|uid| users_by_id.get(&uid));
13885 let created_at = r.created_at.get().copied();
13886 let (prev_id, prev_sequence) =
13887 r.id.get()
13888 .copied()
13889 .and_then(|id| prev_by_id.get(&id).copied())
13890 .map(|(a, b)| (Some(a), Some(b)))
13891 .unwrap_or((None, None));
13892 let is_latest = latest_seq_by_page
13893 .get(&r.page_id)
13894 .is_some_and(|s| *s == r.sequence);
13895 serde_json::json!({
13896 "id": r.id.get().copied(),
13897 "page_id": r.page_id,
13898 "sequence": r.sequence,
13899 "created_at": created_at,
13900 "page_title": page.map(|p| p.title.clone()),
13901 "page_url_path": page.map(|p| p.url_path.clone()),
13902 "page_status": page.map(|p| p.status.as_str()),
13903 "username": user.map(|u| u.username.clone()),
13904 "system_user": r.created_by.is_none(),
13905 "is_latest": is_latest,
13906 "prev_id": prev_id,
13907 "prev_sequence": prev_sequence,
13908 })
13909 })
13910 .collect();
13911
13912 let mut ctx = Context::new();
13913 add_chrome(&mut ctx, &tenant, "history", session_user.as_ref()).await;
13914 add_admin_theme(&mut ctx, tenant.pool()).await;
13915 ctx.insert("rows", &rows);
13916 ctx.insert("filter_page_id", &q.page_id);
13917 ctx.insert("filter_user_id", &q.user_id);
13918 ctx.insert("query_string", &raw_query.unwrap_or_default());
13921 ctx.insert("current_page", ¤t_page);
13922 ctx.insert("has_next", &has_next);
13923 ctx.insert("has_prev", &has_prev);
13924 ctx.insert("total", &total);
13925 ctx.insert("page_size", &page_size);
13926 ctx.insert(
13927 "pagination",
13928 &crate::admin::pagination::context(current_page as i64, page_size, total),
13929 );
13930 render_with_csrf(&state, &headers, "rcms_admin/history.html", &mut ctx)
13931}
13932
13933#[derive(Debug, Deserialize)]
13937pub struct HistoryDiffQuery {
13938 pub a: i64,
13939 pub b: i64,
13940 #[serde(default)]
13941 pub all: Option<String>,
13942}
13943
13944pub async fn history_diff(
13949 State(state): State<super::AdminState>,
13950 tenant: Tenant,
13951 headers: HeaderMap,
13952 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13953 Path(page_id): Path<i64>,
13954 Query(q): Query<HistoryDiffQuery>,
13955) -> Result<Response, AdminError> {
13956 let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
13957 .where_(crate::revision::Revision::page_id.eq(page_id))
13958 .where_(crate::revision::Revision::id.is_in([q.a, q.b]))
13959 .fetch(tenant.pool())
13960 .await?;
13961 let a_row = revisions
13962 .iter()
13963 .find(|r| r.id.get().copied() == Some(q.a))
13964 .cloned()
13965 .ok_or(AdminError::NotFound(q.a))?;
13966 let b_row = revisions
13967 .iter()
13968 .find(|r| r.id.get().copied() == Some(q.b))
13969 .cloned()
13970 .ok_or(AdminError::NotFound(q.b))?;
13971
13972 let page = Page::objects()
13973 .where_(Page::id.eq(page_id))
13974 .first(tenant.pool())
13975 .await?
13976 .ok_or(AdminError::NotFound(page_id))?;
13977
13978 let user_ids: Vec<i64> = [a_row.created_by, b_row.created_by]
13980 .into_iter()
13981 .flatten()
13982 .collect();
13983 let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
13984 Vec::new()
13985 } else {
13986 rustango::tenancy::auth::User::objects()
13987 .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
13988 .fetch(tenant.pool())
13989 .await?
13990 };
13991 let username_for = |uid: Option<i64>| -> Option<String> {
13992 uid.and_then(|id| {
13993 users
13994 .iter()
13995 .find(|u| u.id.get().copied() == Some(id))
13996 .map(|u| u.username.clone())
13997 })
13998 };
13999
14000 let diffs = crate::revision::diff_snapshots(&a_row.snapshot, &b_row.snapshot);
14001 let changed_count = diffs.iter().filter(|d| d.is_change()).count();
14002 let only_changes = q.all.is_none();
14003
14004 let mut ctx = Context::new();
14005 add_chrome(&mut ctx, &tenant, "history", session_user.as_ref()).await;
14006 add_admin_theme(&mut ctx, tenant.pool()).await;
14007 ctx.insert("page", &page);
14008 ctx.insert(
14009 "rev_a",
14010 &serde_json::json!({
14011 "id": a_row.id.get().copied(),
14012 "sequence": a_row.sequence,
14013 "created_at": a_row.created_at.get().copied(),
14014 "username": username_for(a_row.created_by),
14015 }),
14016 );
14017 ctx.insert(
14018 "rev_b",
14019 &serde_json::json!({
14020 "id": b_row.id.get().copied(),
14021 "sequence": b_row.sequence,
14022 "created_at": b_row.created_at.get().copied(),
14023 "username": username_for(b_row.created_by),
14024 }),
14025 );
14026 ctx.insert("diffs", &diffs);
14027 ctx.insert("changed_count", &changed_count);
14028 ctx.insert("only_changes", &only_changes);
14029 render_with_csrf(&state, &headers, "rcms_admin/history_diff.html", &mut ctx)
14030}
14031
14032#[derive(Debug, Deserialize)]
14037pub struct AnalyticsQuery {
14038 #[serde(default)]
14040 pub days: Option<i64>,
14041}
14042
14043pub async fn analytics_dashboard(
14047 State(state): State<super::AdminState>,
14048 tenant: Tenant,
14049 headers: HeaderMap,
14050 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14051 Query(q): Query<AnalyticsQuery>,
14052) -> Result<Response, AdminError> {
14053 let days = q.days.unwrap_or(30).clamp(1, 365);
14054 let to = chrono::Utc::now();
14055 let from = to - chrono::Duration::days(days);
14056 let metrics = crate::analytics::query::compute(tenant.pool(), from, to).await?;
14057 let host = headers
14058 .get(header::HOST)
14059 .and_then(|v| v.to_str().ok())
14060 .unwrap_or("");
14061 let active_now = crate::analytics::presence_count(host);
14062 let series_max = metrics
14065 .series
14066 .iter()
14067 .map(|p| p.pageviews)
14068 .max()
14069 .unwrap_or(0)
14070 .max(1);
14071
14072 let mut ctx = Context::new();
14073 add_chrome(&mut ctx, &tenant, "analytics", session_user.as_ref()).await;
14074 add_admin_theme(&mut ctx, tenant.pool()).await;
14075 ctx.insert("metrics", &metrics);
14076 ctx.insert("active_now", &active_now);
14077 ctx.insert("series_max", &series_max);
14078 ctx.insert("days", &days);
14079 render_with_csrf(&state, &headers, "rcms_admin/analytics.html", &mut ctx)
14080}
14081
14082#[derive(Debug, Deserialize)]
14083pub struct AgingQuery {
14084 #[serde(default)]
14086 pub min_days: Option<i64>,
14087 #[serde(default)]
14089 pub status: Option<String>,
14090 #[serde(default)]
14092 pub page: Option<u32>,
14093 #[serde(default)]
14095 pub per_page: Option<usize>,
14096}
14097
14098pub async fn aging_pages_report(
14102 State(state): State<super::AdminState>,
14103 tenant: Tenant,
14104 headers: HeaderMap,
14105 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14106 Query(q): Query<AgingQuery>,
14107 axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
14108) -> Result<Response, AdminError> {
14109 let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
14110 let min_days = q.min_days.unwrap_or(90).max(0);
14111 let status_filter = q
14112 .status
14113 .as_deref()
14114 .map(str::trim)
14115 .filter(|s| !s.is_empty() && *s != "all")
14116 .map(str::to_owned)
14117 .unwrap_or_else(|| "published".to_owned());
14118
14119 let now = chrono::Utc::now();
14120 let mut q_pages = Page::objects().order_by(&[("updated_at", false)]); if status_filter != "all" {
14122 q_pages = q_pages.where_(Page::status.eq(status_filter.clone()));
14123 }
14124 let all: Vec<Page> = q_pages.fetch(tenant.pool()).await?;
14125
14126 let stale: Vec<&Page> = all
14128 .iter()
14129 .filter(|p| match p.updated_at.get().copied() {
14130 Some(ts) => {
14131 let delta = now.signed_duration_since(ts).num_days();
14132 delta >= min_days
14133 }
14134 None => false,
14135 })
14136 .collect();
14137 let total = stale.len();
14138 let paginator = rustango::pagination::Paginator::new(total, page_size);
14142 let page_obj = paginator.get_page(q.page.unwrap_or(1).max(1) as i64);
14143 let current_page = page_obj.number as u32;
14144 let has_next = page_obj.has_next();
14145 let has_prev = page_obj.has_previous();
14146 let slice: Vec<&&Page> = if total == 0 {
14147 Vec::new()
14148 } else {
14149 stale[page_obj.start_index().saturating_sub(1)..page_obj.end_index()]
14150 .iter()
14151 .collect()
14152 };
14153
14154 let page_ids: Vec<i64> = slice.iter().filter_map(|p| p.id.get().copied()).collect();
14157 let revisions: Vec<crate::revision::Revision> = if page_ids.is_empty() {
14158 Vec::new()
14159 } else {
14160 crate::revision::Revision::objects()
14161 .where_(crate::revision::Revision::page_id.is_in(page_ids.iter().copied()))
14162 .order_by(&[("sequence", true)]) .fetch(tenant.pool())
14164 .await
14165 .unwrap_or_default()
14166 };
14167 let mut last_editor_by_page: std::collections::HashMap<i64, Option<i64>> =
14168 std::collections::HashMap::new();
14169 for r in &revisions {
14170 last_editor_by_page.entry(r.page_id).or_insert(r.created_by);
14173 }
14174 let user_ids: Vec<i64> = last_editor_by_page
14175 .values()
14176 .filter_map(|opt| *opt)
14177 .collect();
14178 let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
14179 Vec::new()
14180 } else {
14181 rustango::tenancy::auth::User::objects()
14182 .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
14183 .fetch(tenant.pool())
14184 .await
14185 .unwrap_or_default()
14186 };
14187 let username_by_id: std::collections::HashMap<i64, String> = users
14188 .into_iter()
14189 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
14190 .collect();
14191
14192 let rows: Vec<serde_json::Value> = slice
14193 .iter()
14194 .map(|p| {
14195 let pid = p.id.get().copied().unwrap_or_default();
14196 let updated = p.updated_at.get().copied();
14197 let days_stale = updated.map(|ts| now.signed_duration_since(ts).num_days());
14198 let editor = last_editor_by_page
14199 .get(&pid)
14200 .and_then(|v| *v)
14201 .and_then(|uid| username_by_id.get(&uid).cloned());
14202 serde_json::json!({
14203 "id": pid,
14204 "title": p.title,
14205 "url_path": p.url_path,
14206 "status": p.status,
14207 "updated_at": updated,
14208 "days_stale": days_stale,
14209 "last_editor": editor,
14210 })
14211 })
14212 .collect();
14213
14214 let mut ctx = Context::new();
14215 add_chrome(&mut ctx, &tenant, "reports", session_user.as_ref()).await;
14216 add_admin_theme(&mut ctx, tenant.pool()).await;
14217 ctx.insert("rows", &rows);
14218 ctx.insert("min_days", &min_days);
14219 ctx.insert("status_filter", &status_filter);
14220 ctx.insert("query_string", &raw_query.unwrap_or_default());
14223 ctx.insert("current_page", ¤t_page);
14224 ctx.insert("has_next", &has_next);
14225 ctx.insert("has_prev", &has_prev);
14226 ctx.insert("total", &total);
14227 ctx.insert("page_size", &page_size);
14228 ctx.insert(
14229 "pagination",
14230 &crate::admin::pagination::context(current_page as i64, page_size, total),
14231 );
14232 render_with_csrf(&state, &headers, "rcms_admin/aging_pages.html", &mut ctx)
14233}
14234
14235pub async fn aging_pages_csv(
14239 State(_state): State<super::AdminState>,
14240 tenant: Tenant,
14241 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14242 Query(q): Query<AgingQuery>,
14243) -> Result<Response, AdminError> {
14244 let min_days = q.min_days.unwrap_or(90).max(0);
14245 let status_filter = q
14246 .status
14247 .as_deref()
14248 .map(str::trim)
14249 .filter(|s| !s.is_empty() && *s != "all")
14250 .map(str::to_owned)
14251 .unwrap_or_else(|| "published".to_owned());
14252 let now = chrono::Utc::now();
14253 let mut q_pages = Page::objects().order_by(&[("updated_at", false)]);
14254 if status_filter != "all" {
14255 q_pages = q_pages.where_(Page::status.eq(status_filter.clone()));
14256 }
14257 let all: Vec<Page> = q_pages.fetch(tenant.pool()).await?;
14258 let stale: Vec<&Page> = all
14259 .iter()
14260 .filter(|p| match p.updated_at.get().copied() {
14261 Some(ts) => now.signed_duration_since(ts).num_days() >= min_days,
14262 None => false,
14263 })
14264 .collect();
14265
14266 let mut out = String::with_capacity(256 + stale.len() * 96);
14267 out.push_str("page_id,title,url_path,status,updated_at,days_stale\n");
14268 for p in stale {
14269 let pid = p.id.get().copied().unwrap_or_default();
14270 let updated = p.updated_at.get().copied();
14271 let days = updated
14272 .map(|ts| now.signed_duration_since(ts).num_days())
14273 .unwrap_or_default();
14274 let when = updated.map(|t| t.to_rfc3339()).unwrap_or_default();
14275 out.push_str(&format!(
14276 "{},{},{},{},{},{}\n",
14277 pid,
14278 csv_escape(&p.title),
14279 csv_escape(&p.url_path),
14280 csv_escape(&p.status),
14281 csv_escape(&when),
14282 days
14283 ));
14284 }
14285 Ok(csv_response("aging-pages", &out))
14286}
14287
14288fn csv_response(name: &str, body: &str) -> Response {
14290 let filename = format!("{name}-{}.csv", chrono::Utc::now().format("%Y%m%d"));
14291 let mut response = (
14292 [(header::CONTENT_TYPE, "text/csv; charset=utf-8")],
14293 body.to_owned(),
14294 )
14295 .into_response();
14296 if let Ok(v) = HeaderValue::from_str(&format!("attachment; filename=\"{filename}\"")) {
14297 response
14298 .headers_mut()
14299 .insert(header::CONTENT_DISPOSITION, v);
14300 }
14301 response
14302}
14303
14304pub async fn site_settings_list(
14309 State(state): State<super::AdminState>,
14310 tenant: Tenant,
14311 headers: HeaderMap,
14312 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14313) -> Result<Response, AdminError> {
14314 let rows = crate::site_setting::list_all(tenant.pool())
14315 .await
14316 .unwrap_or_default();
14317 let by_scope: std::collections::HashMap<&str, &crate::site_setting::SiteSetting> =
14318 rows.iter().map(|r| (r.scope.as_str(), r)).collect();
14319 let mut view: Vec<serde_json::Value> = Vec::new();
14323 for schema in crate::site_setting::registered_schemas() {
14324 let row = by_scope.get(schema.scope).copied();
14325 view.push(serde_json::json!({
14326 "scope": schema.scope,
14327 "label": schema.label,
14328 "typed": true,
14329 "configured": row.is_some(),
14330 "preview": row
14331 .map(|r| serde_json::to_string(&r.value_json).unwrap_or_default())
14332 .unwrap_or_default(),
14333 "updated_at": row.and_then(|r| r.updated_at.get().copied()),
14334 }));
14335 }
14336 for s in &rows {
14337 if crate::site_setting::schema_for(&s.scope).is_some() {
14338 continue;
14339 }
14340 view.push(serde_json::json!({
14341 "scope": s.scope,
14342 "label": s.scope,
14343 "typed": false,
14344 "configured": true,
14345 "preview": serde_json::to_string(&s.value_json).unwrap_or_default(),
14346 "updated_at": s.updated_at.get().copied(),
14347 }));
14348 }
14349 let mut ctx = Context::new();
14350 add_chrome(&mut ctx, &tenant, "site-settings", session_user.as_ref()).await;
14351 add_admin_theme(&mut ctx, tenant.pool()).await;
14352 ctx.insert("rows", &view);
14353 render_with_csrf(
14354 &state,
14355 &headers,
14356 "rcms_admin/site_settings_list.html",
14357 &mut ctx,
14358 )
14359}
14360
14361pub async fn site_setting_edit_form(
14362 State(state): State<super::AdminState>,
14363 tenant: Tenant,
14364 headers: HeaderMap,
14365 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14366 Path(scope): Path<String>,
14367 Query(q): Query<EditQuery>,
14368) -> Result<Response, AdminError> {
14369 let row = crate::site_setting::get(tenant.pool(), &scope)
14370 .await
14371 .unwrap_or(None);
14372 let stored = row
14373 .as_ref()
14374 .map(|s| s.value_json.clone())
14375 .unwrap_or_else(|| serde_json::json!({}));
14376 let mut ctx = Context::new();
14377 add_chrome(&mut ctx, &tenant, "site-settings", session_user.as_ref()).await;
14378 add_admin_theme(&mut ctx, tenant.pool()).await;
14379 ctx.insert("scope", &scope);
14380 ctx.insert("is_new", &row.is_none());
14381 if let Some(schema) = crate::site_setting::schema_for(&scope) {
14384 let widgets = crate::site_setting::prefill_widgets((schema.fields)(), &stored);
14385 ctx.insert("typed", &true);
14386 ctx.insert("schema_label", schema.label);
14387 let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
14389 .where_(crate::locale::Locale::active.eq(true))
14390 .order_by(&[("sort_order", false), ("code", false)])
14391 .fetch(tenant.pool())
14392 .await?;
14393 let editing = q
14394 .locale
14395 .as_deref()
14396 .and_then(|c| locales.iter().find(|l| l.code == c && !l.is_default).cloned());
14397 if let (Some(loc), false) = (&editing, row.is_none()) {
14398 let tr = crate::site_setting::translations(&stored, &loc.code);
14399 let rows: Vec<serde_json::Value> = widgets
14400 .iter()
14401 .filter(|w| site_setting_translatable(w))
14402 .map(|w| {
14403 serde_json::json!({
14404 "name": w.name,
14405 "label": w.label,
14406 "canonical": w.value,
14407 "multiline": !matches!(w.kind, crate::widget::WidgetKind::Text),
14408 "value": tr.get(&w.name).and_then(|v| v.as_str()).unwrap_or(""),
14409 })
14410 })
14411 .collect();
14412 ctx.insert("translation_mode", &true);
14413 ctx.insert("editing_locale", loc);
14414 ctx.insert("tr_rows", &rows);
14415 }
14416 ctx.insert("locales", &locales);
14417 ctx.insert("widgets", &widgets);
14418 } else {
14419 ctx.insert("typed", &false);
14420 let body = serde_json::to_string_pretty(&stored).unwrap_or_else(|_| "{}".to_owned());
14421 ctx.insert("value_pretty", &body);
14422 }
14423 render_with_csrf(
14424 &state,
14425 &headers,
14426 "rcms_admin/site_setting_form.html",
14427 &mut ctx,
14428 )
14429}
14430
14431pub async fn site_setting_edit_submit(
14432 State(_state): State<super::AdminState>,
14433 tenant: Tenant,
14434 headers: HeaderMap,
14435 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14436 Path(scope): Path<String>,
14437 Form(form): Form<std::collections::HashMap<String, String>>,
14438) -> Result<Response, AdminError> {
14439 let parsed: serde_json::Value = if let Some(schema) = crate::site_setting::schema_for(&scope) {
14442 let fields = (schema.fields)();
14443 let missing = crate::site_setting::missing_required(&fields, &form);
14444 if !missing.is_empty() {
14445 return Err(AdminError::Validation(format!(
14446 "These required fields are empty: {}.",
14447 missing.join(", ")
14448 )));
14449 }
14450 let mut value = crate::site_setting::value_json_from_form(&fields, &form);
14451 if let Ok(Some(old)) = crate::site_setting::get(tenant.pool(), &scope).await {
14452 crate::site_setting::keep_translations(&old.value_json, &mut value);
14453 }
14454 value
14455 } else {
14456 let raw = form.get("value_json").map_or("", |s| s.trim());
14457 if raw.is_empty() {
14458 serde_json::json!({})
14459 } else {
14460 serde_json::from_str(raw)
14461 .map_err(|e| AdminError::Validation(format!("value_json isn't valid JSON: {e}")))?
14462 }
14463 };
14464 crate::site_setting::upsert(tenant.pool(), &scope, parsed).await?;
14465 redirect_named_with_message_args(
14466 "rcms-admin:site-settings:list",
14467 MsgLevel::Success,
14468 "Saved site setting “{scope}”.",
14469 &[("scope", scope.as_str())],
14470 &headers,
14471 )
14472}
14473
14474fn site_setting_translatable(w: &crate::widget::Widget) -> bool {
14476 use crate::widget::WidgetKind as K;
14477 matches!(w.kind, K::Text | K::Textarea | K::Markdown | K::RichText)
14478}
14479
14480pub async fn site_setting_translate_submit(
14483 State(_state): State<super::AdminState>,
14484 tenant: Tenant,
14485 headers: HeaderMap,
14486 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14487 Path(scope): Path<String>,
14488 Query(q): Query<EditQuery>,
14489 Form(form): Form<std::collections::HashMap<String, String>>,
14490) -> Result<Response, AdminError> {
14491 let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
14492 let schema = crate::site_setting::schema_for(&scope)
14493 .ok_or_else(|| AdminError::Validation(format!("`{scope}` has no typed fields to translate")))?;
14494 let row = crate::site_setting::get(tenant.pool(), &scope)
14495 .await?
14496 .ok_or_else(|| AdminError::Validation(format!("save `{scope}` before translating it")))?;
14497 let fields: serde_json::Map<String, serde_json::Value> = (schema.fields)()
14498 .iter()
14499 .filter(|w| site_setting_translatable(w))
14500 .filter_map(|w| {
14501 form.get(&format!("tr__{}", w.name))
14502 .map(|v| (w.name.clone(), serde_json::Value::String(v.trim().to_owned())))
14503 })
14504 .collect();
14505 let mut value = row.value_json;
14506 crate::site_setting::set_translations(&mut value, &locale.code, fields);
14507 crate::site_setting::upsert(tenant.pool(), &scope, value).await?;
14508 Ok(rustango::messages::redirect_with_message(
14509 messages_secret(),
14510 &headers,
14511 MsgLevel::Success,
14512 &super::i18n::tr(&headers, "Translations saved.", &[]),
14513 &format!("/cms-admin/site-settings/{scope}/edit?locale={}", locale.code),
14514 ))
14515}
14516
14517pub async fn site_setting_delete_submit(
14518 State(_state): State<super::AdminState>,
14519 tenant: Tenant,
14520 headers: HeaderMap,
14521 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14522 Path(scope): Path<String>,
14523) -> Result<Response, AdminError> {
14524 if let Some(row) = crate::site_setting::get(tenant.pool(), &scope)
14525 .await
14526 .unwrap_or(None)
14527 {
14528 row.delete_pool(tenant.pool()).await?;
14529 }
14530 redirect_named_with_message_args(
14531 "rcms-admin:site-settings:list",
14532 MsgLevel::Success,
14533 "Deleted site setting “{scope}”.",
14534 &[("scope", scope.as_str())],
14535 &headers,
14536 )
14537}
14538
14539pub async fn search_promotions_report(
14548 State(state): State<super::AdminState>,
14549 tenant: Tenant,
14550 headers: HeaderMap,
14551 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14552) -> Result<Response, AdminError> {
14553 let top = crate::search_promotion::top_queries(tenant.pool(), 100)
14554 .await
14555 .unwrap_or_default();
14556 let mut rows: Vec<serde_json::Value> = Vec::with_capacity(top.len());
14558 for q in top {
14559 let qid = q.id.get().copied().unwrap_or_default();
14560 let promos = crate::search_promotion::promotions_for_query(tenant.pool(), qid)
14561 .await
14562 .unwrap_or_default();
14563 rows.push(serde_json::json!({
14564 "id": qid,
14565 "raw": q.raw,
14566 "normalized": q.normalized,
14567 "hits": q.hits,
14568 "last_seen_at": q.last_seen_at.get().copied(),
14569 "promotion_count": promos.len(),
14570 }));
14571 }
14572 let mut ctx = Context::new();
14573 add_chrome(&mut ctx, &tenant, "reports-search", session_user.as_ref()).await;
14574 add_admin_theme(&mut ctx, tenant.pool()).await;
14575 ctx.insert("rows", &rows);
14576 render_with_csrf(
14577 &state,
14578 &headers,
14579 "rcms_admin/search_promotions_report.html",
14580 &mut ctx,
14581 )
14582}
14583
14584pub async fn search_promotion_edit_form(
14587 State(state): State<super::AdminState>,
14588 tenant: Tenant,
14589 headers: HeaderMap,
14590 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14591 Path(query_id): Path<i64>,
14592) -> Result<Response, AdminError> {
14593 use rustango::core::Column as _;
14594 use rustango::sql::FetcherPool as _;
14595 let queries: Vec<crate::search_promotion::SearchQuery> =
14596 crate::search_promotion::SearchQuery::objects()
14597 .where_(crate::search_promotion::SearchQuery::id.eq(query_id))
14598 .fetch(tenant.pool())
14599 .await?;
14600 let Some(query) = queries.into_iter().next() else {
14601 return Err(AdminError::NotFound(query_id));
14602 };
14603 let promotions = crate::search_promotion::promotions_for_query(tenant.pool(), query_id)
14604 .await
14605 .unwrap_or_default();
14606 let pages: Vec<Page> = Page::objects()
14607 .where_(Page::status.eq("published".to_owned()))
14608 .order_by(&[("title", false)])
14609 .fetch(tenant.pool())
14610 .await
14611 .unwrap_or_default();
14612 let mut ctx = Context::new();
14613 add_chrome(&mut ctx, &tenant, "reports-search", session_user.as_ref()).await;
14614 add_admin_theme(&mut ctx, tenant.pool()).await;
14615 ctx.insert("query", &query);
14616 ctx.insert("promotions", &promotions);
14617 ctx.insert("pages", &pages);
14618 render_with_csrf(
14619 &state,
14620 &headers,
14621 "rcms_admin/search_promotion_edit.html",
14622 &mut ctx,
14623 )
14624}
14625
14626#[derive(Debug, Deserialize)]
14627pub struct SearchPromotionForm {
14628 #[serde(default)]
14630 pub page_ids: String,
14631 #[serde(default)]
14632 pub descriptions: String,
14633}
14634
14635pub async fn search_promotion_edit_submit(
14638 State(_state): State<super::AdminState>,
14639 tenant: Tenant,
14640 headers: HeaderMap,
14641 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14642 Path(query_id): Path<i64>,
14643 Form(form): Form<SearchPromotionForm>,
14644) -> Result<Response, AdminError> {
14645 use rustango::core::Column as _;
14646 use rustango::sql::Auto;
14647 use rustango::sql::FetcherPool as _;
14648 let existing: Vec<crate::search_promotion::SearchPromotion> =
14651 crate::search_promotion::SearchPromotion::objects()
14652 .where_(crate::search_promotion::SearchPromotion::query_id.eq(query_id))
14653 .fetch(tenant.pool())
14654 .await?;
14655 for row in existing {
14656 row.delete_pool(tenant.pool()).await.log_warn("old search promotion not deleted");
14657 }
14658 let ids: Vec<i64> = form
14659 .page_ids
14660 .split(',')
14661 .map(str::trim)
14662 .filter(|s| !s.is_empty())
14663 .filter_map(|s| s.parse::<i64>().ok())
14664 .collect();
14665 let descriptions: Vec<String> = form
14666 .descriptions
14667 .split('\n')
14668 .map(|s| s.trim().to_owned())
14669 .collect();
14670 for (idx, page_id) in ids.iter().enumerate() {
14671 let mut row = crate::search_promotion::SearchPromotion {
14672 id: Auto::Unset,
14673 query_id,
14674 page_id: *page_id,
14675 sort_order: idx as i32,
14676 description: descriptions.get(idx).cloned().unwrap_or_default(),
14677 created_at: Auto::Unset,
14678 };
14679 row.insert_pool(tenant.pool()).await.log_warn("search promotion not saved");
14680 }
14681 redirect_named_with_message_plural(
14682 "rcms-admin:reports:search",
14683 MsgLevel::Success,
14684 "Saved {count} pinned result(s).",
14685 ids.len() as i64,
14686 &[("count", &ids.len().to_string())],
14687 &headers,
14688 )
14689}
14690
14691pub(crate) fn derive_scheduled_status(
14707 current: &str,
14708 go_live_at: Option<chrono::DateTime<chrono::Utc>>,
14709) -> String {
14710 let archived = crate::page::PageStatus::Archived.as_str();
14711 if current == archived {
14712 return current.to_owned();
14713 }
14714 let now = chrono::Utc::now();
14715 let future = go_live_at.is_some_and(|t| t > now);
14716 let scheduled = crate::page::PageStatus::Scheduled.as_str();
14717 let draft = crate::page::PageStatus::Draft.as_str();
14718 match (current, future, go_live_at) {
14719 (_, true, _) => scheduled.to_owned(),
14720 (s, false, None) if s == scheduled => draft.to_owned(),
14721 _ => current.to_owned(),
14722 }
14723}
14724
14725#[cfg(test)]
14726mod scheduled_status_tests {
14727 use super::derive_scheduled_status;
14728 use chrono::{Duration, Utc};
14729
14730 #[test]
14731 fn future_go_live_promotes_draft_to_scheduled() {
14732 let go = Utc::now() + Duration::hours(1);
14733 assert_eq!(derive_scheduled_status("draft", Some(go)), "scheduled");
14734 }
14735
14736 #[test]
14737 fn future_go_live_also_promotes_published() {
14738 let go = Utc::now() + Duration::hours(2);
14741 assert_eq!(derive_scheduled_status("published", Some(go)), "scheduled");
14742 }
14743
14744 #[test]
14745 fn cleared_go_live_demotes_scheduled_to_draft() {
14746 assert_eq!(derive_scheduled_status("scheduled", None), "draft");
14747 }
14748
14749 #[test]
14750 fn past_go_live_on_scheduled_left_alone_for_sweep() {
14751 let past = Utc::now() - Duration::hours(1);
14752 assert_eq!(
14753 derive_scheduled_status("scheduled", Some(past)),
14754 "scheduled",
14755 );
14756 }
14757
14758 #[test]
14759 fn archived_preserved_regardless_of_go_live() {
14760 let go = Utc::now() + Duration::hours(1);
14761 assert_eq!(derive_scheduled_status("archived", Some(go)), "archived");
14762 assert_eq!(derive_scheduled_status("archived", None), "archived");
14763 }
14764
14765 #[test]
14766 fn draft_with_no_go_live_unchanged() {
14767 assert_eq!(derive_scheduled_status("draft", None), "draft");
14768 }
14769
14770 #[test]
14771 fn published_with_no_go_live_unchanged() {
14772 assert_eq!(derive_scheduled_status("published", None), "published");
14773 }
14774}
14775
14776async fn scheduled_pages_rows(
14781 pool: &rustango::sql::Pool,
14782) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
14783 use rustango::sql::FetcherPool as _;
14784 let pages: Vec<Page> = Page::objects().fetch(pool).await?;
14785 let now = chrono::Utc::now();
14786 let mut rows: Vec<serde_json::Value> = Vec::new();
14787 for p in &pages {
14788 let pid = p.id.get().copied().unwrap_or_default();
14789 if let Some(go) = p.go_live_at {
14790 if go > now
14798 && p.status != crate::page::PageStatus::Archived.as_str()
14799 && p.status != crate::page::PageStatus::Expired.as_str()
14800 {
14801 let countdown = (go - now).num_seconds();
14802 rows.push(serde_json::json!({
14803 "kind": "publish",
14804 "when": go,
14805 "countdown_secs": countdown,
14806 "page_id": pid,
14807 "title": p.title,
14808 "url_path": p.url_path,
14809 "status": p.status,
14810 }));
14811 }
14812 }
14813 if let Some(exp) = p.expire_at {
14814 if exp > now
14816 && (p.status == crate::page::PageStatus::Published.as_str()
14817 || p.status == crate::page::PageStatus::Scheduled.as_str())
14818 {
14819 let countdown = (exp - now).num_seconds();
14820 rows.push(serde_json::json!({
14821 "kind": "expire",
14822 "when": exp,
14823 "countdown_secs": countdown,
14824 "page_id": pid,
14825 "title": p.title,
14826 "url_path": p.url_path,
14827 "status": p.status,
14828 }));
14829 }
14830 }
14831 }
14832 rows.sort_by_key(|r| {
14833 r.get("countdown_secs")
14834 .and_then(|v| v.as_i64())
14835 .unwrap_or(i64::MAX)
14836 });
14837 Ok(rows)
14838}
14839
14840pub async fn scheduled_report(
14841 State(state): State<super::AdminState>,
14842 tenant: Tenant,
14843 headers: HeaderMap,
14844 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14845) -> Result<Response, AdminError> {
14846 let rows = scheduled_pages_rows(tenant.pool())
14847 .await
14848 .unwrap_or_default();
14849 let mut ctx = Context::new();
14850 add_chrome(
14851 &mut ctx,
14852 &tenant,
14853 "reports-scheduled",
14854 session_user.as_ref(),
14855 )
14856 .await;
14857 add_admin_theme(&mut ctx, tenant.pool()).await;
14858 ctx.insert("rows", &rows);
14859 render_with_csrf(
14860 &state,
14861 &headers,
14862 "rcms_admin/scheduled_report.html",
14863 &mut ctx,
14864 )
14865}
14866
14867pub async fn scheduled_report_csv(
14868 State(_state): State<super::AdminState>,
14869 tenant: Tenant,
14870 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14871) -> Result<Response, AdminError> {
14872 let rows = scheduled_pages_rows(tenant.pool())
14873 .await
14874 .unwrap_or_default();
14875 let mut out = String::with_capacity(256 + rows.len() * 160);
14876 out.push_str("kind,page_id,title,url_path,status,when,countdown_secs\n");
14877 for r in &rows {
14878 out.push_str(&format!(
14879 "{},{},{},{},{},{},{}\n",
14880 csv_escape(r.get("kind").and_then(|v| v.as_str()).unwrap_or_default()),
14881 r.get("page_id")
14882 .and_then(|v| v.as_i64())
14883 .unwrap_or_default(),
14884 csv_escape(r.get("title").and_then(|v| v.as_str()).unwrap_or_default()),
14885 csv_escape(
14886 r.get("url_path")
14887 .and_then(|v| v.as_str())
14888 .unwrap_or_default()
14889 ),
14890 csv_escape(r.get("status").and_then(|v| v.as_str()).unwrap_or_default()),
14891 csv_escape(&r.get("when").map(ToString::to_string).unwrap_or_default()),
14892 r.get("countdown_secs")
14893 .and_then(|v| v.as_i64())
14894 .unwrap_or_default(),
14895 ));
14896 }
14897 Ok(csv_response("scheduled-pages", &out))
14898}
14899
14900async fn locked_pages_rows(
14904 pool: &rustango::sql::Pool,
14905) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
14906 use rustango::sql::FetcherPool as _;
14907 let locks: Vec<crate::lock::PageLock> = crate::lock::PageLock::objects()
14908 .order_by(&[("acquired_at", true)]) .fetch(pool)
14910 .await?;
14911 let now = chrono::Utc::now();
14912 let live: Vec<&crate::lock::PageLock> = locks.iter().filter(|l| !l.is_stale(now)).collect();
14913 if live.is_empty() {
14914 return Ok(Vec::new());
14915 }
14916 let page_ids: Vec<i64> = live.iter().map(|l| l.page_id).collect();
14917 let user_ids: Vec<i64> = live.iter().map(|l| l.user_id).collect();
14918 let pages: Vec<Page> = Page::objects()
14919 .where_(Page::id.is_in(page_ids))
14920 .fetch(pool)
14921 .await
14922 .unwrap_or_default();
14923 let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
14924 .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
14925 .fetch(pool)
14926 .await
14927 .unwrap_or_default();
14928 let page_by_id: std::collections::HashMap<i64, &Page> = pages
14929 .iter()
14930 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
14931 .collect();
14932 let user_by_id: std::collections::HashMap<i64, String> = users
14933 .into_iter()
14934 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
14935 .collect();
14936 Ok(live
14937 .into_iter()
14938 .map(|l| {
14939 let title = page_by_id
14940 .get(&l.page_id)
14941 .map(|p| p.title.clone())
14942 .unwrap_or_else(|| format!("page #{}", l.page_id));
14943 let url_path = page_by_id
14944 .get(&l.page_id)
14945 .map(|p| p.url_path.clone())
14946 .unwrap_or_default();
14947 let username = user_by_id
14948 .get(&l.user_id)
14949 .cloned()
14950 .unwrap_or_else(|| format!("user#{}", l.user_id));
14951 let ttl_remaining = (l.expires_at - now).num_seconds();
14952 serde_json::json!({
14953 "page_id": l.page_id,
14954 "title": title,
14955 "url_path": url_path,
14956 "user_id": l.user_id,
14957 "username": username,
14958 "acquired_at": l.acquired_at.get().copied(),
14959 "expires_at": l.expires_at,
14960 "ttl_remaining_secs": ttl_remaining,
14961 })
14962 })
14963 .collect())
14964}
14965
14966pub async fn locked_pages_report(
14967 State(state): State<super::AdminState>,
14968 tenant: Tenant,
14969 headers: HeaderMap,
14970 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14971) -> Result<Response, AdminError> {
14972 let rows = locked_pages_rows(tenant.pool()).await.unwrap_or_default();
14973 let mut ctx = Context::new();
14974 add_chrome(&mut ctx, &tenant, "reports-locked", session_user.as_ref()).await;
14975 add_admin_theme(&mut ctx, tenant.pool()).await;
14976 ctx.insert("rows", &rows);
14977 render_with_csrf(&state, &headers, "rcms_admin/locked_pages.html", &mut ctx)
14978}
14979
14980pub async fn locked_pages_csv(
14981 State(_state): State<super::AdminState>,
14982 tenant: Tenant,
14983 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14984) -> Result<Response, AdminError> {
14985 let rows = locked_pages_rows(tenant.pool()).await.unwrap_or_default();
14986 let mut out = String::with_capacity(256 + rows.len() * 128);
14987 out.push_str("page_id,title,url_path,username,acquired_at,expires_at\n");
14988 for r in &rows {
14989 out.push_str(&format!(
14990 "{},{},{},{},{},{}\n",
14991 r.get("page_id")
14992 .and_then(|v| v.as_i64())
14993 .unwrap_or_default(),
14994 csv_escape(r.get("title").and_then(|v| v.as_str()).unwrap_or_default()),
14995 csv_escape(
14996 r.get("url_path")
14997 .and_then(|v| v.as_str())
14998 .unwrap_or_default()
14999 ),
15000 csv_escape(
15001 r.get("username")
15002 .and_then(|v| v.as_str())
15003 .unwrap_or_default()
15004 ),
15005 csv_escape(
15006 r.get("acquired_at")
15007 .and_then(|v| v.as_str())
15008 .unwrap_or_default()
15009 ),
15010 csv_escape(
15011 r.get("expires_at")
15012 .and_then(|v| v.as_str())
15013 .unwrap_or_default()
15014 ),
15015 ));
15016 }
15017 Ok(csv_response("locked-pages", &out))
15018}
15019
15020async fn workflows_report_rows(
15025 pool: &rustango::sql::Pool,
15026) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
15027 use rustango::sql::FetcherPool as _;
15028 let states: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
15029 .order_by(&[("requested_at", true)]) .fetch(pool)
15031 .await?;
15032 if states.is_empty() {
15033 return Ok(Vec::new());
15034 }
15035 let workflow_ids: Vec<i64> = states.iter().map(|s| s.workflow_id).collect();
15036 let page_ids: Vec<i64> = states.iter().map(|s| s.page_id).collect();
15037 let user_ids: Vec<i64> = states.iter().map(|s| s.requested_by).collect();
15038 let workflows: Vec<crate::workflow::Workflow> = crate::workflow::Workflow::objects()
15039 .where_(crate::workflow::Workflow::id.is_in(workflow_ids))
15040 .fetch(pool)
15041 .await
15042 .unwrap_or_default();
15043 let pages: Vec<Page> = Page::objects()
15044 .where_(Page::id.is_in(page_ids))
15045 .fetch(pool)
15046 .await
15047 .unwrap_or_default();
15048 let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
15049 .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
15050 .fetch(pool)
15051 .await
15052 .unwrap_or_default();
15053 let task_ids: Vec<i64> = states.iter().filter_map(|s| s.current_task_id).collect();
15054 let tasks: Vec<crate::workflow::WorkflowTask> = if task_ids.is_empty() {
15055 Vec::new()
15056 } else {
15057 crate::workflow::WorkflowTask::objects()
15058 .where_(crate::workflow::WorkflowTask::id.is_in(task_ids))
15059 .fetch(pool)
15060 .await
15061 .unwrap_or_default()
15062 };
15063 let workflow_by_id: std::collections::HashMap<i64, String> = workflows
15064 .into_iter()
15065 .filter_map(|w| w.id.get().copied().map(|id| (id, w.name)))
15066 .collect();
15067 let page_by_id: std::collections::HashMap<i64, &Page> = pages
15068 .iter()
15069 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
15070 .collect();
15071 let user_by_id: std::collections::HashMap<i64, String> = users
15072 .into_iter()
15073 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
15074 .collect();
15075 let task_by_id: std::collections::HashMap<i64, String> = tasks
15076 .into_iter()
15077 .filter_map(|t| t.id.get().copied().map(|id| (id, t.name)))
15078 .collect();
15079 Ok(states
15080 .iter()
15081 .map(|s| {
15082 serde_json::json!({
15083 "id": s.id.get().copied(),
15084 "workflow_name": workflow_by_id.get(&s.workflow_id).cloned().unwrap_or_else(|| format!("workflow #{}", s.workflow_id)),
15085 "page_id": s.page_id,
15086 "page_title": page_by_id.get(&s.page_id).map(|p| p.title.clone()).unwrap_or_else(|| format!("page #{}", s.page_id)),
15087 "page_url_path": page_by_id.get(&s.page_id).map(|p| p.url_path.clone()).unwrap_or_default(),
15088 "status": s.status,
15089 "current_task_name": s.current_task_id.and_then(|tid| task_by_id.get(&tid).cloned()),
15090 "requested_by_username": user_by_id.get(&s.requested_by).cloned(),
15091 "requested_at": s.requested_at.get().copied(),
15092 "finished_at": s.finished_at,
15093 })
15094 })
15095 .collect())
15096}
15097
15098pub async fn workflows_report(
15099 State(state): State<super::AdminState>,
15100 tenant: Tenant,
15101 headers: HeaderMap,
15102 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15103) -> Result<Response, AdminError> {
15104 let rows = workflows_report_rows(tenant.pool())
15105 .await
15106 .unwrap_or_default();
15107 let mut ctx = Context::new();
15108 add_chrome(
15109 &mut ctx,
15110 &tenant,
15111 "reports-workflows",
15112 session_user.as_ref(),
15113 )
15114 .await;
15115 add_admin_theme(&mut ctx, tenant.pool()).await;
15116 ctx.insert("rows", &rows);
15117 render_with_csrf(
15118 &state,
15119 &headers,
15120 "rcms_admin/workflow_report.html",
15121 &mut ctx,
15122 )
15123}
15124
15125pub async fn revisions_report(
15133 State(state): State<super::AdminState>,
15134 tenant: Tenant,
15135 headers: HeaderMap,
15136 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15137) -> Result<Response, AdminError> {
15138 use rustango::sql::FetcherPool as _;
15139 let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
15140 let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
15141 .fetch(tenant.pool())
15142 .await
15143 .unwrap_or_default();
15144 let mut count_by_page: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
15145 for r in &revisions {
15146 *count_by_page.entry(r.page_id).or_default() += 1;
15147 }
15148 let mut rows: Vec<serde_json::Value> = pages
15149 .into_iter()
15150 .filter_map(|p| {
15151 let pid = p.id.get().copied()?;
15152 let count = count_by_page.get(&pid).copied().unwrap_or(0);
15153 if count == 0 {
15154 return None;
15155 }
15156 Some(serde_json::json!({
15157 "page_id": pid,
15158 "title": p.title,
15159 "url_path": p.url_path,
15160 "status": p.status,
15161 "revision_count": count,
15162 }))
15163 })
15164 .collect();
15165 rows.sort_by(|a, b| {
15166 let ac = a
15167 .get("revision_count")
15168 .and_then(|v| v.as_u64())
15169 .unwrap_or(0);
15170 let bc = b
15171 .get("revision_count")
15172 .and_then(|v| v.as_u64())
15173 .unwrap_or(0);
15174 bc.cmp(&ac)
15175 });
15176 let total_revisions = revisions.len();
15177 let mut ctx = Context::new();
15178 add_chrome(
15179 &mut ctx,
15180 &tenant,
15181 "reports-revisions",
15182 session_user.as_ref(),
15183 )
15184 .await;
15185 add_admin_theme(&mut ctx, tenant.pool()).await;
15186 ctx.insert("rows", &rows);
15187 ctx.insert("total_revisions", &total_revisions);
15188 ctx.insert("default_keep_latest", &crate::revision::DEFAULT_KEEP_LATEST);
15189 render_with_csrf(
15190 &state,
15191 &headers,
15192 "rcms_admin/revisions_report.html",
15193 &mut ctx,
15194 )
15195}
15196
15197#[derive(Debug, Deserialize)]
15199pub struct RevisionsPruneForm {
15200 #[serde(default)]
15201 pub keep_latest: Option<usize>,
15202 #[serde(default)]
15203 pub include_published: Option<String>,
15204}
15205
15206pub async fn revisions_report_prune(
15210 State(_state): State<super::AdminState>,
15211 tenant: Tenant,
15212 headers: HeaderMap,
15213 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
15214 Form(form): Form<RevisionsPruneForm>,
15215) -> Result<Response, AdminError> {
15216 let keep_latest = form
15217 .keep_latest
15218 .unwrap_or(crate::revision::DEFAULT_KEEP_LATEST)
15219 .max(1);
15220 let keep_published = form.include_published.as_deref() != Some("1");
15224 let (pages_scanned, rows_deleted) =
15225 crate::revision::prune_all_pages(tenant.pool(), keep_latest, keep_published)
15226 .await
15227 .unwrap_or((0, 0));
15228 let revisions = super::i18n::tr_plural(
15229 &headers,
15230 "{count} revision(s)",
15231 rows_deleted as i64,
15232 &[("count", &rows_deleted.to_string())],
15233 );
15234 let pages_ph = super::i18n::tr_plural(
15235 &headers,
15236 "{count} page(s)",
15237 pages_scanned as i64,
15238 &[("count", &pages_scanned.to_string())],
15239 );
15240 let kl = keep_latest.to_string();
15241 let kp = keep_published.to_string();
15242 redirect_named_with_message_args(
15243 "rcms-admin:reports:revisions",
15244 MsgLevel::Success,
15245 "Pruned {revisions} across {pages} (keep_latest={keep_latest}, keep_published={keep_published}).",
15246 &[
15247 ("revisions", revisions.as_str()),
15248 ("pages", pages_ph.as_str()),
15249 ("keep_latest", kl.as_str()),
15250 ("keep_published", kp.as_str()),
15251 ],
15252 &headers,
15253 )
15254}
15255
15256pub async fn workflows_report_csv(
15257 State(_state): State<super::AdminState>,
15258 tenant: Tenant,
15259 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
15260) -> Result<Response, AdminError> {
15261 let rows = workflows_report_rows(tenant.pool())
15262 .await
15263 .unwrap_or_default();
15264 let mut out = String::with_capacity(256 + rows.len() * 192);
15265 out.push_str("workflow,page_id,page_title,page_url,status,current_task,requested_by,requested_at,finished_at\n");
15266 for r in &rows {
15267 out.push_str(&format!(
15268 "{},{},{},{},{},{},{},{},{}\n",
15269 csv_escape(
15270 r.get("workflow_name")
15271 .and_then(|v| v.as_str())
15272 .unwrap_or_default()
15273 ),
15274 r.get("page_id")
15275 .and_then(|v| v.as_i64())
15276 .unwrap_or_default(),
15277 csv_escape(
15278 r.get("page_title")
15279 .and_then(|v| v.as_str())
15280 .unwrap_or_default()
15281 ),
15282 csv_escape(
15283 r.get("page_url_path")
15284 .and_then(|v| v.as_str())
15285 .unwrap_or_default()
15286 ),
15287 csv_escape(r.get("status").and_then(|v| v.as_str()).unwrap_or_default()),
15288 csv_escape(
15289 r.get("current_task_name")
15290 .and_then(|v| v.as_str())
15291 .unwrap_or_default()
15292 ),
15293 csv_escape(
15294 r.get("requested_by_username")
15295 .and_then(|v| v.as_str())
15296 .unwrap_or_default()
15297 ),
15298 csv_escape(
15299 r.get("requested_at")
15300 .and_then(|v| v.as_str())
15301 .unwrap_or_default()
15302 ),
15303 csv_escape(
15304 r.get("finished_at")
15305 .and_then(|v| v.as_str())
15306 .unwrap_or_default()
15307 ),
15308 ));
15309 }
15310 Ok(csv_response("workflow-report", &out))
15311}
15312
15313#[derive(Debug, Deserialize)]
15321pub struct AdminSearchQuery {
15322 #[serde(default)]
15323 pub q: Option<String>,
15324 #[serde(default)]
15325 pub autocomplete: Option<String>,
15326}
15327
15328#[derive(Debug, Deserialize)]
15330pub struct PageChooserQuery {
15331 #[serde(default)]
15332 pub q: Option<String>,
15333}
15334
15335#[derive(Debug, Default, Deserialize)]
15337pub struct ChooserSearchQuery {
15338 #[serde(default)]
15339 pub q: Option<String>,
15340}
15341
15342pub async fn chooser_search_json(
15347 State(_state): State<super::AdminState>,
15348 tenant: Tenant,
15349 Path(slug): Path<String>,
15350 Query(q): Query<ChooserSearchQuery>,
15351) -> Result<Response, AdminError> {
15352 let Some(cvs) = super::chooser::find(&slug) else {
15353 return Ok((axum::http::StatusCode::NOT_FOUND, "unknown chooser").into_response());
15354 };
15355 let items = (cvs.search_rows)(tenant.pool().clone(), q.q.unwrap_or_default()).await;
15356 let body = serde_json::json!({ "items": items });
15357 Ok((
15358 [(header::CONTENT_TYPE, "application/json")],
15359 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15360 )
15361 .into_response())
15362}
15363
15364#[derive(Debug, Default, Deserialize)]
15366pub struct MediaPickerQuery {
15367 #[serde(default)]
15368 pub q: Option<String>,
15369 #[serde(default)]
15372 pub collection: Option<i64>,
15373 #[serde(default)]
15375 pub kind: Option<String>,
15376 #[serde(default)]
15380 pub ids: Option<String>,
15381 #[serde(default)]
15382 pub limit: Option<usize>,
15383 #[serde(default)]
15384 pub offset: Option<usize>,
15385}
15386
15387pub async fn media_picker_json(
15398 State(_state): State<super::AdminState>,
15399 tenant: Tenant,
15400 Query(q): Query<MediaPickerQuery>,
15401) -> Result<Response, AdminError> {
15402 let body = media_picker_payload(tenant.pool(), &q).await?;
15403 Ok((
15404 [(header::CONTENT_TYPE, "application/json")],
15405 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15406 )
15407 .into_response())
15408}
15409
15410pub(crate) async fn media_picker_payload(
15414 pool: &rustango::sql::Pool,
15415 q: &MediaPickerQuery,
15416) -> Result<serde_json::Value, AdminError> {
15417 let mut rows: Vec<Media> = Media::objects()
15418 .order_by(&[("uploaded_at", true)])
15419 .fetch(pool)
15420 .await?;
15421
15422 let id_set: Option<std::collections::HashSet<i64>> = q.ids.as_deref().map(|s| {
15425 s.split(',')
15426 .filter_map(|t| t.trim().parse::<i64>().ok())
15427 .collect()
15428 });
15429 if let Some(ids) = &id_set {
15430 rows.retain(|m| m.id.get().copied().is_some_and(|id| ids.contains(&id)));
15431 }
15432 let kind = q
15435 .kind
15436 .as_deref()
15437 .unwrap_or(if id_set.is_some() { "any" } else { "image" });
15438 if kind != "any" {
15439 rows.retain(|m| m.kind == kind);
15440 }
15441 let mut collection_counts: std::collections::HashMap<i64, i64> =
15445 std::collections::HashMap::new();
15446 let mut uncategorized_count: i64 = 0;
15447 for m in &rows {
15448 match m.collection_id {
15449 Some(cid) => *collection_counts.entry(cid).or_default() += 1,
15450 None => uncategorized_count += 1,
15451 }
15452 }
15453 match q.collection {
15454 Some(0) => rows.retain(|m| m.collection_id.is_none()),
15455 Some(cid) => rows.retain(|m| m.collection_id == Some(cid)),
15456 None => {}
15457 }
15458 if let Some(needle) = q.q.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
15459 let needle = needle.to_lowercase();
15460 rows.retain(|m| {
15461 m.title.to_lowercase().contains(&needle)
15462 || m.filename.to_lowercase().contains(&needle)
15463 || m.alt_text.to_lowercase().contains(&needle)
15464 || m.description.to_lowercase().contains(&needle)
15465 });
15466 }
15467
15468 let total = rows.len();
15469 let limit = q.limit.unwrap_or(60).min(200);
15470 let offset = q.offset.unwrap_or(0).min(total);
15471 let has_more = offset + limit < total;
15472 let page: Vec<serde_json::Value> = rows[offset..(offset + limit).min(total)]
15473 .iter()
15474 .map(|m| {
15475 let id = m.id.get().copied().unwrap_or_default();
15476 let is_image = m.kind == "image";
15477 let thumb_url = is_image
15478 .then(|| {
15479 crate::rendition::rendition_url_for(
15480 id,
15481 "fill-320x320|format-webp|quality-70",
15482 Some(m.content_hash.as_str()),
15483 )
15484 })
15485 .flatten();
15486 let preview_url = is_image
15487 .then(|| {
15488 crate::rendition::rendition_url_for(
15489 id,
15490 "max-640x480|format-webp|quality-80",
15491 Some(m.content_hash.as_str()),
15492 )
15493 })
15494 .flatten();
15495 serde_json::json!({
15496 "id": id,
15497 "title": if m.title.is_empty() { m.filename.clone() } else { m.title.clone() },
15498 "filename": m.filename,
15499 "kind": m.kind,
15500 "mime": m.mime,
15501 "size": m.size,
15502 "width": m.width,
15503 "height": m.height,
15504 "collection_id": m.collection_id,
15505 "alt_text": m.alt_text,
15506 "uploaded_at": m.uploaded_at,
15507 "thumb_url": thumb_url,
15508 "preview_url": preview_url,
15509 })
15510 })
15511 .collect();
15512
15513 let cols: Vec<crate::media::MediaCollection> =
15517 crate::media::MediaCollection::objects().fetch(pool).await?;
15518 let mut children: std::collections::HashMap<Option<i64>, Vec<&crate::media::MediaCollection>> =
15519 std::collections::HashMap::new();
15520 for c in &cols {
15521 children.entry(c.parent_id).or_default().push(c);
15522 }
15523 for v in children.values_mut() {
15524 v.sort_by(|a, b| a.sort_order.cmp(&b.sort_order).then(a.name.cmp(&b.name)));
15525 }
15526 let mut ordered: Vec<serde_json::Value> = Vec::with_capacity(cols.len());
15527 let mut visited: std::collections::HashSet<i64> = std::collections::HashSet::new();
15528 let mut stack: Vec<(i64, usize)> = children
15529 .get(&None)
15530 .map(|roots| {
15531 roots
15532 .iter()
15533 .rev()
15534 .filter_map(|c| c.id.get().copied())
15535 .map(|id| (id, 0))
15536 .collect()
15537 })
15538 .unwrap_or_default();
15539 let by_id: std::collections::HashMap<i64, &crate::media::MediaCollection> = cols
15540 .iter()
15541 .filter_map(|c| c.id.get().copied().map(|id| (id, c)))
15542 .collect();
15543 while let Some((id, depth)) = stack.pop() {
15544 if !visited.insert(id) {
15545 continue;
15546 }
15547 if let Some(c) = by_id.get(&id) {
15548 ordered.push(serde_json::json!({
15549 "id": id,
15550 "name": c.name,
15551 "depth": depth,
15552 "count": collection_counts.get(&id).copied().unwrap_or(0),
15553 }));
15554 if let Some(kids) = children.get(&Some(id)) {
15555 for k in kids.iter().rev() {
15556 if let Some(kid) = k.id.get().copied() {
15557 stack.push((kid, depth + 1));
15558 }
15559 }
15560 }
15561 }
15562 }
15563
15564 Ok(serde_json::json!({
15565 "items": page,
15566 "collections": ordered,
15567 "uncategorized_count": uncategorized_count,
15568 "total": total,
15569 "has_more": has_more,
15570 }))
15571}
15572
15573pub async fn page_chooser_json(
15579 State(_state): State<super::AdminState>,
15580 tenant: Tenant,
15581 Query(q): Query<PageChooserQuery>,
15582) -> Result<Response, AdminError> {
15583 let needle =
15584 q.q.as_deref()
15585 .map(str::trim)
15586 .filter(|s| !s.is_empty())
15587 .map(str::to_lowercase);
15588
15589 let mut pages: Vec<Page> = Page::objects()
15590 .order_by(&[("updated_at", true)])
15591 .fetch(tenant.pool())
15592 .await
15593 .unwrap_or_default();
15594
15595 if let Some(n) = needle.as_ref() {
15596 pages.retain(|p| {
15597 p.title.to_lowercase().contains(n)
15598 || p.slug.to_lowercase().contains(n)
15599 || p.url_path.to_lowercase().contains(n)
15600 });
15601 }
15602
15603 let items: Vec<serde_json::Value> = pages
15604 .iter()
15605 .take(50)
15606 .map(|p| {
15607 serde_json::json!({
15608 "id": p.id.get().copied(),
15609 "title": p.title,
15610 "slug": p.slug,
15611 "url_path": p.url_path,
15612 "depth": p.depth,
15613 "parent_id": p.parent_id,
15614 "status": p.status,
15615 })
15616 })
15617 .collect();
15618
15619 let body = serde_json::json!({ "items": items });
15620 Ok((
15621 [(header::CONTENT_TYPE, "application/json")],
15622 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15623 )
15624 .into_response())
15625}
15626
15627#[derive(Debug, Deserialize)]
15631pub struct SnippetChooserQuery {
15632 #[serde(default)]
15633 pub q: Option<String>,
15634 #[serde(default)]
15635 pub type_name: Option<String>,
15636 #[serde(default)]
15640 pub ids: Option<String>,
15641}
15642
15643pub async fn snippet_chooser_json(
15648 State(_state): State<super::AdminState>,
15649 tenant: Tenant,
15650 Query(q): Query<SnippetChooserQuery>,
15651) -> Result<Response, AdminError> {
15652 let needle =
15653 q.q.as_deref()
15654 .map(str::trim)
15655 .filter(|s| !s.is_empty())
15656 .map(str::to_lowercase);
15657 let type_filter = q
15658 .type_name
15659 .as_deref()
15660 .map(str::trim)
15661 .filter(|s| !s.is_empty())
15662 .map(str::to_owned);
15663
15664 let mut snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
15665 .order_by(&[("updated_at", true)])
15666 .fetch(tenant.pool())
15667 .await
15668 .unwrap_or_default();
15669
15670 if let Some(ids) = q.ids.as_deref() {
15671 let id_set: std::collections::HashSet<i64> = ids
15672 .split(',')
15673 .filter_map(|t| t.trim().parse::<i64>().ok())
15674 .collect();
15675 snippets.retain(|s| s.id.get().copied().is_some_and(|id| id_set.contains(&id)));
15676 }
15677 if let Some(tn) = type_filter.as_ref() {
15678 snippets.retain(|s| &s.type_name == tn);
15679 }
15680 if let Some(n) = needle.as_ref() {
15681 snippets
15682 .retain(|s| s.title.to_lowercase().contains(n) || s.slug.to_lowercase().contains(n));
15683 }
15684
15685 let items: Vec<serde_json::Value> = snippets
15686 .iter()
15687 .take(50)
15688 .map(|s| {
15689 serde_json::json!({
15690 "id": s.id.get().copied(),
15691 "title": s.title,
15692 "slug": s.slug,
15693 "type_name": s.type_name,
15694 })
15695 })
15696 .collect();
15697
15698 let body = serde_json::json!({ "items": items });
15699 Ok((
15700 [(header::CONTENT_TYPE, "application/json")],
15701 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15702 )
15703 .into_response())
15704}
15705
15706#[derive(Debug, Deserialize)]
15708pub struct DocumentChooserQuery {
15709 #[serde(default)]
15710 pub q: Option<String>,
15711}
15712
15713pub async fn document_chooser_json(
15718 State(_state): State<super::AdminState>,
15719 tenant: Tenant,
15720 Query(q): Query<DocumentChooserQuery>,
15721) -> Result<Response, AdminError> {
15722 let needle =
15723 q.q.as_deref()
15724 .map(str::trim)
15725 .filter(|s| !s.is_empty())
15726 .map(str::to_lowercase);
15727
15728 let mut rows: Vec<Media> = Media::objects()
15729 .where_(Media::kind.eq("document".to_owned()))
15730 .order_by(&[("uploaded_at", true)])
15731 .fetch(tenant.pool())
15732 .await
15733 .unwrap_or_default();
15734
15735 if let Some(n) = needle.as_ref() {
15736 rows.retain(|m| {
15737 m.title.to_lowercase().contains(n) || m.filename.to_lowercase().contains(n)
15738 });
15739 }
15740
15741 let items: Vec<serde_json::Value> = rows
15742 .iter()
15743 .take(50)
15744 .map(|m| {
15745 serde_json::json!({
15746 "id": m.id.get().copied(),
15747 "title": m.title,
15748 "filename": m.filename,
15749 "kind": m.kind,
15750 "mime": m.mime,
15751 })
15752 })
15753 .collect();
15754
15755 let body = serde_json::json!({ "items": items });
15756 Ok((
15757 [(header::CONTENT_TYPE, "application/json")],
15758 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15759 )
15760 .into_response())
15761}
15762
15763pub async fn admin_search(
15768 State(state): State<super::AdminState>,
15769 tenant: Tenant,
15770 headers: HeaderMap,
15771 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15772 Query(q): Query<AdminSearchQuery>,
15773) -> Result<Response, AdminError> {
15774 let needle =
15775 q.q.as_deref()
15776 .map(str::trim)
15777 .filter(|s| !s.is_empty())
15778 .map(str::to_lowercase);
15779 let autocomplete = q.autocomplete.as_deref() == Some("1");
15780
15781 if !autocomplete {
15785 if let Some(raw) = q.q.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
15786 if let Err(e) = crate::search_promotion::log_query(tenant.pool(), raw).await {
15787 tracing::debug!(
15788 target: "rustango_cms::search",
15789 error = %e,
15790 "search query log failed (best-effort)",
15791 );
15792 }
15793 }
15794 }
15795
15796 let mut pages_out: Vec<serde_json::Value> = Vec::new();
15797 let mut snippets_out: Vec<serde_json::Value> = Vec::new();
15798 let mut media_out: Vec<serde_json::Value> = Vec::new();
15799
15800 if let Some(needle) = needle.as_ref() {
15801 let all_pages: Vec<Page> = Page::objects()
15807 .order_by(&[("updated_at", true)])
15808 .fetch(tenant.pool())
15809 .await
15810 .unwrap_or_default();
15811 let page_types: Vec<PageType> = PageType::objects()
15812 .fetch(tenant.pool())
15813 .await
15814 .unwrap_or_default();
15815 let page_type_by_id: std::collections::HashMap<i64, String> = page_types
15816 .into_iter()
15817 .filter_map(|pt| pt.id.get().copied().map(|id| (id, pt.type_name)))
15818 .collect();
15819 let mut title_hits: Vec<serde_json::Value> = Vec::new();
15820 let mut body_hits: Vec<serde_json::Value> = Vec::new();
15821 for p in all_pages {
15822 if title_hits.len() + body_hits.len() >= 20 {
15823 break;
15824 }
15825 let title = p.title.to_lowercase();
15826 let slug = p.slug.to_lowercase();
15827 let url_path = p.url_path.to_lowercase();
15828 let primary_hit =
15829 title.contains(needle) || slug.contains(needle) || url_path.contains(needle);
15830
15831 let mut body_match = false;
15833 if !primary_hit {
15834 if p.seo_title.to_lowercase().contains(needle)
15835 || p.seo_description.to_lowercase().contains(needle)
15836 || p.og_title.to_lowercase().contains(needle)
15837 || p.og_description.to_lowercase().contains(needle)
15838 {
15839 body_match = true;
15840 }
15841 if !body_match {
15842 if let Some(type_name) = page_type_by_id.get(&p.page_type_id) {
15843 if let Some(handler) = crate::page_type::find_handler(type_name) {
15844 let page_id = p.id.get().copied().unwrap_or_default();
15845 if let Ok(ext) = handler.load_extension(tenant.pool(), page_id).await {
15846 body_match = json_contains_needle(&ext, needle);
15847 }
15848 }
15849 }
15850 }
15851 }
15852
15853 if primary_hit || body_match {
15854 let row = serde_json::json!({
15855 "id": p.id.get().copied(),
15856 "title": p.title,
15857 "slug": p.slug,
15858 "url_path": p.url_path,
15859 "status": p.status,
15860 });
15861 if primary_hit {
15862 title_hits.push(row);
15863 } else {
15864 body_hits.push(row);
15865 }
15866 }
15867 }
15868 pages_out.extend(title_hits);
15870 pages_out.extend(body_hits);
15871 if pages_out.len() > 20 {
15872 pages_out.truncate(20);
15873 }
15874
15875 let all_snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
15877 .order_by(&[("updated_at", true)])
15878 .fetch(tenant.pool())
15879 .await
15880 .unwrap_or_default();
15881 for s in all_snippets {
15882 if snippets_out.len() >= 20 {
15883 break;
15884 }
15885 let title = s.title.to_lowercase();
15886 let slug = s.slug.to_lowercase();
15887 if title.contains(needle) || slug.contains(needle) {
15888 snippets_out.push(serde_json::json!({
15889 "id": s.id.get().copied(),
15890 "title": s.title,
15891 "slug": s.slug,
15892 "type_name": s.type_name,
15893 }));
15894 }
15895 }
15896
15897 let all_media: Vec<crate::media::Media> = crate::media::Media::objects()
15899 .order_by(&[("created_at", true)])
15900 .fetch(tenant.pool())
15901 .await
15902 .unwrap_or_default();
15903 for m in all_media {
15904 if media_out.len() >= 20 {
15905 break;
15906 }
15907 let title = m.title.to_lowercase();
15908 let filename = m.filename.to_lowercase();
15909 let alt = m.alt_text.to_lowercase();
15910 if title.contains(needle) || filename.contains(needle) || alt.contains(needle) {
15911 media_out.push(serde_json::json!({
15912 "id": m.id.get().copied(),
15913 "title": m.title,
15914 "filename": m.filename,
15915 "alt_text": m.alt_text,
15916 "kind": m.kind,
15917 }));
15918 }
15919 }
15920 }
15921
15922 let plugin_areas: Vec<serde_json::Value> = if let Some(query) = q.q.as_deref() {
15926 let trimmed = query.trim();
15927 if trimmed.is_empty() {
15928 Vec::new()
15929 } else {
15930 crate::hooks::run_admin_search_areas(trimmed)
15931 .into_iter()
15932 .map(|(label, hits)| {
15933 serde_json::json!({
15934 "label": label,
15935 "hits": hits,
15936 })
15937 })
15938 .collect()
15939 }
15940 } else {
15941 Vec::new()
15942 };
15943
15944 if autocomplete {
15945 let payload = serde_json::json!({
15947 "q": q.q,
15948 "pages": pages_out.iter().take(5).collect::<Vec<_>>(),
15949 "snippets": snippets_out.iter().take(5).collect::<Vec<_>>(),
15950 "media": media_out.iter().take(5).collect::<Vec<_>>(),
15951 "plugin_areas": plugin_areas,
15952 });
15953 return Ok((
15954 [(header::CONTENT_TYPE, "application/json")],
15955 serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
15956 )
15957 .into_response());
15958 }
15959
15960 let mut ctx = Context::new();
15961 add_chrome(&mut ctx, &tenant, "search", session_user.as_ref()).await;
15962 add_admin_theme(&mut ctx, tenant.pool()).await;
15963 ctx.insert("query", &q.q.unwrap_or_default());
15964 ctx.insert("pages", &pages_out);
15965 ctx.insert("snippets", &snippets_out);
15966 ctx.insert("media", &media_out);
15967 let plugin_hit_count: usize = plugin_areas
15968 .iter()
15969 .filter_map(|a| a.get("hits").and_then(|h| h.as_array()).map(Vec::len))
15970 .sum();
15971 ctx.insert("plugin_search_areas", &plugin_areas);
15972 ctx.insert(
15973 "total_hits",
15974 &(pages_out.len() + snippets_out.len() + media_out.len() + plugin_hit_count),
15975 );
15976 render_with_csrf(&state, &headers, "rcms_admin/admin_search.html", &mut ctx)
15977}
15978
15979pub async fn navigation_list(
15985 State(state): State<super::AdminState>,
15986 tenant: Tenant,
15987 headers: HeaderMap,
15988 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15989) -> Result<Response, AdminError> {
15990 let menus: Vec<crate::navigation::Menu> = crate::navigation::Menu::objects()
15991 .order_by(&[("name", false)])
15992 .fetch(tenant.pool())
15993 .await?;
15994 let all_items: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
15996 .fetch(tenant.pool())
15997 .await?;
15998 let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
15999 for it in &all_items {
16000 *counts.entry(it.menu_id).or_insert(0) += 1;
16001 }
16002 let rows: Vec<serde_json::Value> = menus
16003 .iter()
16004 .map(|m| {
16005 let id = m.id.get().copied().unwrap_or_default();
16006 serde_json::json!({
16007 "id": id,
16008 "slug": m.slug,
16009 "name": m.name,
16010 "item_count": counts.get(&id).copied().unwrap_or(0),
16011 "created_at": m.created_at.get().copied(),
16012 })
16013 })
16014 .collect();
16015
16016 let mut ctx = Context::new();
16017 add_chrome(&mut ctx, &tenant, "navigation", session_user.as_ref()).await;
16018 add_admin_theme(&mut ctx, tenant.pool()).await;
16019 ctx.insert("menus", &rows);
16020 render_with_csrf(
16021 &state,
16022 &headers,
16023 "rcms_admin/navigation_list.html",
16024 &mut ctx,
16025 )
16026}
16027
16028#[derive(Debug, Deserialize)]
16030pub struct MenuForm {
16031 pub slug: String,
16032 pub name: String,
16033}
16034
16035pub async fn navigation_create_submit(
16037 State(_state): State<super::AdminState>,
16038 tenant: Tenant,
16039 headers: HeaderMap,
16040 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16041 Form(form): Form<MenuForm>,
16042) -> Result<Response, AdminError> {
16043 let slug = form.slug.trim().to_lowercase();
16044 let name = form.name.trim().to_owned();
16045 if slug.is_empty() || name.is_empty() {
16046 return redirect_named_with_message(
16047 "rcms-admin:navigation:list",
16048 MsgLevel::Warning,
16049 "Menu slug + name are both required.",
16050 &headers,
16051 );
16052 }
16053 let mut row = crate::navigation::Menu {
16054 id: rustango::sql::Auto::Unset,
16055 slug: slug.clone(),
16056 name,
16057 created_at: rustango::sql::Auto::Unset,
16058 };
16059 row.insert_pool(tenant.pool()).await?;
16060 redirect_named_with_message_args(
16061 "rcms-admin:navigation:list",
16062 MsgLevel::Success,
16063 "Menu “{slug}” created.",
16064 &[("slug", slug.as_str())],
16065 &headers,
16066 )
16067}
16068
16069pub async fn navigation_delete_submit(
16072 State(_state): State<super::AdminState>,
16073 tenant: Tenant,
16074 headers: HeaderMap,
16075 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16076 Path(id): Path<i64>,
16077) -> Result<Response, AdminError> {
16078 let menu = crate::navigation::Menu::objects()
16079 .where_(crate::navigation::Menu::id.eq(id))
16080 .first(tenant.pool())
16081 .await?
16082 .ok_or(AdminError::NotFound(id))?;
16083 let items: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16088 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16089 .fetch(tenant.pool())
16090 .await?;
16091 rustango::atomic!(tenant.pool(), |tx| {
16092 let mut guard = tx.lock().await?;
16093 let tx = &mut *guard;
16094 delete_menu_items_tx(tx, items).await?;
16095 menu.delete_tx(tx).await?;
16096 Ok::<_, rustango::sql::ExecError>(())
16097 })
16098 .await?;
16099 redirect_named_with_message(
16100 "rcms-admin:navigation:list",
16101 MsgLevel::Success,
16102 "Menu deleted.",
16103 &headers,
16104 )
16105}
16106
16107pub async fn navigation_clone_submit(
16114 State(_state): State<super::AdminState>,
16115 tenant: Tenant,
16116 headers: HeaderMap,
16117 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16118 Path(id): Path<i64>,
16119) -> Result<Response, AdminError> {
16120 let source = crate::navigation::Menu::objects()
16121 .where_(crate::navigation::Menu::id.eq(id))
16122 .first(tenant.pool())
16123 .await?
16124 .ok_or(AdminError::NotFound(id))?;
16125
16126 let base = source.slug.trim_matches('-').to_owned();
16128 let desired = format!("{base}-copy");
16129 let existing_slugs: std::collections::HashSet<String> = crate::navigation::Menu::objects()
16130 .fetch(tenant.pool())
16131 .await?
16132 .into_iter()
16133 .map(|m| m.slug)
16134 .collect();
16135 let slug = if !existing_slugs.contains(&desired) {
16136 desired
16137 } else {
16138 let mut chosen = None;
16139 for n in 2..=100 {
16140 let candidate = format!("{desired}-{n}");
16141 if !existing_slugs.contains(&candidate) {
16142 chosen = Some(candidate);
16143 break;
16144 }
16145 }
16146 chosen.ok_or_else(|| {
16147 AdminError::Validation(
16148 "Could not allocate a unique slug for the cloned menu.".to_owned(),
16149 )
16150 })?
16151 };
16152
16153 let mut clone_menu = crate::navigation::Menu {
16154 id: rustango::sql::Auto::Unset,
16155 slug,
16156 name: format!("{} (copy)", source.name),
16157 created_at: rustango::sql::Auto::Unset,
16158 };
16159 let items = crate::navigation::order_pre_order(
16169 crate::navigation::MenuItem::objects()
16170 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16171 .order_by(&[("sort_order", false), ("id", false)])
16172 .fetch(tenant.pool())
16173 .await?,
16174 );
16175 let count = items.len().to_string();
16176
16177 let new_menu_id = rustango::atomic!(tenant.pool(), |tx| {
16180 let mut guard = tx.lock().await?;
16181 let tx = &mut *guard;
16182 clone_menu.save_tx(tx).await?;
16183 let new_menu_id = clone_menu.id.get().copied().unwrap_or_default();
16184
16185 let mut id_map: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
16186 for item in &items {
16187 let old_id = item.id.get().copied().unwrap_or_default();
16188 let new_parent = item.parent_id.and_then(|p| id_map.get(&p).copied());
16194 let mut clone_item = crate::navigation::MenuItem {
16195 id: rustango::sql::Auto::Unset,
16196 menu_id: new_menu_id,
16197 parent_id: new_parent,
16198 sort_order: item.sort_order,
16199 label: item.label.clone(),
16200 page_id: item.page_id,
16201 external_url: item.external_url.clone(),
16202 open_in_new_tab: item.open_in_new_tab,
16203 };
16204 clone_item.save_tx(tx).await?;
16205 id_map.insert(old_id, clone_item.id.get().copied().unwrap_or_default());
16206 }
16207 Ok::<_, rustango::sql::ExecError>(new_menu_id)
16208 })
16209 .await?;
16210
16211 redirect_named_with_params_and_message_args(
16212 "rcms-admin:navigation:edit",
16213 &[("id", new_menu_id.to_string())],
16214 MsgLevel::Success,
16215 "Cloned “{name}” with {count} items.",
16216 &[("name", source.name.as_str()), ("count", count.as_str())],
16217 &headers,
16218 )
16219}
16220
16221pub async fn navigation_seed_from_pages_submit(
16235 State(_state): State<super::AdminState>,
16236 tenant: Tenant,
16237 headers: HeaderMap,
16238 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16239 Path(id): Path<i64>,
16240) -> Result<Response, AdminError> {
16241 use rustango::core::Column as _;
16242 use rustango::sql::FetcherPool as _;
16243
16244 let menu = crate::navigation::Menu::objects()
16245 .where_(crate::navigation::Menu::id.eq(id))
16246 .first(tenant.pool())
16247 .await?
16248 .ok_or(AdminError::NotFound(id))?;
16249
16250 let existing: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16256 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16257 .fetch(tenant.pool())
16258 .await?;
16259
16260 let mut pages: Vec<crate::page::Page> = crate::page::Page::objects()
16265 .where_(crate::page::Page::show_in_menus.eq(true))
16266 .where_(crate::page::Page::status.eq("published".to_owned()))
16267 .order_by(&[("path", false), ("id", false)])
16268 .fetch(tenant.pool())
16269 .await?;
16270 let error_tid = crate::error_pages::error_page_type_id(tenant.pool()).await;
16274 pages.retain(|p| error_tid.is_none_or(|tid| p.page_type_id != tid));
16275
16276 let mut page_to_item: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
16281 let mut sibling_counter: std::collections::HashMap<Option<i64>, i32> =
16282 std::collections::HashMap::new();
16283 let inserted = pages.len();
16287 rustango::atomic!(tenant.pool(), |tx| {
16288 let mut guard = tx.lock().await?;
16289 let tx = &mut *guard;
16290 delete_menu_items_tx(tx, existing).await?;
16291 for page in &pages {
16292 let page_id = page.id.get().copied().unwrap_or_default();
16293 let parent_menu_item_id: Option<i64> = page
16294 .parent_id
16295 .and_then(|pid| page_to_item.get(&pid).copied());
16296 let bucket = parent_menu_item_id;
16300 let sort_order = *sibling_counter
16301 .entry(bucket)
16302 .and_modify(|n| *n += 1)
16303 .or_insert(0);
16304 let mut item = crate::navigation::MenuItem {
16305 id: rustango::sql::Auto::Unset,
16306 menu_id: id,
16307 parent_id: parent_menu_item_id,
16308 sort_order,
16309 label: page.title.clone(),
16310 page_id: Some(page_id),
16311 external_url: None,
16312 open_in_new_tab: false,
16313 };
16314 item.save_tx(tx).await?;
16315 let new_item_id = item.id.get().copied().unwrap_or_default();
16316 page_to_item.insert(page_id, new_item_id);
16317 }
16318 Ok::<_, rustango::sql::ExecError>(())
16319 })
16320 .await?;
16321
16322 redirect_named_with_params_and_message_plural(
16323 "rcms-admin:navigation:edit",
16324 &[("id", id.to_string())],
16325 MsgLevel::Success,
16326 "Seeded “{name}” with {count} item(s) from pages marked Show in menus.",
16327 inserted as i64,
16328 &[
16329 ("name", menu.name.as_str()),
16330 ("count", &inserted.to_string()),
16331 ],
16332 &headers,
16333 )
16334}
16335
16336async fn delete_menu_items_tx(
16345 tx: &mut rustango::sql::PoolTx<'_>,
16346 items: Vec<crate::navigation::MenuItem>,
16347) -> Result<(), rustango::sql::ExecError> {
16348 use crate::menu_item_translation::MenuItemTranslation;
16349 if items.is_empty() {
16350 return Ok(());
16351 }
16352 let ids: Vec<i64> = items.iter().filter_map(|it| it.id.get().copied()).collect();
16353 if !ids.is_empty() {
16354 let orphans: Vec<MenuItemTranslation> = MenuItemTranslation::objects()
16355 .where_(MenuItemTranslation::item_id.is_in(ids))
16356 .fetch_tx(tx)
16357 .await?;
16358 for row in orphans {
16359 row.delete_tx(tx).await?;
16360 }
16361 }
16362 for it in crate::navigation::order_deepest_first(items) {
16363 it.delete_tx(tx).await?;
16364 }
16365 Ok(())
16366}
16367
16368#[derive(Debug, Deserialize)]
16389pub struct SaveTreeItem {
16390 #[serde(default)]
16395 pub id: Option<i64>,
16396 pub local_id: i32,
16398 #[serde(default)]
16400 pub parent_local_id: Option<i32>,
16401 pub label: String,
16402 #[serde(default)]
16403 pub page_id: Option<i64>,
16404 #[serde(default)]
16405 pub external_url: Option<String>,
16406 #[serde(default)]
16407 pub open_in_new_tab: bool,
16408}
16409
16410#[derive(Debug, Deserialize)]
16411pub struct SaveTreePayload {
16412 pub items: Vec<SaveTreeItem>,
16413}
16414
16415pub async fn navigation_save_tree_submit(
16416 State(_state): State<super::AdminState>,
16417 tenant: Tenant,
16418 Path(id): Path<i64>,
16419 axum::Json(payload): axum::Json<SaveTreePayload>,
16420) -> Result<Response, AdminError> {
16421 for (i, item) in payload.items.iter().enumerate() {
16424 if item.local_id as usize != i {
16425 return Err(AdminError::Validation(format!(
16426 "items[{i}].local_id must equal its array index"
16427 )));
16428 }
16429 if let Some(p) = item.parent_local_id {
16430 if (p as usize) >= i {
16431 return Err(AdminError::Validation(format!(
16432 "items[{i}].parent_local_id {p} must reference an earlier item"
16433 )));
16434 }
16435 }
16436 }
16437
16438 for (i, item) in payload.items.iter().enumerate() {
16446 let external = item
16447 .external_url
16448 .as_deref()
16449 .map(str::trim)
16450 .filter(|s| !s.is_empty());
16451 match (item.page_id, external) {
16452 (Some(_), Some(_)) => {
16453 return Err(AdminError::Validation(format!(
16454 "items[{i}] sets both a page and an external URL — pick one"
16455 )))
16456 }
16457 (None, None) => {
16458 return Err(AdminError::Validation(format!(
16459 "items[{i}] has no link target — set a page or an external URL"
16460 )))
16461 }
16462 _ => {}
16463 }
16464 if item.label.chars().count() > 200 {
16465 return Err(AdminError::Validation(format!(
16466 "items[{i}].label is too long (max 200 characters)"
16467 )));
16468 }
16469 if external.is_some_and(|u| u.chars().count() > 500) {
16470 return Err(AdminError::Validation(format!(
16471 "items[{i}].external_url is too long (max 500 characters)"
16472 )));
16473 }
16474 }
16475
16476 let mut seen: std::collections::HashSet<i64> = std::collections::HashSet::new();
16480 for (i, item) in payload.items.iter().enumerate() {
16481 if let Some(iid) = item.id {
16482 if !seen.insert(iid) {
16483 return Err(AdminError::Validation(format!(
16484 "items[{i}].id {iid} appears more than once"
16485 )));
16486 }
16487 }
16488 }
16489
16490 if crate::navigation::Menu::objects()
16495 .where_(crate::navigation::Menu::id.eq(id))
16496 .first(tenant.pool())
16497 .await?
16498 .is_none()
16499 {
16500 return Err(AdminError::NotFound(id));
16501 }
16502
16503 let existing: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16504 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16505 .fetch(tenant.pool())
16506 .await?;
16507 let mut existing_by_id: std::collections::HashMap<i64, crate::navigation::MenuItem> = existing
16508 .into_iter()
16509 .filter_map(|it| it.id.get().copied().map(|iid| (iid, it)))
16510 .collect();
16511
16512 let plan: Vec<Option<crate::navigation::MenuItem>> = payload
16518 .items
16519 .iter()
16520 .map(|it| it.id.and_then(|iid| existing_by_id.remove(&iid)))
16521 .collect();
16522
16523 let items_saved = payload.items.len();
16524 rustango::atomic!(tenant.pool(), |tx| {
16525 let mut guard = tx.lock().await?;
16526 let tx = &mut *guard;
16527 let mut resolved: Vec<i64> = Vec::with_capacity(payload.items.len());
16534 for ((i, item), claimed) in payload.items.iter().enumerate().zip(plan) {
16535 let parent_id = item.parent_local_id.map(|p| resolved[p as usize]);
16536 let external_url = item
16537 .external_url
16538 .as_ref()
16539 .filter(|s| !s.trim().is_empty())
16540 .cloned();
16541 let sort_order = (i as i32) * 10;
16542
16543 let new_id = match claimed {
16544 Some(mut row) => {
16545 let iid = row.id.get().copied().unwrap_or_default();
16548 row.parent_id = parent_id;
16549 row.sort_order = sort_order;
16550 row.label = item.label.clone();
16551 row.page_id = item.page_id;
16552 row.external_url = external_url;
16553 row.open_in_new_tab = item.open_in_new_tab;
16554 row.save_tx(tx).await?;
16555 iid
16556 }
16557 None => {
16558 let mut row = crate::navigation::MenuItem {
16559 id: rustango::sql::Auto::Unset,
16560 menu_id: id,
16561 parent_id,
16562 sort_order,
16563 label: item.label.clone(),
16564 page_id: item.page_id,
16565 external_url,
16566 open_in_new_tab: item.open_in_new_tab,
16567 };
16568 row.save_tx(tx).await?;
16569 row.id.get().copied().unwrap_or_default()
16570 }
16571 };
16572 resolved.push(new_id);
16573 }
16574
16575 delete_menu_items_tx(tx, existing_by_id.into_values().collect()).await?;
16581 Ok::<_, rustango::sql::ExecError>(())
16582 })
16583 .await?;
16584
16585 Ok(axum::Json(serde_json::json!({
16586 "ok": true,
16587 "items_saved": items_saved,
16588 }))
16589 .into_response())
16590}
16591
16592pub async fn navigation_edit_form(
16594 State(state): State<super::AdminState>,
16595 tenant: Tenant,
16596 headers: HeaderMap,
16597 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
16598 Path(id): Path<i64>,
16599 Query(q): Query<EditQuery>,
16600) -> Result<Response, AdminError> {
16601 let menu = crate::navigation::Menu::objects()
16602 .where_(crate::navigation::Menu::id.eq(id))
16603 .first(tenant.pool())
16604 .await?
16605 .ok_or(AdminError::NotFound(id))?;
16606 let items = crate::navigation::order_pre_order(
16611 crate::navigation::MenuItem::objects()
16612 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16613 .order_by(&[("sort_order", false), ("id", false)])
16614 .fetch(tenant.pool())
16615 .await?,
16616 );
16617 let suggested: Vec<Page> = Page::objects()
16621 .where_(Page::show_in_menus.eq(true))
16622 .order_by(&[("title", false)])
16623 .fetch(tenant.pool())
16624 .await?;
16625 let all_pages: Vec<Page> = Page::objects()
16630 .order_by(&[("title", false)])
16631 .fetch(tenant.pool())
16632 .await?;
16633
16634 let by_page_id: std::collections::HashMap<i64, &Page> = all_pages
16637 .iter()
16638 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
16639 .collect();
16640 let locales: Vec<Locale> = Locale::objects()
16646 .where_(Locale::active.eq(true))
16647 .order_by(&[("is_default", true), ("code", false)])
16648 .fetch(tenant.pool())
16649 .await?;
16650 let editing_locale: Option<Locale> = match q.locale.as_deref().filter(|c| !c.is_empty()) {
16651 Some(code) => locales.iter().find(|l| l.code == code).cloned(),
16652 None => None,
16653 };
16654 let translation_mode = editing_locale.as_ref().is_some_and(|l| !l.is_default);
16655 let item_translations = match editing_locale.as_ref().filter(|l| !l.is_default) {
16656 Some(loc) => {
16657 let lid = loc.id.get().copied().unwrap_or_default();
16658 let ids: Vec<i64> = items.iter().filter_map(|it| it.id.get().copied()).collect();
16659 crate::menu_item_translation::fetch_for_items(tenant.pool(), &ids, lid).await?
16660 }
16661 None => std::collections::HashMap::new(),
16662 };
16663
16664 let item_rows: Vec<serde_json::Value> = items
16665 .iter()
16666 .map(|it| {
16667 let resolved_label = if it.label.trim().is_empty() {
16668 it.page_id
16669 .and_then(|pid| by_page_id.get(&pid).map(|p| p.title.clone()))
16670 .unwrap_or_default()
16671 } else {
16672 it.label.clone()
16673 };
16674 let resolved_url = match (it.page_id, it.external_url.clone()) {
16675 (Some(pid), _) => by_page_id
16676 .get(&pid)
16677 .map(|p| p.url_path.clone())
16678 .unwrap_or_else(|| "—".to_owned()),
16679 (None, Some(url)) => url,
16680 _ => "—".to_owned(),
16681 };
16682 let tr = it
16683 .id
16684 .get()
16685 .and_then(|iid| item_translations.get(iid));
16686 serde_json::json!({
16687 "id": it.id.get().copied(),
16688 "label": it.label,
16689 "resolved_label": resolved_label,
16690 "page_id": it.page_id,
16691 "external_url": it.external_url,
16692 "parent_id": it.parent_id,
16693 "sort_order": it.sort_order,
16694 "open_in_new_tab": it.open_in_new_tab,
16695 "resolved_url": resolved_url,
16696 "tr_label": tr.and_then(|m| m.get("label")).cloned().unwrap_or_default(),
16697 "tr_external_url": tr
16698 .and_then(|m| m.get("external_url"))
16699 .cloned()
16700 .unwrap_or_default(),
16701 })
16702 })
16703 .collect();
16704
16705 let error_tid = crate::error_pages::error_page_type_id(tenant.pool()).await;
16707 let linkable = |p: &&Page| error_tid.map_or(true, |tid| p.page_type_id != tid);
16708 let picker_pages: Vec<serde_json::Value> = all_pages
16709 .iter()
16710 .filter(linkable)
16711 .map(|p| {
16712 serde_json::json!({
16713 "id": p.id.get().copied(),
16714 "title": p.title,
16715 "url_path": p.url_path,
16716 })
16717 })
16718 .collect();
16719
16720 let recent_pages_raw: Vec<Page> = Page::objects()
16726 .order_by(&[("updated_at", true)])
16727 .fetch(tenant.pool())
16728 .await?;
16729 let picker_recent: Vec<serde_json::Value> = recent_pages_raw
16730 .iter()
16731 .filter(linkable)
16732 .take(20)
16733 .map(|p| {
16734 serde_json::json!({
16735 "id": p.id.get().copied(),
16736 "title": p.title,
16737 "url_path": p.url_path,
16738 "updated_at": p.updated_at,
16739 })
16740 })
16741 .collect();
16742
16743 let mut picker_library: Vec<serde_json::Value> = Vec::new();
16750 for handler in crate::library::registered_handlers() {
16751 let entries = handler
16752 .menu_picker_entries(tenant.pool())
16753 .await
16754 .map_err(|e| {
16755 AdminError::Validation(format!(
16756 "library `{}::menu_picker_entries` failed: {e}",
16757 handler.type_name()
16758 ))
16759 })?;
16760 for entry in entries {
16761 picker_library.push(serde_json::json!({
16762 "label": entry.label,
16763 "url": entry.url,
16764 "kind_hint": entry.kind_hint,
16765 "library_type": handler.verbose_name(),
16766 }));
16767 }
16768 }
16769
16770 let mut ctx = Context::new();
16771 add_chrome(&mut ctx, &tenant, "navigation", session_user.as_ref()).await;
16772 add_admin_theme(&mut ctx, tenant.pool()).await;
16773 ctx.insert("menu_id", &menu.id.get().copied());
16774 ctx.insert("menu_slug", &menu.slug);
16775 ctx.insert("menu_name", &menu.name);
16776 ctx.insert("items", &item_rows);
16777 ctx.insert("picker_pages", &picker_pages);
16778 ctx.insert("picker_recent", &picker_recent);
16779 ctx.insert("picker_library", &picker_library);
16780 ctx.insert("has_library_picker", &!picker_library.is_empty());
16781 ctx.insert("has_curated_picker", &!suggested.is_empty());
16782 ctx.insert("locales", &locales);
16783 ctx.insert("editing_locale", &editing_locale);
16784 ctx.insert("translation_mode", &translation_mode);
16785 render_with_csrf(
16786 &state,
16787 &headers,
16788 "rcms_admin/navigation_edit.html",
16789 &mut ctx,
16790 )
16791}
16792
16793pub async fn navigation_translate_submit(
16805 State(_state): State<super::AdminState>,
16806 tenant: Tenant,
16807 Path(id): Path<i64>,
16808 Query(q): Query<EditQuery>,
16809 Form(form): Form<std::collections::HashMap<String, String>>,
16810) -> Result<Response, AdminError> {
16811 use crate::menu_item_translation::MenuItemTranslation;
16812
16813 let code = q
16814 .locale
16815 .as_deref()
16816 .filter(|c| !c.is_empty())
16817 .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
16818 let locale = Locale::objects()
16819 .where_(Locale::code.eq(code.to_owned()))
16820 .where_(Locale::active.eq(true))
16821 .first(tenant.pool())
16822 .await?
16823 .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
16824 if locale.is_default {
16825 return Ok((
16826 axum::http::StatusCode::BAD_REQUEST,
16827 "cannot translate INTO the default locale; canonical labels live on cms_menu_item",
16828 )
16829 .into_response());
16830 }
16831 let locale_id = locale
16832 .id
16833 .get()
16834 .copied()
16835 .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
16836
16837 let own_items: std::collections::HashSet<i64> = crate::navigation::MenuItem::objects()
16841 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16842 .fetch(tenant.pool())
16843 .await?
16844 .iter()
16845 .filter_map(|it| it.id.get().copied())
16846 .collect();
16847
16848 let mut updates: Vec<(i64, String, String)> = Vec::new();
16849 for (k, v) in &form {
16850 let Some(rest) = k.strip_prefix("tr__") else {
16851 continue;
16852 };
16853 let Some((raw_id, raw_field)) = rest.split_once("__") else {
16854 continue;
16855 };
16856 let Ok(item_id) = raw_id.parse::<i64>() else {
16857 continue;
16858 };
16859 if !own_items.contains(&item_id) {
16860 continue;
16861 }
16862 if let Ok(field) = crate::menu_item_translation::validate_field_path(raw_field) {
16865 updates.push((item_id, field, v.trim().to_owned()));
16866 }
16867 }
16868
16869 rustango::atomic!(tenant.pool(), |tx| {
16870 let mut guard = tx.lock().await?;
16871 let tx = &mut *guard;
16872 for (item_id, field, value) in updates {
16873 let existing: Vec<MenuItemTranslation> = MenuItemTranslation::objects()
16874 .where_(MenuItemTranslation::item_id.eq(item_id))
16875 .where_(MenuItemTranslation::locale_id.eq(locale_id))
16876 .where_(MenuItemTranslation::field_path.eq(field.clone()))
16877 .fetch_tx(tx)
16878 .await?;
16879 if value.is_empty() {
16880 for row in existing {
16881 row.delete_tx(tx).await?;
16882 }
16883 } else if let Some(mut row) = existing.into_iter().next() {
16884 row.value = value;
16885 row.save_tx(tx).await?;
16886 } else {
16887 let mut row = MenuItemTranslation {
16888 id: rustango::sql::Auto::Unset,
16889 item_id,
16890 locale_id,
16891 field_path: field,
16892 value,
16893 updated_at: rustango::sql::Auto::Unset,
16894 };
16895 row.save_tx(tx).await?;
16896 }
16897 }
16898 Ok::<_, rustango::sql::ExecError>(())
16899 })
16900 .await?;
16901
16902 Ok(Redirect::to(&format!(
16903 "/cms-admin/navigation/{id}/edit?locale={code}"
16904 ))
16905 .into_response())
16906}
16907
16908#[derive(Debug, Deserialize)]
16912pub struct MenuItemForm {
16913 pub label: String,
16914 #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
16915 pub page_id: Option<i64>,
16916 #[serde(default)]
16917 pub external_url: Option<String>,
16918 #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
16919 pub parent_id: Option<i64>,
16920 #[serde(default)]
16921 pub sort_order: Option<i32>,
16922 #[serde(default)]
16923 pub open_in_new_tab: Option<String>,
16924}
16925
16926async fn validate_menu_parent(
16935 tenant: &Tenant,
16936 menu_id: i64,
16937 parent_id: Option<i64>,
16938) -> Result<(), AdminError> {
16939 let Some(pid) = parent_id else {
16940 return Ok(());
16941 };
16942 let parent = crate::navigation::MenuItem::objects()
16943 .where_(crate::navigation::MenuItem::id.eq(pid))
16944 .first(tenant.pool())
16945 .await?;
16946 match parent {
16947 Some(p) if p.menu_id == menu_id => Ok(()),
16948 Some(_) => Err(AdminError::Validation(
16949 "That parent item belongs to a different menu.".to_owned(),
16950 )),
16951 None => Err(AdminError::Validation(
16952 "That parent item no longer exists.".to_owned(),
16953 )),
16954 }
16955}
16956
16957impl MenuItemForm {
16958 fn parsed_external_url(&self) -> Option<String> {
16959 self.external_url
16960 .as_deref()
16961 .map(str::trim)
16962 .filter(|s| !s.is_empty())
16963 .map(str::to_owned)
16964 }
16965}
16966
16967pub async fn navigation_item_create(
16969 State(_state): State<super::AdminState>,
16970 tenant: Tenant,
16971 headers: HeaderMap,
16972 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16973 Path(menu_id): Path<i64>,
16974 Form(form): Form<MenuItemForm>,
16975) -> Result<Response, AdminError> {
16976 let external = form.parsed_external_url();
16977 if form.page_id.is_some() == external.is_some() {
16980 return redirect_named_with_params_and_message(
16981 "rcms-admin:navigation:edit",
16982 &[("id", menu_id.to_string())],
16983 MsgLevel::Warning,
16984 "Pick exactly one of: a page link, or a custom URL.",
16985 &headers,
16986 );
16987 }
16988 validate_menu_parent(&tenant, menu_id, form.parent_id).await?;
16990 let mut row = crate::navigation::MenuItem {
16991 id: rustango::sql::Auto::Unset,
16992 menu_id,
16993 parent_id: form.parent_id,
16994 sort_order: form.sort_order.unwrap_or(100),
16995 label: form.label.trim().to_owned(),
16996 page_id: form.page_id,
16997 external_url: external,
16998 open_in_new_tab: form.open_in_new_tab.is_some(),
16999 };
17000 row.insert_pool(tenant.pool()).await?;
17001 redirect_named_with_params_and_message(
17002 "rcms-admin:navigation:edit",
17003 &[("id", menu_id.to_string())],
17004 MsgLevel::Success,
17005 "Item added.",
17006 &headers,
17007 )
17008}
17009
17010pub async fn navigation_item_delete(
17012 State(_state): State<super::AdminState>,
17013 tenant: Tenant,
17014 headers: HeaderMap,
17015 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
17016 Path((menu_id, id)): Path<(i64, i64)>,
17017) -> Result<Response, AdminError> {
17018 let row = crate::navigation::MenuItem::objects()
17019 .where_(crate::navigation::MenuItem::id.eq(id))
17020 .where_(crate::navigation::MenuItem::menu_id.eq(menu_id))
17021 .first(tenant.pool())
17022 .await?
17023 .ok_or(AdminError::NotFound(id))?;
17024 let children: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
17027 .where_(crate::navigation::MenuItem::parent_id.eq(Some(id)))
17028 .fetch(tenant.pool())
17029 .await?;
17030 for mut c in children {
17031 c.parent_id = row.parent_id;
17032 c.save_pool(tenant.pool()).await?;
17033 }
17034 row.delete_pool(tenant.pool()).await?;
17035 redirect_named_with_params_and_message(
17036 "rcms-admin:navigation:edit",
17037 &[("id", menu_id.to_string())],
17038 MsgLevel::Success,
17039 "Item deleted.",
17040 &headers,
17041 )
17042}
17043
17044pub async fn page_types_dashboard(
17053 State(state): State<super::AdminState>,
17054 tenant: Tenant,
17055 headers: HeaderMap,
17056 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17057) -> Result<Response, AdminError> {
17058 let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
17062 let page_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
17063
17064 let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17065 let mut latest: std::collections::HashMap<i64, chrono::DateTime<chrono::Utc>> =
17066 std::collections::HashMap::new();
17067 for p in &pages {
17068 *counts.entry(p.page_type_id).or_insert(0) += 1;
17069 if let Some(when) = p.published_at.or_else(|| p.created_at.get().copied()) {
17070 latest
17071 .entry(p.page_type_id)
17072 .and_modify(|cur| {
17073 if when > *cur {
17074 *cur = when;
17075 }
17076 })
17077 .or_insert(when);
17078 }
17079 }
17080
17081 let type_id_by_name: std::collections::HashMap<&str, i64> = page_types
17082 .iter()
17083 .filter_map(|t| t.id.get().copied().map(|id| (t.type_name.as_str(), id)))
17084 .collect();
17085
17086 let mut handler_names = std::collections::BTreeSet::new();
17091 let mut rows: Vec<serde_json::Value> = Vec::new();
17092 for handler in crate::page_type::registered_handlers() {
17093 let name = handler.type_name().to_owned();
17094 handler_names.insert(name.clone());
17095 let row_id = type_id_by_name.get(name.as_str()).copied();
17096 let count = row_id.and_then(|id| counts.get(&id).copied()).unwrap_or(0);
17097 let last = row_id.and_then(|id| latest.get(&id).copied());
17098 rows.push(serde_json::json!({
17099 "type_name": name,
17100 "verbose_name": handler.verbose_name(),
17101 "app_label": handler.app_label(),
17102 "icon": handler.icon(),
17103 "description": handler.description(),
17104 "default_template": handler.default_template(),
17105 "feed_kind": handler.feed_kind(),
17106 "allowed_parents": handler.allowed_parent_types(),
17107 "allowed_children": handler.allowed_child_types(),
17108 "is_creatable": handler.is_creatable(),
17109 "count": count,
17110 "latest": last,
17111 "registered": true,
17112 "row_id": row_id,
17113 }));
17114 }
17115
17116 for t in &page_types {
17123 if !handler_names.contains(&t.type_name) {
17124 let id = t.id.get().copied().unwrap_or_default();
17125 let count = counts.get(&id).copied().unwrap_or(0);
17126 let ui_type = t.app_label == "cms_ui";
17127 rows.push(serde_json::json!({
17128 "type_name": t.type_name,
17129 "verbose_name": t.verbose_name,
17130 "app_label": t.app_label,
17131 "icon": if ui_type { serde_json::Value::String("dashboard_customize".to_owned()) } else { serde_json::Value::Null },
17132 "description": serde_json::Value::Null,
17133 "default_template": t.default_template,
17134 "feed_kind": serde_json::Value::Null,
17135 "allowed_parents": t.allowed_parent_types.clone(),
17136 "allowed_children": t.allowed_child_types.clone(),
17137 "is_creatable": ui_type && t.is_creatable,
17138 "count": count,
17139 "latest": latest.get(&id).copied(),
17140 "registered": false,
17141 "row_id": id,
17142 "ui_type": ui_type,
17143 "deletable": ui_type && count == 0,
17144 }));
17145 }
17146 }
17147 rows.sort_by(|a, b| {
17149 let ac = a.get("count").and_then(|v| v.as_i64()).unwrap_or(0);
17150 let bc = b.get("count").and_then(|v| v.as_i64()).unwrap_or(0);
17151 bc.cmp(&ac).then_with(|| {
17152 a.get("verbose_name")
17153 .and_then(|v| v.as_str())
17154 .unwrap_or("")
17155 .cmp(b.get("verbose_name").and_then(|v| v.as_str()).unwrap_or(""))
17156 })
17157 });
17158
17159 let mut ctx = Context::new();
17160 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
17161 add_admin_theme(&mut ctx, tenant.pool()).await;
17162 ctx.insert("rows", &rows);
17163 ctx.insert("total_pages", &pages.len());
17164 ctx.insert("total_types", &rows.len());
17165 let can_build = session_user.as_ref().is_some_and(|u| u.is_superuser)
17168 || crate::permissions::user_codenames(
17169 tenant.pool(),
17170 session_user
17171 .as_ref()
17172 .and_then(|u| u.id.get().copied())
17173 .unwrap_or_default(),
17174 )
17175 .await
17176 .unwrap_or_default()
17177 .contains("cms_page_type.build");
17178 ctx.insert("can_build_types", &can_build);
17179 ctx.insert("new_type_url", "/cms-admin/page-types/new");
17180 render_with_csrf(&state, &headers, "rcms_admin/page_types.html", &mut ctx)
17181}
17182
17183fn require_superuser_for_user_admin(
17210 user: Option<&rustango::tenancy::auth::User>,
17211) -> Option<Response> {
17212 use axum::response::{IntoResponse, Redirect};
17213 user_admin_denial_target(user.map(|u| u.is_superuser))
17214 .map(|path| Redirect::to(path).into_response())
17215}
17216
17217fn user_admin_denial_target(is_superuser: Option<bool>) -> Option<&'static str> {
17224 match is_superuser {
17225 Some(true) => None,
17226 Some(false) => Some("/cms-admin/no-access"),
17227 None => Some("/login"),
17228 }
17229}
17230
17231pub async fn users_list(
17234 State(state): State<super::AdminState>,
17235 tenant: Tenant,
17236 headers: HeaderMap,
17237 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17238) -> Result<Response, AdminError> {
17239 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17240 return Ok(redirect);
17241 }
17242 let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
17243 .order_by(&[("username", false)])
17244 .fetch(tenant.pool())
17245 .await?;
17246 let roles: Vec<rustango::tenancy::permissions::Role> =
17247 rustango::tenancy::permissions::Role::objects()
17248 .fetch(tenant.pool())
17249 .await?;
17250 let user_roles: Vec<rustango::tenancy::permissions::UserRole> =
17251 rustango::tenancy::permissions::UserRole::objects()
17252 .fetch(tenant.pool())
17253 .await?;
17254
17255 let roles_by_id: std::collections::HashMap<i64, &rustango::tenancy::permissions::Role> = roles
17256 .iter()
17257 .filter_map(|r| r.id.get().copied().map(|id| (id, r)))
17258 .collect();
17259 let mut roles_by_user: std::collections::HashMap<i64, Vec<String>> =
17260 std::collections::HashMap::new();
17261 for ur in &user_roles {
17262 if let Some(role) = roles_by_id.get(&ur.role_id) {
17263 roles_by_user
17264 .entry(ur.user_id)
17265 .or_default()
17266 .push(role.name.clone());
17267 }
17268 }
17269
17270 let rows: Vec<serde_json::Value> = users
17271 .iter()
17272 .map(|u| {
17273 let id = u.id.get().copied();
17274 serde_json::json!({
17275 "id": id,
17276 "username": u.username,
17277 "email": user_email(u),
17278 "is_superuser": u.is_superuser,
17279 "active": u.active,
17280 "created_at": u.created_at,
17281 "password_changed_at": u.password_changed_at,
17282 "roles": id.and_then(|i| roles_by_user.get(&i).cloned()).unwrap_or_default(),
17283 })
17284 })
17285 .collect();
17286
17287 let mut ctx = Context::new();
17288 add_chrome(&mut ctx, &tenant, "users", session_user.as_ref()).await;
17289 add_admin_theme(&mut ctx, tenant.pool()).await;
17290 ctx.insert("users", &rows);
17291 ctx.insert("total_users", &users.len());
17292 ctx.insert("active_users", &users.iter().filter(|u| u.active).count());
17293 render_with_csrf(&state, &headers, "rcms_admin/users_list.html", &mut ctx)
17294}
17295
17296#[derive(Debug, Deserialize)]
17300pub struct SecurityLogQuery {
17301 #[serde(default)]
17302 pub event: String,
17303 #[serde(default)]
17304 pub username: String,
17305 #[serde(default)]
17306 pub page: Option<i64>,
17307 #[serde(default)]
17308 pub per_page: Option<usize>,
17309}
17310
17311fn security_event_tone(event: &str) -> &'static str {
17313 use crate::security_log as log;
17314 match event {
17315 log::EVENT_LOGIN => "published",
17316 log::EVENT_LOGIN_FAILED => "scheduled",
17317 log::EVENT_LOCKOUT => "expired",
17318 log::EVENT_PERMISSIONS_CHANGED => "archived",
17319 _ => "draft",
17320 }
17321}
17322
17323pub async fn security_log_page(
17327 State(state): State<super::AdminState>,
17328 tenant: Tenant,
17329 headers: HeaderMap,
17330 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17331 Query(q): Query<SecurityLogQuery>,
17332) -> Result<Response, AdminError> {
17333 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17334 return Ok(redirect);
17335 }
17336 let per_page = crate::admin::pagination::clamp_per_page(q.per_page);
17337 let filter = crate::security_log::Filter {
17338 event: q.event.trim().to_owned(),
17339 username: q.username.trim().to_owned(),
17340 };
17341 let total = crate::security_log::count(tenant.pool(), &filter).await?;
17342 let pagination = crate::admin::pagination::context(
17343 q.page.unwrap_or(1),
17344 per_page,
17345 usize::try_from(total).unwrap_or(0),
17346 );
17347 let page = pagination["page"].as_i64().unwrap_or(1);
17349 let events = crate::security_log::list(
17350 tenant.pool(),
17351 &filter,
17352 per_page as i64,
17353 crate::admin::pagination::offset(page, per_page),
17354 )
17355 .await?;
17356 let rows: Vec<serde_json::Value> = events
17357 .iter()
17358 .map(|e| {
17359 serde_json::json!({
17360 "event": e.event,
17361 "tone": security_event_tone(&e.event),
17362 "source": e.source,
17363 "user_id": e.user_id,
17364 "username": e.username,
17365 "reason": e.reason,
17366 "actor": e.actor,
17367 "detail": e.detail,
17368 "ip_address": e.ip_address,
17369 "user_agent": e.user_agent,
17370 "created_at": e.created_at.get().copied(),
17371 })
17372 })
17373 .collect();
17374
17375 let mut ctx = Context::new();
17376 add_chrome(&mut ctx, &tenant, "security-log", session_user.as_ref()).await;
17377 add_admin_theme(&mut ctx, tenant.pool()).await;
17378 ctx.insert("rows", &rows);
17379 ctx.insert("total", &total);
17380 ctx.insert("events", crate::security_log::EVENTS);
17381 ctx.insert("filter_event", &filter.event);
17382 ctx.insert("filter_username", &filter.username);
17383 ctx.insert("pagination", &pagination);
17384 render_with_csrf(&state, &headers, "rcms_admin/security_log.html", &mut ctx)
17385}
17386
17387pub async fn roles_list(
17390 State(state): State<super::AdminState>,
17391 tenant: Tenant,
17392 headers: HeaderMap,
17393 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17394) -> Result<Response, AdminError> {
17395 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17397 return Ok(redirect);
17398 }
17399 let roles: Vec<rustango::tenancy::permissions::Role> =
17400 rustango::tenancy::permissions::Role::objects()
17401 .order_by(&[("name", false)])
17402 .fetch(tenant.pool())
17403 .await?;
17404 let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17405 rustango::tenancy::permissions::RolePermission::objects()
17406 .fetch(tenant.pool())
17407 .await?;
17408 let user_roles: Vec<rustango::tenancy::permissions::UserRole> =
17409 rustango::tenancy::permissions::UserRole::objects()
17410 .fetch(tenant.pool())
17411 .await?;
17412
17413 let mut perm_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17414 for p in &perms {
17415 *perm_counts.entry(p.role_id).or_insert(0) += 1;
17416 }
17417 let mut member_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17418 for ur in &user_roles {
17419 *member_counts.entry(ur.role_id).or_insert(0) += 1;
17420 }
17421
17422 let rows: Vec<serde_json::Value> = roles
17423 .iter()
17424 .map(|r| {
17425 let id = r.id.get().copied().unwrap_or_default();
17426 serde_json::json!({
17427 "id": id,
17428 "name": r.name,
17429 "description": r.description,
17430 "perm_count": perm_counts.get(&id).copied().unwrap_or(0),
17431 "member_count": member_counts.get(&id).copied().unwrap_or(0),
17432 })
17433 })
17434 .collect();
17435 let mut ctx = Context::new();
17436 add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17437 add_admin_theme(&mut ctx, tenant.pool()).await;
17438 ctx.insert("roles", &rows);
17439 render_with_csrf(&state, &headers, "rcms_admin/roles_list.html", &mut ctx)
17440}
17441
17442pub async fn permissions_overview(
17448 State(state): State<super::AdminState>,
17449 tenant: Tenant,
17450 headers: HeaderMap,
17451 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17452) -> Result<Response, AdminError> {
17453 let roles: Vec<rustango::tenancy::permissions::Role> =
17454 rustango::tenancy::permissions::Role::objects()
17455 .order_by(&[("name", false)])
17456 .fetch(tenant.pool())
17457 .await?;
17458 let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17459 rustango::tenancy::permissions::RolePermission::objects()
17460 .fetch(tenant.pool())
17461 .await?;
17462 let granted: std::collections::HashSet<(i64, String)> = perms
17463 .iter()
17464 .map(|p| (p.role_id, p.codename.clone()))
17465 .collect();
17466
17467 let role_headers: Vec<serde_json::Value> = roles
17468 .iter()
17469 .map(|r| {
17470 serde_json::json!({
17471 "id": r.id.get().copied().unwrap_or_default(),
17472 "name": r.name,
17473 })
17474 })
17475 .collect();
17476
17477 let sections: Vec<serde_json::Value> = super::resources::grouped()
17479 .into_iter()
17480 .map(|(section, resources)| {
17481 let rows: Vec<serde_json::Value> = resources
17482 .iter()
17483 .map(|res| {
17484 let cells: Vec<serde_json::Value> = roles
17485 .iter()
17486 .map(|r| {
17487 let rid = r.id.get().copied().unwrap_or_default();
17488 let actions = super::resources::granted_actions(res, rid, &granted);
17489 serde_json::json!({
17490 "actions": actions,
17491 "any": !actions.is_empty(),
17492 })
17493 })
17494 .collect();
17495 serde_json::json!({
17496 "label": res.label,
17497 "key": res.key,
17498 "cells": cells,
17499 })
17500 })
17501 .collect();
17502 serde_json::json!({
17503 "label": section.label(),
17504 "rows": rows,
17505 })
17506 })
17507 .collect();
17508
17509 let mut ctx = Context::new();
17510 add_chrome(&mut ctx, &tenant, "permissions", session_user.as_ref()).await;
17511 add_admin_theme(&mut ctx, tenant.pool()).await;
17512 ctx.insert("roles", &role_headers);
17513 ctx.insert("sections", §ions);
17514 ctx.insert("role_count", &role_headers.len());
17515 render_with_csrf(
17516 &state,
17517 &headers,
17518 "rcms_admin/permissions_overview.html",
17519 &mut ctx,
17520 )
17521}
17522
17523pub async fn roles_new_form(
17525 State(state): State<super::AdminState>,
17526 tenant: Tenant,
17527 headers: HeaderMap,
17528 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17529) -> Result<Response, AdminError> {
17530 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17532 return Ok(redirect);
17533 }
17534 let mut ctx = Context::new();
17535 add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17536 add_admin_theme(&mut ctx, tenant.pool()).await;
17537 ctx.insert("mode", "new");
17538 ctx.insert(
17539 "role",
17540 &serde_json::json!({ "id": serde_json::Value::Null, "name": "", "description": "", "permissions": [] }),
17541 );
17542 ctx.insert("matrix", &build_permission_matrix(&[]));
17543 ctx.insert("legacy_codenames", &Vec::<String>::new());
17544 render_with_csrf(&state, &headers, "rcms_admin/role_form.html", &mut ctx)
17545}
17546
17547pub async fn roles_edit_form(
17550 State(state): State<super::AdminState>,
17551 tenant: Tenant,
17552 headers: HeaderMap,
17553 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17554 Path(id): Path<i64>,
17555) -> Result<Response, AdminError> {
17556 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17558 return Ok(redirect);
17559 }
17560 let role = rustango::tenancy::permissions::Role::objects()
17561 .where_(rustango::tenancy::permissions::Role::id.eq(id))
17562 .first(tenant.pool())
17563 .await?
17564 .ok_or(AdminError::NotFound(id))?;
17565 let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17566 rustango::tenancy::permissions::RolePermission::objects()
17567 .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17568 .order_by(&[("codename", false)])
17569 .fetch(tenant.pool())
17570 .await?;
17571 let codenames: Vec<String> = perms.iter().map(|p| p.codename.clone()).collect();
17572 let (_matched, legacy) = split_matrix_codenames(&codenames);
17573 let mut ctx = Context::new();
17574 add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17575 add_admin_theme(&mut ctx, tenant.pool()).await;
17576 ctx.insert("mode", "edit");
17577 ctx.insert(
17578 "role",
17579 &serde_json::json!({
17580 "id": role.id.get().copied(),
17581 "name": role.name,
17582 "description": role.description,
17583 "permissions": codenames,
17584 }),
17585 );
17586 ctx.insert("matrix", &build_permission_matrix(&codenames));
17587 ctx.insert("legacy_codenames", &legacy);
17588 render_with_csrf(&state, &headers, "rcms_admin/role_form.html", &mut ctx)
17589}
17590
17591fn build_permission_matrix(granted: &[String]) -> serde_json::Value {
17601 use super::resources::{codename, grouped};
17602 use crate::permissions::Action;
17603
17604 let granted_set: std::collections::HashSet<&str> = granted.iter().map(String::as_str).collect();
17605
17606 let mut sections = Vec::new();
17607 for (section, rows) in grouped() {
17608 let rows_json: Vec<serde_json::Value> = rows
17609 .iter()
17610 .map(|r| {
17611 let applicable: Vec<&str> = r.actions.iter().map(|a| a.as_str()).collect();
17612 let granted_actions: Vec<&str> = [
17613 Action::Access,
17614 Action::AccessAdmin,
17615 Action::View,
17616 Action::Add,
17617 Action::Edit,
17618 Action::Publish,
17619 Action::Delete,
17620 ]
17621 .iter()
17622 .copied()
17623 .filter(|action| {
17624 r.actions.contains(action)
17625 && granted_set.contains(codename(r, *action).as_str())
17626 })
17627 .map(|a| a.as_str())
17628 .collect();
17629 serde_json::json!({
17630 "key": r.key,
17631 "label": r.label,
17632 "applicable": applicable,
17633 "granted": granted_actions,
17634 })
17635 })
17636 .collect();
17637 sections.push(serde_json::json!({
17638 "section_label": section.label(),
17639 "rows": rows_json,
17640 }));
17641 }
17642 serde_json::Value::Array(sections)
17643}
17644
17645fn split_matrix_codenames(granted: &[String]) -> (Vec<String>, Vec<String>) {
17652 use super::resources::{all_resources, codename};
17653 use crate::permissions::Action;
17654
17655 let known: std::collections::HashSet<String> = all_resources()
17656 .iter()
17657 .flat_map(|r| {
17658 r.actions
17659 .iter()
17660 .copied()
17661 .filter(|a| {
17662 matches!(
17666 a,
17667 Action::View
17668 | Action::Add
17669 | Action::Edit
17670 | Action::Publish
17671 | Action::Delete
17672 | Action::Access
17673 | Action::AccessAdmin
17674 )
17675 })
17676 .map(|a| codename(r, a))
17677 .collect::<Vec<_>>()
17678 })
17679 .collect();
17680 let (matched, legacy): (Vec<String>, Vec<String>) =
17681 granted.iter().cloned().partition(|c| known.contains(c));
17682 (matched, legacy)
17683}
17684
17685fn parse_matrix_form(form: &std::collections::HashMap<String, String>) -> Vec<String> {
17689 use super::resources::{all_resources, codename};
17690 use crate::permissions::Action;
17691
17692 let resources = all_resources();
17693 let resource_by_key: std::collections::HashMap<&str, &super::resources::AdminResource> =
17694 resources.iter().map(|r| (r.key.as_str(), r)).collect();
17695
17696 let mut out = Vec::new();
17697 for (raw_key, value) in form {
17698 let Some(rest) = raw_key.strip_prefix("perm[") else {
17702 continue;
17703 };
17704 let Some((key, rest)) = rest.split_once("][") else {
17705 continue;
17706 };
17707 let Some(action_str) = rest.strip_suffix(']') else {
17708 continue;
17709 };
17710 if value.is_empty() || value == "0" || value.eq_ignore_ascii_case("off") {
17714 continue;
17715 }
17716 let Some(resource) = resource_by_key.get(key) else {
17717 continue;
17718 };
17719 let action = match action_str {
17720 "view" => Action::View,
17721 "add" => Action::Add,
17722 "edit" => Action::Edit,
17723 "publish" => Action::Publish,
17724 "delete" => Action::Delete,
17725 "access" => Action::Access,
17726 "access_admin" => Action::AccessAdmin,
17727 _ => continue,
17728 };
17729 if !resource.actions.contains(&action) {
17730 continue;
17731 }
17732 out.push(codename(resource, action));
17733 }
17734 out.sort();
17735 out.dedup();
17736 out
17737}
17738
17739async fn sync_role_codenames(
17742 pool: &rustango::sql::Pool,
17743 role_id: i64,
17744 new_codenames: &[String],
17745) -> Result<(), AdminError> {
17746 let existing: Vec<rustango::tenancy::permissions::RolePermission> =
17747 rustango::tenancy::permissions::RolePermission::objects()
17748 .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(role_id))
17749 .fetch(pool)
17750 .await?;
17751 let want: std::collections::BTreeSet<&str> = new_codenames.iter().map(String::as_str).collect();
17752 let have: std::collections::BTreeSet<&str> =
17753 existing.iter().map(|p| p.codename.as_str()).collect();
17754 for p in &existing {
17756 if !want.contains(p.codename.as_str()) {
17757 p.clone().delete_pool(pool).await?;
17758 }
17759 }
17760 for codename in new_codenames {
17762 if !have.contains(codename.as_str()) {
17763 let mut row = rustango::tenancy::permissions::RolePermission {
17764 id: rustango::sql::Auto::Unset,
17765 role_id,
17766 codename: codename.clone(),
17767 };
17768 row.insert_pool(pool).await?;
17769 }
17770 }
17771 Ok(())
17772}
17773
17774pub async fn roles_create_submit(
17778 State(_state): State<super::AdminState>,
17779 tenant: Tenant,
17780 headers: HeaderMap,
17781 request: crate::security_log::LoginRequest,
17782 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17783 Form(form): Form<std::collections::HashMap<String, String>>,
17784) -> Result<Response, AdminError> {
17785 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17787 return Ok(redirect);
17788 }
17789 let name = form.get("name").map(|s| s.trim()).unwrap_or("").to_owned();
17790 if name.is_empty() {
17791 return Err(AdminError::Validation("Role name is required.".to_owned()));
17792 }
17793 let description = form
17794 .get("description")
17795 .map(|s| s.trim())
17796 .unwrap_or("")
17797 .to_owned();
17798 let mut row = rustango::tenancy::permissions::Role {
17799 id: rustango::sql::Auto::Unset,
17800 name: name.clone(),
17801 description,
17802 data: serde_json::Value::Object(serde_json::Map::new()),
17803 };
17804 row.insert_pool(tenant.pool()).await?;
17805 let role_id = row.id.get().copied().unwrap_or_default();
17806 let codenames = parse_matrix_form(&form);
17807 sync_role_codenames(tenant.pool(), role_id, &codenames).await?;
17808 let detail = crate::security_log::describe_role_change(&name, &[], &codenames)
17809 .unwrap_or_else(|| format!("role “{name}”: no permissions"));
17810 record_access_change(&tenant, session_user.as_ref(), &request, None, format!("created {detail}"))
17811 .await;
17812 redirect_named_with_message_args(
17813 "rcms-admin:roles",
17814 MsgLevel::Success,
17815 "Role “{name}” created.",
17816 &[("name", name.as_str())],
17817 &headers,
17818 )
17819}
17820
17821pub async fn roles_edit_submit(
17825 State(_state): State<super::AdminState>,
17826 tenant: Tenant,
17827 headers: HeaderMap,
17828 request: crate::security_log::LoginRequest,
17829 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17830 Path(id): Path<i64>,
17831 Form(form): Form<std::collections::HashMap<String, String>>,
17832) -> Result<Response, AdminError> {
17833 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17835 return Ok(redirect);
17836 }
17837 let mut role = rustango::tenancy::permissions::Role::objects()
17838 .where_(rustango::tenancy::permissions::Role::id.eq(id))
17839 .first(tenant.pool())
17840 .await?
17841 .ok_or(AdminError::NotFound(id))?;
17842 let name = form.get("name").map(|s| s.trim()).unwrap_or("").to_owned();
17843 if name.is_empty() {
17844 return Err(AdminError::Validation("Role name is required.".to_owned()));
17845 }
17846 let description = form
17847 .get("description")
17848 .map(|s| s.trim())
17849 .unwrap_or("")
17850 .to_owned();
17851 role.name = name.clone();
17852 role.description = description;
17853 role.save_pool(tenant.pool()).await?;
17854 let existing: Vec<rustango::tenancy::permissions::RolePermission> =
17858 rustango::tenancy::permissions::RolePermission::objects()
17859 .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17860 .fetch(tenant.pool())
17861 .await?;
17862 let existing_codenames: Vec<String> = existing.into_iter().map(|p| p.codename).collect();
17863 let (_old_matrix, legacy) = split_matrix_codenames(&existing_codenames);
17864 let mut codenames = parse_matrix_form(&form);
17865 codenames.extend(legacy);
17866 codenames.sort();
17867 codenames.dedup();
17868 sync_role_codenames(tenant.pool(), id, &codenames).await?;
17869 if let Some(detail) =
17870 crate::security_log::describe_role_change(&name, &existing_codenames, &codenames)
17871 {
17872 record_access_change(&tenant, session_user.as_ref(), &request, None, detail).await;
17873 }
17874 redirect_named_with_message_args(
17875 "rcms-admin:roles",
17876 MsgLevel::Success,
17877 "Role “{name}” saved.",
17878 &[("name", name.as_str())],
17879 &headers,
17880 )
17881}
17882
17883pub async fn roles_delete_submit(
17886 State(_state): State<super::AdminState>,
17887 tenant: Tenant,
17888 headers: HeaderMap,
17889 request: crate::security_log::LoginRequest,
17890 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17891 Path(id): Path<i64>,
17892) -> Result<Response, AdminError> {
17893 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17895 return Ok(redirect);
17896 }
17897 let role = rustango::tenancy::permissions::Role::objects()
17898 .where_(rustango::tenancy::permissions::Role::id.eq(id))
17899 .first(tenant.pool())
17900 .await?
17901 .ok_or(AdminError::NotFound(id))?;
17902 let name = role.name.clone();
17903 for p in rustango::tenancy::permissions::RolePermission::objects()
17905 .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17906 .fetch(tenant.pool())
17907 .await?
17908 {
17909 p.delete_pool(tenant.pool()).await?;
17910 }
17911 for ur in rustango::tenancy::permissions::UserRole::objects()
17912 .where_(rustango::tenancy::permissions::UserRole::role_id.eq(id))
17913 .fetch(tenant.pool())
17914 .await?
17915 {
17916 ur.delete_pool(tenant.pool()).await?;
17917 }
17918 role.delete_pool(tenant.pool()).await?;
17919 record_access_change(
17920 &tenant,
17921 session_user.as_ref(),
17922 &request,
17923 None,
17924 format!("deleted role “{name}”"),
17925 )
17926 .await;
17927 redirect_named_with_message_args(
17928 "rcms-admin:roles",
17929 MsgLevel::Success,
17930 "Role “{name}” deleted.",
17931 &[("name", name.as_str())],
17932 &headers,
17933 )
17934}
17935
17936pub async fn users_new_form(
17938 State(state): State<super::AdminState>,
17939 tenant: Tenant,
17940 headers: HeaderMap,
17941 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17942) -> Result<Response, AdminError> {
17943 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17944 return Ok(redirect);
17945 }
17946 let mut ctx = Context::new();
17947 add_chrome(&mut ctx, &tenant, "users", session_user.as_ref()).await;
17948 add_admin_theme(&mut ctx, tenant.pool()).await;
17949 ctx.insert("mode", "new");
17950 ctx.insert(
17951 "user",
17952 &serde_json::json!({
17953 "id": serde_json::Value::Null,
17954 "username": "",
17955 "is_superuser": false,
17956 "active": true,
17957 }),
17958 );
17959 let role_choices: Vec<serde_json::Value> = rustango::tenancy::permissions::Role::objects()
17961 .order_by(&[("name", false)])
17962 .fetch(tenant.pool())
17963 .await?
17964 .iter()
17965 .map(|r| {
17966 serde_json::json!({
17967 "id": r.id.get().copied().unwrap_or_default(),
17968 "name": r.name,
17969 "description": r.description,
17970 "assigned": false,
17971 })
17972 })
17973 .collect();
17974 ctx.insert("role_choices", &role_choices);
17975 render_with_csrf(&state, &headers, "rcms_admin/user_form.html", &mut ctx)
17976}
17977
17978pub async fn users_edit_form(
17983 State(state): State<super::AdminState>,
17984 tenant: Tenant,
17985 headers: HeaderMap,
17986 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17987 Path(id): Path<i64>,
17988) -> Result<Response, AdminError> {
17989 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17990 return Ok(redirect);
17991 }
17992 render_user_edit_page(&state, &tenant, &headers, session_user.as_ref(), id, None).await
17993}
17994
17995async fn render_user_edit_page(
17996 state: &super::AdminState,
17997 tenant: &Tenant,
17998 headers: &HeaderMap,
17999 session_user: Option<&rustango::tenancy::auth::User>,
18000 id: i64,
18001 mcp_one_time: Option<serde_json::Value>,
18002) -> Result<Response, AdminError> {
18003 let user = rustango::tenancy::auth::User::objects()
18004 .where_(rustango::tenancy::auth::User::id.eq(id))
18005 .first(tenant.pool())
18006 .await?
18007 .ok_or(AdminError::NotFound(id))?;
18008 let roles: Vec<rustango::tenancy::permissions::Role> =
18009 rustango::tenancy::permissions::Role::objects()
18010 .order_by(&[("name", false)])
18011 .fetch(tenant.pool())
18012 .await?;
18013 let memberships: Vec<rustango::tenancy::permissions::UserRole> =
18014 rustango::tenancy::permissions::UserRole::objects()
18015 .where_(rustango::tenancy::permissions::UserRole::user_id.eq(id))
18016 .fetch(tenant.pool())
18017 .await?;
18018 let assigned: std::collections::BTreeSet<i64> = memberships.iter().map(|m| m.role_id).collect();
18019
18020 let role_choices: Vec<serde_json::Value> = roles
18021 .iter()
18022 .map(|r| {
18023 let rid = r.id.get().copied().unwrap_or_default();
18024 serde_json::json!({
18025 "id": rid,
18026 "name": r.name,
18027 "description": r.description,
18028 "assigned": assigned.contains(&rid),
18029 })
18030 })
18031 .collect();
18032
18033 let user_timezone = user
18038 .data
18039 .get("timezone")
18040 .and_then(serde_json::Value::as_str)
18041 .unwrap_or("")
18042 .to_owned();
18043 let user_email = user_email(&user);
18044
18045 let mut ctx = Context::new();
18046 add_chrome(&mut ctx, tenant, "users", session_user).await;
18047 add_admin_theme(&mut ctx, tenant.pool()).await;
18048 ctx.insert("mode", "edit");
18049 ctx.insert(
18050 "user",
18051 &serde_json::json!({
18052 "id": user.id.get().copied(),
18053 "username": user.username,
18054 "email": user_email,
18055 "is_superuser": user.is_superuser,
18056 "active": user.active,
18057 "timezone": user_timezone,
18058 "password_changed_at": user.password_changed_at,
18059 "created_at": user.created_at,
18060 }),
18061 );
18062 ctx.insert("role_choices", &role_choices);
18063 let (keys, skills) = mcp_keys_ctx(tenant.pool(), id).await;
18066 ctx.insert("mcp_keys", &keys);
18067 ctx.insert("mcp_skills", &skills);
18068 if let Some(one_time) = &mcp_one_time {
18069 ctx.insert("mcp_one_time", one_time);
18070 }
18071 render_with_csrf(state, headers, "rcms_admin/user_form.html", &mut ctx)
18072}
18073
18074fn parse_mcp_key_form(pairs: &[(String, String)]) -> (String, Vec<String>) {
18079 let label = pairs
18080 .iter()
18081 .find(|(k, _)| k == "label")
18082 .map(|(_, v)| v.trim())
18083 .filter(|v| !v.is_empty())
18084 .unwrap_or("MCP key")
18085 .to_owned();
18086 let skills: Vec<String> = pairs
18087 .iter()
18088 .filter(|(k, v)| k == "skill" && !v.trim().is_empty())
18089 .map(|(_, v)| v.trim().to_owned())
18090 .collect();
18091 (label, skills)
18092}
18093
18094async fn audit_mcp_key(
18097 pool: &rustango::sql::Pool,
18098 actor_id: i64,
18099 what: &str,
18100 detail: serde_json::Value,
18101) {
18102 let entry = rustango::audit::PendingEntry {
18103 entity_table: "rustango_agents",
18104 entity_pk: detail
18105 .get("key_id")
18106 .and_then(serde_json::Value::as_i64)
18107 .map(|i| i.to_string())
18108 .unwrap_or_default(),
18109 operation: rustango::audit::AuditOp::Action,
18110 source: rustango::audit::AuditSource::User {
18111 id: actor_id.to_string(),
18112 },
18113 changes: serde_json::json!({ "event": what, "detail": detail }),
18114 };
18115 if let Err(e) = rustango::audit::emit_one_pool(pool, &entry).await {
18116 tracing::warn!(error = %e, "mcp key audit emit failed");
18117 }
18118}
18119
18120async fn mint_mcp_key(
18123 pool: &rustango::sql::Pool,
18124 actor_id: i64,
18125 owner_id: i64,
18126 label: &str,
18127 skills: &[String],
18128) -> Result<serde_json::Value, String> {
18129 match rustango::tenancy::create_user_key_pool(pool, owner_id, label, skills).await {
18130 Ok(issued) => {
18131 let key_id = issued.agent.id.get().copied().unwrap_or_default();
18132 audit_mcp_key(
18133 pool,
18134 actor_id,
18135 "created",
18136 serde_json::json!({ "key_id": key_id, "owner_id": owner_id, "label": label, "scope": skills }),
18137 )
18138 .await;
18139 Ok(serde_json::json!({ "token": issued.token, "label": label }))
18140 }
18141 Err(e) => Err(e.to_string()),
18142 }
18143}
18144
18145pub async fn account_mcp_key_create(
18149 State(state): State<super::AdminState>,
18150 tenant: Tenant,
18151 headers: HeaderMap,
18152 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18153 Form(pairs): Form<Vec<(String, String)>>,
18154) -> Result<Response, AdminError> {
18155 let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18156 return Ok(unauthorized_no_session());
18157 };
18158 let (label, skills) = parse_mcp_key_form(&pairs);
18159 match mint_mcp_key(tenant.pool(), uid, uid, &label, &skills).await {
18160 Ok(one_time) => {
18161 render_account_page(
18162 &state,
18163 &tenant,
18164 &headers,
18165 session_user.as_ref(),
18166 Some(one_time),
18167 )
18168 .await
18169 }
18170 Err(msg) => redirect_named_with_message_args(
18171 "rcms-admin:account",
18172 MsgLevel::Error,
18173 "Couldn't create the key: {error}",
18174 &[("error", msg.as_str())],
18175 &headers,
18176 ),
18177 }
18178}
18179
18180pub async fn account_mcp_key_revoke(
18183 State(_state): State<super::AdminState>,
18184 tenant: Tenant,
18185 headers: HeaderMap,
18186 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18187 Path(key_id): Path<i64>,
18188) -> Result<Response, AdminError> {
18189 let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18190 return Ok(unauthorized_no_session());
18191 };
18192 match rustango::tenancy::revoke_user_key_pool(tenant.pool(), uid, key_id).await {
18193 Ok(()) => {
18194 audit_mcp_key(
18195 tenant.pool(),
18196 uid,
18197 "revoked",
18198 serde_json::json!({ "key_id": key_id, "owner_id": uid }),
18199 )
18200 .await;
18201 redirect_named_with_message_args(
18202 "rcms-admin:account",
18203 MsgLevel::Success,
18204 "MCP key revoked.",
18205 &[],
18206 &headers,
18207 )
18208 }
18209 Err(e) => {
18210 let msg = e.to_string();
18211 redirect_named_with_message_args(
18212 "rcms-admin:account",
18213 MsgLevel::Error,
18214 "Couldn't revoke the key: {error}",
18215 &[("error", msg.as_str())],
18216 &headers,
18217 )
18218 }
18219 }
18220}
18221
18222pub async fn users_mcp_key_create(
18228 State(state): State<super::AdminState>,
18229 tenant: Tenant,
18230 headers: HeaderMap,
18231 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18232 Path(user_id): Path<i64>,
18233 Form(pairs): Form<Vec<(String, String)>>,
18234) -> Result<Response, AdminError> {
18235 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18241 return Ok(redirect);
18242 }
18243 let Some(actor_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18244 return Ok(unauthorized_no_session());
18245 };
18246 let (label, skills) = parse_mcp_key_form(&pairs);
18247 match mint_mcp_key(tenant.pool(), actor_id, user_id, &label, &skills).await {
18248 Ok(one_time) => {
18249 render_user_edit_page(
18250 &state,
18251 &tenant,
18252 &headers,
18253 session_user.as_ref(),
18254 user_id,
18255 Some(one_time),
18256 )
18257 .await
18258 }
18259 Err(msg) => redirect_named_with_params_and_message_args(
18260 "rcms-admin:users:edit",
18261 &[("id", user_id.to_string())],
18262 MsgLevel::Error,
18263 "Couldn't create the key: {error}",
18264 &[("error", msg.as_str())],
18265 &headers,
18266 ),
18267 }
18268}
18269
18270pub async fn users_mcp_key_revoke(
18273 State(_state): State<super::AdminState>,
18274 tenant: Tenant,
18275 headers: HeaderMap,
18276 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18277 Path((user_id, key_id)): Path<(i64, i64)>,
18278) -> Result<Response, AdminError> {
18279 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18285 return Ok(redirect);
18286 }
18287 let Some(actor_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18288 return Ok(unauthorized_no_session());
18289 };
18290 match rustango::tenancy::revoke_user_key_pool(tenant.pool(), user_id, key_id).await {
18291 Ok(()) => {
18292 audit_mcp_key(
18293 tenant.pool(),
18294 actor_id,
18295 "revoked",
18296 serde_json::json!({ "key_id": key_id, "owner_id": user_id }),
18297 )
18298 .await;
18299 redirect_named_with_params_and_message_args(
18300 "rcms-admin:users:edit",
18301 &[("id", user_id.to_string())],
18302 MsgLevel::Success,
18303 "MCP key revoked.",
18304 &[],
18305 &headers,
18306 )
18307 }
18308 Err(e) => {
18309 let msg = e.to_string();
18310 redirect_named_with_params_and_message_args(
18311 "rcms-admin:users:edit",
18312 &[("id", user_id.to_string())],
18313 MsgLevel::Error,
18314 "Couldn't revoke the key: {error}",
18315 &[("error", msg.as_str())],
18316 &headers,
18317 )
18318 }
18319 }
18320}
18321
18322#[derive(Deserialize)]
18326pub struct UserForm {
18327 pub username: String,
18328 #[serde(default)]
18329 pub email: Option<String>,
18330 #[serde(default)]
18331 pub password: Option<String>,
18332 #[serde(default)]
18333 pub is_superuser: Option<String>,
18334 #[serde(default)]
18335 pub active: Option<String>,
18336}
18337
18338fn validate_optional_email(raw: Option<&str>) -> Result<String, String> {
18342 let e = raw.map(str::trim).unwrap_or("");
18343 if e.is_empty() {
18344 return Ok(String::new());
18345 }
18346 let ok = e.split('@').count() == 2
18347 && e.split('@').all(|p| !p.is_empty())
18348 && !e.contains(char::is_whitespace);
18349 if ok {
18350 Ok(e.to_owned())
18351 } else {
18352 Err(format!("“{e}” is not a valid email address."))
18353 }
18354}
18355
18356pub async fn users_create_submit(
18359 State(_state): State<super::AdminState>,
18360 tenant: Tenant,
18361 headers: HeaderMap,
18362 request: crate::security_log::LoginRequest,
18363 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18364 Form(pairs): Form<Vec<(String, String)>>,
18365) -> Result<Response, AdminError> {
18366 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18367 return Ok(redirect);
18368 }
18369 use rustango::sql::Auto;
18370 let single = |k: &str| pairs.iter().find(|(n, _)| n == k).map(|(_, v)| v.clone());
18373 let form = UserForm {
18374 username: single("username").unwrap_or_default(),
18375 email: single("email"),
18376 password: single("password"),
18377 is_superuser: single("is_superuser"),
18378 active: single("active"),
18379 };
18380 let role_ids: Vec<i64> = pairs
18381 .iter()
18382 .filter(|(k, _)| k == "role_id")
18383 .filter_map(|(_, v)| v.parse::<i64>().ok())
18384 .collect();
18385 let username = form.username.trim().to_owned();
18386 let password = form
18387 .password
18388 .as_deref()
18389 .map(str::trim)
18390 .filter(|s| !s.is_empty())
18391 .map(str::to_owned);
18392 if username.is_empty() || password.is_none() {
18393 return Err(AdminError::Validation(
18394 "Username and initial password are both required.".to_owned(),
18395 ));
18396 }
18397 let hash = crate::passwords::hash(password.as_deref().unwrap_or_default()).await
18398 .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
18399 let email = validate_optional_email(form.email.as_deref()).map_err(AdminError::Validation)?;
18400 let email_col = (!email.is_empty()).then(|| email.clone());
18404
18405 let mut data = serde_json::Map::new();
18408 if !email.is_empty() {
18409 data.insert("email".to_owned(), serde_json::Value::String(email));
18410 }
18411 let mut row = rustango::tenancy::auth::User {
18412 id: Auto::Unset,
18413 username: username.clone(),
18414 password_hash: hash,
18415 email: email_col,
18416 is_superuser: form.is_superuser.is_some(),
18417 active: form.active.is_some(),
18418 created_at: chrono::Utc::now(),
18419 data: serde_json::Value::Object(data),
18420 password_changed_at: Some(chrono::Utc::now()),
18421 sessions_revoked_at: None,
18422 };
18423 row.insert_pool(tenant.pool()).await?;
18424 if let Some(new_id) = row.id.get().copied() {
18425 sync_user_roles(tenant.pool(), new_id, &role_ids).await?;
18426 }
18427 let access = user_access(tenant.pool(), &row).await?;
18428 record_access_change(
18429 &tenant,
18430 session_user.as_ref(),
18431 &request,
18432 Some(&row),
18433 crate::security_log::describe_new_user(&access),
18434 )
18435 .await;
18436 redirect_named_with_message_args(
18437 "rcms-admin:users",
18438 MsgLevel::Success,
18439 "User “{username}” created.",
18440 &[("username", username.as_str())],
18441 &headers,
18442 )
18443}
18444
18445pub async fn users_edit_submit(
18453 State(_state): State<super::AdminState>,
18454 tenant: Tenant,
18455 headers: HeaderMap,
18456 request: crate::security_log::LoginRequest,
18457 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18458 Path(id): Path<i64>,
18459 Form(form): Form<Vec<(String, String)>>,
18460) -> Result<Response, AdminError> {
18461 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18462 return Ok(redirect);
18463 }
18464 let single = |key: &str| -> Option<String> {
18467 form.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
18468 };
18469 let username_raw = single("username").unwrap_or_default();
18470 let username = username_raw.trim().to_owned();
18471 if username.is_empty() {
18472 return Err(AdminError::Validation(
18473 "Username cannot be empty.".to_owned(),
18474 ));
18475 }
18476 let password = single("password");
18477 let is_superuser = form.iter().any(|(k, _)| k == "is_superuser");
18478 let active = form.iter().any(|(k, _)| k == "active");
18479 let timezone_raw = single("timezone").unwrap_or_default();
18480 let timezone = timezone_raw.trim().to_owned();
18481 let email =
18483 validate_optional_email(single("email").as_deref()).map_err(AdminError::Validation)?;
18484 let role_ids: Vec<i64> = form
18485 .iter()
18486 .filter(|(k, _)| k == "role_id")
18487 .filter_map(|(_, v)| v.parse::<i64>().ok())
18488 .collect();
18489
18490 let mut user = rustango::tenancy::auth::User::objects()
18491 .where_(rustango::tenancy::auth::User::id.eq(id))
18492 .first(tenant.pool())
18493 .await?
18494 .ok_or(AdminError::NotFound(id))?;
18495 let before = user_access(tenant.pool(), &user).await?;
18496 user.username = username.clone();
18497 user.is_superuser = is_superuser;
18498 user.active = active;
18499 {
18502 let map = user.data.as_object_mut().ok_or_else(|| {
18503 AdminError::Validation(
18504 "User.data is not a JSON object — refusing to overwrite.".to_owned(),
18505 )
18506 })?;
18507 if timezone.is_empty() {
18508 map.remove("timezone");
18509 } else {
18510 map.insert(
18511 "timezone".to_owned(),
18512 serde_json::Value::String(timezone.clone()),
18513 );
18514 }
18515 if email.is_empty() {
18516 map.remove("email");
18517 } else {
18518 map.insert("email".to_owned(), serde_json::Value::String(email.clone()));
18519 }
18520 }
18521 user.email = (!email.is_empty()).then(|| email.clone());
18524
18525 let rotated = password.as_deref().map(str::trim).filter(|s| !s.is_empty());
18526 if let Some(new_pw) = rotated {
18527 let hash = crate::passwords::hash(new_pw).await
18528 .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
18529 user.password_hash = hash;
18530 user.password_changed_at = Some(chrono::Utc::now());
18531 }
18532 user.save_pool(tenant.pool()).await?;
18533 sync_user_roles(tenant.pool(), id, &role_ids).await?;
18534 let after = user_access(tenant.pool(), &user).await?;
18535 if let Some(detail) = crate::security_log::describe_user_change(&before, &after) {
18536 record_access_change(&tenant, session_user.as_ref(), &request, Some(&user), detail).await;
18537 }
18538 if rotated.is_some() {
18539 redirect_named_with_message_args(
18540 "rcms-admin:users",
18541 MsgLevel::Success,
18542 "User “{username}” saved (password rotated).",
18543 &[("username", username.as_str())],
18544 &headers,
18545 )
18546 } else {
18547 redirect_named_with_message_args(
18548 "rcms-admin:users",
18549 MsgLevel::Success,
18550 "User “{username}” saved.",
18551 &[("username", username.as_str())],
18552 &headers,
18553 )
18554 }
18555}
18556
18557async fn sync_user_roles(
18560 pool: &rustango::sql::Pool,
18561 user_id: i64,
18562 new_role_ids: &[i64],
18563) -> Result<(), AdminError> {
18564 let existing: Vec<rustango::tenancy::permissions::UserRole> =
18565 rustango::tenancy::permissions::UserRole::objects()
18566 .where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
18567 .fetch(pool)
18568 .await?;
18569 let want: std::collections::BTreeSet<i64> = new_role_ids.iter().copied().collect();
18570 let have: std::collections::BTreeSet<i64> = existing.iter().map(|m| m.role_id).collect();
18571 for m in &existing {
18572 if !want.contains(&m.role_id) {
18573 m.clone().delete_pool(pool).await?;
18574 }
18575 }
18576 for role_id in new_role_ids {
18577 if !have.contains(role_id) {
18578 let mut row = rustango::tenancy::permissions::UserRole {
18579 id: rustango::sql::Auto::Unset,
18580 user_id,
18581 role_id: *role_id,
18582 };
18583 row.insert_pool(pool).await?;
18584 }
18585 }
18586 Ok(())
18587}
18588
18589async fn user_access(
18591 pool: &rustango::sql::Pool,
18592 user: &rustango::tenancy::auth::User,
18593) -> Result<crate::security_log::Access, AdminError> {
18594 use rustango::tenancy::permissions::{Role, UserRole};
18595 let role_ids: Vec<i64> = match user.id.get().copied() {
18596 Some(uid) => UserRole::objects()
18597 .where_(UserRole::user_id.eq(uid))
18598 .fetch(pool)
18599 .await?
18600 .into_iter()
18601 .map(|m| m.role_id)
18602 .collect(),
18603 None => Vec::new(),
18604 };
18605 let roles = if role_ids.is_empty() {
18606 Vec::new()
18607 } else {
18608 Role::objects()
18609 .where_(Role::id.is_in(role_ids))
18610 .fetch(pool)
18611 .await?
18612 .into_iter()
18613 .map(|r| r.name)
18614 .collect()
18615 };
18616 Ok(crate::security_log::Access {
18617 superuser: user.is_superuser,
18618 active: user.active,
18619 roles,
18620 })
18621}
18622
18623async fn record_access_change(
18626 tenant: &Tenant,
18627 actor: Option<&rustango::tenancy::auth::User>,
18628 request: &crate::security_log::LoginRequest,
18629 target: Option<&rustango::tenancy::auth::User>,
18630 detail: String,
18631) {
18632 let mut entry = SecurityEntry::new(
18633 crate::security_log::EVENT_PERMISSIONS_CHANGED,
18634 "admin",
18635 &request.meta,
18636 )
18637 .change(actor.map_or("", |u| u.username.as_str()), detail);
18638 if let Some(user) = target {
18639 entry = entry.user(user.id.get().copied(), &user.username);
18640 }
18641 crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
18642}
18643
18644pub async fn users_deactivate_submit(
18647 State(_state): State<super::AdminState>,
18648 tenant: Tenant,
18649 headers: HeaderMap,
18650 request: crate::security_log::LoginRequest,
18651 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18652 Path(id): Path<i64>,
18653) -> Result<Response, AdminError> {
18654 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18655 return Ok(redirect);
18656 }
18657 let mut user = rustango::tenancy::auth::User::objects()
18658 .where_(rustango::tenancy::auth::User::id.eq(id))
18659 .first(tenant.pool())
18660 .await?
18661 .ok_or(AdminError::NotFound(id))?;
18662 let was_active = user.active;
18663 user.active = false;
18664 user.save_pool(tenant.pool()).await?;
18665 if was_active {
18666 record_access_change(
18667 &tenant,
18668 session_user.as_ref(),
18669 &request,
18670 Some(&user),
18671 "active: on → off".to_owned(),
18672 )
18673 .await;
18674 }
18675 redirect_named_with_message_args(
18676 "rcms-admin:users",
18677 MsgLevel::Success,
18678 "User “{username}” deactivated.",
18679 &[("username", user.username.as_str())],
18680 &headers,
18681 )
18682}
18683
18684pub async fn users_bulk_submit(
18689 State(_state): State<super::AdminState>,
18690 tenant: Tenant,
18691 headers: HeaderMap,
18692 request: crate::security_log::LoginRequest,
18693 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18694 Form(pairs): Form<Vec<(String, String)>>,
18695) -> Result<Response, AdminError> {
18696 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18697 return Ok(redirect);
18698 }
18699 let mut ids: Vec<i64> = Vec::new();
18700 let mut action = String::new();
18701 for (k, v) in &pairs {
18702 match k.as_str() {
18703 "user_id" => {
18704 if let Ok(id) = v.parse::<i64>() {
18705 ids.push(id);
18706 }
18707 }
18708 "action" => action = v.clone(),
18709 _ => {}
18710 }
18711 }
18712 let target_active = match action.as_str() {
18713 "enable" => true,
18714 "disable" => false,
18715 _ => {
18716 return redirect_named_with_message(
18717 "rcms-admin:users",
18718 MsgLevel::Error,
18719 "Unknown bulk action.",
18720 &headers,
18721 );
18722 }
18723 };
18724 if ids.is_empty() {
18725 return redirect_named_with_message(
18726 "rcms-admin:users",
18727 MsgLevel::Info,
18728 "No users selected.",
18729 &headers,
18730 );
18731 }
18732 let me = session_user.as_ref().and_then(|u| u.id.get().copied());
18733 let mut changed = 0usize;
18734 let mut skipped_self = false;
18735 for id in ids {
18736 if !target_active && Some(id) == me {
18738 skipped_self = true;
18739 continue;
18740 }
18741 if let Some(mut user) = rustango::tenancy::auth::User::objects()
18742 .where_(rustango::tenancy::auth::User::id.eq(id))
18743 .first(tenant.pool())
18744 .await?
18745 {
18746 if user.active != target_active {
18747 user.active = target_active;
18748 user.save_pool(tenant.pool()).await?;
18749 changed += 1;
18750 let detail = if target_active { "active: off → on" } else { "active: on → off" };
18751 record_access_change(
18752 &tenant,
18753 session_user.as_ref(),
18754 &request,
18755 Some(&user),
18756 detail.to_owned(),
18757 )
18758 .await;
18759 }
18760 }
18761 }
18762 let verb = if target_active { "Enabled" } else { "Disabled" };
18763 let mut msg = format!("{verb} {changed} user(s).");
18764 if skipped_self {
18765 msg.push_str(" (Skipped your own account.)");
18766 }
18767 redirect_named_with_message("rcms-admin:users", MsgLevel::Success, &msg, &headers)
18768}
18769
18770pub async fn settings_page(
18775 State(state): State<super::AdminState>,
18776 tenant: Tenant,
18777 headers: HeaderMap,
18778 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18779) -> Result<Response, AdminError> {
18780 let locales: Vec<Locale> = Locale::objects()
18781 .order_by(&[("sort_order", false), ("code", false)])
18782 .fetch(tenant.pool())
18783 .await?;
18784 let media_count: Vec<Media> = Media::objects().fetch(tenant.pool()).await?;
18785 let themes: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
18788 .order_by(&[("name", false)])
18789 .fetch(tenant.pool())
18790 .await?;
18791 let theme_rows: Vec<serde_json::Value> = themes
18792 .iter()
18793 .map(|t| {
18794 serde_json::json!({
18795 "id": t.id.get().copied(),
18796 "name": t.name,
18797 "slug": t.slug,
18798 "is_admin_default": t.is_admin_default,
18799 "is_default": t.is_default,
18800 "color_bg": t.color_bg,
18801 "color_surface": t.color_surface,
18802 "color_text_primary": t.color_text_primary,
18803 "color_link": t.color_link,
18804 })
18805 })
18806 .collect();
18807 let mut ctx = Context::new();
18808 add_chrome(&mut ctx, &tenant, "settings", session_user.as_ref()).await;
18809 add_admin_theme(&mut ctx, tenant.pool()).await;
18810 ctx.insert("locales", &locales);
18811 ctx.insert("media_count", &media_count.len());
18812 ctx.insert("org_slug", &tenant.org.slug);
18813 ctx.insert("org_display_name", &tenant.org.display_name);
18814 ctx.insert("themes", &theme_rows);
18815
18816 if let Ok(Some(row)) = crate::site_setting::get(tenant.pool(), "branding").await {
18820 let logo_key = row
18821 .value_json
18822 .get("logo_storage_key")
18823 .and_then(|v| v.as_str())
18824 .unwrap_or("")
18825 .to_owned();
18826 let favicon_key = row
18827 .value_json
18828 .get("favicon_storage_key")
18829 .and_then(|v| v.as_str())
18830 .unwrap_or("")
18831 .to_owned();
18832 ctx.insert("branding_logo_filename", &logo_key);
18833 ctx.insert("branding_favicon_filename", &favicon_key);
18834 ctx.insert(
18835 "branding_site_name",
18836 row.value_json.get("site_name").and_then(|v| v.as_str()).unwrap_or(""),
18837 );
18838 }
18839
18840 render_with_csrf(&state, &headers, "rcms_admin/settings.html", &mut ctx)
18841}
18842
18843pub async fn settings_branding_submit(
18848 State(_state): State<super::AdminState>,
18849 tenant: Tenant,
18850 headers: HeaderMap,
18851 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
18852 mut multipart: axum::extract::Multipart,
18853) -> Result<Response, AdminError> {
18854 let mut logo_filename: Option<String> = None;
18855 let mut favicon_filename: Option<String> = None;
18856 let mut site_name: Option<String> = None;
18857
18858 while let Some(field) = multipart
18859 .next_field()
18860 .await
18861 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
18862 {
18863 let field_name = field.name().unwrap_or("").to_owned();
18864 let original = field.file_name().map(|s| s.to_owned());
18865 let bytes = field
18866 .bytes()
18867 .await
18868 .map_err(|e| AdminError::Upload(format!("read field {field_name}: {e}")))?;
18869 if field_name == "site_name" {
18871 site_name = Some(String::from_utf8_lossy(&bytes).trim().chars().take(120).collect());
18872 continue;
18873 }
18874 if bytes.is_empty() {
18875 continue;
18876 }
18877 let (slot, default_ext) = match field_name.as_str() {
18878 "logo" => (&mut logo_filename, "png"),
18879 "favicon" => (&mut favicon_filename, "ico"),
18880 _ => continue,
18881 };
18882 let safe_ext = original
18883 .as_deref()
18884 .and_then(|n| n.rsplit_once('.'))
18885 .map(|(_, ext)| ext)
18886 .filter(|ext| ext.len() <= 8 && ext.chars().all(|c| c.is_ascii_alphanumeric()))
18887 .map(str::to_ascii_lowercase)
18888 .unwrap_or_else(|| default_ext.to_owned());
18889 let storage_name = format!("{field_name}.{safe_ext}");
18890 crate::media_storage::disk_for(&tenant.org.slug)
18891 .save(
18892 &crate::media_storage::key(&tenant.org.slug, &format!("branding/{storage_name}")),
18893 &bytes,
18894 )
18895 .await
18896 .map_err(|e| AdminError::Upload(format!("write {field_name}: {e}")))?;
18897 *slot = Some(storage_name);
18898 }
18899
18900 let existing = crate::site_setting::get(tenant.pool(), "branding")
18903 .await
18904 .unwrap_or_default()
18905 .map(|r| r.value_json)
18906 .unwrap_or_else(|| serde_json::json!({}));
18907 let mut value = existing.as_object().cloned().unwrap_or_default();
18908 if let Some(name) = logo_filename {
18909 value.insert("logo_storage_key".to_owned(), serde_json::json!(name));
18910 }
18911 if let Some(name) = favicon_filename {
18912 value.insert("favicon_storage_key".to_owned(), serde_json::json!(name));
18913 }
18914 match site_name {
18915 Some(n) if n.is_empty() => {
18916 value.remove("site_name");
18917 }
18918 Some(n) => {
18919 value.insert("site_name".to_owned(), serde_json::json!(n));
18920 }
18921 None => {}
18922 }
18923 let _ =
18924 crate::site_setting::upsert(tenant.pool(), "branding", serde_json::Value::Object(value))
18925 .await?;
18926
18927 redirect_named_with_message(
18928 "rcms-admin:settings",
18929 MsgLevel::Success,
18930 "Branding saved. Reload to see the new logo / favicon.",
18931 &headers,
18932 )
18933}
18934
18935pub async fn settings_branding_serve_logo(headers: HeaderMap, tenant: Tenant) -> Response {
18939 serve_branding_asset(&headers, &tenant, "logo_storage_key").await
18940}
18941
18942pub async fn settings_branding_serve_favicon(headers: HeaderMap, tenant: Tenant) -> Response {
18944 serve_branding_asset(&headers, &tenant, "favicon_storage_key").await
18945}
18946
18947async fn serve_branding_asset(headers: &HeaderMap, tenant: &Tenant, slot: &str) -> Response {
18948 let setting = match crate::site_setting::get(tenant.pool(), "branding").await {
18949 Ok(Some(s)) => s,
18950 _ => {
18951 return (axum::http::StatusCode::NOT_FOUND, "no branding set").into_response();
18952 }
18953 };
18954 let storage_name = match setting.value_json.get(slot).and_then(|v| v.as_str()) {
18955 Some(s) if !s.is_empty() => s.to_owned(),
18956 _ => {
18957 return (axum::http::StatusCode::NOT_FOUND, "asset not set").into_response();
18958 }
18959 };
18960 if storage_name.contains('/') || storage_name.contains("..") {
18963 return (axum::http::StatusCode::BAD_REQUEST, "invalid storage name").into_response();
18964 }
18965 let bytes = match crate::media_storage::disk_for(&tenant.org.slug)
18966 .load(&crate::media_storage::key(
18967 &tenant.org.slug,
18968 &format!("branding/{storage_name}"),
18969 ))
18970 .await
18971 {
18972 Ok(b) => b,
18973 Err(_) => {
18974 return (axum::http::StatusCode::NOT_FOUND, "branding bytes missing").into_response();
18975 }
18976 };
18977 let mime = mime_guess::from_path(&storage_name)
18978 .first_or_octet_stream()
18979 .essence_str()
18980 .to_owned();
18981 revalidated_asset(headers, mime, bytes)
18987}
18988
18989fn revalidated_asset(headers: &HeaderMap, mime: String, bytes: Vec<u8>) -> Response {
18995 use sha2::{Digest, Sha256};
18996 let digest = Sha256::digest(&bytes);
18997 let mut etag = String::with_capacity(34);
18998 etag.push('"');
18999 for b in digest.iter().take(16) {
19000 use std::fmt::Write as _;
19001 let _ = write!(etag, "{b:02x}");
19002 }
19003 etag.push('"');
19004 let matches_etag = headers
19005 .get(axum::http::header::IF_NONE_MATCH)
19006 .and_then(|v| v.to_str().ok())
19007 .is_some_and(|inm| inm.split(',').any(|t| t.trim() == etag));
19008 if matches_etag {
19009 return (
19010 axum::http::StatusCode::NOT_MODIFIED,
19011 [
19012 (axum::http::header::ETAG, etag),
19013 (axum::http::header::CACHE_CONTROL, "no-cache".to_owned()),
19014 ],
19015 )
19016 .into_response();
19017 }
19018 (
19019 [
19020 (axum::http::header::CONTENT_TYPE, mime),
19021 (axum::http::header::CACHE_CONTROL, "no-cache".to_owned()),
19022 (axum::http::header::ETAG, etag),
19023 ],
19024 bytes,
19025 )
19026 .into_response()
19027}
19028
19029#[derive(Debug, Deserialize)]
19038pub struct ThemeSwitchForm {
19039 pub surface: String,
19040 pub theme_id: i64,
19041}
19042
19043pub async fn settings_theme_switch(
19044 State(_state): State<super::AdminState>,
19045 tenant: Tenant,
19046 headers: HeaderMap,
19047 Form(form): Form<ThemeSwitchForm>,
19048) -> Result<Response, AdminError> {
19049 if form.surface != "admin" && form.surface != "public" {
19054 return Err(AdminError::Validation(format!(
19055 "Unknown surface `{}` — expected `admin` or `public`.",
19056 form.surface
19057 )));
19058 }
19059 let target = crate::theme::Theme::objects()
19060 .where_(crate::theme::Theme::id.eq(form.theme_id))
19061 .first(tenant.pool())
19062 .await?
19063 .ok_or(AdminError::NotFound(form.theme_id))?;
19064
19065 let all_themes: Vec<crate::theme::Theme> =
19070 crate::theme::Theme::objects().fetch(tenant.pool()).await?;
19071 for mut t in all_themes {
19072 let target_id = target.id.get().copied().unwrap_or_default();
19073 let this_id = t.id.get().copied().unwrap_or_default();
19074 if form.surface == "admin" {
19075 t.is_admin_default = this_id == target_id;
19076 } else {
19077 t.is_default = this_id == target_id;
19078 }
19079 t.save_pool(tenant.pool()).await?;
19080 }
19081 if wants_json_response(&headers) && form.surface == "admin" {
19090 let target_id = target.id.get().copied().unwrap_or_default();
19091 let brand_colors: Vec<crate::theme::BrandColor> = crate::theme::BrandColor::objects()
19092 .where_(crate::theme::BrandColor::theme_id.eq(target_id))
19093 .order_by(&[("sort_order", false)])
19094 .fetch(tenant.pool())
19095 .await
19096 .unwrap_or_default();
19097 let css = crate::theme::emit_css(&target, &brand_colors);
19098 return Ok(Json(serde_json::json!({
19099 "ok": true,
19100 "id": target_id,
19101 "slug": target.slug,
19102 "name": target.name,
19103 "default_mode": target.default_mode,
19104 "css": css,
19105 "message": format!("Admin theme switched to “{}”.", target.name),
19106 }))
19107 .into_response());
19108 }
19109 let redirect_target = if form.surface == "admin" {
19113 "rcms-admin:account"
19114 } else {
19115 "rcms-admin:settings"
19116 };
19117 let theme_flash = if form.surface == "admin" {
19118 "Admin theme switched to “{name}”."
19119 } else {
19120 "Public theme switched to “{name}”."
19121 };
19122 redirect_named_with_message_args(
19123 redirect_target,
19124 MsgLevel::Success,
19125 theme_flash,
19126 &[("name", target.name.as_str())],
19127 &headers,
19128 )
19129}
19130
19131fn wants_json_response(headers: &HeaderMap) -> bool {
19137 let accept = headers
19138 .get(header::ACCEPT)
19139 .and_then(|v| v.to_str().ok())
19140 .unwrap_or("");
19141 if accept.contains("application/json") {
19142 return true;
19143 }
19144 headers
19145 .get("x-requested-with")
19146 .and_then(|v| v.to_str().ok())
19147 .is_some_and(|v| v.eq_ignore_ascii_case("XMLHttpRequest"))
19148}
19149
19150#[derive(Debug, Deserialize)]
19157pub struct RedirectForm {
19158 pub from_path: String,
19159 pub to_path: String,
19160 #[serde(default)]
19163 pub is_permanent: Option<String>,
19164 #[serde(default)]
19165 pub note: Option<String>,
19166 #[serde(default)]
19169 pub overrides_live: Option<String>,
19170 #[serde(default)]
19172 pub from_page_id: Option<String>,
19173 #[serde(default)]
19174 pub to_page_id: Option<String>,
19175}
19176
19177impl RedirectForm {
19178 fn parsed_permanent(&self) -> bool {
19179 self.is_permanent.is_some()
19180 }
19181 fn parsed_overrides_live(&self) -> bool {
19182 self.overrides_live.is_some()
19183 }
19184 fn parsed_page_id(raw: &Option<String>) -> Option<i64> {
19185 raw.as_deref()
19186 .and_then(|s| s.trim().parse::<i64>().ok())
19187 .filter(|id| *id > 0)
19188 }
19189 fn parsed_from_page_id(&self) -> Option<i64> {
19190 Self::parsed_page_id(&self.from_page_id)
19191 }
19192 fn parsed_to_page_id(&self) -> Option<i64> {
19193 Self::parsed_page_id(&self.to_page_id)
19194 }
19195}
19196
19197async fn redirect_form_paths(
19204 pool: &rustango::sql::Pool,
19205 form: &RedirectForm,
19206) -> Result<(String, String), AdminError> {
19207 let mut from = form.from_path.trim().to_owned();
19208 let mut to = form.to_path.trim().to_owned();
19209 if let Some(pid) = form.parsed_from_page_id() {
19210 if let Some(p) = Page::objects().where_(Page::id.eq(pid)).first(pool).await? {
19211 from = p.url_path;
19212 }
19213 }
19214 if let Some(pid) = form.parsed_to_page_id() {
19215 if let Some(p) = Page::objects().where_(Page::id.eq(pid)).first(pool).await? {
19216 to = p.url_path;
19217 }
19218 }
19219 Ok((from, to))
19220}
19221
19222async fn redirect_is_shadowed(tenant: &Tenant, from_path: &str, overrides_live: bool) -> bool {
19227 if overrides_live || crate::redirect::is_wildcard(from_path) {
19228 return false;
19231 }
19232 matches!(
19233 crate::resolver::resolve_path(tenant, from_path).await,
19234 Ok(Some(_))
19235 )
19236}
19237
19238fn redirect_pattern_error(from_path: &str, to_path: &str) -> Option<&'static str> {
19242 if from_path.matches('*').count() > 1 {
19243 Some("The from-path may contain at most one “*” wildcard (e.g. /old/* or */feed).")
19244 } else if crate::redirect::redirect_loops(from_path, to_path) {
19245 Some("That redirect points back at its own from-path, so visitors would loop.")
19246 } else {
19247 None
19248 }
19249}
19250
19251#[derive(Debug, Deserialize, Default)]
19254pub struct RedirectListQuery {
19255 #[serde(default)]
19256 pub q: Option<String>,
19257 #[serde(default)]
19259 pub filter: Option<String>,
19260 #[serde(default)]
19262 pub sort: Option<String>,
19263 #[serde(default)]
19265 pub dir: Option<String>,
19266 #[serde(default)]
19267 pub page: Option<i64>,
19268}
19269
19270const REDIRECTS_PER_PAGE: usize = 50;
19271
19272pub async fn redirect_list(
19273 State(state): State<super::AdminState>,
19274 tenant: Tenant,
19275 headers: HeaderMap,
19276 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19277 Query(q): Query<RedirectListQuery>,
19278) -> Result<Response, AdminError> {
19279 let mut all: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
19283 .fetch(tenant.pool())
19284 .await?;
19285 let now = chrono::Utc::now();
19286
19287 let needle = q.q.as_deref().unwrap_or("").trim().to_lowercase();
19288 if !needle.is_empty() {
19289 all.retain(|r| {
19290 r.from_path.to_lowercase().contains(&needle)
19291 || r.to_path.to_lowercase().contains(&needle)
19292 || r.note.to_lowercase().contains(&needle)
19293 });
19294 }
19295
19296 let count_all = all.len();
19298 let count_active = all.iter().filter(|r| r.is_active).count();
19299 let count_disabled = all.iter().filter(|r| !r.is_active).count();
19300 let count_stale = all
19301 .iter()
19302 .filter(|r| matches!(crate::redirect::staleness(r, now), "stale" | "unused"))
19303 .count();
19304
19305 let filter = q.filter.as_deref().unwrap_or("all");
19306 all.retain(|r| match filter {
19307 "active" => r.is_active,
19308 "disabled" => !r.is_active,
19309 "stale" => matches!(crate::redirect::staleness(r, now), "stale" | "unused"),
19310 _ => true,
19311 });
19312
19313 let sort = q.sort.as_deref().unwrap_or("from");
19314 let desc = q.dir.as_deref() == Some("desc");
19315 all.sort_by(|a, b| {
19316 let o = match sort {
19317 "last_used" => a.last_hit_at.cmp(&b.last_hit_at),
19318 "created" => a.created_at.get().cmp(&b.created_at.get()),
19319 "hits" => a.hit_count.cmp(&b.hit_count),
19320 "staleness" => {
19321 let rank = |r: &crate::redirect::Redirect| match crate::redirect::staleness(r, now)
19322 {
19323 "disabled" => 0u8,
19324 "unused" => 1,
19325 "stale" => 2,
19326 _ => 3,
19327 };
19328 rank(a).cmp(&rank(b))
19329 }
19330 _ => a.from_path.cmp(&b.from_path),
19331 };
19332 if desc {
19333 o.reverse()
19334 } else {
19335 o
19336 }
19337 });
19338
19339 let total = all.len();
19340 let total_pages = total.div_ceil(REDIRECTS_PER_PAGE).max(1);
19341 let page = q.page.unwrap_or(1).clamp(1, total_pages as i64) as usize;
19342 let start = (page - 1) * REDIRECTS_PER_PAGE;
19343 let items: Vec<crate::redirect::Redirect> = all
19344 .into_iter()
19345 .skip(start)
19346 .take(REDIRECTS_PER_PAGE)
19347 .collect();
19348
19349 let mut ctx = Context::new();
19350 add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19351 add_admin_theme(&mut ctx, tenant.pool()).await;
19352 ctx.insert("items", &items);
19353 ctx.insert("q", &needle);
19354 ctx.insert("filter", filter);
19355 ctx.insert("sort", sort);
19356 ctx.insert("dir", if desc { "desc" } else { "asc" });
19357 ctx.insert("current_page", &page);
19358 ctx.insert("total_pages", &total_pages);
19359 ctx.insert("total", &total);
19360 ctx.insert("count_all", &count_all);
19361 ctx.insert("count_active", &count_active);
19362 ctx.insert("count_disabled", &count_disabled);
19363 ctx.insert("count_stale", &count_stale);
19364 render_with_csrf(&state, &headers, "rcms_admin/redirect_list.html", &mut ctx)
19365}
19366
19367pub async fn redirect_new_form(
19368 State(state): State<super::AdminState>,
19369 tenant: Tenant,
19370 headers: HeaderMap,
19371 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19372) -> Result<Response, AdminError> {
19373 let mut ctx = Context::new();
19374 add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19375 add_admin_theme(&mut ctx, tenant.pool()).await;
19376 ctx.insert("mode", "new");
19377 ctx.insert(
19378 "redirect",
19379 &serde_json::json!({
19380 "from_path": "",
19381 "to_path": "",
19382 "is_permanent": true,
19383 "note": "",
19384 "hit_count": 0,
19385 "overrides_live": false,
19386 "from_page_id": null,
19387 "to_page_id": null,
19388 }),
19389 );
19390 render_with_csrf(&state, &headers, "rcms_admin/redirect_form.html", &mut ctx)
19391}
19392
19393pub async fn redirect_new_submit(
19394 State(_state): State<super::AdminState>,
19395 tenant: Tenant,
19396 headers: HeaderMap,
19397 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19398 Form(form): Form<RedirectForm>,
19399) -> Result<Response, AdminError> {
19400 use rustango::sql::Auto;
19401 let (from, to) = redirect_form_paths(tenant.pool(), &form).await?;
19402 if from.is_empty() || to.is_empty() {
19403 return redirect_named_with_message(
19404 "rcms-admin:redirects:list",
19405 MsgLevel::Error,
19406 "From-path and to-path are both required.",
19407 &headers,
19408 );
19409 }
19410 if let Some(msg) = redirect_pattern_error(&from, &to) {
19411 return redirect_named_with_message(
19412 "rcms-admin:redirects:list",
19413 MsgLevel::Error,
19414 msg,
19415 &headers,
19416 );
19417 }
19418 let overrides_live = form.parsed_overrides_live();
19419 let is_permanent = form.parsed_permanent();
19420 let from_page_id = form.parsed_from_page_id();
19421 let to_page_id = form.parsed_to_page_id();
19422 let mut row = crate::redirect::Redirect {
19423 id: Auto::Unset,
19424 from_path: from,
19425 to_path: to,
19426 is_permanent,
19427 note: form.note.unwrap_or_default().trim().to_owned(),
19428 hit_count: 0,
19429 overrides_live,
19430 from_page_id,
19431 to_page_id,
19432 is_active: true,
19433 disabled_reason: String::new(),
19434 last_hit_at: None,
19435 created_at: Auto::Unset,
19436 updated_at: Auto::Unset,
19437 };
19438 row.insert_pool(tenant.pool()).await?;
19439 redirect_save_response(&tenant, &row, overrides_live, true, &headers).await
19440}
19441
19442async fn redirect_save_response(
19448 tenant: &Tenant,
19449 row: &crate::redirect::Redirect,
19450 overrides_live: bool,
19451 is_new: bool,
19452 headers: &HeaderMap,
19453) -> Result<Response, AdminError> {
19454 let args = &[
19455 ("from", row.from_path.as_str()),
19456 ("to", row.to_path.as_str()),
19457 ];
19458 if overrides_live && crate::redirect::is_wildcard(&row.from_path) {
19459 let key = if is_new {
19460 "Added redirect {from} → {to} — heads up: a wildcard override can shadow many live pages under this pattern. Double-check the pattern."
19461 } else {
19462 "Saved redirect {from} → {to} — heads up: a wildcard override can shadow many live pages under this pattern. Double-check the pattern."
19463 };
19464 return redirect_named_with_message_args(
19465 "rcms-admin:redirects:list",
19466 MsgLevel::Warning,
19467 key,
19468 args,
19469 headers,
19470 );
19471 }
19472 if redirect_is_shadowed(tenant, &row.from_path, overrides_live).await {
19473 let key = if is_new {
19474 "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”)."
19475 } else {
19476 "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”)."
19477 };
19478 return redirect_named_with_message_args(
19479 "rcms-admin:redirects:list",
19480 MsgLevel::Warning,
19481 key,
19482 args,
19483 headers,
19484 );
19485 }
19486 let key = if is_new {
19487 "Added redirect {from} → {to}."
19488 } else {
19489 "Saved redirect {from} → {to}."
19490 };
19491 redirect_named_with_message_args(
19492 "rcms-admin:redirects:list",
19493 MsgLevel::Success,
19494 key,
19495 args,
19496 headers,
19497 )
19498}
19499
19500#[derive(Debug)]
19506struct SnippetImportRow {
19507 slug: String,
19508 title: String,
19509 body_markdown: String,
19510 folder_path: String,
19511 data: serde_json::Map<String, serde_json::Value>,
19512}
19513
19514fn parse_snippet_csv(text: &str) -> Vec<SnippetImportRow> {
19515 let delimiter = if text.contains('\t') { '\t' } else { ',' };
19518 let mut lines = text.lines();
19519 let header = match lines.next() {
19520 Some(h) => h,
19521 None => return Vec::new(),
19522 };
19523 let cols: Vec<String> = header
19524 .split(delimiter)
19525 .map(|s| s.trim().to_ascii_lowercase())
19526 .collect();
19527 let slug_idx = cols.iter().position(|c| c == "slug" || c == "key");
19529 let title_idx = cols.iter().position(|c| c == "title" || c == "name");
19530 let (Some(slug_idx), Some(title_idx)) = (slug_idx, title_idx) else {
19531 return Vec::new();
19532 };
19533 let body_idx = cols
19534 .iter()
19535 .position(|c| c == "body_markdown" || c == "body" || c == "content");
19536 let folder_idx = cols
19537 .iter()
19538 .position(|c| c == "folder_path" || c == "folder" || c == "path");
19539 let mut out = Vec::new();
19540 for raw in lines {
19541 let trimmed = raw.trim();
19542 if trimmed.is_empty() {
19543 continue;
19544 }
19545 let parts: Vec<&str> = trimmed.split(delimiter).map(str::trim).collect();
19546 let slug = parts.get(slug_idx).copied().unwrap_or("");
19547 let title = parts.get(title_idx).copied().unwrap_or("");
19548 if slug.is_empty() || title.is_empty() {
19549 continue;
19550 }
19551 let body_markdown = body_idx
19552 .and_then(|i| parts.get(i))
19553 .copied()
19554 .unwrap_or("")
19555 .to_owned();
19556 let folder_path = folder_idx
19557 .and_then(|i| parts.get(i))
19558 .copied()
19559 .unwrap_or("")
19560 .to_owned();
19561 let mut data = serde_json::Map::new();
19563 for (i, col) in cols.iter().enumerate() {
19564 if Some(i) == Some(slug_idx)
19565 || Some(i) == Some(title_idx)
19566 || Some(i) == body_idx
19567 || Some(i) == folder_idx
19568 {
19569 continue;
19570 }
19571 if col.is_empty() {
19572 continue;
19573 }
19574 let v = parts.get(i).copied().unwrap_or("");
19575 if !v.is_empty() {
19576 data.insert(col.clone(), serde_json::Value::String(v.to_owned()));
19577 }
19578 }
19579 out.push(SnippetImportRow {
19580 slug: slug.to_owned(),
19581 title: title.to_owned(),
19582 body_markdown,
19583 folder_path: crate::snippet::normalize_folder(&folder_path),
19584 data,
19585 });
19586 }
19587 out
19588}
19589
19590pub async fn snippet_import_form(
19592 State(state): State<super::AdminState>,
19593 tenant: Tenant,
19594 headers: HeaderMap,
19595 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19596 Path(type_name): Path<String>,
19597) -> Result<Response, AdminError> {
19598 let mut ctx = Context::new();
19599 add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
19600 add_admin_theme(&mut ctx, tenant.pool()).await;
19601 ctx.insert("type_name", &type_name);
19602 render_with_csrf(&state, &headers, "rcms_admin/snippet_import.html", &mut ctx)
19603}
19604
19605pub async fn snippet_import_submit(
19608 State(_state): State<super::AdminState>,
19609 tenant: Tenant,
19610 headers: HeaderMap,
19611 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19612 Path(type_name): Path<String>,
19613 mut multipart: axum::extract::Multipart,
19614) -> Result<Response, AdminError> {
19615 use rustango::sql::Auto;
19616 let mut bytes: Vec<u8> = Vec::new();
19617 let mut filename = String::new();
19618 while let Some(field) = multipart
19619 .next_field()
19620 .await
19621 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
19622 {
19623 if field.name().unwrap_or("") == "file" {
19624 if let Some(name) = field.file_name() {
19625 filename = name.to_owned();
19626 }
19627 bytes = field
19628 .bytes()
19629 .await
19630 .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
19631 .to_vec();
19632 } else {
19633 let _ = field.bytes().await;
19634 }
19635 }
19636 if bytes.is_empty() {
19637 return redirect_named_with_message(
19638 "rcms-admin:library:list",
19639 MsgLevel::Error,
19640 "No file uploaded.",
19641 &headers,
19642 );
19643 }
19644 let text = String::from_utf8_lossy(&bytes);
19645 let rows = parse_snippet_csv(&text);
19646 let total = rows.len();
19647 if total == 0 {
19648 return redirect_named_with_message(
19649 "rcms-admin:library:list",
19650 MsgLevel::Error,
19651 "Imported 0 snippets — CSV must have a header row with `slug` + `title` columns.",
19652 &headers,
19653 );
19654 }
19655 let mut inserted = 0usize;
19656 let mut skipped = 0usize;
19657 let _ = filename; for row in rows {
19659 let mut snippet = crate::snippet::Snippet {
19660 id: Auto::Unset,
19661 type_name: type_name.clone(),
19662 folder_path: row.folder_path,
19663 slug: row.slug,
19664 title: row.title,
19665 body_markdown: row.body_markdown,
19666 data: serde_json::Value::Object(row.data),
19667 created_at: Auto::Unset,
19668 updated_at: Auto::Unset,
19669 };
19670 match snippet.insert_pool(tenant.pool()).await {
19671 Ok(_) => inserted += 1,
19672 Err(_) => skipped += 1,
19673 }
19674 }
19675 let inserted_str = inserted.to_string();
19676 let total_str = total.to_string();
19677 let skipped_str = skipped.to_string();
19678 redirect_named_with_message_args(
19679 "rcms-admin:library:list",
19680 MsgLevel::Success,
19681 "Imported {inserted}/{total} snippets ({skipped} skipped — likely duplicate slugs).",
19682 &[
19683 ("inserted", inserted_str.as_str()),
19684 ("total", total_str.as_str()),
19685 ("skipped", skipped_str.as_str()),
19686 ],
19687 &headers,
19688 )
19689}
19690
19691pub async fn redirect_import_form(
19693 State(state): State<super::AdminState>,
19694 tenant: Tenant,
19695 headers: HeaderMap,
19696 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19697) -> Result<Response, AdminError> {
19698 let mut ctx = Context::new();
19699 add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19700 add_admin_theme(&mut ctx, tenant.pool()).await;
19701 render_with_csrf(
19702 &state,
19703 &headers,
19704 "rcms_admin/redirect_import.html",
19705 &mut ctx,
19706 )
19707}
19708
19709#[derive(Debug)]
19713struct RedirectImportRow {
19714 from_path: String,
19715 to_path: String,
19716 is_permanent: bool,
19717}
19718
19719fn parse_redirect_csv(text: &str) -> Vec<RedirectImportRow> {
19720 let delimiter = if text.contains('\t') { '\t' } else { ',' };
19725 let mut out = Vec::new();
19726 for (lineno, raw) in text.lines().enumerate() {
19727 let trimmed = raw.trim();
19728 if trimmed.is_empty() {
19729 continue;
19730 }
19731 let parts: Vec<&str> = trimmed.split(delimiter).map(str::trim).collect();
19732 if lineno == 0 {
19735 let h0 = parts.first().copied().unwrap_or("").to_ascii_lowercase();
19736 if h0 == "from_path" || h0 == "from" || h0 == "old" || h0 == "source" {
19737 continue;
19738 }
19739 }
19740 if parts.len() < 2 {
19741 continue;
19742 }
19743 let from = parts[0];
19744 let to = parts[1];
19745 if from.is_empty() || to.is_empty() {
19746 continue;
19747 }
19748 let is_permanent = parts
19749 .get(2)
19750 .map(|s| {
19751 let v = s.to_ascii_lowercase();
19752 !matches!(v.as_str(), "false" | "0" | "302" | "no")
19753 })
19754 .unwrap_or(true);
19755 out.push(RedirectImportRow {
19756 from_path: from.to_owned(),
19757 to_path: to.to_owned(),
19758 is_permanent,
19759 });
19760 }
19761 out
19762}
19763
19764fn redirects_csv(items: &[crate::redirect::Redirect]) -> String {
19768 let mut out = String::from("from_path,to_path,is_permanent\n");
19769 for r in items {
19770 out.push_str(&csv_escape(&r.from_path));
19771 out.push(',');
19772 out.push_str(&csv_escape(&r.to_path));
19773 out.push(',');
19774 out.push_str(if r.is_permanent { "301" } else { "302" });
19775 out.push('\n');
19776 }
19777 out
19778}
19779
19780pub async fn redirect_export_csv(
19783 State(_state): State<super::AdminState>,
19784 tenant: Tenant,
19785 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19786) -> Result<Response, AdminError> {
19787 let items: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
19788 .order_by(&[("from_path", false)])
19789 .fetch(tenant.pool())
19790 .await?;
19791 let body = redirects_csv(&items);
19792 let filename = format!("redirects-{}.csv", chrono::Utc::now().format("%Y%m%d"));
19793 let mut response = ([(header::CONTENT_TYPE, "text/csv; charset=utf-8")], body).into_response();
19794 if let Ok(v) = HeaderValue::from_str(&format!("attachment; filename=\"{filename}\"")) {
19795 response
19796 .headers_mut()
19797 .insert(header::CONTENT_DISPOSITION, v);
19798 }
19799 Ok(response)
19800}
19801
19802#[cfg(test)]
19803mod user_email_column_tests {
19804 use super::user_email;
19805
19806 fn user(email: Option<&str>, data: serde_json::Value) -> rustango::tenancy::auth::User {
19807 rustango::tenancy::auth::User {
19808 id: rustango::sql::Auto::Set(1),
19809 username: "u".into(),
19810 password_hash: String::new(),
19811 email: email.map(ToOwned::to_owned),
19812 is_superuser: false,
19813 active: true,
19814 created_at: chrono::Utc::now(),
19815 data,
19816 password_changed_at: None,
19817 sessions_revoked_at: None,
19818 }
19819 }
19820
19821 #[test]
19822 fn column_first_then_legacy_data_bag() {
19823 assert_eq!(user_email(&user(Some("a@x.example"), serde_json::json!({}))), "a@x.example");
19825 assert_eq!(user_email(&user(None, serde_json::json!({"email": "b@x.example"}))), "b@x.example");
19827 assert_eq!(
19828 user_email(&user(Some("a@x.example"), serde_json::json!({"email": "old@x.example"}))),
19829 "a@x.example"
19830 );
19831 assert_eq!(user_email(&user(Some(" "), serde_json::json!({}))), "");
19832 }
19833}
19834
19835#[cfg(test)]
19836mod translation_canonical_html_tests {
19837 use super::translation_canonical_html;
19838
19839 #[test]
19840 fn rich_text_is_sanitized_html_other_kinds_empty() {
19841 let html = translation_canonical_html("richtext", "<p>A jar</p><script>x()</script>");
19842 assert_eq!(html, "<p>A jar</p>");
19843 assert_eq!(translation_canonical_html("richtext", " "), "");
19844 assert_eq!(translation_canonical_html("textarea", "<p>A jar</p>"), "");
19845 assert_eq!(translation_canonical_html("text", "Moon jar"), "");
19846 }
19847}
19848
19849#[cfg(test)]
19850mod user_email_tests {
19851 use super::validate_optional_email;
19852
19853 #[test]
19854 fn accepts_valid_and_empty() {
19855 assert_eq!(validate_optional_email(Some("a@b.com")).unwrap(), "a@b.com");
19856 assert_eq!(
19857 validate_optional_email(Some(" a@b.com ")).unwrap(),
19858 "a@b.com"
19859 ); assert_eq!(validate_optional_email(None).unwrap(), ""); assert_eq!(validate_optional_email(Some(" ")).unwrap(), ""); }
19863
19864 #[test]
19865 fn rejects_malformed() {
19866 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()); }
19872}
19873
19874#[cfg(test)]
19875mod copy_to_locale_tests {
19876 use super::copy_translatable_fields;
19877
19878 #[test]
19879 fn selects_nonempty_canonical_fields() {
19880 let out = copy_translatable_fields("Home", "", " Welcome ");
19881 assert_eq!(
19883 out,
19884 vec![
19885 ("title", "Home".to_owned()),
19886 ("seo_description", " Welcome ".to_owned()),
19887 ]
19888 );
19889 }
19890
19891 #[test]
19892 fn all_empty_yields_nothing_to_seed() {
19893 assert!(copy_translatable_fields("", " ", "").is_empty());
19894 }
19895}
19896
19897#[cfg(test)]
19898mod redirect_csv_tests {
19899 use super::*;
19900 use rustango::sql::Auto;
19901
19902 fn row(from: &str, to: &str, permanent: bool) -> crate::redirect::Redirect {
19903 crate::redirect::Redirect {
19904 id: Auto::Unset,
19905 from_path: from.to_owned(),
19906 to_path: to.to_owned(),
19907 is_permanent: permanent,
19908 note: String::new(),
19909 hit_count: 0,
19910 overrides_live: false,
19911 from_page_id: None,
19912 to_page_id: None,
19913 is_active: true,
19914 disabled_reason: String::new(),
19915 last_hit_at: None,
19916 created_at: Auto::Unset,
19917 updated_at: Auto::Unset,
19918 }
19919 }
19920
19921 #[test]
19922 fn redirects_csv_header_and_301_302_mapping() {
19923 let csv = redirects_csv(&[row("/old", "/new", true), row("/tmp", "/dst", false)]);
19924 let mut lines = csv.lines();
19925 assert_eq!(lines.next(), Some("from_path,to_path,is_permanent"));
19926 assert_eq!(lines.next(), Some("/old,/new,301"));
19927 assert_eq!(lines.next(), Some("/tmp,/dst,302"));
19928 assert_eq!(lines.next(), None);
19929 }
19930
19931 #[test]
19932 fn redirects_csv_empty_is_header_only() {
19933 assert_eq!(redirects_csv(&[]), "from_path,to_path,is_permanent\n");
19934 }
19935}
19936
19937pub async fn redirect_import_submit(
19940 State(_state): State<super::AdminState>,
19941 tenant: Tenant,
19942 headers: HeaderMap,
19943 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19944 mut multipart: axum::extract::Multipart,
19945) -> Result<Response, AdminError> {
19946 use rustango::sql::Auto;
19947 let mut bytes: Vec<u8> = Vec::new();
19948 let mut filename = String::new();
19949 while let Some(field) = multipart
19950 .next_field()
19951 .await
19952 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
19953 {
19954 if field.name().unwrap_or("") == "file" {
19955 if let Some(name) = field.file_name() {
19956 filename = name.to_owned();
19957 }
19958 bytes = field
19959 .bytes()
19960 .await
19961 .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
19962 .to_vec();
19963 } else {
19964 let _ = field.bytes().await;
19965 }
19966 }
19967 if bytes.is_empty() {
19968 return redirect_named_with_message(
19969 "rcms-admin:redirects:list",
19970 MsgLevel::Error,
19971 "No file uploaded.",
19972 &headers,
19973 );
19974 }
19975 let text = String::from_utf8_lossy(&bytes);
19976 let rows = parse_redirect_csv(&text);
19977 let total = rows.len();
19978 let mut inserted = 0usize;
19979 let mut skipped = 0usize;
19980 for row in rows {
19981 if redirect_pattern_error(&row.from_path, &row.to_path).is_some() {
19982 skipped += 1;
19983 continue;
19984 }
19985 let mut redirect = crate::redirect::Redirect {
19986 id: Auto::Unset,
19987 from_path: row.from_path,
19988 to_path: row.to_path,
19989 is_permanent: row.is_permanent,
19990 note: format!("Imported from {filename}"),
19991 hit_count: 0,
19992 overrides_live: false,
19993 from_page_id: None,
19994 to_page_id: None,
19995 is_active: true,
19996 disabled_reason: String::new(),
19997 last_hit_at: None,
19998 created_at: Auto::Unset,
19999 updated_at: Auto::Unset,
20000 };
20001 match redirect.insert_pool(tenant.pool()).await {
20002 Ok(_) => inserted += 1,
20003 Err(_) => skipped += 1,
20004 }
20005 }
20006 let inserted_str = inserted.to_string();
20007 let total_str = total.to_string();
20008 let skipped_str = skipped.to_string();
20009 redirect_named_with_message_args(
20010 "rcms-admin:redirects:list",
20011 MsgLevel::Success,
20012 "Imported {inserted}/{total} redirects ({skipped} skipped — likely duplicates).",
20013 &[
20014 ("inserted", inserted_str.as_str()),
20015 ("total", total_str.as_str()),
20016 ("skipped", skipped_str.as_str()),
20017 ],
20018 &headers,
20019 )
20020}
20021
20022pub async fn redirect_edit_form(
20023 State(state): State<super::AdminState>,
20024 tenant: Tenant,
20025 headers: HeaderMap,
20026 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20027 Path(id): Path<i64>,
20028) -> Result<Response, AdminError> {
20029 let row = crate::redirect::Redirect::objects()
20030 .where_(crate::redirect::Redirect::id.eq(id))
20031 .first(tenant.pool())
20032 .await?
20033 .ok_or(AdminError::NotFound(id))?;
20034 let mut ctx = Context::new();
20035 add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
20036 add_admin_theme(&mut ctx, tenant.pool()).await;
20037 ctx.insert("mode", "edit");
20038 ctx.insert("redirect", &row);
20039 render_with_csrf(&state, &headers, "rcms_admin/redirect_form.html", &mut ctx)
20040}
20041
20042pub async fn redirect_edit_submit(
20043 State(_state): State<super::AdminState>,
20044 tenant: Tenant,
20045 headers: HeaderMap,
20046 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
20047 Path(id): Path<i64>,
20048 Form(form): Form<RedirectForm>,
20049) -> Result<Response, AdminError> {
20050 let mut row = crate::redirect::Redirect::objects()
20051 .where_(crate::redirect::Redirect::id.eq(id))
20052 .first(tenant.pool())
20053 .await?
20054 .ok_or(AdminError::NotFound(id))?;
20055 let (from, to) = redirect_form_paths(tenant.pool(), &form).await?;
20056 if from.is_empty() || to.is_empty() {
20057 return redirect_named_with_message(
20058 "rcms-admin:redirects:list",
20059 MsgLevel::Error,
20060 "From-path and to-path are both required.",
20061 &headers,
20062 );
20063 }
20064 if let Some(msg) = redirect_pattern_error(&from, &to) {
20065 return redirect_named_with_message(
20066 "rcms-admin:redirects:list",
20067 MsgLevel::Error,
20068 msg,
20069 &headers,
20070 );
20071 }
20072 row.from_path = from;
20073 row.to_path = to;
20074 row.is_permanent = form.parsed_permanent();
20075 row.overrides_live = form.parsed_overrides_live();
20076 row.from_page_id = form.parsed_from_page_id();
20077 row.to_page_id = form.parsed_to_page_id();
20078 row.note = form.note.unwrap_or_default().trim().to_owned();
20079 row.save_pool(tenant.pool()).await?;
20080 let overrides_live = row.overrides_live;
20081 redirect_save_response(&tenant, &row, overrides_live, false, &headers).await
20082}
20083
20084pub async fn redirect_enable_submit(
20087 State(_state): State<super::AdminState>,
20088 tenant: Tenant,
20089 headers: HeaderMap,
20090 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
20091 Path(id): Path<i64>,
20092) -> Result<Response, AdminError> {
20093 let mut row = crate::redirect::Redirect::objects()
20094 .where_(crate::redirect::Redirect::id.eq(id))
20095 .first(tenant.pool())
20096 .await?
20097 .ok_or(AdminError::NotFound(id))?;
20098 row.is_active = true;
20099 row.disabled_reason = String::new();
20100 row.save_pool(tenant.pool()).await?;
20101 redirect_named_with_message_args(
20102 "rcms-admin:redirects:list",
20103 MsgLevel::Success,
20104 "Re-enabled redirect {from} → {to}.",
20105 &[
20106 ("from", row.from_path.as_str()),
20107 ("to", row.to_path.as_str()),
20108 ],
20109 &headers,
20110 )
20111}
20112
20113pub async fn redirect_delete_submit(
20114 State(_state): State<super::AdminState>,
20115 tenant: Tenant,
20116 headers: HeaderMap,
20117 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
20118 Path(id): Path<i64>,
20119) -> Result<Response, AdminError> {
20120 let row = crate::redirect::Redirect::objects()
20121 .where_(crate::redirect::Redirect::id.eq(id))
20122 .first(tenant.pool())
20123 .await?
20124 .ok_or(AdminError::NotFound(id))?;
20125 let label = format!("{} → {}", row.from_path, row.to_path);
20126 row.delete_pool(tenant.pool()).await?;
20127 redirect_named_with_message_args(
20128 "rcms-admin:redirects:list",
20129 MsgLevel::Success,
20130 "Deleted redirect {label}.",
20131 &[("label", label.as_str())],
20132 &headers,
20133 )
20134}
20135
20136pub(crate) fn creatable_types(all: &[PageType]) -> Vec<PageType> {
20146 all.iter()
20147 .filter(|t| {
20148 find_handler(&t.type_name)
20149 .map(|h| h.is_creatable())
20150 .unwrap_or(t.is_creatable)
20151 })
20152 .cloned()
20153 .collect()
20154}
20155
20156pub(crate) fn allowed_root_types(all: &[PageType]) -> Vec<PageType> {
20165 creatable_types(all)
20166 .into_iter()
20167 .filter(|t| t.allowed_parents().is_empty())
20168 .collect()
20169}
20170
20171pub(crate) fn allowed_children_for(parent: &Page, all: &[PageType]) -> Vec<PageType> {
20176 let parent_row = all
20177 .iter()
20178 .find(|t| t.id.get().copied() == Some(parent.page_type_id));
20179 let parent_type_name = parent_row.map(|t| t.type_name.clone()).unwrap_or_default();
20180 let parent_allowed_children = parent_row.map(PageType::allowed_children).unwrap_or_default();
20182
20183 creatable_types(all)
20184 .into_iter()
20185 .filter(|cand| {
20186 if !parent_allowed_children.is_empty()
20188 && !parent_allowed_children.iter().any(|t| t == &cand.type_name)
20189 {
20190 return false;
20191 }
20192 let allowed_parents = cand.allowed_parents();
20194 allowed_parents.is_empty() || allowed_parents.iter().any(|p| *p == parent_type_name)
20195 })
20196 .collect()
20197}
20198
20199fn empty_page_form_values() -> serde_json::Value {
20202 serde_json::json!({
20203 "title": "",
20204 "slug": "",
20205 "page_type_id": 0,
20206 "status": "draft",
20207 "seo_title": "",
20208 "seo_description": "",
20209 "robots_index": true,
20210 "sitemap_priority": 0.5,
20211 "show_in_menus": true,
20212 "go_live_at": serde_json::Value::Null,
20213 "expire_at": serde_json::Value::Null,
20214 "og_title": "",
20215 "og_description": "",
20216 "og_image_media_id": serde_json::Value::Null,
20217 "twitter_card": "summary_large_image",
20218 })
20219}
20220
20221pub async fn cms_logout_submit(
20248 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20249 tenant: Result<Tenant, rustango::extractors::TenantRejection>,
20250 request: crate::security_log::LoginRequest,
20251) -> Response {
20252 if let (Some(user), Ok(tenant)) = (session_user, tenant) {
20253 let entry = SecurityEntry::new(crate::security_log::EVENT_LOGOUT, "admin", &request.meta)
20254 .user(user.id.get().copied(), &user.username);
20255 crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
20256 }
20257 let mut resp = Redirect::to("/login").into_response();
20258 let cookies = [
20262 "rustango_admin_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20263 "rustango_tenant_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20264 "rustango_op_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20265 ];
20266 for c in cookies {
20267 if let Ok(v) = HeaderValue::from_str(c) {
20268 resp.headers_mut().append(header::SET_COOKIE, v);
20269 }
20270 }
20271 resp
20272}
20273
20274pub async fn no_access_page(
20285 State(state): State<super::AdminState>,
20286 headers: HeaderMap,
20287 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
20288) -> Result<Response, AdminError> {
20289 let mut ctx = Context::new();
20290 ctx.insert("admin_title", &"CMS Admin");
20291 render_with_csrf(&state, &headers, "rcms_admin/no_access.html", &mut ctx)
20292}
20293
20294pub async fn dismissible_submit(
20303 State(_state): State<super::AdminState>,
20304 tenant: Tenant,
20305 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20306 Path(key): Path<String>,
20307) -> Result<Response, AdminError> {
20308 let Some(viewer) = session_user.as_ref() else {
20309 return Ok(unauthorized_no_session());
20310 };
20311 let viewer_id = viewer.id.get().copied().unwrap_or_default();
20312 crate::dismissible::dismiss(tenant.pool(), viewer_id, &key).await?;
20313 Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
20314}
20315
20316pub async fn dashboard(
20321 State(state): State<super::AdminState>,
20322 tenant: Tenant,
20323 headers: HeaderMap,
20324 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20325) -> Result<Response, AdminError> {
20326 let pool = tenant.pool();
20327 let viewer_id = session_user.as_ref().and_then(|u| u.id.get().copied());
20328
20329 let all_pages: Vec<Page> = Page::objects().fetch(pool).await.unwrap_or_default();
20331 let mut count_drafts = 0usize;
20332 let mut count_published = 0usize;
20333 let mut count_scheduled = 0usize;
20334 let mut count_archived = 0usize;
20335 for p in &all_pages {
20336 match p.status.as_str() {
20337 "draft" => count_drafts += 1,
20338 "published" => count_published += 1,
20339 "scheduled" => count_scheduled += 1,
20340 "archived" => count_archived += 1,
20341 _ => {}
20342 }
20343 }
20344 let snippet_count: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
20345 .fetch(pool)
20346 .await
20347 .unwrap_or_default();
20348 let media_rows: Vec<Media> = Media::objects().fetch(pool).await.unwrap_or_default();
20349 let media_images = media_rows.iter().filter(|m| m.kind == "image").count();
20350 let media_docs = media_rows.len() - media_images;
20351
20352 let revs: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
20354 .order_by(&[("created_at", true)]) .limit(10)
20356 .fetch(pool)
20357 .await
20358 .unwrap_or_default();
20359 let user_ids: std::collections::BTreeSet<i64> = revs.iter().filter_map(|r| r.created_by).collect();
20361 let usernames: std::collections::HashMap<i64, String> = if user_ids.is_empty() {
20362 std::collections::HashMap::new()
20363 } else {
20364 rustango::tenancy::auth::User::objects()
20365 .where_(rustango::tenancy::auth::User::id.is_in(user_ids.into_iter()))
20366 .fetch(pool)
20367 .await
20368 .unwrap_or_default()
20369 .into_iter()
20370 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
20371 .collect()
20372 };
20373 let page_by_id: std::collections::HashMap<i64, &Page> = all_pages
20374 .iter()
20375 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
20376 .collect();
20377 let recent_edits: Vec<serde_json::Value> = revs
20378 .iter()
20379 .filter_map(|r| {
20380 let p = page_by_id.get(&r.page_id)?;
20381 Some(serde_json::json!({
20382 "page_id": r.page_id,
20383 "title": p.title,
20384 "url_path": p.url_path,
20385 "sequence": r.sequence,
20386 "created_at": r.created_at.get().copied(),
20387 "created_by": r.created_by.and_then(|id| usernames.get(&id).cloned()),
20388 }))
20389 })
20390 .collect();
20391
20392 let locks: Vec<crate::lock::PageLock> = crate::lock::PageLock::objects()
20394 .fetch(pool)
20395 .await
20396 .unwrap_or_default();
20397 let now = chrono::Utc::now();
20398 let mine_locked: Vec<serde_json::Value> = locks
20399 .iter()
20400 .filter(|l| !l.is_stale(now))
20401 .filter(|l| Some(l.user_id) == viewer_id)
20402 .filter_map(|l| {
20403 let p = page_by_id.get(&l.page_id)?;
20404 Some(serde_json::json!({
20405 "page_id": l.page_id,
20406 "title": p.title,
20407 "url_path": p.url_path,
20408 "acquired_at": l.acquired_at.get().copied(),
20409 }))
20410 })
20411 .collect();
20412
20413 let mut review_rows: Vec<serde_json::Value> = Vec::new();
20418 if let Some(viewer) = session_user.as_ref() {
20419 let states: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
20420 .where_(crate::workflow::WorkflowState::status.eq(crate::workflow::WorkflowStatus::InProgress.as_str().to_owned()))
20421 .fetch(pool)
20422 .await
20423 .unwrap_or_default();
20424 if !states.is_empty() {
20425 let my_roles: std::collections::BTreeSet<i64> = rustango::tenancy::permissions::UserRole::objects()
20426 .where_(rustango::tenancy::permissions::UserRole::user_id.eq(viewer_id.unwrap_or_default()))
20427 .fetch(pool)
20428 .await
20429 .unwrap_or_default()
20430 .into_iter()
20431 .map(|m| m.role_id)
20432 .collect();
20433 let task_ids: Vec<i64> = states.iter().filter_map(|st| st.current_task_id).collect();
20434 let tasks: std::collections::HashMap<i64, crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
20435 .where_(crate::workflow::WorkflowTask::id.is_in(task_ids.into_iter()))
20436 .fetch(pool)
20437 .await
20438 .unwrap_or_default()
20439 .into_iter()
20440 .filter_map(|t| t.id.get().copied().map(|id| (id, t)))
20441 .collect();
20442 for st in &states {
20443 let Some(task) = st.current_task_id.and_then(|id| tasks.get(&id)) else { continue };
20444 if !viewer.is_superuser && !my_roles.contains(&task.role_id) {
20445 continue;
20446 }
20447 let Some(p) = page_by_id.get(&st.page_id) else { continue };
20448 review_rows.push(serde_json::json!({
20449 "page_id": st.page_id,
20450 "title": p.title,
20451 "url_path": p.url_path,
20452 "step": task.name,
20453 "requested_at": st.requested_at.get().copied(),
20454 }));
20455 }
20456 }
20457 }
20458
20459 let mut scheduled: Vec<&Page> = all_pages
20461 .iter()
20462 .filter(|p| {
20463 p.status == "scheduled" && p.go_live_at.is_some() && p.go_live_at.unwrap() > now
20464 })
20465 .collect();
20466 scheduled.sort_by_key(|p| p.go_live_at);
20467 scheduled.truncate(5);
20468 let scheduled_rows: Vec<serde_json::Value> = scheduled
20469 .into_iter()
20470 .map(|p| {
20471 serde_json::json!({
20472 "page_id": p.id.get().copied().unwrap_or_default(),
20473 "title": p.title,
20474 "url_path": p.url_path,
20475 "go_live_at": p.go_live_at,
20476 })
20477 })
20478 .collect();
20479
20480 let plugin_widgets: Vec<serde_json::Value> = crate::hooks::dashboard_widgets()
20482 .into_iter()
20483 .map(|w| {
20484 serde_json::json!({
20485 "key": w.key,
20486 "label": w.label,
20487 "icon": w.icon,
20488 "html": w.html,
20489 })
20490 })
20491 .collect();
20492
20493 let mut ctx = Context::new();
20494 add_chrome(&mut ctx, &tenant, "dashboard", session_user.as_ref()).await;
20495 add_admin_theme(&mut ctx, tenant.pool()).await;
20496 ctx.insert("review_rows", &review_rows);
20497 ctx.insert("count_drafts", &count_drafts);
20498 ctx.insert("count_published", &count_published);
20499 ctx.insert("count_scheduled", &count_scheduled);
20500 ctx.insert("count_archived", &count_archived);
20501 ctx.insert("count_snippets", &snippet_count.len());
20502 ctx.insert("count_images", &media_images);
20503 ctx.insert("count_documents", &media_docs);
20504 ctx.insert("recent_edits", &recent_edits);
20505 ctx.insert("mine_locked", &mine_locked);
20506 ctx.insert("scheduled_rows", &scheduled_rows);
20507 ctx.insert("plugin_widgets", &plugin_widgets);
20508 render_with_csrf(&state, &headers, "rcms_admin/dashboard.html", &mut ctx)
20509}
20510
20511pub async fn styleguide(
20514 State(state): State<super::AdminState>,
20515 tenant: Tenant,
20516 headers: HeaderMap,
20517 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20518) -> Result<Response, AdminError> {
20519 let mut ctx = Context::new();
20520 add_chrome(&mut ctx, &tenant, "styleguide", session_user.as_ref()).await;
20521 add_admin_theme(&mut ctx, tenant.pool()).await;
20522
20523 let blocks: Vec<serde_json::Value> = crate::block::registered_blocks()
20527 .map(|b| {
20528 serde_json::json!({
20529 "type_name": b.type_name(),
20530 "verbose_name": b.verbose_name(),
20531 "icon": b.icon(),
20532 "group": b.group(),
20533 "field_count": b.fields().len(),
20534 })
20535 })
20536 .collect();
20537 ctx.insert("blocks", &blocks);
20538
20539 let page_types: Vec<serde_json::Value> = crate::page_type::registered_handlers()
20541 .map(|h| {
20542 serde_json::json!({
20543 "type_name": h.type_name(),
20544 "verbose_name": h.verbose_name(),
20545 "icon": h.icon(),
20546 "description": h.description(),
20547 })
20548 })
20549 .collect();
20550 ctx.insert("page_types", &page_types);
20551
20552 let library_types: Vec<serde_json::Value> = crate::library::registered_handlers()
20554 .map(|h| {
20555 serde_json::json!({
20556 "type_name": h.type_name(),
20557 "verbose_name": h.verbose_name(),
20558 })
20559 })
20560 .collect();
20561 ctx.insert("library_types", &library_types);
20562
20563 render_with_csrf(&state, &headers, "rcms_admin/styleguide.html", &mut ctx)
20564}
20565
20566pub async fn account_preferences(
20567 State(state): State<super::AdminState>,
20568 tenant: Tenant,
20569 headers: HeaderMap,
20570 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20571) -> Result<Response, AdminError> {
20572 render_account_page(&state, &tenant, &headers, session_user.as_ref(), None).await
20573}
20574
20575async fn mcp_keys_ctx(
20578 pool: &rustango::sql::Pool,
20579 owner_id: i64,
20580) -> (Vec<serde_json::Value>, Vec<serde_json::Value>) {
20581 use rustango::tenancy::{AgentGrant, AgentSkill};
20582
20583 let keys = rustango::tenancy::list_user_keys_pool(pool, owner_id)
20584 .await
20585 .unwrap_or_default();
20586 let skills: Vec<AgentSkill> = rustango::tenancy::list_skills_pool(pool)
20587 .await
20588 .unwrap_or_default();
20589 let skill_name = |sid: i64| -> Option<String> {
20590 skills
20591 .iter()
20592 .find(|s| s.id.get().copied() == Some(sid))
20593 .map(|s| s.codename.clone())
20594 };
20595 let mut rows = Vec::with_capacity(keys.len());
20596 for key in &keys {
20597 let key_id = key.id.get().copied().unwrap_or_default();
20598 let grants: Vec<AgentGrant> = AgentGrant::objects()
20599 .where_(AgentGrant::agent_id.eq(key_id))
20600 .fetch(pool)
20601 .await
20602 .unwrap_or_default();
20603 let scope: Vec<String> = grants
20604 .iter()
20605 .filter_map(|g| skill_name(g.skill_id))
20606 .collect();
20607 rows.push(serde_json::json!({
20608 "id": key_id,
20609 "label": key.data.get("label").and_then(|v| v.as_str()).unwrap_or(&key.name),
20610 "prefix": key.secret_prefix,
20611 "active": key.active,
20612 "created_at": key.created_at.get().map(|t| t.format("%Y-%m-%d %H:%M").to_string()),
20613 "scope": scope,
20614 }));
20615 }
20616 let skill_rows: Vec<serde_json::Value> = skills
20617 .iter()
20618 .map(|s| {
20619 serde_json::json!({
20620 "codename": s.codename,
20621 "name": s.name,
20622 "description": s.description,
20623 })
20624 })
20625 .collect();
20626 (rows, skill_rows)
20627}
20628
20629async fn render_account_page(
20630 state: &super::AdminState,
20631 tenant: &Tenant,
20632 headers: &HeaderMap,
20633 session_user: Option<&rustango::tenancy::auth::User>,
20634 mcp_one_time: Option<serde_json::Value>,
20635) -> Result<Response, AdminError> {
20636 let (current_email, pending_email, mailer_wired) = {
20639 let mailer = state.mailer.is_some();
20640 let user_data = session_user
20641 .map(|u| u.data.clone())
20642 .unwrap_or_else(|| serde_json::json!({}));
20643 let cur = session_user.map(user_email).unwrap_or_default();
20644 let pending = user_data
20645 .get("pending_email")
20646 .and_then(|v| v.as_str())
20647 .unwrap_or("")
20648 .to_owned();
20649 (cur, pending, mailer)
20650 };
20651 let mut ctx = Context::new();
20652 add_chrome(&mut ctx, tenant, "", session_user).await;
20653 add_admin_theme(&mut ctx, tenant.pool()).await;
20654 let themes: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
20658 .order_by(&[("name", false)])
20659 .fetch(tenant.pool())
20660 .await
20661 .unwrap_or_default();
20662 let theme_rows: Vec<serde_json::Value> = themes
20663 .iter()
20664 .map(|t| {
20665 serde_json::json!({
20666 "id": t.id.get().copied(),
20667 "name": t.name,
20668 "slug": t.slug,
20669 "is_admin_default": t.is_admin_default,
20670 "color_bg": t.color_bg,
20671 "color_surface": t.color_surface,
20672 "color_text_primary": t.color_text_primary,
20673 "color_link": t.color_link,
20674 })
20675 })
20676 .collect();
20677 ctx.insert("themes", &theme_rows);
20678 let account_panels: Vec<serde_json::Value> = crate::hooks::account_settings_panels()
20681 .into_iter()
20682 .map(|p| {
20683 serde_json::json!({
20684 "key": p.key,
20685 "label": p.label,
20686 "icon": p.icon,
20687 "html": p.html,
20688 })
20689 })
20690 .collect();
20691 ctx.insert("account_panels", &account_panels);
20692
20693 let pref_map = session_user
20698 .and_then(|u| u.id.get().copied())
20699 .map(|uid| crate::notification_pref::map_for_user(tenant.pool(), uid))
20700 .map(|fut| async move { fut.await.unwrap_or_default() });
20701 let pref_lookup: std::collections::HashMap<String, bool> = match pref_map {
20702 Some(f) => f.await,
20703 None => std::collections::HashMap::new(),
20704 };
20705 let notification_rows: Vec<serde_json::Value> = crate::notification_pref::ALL_KINDS
20706 .iter()
20707 .map(|(label, kind, hint)| {
20708 let enabled = pref_lookup.get(*kind).copied().unwrap_or(true);
20709 serde_json::json!({
20710 "label": label,
20711 "kind": kind,
20712 "hint": hint,
20713 "enabled": enabled,
20714 })
20715 })
20716 .collect();
20717 ctx.insert("notification_prefs", ¬ification_rows);
20718
20719 ctx.insert("account_email", ¤t_email);
20720 ctx.insert("account_pending_email", &pending_email);
20721 ctx.insert("account_mailer_wired", &mailer_wired);
20722
20723 if let Some(uid) = session_user.and_then(|u| u.id.get().copied()) {
20727 let (keys, skills) = mcp_keys_ctx(tenant.pool(), uid).await;
20728 ctx.insert("mcp_keys", &keys);
20729 ctx.insert("mcp_skills", &skills);
20730 }
20731 if let Some(one_time) = &mcp_one_time {
20732 ctx.insert("mcp_one_time", one_time);
20733 }
20734
20735 render_with_csrf(
20736 state,
20737 headers,
20738 "rcms_admin/account_preferences.html",
20739 &mut ctx,
20740 )
20741}
20742
20743pub async fn account_notifications_submit(
20748 State(_state): State<super::AdminState>,
20749 tenant: Tenant,
20750 headers: HeaderMap,
20751 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20752 Form(form): Form<std::collections::HashMap<String, String>>,
20753) -> Result<Response, AdminError> {
20754 let Some(viewer) = session_user.as_ref() else {
20755 return Ok(unauthorized_no_session());
20756 };
20757 let Some(uid) = viewer.id.get().copied() else {
20758 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20759 };
20760 for (_label, kind, _hint) in crate::notification_pref::ALL_KINDS {
20761 let key = format!("kind_{kind}");
20762 let enabled = form
20763 .get(&key)
20764 .map(|v| matches!(v.as_str(), "on" | "true" | "1" | "yes"))
20765 .unwrap_or(false);
20766 crate::notification_pref::set_enabled(tenant.pool(), uid, kind, enabled).await?;
20767 }
20768 redirect_named_with_params_and_message(
20769 "rcms-admin:account",
20770 &[],
20771 MsgLevel::Success,
20772 "Notification preferences saved.",
20773 &headers,
20774 )
20775}
20776
20777pub async fn account_profile_submit(
20784 State(_state): State<super::AdminState>,
20785 tenant: Tenant,
20786 headers: HeaderMap,
20787 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20788 mut multipart: axum::extract::Multipart,
20789) -> Result<Response, AdminError> {
20790 let Some(viewer) = session_user.as_ref() else {
20791 return Ok(unauthorized_no_session());
20792 };
20793 let Some(uid) = viewer.id.get().copied() else {
20794 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20795 };
20796
20797 let mut new_display_name: Option<String> = None;
20798 let mut new_avatar_path: Option<String> = None;
20799 let avatar_dir = std::path::PathBuf::from("./var/avatars").join(&tenant.org.slug);
20803
20804 while let Some(field) = multipart
20805 .next_field()
20806 .await
20807 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
20808 {
20809 let field_name = field.name().unwrap_or("").to_owned();
20810 match field_name.as_str() {
20811 "display_name" => {
20812 new_display_name = Some(
20813 field
20814 .text()
20815 .await
20816 .map_err(|e| AdminError::Upload(format!("read display_name: {e}")))?
20817 .trim()
20818 .to_owned(),
20819 );
20820 }
20821 "avatar" => {
20822 let original = field.file_name().map(|s| s.to_owned());
20823 let bytes = field
20824 .bytes()
20825 .await
20826 .map_err(|e| AdminError::Upload(format!("read avatar: {e}")))?;
20827 if bytes.is_empty() {
20828 continue;
20829 }
20830 let ext = original
20831 .as_deref()
20832 .and_then(|n| n.rsplit_once('.'))
20833 .map(|(_, ext)| ext)
20834 .filter(|ext| ext.len() <= 8 && ext.chars().all(|c| c.is_ascii_alphanumeric()))
20835 .map(str::to_ascii_lowercase)
20836 .unwrap_or_else(|| "png".to_owned());
20837 std::fs::create_dir_all(&avatar_dir)
20838 .map_err(|e| AdminError::Upload(format!("create avatar dir: {e}")))?;
20839 let storage_name = format!("{uid}.{ext}");
20840 let path = avatar_dir.join(&storage_name);
20841 std::fs::write(&path, &bytes)
20842 .map_err(|e| AdminError::Upload(format!("write avatar: {e}")))?;
20843 new_avatar_path = Some(storage_name);
20844 }
20845 _ => {
20846 let _ = field.bytes().await;
20847 }
20848 }
20849 }
20850
20851 let mut user_rows: Vec<rustango::tenancy::auth::User> =
20855 rustango::tenancy::auth::User::objects()
20856 .where_(rustango::tenancy::auth::User::id.eq(uid))
20857 .fetch(tenant.pool())
20858 .await?;
20859 let Some(mut user) = user_rows.pop() else {
20860 return Ok((axum::http::StatusCode::NOT_FOUND, "user not found").into_response());
20861 };
20862
20863 let mut data = user.data.as_object().cloned().unwrap_or_default();
20864 if let Some(name) = new_display_name {
20865 if name.is_empty() {
20866 data.remove("display_name");
20867 } else {
20868 data.insert("display_name".to_owned(), serde_json::json!(name));
20869 }
20870 }
20871 if let Some(path) = new_avatar_path {
20872 data.insert("avatar_path".to_owned(), serde_json::json!(path));
20873 }
20874 user.data = serde_json::Value::Object(data);
20875 user.save_pool(tenant.pool()).await?;
20876
20877 redirect_named_with_message(
20878 "rcms-admin:account",
20879 MsgLevel::Success,
20880 "Profile saved.",
20881 &headers,
20882 )
20883}
20884
20885async fn persist_user_admin_lang(
20889 pool: &rustango::sql::Pool,
20890 uid: i64,
20891 lang: &str,
20892) -> Result<(), AdminError> {
20893 let mut rows: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
20894 .where_(rustango::tenancy::auth::User::id.eq(uid))
20895 .fetch(pool)
20896 .await?;
20897 if let Some(mut user) = rows.pop() {
20898 let mut data = user.data.as_object().cloned().unwrap_or_default();
20899 data.insert("admin_lang".to_owned(), serde_json::json!(lang));
20900 user.data = serde_json::Value::Object(data);
20901 user.save_pool(pool).await?;
20902 }
20903 Ok(())
20904}
20905
20906#[derive(Debug, Deserialize)]
20908pub struct AccountLanguageForm {
20909 pub lang: String,
20910}
20911
20912pub async fn account_language_submit(
20918 State(_state): State<super::AdminState>,
20919 tenant: Tenant,
20920 headers: HeaderMap,
20921 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20922 Form(form): Form<AccountLanguageForm>,
20923) -> Result<Response, AdminError> {
20924 let Some(viewer) = session_user.as_ref() else {
20925 return Ok(unauthorized_no_session());
20926 };
20927 let Some(uid) = viewer.id.get().copied() else {
20928 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20929 };
20930 let lang = if super::i18n::is_ui_locale(&form.lang) {
20931 form.lang.clone()
20932 } else {
20933 "en".to_owned()
20934 };
20935 persist_user_admin_lang(tenant.pool(), uid, &lang).await?;
20936
20937 let mut resp = redirect_named_with_message(
20938 "rcms-admin:account",
20939 MsgLevel::Success,
20940 "Language updated.",
20941 &headers,
20942 )?;
20943 let cookie = format!(
20944 "{}={lang}; Path=/; SameSite=Lax; Max-Age=31536000",
20945 super::i18n::ADMIN_LANG_COOKIE
20946 );
20947 if let Ok(v) = HeaderValue::from_str(&cookie) {
20948 resp.headers_mut().append(header::SET_COOKIE, v);
20949 }
20950 Ok(resp)
20951}
20952
20953#[derive(Debug, Deserialize)]
20955pub struct AccountEmailForm {
20956 pub new_email: String,
20957}
20958
20959pub async fn account_email_submit(
20969 State(state): State<super::AdminState>,
20970 tenant: Tenant,
20971 headers: HeaderMap,
20972 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20973 Form(form): Form<AccountEmailForm>,
20974) -> Result<Response, AdminError> {
20975 let Some(viewer) = session_user.as_ref() else {
20976 return Ok(unauthorized_no_session());
20977 };
20978 let Some(uid) = viewer.id.get().copied() else {
20979 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20980 };
20981
20982 let new_email = form.new_email.trim().to_owned();
20983 if new_email.is_empty() || !new_email.contains('@') {
20984 return redirect_named_with_message(
20985 "rcms-admin:account",
20986 MsgLevel::Error,
20987 "Enter a valid email address.",
20988 &headers,
20989 );
20990 }
20991
20992 let mut user = rustango::tenancy::auth::User::objects()
20993 .where_(rustango::tenancy::auth::User::id.eq(uid))
20994 .first(tenant.pool())
20995 .await?
20996 .ok_or(AdminError::NotFound(uid))?;
20997 let mut data = user.data.as_object().cloned().unwrap_or_default();
20998
20999 if state.mailer.is_none() {
21000 data.insert("email".to_owned(), serde_json::json!(new_email));
21002 user.email = Some(new_email.clone());
21003 data.remove("pending_email");
21005 user.data = serde_json::Value::Object(data);
21006 user.save_pool(tenant.pool()).await?;
21007 return redirect_named_with_message(
21008 "rcms-admin:account",
21009 MsgLevel::Warning,
21010 "Email updated. No confirmation email was sent — the host hasn't wired a mailer.",
21011 &headers,
21012 );
21013 }
21014
21015 data.insert(
21021 "pending_email".to_owned(),
21022 serde_json::json!(new_email.clone()),
21023 );
21024 data.remove("pending_email_token");
21025 data.remove("pending_email_expires_at");
21026 user.data = serde_json::Value::Object(data);
21027 user.save_pool(tenant.pool()).await?;
21028
21029 if let Some(mailer) = state.mailer.as_deref() {
21034 let link = rustango::auth_flows::EmailVerification::issue(
21035 &rustango::auth_flows::LinkScope::from(&tenant),
21036 "/cms-admin/me/email/confirm",
21037 uid,
21038 &new_email,
21039 state.signing_secret.as_slice(),
21040 std::time::Duration::from_secs(3600),
21041 );
21042 let subject = "Confirm your CMS email change";
21043 let body = format!(
21044 "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",
21045 );
21046 let email = rustango::email::Email::new()
21047 .from((*state.mailer_from).clone())
21048 .to(new_email.clone())
21049 .subject(subject.to_owned())
21050 .body(body);
21051 if let Err(e) = mailer.send(&email).await {
21052 tracing::warn!(
21053 target: "rustango_cms::admin::account",
21054 user_id = uid, error = %e,
21055 "email-change confirmation send failed (pending_email stashed; user can re-request)"
21056 );
21057 }
21058 }
21059
21060 redirect_named_with_message(
21061 "rcms-admin:account",
21062 MsgLevel::Success,
21063 "Confirmation link sent to the new email. Click it within an hour to finalize the change.",
21064 &headers,
21065 )
21066}
21067
21068pub async fn account_email_confirm(
21075 State(state): State<super::AdminState>,
21076 tenant: Tenant,
21077 headers: HeaderMap,
21078 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
21079 axum::extract::OriginalUri(uri): axum::extract::OriginalUri,
21080) -> Result<Response, AdminError> {
21081 let Some(viewer) = session_user.as_ref() else {
21082 return Ok(unauthorized_no_session());
21083 };
21084 let Some(uid) = viewer.id.get().copied() else {
21085 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
21086 };
21087
21088 let path_and_query = uri
21089 .path_and_query()
21090 .map(|p| p.as_str())
21091 .unwrap_or_default()
21092 .to_owned();
21093 let (token_uid, signed_email) = match rustango::auth_flows::EmailVerification::verify(
21094 &rustango::auth_flows::LinkScope::from(&tenant),
21095 &path_and_query,
21096 state.signing_secret.as_slice(),
21097 ) {
21098 Ok(pair) => pair,
21099 Err(_) => {
21100 return redirect_named_with_message(
21101 "rcms-admin:account",
21102 MsgLevel::Error,
21103 "Confirmation link is invalid or has expired. Request a new one.",
21104 &headers,
21105 );
21106 }
21107 };
21108 if token_uid != uid {
21114 return redirect_named_with_message(
21115 "rcms-admin:account",
21116 MsgLevel::Error,
21117 "Confirmation link belongs to a different account. Sign in as that account to confirm.",
21118 &headers,
21119 );
21120 }
21121
21122 let mut user = rustango::tenancy::auth::User::objects()
21123 .where_(rustango::tenancy::auth::User::id.eq(uid))
21124 .first(tenant.pool())
21125 .await?
21126 .ok_or(AdminError::NotFound(uid))?;
21127 let mut data = user.data.as_object().cloned().unwrap_or_default();
21128 let pending = data
21132 .get("pending_email")
21133 .and_then(|v| v.as_str())
21134 .unwrap_or("");
21135 if pending != signed_email {
21136 return redirect_named_with_message(
21137 "rcms-admin:account",
21138 MsgLevel::Error,
21139 "This link is for a different email change than the one currently pending. Request a fresh confirmation.",
21140 &headers,
21141 );
21142 }
21143
21144 data.insert("email".to_owned(), serde_json::json!(signed_email));
21145 user.email = Some(signed_email.clone());
21146 data.remove("pending_email");
21147 data.remove("pending_email_token");
21150 data.remove("pending_email_expires_at");
21151 user.data = serde_json::Value::Object(data);
21152 user.save_pool(tenant.pool()).await?;
21153
21154 redirect_named_with_message(
21155 "rcms-admin:account",
21156 MsgLevel::Success,
21157 "Email confirmed. Notifications go to the new address from now on.",
21158 &headers,
21159 )
21160}
21161
21162#[derive(Deserialize)]
21164pub struct AccountPasswordForm {
21165 pub current_password: String,
21166 pub new_password: String,
21167 pub new_password_confirm: String,
21168}
21169
21170pub async fn account_password_submit(
21173 State(_state): State<super::AdminState>,
21174 tenant: Tenant,
21175 headers: HeaderMap,
21176 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
21177 Form(form): Form<AccountPasswordForm>,
21178) -> Result<Response, AdminError> {
21179 let Some(viewer) = session_user.as_ref() else {
21180 return Ok(unauthorized_no_session());
21181 };
21182 let Some(uid) = viewer.id.get().copied() else {
21183 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
21184 };
21185 if form.new_password.len() < 12 {
21186 return redirect_named_with_message(
21187 "rcms-admin:account",
21188 MsgLevel::Error,
21189 "New password must be at least 12 characters.",
21190 &headers,
21191 );
21192 }
21193 if form.new_password != form.new_password_confirm {
21194 return redirect_named_with_message(
21195 "rcms-admin:account",
21196 MsgLevel::Error,
21197 "New password and confirmation don't match.",
21198 &headers,
21199 );
21200 }
21201
21202 let mut user = rustango::tenancy::auth::User::objects()
21203 .where_(rustango::tenancy::auth::User::id.eq(uid))
21204 .first(tenant.pool())
21205 .await?
21206 .ok_or(AdminError::NotFound(uid))?;
21207
21208 let verified =
21209 crate::passwords::verify(&form.current_password, &user.password_hash).await.unwrap_or(false);
21210 if !verified {
21211 return redirect_named_with_message(
21212 "rcms-admin:account",
21213 MsgLevel::Error,
21214 "Current password is incorrect.",
21215 &headers,
21216 );
21217 }
21218 let hash = crate::passwords::hash(&form.new_password).await
21219 .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
21220 user.password_hash = hash;
21221 user.password_changed_at = Some(chrono::Utc::now());
21222 user.save_pool(tenant.pool()).await?;
21223
21224 redirect_named_with_message(
21225 "rcms-admin:account",
21226 MsgLevel::Success,
21227 "Password changed. Old sessions on other devices will be signed out on next request.",
21228 &headers,
21229 )
21230}
21231
21232pub async fn account_avatar_serve(
21236 headers: HeaderMap,
21237 tenant: Tenant,
21238 Path(user_id): Path<i64>,
21239) -> Response {
21240 let user_rows: Vec<rustango::tenancy::auth::User> =
21241 match rustango::tenancy::auth::User::objects()
21242 .where_(rustango::tenancy::auth::User::id.eq(user_id))
21243 .fetch(tenant.pool())
21244 .await
21245 {
21246 Ok(v) => v,
21247 Err(_) => {
21248 return (
21249 axum::http::StatusCode::INTERNAL_SERVER_ERROR,
21250 "user lookup failed",
21251 )
21252 .into_response();
21253 }
21254 };
21255 let Some(user) = user_rows.into_iter().next() else {
21256 return (axum::http::StatusCode::NOT_FOUND, "user not found").into_response();
21257 };
21258 let storage_name = match user.data.get("avatar_path").and_then(|v| v.as_str()) {
21259 Some(s) if !s.is_empty() => s.to_owned(),
21260 _ => return (axum::http::StatusCode::NOT_FOUND, "no avatar").into_response(),
21261 };
21262 if storage_name.contains('/') || storage_name.contains("..") {
21263 return (axum::http::StatusCode::BAD_REQUEST, "invalid storage name").into_response();
21264 }
21265 let path = std::path::PathBuf::from("./var/avatars")
21268 .join(&tenant.org.slug)
21269 .join(&storage_name);
21270 let bytes = match std::fs::read(&path) {
21271 Ok(b) => b,
21272 Err(_) => {
21273 return (axum::http::StatusCode::NOT_FOUND, "avatar bytes missing").into_response()
21274 }
21275 };
21276 let mime = mime_guess::from_path(&storage_name)
21277 .first_or_octet_stream()
21278 .essence_str()
21279 .to_owned();
21280 revalidated_asset(&headers, mime, bytes)
21283}
21284
21285pub async fn cms_login_form(
21286 State(state): State<super::AdminState>,
21287 headers: HeaderMap,
21288 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21289 tenant: Tenant,
21290 Query(q): Query<std::collections::HashMap<String, String>>,
21291) -> Result<Response, AdminError> {
21292 let mut ctx = Context::new();
21293 ctx.insert("action", &"/login");
21297 ctx.insert("admin_title", &"CMS Admin");
21298 let next = q
21311 .get("next")
21312 .map(String::as_str)
21313 .filter(|s| !s.is_empty())
21314 .unwrap_or("/cms-admin/");
21315 ctx.insert("next", next);
21316 if let Some(err) = q.get("error") {
21318 ctx.insert("error", err);
21319 }
21320 let sso_providers = rustango::admin::sso_provider::list_enabled(tenant.pool(), "/login").await;
21327 ctx.insert("sso_enabled", &!sso_providers.is_empty());
21328 ctx.insert("sso_providers", &sso_providers);
21329 if let Some(err) = q.get("sso_error") {
21331 ctx.insert("sso_error", err);
21332 }
21333 add_branding_urls(&mut ctx, &tenant).await;
21337 render_with_csrf(&state, &headers, "login.html", &mut ctx)
21338}
21339
21340pub async fn password_reset_request_form(
21342 State(state): State<super::AdminState>,
21343 headers: HeaderMap,
21344 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21345) -> Result<Response, AdminError> {
21346 let mut ctx = Context::new();
21347 render_with_csrf(
21348 &state,
21349 &headers,
21350 "rcms_admin/password_reset_request.html",
21351 &mut ctx,
21352 )
21353}
21354
21355fn password_reset_scope(tenant_slug: &str) -> rustango::auth_flows::LinkScope {
21369 rustango::auth_flows::LinkScope::audience(&format!("rcms-reset:{tenant_slug}"))
21370}
21371
21372fn password_reset_key(secret: &[u8], tenant_slug: &str, password_hash: &str) -> Vec<u8> {
21373 let msg = format!("rcms-password-reset\0{tenant_slug}\0{password_hash}");
21374 crate::signing::hmac_sha256_hex(secret, msg.as_bytes()).into_bytes()
21375}
21376
21377fn password_reset_url(
21381 secret: &[u8],
21382 tenant_slug: &str,
21383 user: &rustango::tenancy::auth::User,
21384) -> String {
21385 let key = password_reset_key(secret, tenant_slug, &user.password_hash);
21386 rustango::auth_flows::PasswordReset::issue(
21387 &password_reset_scope(tenant_slug),
21388 "/cms-admin/password-reset/confirm",
21389 user.id.get().copied().unwrap_or(0),
21390 &key,
21391 std::time::Duration::from_secs(3600),
21392 )
21393}
21394
21395pub async fn issue_password_reset_link(
21406 pool: &rustango::sql::Pool,
21407 tenant_slug: &str,
21408 username: &str,
21409) -> Result<Option<String>, rustango::sql::ExecError> {
21410 let user: Option<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
21411 .where_(rustango::tenancy::auth::User::username.eq(username.to_owned()))
21412 .where_(rustango::tenancy::auth::User::active.eq(true))
21413 .fetch(pool)
21414 .await?
21415 .into_iter()
21416 .next();
21417 let secret = crate::signing::derived_key(super::PASSWORD_RESET_KEY_PURPOSE);
21418 Ok(user.map(|u| password_reset_url(&secret, tenant_slug, &u)))
21419}
21420
21421async fn password_reset_user(
21427 tenant: &Tenant,
21428 secret: &[u8],
21429 signed_url: &str,
21430) -> Option<rustango::tenancy::auth::User> {
21431 let claimed: i64 = signed_url
21432 .split_once('?')?
21433 .1
21434 .split('&')
21435 .find_map(|kv| kv.strip_prefix("user_id="))?
21436 .parse()
21437 .ok()?;
21438 let user = rustango::tenancy::auth::User::objects()
21439 .where_(rustango::tenancy::auth::User::id.eq(claimed))
21440 .where_(rustango::tenancy::auth::User::active.eq(true))
21441 .first(tenant.pool())
21442 .await
21443 .ok()??;
21444 let key = password_reset_key(secret, &tenant.org.slug, &user.password_hash);
21445 match rustango::auth_flows::PasswordReset::verify(
21446 &password_reset_scope(&tenant.org.slug),
21447 signed_url,
21448 &key,
21449 ) {
21450 Ok(uid) if uid == claimed => Some(user),
21451 _ => None,
21452 }
21453}
21454
21455pub async fn password_reset_request_submit(
21456 State(state): State<super::AdminState>,
21457 tenant: Tenant,
21458 headers: HeaderMap,
21459 request: crate::security_log::LoginRequest,
21460 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21461 Form(form): Form<std::collections::HashMap<String, String>>,
21462) -> Result<Response, AdminError> {
21463 let username = form.get("username").cloned().unwrap_or_default();
21464 if !username.trim().is_empty() {
21465 let user: Option<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
21469 .where_(rustango::tenancy::auth::User::username.eq(username.clone()))
21470 .where_(rustango::tenancy::auth::User::active.eq(true))
21471 .fetch(tenant.pool())
21472 .await
21473 .unwrap_or_default()
21474 .into_iter()
21475 .next();
21476 if let Some(u) = user {
21477 let entry = SecurityEntry::new(
21478 crate::security_log::EVENT_PASSWORD_RESET_REQUESTED,
21479 "admin",
21480 &request.meta,
21481 )
21482 .user(u.id.get().copied(), &u.username);
21483 crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
21484 let token_url =
21488 password_reset_url(state.signing_secret.as_slice(), &tenant.org.slug, &u);
21489 let to_email = Some(user_email(&u)).filter(|e| !e.is_empty());
21490 match (to_email, state.mailer.is_some()) {
21491 (Some(to), _) => {
21492 send_reset_email(
21493 state.mailer.as_deref(),
21494 &state.mailer_from,
21495 &to,
21496 &u.username,
21497 &token_url,
21498 )
21499 .await;
21500 }
21501 (None, false) => {
21505 println!(
21506 "============= password reset =============\n\
21507 {} has no email on file. Reset link, valid for an hour \
21508 (prefix the site's address):\n{token_url}\n\
21509 ==========================================",
21510 u.username
21511 );
21512 tracing::warn!(
21513 username = %u.username,
21514 "password reset for an account with no email: link printed to stdout"
21515 );
21516 }
21517 (None, true) => {
21518 tracing::warn!(
21519 username = %u.username,
21520 "password reset requested but the account has no email on file; nothing \
21521 sent. Add an email to the account, or issue a link with \
21522 rustango_cms::admin::issue_password_reset_link"
21523 );
21524 }
21525 }
21526 }
21527 }
21528 let mut ctx = Context::new();
21529 ctx.insert("console_mail", &state.mailer.is_none());
21531 render_with_csrf(
21532 &state,
21533 &headers,
21534 "rcms_admin/password_reset_sent.html",
21535 &mut ctx,
21536 )
21537}
21538
21539pub async fn password_reset_confirm_form(
21543 State(state): State<super::AdminState>,
21544 tenant: Tenant,
21545 headers: HeaderMap,
21546 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21547 axum::extract::OriginalUri(uri): axum::extract::OriginalUri,
21548) -> Result<Response, AdminError> {
21549 let path_and_query = uri
21550 .path_and_query()
21551 .map(|p| p.as_str())
21552 .unwrap_or_default()
21553 .to_owned();
21554 let mut ctx = Context::new();
21555 match password_reset_user(&tenant, state.signing_secret.as_slice(), &path_and_query).await {
21556 Some(_) => {
21557 ctx.insert("signed_token", &path_and_query);
21560 render_with_csrf(
21561 &state,
21562 &headers,
21563 "rcms_admin/password_reset_confirm.html",
21564 &mut ctx,
21565 )
21566 }
21567 None => {
21568 ctx.insert(
21569 "error",
21570 &"This reset link is invalid or has expired. Request a fresh one.",
21571 );
21572 render_with_csrf(
21573 &state,
21574 &headers,
21575 "rcms_admin/password_reset_request.html",
21576 &mut ctx,
21577 )
21578 }
21579 }
21580}
21581
21582pub async fn password_reset_confirm_submit(
21586 State(state): State<super::AdminState>,
21587 tenant: Tenant,
21588 headers: HeaderMap,
21589 request: crate::security_log::LoginRequest,
21590 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21591 Form(form): Form<std::collections::HashMap<String, String>>,
21592) -> Result<Response, AdminError> {
21593 let token = form.get("token").cloned().unwrap_or_default();
21594 let password = form.get("password").cloned().unwrap_or_default();
21595 let password_confirm = form.get("password_confirm").cloned().unwrap_or_default();
21596
21597 let mut ctx = Context::new();
21598 let render_confirm_with_error = |state: &super::AdminState,
21599 headers: &HeaderMap,
21600 token: &str,
21601 msg: &str|
21602 -> Result<Response, AdminError> {
21603 let mut c = Context::new();
21604 c.insert("signed_token", &token);
21605 c.insert("error", &msg);
21606 render_with_csrf(
21607 state,
21608 headers,
21609 "rcms_admin/password_reset_confirm.html",
21610 &mut c,
21611 )
21612 };
21613
21614 if password.len() < 12 {
21615 return render_confirm_with_error(
21616 &state,
21617 &headers,
21618 &token,
21619 "Password must be at least 12 characters.",
21620 );
21621 }
21622 if password != password_confirm {
21623 return render_confirm_with_error(
21624 &state,
21625 &headers,
21626 &token,
21627 "Password confirmation didn't match.",
21628 );
21629 }
21630
21631 let Some(mut user) = password_reset_user(&tenant, state.signing_secret.as_slice(), &token).await
21634 else {
21635 ctx.insert(
21636 "error",
21637 &"This reset link is invalid or has expired. Request a fresh one.",
21638 );
21639 return render_with_csrf(
21640 &state,
21641 &headers,
21642 "rcms_admin/password_reset_request.html",
21643 &mut ctx,
21644 );
21645 };
21646 let new_hash = match crate::passwords::hash(&password).await {
21647 Ok(h) => h,
21648 Err(e) => {
21649 tracing::warn!(error = %e, "password hash failed");
21650 return render_confirm_with_error(
21651 &state,
21652 &headers,
21653 &token,
21654 "Could not save the new password. Try again.",
21655 );
21656 }
21657 };
21658 user.password_hash = new_hash;
21659 if user.save_pool(tenant.pool()).await.is_err() {
21660 return render_confirm_with_error(
21661 &state,
21662 &headers,
21663 &token,
21664 "Could not save the new password. Try again.",
21665 );
21666 }
21667 crate::security_log::unlock(&tenant.org.slug, &user.username).await;
21669 let entry = SecurityEntry::new(crate::security_log::EVENT_PASSWORD_RESET, "admin", &request.meta)
21670 .user(user.id.get().copied(), &user.username);
21671 crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
21672
21673 render_with_csrf(
21674 &state,
21675 &headers,
21676 "rcms_admin/password_reset_done.html",
21677 &mut ctx,
21678 )
21679}
21680
21681async fn send_reset_email(
21691 mailer: Option<&dyn rustango::email::Mailer>,
21692 mailer_from: &str,
21693 to_email: &str,
21694 username: &str,
21695 reset_url: &str,
21696) {
21697 let from = if mailer_from.trim().is_empty() {
21698 "noreply@cms.local"
21699 } else {
21700 mailer_from
21701 };
21702 let email = rustango::email::Email::new()
21703 .to(to_email)
21704 .from(from)
21705 .subject("Reset your CMS password")
21706 .body(format!(
21707 "Hi {username},\n\n\
21708 We received a request to reset your CMS password.\n\
21709 Click the link below within the next hour to set a new one:\n\n\
21710 {reset_url}\n\n\
21711 If you didn't request this, you can safely ignore this email.\n"
21712 ));
21713 let result = match mailer {
21714 Some(m) => m.send(&email).await,
21715 None => {
21716 let console = rustango::email::ConsoleMailer;
21717 <rustango::email::ConsoleMailer as rustango::email::Mailer>::send(&console, &email)
21718 .await
21719 }
21720 };
21721 if let Err(e) = result {
21722 tracing::warn!(error = %e, username = %username, "password-reset mail send failed");
21723 }
21724 tracing::info!(username = %username, "issued password-reset link");
21725}
21726
21727#[cfg(test)]
21728mod tests {
21729 use super::*;
21732
21733 fn reset_user(password_hash: &str) -> rustango::tenancy::auth::User {
21734 rustango::tenancy::auth::User {
21735 id: rustango::sql::Auto::Set(7),
21736 username: "admin".to_owned(),
21737 password_hash: password_hash.to_owned(),
21738 email: None,
21739 is_superuser: true,
21740 active: true,
21741 created_at: chrono::Utc::now(),
21742 data: serde_json::json!({}),
21743 password_changed_at: None,
21744 sessions_revoked_at: None,
21745 }
21746 }
21747
21748 #[test]
21752 fn a_reset_link_verifies_until_the_password_changes() {
21753 let secret = b"test-secret";
21754 let url = password_reset_url(secret, "blog", &reset_user("hash-1"));
21755 assert!(url.starts_with("/cms-admin/password-reset/confirm?user_id=7&"), "{url}");
21756 let key = password_reset_key(secret, "blog", "hash-1");
21757 let blog = password_reset_scope("blog");
21758 assert_eq!(rustango::auth_flows::PasswordReset::verify(&blog, &url, &key).ok(), Some(7));
21759 let after_change = password_reset_key(secret, "blog", "hash-2");
21760 assert!(rustango::auth_flows::PasswordReset::verify(&blog, &url, &after_change).is_err());
21761 let other_tenant = password_reset_key(secret, "shop", "hash-1");
21762 let shop = password_reset_scope("shop");
21763 assert!(rustango::auth_flows::PasswordReset::verify(&shop, &url, &other_tenant).is_err());
21764 }
21765
21766 #[test]
21767 fn parse_matrix_form_translates_brackets_to_codenames() {
21768 let mut form = std::collections::HashMap::new();
21769 form.insert("name".to_owned(), "Editor".to_owned());
21770 form.insert("perm[pages][view]".to_owned(), "1".to_owned());
21771 form.insert("perm[pages][add]".to_owned(), "1".to_owned());
21772 form.insert("perm[pages][edit]".to_owned(), "1".to_owned());
21773 form.insert("perm[history][view]".to_owned(), "1".to_owned());
21775 form.insert("perm[history][edit]".to_owned(), "1".to_owned());
21778 form.insert("perm[redirects][delete]".to_owned(), "0".to_owned());
21780 form.insert("perm[bogus][view]".to_owned(), "1".to_owned());
21782 form.insert("perm[pages]".to_owned(), "1".to_owned());
21784
21785 let codenames = parse_matrix_form(&form);
21786 assert!(codenames.contains(&"cms_page.view".to_owned()));
21787 assert!(codenames.contains(&"cms_page.add".to_owned()));
21788 assert!(codenames.contains(&"cms_page.edit".to_owned()));
21789 assert!(codenames.contains(&"cms_history.view".to_owned()));
21790 assert!(!codenames.contains(&"cms_history.edit".to_owned()));
21791 assert!(!codenames.contains(&"cms_redirect.delete".to_owned()));
21792 assert!(!codenames.iter().any(|c| c.contains("bogus")));
21794 }
21795
21796 #[test]
21797 fn split_matrix_codenames_isolates_legacy() {
21798 let granted = vec![
21799 "cms_page.view".to_owned(),
21800 "cms_page.edit".to_owned(),
21801 "rustango_roles.view".to_owned(),
21802 "acme_custom.do_thing".to_owned(),
21803 "free_form_string".to_owned(),
21804 ];
21805 let (matched, legacy) = split_matrix_codenames(&granted);
21806 assert!(matched.contains(&"cms_page.view".to_owned()));
21807 assert!(matched.contains(&"cms_page.edit".to_owned()));
21808 assert!(matched.contains(&"rustango_roles.view".to_owned()));
21809 assert!(legacy.contains(&"acme_custom.do_thing".to_owned()));
21810 assert!(legacy.contains(&"free_form_string".to_owned()));
21811 }
21812
21813 #[test]
21814 fn build_permission_matrix_marks_granted_cells() {
21815 let granted = vec![
21816 "cms_page.view".to_owned(),
21817 "cms_page.add".to_owned(),
21818 "cms_media.view".to_owned(),
21819 ];
21820 let matrix = build_permission_matrix(&granted);
21821 let arr = matrix.as_array().expect("matrix is an array of sections");
21822 let pages_row = arr
21824 .iter()
21825 .flat_map(|s| s["rows"].as_array().unwrap().iter())
21826 .find(|r| r["key"] == "pages")
21827 .expect("pages row present");
21828 let granted_actions: Vec<&str> = pages_row["granted"]
21829 .as_array()
21830 .unwrap()
21831 .iter()
21832 .map(|v| v.as_str().unwrap())
21833 .collect();
21834 assert!(granted_actions.contains(&"view"));
21835 assert!(granted_actions.contains(&"add"));
21836 assert!(!granted_actions.contains(&"edit"));
21837 assert!(!granted_actions.contains(&"delete"));
21838 }
21839
21840 #[test]
21841 fn round_trip_form_to_codenames_to_matrix() {
21842 let mut form = std::collections::HashMap::new();
21845 form.insert("perm[pages][view]".to_owned(), "1".to_owned());
21846 form.insert("perm[pages][publish]".to_owned(), "1".to_owned());
21847 form.insert("perm[media][view]".to_owned(), "1".to_owned());
21848 let codenames = parse_matrix_form(&form);
21849 let matrix = build_permission_matrix(&codenames);
21850
21851 let pages = matrix
21852 .as_array()
21853 .unwrap()
21854 .iter()
21855 .flat_map(|s| s["rows"].as_array().unwrap().iter())
21856 .find(|r| r["key"] == "pages")
21857 .unwrap();
21858 let granted: Vec<&str> = pages["granted"]
21859 .as_array()
21860 .unwrap()
21861 .iter()
21862 .map(|v| v.as_str().unwrap())
21863 .collect();
21864 assert_eq!(granted, vec!["view", "publish"]);
21865 }
21866
21867 fn sample_spec() -> crate::page_type::InlinePanelSpec {
21870 crate::page_type::InlinePanelSpec::new(
21871 "team",
21872 "Team",
21873 vec![
21874 crate::page_type::ExtensionField {
21875 name: "name".to_owned(),
21876 label: "Name".to_owned(),
21877 kind: crate::page_type::ExtensionFieldKind::Text,
21878 value: String::new(),
21879 help: String::new(),
21880 max_length: None,
21881 },
21882 crate::page_type::ExtensionField {
21883 name: "role".to_owned(),
21884 label: "Role".to_owned(),
21885 kind: crate::page_type::ExtensionFieldKind::Text,
21886 value: String::new(),
21887 help: String::new(),
21888 max_length: None,
21889 },
21890 ],
21891 )
21892 }
21893
21894 #[test]
21895 fn inline_extractor_groups_by_row_index() {
21896 let spec = sample_spec();
21897 let mut form = std::collections::HashMap::new();
21898 form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21899 form.insert("inline__team__0__role".to_owned(), "Engineer".to_owned());
21900 form.insert("inline__team__1__name".to_owned(), "Bob".to_owned());
21901 form.insert("inline__team__1__role".to_owned(), "Designer".to_owned());
21902 let rows = extract_inline_panel_rows(&form, &spec);
21903 assert_eq!(rows.len(), 2);
21904 assert_eq!(rows[0]["name"], "Ada");
21905 assert_eq!(rows[1]["role"], "Designer");
21906 }
21907
21908 #[test]
21909 fn inline_extractor_drops_tombstoned_rows() {
21910 let spec = sample_spec();
21911 let mut form = std::collections::HashMap::new();
21912 form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21913 form.insert("inline__team__1__name".to_owned(), "Bob".to_owned());
21914 form.insert("inline__team__1____deleted".to_owned(), "1".to_owned());
21915 let rows = extract_inline_panel_rows(&form, &spec);
21916 assert_eq!(rows.len(), 1);
21917 assert_eq!(rows[0]["name"], "Ada");
21918 }
21919
21920 #[test]
21921 fn inline_extractor_ignores_unknown_field_names() {
21922 let spec = sample_spec();
21923 let mut form = std::collections::HashMap::new();
21924 form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21925 form.insert("inline__team__0__bogus".to_owned(), "x".to_owned());
21926 let rows = extract_inline_panel_rows(&form, &spec);
21927 assert_eq!(rows.len(), 1);
21928 assert!(!rows[0].contains_key("bogus"));
21929 }
21930
21931 #[test]
21932 fn inline_extractor_ignores_unrelated_form_keys() {
21933 let spec = sample_spec();
21934 let mut form = std::collections::HashMap::new();
21935 form.insert("title".to_owned(), "irrelevant".to_owned());
21936 form.insert("inline__other_panel__0__name".to_owned(), "x".to_owned());
21937 let rows = extract_inline_panel_rows(&form, &spec);
21938 assert!(rows.is_empty());
21939 }
21940
21941 #[test]
21950 fn page_form_canonical_keys_include_schedule_and_menu_fields() {
21951 assert!(
21952 PAGE_FORM_CANONICAL_KEYS.contains(&"go_live_at"),
21953 "go_live_at must be in canonical keys — see #268"
21954 );
21955 assert!(
21956 PAGE_FORM_CANONICAL_KEYS.contains(&"expire_at"),
21957 "expire_at must be in canonical keys — see #268"
21958 );
21959 assert!(
21960 PAGE_FORM_CANONICAL_KEYS.contains(&"show_in_menus"),
21961 "show_in_menus must be in canonical keys — see #268"
21962 );
21963 }
21964}
21965
21966#[cfg(all(test, feature = "sqlite"))]
21967mod media_picker_tests {
21968 use super::{media_picker_payload, MediaPickerQuery};
21972 use crate::media::{Media, MediaCollection};
21973 use rustango::core::Model as _;
21974 use rustango::sql::{Auto, FetcherPool as _, Pool};
21975
21976 async fn mem_pool() -> Pool {
21977 let pool = Pool::connect("sqlite::memory:")
21978 .await
21979 .expect("in-memory sqlite");
21980 for schema in [&Media::SCHEMA, &MediaCollection::SCHEMA] {
21981 let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
21982 pool.dialect(),
21983 schema,
21984 );
21985 for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
21986 rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
21987 .await
21988 .expect("ddl");
21989 }
21990 }
21991 pool
21992 }
21993
21994 async fn mk_collection(pool: &Pool, name: &str, parent_id: Option<i64>, sort: i32) -> i64 {
21995 MediaCollection {
21996 id: Auto::Unset,
21997 name: name.to_owned(),
21998 parent_id,
21999 sort_order: sort,
22000 created_at: Auto::Unset,
22001 }
22002 .insert_pool(pool)
22003 .await
22004 .expect("collection insert");
22005 MediaCollection::objects()
22006 .fetch(pool)
22007 .await
22008 .expect("fetch")
22009 .into_iter()
22010 .find(|c| c.name == name)
22011 .and_then(|c| c.id.get().copied())
22012 .expect("collection id")
22013 }
22014
22015 async fn mk_media(
22016 pool: &Pool,
22017 title: &str,
22018 filename: &str,
22019 kind: &str,
22020 collection_id: Option<i64>,
22021 alt: &str,
22022 ) {
22023 Media {
22024 id: Auto::Unset,
22025 filename: filename.to_owned(),
22026 content_hash: format!("{:0>64}", title.len()),
22027 mime: if kind == "image" {
22028 "image/png"
22029 } else {
22030 "application/pdf"
22031 }
22032 .to_owned(),
22033 size: 123,
22034 kind: kind.to_owned(),
22035 width: (kind == "image").then_some(100),
22036 height: (kind == "image").then_some(80),
22037 storage_key: format!("k-{filename}"),
22038 title: title.to_owned(),
22039 alt_text: alt.to_owned(),
22040 description: String::new(),
22041 uploaded_by: None,
22042 collection_id,
22043 focal_point_x: None,
22044 focal_point_y: None,
22045 uploaded_at: Auto::Unset,
22046 }
22047 .insert_pool(pool)
22048 .await
22049 .expect("media insert");
22050 }
22051
22052 #[tokio::test]
22053 async fn default_kind_excludes_documents() {
22054 let pool = mem_pool().await;
22055 mk_media(&pool, "Photo", "p.png", "image", None, "").await;
22056 mk_media(&pool, "Spec", "s.pdf", "document", None, "").await;
22057 let body = media_picker_payload(&pool, &MediaPickerQuery::default())
22058 .await
22059 .expect("payload");
22060 let items = body["items"].as_array().expect("items");
22061 assert_eq!(items.len(), 1);
22062 assert_eq!(items[0]["kind"], "image");
22063 let q = MediaPickerQuery {
22065 kind: Some("any".to_owned()),
22066 ..Default::default()
22067 };
22068 let body = media_picker_payload(&pool, &q).await.expect("payload");
22069 assert_eq!(body["items"].as_array().expect("items").len(), 2);
22070 }
22071
22072 #[tokio::test]
22073 async fn collection_zero_means_uncategorized_only() {
22074 let pool = mem_pool().await;
22075 let cid = mk_collection(&pool, "Root", None, 0).await;
22076 mk_media(&pool, "In", "in.png", "image", Some(cid), "").await;
22077 mk_media(&pool, "Loose", "loose.png", "image", None, "").await;
22078 let q = MediaPickerQuery {
22079 collection: Some(0),
22080 ..Default::default()
22081 };
22082 let body = media_picker_payload(&pool, &q).await.expect("payload");
22083 let items = body["items"].as_array().expect("items");
22084 assert_eq!(items.len(), 1);
22085 assert_eq!(items[0]["title"], "Loose");
22086 assert_eq!(body["uncategorized_count"], 1);
22087 let q = MediaPickerQuery {
22089 collection: Some(cid),
22090 ..Default::default()
22091 };
22092 let body = media_picker_payload(&pool, &q).await.expect("payload");
22093 assert_eq!(body["items"].as_array().expect("items").len(), 1);
22094 assert_eq!(body["items"][0]["title"], "In");
22095 }
22096
22097 #[tokio::test]
22098 async fn search_matches_alt_text() {
22099 let pool = mem_pool().await;
22100 mk_media(
22101 &pool,
22102 "IMG_0001",
22103 "a.png",
22104 "image",
22105 None,
22106 "sunset glow over harbour",
22107 )
22108 .await;
22109 mk_media(&pool, "IMG_0002", "b.png", "image", None, "office desk").await;
22110 let q = MediaPickerQuery {
22111 q: Some("Sunset".to_owned()),
22112 ..Default::default()
22113 };
22114 let body = media_picker_payload(&pool, &q).await.expect("payload");
22115 let items = body["items"].as_array().expect("items");
22116 assert_eq!(items.len(), 1);
22117 assert_eq!(items[0]["title"], "IMG_0001");
22118 }
22119
22120 #[tokio::test]
22121 async fn pagination_math_and_has_more() {
22122 let pool = mem_pool().await;
22123 for i in 0..5 {
22124 mk_media(
22125 &pool,
22126 &format!("M{i}"),
22127 &format!("m{i}.png"),
22128 "image",
22129 None,
22130 "",
22131 )
22132 .await;
22133 }
22134 let q = MediaPickerQuery {
22135 limit: Some(2),
22136 offset: Some(0),
22137 ..Default::default()
22138 };
22139 let body = media_picker_payload(&pool, &q).await.expect("payload");
22140 assert_eq!(body["items"].as_array().expect("items").len(), 2);
22141 assert_eq!(body["total"], 5);
22142 assert_eq!(body["has_more"], true);
22143 let q = MediaPickerQuery {
22144 limit: Some(2),
22145 offset: Some(4),
22146 ..Default::default()
22147 };
22148 let body = media_picker_payload(&pool, &q).await.expect("payload");
22149 assert_eq!(body["items"].as_array().expect("items").len(), 1);
22150 assert_eq!(body["has_more"], false);
22151 let q = MediaPickerQuery {
22153 limit: Some(2),
22154 offset: Some(99),
22155 ..Default::default()
22156 };
22157 let body = media_picker_payload(&pool, &q).await.expect("payload");
22158 assert_eq!(body["items"].as_array().expect("items").len(), 0);
22159 }
22160
22161 #[tokio::test]
22162 async fn collections_come_back_in_dfs_order_with_depth() {
22163 let pool = mem_pool().await;
22164 let root_a = mk_collection(&pool, "Alpha", None, 0).await;
22165 let _sub = mk_collection(&pool, "Alpha Child", Some(root_a), 0).await;
22166 let _root_b = mk_collection(&pool, "Beta", None, 1).await;
22167 mk_media(&pool, "In A", "a.png", "image", Some(root_a), "").await;
22168 let body = media_picker_payload(&pool, &MediaPickerQuery::default())
22169 .await
22170 .expect("payload");
22171 let cols = body["collections"].as_array().expect("collections");
22172 let names: Vec<&str> = cols.iter().map(|c| c["name"].as_str().unwrap()).collect();
22173 assert_eq!(names, ["Alpha", "Alpha Child", "Beta"]);
22174 assert_eq!(cols[0]["depth"], 0);
22175 assert_eq!(cols[1]["depth"], 1);
22176 assert_eq!(cols[2]["depth"], 0);
22177 assert_eq!(cols[0]["count"], 1);
22178 assert_eq!(cols[2]["count"], 0);
22179 }
22180
22181 #[tokio::test]
22182 async fn ids_lookup_resolves_any_kind() {
22183 let pool = mem_pool().await;
22186 mk_media(&pool, "Photo", "p.png", "image", None, "").await;
22187 mk_media(&pool, "Spec", "s.pdf", "document", None, "").await;
22188 let all = media_picker_payload(
22189 &pool,
22190 &MediaPickerQuery {
22191 kind: Some("any".to_owned()),
22192 ..Default::default()
22193 },
22194 )
22195 .await
22196 .expect("payload");
22197 let ids: Vec<i64> = all["items"]
22198 .as_array()
22199 .unwrap()
22200 .iter()
22201 .map(|i| i["id"].as_i64().unwrap())
22202 .collect();
22203 let q = MediaPickerQuery {
22204 ids: Some(
22205 ids.iter()
22206 .map(|i| i.to_string())
22207 .collect::<Vec<_>>()
22208 .join(","),
22209 ),
22210 ..Default::default()
22211 };
22212 let body = media_picker_payload(&pool, &q).await.expect("payload");
22213 let items = body["items"].as_array().expect("items");
22214 assert_eq!(
22215 items.len(),
22216 2,
22217 "document resolves too when ids are explicit"
22218 );
22219 let q = MediaPickerQuery {
22221 ids: Some(
22222 ids.iter()
22223 .map(|i| i.to_string())
22224 .collect::<Vec<_>>()
22225 .join(","),
22226 ),
22227 kind: Some("image".to_owned()),
22228 ..Default::default()
22229 };
22230 let body = media_picker_payload(&pool, &q).await.expect("payload");
22231 assert_eq!(body["items"].as_array().expect("items").len(), 1);
22232 }
22233
22234 #[tokio::test]
22235 async fn image_items_carry_rendition_thumb_urls() {
22236 let pool = mem_pool().await;
22237 mk_media(&pool, "Pic", "p.png", "image", None, "").await;
22238 let body = media_picker_payload(&pool, &MediaPickerQuery::default())
22239 .await
22240 .expect("payload");
22241 let item = &body["items"][0];
22242 let thumb = item["thumb_url"].as_str().expect("thumb_url");
22243 assert!(
22244 thumb.starts_with("/__media__/fill-320x320"),
22245 "spec-first URL: {thumb}"
22246 );
22247 assert!(thumb.contains("v="), "cache-buster present: {thumb}");
22248 let preview = item["preview_url"].as_str().expect("preview_url");
22249 assert!(preview.contains("max-640x480"), "{preview}");
22250 }
22251}
22252
22253#[cfg(all(test, feature = "sqlite"))]
22254mod forms_list_tests {
22255 use super::forms_list_rows;
22257 use crate::forms::submit::FormEntry;
22258 use crate::snippet::Snippet;
22259 use rustango::core::Model as _;
22260 use rustango::sql::{Auto, FetcherPool as _, Pool};
22261
22262 async fn mem_pool() -> Pool {
22263 let pool = Pool::connect("sqlite::memory:")
22264 .await
22265 .expect("in-memory sqlite");
22266 for schema in [&Snippet::SCHEMA, &FormEntry::SCHEMA] {
22267 let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
22268 pool.dialect(),
22269 schema,
22270 );
22271 for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
22272 rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
22273 .await
22274 .expect("ddl");
22275 }
22276 }
22277 pool
22278 }
22279
22280 async fn mk_form(pool: &Pool, slug: &str, title: &str, fields: usize) -> i64 {
22281 let field_json: Vec<serde_json::Value> = (0..fields)
22282 .map(|i| serde_json::json!({"id": format!("f{i}"), "key": format!("k{i}"), "type": "text", "label": "F"}))
22283 .collect();
22284 Snippet {
22285 id: Auto::Unset,
22286 type_name: "form".to_owned(),
22287 folder_path: String::new(),
22288 slug: slug.to_owned(),
22289 title: title.to_owned(),
22290 body_markdown: String::new(),
22291 data: serde_json::json!({
22292 "settings": {},
22293 "pages": [{"id": "p1", "sections": [{"id": "s1", "rows": [{"id": "r1",
22294 "columns": [{"id": "c1", "width": 12, "fields": field_json}]}]}]}]
22295 }),
22296 created_at: Auto::Unset,
22297 updated_at: Auto::Unset,
22298 }
22299 .insert_pool(pool)
22300 .await
22301 .expect("form insert");
22302 Snippet::objects()
22303 .fetch(pool)
22304 .await
22305 .expect("fetch")
22306 .into_iter()
22307 .find(|s| s.slug == slug)
22308 .and_then(|s| s.id.get().copied())
22309 .expect("form id")
22310 }
22311
22312 async fn mk_entry(pool: &Pool, form_id: i64) {
22313 FormEntry {
22314 id: Auto::Unset,
22315 form_snippet_id: form_id,
22316 form_version: 1,
22317 source_page_id: 0,
22318 source_url: "/contact".to_owned(),
22319 data_json: serde_json::json!({"k0": "hi"}),
22320 locale: "en".to_owned(),
22321 ip: String::new(),
22322 submitted_at: Auto::Unset,
22323 }
22324 .insert_pool(pool)
22325 .await
22326 .expect("entry insert");
22327 }
22328
22329 #[tokio::test]
22330 async fn rows_carry_field_and_submission_counts() {
22331 let pool = mem_pool().await;
22332 let a = mk_form(&pool, "contact", "Contact", 3).await;
22333 let b = mk_form(&pool, "rsvp", "RSVP", 1).await;
22334 mk_entry(&pool, a).await;
22335 mk_entry(&pool, a).await;
22336 let rows = forms_list_rows(&pool).await.expect("rows");
22337 assert_eq!(rows.len(), 2);
22338 let by_slug = |slug: &str| rows.iter().find(|r| r["slug"] == slug).expect("row");
22339 let ra = by_slug("contact");
22340 assert_eq!(ra["fields"], 3);
22341 assert_eq!(ra["submissions"], 2);
22342 assert!(
22343 ra["last_submission"].as_str().unwrap().len() >= 16,
22344 "has a timestamp"
22345 );
22346 assert_eq!(ra["build_url"], format!("/cms-admin/forms/{a}/build"));
22347 assert_eq!(
22348 ra["submissions_url"],
22349 format!("/cms-admin/forms/{a}/submissions")
22350 );
22351 let rb = by_slug("rsvp");
22352 assert_eq!(rb["fields"], 1);
22353 assert_eq!(rb["submissions"], 0);
22354 assert_eq!(rb["last_submission"], "");
22355 assert_eq!(rb["delete_url"], format!("/cms-admin/library/{b}/delete"));
22356 }
22357
22358 #[tokio::test]
22359 async fn only_form_snippets_appear() {
22360 let pool = mem_pool().await;
22361 mk_form(&pool, "contact", "Contact", 1).await;
22362 Snippet {
22363 id: Auto::Unset,
22364 type_name: "branding".to_owned(),
22365 folder_path: String::new(),
22366 slug: "site-branding".to_owned(),
22367 title: "Branding".to_owned(),
22368 body_markdown: String::new(),
22369 data: serde_json::json!({}),
22370 created_at: Auto::Unset,
22371 updated_at: Auto::Unset,
22372 }
22373 .insert_pool(&pool)
22374 .await
22375 .expect("snippet insert");
22376 let rows = forms_list_rows(&pool).await.expect("rows");
22377 assert_eq!(rows.len(), 1);
22378 assert_eq!(rows[0]["slug"], "contact");
22379 }
22380
22381 #[test]
22382 fn user_admin_is_superuser_only() {
22383 assert_eq!(super::user_admin_denial_target(Some(true)), None);
22389 assert_eq!(
22390 super::user_admin_denial_target(Some(false)),
22391 Some("/cms-admin/no-access")
22392 );
22393 assert_eq!(super::user_admin_denial_target(None), Some("/login"));
22394 }
22395
22396 #[test]
22397 fn mcp_key_admin_handlers_enforce_the_superuser_gate() {
22398 let src = include_str!("handlers.rs");
22405 for name in ["users_mcp_key_create", "users_mcp_key_revoke"] {
22406 let start = src
22407 .find(&format!("pub async fn {name}("))
22408 .unwrap_or_else(|| panic!("handler {name} not found"));
22409 let rest = &src[start + 1..];
22411 let end = rest.find("\npub async fn ").unwrap_or(rest.len());
22412 assert!(
22413 rest[..end].contains("require_superuser_for_user_admin(session_user.as_ref())"),
22414 "{name} is missing the superuser gate (#646)"
22415 );
22416 }
22417 }
22418}
22419
22420#[cfg(test)]
22421mod password_reset_key_tests {
22422 use super::{password_reset_key, password_reset_scope};
22423 use rustango::auth_flows::PasswordReset;
22424 use std::time::Duration;
22425
22426 const SECRET: &[u8] = b"process-wide-signing-secret";
22427 const BASE: &str = "/cms-admin/password-reset/confirm";
22428
22429 fn link(tenant: &str, hash: &str) -> String {
22430 PasswordReset::issue(
22431 &password_reset_scope(tenant),
22432 BASE,
22433 1,
22434 &password_reset_key(SECRET, tenant, hash),
22435 Duration::from_secs(3600),
22436 )
22437 }
22438
22439 #[test]
22440 fn a_link_verifies_for_the_tenant_and_password_it_was_issued_for() {
22441 let url = link("acme", "$argon2id$v=19$old");
22442 let key = password_reset_key(SECRET, "acme", "$argon2id$v=19$old");
22443 assert_eq!(PasswordReset::verify(&password_reset_scope("acme"), &url, &key).ok(), Some(1));
22444 }
22445
22446 #[test]
22447 fn a_link_issued_on_one_tenant_does_not_verify_on_another() {
22448 let url = link("acme", "$argon2id$v=19$same");
22450 let other = password_reset_key(SECRET, "globex", "$argon2id$v=19$same");
22451 assert!(PasswordReset::verify(&password_reset_scope("globex"), &url, &other).is_err());
22452 }
22453
22454 #[test]
22455 fn a_link_stops_verifying_once_the_password_changes() {
22456 let url = link("acme", "$argon2id$v=19$before");
22457 let after = password_reset_key(SECRET, "acme", "$argon2id$v=19$after");
22458 assert!(PasswordReset::verify(&password_reset_scope("acme"), &url, &after).is_err());
22459 }
22460}
22461
22462#[cfg(all(test, feature = "sqlite"))]
22463mod publish_gate_tests {
22464 use super::{apply_page_edit, PageEditActor, PageEditRefusal};
22467 use crate::page::{Page, PageStatus};
22468 use crate::page_type_model::PageType;
22469 use rustango::core::Column as _;
22470 use rustango::sql::{Auto, Pool};
22471
22472 async fn mem_pool() -> Pool {
22473 let pool = Pool::connect("sqlite::memory:").await.expect("in-memory sqlite");
22474 for entry in inventory::iter::<rustango::core::ModelEntry> {
22475 if !entry.schema.managed {
22476 continue;
22477 }
22478 let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
22479 pool.dialect(),
22480 entry.schema,
22481 );
22482 for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
22483 rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
22484 .await
22485 .expect("ddl");
22486 }
22487 }
22488 pool
22489 }
22490
22491 async fn draft(pool: &Pool) -> Page {
22492 let mut pt = PageType {
22493 id: Auto::Unset,
22494 app_label: "cms".to_owned(),
22495 type_name: "TestPage".to_owned(),
22496 verbose_name: "Test page".to_owned(),
22497 default_template: "page.html".to_owned(),
22498 view_mode: "auto".to_owned(),
22499 is_creatable: true,
22500 allowed_parent_types: serde_json::json!([]),
22501 allowed_child_types: serde_json::json!([]),
22502 workflow: String::new(),
22503 created_at: Auto::Unset,
22504 updated_at: Auto::Unset,
22505 };
22506 pt.save_pool(pool).await.expect("page type");
22507 let mut p = draft_template(pt.id.get().copied().expect("type id"));
22508 p.save_pool(pool).await.expect("page");
22509 p
22510 }
22511
22512 fn draft_template(type_id: i64) -> Page {
22513 Page {
22514 id: Auto::Unset,
22515 page_type_id: type_id,
22516 title: "Draft".to_owned(),
22517 slug: "draft".to_owned(),
22518 path: "0001/".to_owned(),
22519 url_path: "/draft".to_owned(),
22520 preview_path: String::new(),
22521 template_override: String::new(),
22522 depth: 1,
22523 parent_id: None,
22524 locale_variant_of: None,
22525 alias_of: None,
22526 theme_id: None,
22527 sort_order: 0,
22528 status: PageStatus::Draft.as_str().to_owned(),
22529 published_at: None,
22530 last_published_at: None,
22531 go_live_at: None,
22532 expire_at: None,
22533 seo_title: String::new(),
22534 seo_description: String::new(),
22535 robots_index: true,
22536 sitemap_priority: 0.5,
22537 show_in_menus: true,
22538 og_title: String::new(),
22539 og_description: String::new(),
22540 og_image_media_id: None,
22541 twitter_card: "summary".to_owned(),
22542 notification_pre_published_sent: false,
22543 created_at: Auto::Unset,
22544 updated_at: Auto::Unset,
22545 }
22546 }
22547
22548 async fn save(
22549 pool: &Pool,
22550 page: &Page,
22551 status: &str,
22552 go_live_days: Option<i64>,
22553 superuser: bool,
22554 ) -> Result<String, &'static str> {
22555 let mut form = crate::page_form::prefill(pool, page).await;
22556 form.insert("status".into(), status.to_owned());
22557 match go_live_days {
22558 Some(d) => form.insert(
22559 "go_live_at".into(),
22560 (chrono::Utc::now() + chrono::Duration::days(d))
22561 .format("%Y-%m-%dT%H:%M")
22562 .to_string(),
22563 ),
22564 None => form.remove("go_live_at"),
22565 };
22566 let actor = PageEditActor { id: 999, username: "editor".to_owned(), is_superuser: superuser };
22568 let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
22569 std::sync::Arc::new(crate::cache_invalidate::Noop);
22570 let id = page.id.get().copied().expect("id");
22571 match apply_page_edit(pool, "t", &invalidator, None, "", false, id, &form, Some(&actor))
22572 .await
22573 .expect("save")
22574 {
22575 Ok(o) => Ok(o.page.status),
22576 Err(PageEditRefusal::PublishDenied) => Err("publish denied"),
22577 Err(PageEditRefusal::ReviewRequired { .. }) => Err("review required"),
22578 Err(_) => Err("other refusal"),
22579 }
22580 }
22581
22582 async fn stored_status(pool: &Pool, page: &Page) -> String {
22583 Page::objects()
22584 .where_(Page::id.eq(page.id.get().copied().expect("id")))
22585 .first(pool)
22586 .await
22587 .expect("query")
22588 .expect("page")
22589 .status
22590 }
22591
22592 async fn stored_theme(pool: &Pool, page: &Page) -> Option<i64> {
22593 Page::objects()
22594 .where_(Page::id.eq(page.id.get().copied().expect("id")))
22595 .first(pool)
22596 .await
22597 .expect("query")
22598 .expect("page")
22599 .theme_id
22600 }
22601
22602 #[tokio::test]
22605 async fn an_editor_save_keeps_the_page_theme() {
22606 let pool = mem_pool().await;
22607 let mut page = draft(&pool).await;
22608 let mut theme = crate::theme::tests::fixture_theme();
22609 theme.save_pool(&pool).await.expect("theme");
22610 let theme_id = theme.id.get().copied().expect("theme id");
22611 page.theme_id = Some(theme_id);
22612 page.save_pool(&pool).await.expect("set theme");
22613
22614 let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
22615 std::sync::Arc::new(crate::cache_invalidate::Noop);
22616 let id = page.id.get().copied().expect("id");
22617 let mut form = crate::page_form::prefill(&pool, &page).await;
22618 form.remove("theme_id");
22619 assert!(apply_page_edit(&pool, "t", &invalidator, None, "", false, id, &form, None).await.expect("save").is_ok());
22620 assert_eq!(stored_theme(&pool, &page).await, Some(theme_id), "a form without the field keeps it");
22621
22622 form.insert("theme_id".into(), String::new());
22623 assert!(apply_page_edit(&pool, "t", &invalidator, None, "", false, id, &form, None).await.expect("save").is_ok());
22624 assert_eq!(stored_theme(&pool, &page).await, None, "posted empty clears it");
22625 }
22626
22627 async fn publish_headline_schema(pool: &Pool, type_id: i64) {
22629 let document = serde_json::json!({
22630 "nodes": [{ "kind": "field", "key": "headline", "label": "Headline", "widget": "text" }]
22631 });
22632 rustango::sql::raw_execute_pool(
22633 pool,
22634 "INSERT INTO cms_page_type_schema (page_type_id, status, version, document) \
22635 VALUES (?, 'published', 1, ?)",
22636 vec![
22637 rustango::core::SqlValue::I64(type_id),
22638 rustango::core::SqlValue::Json(document),
22639 ],
22640 )
22641 .await
22642 .expect("schema");
22643 }
22644
22645 #[tokio::test]
22648 async fn the_new_page_form_shows_the_type_fields() {
22649 let pool = mem_pool().await;
22650 let type_id = draft(&pool).await.page_type_id;
22651 publish_headline_schema(&pool, type_id).await;
22652 let mut tera = tera::Tera::default();
22653 crate::admin::register_templates(&mut tera).expect("templates");
22654 let mut ctx = tera::Context::new();
22655 super::insert_type_fields(&mut ctx, &tera, &pool, None, Vec::new(), 0, type_id, None).await;
22656 let body = ctx
22657 .get("builder_body_html")
22658 .and_then(serde_json::Value::as_str)
22659 .expect("builder body on the new form")
22660 .to_owned();
22661 assert!(body.contains("pb__headline"), "headline input missing: {body}");
22662 }
22663
22664 #[tokio::test]
22667 async fn creating_a_page_saves_its_type_fields() {
22668 let pool = mem_pool().await;
22669 let page = draft(&pool).await;
22670 publish_headline_schema(&pool, page.page_type_id).await;
22671 let page_type = PageType::objects()
22672 .where_(PageType::id.eq(page.page_type_id))
22673 .first(&pool)
22674 .await
22675 .expect("type query");
22676 let id = page.id.get().copied().expect("id");
22677 let form = std::collections::HashMap::from([("pb__headline".to_owned(), "Hello".to_owned())]);
22678 super::save_type_content(&pool, page_type.as_ref(), page.page_type_id, id, &form)
22679 .await
22680 .expect("save");
22681 let data = crate::page_builder::model::data_for_page(&pool, id)
22682 .await
22683 .expect("builder data query")
22684 .expect("builder data row")
22685 .data;
22686 assert_eq!(data["headline"], "Hello", "{data}");
22687 }
22688
22689 #[tokio::test]
22690 async fn going_live_by_any_route_needs_the_publish_right() {
22691 let pool = mem_pool().await;
22692 let page = draft(&pool).await;
22693 for (status, go_live) in [
22694 ("archived", None),
22695 ("published", None),
22696 ("draft", Some(1)),
22698 ("scheduled", Some(-1)),
22700 ] {
22701 assert_eq!(
22702 save(&pool, &page, status, go_live, false).await,
22703 Err("publish denied"),
22704 "{status} / {go_live:?}"
22705 );
22706 assert_eq!(stored_status(&pool, &page).await, "draft", "nothing written");
22707 }
22708 assert_eq!(
22709 save(&pool, &page, "scheduled", None, false).await,
22710 Ok("draft".to_owned()),
22711 "scheduled without a date is parked as a draft, so it is allowed"
22712 );
22713 assert_eq!(
22714 save(&pool, &page, "draft", Some(1), true).await,
22715 Ok("scheduled".to_owned()),
22716 "the publish right schedules"
22717 );
22718 }
22719
22720 async fn bind_review(pool: &Pool, type_id: i64, reapproval: bool) -> crate::workflow::Workflow {
22725 let mut wf = crate::workflow::Workflow {
22726 id: Auto::Unset,
22727 name: "Owner review".to_owned(),
22728 description: String::new(),
22729 active: true,
22730 require_reapproval_on_edit: reapproval,
22731 created_at: Auto::Unset,
22732 updated_at: Auto::Unset,
22733 };
22734 wf.save_pool(pool).await.expect("workflow");
22735 rustango::sql::raw_execute_pool(pool, "INSERT INTO rustango_roles (id, name, description) VALUES (1, 'Owner', '')", Vec::new())
22736 .await
22737 .expect("role");
22738 let mut task = crate::workflow::WorkflowTask {
22739 id: Auto::Unset,
22740 workflow_id: wf.id.get().copied().expect("id"),
22741 name: "Owner checks".to_owned(),
22742 role_id: 1,
22743 sort_order: 10,
22744 kind: "group_approval".to_owned(),
22745 webhook_url: String::new(),
22746 };
22747 task.save_pool(pool).await.expect("task");
22748 let mut pt = PageType::objects()
22749 .where_(PageType::id.eq(type_id))
22750 .first(pool)
22751 .await
22752 .expect("q")
22753 .expect("type");
22754 pt.workflow = "Owner review".to_owned();
22755 pt.save_pool(pool).await.expect("bind");
22756 wf
22757 }
22758
22759 #[tokio::test]
22760 async fn a_review_workflow_cannot_be_published_around() {
22761 let pool = mem_pool().await;
22762 let page = draft(&pool).await;
22763 let mut wf = bind_review(&pool, page.page_type_id, false).await;
22764
22765 assert_eq!(save(&pool, &page, "published", None, false).await, Err("review required"));
22766 assert_eq!(save(&pool, &page, "draft", Some(1), false).await, Err("review required"), "nor scheduled");
22767 assert_eq!(stored_status(&pool, &page).await, "draft");
22768 assert_eq!(save(&pool, &page, "draft", None, false).await, Ok("draft".to_owned()), "drafts still save");
22769 assert_eq!(save(&pool, &page, "published", None, true).await, Ok("published".to_owned()), "the owner can");
22770
22771 let other = draft_named(&pool, page.page_type_id, "second").await;
22773 wf.name = "Studio review".to_owned();
22774 wf.save_pool(&pool).await.expect("rename");
22775 assert_eq!(crate::workflow::rebind_page_types(&pool, "Owner review", "Studio review").await.expect("rebind"), 1);
22776 assert_eq!(save(&pool, &other, "published", None, false).await, Err("review required"));
22777 }
22778
22779 async fn retitle(pool: &Pool, page: &Page, title: &str, actor: Option<&PageEditActor>) -> super::PageEditOutcome {
22781 let mut form = crate::page_form::prefill(pool, page).await;
22782 form.insert("title".into(), title.to_owned());
22783 let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
22784 std::sync::Arc::new(crate::cache_invalidate::Noop);
22785 let id = page.id.get().copied().expect("id");
22786 match apply_page_edit(pool, "t", &invalidator, None, "", false, id, &form, actor).await.expect("save") {
22787 Ok(o) => o,
22788 Err(_) => panic!("refused"),
22789 }
22790 }
22791
22792 async fn stored_title(pool: &Pool, page: &Page) -> String {
22793 Page::objects()
22794 .where_(Page::id.eq(page.id.get().copied().expect("id")))
22795 .first(pool)
22796 .await
22797 .expect("query")
22798 .expect("page")
22799 .title
22800 }
22801
22802 #[tokio::test]
22806 async fn a_live_page_edit_waits_for_review() {
22807 let pool = mem_pool().await;
22808 let page = draft(&pool).await;
22809 bind_review(&pool, page.page_type_id, true).await;
22810 assert_eq!(save(&pool, &page, "published", None, true).await, Ok("published".to_owned()));
22811 let id = page.id.get().copied().expect("id");
22812 let mut mia = rustango::tenancy::auth::User {
22813 id: Auto::Unset,
22814 username: "mia".to_owned(),
22815 password_hash: String::new(),
22816 email: None,
22817 is_superuser: false,
22818 active: true,
22819 created_at: chrono::Utc::now(),
22820 data: serde_json::json!({}),
22821 password_changed_at: None,
22822 sessions_revoked_at: None,
22823 };
22824 mia.save_pool(&pool).await.expect("user");
22825 let editor = PageEditActor { id: mia.id.get().copied().expect("id"), username: "mia".to_owned(), is_superuser: false };
22826
22827 let out = retitle(&pool, &page, "Proposed", Some(&editor)).await;
22828 assert!(out.held_for_review && out.reapproval_kicked);
22829 assert_eq!(stored_title(&pool, &page).await, "Draft", "the live page is unchanged");
22830 let held = crate::pending_change::for_page(&pool, id).await.expect("q").expect("held");
22831 assert_eq!(held.form_map().get("title").map(String::as_str), Some("Proposed"));
22832 let mut state = crate::workflow::active_state_for_page(&pool, id).await.expect("q").expect("review started");
22833
22834 let tasks = crate::workflow::tasks_for(&pool, state.workflow_id).await.expect("tasks");
22836 crate::workflow::approve_current(&pool, &mut state, &tasks, editor.id, "").await.expect("approve");
22837 let applied = retitle(&pool, &page, "Proposed", None).await;
22838 assert!(!applied.held_for_review);
22839 assert_eq!(stored_title(&pool, &page).await, "Proposed");
22840
22841 retitle(&pool, &page, "Second try", Some(&editor)).await;
22843 let mut state = crate::workflow::active_state_for_page(&pool, id).await.expect("q").expect("review restarted");
22844 crate::workflow::cancel(&pool, &mut state, editor.id).await.expect("cancel");
22845 assert!(crate::pending_change::for_page(&pool, id).await.expect("q").is_none());
22846
22847 retitle(&pool, &page, "Third try", Some(&editor)).await;
22849 let owner = PageEditActor { id: 1, username: "owner".to_owned(), is_superuser: true };
22850 assert!(!retitle(&pool, &page, "Owner's", Some(&owner)).await.held_for_review);
22851 assert_eq!(stored_title(&pool, &page).await, "Owner's");
22852 assert!(crate::pending_change::for_page(&pool, id).await.expect("q").is_none());
22853 }
22854
22855 async fn draft_named(pool: &Pool, type_id: i64, slug: &str) -> Page {
22856 let mut p = draft_template(type_id);
22857 slug.clone_into(&mut p.slug);
22858 p.path = "0002/".to_owned();
22859 p.url_path = format!("/{slug}");
22860 p.save_pool(pool).await.expect("page");
22861 p
22862 }
22863}
22864
22865#[cfg(test)]
22866mod active_upload_tests {
22867 use super::refuse_active_upload;
22868
22869 #[test]
22870 fn page_like_types_are_refused_and_media_is_not() {
22871 for bad in ["text/html", "application/xhtml+xml", "text/javascript", "application/xml"] {
22872 assert!(refuse_active_upload(bad).is_err(), "{bad}");
22873 }
22874 for ok in ["image/png", "image/svg+xml", "application/pdf", "text/plain", "video/mp4"] {
22875 assert!(refuse_active_upload(ok).is_ok(), "{ok}");
22876 }
22877 }
22878}