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;
22
23fn messages_secret() -> &'static [u8] {
35 static SECRET: OnceLock<Vec<u8>> = OnceLock::new();
36 SECRET.get_or_init(|| {
37 let mut k = [0u8; 32];
42 getrandom::fill(&mut k).expect("OS CSPRNG unavailable");
43 k.to_vec()
44 })
45}
46
47async fn sanitized_extension_form(
57 handler: &dyn crate::page_type::PageTypeHandler,
58 pool: &rustango::sql::Pool,
59 page_id: i64,
60 form_map: &std::collections::HashMap<String, String>,
61) -> std::collections::HashMap<String, String> {
62 let mut out = form_map.clone();
63 if let Ok(widgets) = handler.widgets(pool, page_id).await {
64 for w in widgets {
65 if w.kind == crate::widget::WidgetKind::RichText {
66 if let Some(raw) = out.get(&w.name) {
67 let cleaned = crate::markdown::sanitize_html(raw);
68 out.insert(w.name.clone(), cleaned);
69 }
70 }
71 }
72 }
73 out
74}
75
76const PREVIEW_TOKEN_TTL_SECS: i64 = 3600;
80
81pub(crate) fn render_with_csrf(
95 state: &super::AdminState,
96 headers: &HeaderMap,
97 template: &str,
98 ctx: &mut Context,
99) -> Result<Response, AdminError> {
100 let user_pref = ctx
106 .get("user_lang_pref")
107 .and_then(|v| v.as_str())
108 .map(str::to_owned);
109 let tenant_default = super::i18n::tenant_default_locale();
110 let lang = super::i18n::negotiate(
111 headers.get(header::COOKIE).and_then(|v| v.to_str().ok()),
112 headers
113 .get(header::ACCEPT_LANGUAGE)
114 .and_then(|v| v.to_str().ok()),
115 user_pref.as_deref(),
116 tenant_default.as_deref(),
117 );
118 let lang_dir = rustango::i18n::text_direction(&lang);
119 ctx.insert("LANG", &lang);
120 ctx.insert("LANG_DIR", lang_dir);
121 let csrf_cookie = rustango::forms::csrf::stamp_into_context(headers, ctx);
122 let msg_clear = rustango::messages::stamp_into_context(messages_secret(), headers, ctx);
123 let html = state.tera.render(template, ctx)?;
124 let mut resp = Html(html).into_response();
125 if let Some(c) = csrf_cookie {
126 if let Ok(v) = HeaderValue::from_str(&c) {
127 resp.headers_mut().append(header::SET_COOKIE, v);
128 }
129 }
130 if let Some(c) = msg_clear {
131 if let Ok(v) = HeaderValue::from_str(&c) {
132 resp.headers_mut().append(header::SET_COOKIE, v);
133 }
134 }
135 Ok(resp)
136}
137
138fn redirect_named_with_message(
146 name: &'static str,
147 level: MsgLevel,
148 body: &str,
149 headers: &HeaderMap,
150) -> Result<Response, AdminError> {
151 let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
152 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
153 let body = super::i18n::tr(headers, body, &[]);
156 Ok(rustango::messages::redirect_with_message(
157 messages_secret(),
158 headers,
159 level,
160 &body,
161 &url,
162 ))
163}
164
165fn redirect_named_with_message_args(
172 name: &'static str,
173 level: MsgLevel,
174 key: &str,
175 args: &[(&str, &str)],
176 headers: &HeaderMap,
177) -> Result<Response, AdminError> {
178 let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
179 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
180 let body = super::i18n::tr(headers, key, args);
181 Ok(rustango::messages::redirect_with_message(
182 messages_secret(),
183 headers,
184 level,
185 &body,
186 &url,
187 ))
188}
189
190fn redirect_named_with_message_plural(
195 name: &'static str,
196 level: MsgLevel,
197 key: &str,
198 n: i64,
199 args: &[(&str, &str)],
200 headers: &HeaderMap,
201) -> Result<Response, AdminError> {
202 let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
203 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
204 let body = super::i18n::tr_plural(headers, key, n, args);
205 Ok(rustango::messages::redirect_with_message(
206 messages_secret(),
207 headers,
208 level,
209 &body,
210 &url,
211 ))
212}
213
214fn redirect_named_with_params_and_message_plural(
217 name: &'static str,
218 params: &[(&str, String)],
219 level: MsgLevel,
220 key: &str,
221 n: i64,
222 args: &[(&str, &str)],
223 headers: &HeaderMap,
224) -> Result<Response, AdminError> {
225 let owned: std::collections::HashMap<String, String> = params
226 .iter()
227 .map(|(k, v)| ((*k).to_owned(), v.clone()))
228 .collect();
229 let url = rustango::urls::reverse_owned(name, &owned)
230 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
231 let body = super::i18n::tr_plural(headers, key, n, args);
232 Ok(rustango::messages::redirect_with_message(
233 messages_secret(),
234 headers,
235 level,
236 &body,
237 &url,
238 ))
239}
240
241fn unauthorized_no_session() -> Response {
259 unauthorized_no_session_for(None)
260}
261
262fn unauthorized_no_session_for(headers: Option<&HeaderMap>) -> Response {
267 let wants_json = headers
268 .map(|h| {
269 let accept = h
270 .get(header::ACCEPT)
271 .and_then(|v| v.to_str().ok())
272 .unwrap_or("");
273 if accept.contains("application/json") {
274 return true;
275 }
276 h.get("x-requested-with")
277 .and_then(|v| v.to_str().ok())
278 .is_some_and(|v| v.eq_ignore_ascii_case("XMLHttpRequest"))
279 })
280 .unwrap_or(false);
281 let t = |key: &str| -> String {
284 match headers {
285 Some(h) => super::i18n::tr(h, key, &[]),
286 None => key.to_owned(),
287 }
288 };
289 if wants_json {
290 let payload = serde_json::json!({
291 "error": "session_expired",
292 "message": t("Sign in again to keep uploading."),
293 "login_url": "/login?next=/cms-admin/",
294 });
295 return (
296 axum::http::StatusCode::UNAUTHORIZED,
297 [(axum::http::header::CONTENT_TYPE, "application/json")],
298 serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
299 )
300 .into_response();
301 }
302 let lang = headers
303 .map(|h| {
304 super::i18n::negotiate(
305 h.get(header::COOKIE).and_then(|v| v.to_str().ok()),
306 h.get(header::ACCEPT_LANGUAGE).and_then(|v| v.to_str().ok()),
307 None,
308 super::i18n::tenant_default_locale().as_deref(),
309 )
310 })
311 .unwrap_or_else(|| "en".to_owned());
312 let dir = rustango::i18n::text_direction(&lang);
313 const STYLE: &str = r#"<style>
314body{font:14px/1.5 -apple-system,system-ui,sans-serif;color:#222;background:#fafafa;margin:0;padding:48px 20px}
315.box{max-width:560px;margin:0 auto;padding:32px;background:#fff;border-radius:12px;box-shadow:0 2px 8px rgba(0,0,0,.08)}
316h1{font-size:18px;margin:0 0 12px}
317p{margin:0 0 12px;color:#444}
318ul{margin:0 0 12px;padding-left:20px;color:#444}
319li{margin:4px 0}
320a{color:#1565c0}
321</style>"#;
322 let mut body = String::with_capacity(STYLE.len() + 1024);
323 body.push_str("<!doctype html>\n<html lang=\"");
324 body.push_str(&crate::forms::render::html_escape(&lang));
325 body.push_str("\" dir=\"");
326 body.push_str(dir);
327 body.push_str("\"><head><meta charset=\"utf-8\"><title>");
328 body.push_str(&crate::forms::render::html_escape(&t("Session expired")));
329 body.push_str(" — ");
330 body.push_str(&crate::forms::render::html_escape(&t("CMS Admin")));
331 body.push_str("</title>");
332 body.push_str(STYLE);
333 body.push_str("</head><body><div class=\"box\">\n<h1>");
334 body.push_str(&crate::forms::render::html_escape(&t(
335 "Your session has expired",
336 )));
337 body.push_str("</h1>\n<p>");
338 body.push_str(&crate::forms::render::html_escape(&t(
339 "The form couldn't be saved because your admin session decoded as anonymous. The most likely causes:",
340 )));
341 body.push_str("</p>\n<ul>\n<li>");
342 body.push_str(&crate::forms::render::html_escape(&t(
343 "Your login session expired or was signed out from another tab.",
344 )));
345 body.push_str("</li>\n<li>");
346 body.push_str(&crate::forms::render::html_escape(&t(
347 "The cookie was issued for a different tenant slug.",
348 )));
349 body.push_str("</li>\n<li>");
350 body.push_str(&crate::forms::render::html_escape(&t(
351 "On sqlite/mysql builds the framework's tenant session store may not be wired up yet (see issue #259).",
352 )));
353 body.push_str("</li>\n</ul>\n<p><a href=\"/login?next=/cms-admin/\">");
354 body.push_str(&crate::forms::render::html_escape(&t("Sign back in")));
355 body.push_str("</a>");
356 body.push_str(&crate::forms::render::html_escape(&t(
357 ", then re-submit the form.",
358 )));
359 body.push_str("</p>\n</div></body></html>");
360 (
361 axum::http::StatusCode::UNAUTHORIZED,
362 [(axum::http::header::CONTENT_TYPE, "text/html; charset=utf-8")],
363 body,
364 )
365 .into_response()
366}
367
368pub(crate) fn redirect_named_with_params_and_message(
371 name: &'static str,
372 params: &[(&str, String)],
373 level: MsgLevel,
374 body: &str,
375 headers: &HeaderMap,
376) -> Result<Response, AdminError> {
377 let owned: std::collections::HashMap<String, String> = params
378 .iter()
379 .map(|(k, v)| ((*k).to_owned(), v.clone()))
380 .collect();
381 let url = rustango::urls::reverse_owned(name, &owned)
382 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
383 let body = super::i18n::tr(headers, body, &[]);
385 Ok(rustango::messages::redirect_with_message(
386 messages_secret(),
387 headers,
388 level,
389 &body,
390 &url,
391 ))
392}
393
394pub(crate) fn redirect_named_with_params_and_message_args(
398 name: &'static str,
399 params: &[(&str, String)],
400 level: MsgLevel,
401 key: &str,
402 args: &[(&str, &str)],
403 headers: &HeaderMap,
404) -> Result<Response, AdminError> {
405 let owned: std::collections::HashMap<String, String> = params
406 .iter()
407 .map(|(k, v)| ((*k).to_owned(), v.clone()))
408 .collect();
409 let url = rustango::urls::reverse_owned(name, &owned)
410 .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
411 let body = super::i18n::tr(headers, key, args);
412 Ok(rustango::messages::redirect_with_message(
413 messages_secret(),
414 headers,
415 level,
416 &body,
417 &url,
418 ))
419}
420
421fn redirect_after_page_save(
436 action: &str,
437 page_id: i64,
438 parent_id: Option<i64>,
439 body: &str,
440 headers: &HeaderMap,
441) -> Result<Response, AdminError> {
442 let url = match action {
443 "continue" => rustango::urls::reverse_owned(
444 "rcms-admin:pages:edit",
445 &std::iter::once(("id".to_owned(), page_id.to_string())).collect(),
446 )
447 .map_err(|e| AdminError::Validation(format!("url reversal of `pages:edit` failed: {e}")))?,
448 "addanother" => {
449 let base =
450 rustango::urls::reverse("rcms-admin:pages:new", &std::collections::HashMap::new())
451 .map_err(|e| {
452 AdminError::Validation(format!("url reversal of `pages:new` failed: {e}"))
453 })?;
454 match parent_id {
455 Some(pid) => format!("{base}?parent={pid}"),
456 None => base,
457 }
458 }
459 _ => rustango::urls::reverse("rcms-admin:pages:list", &std::collections::HashMap::new())
460 .map_err(|e| {
461 AdminError::Validation(format!("url reversal of `pages:list` failed: {e}"))
462 })?,
463 };
464 Ok(rustango::messages::redirect_with_message(
465 messages_secret(),
466 headers,
467 MsgLevel::Success,
468 body,
469 &url,
470 ))
471}
472
473pub(crate) fn user_email(u: &rustango::tenancy::auth::User) -> String {
477 u.email
478 .as_deref()
479 .map(str::trim)
480 .filter(|e| !e.is_empty())
481 .or_else(|| u.data.get("email").and_then(|v| v.as_str()).map(str::trim))
482 .unwrap_or("")
483 .to_owned()
484}
485
486pub async fn add_chrome(
503 ctx: &mut Context,
504 tenant: &Tenant,
505 active_tab: &str,
506 session_user: Option<&rustango::tenancy::auth::User>,
507) {
508 add_chrome_sync(ctx, tenant, active_tab);
509 super::i18n::maybe_refresh_overrides(tenant.pool()).await;
512 if let Some(user) = session_user {
513 add_user_chrome(ctx, user, tenant.pool()).await;
514 }
515 add_branding_urls(ctx, tenant).await;
517}
518
519pub(crate) async fn add_branding_urls(ctx: &mut Context, tenant: &Tenant) {
527 let mut site_name = tenant.org.display_name.clone();
530 if let Ok(Some(row)) = crate::site_setting::get(tenant.pool(), "branding").await {
531 if let Some(n) = row.value_json.get("site_name").and_then(|v| v.as_str()).filter(|n| !n.trim().is_empty()) {
532 n.trim().clone_into(&mut site_name);
533 }
534 let is_set = |key: &str| {
535 row.value_json
536 .get(key)
537 .and_then(|v| v.as_str())
538 .is_some_and(|s| !s.is_empty())
539 };
540 if is_set("logo_storage_key") {
541 ctx.insert("branding_logo_url", "/__cms-branding/logo");
542 }
543 if is_set("favicon_storage_key") {
544 ctx.insert("branding_favicon_url", "/__cms-branding/favicon");
545 }
546 }
547 ctx.insert("site_name", &site_name);
548}
549
550fn add_chrome_sync(ctx: &mut Context, tenant: &Tenant, active_tab: &str) {
555 ctx.insert("active_tab", active_tab);
556 ctx.insert("tenant_slug", &tenant.org.slug);
557 ctx.insert("LANG", "en");
561 ctx.insert("LANG_DIR", "ltr");
562 ctx.insert(
564 "ui_locales",
565 &super::i18n::UI_LOCALES
566 .iter()
567 .map(|(c, n)| serde_json::json!({ "code": c, "name": n }))
568 .collect::<Vec<_>>(),
569 );
570 let brand = tenant
571 .org
572 .brand_name
573 .clone()
574 .filter(|s| !s.is_empty())
575 .unwrap_or_else(|| tenant.org.display_name.clone());
576 ctx.insert("brand_name", &brand);
577 ctx.insert("user_timezone", "");
581 static DEFAULT_TZ: std::sync::OnceLock<String> = std::sync::OnceLock::new();
588 let tenant_default_tz = DEFAULT_TZ
589 .get_or_init(|| crate::config::var("DEFAULT_TIMEZONE").unwrap_or_default())
590 .clone();
591 ctx.insert("tenant_default_timezone", &tenant_default_tz);
592
593 let mut by_section: std::collections::BTreeMap<String, Vec<serde_json::Value>> =
598 std::collections::BTreeMap::new();
599 for handler in super::admin_page::registered_admin_pages() {
600 let section = handler.section().label().to_owned();
601 by_section
602 .entry(section)
603 .or_default()
604 .push(serde_json::json!({
605 "slug": handler.slug(),
606 "label": handler.label(),
607 "icon": handler.icon(),
608 "sort_order": handler.sort_order(),
609 }));
610 }
611 for items in by_section.values_mut() {
612 items.sort_by(|a, b| {
613 let ao = a.get("sort_order").and_then(|v| v.as_i64()).unwrap_or(100);
614 let bo = b.get("sort_order").and_then(|v| v.as_i64()).unwrap_or(100);
615 ao.cmp(&bo).then_with(|| {
616 a.get("label")
617 .and_then(|v| v.as_str())
618 .unwrap_or("")
619 .cmp(b.get("label").and_then(|v| v.as_str()).unwrap_or(""))
620 })
621 });
622 }
623 ctx.insert("extra_admin_pages_by_section", &by_section);
624 let reports_nav: Vec<serde_json::Value> = super::report::registered_reports()
629 .iter()
630 .map(|r| {
631 serde_json::json!({
632 "slug": r.slug(),
633 "title": r.title(),
634 "icon": r.icon(),
635 })
636 })
637 .collect();
638 ctx.insert("registered_reports", &reports_nav);
639 let plugin_menu_items: Vec<serde_json::Value> = crate::hooks::admin_menu_items()
642 .into_iter()
643 .map(|i| {
644 serde_json::json!({
645 "key": i.key,
646 "label": i.label,
647 "icon": i.icon,
648 "href": i.href,
649 })
650 })
651 .collect();
652 ctx.insert("plugin_admin_menu_items", &plugin_menu_items);
653 let help_menu_items: Vec<serde_json::Value> = crate::hooks::help_menu_items()
656 .into_iter()
657 .map(|i| {
658 serde_json::json!({
659 "key": i.key,
660 "label": i.label,
661 "icon": i.icon,
662 "href": i.href,
663 })
664 })
665 .collect();
666 ctx.insert("help_menu_items", &help_menu_items);
667 ctx.insert("admin_css_blobs", &crate::hooks::admin_css());
670 ctx.insert("admin_js_blobs", &crate::hooks::admin_js());
671 ctx.insert("sidebar_gating", &false);
676 ctx.insert("user_is_superuser", &false);
677 ctx.insert(
678 "allowed_resources",
679 &std::collections::HashSet::<String>::new(),
680 );
681}
682
683pub(crate) async fn add_user_chrome(
698 ctx: &mut Context,
699 user: &rustango::tenancy::auth::User,
700 pool: &rustango::sql::Pool,
701) {
702 let user_timezone = user
703 .data
704 .get("timezone")
705 .and_then(serde_json::Value::as_str)
706 .unwrap_or("")
707 .to_owned();
708 ctx.insert("user_timezone", &user_timezone);
709 if let Some(pref) = user
713 .data
714 .get("admin_lang")
715 .and_then(serde_json::Value::as_str)
716 .filter(|s| super::i18n::is_ui_locale(s))
717 {
718 ctx.insert("user_lang_pref", pref);
719 }
720 ctx.insert("user_is_superuser", &user.is_superuser);
721 ctx.insert("user_username", &user.username);
722 let display_name = user
727 .data
728 .get("display_name")
729 .and_then(serde_json::Value::as_str)
730 .filter(|s| !s.is_empty())
731 .unwrap_or(&user.username)
732 .to_owned();
733 ctx.insert("user_display_name", &display_name);
734 let has_avatar = user
735 .data
736 .get("avatar_path")
737 .and_then(serde_json::Value::as_str)
738 .map(|s| !s.is_empty())
739 .unwrap_or(false);
740 if has_avatar {
741 let uid = user.id.get().copied().unwrap_or(0);
742 ctx.insert("user_avatar_url", &format!("/__cms-avatar/{uid}"));
743 }
744 let codenames = if user.is_superuser {
745 std::collections::HashSet::<String>::new()
748 } else {
749 let uid = user.id.get().copied().unwrap_or(0);
750 crate::permissions::user_codenames(pool, uid)
751 .await
752 .unwrap_or_default()
753 };
754 ctx.insert("allowed_resources", &codenames);
755 ctx.insert("sidebar_gating", &true);
756}
757
758pub async fn collections_list(
762 State(state): State<super::AdminState>,
763 tenant: Tenant,
764 headers: HeaderMap,
765 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
766) -> Result<Response, AdminError> {
767 let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
768 .order_by(&[("parent_id", false), ("sort_order", false), ("name", false)])
769 .fetch(tenant.pool())
770 .await?;
771 let by_id: std::collections::HashMap<i64, &crate::media::MediaCollection> = collections
774 .iter()
775 .filter_map(|c| c.id.get().copied().map(|id| (id, c)))
776 .collect();
777 fn depth(
778 c: &crate::media::MediaCollection,
779 by_id: &std::collections::HashMap<i64, &crate::media::MediaCollection>,
780 cache: &mut std::collections::HashMap<i64, i32>,
781 ) -> i32 {
782 let id = c.id.get().copied().unwrap_or_default();
783 if let Some(d) = cache.get(&id) {
784 return *d;
785 }
786 let d = match c.parent_id {
787 None => 0,
788 Some(pid) => match by_id.get(&pid) {
789 Some(parent) => depth(parent, by_id, cache) + 1,
790 None => 0,
791 },
792 };
793 cache.insert(id, d);
794 d
795 }
796 let media: Vec<Media> = Media::objects().fetch(tenant.pool()).await?;
798 let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
799 for m in &media {
800 if let Some(cid) = m.collection_id {
801 *counts.entry(cid).or_insert(0) += 1;
802 }
803 }
804 let mut depth_cache: std::collections::HashMap<i64, i32> = std::collections::HashMap::new();
805 let rows: Vec<serde_json::Value> = collections
806 .iter()
807 .map(|c| {
808 let id = c.id.get().copied().unwrap_or_default();
809 serde_json::json!({
810 "id": id,
811 "name": c.name,
812 "parent_id": c.parent_id,
813 "parent_name": c.parent_id.and_then(|pid| by_id.get(&pid)).map(|p| p.name.clone()),
816 "sort_order": c.sort_order,
817 "depth": depth(c, &by_id, &mut depth_cache),
818 "media_count": counts.get(&id).copied().unwrap_or(0),
819 "created_at": c.created_at.get().copied(),
820 })
821 })
822 .collect();
823
824 let mut ctx = Context::new();
825 add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
826 add_admin_theme(&mut ctx, tenant.pool()).await;
827 ctx.insert("collections", &rows);
828 render_with_csrf(
829 &state,
830 &headers,
831 "rcms_admin/collections_list.html",
832 &mut ctx,
833 )
834}
835
836#[derive(Debug, Deserialize)]
838pub struct CollectionForm {
839 pub name: String,
840 #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
841 pub parent_id: Option<i64>,
842 #[serde(default)]
843 pub sort_order: Option<i32>,
844}
845
846pub async fn collections_create(
848 State(_state): State<super::AdminState>,
849 tenant: Tenant,
850 headers: HeaderMap,
851 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
852 Form(form): Form<CollectionForm>,
853) -> Result<Response, AdminError> {
854 let name = form.name.trim().to_owned();
855 if name.is_empty() {
856 return Err(AdminError::Validation(
857 "Collection name is required.".to_owned(),
858 ));
859 }
860 let mut row = crate::media::MediaCollection {
861 id: rustango::sql::Auto::Unset,
862 name: name.clone(),
863 parent_id: form.parent_id,
864 sort_order: form.sort_order.unwrap_or(100),
865 created_at: rustango::sql::Auto::Unset,
866 };
867 row.insert_pool(tenant.pool()).await?;
868 redirect_named_with_message_args(
869 "rcms-admin:media:collections",
870 MsgLevel::Success,
871 "Collection “{name}” created.",
872 &[("name", name.as_str())],
873 &headers,
874 )
875}
876
877pub async fn collections_edit(
881 State(_state): State<super::AdminState>,
882 tenant: Tenant,
883 headers: HeaderMap,
884 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
885 Path(id): Path<i64>,
886 Form(form): Form<CollectionForm>,
887) -> Result<Response, AdminError> {
888 let mut row = crate::media::MediaCollection::objects()
889 .where_(crate::media::MediaCollection::id.eq(id))
890 .first(tenant.pool())
891 .await?
892 .ok_or(AdminError::NotFound(id))?;
893 let name = form.name.trim().to_owned();
894 if name.is_empty() {
895 return Err(AdminError::Validation(
896 "Collection name is required.".to_owned(),
897 ));
898 }
899 if form.parent_id == Some(id) {
902 return Err(AdminError::Validation(
903 "A collection cannot be its own parent.".to_owned(),
904 ));
905 }
906 row.name = name;
907 row.parent_id = form.parent_id;
908 if let Some(so) = form.sort_order {
909 row.sort_order = so;
910 }
911 row.save_pool(tenant.pool()).await?;
912 redirect_named_with_message(
913 "rcms-admin:media:collections",
914 MsgLevel::Success,
915 "Collection saved.",
916 &headers,
917 )
918}
919
920pub async fn collections_delete(
925 State(_state): State<super::AdminState>,
926 tenant: Tenant,
927 headers: HeaderMap,
928 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
929 Path(id): Path<i64>,
930) -> Result<Response, AdminError> {
931 let row = crate::media::MediaCollection::objects()
932 .where_(crate::media::MediaCollection::id.eq(id))
933 .first(tenant.pool())
934 .await?
935 .ok_or(AdminError::NotFound(id))?;
936 let parent = row.parent_id;
937 let name = row.name.clone();
938 for mut child in crate::media::MediaCollection::objects()
940 .where_(crate::media::MediaCollection::parent_id.eq(Some(id)))
941 .fetch(tenant.pool())
942 .await?
943 {
944 child.parent_id = parent;
945 child.save_pool(tenant.pool()).await?;
946 }
947 for mut m in Media::objects()
950 .where_(Media::collection_id.eq(Some(id)))
951 .fetch(tenant.pool())
952 .await?
953 {
954 m.collection_id = None;
955 m.save_pool(tenant.pool()).await?;
956 }
957 row.delete_pool(tenant.pool()).await?;
958 redirect_named_with_message_args(
959 "rcms-admin:media:collections",
960 MsgLevel::Success,
961 "Collection “{name}” deleted. Children re-parented; media moved to Uncategorized.",
962 &[("name", name.as_str())],
963 &headers,
964 )
965}
966
967use crate::category::model::{self as category_model, Category, CategoryError};
979
980fn category_tree_redirect(
982 slug: &str,
983 headers: &HeaderMap,
984 level: MsgLevel,
985 key: &str,
986 args: &[(&str, &str)],
987) -> Result<Response, AdminError> {
988 let body = super::i18n::tr(headers, key, args);
989 let url = format!("/cms-admin/taxonomies/{slug}");
990 Ok(rustango::messages::redirect_with_message(
991 messages_secret(),
992 headers,
993 level,
994 &body,
995 &url,
996 ))
997}
998
999fn opt_i64_from_form(form: &std::collections::HashMap<String, String>, key: &str) -> Option<i64> {
1000 form.get(key)
1001 .map(|s| s.trim())
1002 .filter(|s| !s.is_empty())
1003 .and_then(|s| s.parse::<i64>().ok())
1004}
1005
1006fn category_base_widgets(
1010 cat: Option<&Category>,
1011 parent_opts: Vec<(String, String)>,
1012) -> Vec<crate::widget::Widget> {
1013 use crate::widget::{Widget, WidgetKind};
1014 let mut opts = vec![(String::new(), "— none (top level) —".to_owned())];
1015 opts.extend(parent_opts);
1016 vec![
1017 Widget::new(WidgetKind::Text, "name", "Name")
1018 .required()
1019 .with_value(cat.map(|c| c.name.clone()).unwrap_or_default()),
1020 Widget::new(WidgetKind::Text, "slug", "Slug")
1021 .with_help("URL identifier — auto-generated from the name if left blank.")
1022 .with_value(cat.map(|c| c.slug.clone()).unwrap_or_default()),
1023 Widget::new(WidgetKind::Textarea, "description", "Description")
1024 .with_value(cat.map(|c| c.description.clone()).unwrap_or_default()),
1025 Widget::new(
1026 WidgetKind::MediaPicker,
1027 "featured_image_id",
1028 "Featured image",
1029 )
1030 .with_value(
1031 cat.and_then(|c| c.featured_image_id)
1032 .map(|i| i.to_string())
1033 .unwrap_or_default(),
1034 ),
1035 Widget::new(WidgetKind::MediaPicker, "thumbnail_id", "Thumbnail").with_value(
1036 cat.and_then(|c| c.thumbnail_id)
1037 .map(|i| i.to_string())
1038 .unwrap_or_default(),
1039 ),
1040 Widget::new(WidgetKind::Select, "parent_id", "Parent")
1041 .with_options(opts)
1042 .with_help("Nest this category under another (siblings share a parent).")
1043 .with_value(
1044 cat.and_then(|c| c.parent_id)
1045 .map(|i| i.to_string())
1046 .unwrap_or_default(),
1047 ),
1048 ]
1049}
1050
1051async fn category_parent_options(
1055 pool: &rustango::sql::Pool,
1056 taxonomy_id: i64,
1057 exclude: Option<i64>,
1058) -> Result<Vec<(String, String)>, AdminError> {
1059 let cats = category_model::all_in_taxonomy(pool, taxonomy_id)
1060 .await
1061 .map_err(|e| AdminError::Validation(e.to_string()))?;
1062 Ok(cats
1063 .iter()
1064 .filter(|c| c.id.get().copied() != exclude)
1065 .map(|c| {
1066 let indent = "— ".repeat((c.depth.max(1) - 1) as usize);
1067 (
1068 c.id.get().copied().unwrap_or_default().to_string(),
1069 format!("{indent}{}", c.name),
1070 )
1071 })
1072 .collect())
1073}
1074
1075pub async fn taxonomies_index(
1077 State(state): State<super::AdminState>,
1078 tenant: Tenant,
1079 headers: HeaderMap,
1080 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1081) -> Result<Response, AdminError> {
1082 let taxes = crate::category::taxonomies(tenant.pool())
1083 .await
1084 .map_err(|e| AdminError::Validation(e.to_string()))?;
1085 let all_cats: Vec<Category> = Category::objects().fetch(tenant.pool()).await?;
1086 let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
1087 for c in &all_cats {
1088 *counts.entry(c.taxonomy_id).or_insert(0) += 1;
1089 }
1090 let rows: Vec<serde_json::Value> = taxes
1091 .iter()
1092 .map(|t| {
1093 serde_json::json!({
1094 "slug": t.slug,
1095 "verbose_name": t.verbose_name,
1096 "icon": if t.icon.is_empty() { "sell".to_owned() } else { t.icon.clone() },
1097 "description": t.description,
1098 "hierarchical": t.hierarchical,
1099 "count": counts.get(&t.id.get().copied().unwrap_or_default()).copied().unwrap_or(0),
1100 })
1101 })
1102 .collect();
1103 let mut ctx = Context::new();
1104 add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1105 add_admin_theme(&mut ctx, tenant.pool()).await;
1106 ctx.insert("taxonomies", &rows);
1107 render_with_csrf(
1108 &state,
1109 &headers,
1110 "rcms_admin/taxonomies_list.html",
1111 &mut ctx,
1112 )
1113}
1114
1115pub async fn category_tree(
1117 State(state): State<super::AdminState>,
1118 tenant: Tenant,
1119 headers: HeaderMap,
1120 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1121 Path(slug): Path<String>,
1122) -> Result<Response, AdminError> {
1123 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1124 .await
1125 .map_err(|e| AdminError::Validation(e.to_string()))?
1126 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1127 let cats =
1128 category_model::all_in_taxonomy(tenant.pool(), tax.id.get().copied().unwrap_or_default())
1129 .await
1130 .map_err(|e| AdminError::Validation(e.to_string()))?;
1131 let rows: Vec<serde_json::Value> = cats
1132 .iter()
1133 .map(|c| {
1134 serde_json::json!({
1135 "id": c.id.get().copied(),
1136 "name": c.name,
1137 "slug": c.slug,
1138 "description": c.description,
1139 "depth": c.depth,
1140 "thumbnail_id": c.thumbnail_id,
1141 "featured_image_id": c.featured_image_id,
1142 })
1143 })
1144 .collect();
1145 let mut ctx = Context::new();
1146 add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1147 add_admin_theme(&mut ctx, tenant.pool()).await;
1148 ctx.insert("taxonomy_slug", &tax.slug);
1149 ctx.insert("taxonomy_name", &tax.verbose_name);
1150 ctx.insert("categories", &rows);
1151 render_with_csrf(&state, &headers, "rcms_admin/category_tree.html", &mut ctx)
1152}
1153
1154pub async fn category_new_form(
1156 State(state): State<super::AdminState>,
1157 tenant: Tenant,
1158 headers: HeaderMap,
1159 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1160 Path(slug): Path<String>,
1161) -> Result<Response, AdminError> {
1162 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1163 .await
1164 .map_err(|e| AdminError::Validation(e.to_string()))?
1165 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1166 let tid = tax.id.get().copied().unwrap_or_default();
1167 let mut fields = if tax.hierarchical {
1168 category_base_widgets(
1169 None,
1170 category_parent_options(tenant.pool(), tid, None).await?,
1171 )
1172 } else {
1173 let mut w = category_base_widgets(None, Vec::new());
1175 w.pop();
1176 w
1177 };
1178 let _ = &mut fields;
1180 let mut ctx = Context::new();
1181 add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1182 add_admin_theme(&mut ctx, tenant.pool()).await;
1183 ctx.insert("taxonomy_slug", &tax.slug);
1184 ctx.insert("taxonomy_name", &tax.verbose_name);
1185 ctx.insert("mode", "new");
1186 ctx.insert("fields", &fields);
1187 render_with_csrf(&state, &headers, "rcms_admin/category_form.html", &mut ctx)
1188}
1189
1190pub async fn category_create(
1192 State(_state): State<super::AdminState>,
1193 tenant: Tenant,
1194 headers: HeaderMap,
1195 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1196 Path(slug): Path<String>,
1197 Form(form): Form<std::collections::HashMap<String, String>>,
1198) -> Result<Response, AdminError> {
1199 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1200 .await
1201 .map_err(|e| AdminError::Validation(e.to_string()))?
1202 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1203 let tid = tax.id.get().copied().unwrap_or_default();
1204 let new = category_model::NewCategory {
1205 name: form
1206 .get("name")
1207 .cloned()
1208 .unwrap_or_default()
1209 .trim()
1210 .to_owned(),
1211 slug: form.get("slug").cloned().unwrap_or_default(),
1212 description: form.get("description").cloned().unwrap_or_default(),
1213 featured_image_id: opt_i64_from_form(&form, "featured_image_id"),
1214 thumbnail_id: opt_i64_from_form(&form, "thumbnail_id"),
1215 parent_id: opt_i64_from_form(&form, "parent_id"),
1216 };
1217 if new.name.is_empty() {
1218 return category_tree_redirect(
1219 &slug,
1220 &headers,
1221 MsgLevel::Error,
1222 "Category name is required.",
1223 &[],
1224 );
1225 }
1226 match category_model::create(tenant.pool(), tid, new).await {
1227 Ok(cat) => {
1228 let id = cat.id.get().copied().unwrap_or_default();
1229 let body = super::i18n::tr(
1230 &headers,
1231 "Category “{name}” created.",
1232 &[("name", cat.name.as_str())],
1233 );
1234 let url = format!("/cms-admin/taxonomies/{slug}/categories/{id}/edit");
1235 Ok(rustango::messages::redirect_with_message(
1236 messages_secret(),
1237 &headers,
1238 MsgLevel::Success,
1239 &body,
1240 &url,
1241 ))
1242 }
1243 Err(e) => category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]),
1244 }
1245}
1246
1247pub async fn category_edit_form(
1249 State(state): State<super::AdminState>,
1250 tenant: Tenant,
1251 headers: HeaderMap,
1252 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1253 Path((slug, id)): Path<(String, i64)>,
1254 Query(q): Query<EditQuery>,
1255) -> Result<Response, AdminError> {
1256 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1257 .await
1258 .map_err(|e| AdminError::Validation(e.to_string()))?
1259 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1260 let tid = tax.id.get().copied().unwrap_or_default();
1261 let cat = Category::objects()
1262 .where_(Category::id.eq(id))
1263 .where_(Category::taxonomy_id.eq(tid))
1264 .first(tenant.pool())
1265 .await?
1266 .ok_or(AdminError::NotFound(id))?;
1267 let mut fields = if tax.hierarchical {
1268 category_base_widgets(
1269 Some(&cat),
1270 category_parent_options(tenant.pool(), tid, Some(id)).await?,
1271 )
1272 } else {
1273 let mut w = category_base_widgets(Some(&cat), Vec::new());
1274 w.pop();
1275 w
1276 };
1277 if let Some(handler) = crate::category::find_handler(&slug) {
1279 if let Ok(ext) = handler.ext_widgets(tenant.pool(), id).await {
1280 fields.extend(ext);
1281 }
1282 }
1283 let mut ctx = Context::new();
1284 add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1285 add_admin_theme(&mut ctx, tenant.pool()).await;
1286 ctx.insert("taxonomy_slug", &tax.slug);
1287 ctx.insert("taxonomy_name", &tax.verbose_name);
1288 ctx.insert("mode", "edit");
1289 ctx.insert("category_id", &id);
1290 ctx.insert("fields", &fields);
1291 let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
1294 .where_(crate::locale::Locale::active.eq(true))
1295 .order_by(&[("sort_order", false), ("code", false)])
1296 .fetch(tenant.pool())
1297 .await?;
1298 let editing_locale = q
1299 .locale
1300 .as_deref()
1301 .filter(|c| !c.is_empty())
1302 .and_then(|code| locales.iter().find(|l| l.code == code && !l.is_default).cloned());
1303 if let Some(loc) = &editing_locale {
1304 let lid = loc.id.get().copied().unwrap_or_default();
1305 let mut existing = crate::category_translation::fetch_for_categories(tenant.pool(), &[id], lid)
1306 .await
1307 .unwrap_or_default();
1308 ctx.insert("translation_mode", &true);
1309 ctx.insert("editing_locale", loc);
1310 ctx.insert("category_name", &cat.name);
1311 ctx.insert("tr_name", &existing.remove(&id).and_then(|mut f| f.remove("name")).unwrap_or_default());
1312 }
1313 ctx.insert("locales", &locales);
1314 render_with_csrf(&state, &headers, "rcms_admin/category_form.html", &mut ctx)
1315}
1316
1317pub async fn category_translate_submit(
1321 State(_state): State<super::AdminState>,
1322 tenant: Tenant,
1323 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1324 Path((slug, id)): Path<(String, i64)>,
1325 Query(q): Query<EditQuery>,
1326 Form(form): Form<std::collections::HashMap<String, String>>,
1327) -> Result<Response, AdminError> {
1328 use crate::category_translation::{CategoryTranslation, TRANSLATABLE_FIELDS};
1329 let code = q
1330 .locale
1331 .as_deref()
1332 .filter(|c| !c.is_empty())
1333 .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
1334 let locale = crate::locale::Locale::objects()
1335 .where_(crate::locale::Locale::code.eq(code.to_owned()))
1336 .where_(crate::locale::Locale::active.eq(true))
1337 .where_(crate::locale::Locale::is_default.eq(false))
1338 .first(tenant.pool())
1339 .await?
1340 .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
1341 let locale_id = locale.id.get().copied().unwrap_or_default();
1342 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1343 .await
1344 .map_err(|e| AdminError::Validation(e.to_string()))?
1345 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1346 Category::objects()
1347 .where_(Category::id.eq(id))
1348 .where_(Category::taxonomy_id.eq(tax.id.get().copied().unwrap_or_default()))
1349 .first(tenant.pool())
1350 .await?
1351 .ok_or(AdminError::NotFound(id))?;
1352 rustango::atomic!(tenant.pool(), |tx| {
1353 let mut guard = tx.lock().await?;
1354 let tx = &mut *guard;
1355 for field in TRANSLATABLE_FIELDS {
1356 let Some(value) = form.get(&format!("tr__{field}")) else {
1357 continue;
1358 };
1359 let value = value.trim().to_owned();
1360 let existing: Vec<CategoryTranslation> = CategoryTranslation::objects()
1361 .where_(CategoryTranslation::category_id.eq(id))
1362 .where_(CategoryTranslation::locale_id.eq(locale_id))
1363 .where_(CategoryTranslation::field_path.eq(field.to_owned()))
1364 .fetch_tx(tx)
1365 .await?;
1366 if value.is_empty() {
1367 for row in existing {
1368 row.delete_tx(tx).await?;
1369 }
1370 } else if let Some(mut row) = existing.into_iter().next() {
1371 row.value = value;
1372 row.save_tx(tx).await?;
1373 } else {
1374 let mut row = CategoryTranslation {
1375 id: rustango::sql::Auto::Unset,
1376 category_id: id,
1377 locale_id,
1378 field_path: field.to_owned(),
1379 value,
1380 updated_at: rustango::sql::Auto::Unset,
1381 };
1382 row.save_tx(tx).await?;
1383 }
1384 }
1385 Ok::<_, rustango::sql::ExecError>(())
1386 })
1387 .await?;
1388 Ok(Redirect::to(&format!("/cms-admin/taxonomies/{slug}/categories/{id}/edit?locale={code}")).into_response())
1389}
1390
1391pub async fn category_update(
1393 State(_state): State<super::AdminState>,
1394 tenant: Tenant,
1395 headers: HeaderMap,
1396 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1397 Path((slug, id)): Path<(String, i64)>,
1398 Form(form): Form<std::collections::HashMap<String, String>>,
1399) -> Result<Response, AdminError> {
1400 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1401 .await
1402 .map_err(|e| AdminError::Validation(e.to_string()))?
1403 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1404 let tid = tax.id.get().copied().unwrap_or_default();
1405 let new = category_model::NewCategory {
1406 name: form
1407 .get("name")
1408 .cloned()
1409 .unwrap_or_default()
1410 .trim()
1411 .to_owned(),
1412 slug: form.get("slug").cloned().unwrap_or_default(),
1413 description: form.get("description").cloned().unwrap_or_default(),
1414 featured_image_id: opt_i64_from_form(&form, "featured_image_id"),
1415 thumbnail_id: opt_i64_from_form(&form, "thumbnail_id"),
1416 parent_id: opt_i64_from_form(&form, "parent_id"),
1417 };
1418 if new.name.is_empty() {
1419 return category_tree_redirect(
1420 &slug,
1421 &headers,
1422 MsgLevel::Error,
1423 "Category name is required.",
1424 &[],
1425 );
1426 }
1427 let new_parent = new.parent_id;
1428 if let Err(e) = category_model::update(tenant.pool(), tid, id, new).await {
1429 return category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]);
1430 }
1431 if let Err(e) = category_model::move_to(tenant.pool(), tid, id, new_parent).await {
1434 return category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]);
1435 }
1436 if let Some(handler) = crate::category::find_handler(&slug) {
1438 if let Err(e) = handler.save_ext(tenant.pool(), id, &form).await {
1439 tracing::warn!(category_id = id, error = %e, "category extension save failed");
1440 }
1441 }
1442 category_tree_redirect(&slug, &headers, MsgLevel::Success, "Category saved.", &[])
1443}
1444
1445pub async fn category_delete(
1447 State(_state): State<super::AdminState>,
1448 tenant: Tenant,
1449 headers: HeaderMap,
1450 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1451 Path((slug, id)): Path<(String, i64)>,
1452) -> Result<Response, AdminError> {
1453 let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1454 .await
1455 .map_err(|e| AdminError::Validation(e.to_string()))?
1456 .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1457 let tid = tax.id.get().copied().unwrap_or_default();
1458 match category_model::delete(tenant.pool(), tid, id, false).await {
1459 Ok(_) => {
1460 category_tree_redirect(&slug, &headers, MsgLevel::Success, "Category deleted.", &[])
1461 }
1462 Err(CategoryError::HasChildren(_, n)) => {
1463 let n = n.to_string();
1464 category_tree_redirect(
1465 &slug,
1466 &headers,
1467 MsgLevel::Error,
1468 "Can't delete a category with {count} child categor(ies) — delete or move them first.",
1469 &[("count", n.as_str())],
1470 )
1471 }
1472 Err(e) => category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]),
1473 }
1474}
1475
1476async fn ensure_builder_access(
1488 tenant: &Tenant,
1489 user: Option<&rustango::tenancy::auth::User>,
1490) -> Option<Response> {
1491 super::codename_gate(tenant, user, "cms_page_type.build").await
1492}
1493
1494pub async fn page_type_build_form(
1496 State(state): State<super::AdminState>,
1497 tenant: Tenant,
1498 headers: HeaderMap,
1499 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1500 Path(id): Path<i64>,
1501) -> Result<Response, AdminError> {
1502 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1503 return Ok(r);
1504 }
1505 let pt = crate::page_type_model::PageType::objects()
1506 .where_(crate::page_type_model::PageType::id.eq(id))
1507 .first(tenant.pool())
1508 .await?
1509 .ok_or(AdminError::NotFound(id))?;
1510
1511 let draft = crate::page_builder::model::draft_for(tenant.pool(), id).await?;
1512 let published = crate::page_builder::model::published_for(tenant.pool(), id).await?;
1513 let doc_value = draft
1516 .as_ref()
1517 .map(|d| d.document.clone())
1518 .or_else(|| published.as_ref().map(|p| p.document.clone()))
1519 .unwrap_or_else(|| serde_json::json!({ "nodes": [] }));
1520 let schema_json =
1521 serde_json::to_string(&doc_value).unwrap_or_else(|_| "{\"nodes\":[]}".to_owned());
1522
1523 let components: Vec<serde_json::Value> =
1524 crate::page_builder::model::all_components(tenant.pool())
1525 .await?
1526 .iter()
1527 .map(|c| serde_json::json!({ "slug": c.slug, "label": c.label }))
1528 .collect();
1529 let components_json = serde_json::to_string(&components).unwrap_or_else(|_| "[]".to_owned());
1530 let versions: Vec<serde_json::Value> =
1531 crate::page_builder::model::list_versions(tenant.pool(), id)
1532 .await?
1533 .iter()
1534 .map(|v| {
1535 serde_json::json!({
1536 "version": v.version,
1537 "status": v.status,
1538 "updated_at": v.updated_at.get().copied(),
1539 })
1540 })
1541 .collect();
1542
1543 let is_ui_type = pt.app_label == "cms_ui";
1547 let page_count = if is_ui_type {
1548 Page::objects()
1549 .where_(Page::page_type_id.eq(id))
1550 .fetch(tenant.pool())
1551 .await
1552 .map(|v| v.len())
1553 .unwrap_or(0)
1554 } else {
1555 0
1556 };
1557
1558 let mut ctx = Context::new();
1559 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
1560 add_admin_theme(&mut ctx, tenant.pool()).await;
1561 ctx.insert("page_type_id", &id);
1562 ctx.insert("title", &pt.verbose_name);
1563 ctx.insert("schema_json", &schema_json);
1564 ctx.insert("build_url", &format!("/cms-admin/page-types/{id}/build"));
1565 ctx.insert(
1566 "publish_url",
1567 &format!("/cms-admin/page-types/{id}/build/publish"),
1568 );
1569 ctx.insert("delete_url", &format!("/cms-admin/page-types/{id}/delete"));
1570 ctx.insert("list_url", "/cms-admin/page-types");
1571 ctx.insert("components_json", &components_json);
1572 ctx.insert("versions", &versions);
1573 ctx.insert("has_unpublished", &draft.is_some());
1574 let translate_locales: Vec<crate::locale::Locale> = if published.is_some() {
1576 crate::locale::Locale::objects()
1577 .where_(crate::locale::Locale::active.eq(true))
1578 .where_(crate::locale::Locale::is_default.eq(false))
1579 .order_by(&[("sort_order", false), ("code", false)])
1580 .fetch(tenant.pool())
1581 .await?
1582 } else {
1583 Vec::new()
1584 };
1585 ctx.insert("translate_locales", &translate_locales);
1586 ctx.insert("translate_url", &format!("/cms-admin/page-types/{id}/translate"));
1587 ctx.insert("is_ui_type", &is_ui_type);
1588 ctx.insert("page_count", &page_count);
1589 ctx.insert("deletable", &(is_ui_type && page_count == 0));
1590 render_with_csrf(
1591 &state,
1592 &headers,
1593 "rcms_admin/page_type_builder.html",
1594 &mut ctx,
1595 )
1596}
1597
1598pub async fn page_type_translate_form(
1602 State(state): State<super::AdminState>,
1603 tenant: Tenant,
1604 headers: HeaderMap,
1605 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1606 Path(id): Path<i64>,
1607 Query(q): Query<EditQuery>,
1608) -> Result<Response, AdminError> {
1609 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1610 return Ok(r);
1611 }
1612 let pt = crate::page_type_model::PageType::objects()
1613 .where_(crate::page_type_model::PageType::id.eq(id))
1614 .first(tenant.pool())
1615 .await?
1616 .ok_or(AdminError::NotFound(id))?;
1617 let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
1618 let published = crate::page_builder::model::published_for(tenant.pool(), id).await?;
1619 let fields = published
1620 .as_ref()
1621 .map(|p| crate::page_builder::choice_i18n::choice_fields(&p.document, &locale.code))
1622 .unwrap_or_default();
1623 let mut ctx = Context::new();
1624 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
1625 add_admin_theme(&mut ctx, tenant.pool()).await;
1626 ctx.insert("title", &pt.verbose_name);
1627 ctx.insert("editing_locale", &locale);
1628 ctx.insert("choice_fields", &fields);
1629 ctx.insert("build_url", &format!("/cms-admin/page-types/{id}/build"));
1630 ctx.insert("translate_url", &format!("/cms-admin/page-types/{id}/translate"));
1631 render_with_csrf(&state, &headers, "rcms_admin/page_type_translate.html", &mut ctx)
1632}
1633
1634pub async fn page_type_translate_submit(
1638 State(_state): State<super::AdminState>,
1639 tenant: Tenant,
1640 headers: HeaderMap,
1641 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1642 Path(id): Path<i64>,
1643 Query(q): Query<EditQuery>,
1644 Form(form): Form<Vec<(String, String)>>,
1645) -> Result<Response, AdminError> {
1646 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1647 return Ok(r);
1648 }
1649 let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
1650 let labels: std::collections::HashMap<(String, String), String> = form
1651 .into_iter()
1652 .filter_map(|(k, v)| {
1653 let rest = k.strip_prefix("tr__")?;
1654 let (path, value) = rest.split_once("__")?;
1655 Some(((path.to_owned(), value.to_owned()), v))
1656 })
1657 .collect();
1658 for row in [
1659 crate::page_builder::model::published_for(tenant.pool(), id).await?,
1660 crate::page_builder::model::draft_for(tenant.pool(), id).await?,
1661 ]
1662 .into_iter()
1663 .flatten()
1664 {
1665 let mut row = row;
1666 if crate::page_builder::choice_i18n::set_choice_labels(&mut row.document, &locale.code, &labels) > 0 {
1667 row.save_pool(tenant.pool()).await?;
1668 }
1669 }
1670 let back = format!("/cms-admin/page-types/{id}/translate?locale={}", locale.code);
1671 Ok(rustango::messages::redirect_with_message(
1672 messages_secret(),
1673 &headers,
1674 MsgLevel::Success,
1675 &super::i18n::tr(&headers, "Translations saved.", &[]),
1676 &back,
1677 ))
1678}
1679
1680async fn translate_locale(tenant: &Tenant, code: Option<&str>) -> Result<crate::locale::Locale, AdminError> {
1683 let code = code
1684 .filter(|c| !c.is_empty())
1685 .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
1686 crate::locale::Locale::objects()
1687 .where_(crate::locale::Locale::code.eq(code.to_owned()))
1688 .where_(crate::locale::Locale::active.eq(true))
1689 .where_(crate::locale::Locale::is_default.eq(false))
1690 .first(tenant.pool())
1691 .await?
1692 .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))
1693}
1694
1695async fn parse_builder_submit(
1699 tenant: &Tenant,
1700 user: Option<&rustango::tenancy::auth::User>,
1701 id: i64,
1702 schema_str: &str,
1703) -> Result<Result<(crate::page_builder::Document, Vec<String>), Response>, AdminError> {
1704 if let Some(r) = ensure_builder_access(tenant, user).await {
1705 return Ok(Err(r));
1706 }
1707 let exists = crate::page_type_model::PageType::objects()
1709 .where_(crate::page_type_model::PageType::id.eq(id))
1710 .first(tenant.pool())
1711 .await?
1712 .is_some();
1713 if !exists {
1714 return Err(AdminError::NotFound(id));
1715 }
1716 let value: serde_json::Value = serde_json::from_str(schema_str)
1717 .map_err(|e| AdminError::Validation(format!("invalid schema JSON: {e}")))?;
1718 let doc = crate::page_builder::parse_schema(&value)
1719 .map_err(|e| AdminError::Validation(format!("invalid schema document: {e}")))?;
1720 let components = crate::page_builder::model::component_map(tenant.pool()).await?;
1721 let problems = crate::page_builder::validate_schema(&doc, &components);
1722 Ok(Ok((doc, problems)))
1723}
1724
1725pub async fn page_type_build_submit(
1728 State(_state): State<super::AdminState>,
1729 tenant: Tenant,
1730 headers: HeaderMap,
1731 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1732 Path(id): Path<i64>,
1733 Form(form): Form<FormBuildSubmit>,
1734) -> Result<Response, AdminError> {
1735 let (doc, problems) =
1736 match parse_builder_submit(&tenant, session_user.as_ref(), id, &form.schema).await? {
1737 Ok(v) => v,
1738 Err(resp) => return Ok(resp),
1739 };
1740 let document =
1741 serde_json::to_value(&doc).unwrap_or_else(|_| serde_json::json!({ "nodes": [] }));
1742 let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
1743 crate::page_builder::model::save_draft(tenant.pool(), id, document, created_by).await?;
1744 let (level, msg) = if problems.is_empty() {
1745 (MsgLevel::Success, "Draft saved.".to_owned())
1746 } else {
1747 (
1748 MsgLevel::Warning,
1749 format!("Draft saved with warnings: {}", problems.join(" ")),
1750 )
1751 };
1752 redirect_named_with_params_and_message(
1753 "rcms-admin:page-types:build",
1754 &[("id", id.to_string())],
1755 level,
1756 &msg,
1757 &headers,
1758 )
1759}
1760
1761pub async fn page_type_publish_submit(
1764 State(_state): State<super::AdminState>,
1765 tenant: Tenant,
1766 headers: HeaderMap,
1767 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1768 Path(id): Path<i64>,
1769 Form(form): Form<FormBuildSubmit>,
1770) -> Result<Response, AdminError> {
1771 let (doc, problems) =
1772 match parse_builder_submit(&tenant, session_user.as_ref(), id, &form.schema).await? {
1773 Ok(v) => v,
1774 Err(resp) => return Ok(resp),
1775 };
1776 let document =
1779 serde_json::to_value(&doc).unwrap_or_else(|_| serde_json::json!({ "nodes": [] }));
1780 let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
1781 crate::page_builder::model::save_draft(tenant.pool(), id, document, created_by).await?;
1782 if !problems.is_empty() {
1783 return redirect_named_with_params_and_message(
1784 "rcms-admin:page-types:build",
1785 &[("id", id.to_string())],
1786 MsgLevel::Error,
1787 &format!("Can't publish — fix these first: {}", problems.join(" ")),
1788 &headers,
1789 );
1790 }
1791 crate::page_builder::model::publish(tenant.pool(), id).await?;
1792 redirect_named_with_params_and_message(
1793 "rcms-admin:page-types:build",
1794 &[("id", id.to_string())],
1795 MsgLevel::Success,
1796 "Schema published — the page editor now uses this structure.",
1797 &headers,
1798 )
1799}
1800
1801pub(crate) async fn save_page_builder_values(
1810 pool: &rustango::sql::Pool,
1811 page_type_id: i64,
1812 page_id: i64,
1813 form_map: &std::collections::HashMap<String, String>,
1814) -> Result<(), rustango::sql::ExecError> {
1815 let Some(row) = crate::page_builder::model::published_for(pool, page_type_id).await? else {
1816 return Ok(());
1817 };
1818 let Ok(doc) = crate::page_builder::parse_schema(&row.document) else {
1819 return Ok(());
1820 };
1821 let components = crate::page_builder::model::component_map(pool).await?;
1822 let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
1823 crate::page_builder::values::save_from_form(pool, page_id, &compiled, form_map).await
1824}
1825
1826async fn page_builder_editor_ctx(
1830 tenant: &Tenant,
1831 tera: &tera::Tera,
1832 page_id: i64,
1833 page_type_id: i64,
1834 held: Option<&std::collections::HashMap<String, String>>,
1835) -> Option<(String, String, bool)> {
1836 let row = crate::page_builder::model::published_for(tenant.pool(), page_type_id)
1837 .await
1838 .ok()??;
1839 let doc = crate::page_builder::parse_schema(&row.document).ok()?;
1840 let components = crate::page_builder::model::component_map(tenant.pool())
1841 .await
1842 .unwrap_or_default();
1843 let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
1844 let (mut values, report) =
1845 crate::page_builder::values::load_upgraded(tenant.pool(), page_id, &compiled)
1846 .await
1847 .unwrap_or_else(|_| (serde_json::json!({}), Default::default()));
1848 if let Some(form) = held {
1850 values = serde_json::Value::Object(crate::page_builder::values::build_values(&compiled, form));
1851 }
1852 let html =
1853 crate::page_builder::values::render_body(&compiled, &values, tera);
1854 let rules: Vec<serde_json::Value> = compiled
1856 .rules
1857 .iter()
1858 .map(|r| serde_json::json!({ "field": r.field, "rule": r.rule }))
1859 .collect();
1860 let rules_json = serde_json::to_string(&rules).unwrap_or_else(|_| "[]".to_owned());
1861 Some((html, rules_json, report.upgraded))
1862}
1863
1864pub async fn components_index(
1868 State(state): State<super::AdminState>,
1869 tenant: Tenant,
1870 headers: HeaderMap,
1871 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1872) -> Result<Response, AdminError> {
1873 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1874 return Ok(r);
1875 }
1876 let comps = crate::page_builder::model::all_components(tenant.pool()).await?;
1877 let mut rows = Vec::with_capacity(comps.len());
1878 for c in &comps {
1879 let refs = crate::page_builder::model::component_references(tenant.pool(), &c.slug)
1880 .await
1881 .unwrap_or_default();
1882 rows.push(serde_json::json!({
1883 "id": c.id.get().copied(),
1884 "slug": c.slug,
1885 "label": c.label,
1886 "icon": if c.icon.is_empty() { "extension".to_owned() } else { c.icon.clone() },
1887 "description": c.description,
1888 "version": c.version,
1889 "ref_count": refs.len(),
1890 }));
1891 }
1892 let mut ctx = Context::new();
1893 add_chrome(&mut ctx, &tenant, "components", session_user.as_ref()).await;
1894 add_admin_theme(&mut ctx, tenant.pool()).await;
1895 ctx.insert("components", &rows);
1896 ctx.insert("new_url", "/cms-admin/components/new");
1897 render_with_csrf(
1898 &state,
1899 &headers,
1900 "rcms_admin/components_list.html",
1901 &mut ctx,
1902 )
1903}
1904
1905#[allow(clippy::too_many_arguments)]
1907async fn render_component_builder(
1908 state: &super::AdminState,
1909 headers: &HeaderMap,
1910 tenant: &Tenant,
1911 user: Option<&rustango::tenancy::auth::User>,
1912 id: Option<i64>,
1913 slug: &str,
1914 label: &str,
1915 icon: &str,
1916 description: &str,
1917 schema_json: &str,
1918 error: Option<&str>,
1919) -> Result<Response, AdminError> {
1920 let mut ctx = Context::new();
1921 add_chrome(&mut ctx, tenant, "components", user).await;
1922 add_admin_theme(&mut ctx, tenant.pool()).await;
1923 ctx.insert("component_id", &id);
1924 ctx.insert("slug", slug);
1925 ctx.insert("label", label);
1926 ctx.insert("icon", icon);
1927 ctx.insert("description", description);
1928 ctx.insert("schema_json", schema_json);
1929 ctx.insert("is_edit", &id.is_some());
1930 let save_url = match id {
1931 Some(cid) => format!("/cms-admin/components/{cid}/edit"),
1932 None => "/cms-admin/components/new".to_owned(),
1933 };
1934 ctx.insert("save_url", &save_url);
1935 ctx.insert("list_url", "/cms-admin/components");
1936 if let Some(e) = error {
1937 ctx.insert("error", e);
1938 }
1939 render_with_csrf(
1940 state,
1941 headers,
1942 "rcms_admin/component_builder.html",
1943 &mut ctx,
1944 )
1945}
1946
1947pub async fn component_new_form(
1949 State(state): State<super::AdminState>,
1950 tenant: Tenant,
1951 headers: HeaderMap,
1952 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1953) -> Result<Response, AdminError> {
1954 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1955 return Ok(r);
1956 }
1957 render_component_builder(
1958 &state,
1959 &headers,
1960 &tenant,
1961 session_user.as_ref(),
1962 None,
1963 "",
1964 "",
1965 "",
1966 "",
1967 "{\"nodes\":[]}",
1968 None,
1969 )
1970 .await
1971}
1972
1973pub async fn component_edit_form(
1975 State(state): State<super::AdminState>,
1976 tenant: Tenant,
1977 headers: HeaderMap,
1978 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1979 Path(id): Path<i64>,
1980) -> Result<Response, AdminError> {
1981 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1982 return Ok(r);
1983 }
1984 let c = crate::page_builder::model::component_by_id(tenant.pool(), id)
1985 .await?
1986 .ok_or(AdminError::NotFound(id))?;
1987 let doc: crate::page_builder::schema::ComponentDoc =
1989 serde_json::from_value(c.document.clone()).unwrap_or_default();
1990 let schema_json =
1991 serde_json::to_string(&serde_json::json!({ "nodes": doc.children })).unwrap_or_default();
1992 render_component_builder(
1993 &state,
1994 &headers,
1995 &tenant,
1996 session_user.as_ref(),
1997 Some(id),
1998 &c.slug,
1999 &c.label,
2000 &c.icon,
2001 &c.description,
2002 &schema_json,
2003 None,
2004 )
2005 .await
2006}
2007
2008fn parse_component_doc(
2011 schema_str: &str,
2012) -> Result<crate::page_builder::schema::ComponentDoc, String> {
2013 let value: serde_json::Value =
2014 serde_json::from_str(schema_str).map_err(|e| format!("invalid schema JSON: {e}"))?;
2015 let doc = crate::page_builder::parse_schema(&value)
2016 .map_err(|e| format!("invalid schema document: {e}"))?;
2017 let cdoc = crate::page_builder::schema::ComponentDoc {
2018 label_format: None,
2019 children: doc.nodes,
2020 };
2021 let problems = crate::page_builder::schema::validate_component(&cdoc);
2022 if problems.is_empty() {
2023 Ok(cdoc)
2024 } else {
2025 Err(problems.join(" "))
2026 }
2027}
2028
2029pub async fn component_create(
2031 State(state): State<super::AdminState>,
2032 tenant: Tenant,
2033 headers: HeaderMap,
2034 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2035 Form(form): Form<FormComponentSubmit>,
2036) -> Result<Response, AdminError> {
2037 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2038 return Ok(r);
2039 }
2040 let slug = crate::forms::schema::slugify_key(&form.slug);
2041 let checked: Result<crate::page_builder::schema::ComponentDoc, String> =
2043 if !crate::forms::schema::is_valid_key(&slug) {
2044 Err(
2045 "Slug is invalid — use letters/digits/underscores, starting with a letter."
2046 .to_owned(),
2047 )
2048 } else if form.label.trim().is_empty() {
2049 Err("Label is required.".to_owned())
2050 } else {
2051 parse_component_doc(&form.schema)
2052 };
2053 let msg: Option<String> = match checked {
2055 Ok(cdoc) => {
2056 let document = serde_json::to_value(&cdoc).unwrap_or_else(|_| serde_json::json!({}));
2057 match crate::page_builder::model::create_component(
2058 tenant.pool(),
2059 &slug,
2060 form.label.trim(),
2061 form.icon.trim(),
2062 form.description.trim(),
2063 document,
2064 )
2065 .await
2066 {
2067 Ok(_) => {
2068 return redirect_named_with_message(
2069 "rcms-admin:components:index",
2070 MsgLevel::Success,
2071 "Component created.",
2072 &headers,
2073 )
2074 }
2075 Err(_) => Some(format!(
2076 "Could not create — a component with slug `{slug}` may already exist."
2077 )),
2078 }
2079 }
2080 Err(e) => Some(e),
2081 };
2082 render_component_builder(
2083 &state,
2084 &headers,
2085 &tenant,
2086 session_user.as_ref(),
2087 None,
2088 &form.slug,
2089 &form.label,
2090 &form.icon,
2091 &form.description,
2092 &form.schema,
2093 msg.as_deref(),
2094 )
2095 .await
2096}
2097
2098pub async fn component_update(
2100 State(state): State<super::AdminState>,
2101 tenant: Tenant,
2102 headers: HeaderMap,
2103 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2104 Path(id): Path<i64>,
2105 Form(form): Form<FormComponentSubmit>,
2106) -> Result<Response, AdminError> {
2107 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2108 return Ok(r);
2109 }
2110 let existing = crate::page_builder::model::component_by_id(tenant.pool(), id)
2111 .await?
2112 .ok_or(AdminError::NotFound(id))?;
2113 if form.label.trim().is_empty() {
2114 return render_component_builder(
2115 &state,
2116 &headers,
2117 &tenant,
2118 session_user.as_ref(),
2119 Some(id),
2120 &existing.slug,
2121 &form.label,
2122 &form.icon,
2123 &form.description,
2124 &form.schema,
2125 Some("Label is required."),
2126 )
2127 .await;
2128 }
2129 let cdoc = match parse_component_doc(&form.schema) {
2130 Ok(d) => d,
2131 Err(e) => {
2132 return render_component_builder(
2133 &state,
2134 &headers,
2135 &tenant,
2136 session_user.as_ref(),
2137 Some(id),
2138 &existing.slug,
2139 &form.label,
2140 &form.icon,
2141 &form.description,
2142 &form.schema,
2143 Some(&e),
2144 )
2145 .await
2146 }
2147 };
2148 let document = serde_json::to_value(&cdoc).unwrap_or_else(|_| serde_json::json!({}));
2149 crate::page_builder::model::update_component(
2150 tenant.pool(),
2151 id,
2152 form.label.trim(),
2153 form.icon.trim(),
2154 form.description.trim(),
2155 document,
2156 )
2157 .await?;
2158 redirect_named_with_message(
2159 "rcms-admin:components:index",
2160 MsgLevel::Success,
2161 "Component saved — referencing page types pick it up on next open.",
2162 &headers,
2163 )
2164}
2165
2166pub async fn component_delete(
2168 State(_state): State<super::AdminState>,
2169 tenant: Tenant,
2170 headers: HeaderMap,
2171 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2172 Path(id): Path<i64>,
2173) -> Result<Response, AdminError> {
2174 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2175 return Ok(r);
2176 }
2177 let c = crate::page_builder::model::component_by_id(tenant.pool(), id)
2178 .await?
2179 .ok_or(AdminError::NotFound(id))?;
2180 let refs = crate::page_builder::model::component_references(tenant.pool(), &c.slug).await?;
2181 if !refs.is_empty() {
2182 let ids: Vec<i64> = refs.iter().map(|(pt, _)| *pt).collect();
2184 let pts: Vec<PageType> = PageType::objects()
2185 .where_(PageType::id.is_in(ids))
2186 .fetch(tenant.pool())
2187 .await
2188 .unwrap_or_default();
2189 let names: Vec<String> = pts.iter().map(|p| p.verbose_name.clone()).collect();
2190 let listed = if names.is_empty() {
2191 format!("{} page type(s)", refs.len())
2192 } else {
2193 names.join(", ")
2194 };
2195 return redirect_named_with_message(
2196 "rcms-admin:components:index",
2197 MsgLevel::Error,
2198 &format!("Can't delete `{}` — still used by: {listed}.", c.slug),
2199 &headers,
2200 );
2201 }
2202 crate::page_builder::model::delete_component(tenant.pool(), id).await?;
2203 redirect_named_with_message(
2204 "rcms-admin:components:index",
2205 MsgLevel::Success,
2206 "Component deleted.",
2207 &headers,
2208 )
2209}
2210
2211pub async fn page_type_new_form(
2215 State(state): State<super::AdminState>,
2216 tenant: Tenant,
2217 headers: HeaderMap,
2218 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2219) -> Result<Response, AdminError> {
2220 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2221 return Ok(r);
2222 }
2223 let mut ctx = Context::new();
2224 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2225 add_admin_theme(&mut ctx, tenant.pool()).await;
2226 ctx.insert("list_url", "/cms-admin/page-types");
2227 insert_workflow_choices(&mut ctx, tenant.pool()).await;
2228 render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx)
2229}
2230
2231async fn insert_workflow_choices(ctx: &mut Context, pool: &rustango::sql::Pool) {
2234 let names: Vec<String> = crate::workflow::Workflow::objects()
2235 .where_(crate::workflow::Workflow::active.eq(true))
2236 .order_by(&[("name", false)])
2237 .fetch(pool)
2238 .await
2239 .unwrap_or_default()
2240 .into_iter()
2241 .map(|w| w.name)
2242 .collect();
2243 ctx.insert("workflows", &names);
2244}
2245
2246fn type_list_json(raw: &str) -> serde_json::Value {
2249 serde_json::Value::Array(
2250 raw.split(',')
2251 .map(str::trim)
2252 .filter(|s| !s.is_empty())
2253 .map(|s| serde_json::Value::String(s.to_owned()))
2254 .collect(),
2255 )
2256}
2257
2258async fn ui_page_type(
2261 pool: &rustango::sql::Pool,
2262 id: i64,
2263) -> Result<Option<crate::page_type_model::PageType>, AdminError> {
2264 Ok(crate::page_type_model::PageType::objects()
2265 .where_(crate::page_type_model::PageType::id.eq(id))
2266 .first(pool)
2267 .await?
2268 .filter(|t| crate::page_type::find_handler(&t.type_name).is_none()))
2269}
2270
2271pub async fn page_type_edit_form(
2273 State(state): State<super::AdminState>,
2274 tenant: Tenant,
2275 headers: HeaderMap,
2276 Path(id): Path<i64>,
2277 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2278) -> Result<Response, AdminError> {
2279 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2280 return Ok(r);
2281 }
2282 let Some(pt) = ui_page_type(tenant.pool(), id).await? else {
2283 return Err(AdminError::NotFound(id));
2284 };
2285 let mut ctx = Context::new();
2286 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2287 add_admin_theme(&mut ctx, tenant.pool()).await;
2288 ctx.insert("list_url", "/cms-admin/page-types");
2289 ctx.insert("edit_id", &id);
2290 ctx.insert("form_verbose_name", &pt.verbose_name);
2291 ctx.insert("form_type_name", &pt.type_name);
2292 ctx.insert("form_allowed_parents", &pt.allowed_parents().join(", "));
2293 ctx.insert("form_allowed_children", &pt.allowed_children().join(", "));
2294 ctx.insert("form_workflow", &pt.workflow);
2295 insert_workflow_choices(&mut ctx, tenant.pool()).await;
2296 render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx)
2297}
2298
2299pub async fn page_type_update(
2302 tenant: Tenant,
2303 headers: HeaderMap,
2304 Path(id): Path<i64>,
2305 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2306 Form(form): Form<FormPageTypeCreate>,
2307) -> Result<Response, AdminError> {
2308 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2309 return Ok(r);
2310 }
2311 let Some(mut pt) = ui_page_type(tenant.pool(), id).await? else {
2312 return Err(AdminError::NotFound(id));
2313 };
2314 if form.verbose_name.trim().is_empty() {
2315 return Err(AdminError::Validation("Name is required.".to_owned()));
2316 }
2317 pt.verbose_name = form.verbose_name.trim().to_owned();
2318 pt.allowed_parent_types = type_list_json(&form.allowed_parents);
2319 pt.allowed_child_types = type_list_json(&form.allowed_children);
2320 pt.workflow = form.workflow.trim().to_owned();
2321 pt.save_pool(tenant.pool()).await?;
2322 redirect_named_with_message(
2323 "rcms-admin:page-types",
2324 MsgLevel::Success,
2325 "Page type settings saved.",
2326 &headers,
2327 )
2328}
2329
2330pub async fn page_type_create(
2334 State(state): State<super::AdminState>,
2335 tenant: Tenant,
2336 headers: HeaderMap,
2337 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2338 Form(form): Form<FormPageTypeCreate>,
2339) -> Result<Response, AdminError> {
2340 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2341 return Ok(r);
2342 }
2343 let ident_src = if form.type_name.trim().is_empty() {
2347 form.verbose_name.as_str()
2348 } else {
2349 form.type_name.as_str()
2350 };
2351 let slug = crate::forms::schema::slugify_key(ident_src);
2352 let err: Option<String> = if form.verbose_name.trim().is_empty() {
2353 Some("Name is required.".to_owned())
2354 } else if !crate::forms::schema::is_valid_key(&slug) {
2355 Some(
2356 "Identifier is invalid — use letters/digits/underscores, starting with a letter."
2357 .to_owned(),
2358 )
2359 } else if crate::page_type_model::PageType::objects()
2360 .where_(crate::page_type_model::PageType::type_name.eq(slug.clone()))
2361 .first(tenant.pool())
2362 .await?
2363 .is_some()
2364 || crate::page_type::find_handler(&slug).is_some()
2365 {
2366 Some(format!(
2367 "A page type with identifier `{slug}` already exists."
2368 ))
2369 } else {
2370 None
2371 };
2372 if let Some(msg) = err {
2373 let mut ctx = Context::new();
2374 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2375 add_admin_theme(&mut ctx, tenant.pool()).await;
2376 ctx.insert("list_url", "/cms-admin/page-types");
2377 ctx.insert("error", &msg);
2378 ctx.insert("form_verbose_name", &form.verbose_name);
2379 ctx.insert("form_type_name", &form.type_name);
2380 ctx.insert("form_allowed_parents", &form.allowed_parents);
2381 ctx.insert("form_allowed_children", &form.allowed_children);
2382 ctx.insert("form_workflow", &form.workflow);
2383 insert_workflow_choices(&mut ctx, tenant.pool()).await;
2384 return render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx);
2385 }
2386 let view_mode = crate::page_view::PageViewMode::parse(&form.view_mode);
2391 let default_template = if view_mode == crate::page_view::PageViewMode::Api {
2392 String::new()
2393 } else {
2394 crate::page_builder::DEFAULT_SCHEMA_TEMPLATE.to_owned()
2395 };
2396 let mut row = crate::page_type_model::PageType {
2397 id: rustango::sql::Auto::Unset,
2398 app_label: "cms_ui".to_owned(),
2399 type_name: slug.clone(),
2400 verbose_name: form.verbose_name.trim().to_owned(),
2401 default_template,
2402 view_mode: view_mode.as_str().to_owned(),
2403 is_creatable: true,
2404 allowed_parent_types: type_list_json(&form.allowed_parents),
2405 allowed_child_types: type_list_json(&form.allowed_children),
2406 workflow: form.workflow.trim().to_owned(),
2407 created_at: rustango::sql::Auto::Unset,
2408 updated_at: rustango::sql::Auto::Unset,
2409 };
2410 row.insert_pool(tenant.pool()).await?;
2411 let new_id = row.id.get().copied().unwrap_or_default();
2412 let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
2414 crate::page_builder::model::save_draft(
2415 tenant.pool(),
2416 new_id,
2417 serde_json::json!({ "nodes": [] }),
2418 created_by,
2419 )
2420 .await
2421 .log_warn("empty builder draft not seeded");
2422 redirect_named_with_params_and_message(
2423 "rcms-admin:page-types:build",
2424 &[("id", new_id.to_string())],
2425 MsgLevel::Success,
2426 "Page type created — design its body, then Publish.",
2427 &headers,
2428 )
2429}
2430
2431pub async fn page_type_delete(
2434 State(_state): State<super::AdminState>,
2435 tenant: Tenant,
2436 headers: HeaderMap,
2437 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2438 Path(id): Path<i64>,
2439) -> Result<Response, AdminError> {
2440 if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2441 return Ok(r);
2442 }
2443 let pt = crate::page_type_model::PageType::objects()
2444 .where_(crate::page_type_model::PageType::id.eq(id))
2445 .first(tenant.pool())
2446 .await?
2447 .ok_or(AdminError::NotFound(id))?;
2448 if pt.app_label != "cms_ui" {
2450 return redirect_named_with_message(
2451 "rcms-admin:page-types",
2452 MsgLevel::Error,
2453 "Only UI-created page types can be deleted.",
2454 &headers,
2455 );
2456 }
2457 let page_count = Page::objects()
2458 .where_(Page::page_type_id.eq(id))
2459 .fetch(tenant.pool())
2460 .await
2461 .map(|v| v.len())
2462 .unwrap_or(0);
2463 if page_count > 0 {
2464 return redirect_named_with_message(
2465 "rcms-admin:page-types",
2466 MsgLevel::Error,
2467 "Can't delete — pages still use this type. Delete or move them first.",
2468 &headers,
2469 );
2470 }
2471 for row in crate::page_builder::model::list_versions(tenant.pool(), id)
2473 .await
2474 .unwrap_or_default()
2475 {
2476 row.delete_pool(tenant.pool()).await.log_warn("page-builder schema version not deleted");
2477 }
2478 pt.delete_pool(tenant.pool()).await?;
2479 redirect_named_with_message(
2480 "rcms-admin:page-types",
2481 MsgLevel::Success,
2482 "Page type deleted.",
2483 &headers,
2484 )
2485}
2486
2487fn translation_canonical_html(widget_tag: &str, canonical: &str) -> String {
2491 if widget_tag == "richtext" && !canonical.trim().is_empty() {
2492 crate::markdown::sanitize_html(canonical)
2493 } else {
2494 String::new()
2495 }
2496}
2497
2498async fn builder_translation_groups(
2504 tenant: &Tenant,
2505 page_id: i64,
2506 page_type_id: i64,
2507 existing: &std::collections::HashMap<String, String>,
2508) -> (Vec<serde_json::Value>, std::collections::HashSet<String>) {
2509 let mut paths = std::collections::HashSet::new();
2510 let Ok(Some(row)) =
2511 crate::page_builder::model::published_for(tenant.pool(), page_type_id).await
2512 else {
2513 return (Vec::new(), paths);
2514 };
2515 let Ok(doc) = crate::page_builder::parse_schema(&row.document) else {
2516 return (Vec::new(), paths);
2517 };
2518 let components = crate::page_builder::model::component_map(tenant.pool())
2519 .await
2520 .unwrap_or_default();
2521 let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
2522 let (values, _) = crate::page_builder::values::load_upgraded(tenant.pool(), page_id, &compiled)
2523 .await
2524 .unwrap_or_else(|_| (serde_json::json!({}), Default::default()));
2525 let leaves = crate::page_builder::values::builder_translatable_leaves(&compiled, &values);
2526 let mut groups: Vec<serde_json::Value> = Vec::new();
2528 let mut cur = String::new();
2529 for leaf in &leaves {
2530 paths.insert(leaf.path.clone());
2531 let rowv = serde_json::json!({
2532 "path": leaf.path,
2533 "widget_kind": leaf.widget_kind.as_tag(),
2534 "field_label": leaf.field_label,
2535 "canonical": leaf.canonical_text,
2536 "canonical_html": translation_canonical_html(leaf.widget_kind.as_tag(), &leaf.canonical_text),
2537 "value": existing.get(&leaf.path).cloned().unwrap_or_default(),
2538 });
2539 if leaf.block_id != cur {
2540 cur.clone_from(&leaf.block_id);
2541 groups.push(serde_json::json!({
2542 "block_type": leaf.block_type,
2543 "block_label": leaf.block_label,
2544 "block_id": leaf.block_id,
2545 "depth": leaf.depth,
2546 "leaves": [rowv],
2547 }));
2548 } else if let Some(arr) = groups
2549 .last_mut()
2550 .and_then(|g| g.get_mut("leaves"))
2551 .and_then(|v| v.as_array_mut())
2552 {
2553 arr.push(rowv);
2554 }
2555 }
2556 (groups, paths)
2557}
2558
2559pub async fn media_bulk_move_collection(
2563 State(_state): State<super::AdminState>,
2564 tenant: Tenant,
2565 headers: HeaderMap,
2566 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
2567 Form(form): Form<Vec<(String, String)>>,
2568) -> Result<Response, AdminError> {
2569 let target: Option<i64> = form
2570 .iter()
2571 .find(|(k, _)| k == "collection_id")
2572 .and_then(|(_, v)| v.parse::<i64>().ok())
2573 .filter(|id| *id > 0);
2574 let ids: Vec<i64> = form
2575 .iter()
2576 .filter(|(k, _)| k == "ids" || k == "id")
2577 .filter_map(|(_, v)| v.parse::<i64>().ok())
2578 .collect();
2579 let kind = form
2580 .iter()
2581 .find(|(k, _)| k == "kind")
2582 .map(|(_, v)| v.clone())
2583 .unwrap_or_else(|| "image".to_owned());
2584 let mut touched = 0;
2585 for id in ids {
2586 if let Some(mut m) = Media::objects()
2587 .where_(Media::id.eq(id))
2588 .first(tenant.pool())
2589 .await?
2590 {
2591 m.collection_id = target;
2592 m.save_pool(tenant.pool()).await?;
2593 touched += 1;
2594 }
2595 }
2596 let redirect_url = if kind == "document" {
2597 "rcms-admin:documents:list"
2598 } else {
2599 "rcms-admin:media:list"
2600 };
2601 let dest = match target {
2602 Some(id) => format!("to collection #{id}"),
2603 None => "to Uncategorized".to_owned(),
2604 };
2605 redirect_named_with_message_plural(
2606 redirect_url,
2607 MsgLevel::Success,
2608 "Moved {count} item(s) {dest}.",
2609 touched as i64,
2610 &[("count", &touched.to_string()), ("dest", &dest)],
2611 &headers,
2612 )
2613}
2614
2615pub async fn collection_permissions_form(
2619 State(state): State<super::AdminState>,
2620 tenant: Tenant,
2621 headers: HeaderMap,
2622 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2623 Path(id): Path<i64>,
2624) -> Result<Response, AdminError> {
2625 let collection = crate::media::MediaCollection::objects()
2626 .where_(crate::media::MediaCollection::id.eq(id))
2627 .first(tenant.pool())
2628 .await?
2629 .ok_or(AdminError::NotFound(id))?;
2630 let roles: Vec<rustango::tenancy::permissions::Role> =
2631 rustango::tenancy::permissions::Role::objects()
2632 .order_by(&[("name", false)])
2633 .fetch(tenant.pool())
2634 .await?;
2635 let grants: Vec<crate::permissions::CollectionPermission> =
2636 crate::permissions::CollectionPermission::objects()
2637 .where_(crate::permissions::CollectionPermission::collection_id.eq(id))
2638 .fetch(tenant.pool())
2639 .await?;
2640 let granted: std::collections::HashSet<(i64, String)> = grants
2641 .iter()
2642 .map(|g| (g.role_id, g.permission.clone()))
2643 .collect();
2644 let actions: Vec<&str> = crate::permissions::Action::all()
2645 .iter()
2646 .map(|a| a.as_str())
2647 .collect();
2648 let perm_grid: Vec<serde_json::Value> = roles
2649 .iter()
2650 .map(|r| {
2651 let rid = r.id.get().copied().unwrap_or_default();
2652 let row_cells: Vec<serde_json::Value> = actions
2653 .iter()
2654 .map(|a| {
2655 serde_json::json!({
2656 "action": a,
2657 "granted": granted.contains(&(rid, (*a).to_owned())),
2658 })
2659 })
2660 .collect();
2661 serde_json::json!({
2662 "role_id": rid,
2663 "role_name": r.name,
2664 "role_description": r.description,
2665 "cells": row_cells,
2666 })
2667 })
2668 .collect();
2669
2670 let mut ctx = Context::new();
2671 add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
2672 add_admin_theme(&mut ctx, tenant.pool()).await;
2673 ctx.insert("collection_id", &id);
2674 ctx.insert("collection_name", &collection.name);
2675 ctx.insert("perm_actions", &actions);
2676 ctx.insert("perm_grid", &perm_grid);
2677
2678 let restriction = crate::collection_view_restriction::direct_for_collection(tenant.pool(), id)
2681 .await
2682 .unwrap_or_default();
2683 let restriction_kind = restriction
2684 .as_ref()
2685 .map(|r| r.kind.clone())
2686 .unwrap_or_else(|| "none".to_owned());
2687 let restriction_groups: std::collections::HashSet<i64> = restriction
2688 .as_ref()
2689 .map(|r| r.parsed_groups().into_iter().collect())
2690 .unwrap_or_default();
2691 let restriction_has_password = restriction
2692 .as_ref()
2693 .map(|r| !r.password_hash.is_empty())
2694 .unwrap_or(false);
2695 let role_options: Vec<serde_json::Value> = roles
2696 .iter()
2697 .map(|r| {
2698 let rid = r.id.get().copied().unwrap_or_default();
2699 serde_json::json!({
2700 "id": rid,
2701 "name": r.name,
2702 "selected": restriction_groups.contains(&rid),
2703 })
2704 })
2705 .collect();
2706 let restriction_codenames: Vec<String> = restriction
2708 .as_ref()
2709 .map(|r| r.parsed_codenames())
2710 .unwrap_or_default();
2711 let restriction_codenames_str = restriction_codenames.join(",");
2712 let codename_choices: Vec<serde_json::Value> = super::resources::membership_codenames()
2713 .into_iter()
2714 .map(|(codename, label)| {
2715 serde_json::json!({
2716 "codename": codename,
2717 "label": label,
2718 "checked": restriction_codenames.contains(&codename),
2719 })
2720 })
2721 .collect();
2722 ctx.insert("restriction_kind", &restriction_kind);
2723 ctx.insert("restriction_has_password", &restriction_has_password);
2724 ctx.insert("restriction_roles", &role_options);
2725 ctx.insert("restriction_codenames_str", &restriction_codenames_str);
2726 ctx.insert("restriction_codename_choices", &codename_choices);
2727
2728 render_with_csrf(
2729 &state,
2730 &headers,
2731 "rcms_admin/collection_permissions.html",
2732 &mut ctx,
2733 )
2734}
2735
2736#[derive(Deserialize)]
2738pub struct CollectionPrivacyForm {
2739 pub kind: String,
2740 #[serde(default)]
2741 pub password: String,
2742 #[serde(default)]
2743 pub group_ids: String,
2744 #[serde(default)]
2747 pub codenames: String,
2748}
2749
2750pub async fn collection_privacy_submit(
2754 State(_state): State<super::AdminState>,
2755 tenant: Tenant,
2756 headers: HeaderMap,
2757 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
2758 Path(id): Path<i64>,
2759 Form(form): Form<CollectionPrivacyForm>,
2760) -> Result<Response, AdminError> {
2761 use rustango::sql::Auto;
2762 let existing =
2763 crate::collection_view_restriction::direct_for_collection(tenant.pool(), id).await?;
2764 if form.kind == "none" {
2765 if let Some(row) = existing {
2766 row.delete_pool(tenant.pool()).await?;
2767 return redirect_named_with_params_and_message(
2768 "rcms-admin:media:collection-permissions",
2769 &[("id", id.to_string())],
2770 MsgLevel::Success,
2771 "Removed view restriction — collection is now public.",
2772 &headers,
2773 );
2774 }
2775 return redirect_named_with_params_and_message(
2776 "rcms-admin:media:collection-permissions",
2777 &[("id", id.to_string())],
2778 MsgLevel::Info,
2779 "No restriction to remove.",
2780 &headers,
2781 );
2782 }
2783 let Some(kind) = crate::collection_view_restriction::RestrictionKind::parse(&form.kind) else {
2784 return Err(AdminError::Validation(format!(
2785 "unknown restriction kind `{}`",
2786 form.kind
2787 )));
2788 };
2789 let password_hash = match kind {
2790 crate::collection_view_restriction::RestrictionKind::Password => {
2791 if form.password.is_empty() {
2792 if let Some(row) = &existing {
2793 if row.kind == kind.as_str() {
2794 row.password_hash.clone()
2795 } else {
2796 return redirect_named_with_params_and_message(
2797 "rcms-admin:media:collection-permissions",
2798 &[("id", id.to_string())],
2799 MsgLevel::Error,
2800 "Password is required when switching the restriction kind to password.",
2801 &headers,
2802 );
2803 }
2804 } else {
2805 return redirect_named_with_params_and_message(
2806 "rcms-admin:media:collection-permissions",
2807 &[("id", id.to_string())],
2808 MsgLevel::Error,
2809 "Password is required for password-protected collections.",
2810 &headers,
2811 );
2812 }
2813 } else {
2814 crate::passwords::hash(&form.password).await
2815 .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?
2816 }
2817 }
2818 _ => String::new(),
2819 };
2820 let group_ids: Vec<i64> = if matches!(
2821 kind,
2822 crate::collection_view_restriction::RestrictionKind::Groups
2823 ) {
2824 form.group_ids
2825 .split(',')
2826 .filter_map(|s| s.trim().parse::<i64>().ok())
2827 .collect()
2828 } else {
2829 Vec::new()
2830 };
2831 let group_json = serde_json::json!(group_ids);
2832 let codenames: Vec<String> = if matches!(
2833 kind,
2834 crate::collection_view_restriction::RestrictionKind::Permission
2835 ) {
2836 form.codenames
2837 .split(',')
2838 .map(str::trim)
2839 .filter(|s| !s.is_empty())
2840 .map(str::to_owned)
2841 .collect()
2842 } else {
2843 Vec::new()
2844 };
2845 let codenames_json = serde_json::json!(codenames);
2846 match existing {
2847 Some(mut row) => {
2848 row.kind = kind.as_str().to_owned();
2849 row.password_hash = password_hash;
2850 row.group_ids = group_json;
2851 row.codenames = codenames_json;
2852 row.save_pool(tenant.pool()).await?;
2853 }
2854 None => {
2855 let mut row = crate::collection_view_restriction::CollectionViewRestriction {
2856 id: Auto::Unset,
2857 collection_id: id,
2858 kind: kind.as_str().to_owned(),
2859 password_hash,
2860 group_ids: group_json,
2861 codenames: codenames_json,
2862 created_at: Auto::Unset,
2863 updated_at: Auto::Unset,
2864 };
2865 row.insert_pool(tenant.pool()).await?;
2866 }
2867 }
2868 redirect_named_with_params_and_message(
2869 "rcms-admin:media:collection-permissions",
2870 &[("id", id.to_string())],
2871 MsgLevel::Success,
2872 "Collection privacy updated. New requests to /__media__/<spec>/<id> will enforce it.",
2873 &headers,
2874 )
2875}
2876
2877pub async fn collection_permissions_submit(
2882 State(_state): State<super::AdminState>,
2883 tenant: Tenant,
2884 Path(collection_id): Path<i64>,
2885 axum::Json(payload): axum::Json<PagePermissionsPayload>,
2886) -> Result<Response, AdminError> {
2887 use rustango::sql::Auto;
2888 let valid_actions: std::collections::HashSet<&str> = crate::permissions::Action::all()
2889 .iter()
2890 .map(|a| a.as_str())
2891 .collect();
2892 let want: std::collections::BTreeSet<(i64, String)> = payload
2893 .grants
2894 .iter()
2895 .filter(|g| valid_actions.contains(g.action.as_str()))
2896 .map(|g| (g.role_id, g.action.clone()))
2897 .collect();
2898
2899 let existing: Vec<crate::permissions::CollectionPermission> =
2900 crate::permissions::CollectionPermission::objects()
2901 .where_(crate::permissions::CollectionPermission::collection_id.eq(collection_id))
2902 .fetch(tenant.pool())
2903 .await?;
2904 let have: std::collections::BTreeSet<(i64, String)> = existing
2905 .iter()
2906 .map(|p| (p.role_id, p.permission.clone()))
2907 .collect();
2908
2909 for p in &existing {
2910 let key = (p.role_id, p.permission.clone());
2911 if !want.contains(&key) {
2912 p.clone().delete_pool(tenant.pool()).await?;
2913 }
2914 }
2915 for (role_id, action) in &want {
2916 if !have.contains(&(*role_id, action.clone())) {
2917 let mut row = crate::permissions::CollectionPermission {
2918 id: Auto::Unset,
2919 collection_id,
2920 role_id: *role_id,
2921 permission: action.clone(),
2922 created_at: Auto::Unset,
2923 };
2924 row.insert_pool(tenant.pool()).await?;
2925 }
2926 }
2927 Ok(axum::http::StatusCode::NO_CONTENT.into_response())
2928}
2929
2930#[derive(Debug, Deserialize)]
2934pub struct PagePermissionsPayload {
2935 pub grants: Vec<PagePermissionGrant>,
2936}
2937#[derive(Debug, Deserialize)]
2938pub struct PagePermissionGrant {
2939 pub role_id: i64,
2940 pub action: String,
2941}
2942
2943pub async fn page_permissions_submit(
2948 State(_state): State<super::AdminState>,
2949 tenant: Tenant,
2950 Path(page_id): Path<i64>,
2951 axum::Json(payload): axum::Json<PagePermissionsPayload>,
2952) -> Result<Response, AdminError> {
2953 use rustango::sql::Auto;
2954 let valid_actions: std::collections::HashSet<&str> = crate::permissions::Action::all()
2955 .iter()
2956 .map(|a| a.as_str())
2957 .collect();
2958 let want: std::collections::BTreeSet<(i64, String)> = payload
2959 .grants
2960 .iter()
2961 .filter(|g| valid_actions.contains(g.action.as_str()))
2962 .map(|g| (g.role_id, g.action.clone()))
2963 .collect();
2964
2965 let existing: Vec<crate::permissions::PagePermission> =
2966 crate::permissions::PagePermission::objects()
2967 .where_(crate::permissions::PagePermission::page_id.eq(page_id))
2968 .fetch(tenant.pool())
2969 .await?;
2970 let have: std::collections::BTreeSet<(i64, String)> = existing
2971 .iter()
2972 .map(|p| (p.role_id, p.permission.clone()))
2973 .collect();
2974
2975 for p in &existing {
2977 let key = (p.role_id, p.permission.clone());
2978 if !want.contains(&key) {
2979 p.clone().delete_pool(tenant.pool()).await?;
2980 }
2981 }
2982 for (role_id, action) in &want {
2984 if !have.contains(&(*role_id, action.clone())) {
2985 let mut row = crate::permissions::PagePermission {
2986 id: Auto::Unset,
2987 page_id,
2988 role_id: *role_id,
2989 permission: action.clone(),
2990 created_at: Auto::Unset,
2991 };
2992 row.insert_pool(tenant.pool()).await?;
2993 }
2994 }
2995
2996 Ok(axum::http::StatusCode::NO_CONTENT.into_response())
2997}
2998
2999fn render_extra_tabs(
3005 specs: Vec<crate::page_type::TabSpec>,
3006 tera: &std::sync::Arc<tera::Tera>,
3007 base_ctx: &Context,
3008 headers: &HeaderMap,
3009) -> Vec<serde_json::Value> {
3010 use crate::page_type::TabBody;
3011 specs
3012 .into_iter()
3013 .map(|spec| {
3014 let html = match spec.body {
3015 TabBody::Html(s) => s,
3016 TabBody::Template { path, context } => {
3017 let mut tab_ctx = base_ctx.clone();
3018 for (k, v) in context {
3019 tab_ctx.insert(&k, &v);
3020 }
3021 tera.render(&path, &tab_ctx).unwrap_or_else(|e| {
3022 format!(
3023 r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3024 <span class="rcms-flash-body"><strong>{label}</strong> {failed} <code>{path}</code>: {e}</span>
3025</div>"#,
3026 label = tera::escape_html(&super::i18n::tr(headers, "Tab template error:", &[])),
3027 failed = tera::escape_html(&super::i18n::tr(headers, "failed to render", &[])),
3028 path = tera::escape_html(&path),
3029 e = tera::escape_html(&e.to_string()),
3030 )
3031 })
3032 }
3033 TabBody::Widgets(widgets) => {
3034 let mut ctx = Context::new();
3035 ctx.insert("widgets", &widgets);
3036 tera.render("rcms_admin/_widget_group.html", &ctx)
3037 .unwrap_or_else(|e| {
3038 format!(
3039 r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3040 <span class="rcms-flash-body"><strong>{label}</strong> {e}</span>
3041</div>"#,
3042 label = tera::escape_html(&super::i18n::tr(headers, "Widget-group tab error:", &[])),
3043 e = tera::escape_html(&e.to_string()),
3044 )
3045 })
3046 }
3047 TabBody::Group { heading, help, layout, widgets } => {
3048 let mut ctx = Context::new();
3053 ctx.insert("widgets", &widgets);
3054 let inner = tera
3055 .render("rcms_admin/_widget_group.html", &ctx)
3056 .unwrap_or_else(|e| {
3057 format!(
3058 r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3059 <span class="rcms-flash-body"><strong>{label}</strong> {e}</span>
3060</div>"#,
3061 label = tera::escape_html(&super::i18n::tr(headers, "Panel-group tab error:", &[])),
3062 e = tera::escape_html(&e.to_string()),
3063 )
3064 });
3065 let help_html = if help.is_empty() {
3066 String::new()
3067 } else {
3068 format!(
3069 r#"<p class="rcms-hint rcms-panel-group-help">{}</p>"#,
3070 tera::escape_html(&help),
3071 )
3072 };
3073 format!(
3074 r#"<fieldset class="rcms-panel-group rcms-panel-group--{layout}">
3075 <legend>{heading}</legend>
3076 {help_html}
3077 <div class="rcms-panel-group-body">{inner}</div>
3078</fieldset>"#,
3079 layout = layout.class_suffix(),
3080 heading = tera::escape_html(&heading),
3081 help_html = help_html,
3082 inner = inner,
3083 )
3084 }
3085 TabBody::Help { content } => {
3086 format!(
3089 r#"<div class="rcms-panel-help">{content}</div>"#,
3090 content = content,
3091 )
3092 }
3093 };
3094 serde_json::json!({
3095 "name": spec.name,
3096 "label": spec.label,
3097 "icon": spec.icon,
3098 "badge": spec.badge,
3099 "html": html,
3100 })
3101 })
3102 .collect()
3103}
3104
3105pub async fn admin_page_dispatch(
3110 State(state): State<super::AdminState>,
3111 tenant: Tenant,
3112 headers: HeaderMap,
3113 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3114 Path(slug): Path<String>,
3115) -> Result<Response, AdminError> {
3116 match super::admin_page::find_admin_page(&slug) {
3117 Some(handler) => Ok(handler
3118 .render(super::admin_page::AdminPageCtx {
3119 tera: &state.tera,
3120 tenant: &tenant,
3121 headers: &headers,
3122 user: session_user.as_ref(),
3123 })
3124 .await),
3125 None => Err(AdminError::NotFound(0)),
3126 }
3127}
3128
3129pub(crate) async fn add_admin_theme(ctx: &mut Context, pool: &rustango::sql::Pool) {
3134 let mut admin_default: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3137 .where_(crate::theme::Theme::is_admin_default.eq(true))
3138 .fetch(pool)
3139 .await
3140 .unwrap_or_default();
3141 let theme = if let Some(t) = admin_default.pop() {
3142 t
3143 } else {
3144 let mut any: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3145 .where_(crate::theme::Theme::is_default.eq(true))
3146 .fetch(pool)
3147 .await
3148 .unwrap_or_default();
3149 match any.pop() {
3150 Some(t) => t,
3151 None => {
3152 let mut first: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3153 .order_by(&[("name", false)])
3154 .fetch(pool)
3155 .await
3156 .unwrap_or_default();
3157 let Some(t) = first.pop() else {
3158 ctx.insert("theme_css", &String::new());
3161 ctx.insert("theme_slug", &String::new());
3162 ctx.insert("theme_default_mode", &"light");
3163 ctx.insert("theme_font_url", &String::new());
3164 return;
3165 };
3166 t
3167 }
3168 }
3169 };
3170 let theme_id = theme.id.get().copied().unwrap_or_default();
3171 let brand_colors: Vec<crate::theme::BrandColor> = crate::theme::BrandColor::objects()
3172 .where_(crate::theme::BrandColor::theme_id.eq(theme_id))
3173 .order_by(&[("sort_order", false)])
3174 .fetch(pool)
3175 .await
3176 .unwrap_or_default();
3177 let css = crate::theme::emit_css(&theme, &brand_colors);
3178 ctx.insert("theme_css", &css);
3179 ctx.insert("theme_slug", &theme.slug);
3180 ctx.insert("theme_name", &theme.name);
3181 ctx.insert("theme_default_mode", &theme.default_mode);
3182 ctx.insert("theme_font_url", &theme.font_url);
3183}
3184
3185#[derive(Debug, Deserialize)]
3187pub struct ListQuery {
3188 #[serde(default)]
3191 pub parent: Option<i64>,
3192 #[serde(default)]
3196 pub q: Option<String>,
3197 #[serde(default)]
3200 pub r#type: Option<String>,
3201 #[serde(default)]
3203 pub status: Option<String>,
3204}
3205
3206pub async fn page_list(
3217 State(state): State<super::AdminState>,
3218 tenant: Tenant,
3219 headers: HeaderMap,
3220 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3221 Query(q): Query<ListQuery>,
3222) -> Result<Response, AdminError> {
3223 match crate::page::run_schedule_sweep_with_mailer(
3227 tenant.pool(),
3228 state.mailer.as_deref(),
3229 &state.mailer_from,
3230 &tenant.org.slug,
3231 )
3232 .await
3233 {
3234 Ok(result) if !result.changed_urls.is_empty() => {
3237 crate::task_queue::purge_urls(
3238 state.cache_invalidator.clone(),
3239 tenant.org.slug.clone(),
3240 result.changed_urls,
3241 )
3242 .await;
3243 }
3244 Ok(_) => {}
3245 Err(e) => tracing::warn!(target: "rustango_cms::admin", error = %e, "schedule sweep failed"),
3246 }
3247
3248 let all_pages: Vec<Page> = Page::objects()
3254 .order_by(&[("path", false), ("sort_order", false)])
3255 .fetch(tenant.pool())
3256 .await?;
3257
3258 let by_id: std::collections::HashMap<i64, &Page> = all_pages
3260 .iter()
3261 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
3262 .collect();
3263
3264 let parent_page: Option<&Page> = q.parent.and_then(|pid| by_id.get(&pid).copied());
3266
3267 let mut breadcrumbs: Vec<serde_json::Value> = Vec::new();
3269 if let Some(mut cur) = parent_page {
3270 breadcrumbs.push(serde_json::json!({
3271 "id": cur.id.get().copied(),
3272 "title": cur.title.clone(),
3273 }));
3274 while let Some(ppid) = cur.parent_id {
3275 if let Some(p) = by_id.get(&ppid).copied() {
3276 breadcrumbs.push(serde_json::json!({
3277 "id": p.id.get().copied(),
3278 "title": p.title.clone(),
3279 }));
3280 cur = p;
3281 } else {
3282 break;
3283 }
3284 }
3285 breadcrumbs.reverse();
3286 }
3287
3288 let search_query =
3292 q.q.as_deref()
3293 .map(str::trim)
3294 .filter(|s| !s.is_empty())
3295 .map(str::to_owned);
3296 let status_filter = q
3297 .status
3298 .as_deref()
3299 .map(str::trim)
3300 .filter(|s| !s.is_empty())
3301 .map(str::to_owned);
3302 let type_filter_slug = q
3303 .r#type
3304 .as_deref()
3305 .map(str::trim)
3306 .filter(|s| !s.is_empty())
3307 .map(str::to_owned);
3308
3309 let viewer_user_id: Option<i64> = session_user
3315 .as_ref()
3316 .filter(|u| u.active)
3317 .and_then(|u| u.id.get().copied());
3318 let viewer_is_superuser = session_user.as_ref().is_some_and(|u| u.is_superuser);
3319 let permission_filter_enabled = viewer_user_id.is_some() && !viewer_is_superuser;
3320 let viewable_ids: Option<std::collections::HashSet<i64>> = match viewer_user_id {
3321 Some(uid) if permission_filter_enabled => {
3322 let pages: Vec<(i64, Option<i64>)> = all_pages
3323 .iter()
3324 .filter_map(|p| p.id.get().copied().map(|id| (id, p.parent_id)))
3325 .collect();
3326 Some(
3327 crate::permissions::viewable_page_ids(tenant.pool(), uid, &pages)
3328 .await
3329 .unwrap_or_default(),
3330 )
3331 }
3332 _ => None,
3333 };
3334
3335 let fts_rank: Option<std::collections::HashMap<i64, usize>> = match search_query.as_deref() {
3340 Some(q) => crate::search::search_page_ids_all_statuses(tenant.pool(), q, 1000)
3341 .await
3342 .map(|ids| ids.iter().enumerate().map(|(i, id)| (*id, i)).collect()),
3343 None => None,
3344 };
3345 let visible: Vec<&Page> = if search_query.is_some()
3346 || status_filter.is_some()
3347 || type_filter_slug.is_some()
3348 {
3349 let q_lower = search_query.as_deref().map(str::to_lowercase);
3351 let prefetch_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3355 let type_id_by_slug: std::collections::HashMap<String, i64> = prefetch_types
3356 .iter()
3357 .filter_map(|t| t.id.get().copied().map(|id| (t.type_name.clone(), id)))
3358 .collect();
3359 let type_id_filter = type_filter_slug
3360 .as_deref()
3361 .and_then(|s| type_id_by_slug.get(s).copied());
3362 all_pages
3363 .iter()
3364 .filter(|p| {
3365 let matches_search = match &q_lower {
3371 None => true,
3372 Some(needle) => {
3373 fts_rank.as_ref().is_some_and(|rank| {
3374 p.id.get().copied().is_some_and(|id| rank.contains_key(&id))
3375 }) || p.title.to_lowercase().contains(needle)
3376 || p.slug.to_lowercase().contains(needle)
3377 || p.url_path.to_lowercase().contains(needle)
3378 }
3379 };
3380 let matches_status = match &status_filter {
3381 None => true,
3382 Some(s) => p.status == *s,
3383 };
3384 let matches_type = match type_id_filter {
3385 None => true,
3386 Some(id) => p.page_type_id == id,
3387 };
3388 matches_search && matches_status && matches_type
3389 })
3390 .collect()
3391 } else {
3392 all_pages
3394 .iter()
3395 .filter(|p| p.parent_id == q.parent)
3396 .collect()
3397 };
3398 let visible_before_permission_filter = visible.len();
3402 let visible: Vec<&Page> = match &viewable_ids {
3405 None => visible,
3406 Some(set) => visible
3407 .into_iter()
3408 .filter(|p| p.id.get().copied().is_some_and(|id| set.contains(&id)))
3409 .collect(),
3410 };
3411 let visible: Vec<&Page> = if let Some(rank) = &fts_rank {
3414 let mut v = visible;
3415 v.sort_by_key(|p| {
3416 p.id.get()
3417 .copied()
3418 .and_then(|id| rank.get(&id).copied())
3419 .unwrap_or(usize::MAX)
3420 });
3421 v
3422 } else {
3423 visible
3424 };
3425 let is_search_mode =
3426 search_query.is_some() || status_filter.is_some() || type_filter_slug.is_some();
3427 let empty_filtered = is_search_mode && visible.is_empty();
3434 let empty_hidden_by_perms = !is_search_mode
3435 && visible.is_empty()
3436 && visible_before_permission_filter > 0
3437 && permission_filter_enabled;
3438
3439 let mut child_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
3441 for p in &all_pages {
3442 if let Some(ppid) = p.parent_id {
3443 *child_counts.entry(ppid).or_insert(0) += 1;
3444 }
3445 }
3446
3447 let types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3448 let type_map: std::collections::HashMap<i64, String> = types
3449 .iter()
3450 .filter_map(|t| t.id.get().copied().map(|id| (id, t.verbose_name.clone())))
3451 .collect();
3452
3453 let live_urls = build_live_url_map(&all_pages);
3454
3455 let ancestors_for = |p: &Page| -> Vec<serde_json::Value> {
3459 let mut chain: Vec<serde_json::Value> = Vec::new();
3460 let mut cur_parent = p.parent_id;
3461 while let Some(pid) = cur_parent {
3462 match by_id.get(&pid).copied() {
3463 Some(ancestor) => {
3464 chain.push(serde_json::json!({
3465 "id": ancestor.id.get().copied(),
3466 "title": ancestor.title.clone(),
3467 }));
3468 cur_parent = ancestor.parent_id;
3469 }
3470 None => break,
3471 }
3472 }
3473 chain.reverse();
3474 chain
3475 };
3476
3477 let rows: Vec<serde_json::Value> = visible
3478 .iter()
3479 .map(|p| {
3480 let id = p.id.get().copied();
3481 let ancestors = if is_search_mode {
3482 ancestors_for(p)
3483 } else {
3484 Vec::new()
3485 };
3486 serde_json::json!({
3487 "id": id,
3488 "title": p.title,
3489 "slug": p.slug,
3490 "path": p.path,
3491 "url_path": p.url_path,
3492 "status": p.status,
3493 "page_type_id": p.page_type_id,
3494 "go_live_at": p.go_live_at,
3495 "expire_at": p.expire_at,
3496 "updated_at": p.updated_at.get().copied(),
3497 "published_at": p.published_at,
3498 "locale_variant_of": p.locale_variant_of,
3499 "alias_of": p.alias_of,
3500 "child_count": id.and_then(|i| child_counts.get(&i).copied()).unwrap_or(0),
3501 "ancestors": ancestors,
3502 })
3503 })
3504 .collect();
3505
3506 let mut ctx = Context::new();
3507 add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3508 add_admin_theme(&mut ctx, tenant.pool()).await;
3509 ctx.insert("rows", &rows);
3510 ctx.insert("type_map", &type_map);
3511 ctx.insert("creatable_types", &allowed_root_types(&types));
3513 ctx.insert("live_urls", &live_urls);
3514 ctx.insert("breadcrumbs", &breadcrumbs);
3515 ctx.insert("parent_id", &q.parent);
3516 ctx.insert("parent_title", &parent_page.map(|p| p.title.clone()));
3517 ctx.insert("search_query", &search_query);
3518 ctx.insert("status_filter", &status_filter);
3519 ctx.insert("type_filter", &type_filter_slug);
3520 ctx.insert("is_search_mode", &is_search_mode);
3521 ctx.insert("empty_filtered", &empty_filtered);
3522 ctx.insert("empty_hidden_by_perms", &empty_hidden_by_perms);
3523 let mut type_slugs: Vec<(String, String)> = types
3526 .iter()
3527 .map(|t| (t.type_name.clone(), t.verbose_name.clone()))
3528 .collect();
3529 type_slugs.sort_by(|a, b| a.1.cmp(&b.1));
3530 ctx.insert("type_choices", &type_slugs);
3531
3532 let move_choices: Vec<serde_json::Value> = all_pages
3538 .iter()
3539 .map(|p| {
3540 let indent = "—".repeat(p.depth.max(1) as usize - 1);
3541 let label = if indent.is_empty() {
3542 p.title.clone()
3543 } else {
3544 format!("{indent} {}", p.title)
3545 };
3546 serde_json::json!({
3547 "id": p.id.get().copied(),
3548 "label": label,
3549 "path": p.path.clone(),
3550 })
3551 })
3552 .collect();
3553 ctx.insert("move_choices", &move_choices);
3554 ctx.insert(
3557 "plugin_page_listing_buttons",
3558 &crate::hooks::page_listing_buttons_raw(),
3559 );
3560 let plugin_bulk_actions: Vec<serde_json::Value> = crate::hooks::bulk_actions_for("cms_page")
3562 .into_iter()
3563 .map(|a| {
3564 serde_json::json!({
3565 "key": a.key,
3566 "label": a.label,
3567 "icon": a.icon,
3568 "danger": a.danger,
3569 "confirm_message": a.confirm_message,
3570 "action_url": a.action_url,
3571 })
3572 })
3573 .collect();
3574 ctx.insert("plugin_bulk_actions", &plugin_bulk_actions);
3575 let copy_locales: Vec<Locale> = Locale::objects()
3578 .where_(Locale::active.eq(true))
3579 .order_by(&[("sort_order", false), ("code", false)])
3580 .fetch(tenant.pool())
3581 .await
3582 .unwrap_or_default()
3583 .into_iter()
3584 .filter(|l| !l.is_default)
3585 .collect();
3586 ctx.insert("copy_locales", ©_locales);
3587 render_with_csrf(&state, &headers, "rcms_admin/page_list.html", &mut ctx)
3588}
3589
3590fn extract_inline_panel_rows(
3607 form: &std::collections::HashMap<String, String>,
3608 spec: &crate::page_type::InlinePanelSpec,
3609) -> Vec<serde_json::Map<String, serde_json::Value>> {
3610 let mut by_idx: std::collections::BTreeMap<usize, serde_json::Map<String, serde_json::Value>> =
3611 std::collections::BTreeMap::new();
3612 let prefix = format!("inline__{}__", spec.name);
3613 for (key, value) in form {
3614 let Some(rest) = key.strip_prefix(&prefix) else {
3615 continue;
3616 };
3617 let Some((idx_str, field_name)) = rest.split_once("__") else {
3618 continue;
3619 };
3620 let Ok(idx) = idx_str.parse::<usize>() else {
3621 continue;
3622 };
3623 if field_name == "__deleted" && value == "1" {
3624 by_idx.remove(&idx);
3625 let mut row = serde_json::Map::new();
3629 row.insert("__deleted".to_owned(), serde_json::Value::Bool(true));
3630 by_idx.insert(idx, row);
3631 continue;
3632 }
3633 if !spec.fields.iter().any(|f| f.name == field_name) {
3634 continue;
3635 }
3636 let row = by_idx.entry(idx).or_default();
3637 if row.contains_key("__deleted") {
3638 continue;
3639 }
3640 row.insert(
3641 field_name.to_owned(),
3642 serde_json::Value::String(value.clone()),
3643 );
3644 }
3645 by_idx
3646 .into_iter()
3647 .filter_map(|(_, row)| {
3648 if row.contains_key("__deleted") {
3649 None
3650 } else {
3651 Some(row)
3652 }
3653 })
3654 .collect()
3655}
3656
3657fn build_live_url_map(pages: &[Page]) -> std::collections::HashMap<String, String> {
3658 let mut by_id: std::collections::HashMap<String, String> = std::collections::HashMap::new();
3659 for p in pages {
3660 let Some(pid) = p.id.get().copied() else {
3661 continue;
3662 };
3663 let url = match p.parent_id {
3664 None => {
3665 if p.slug.is_empty() {
3666 "/".to_owned()
3667 } else {
3668 format!("/{}", p.slug)
3669 }
3670 }
3671 Some(parent_id) => {
3672 let parent_url = by_id
3673 .get(&parent_id.to_string())
3674 .cloned()
3675 .unwrap_or_else(|| "/".to_owned());
3676 if p.slug.is_empty() {
3677 parent_url
3678 } else if parent_url == "/" {
3679 format!("/{}", p.slug)
3680 } else {
3681 format!("{}/{}", parent_url, p.slug)
3682 }
3683 }
3684 };
3685 by_id.insert(pid.to_string(), url);
3688 }
3689 by_id
3690}
3691
3692#[derive(Debug, Deserialize)]
3707pub struct NewQuery {
3708 #[serde(default)]
3709 pub parent: Option<i64>,
3710 #[serde(default, rename = "type")]
3711 pub type_id: Option<i64>,
3712}
3713
3714pub async fn page_new_form(
3715 State(state): State<super::AdminState>,
3716 tenant: Tenant,
3717 headers: HeaderMap,
3718 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3719 Query(q): Query<NewQuery>,
3720) -> Result<Response, AdminError> {
3721 let all_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3722
3723 let (parent, allowed_types) = match q.parent {
3724 Some(pid) => {
3725 let parent_row = Page::objects()
3726 .where_(Page::id.eq(pid))
3727 .first(tenant.pool())
3728 .await?
3729 .ok_or(AdminError::NotFound(pid))?;
3730 let allowed = allowed_children_for(&parent_row, &all_types);
3731 (Some(parent_row), allowed)
3732 }
3733 None => (None, allowed_root_types(&all_types)),
3735 };
3736
3737 let Some(type_id) = q.type_id else {
3739 #[derive(serde::Serialize)]
3744 struct PickerType<'a> {
3745 id: i64,
3746 type_name: &'a str,
3747 verbose_name: &'a str,
3748 icon: Option<&'static str>,
3749 description: Option<&'static str>,
3750 }
3751 let allowed_enriched: Vec<PickerType<'_>> = allowed_types
3752 .iter()
3753 .map(|t| {
3754 let handler = find_handler(&t.type_name);
3755 PickerType {
3756 id: t.id.get().copied().unwrap_or_default(),
3757 type_name: t.type_name.as_str(),
3758 verbose_name: t.verbose_name.as_str(),
3759 icon: handler.as_ref().and_then(|h| h.icon()),
3760 description: handler.as_ref().and_then(|h| h.description()),
3761 }
3762 })
3763 .collect();
3764
3765 let mut ctx = Context::new();
3766 add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3767 add_admin_theme(&mut ctx, tenant.pool()).await;
3768 ctx.insert("parent", &parent);
3769 ctx.insert("allowed_types", &allowed_enriched);
3770 return render_with_csrf(
3771 &state,
3772 &headers,
3773 "rcms_admin/page_type_picker.html",
3774 &mut ctx,
3775 );
3776 };
3777
3778 let chosen_type = allowed_types
3783 .iter()
3784 .find(|t| t.id.get().copied() == Some(type_id))
3785 .cloned()
3786 .ok_or_else(|| {
3787 AdminError::Validation(format!(
3788 "page type {type_id} is not creatable under the chosen parent"
3789 ))
3790 })?;
3791
3792 let mut page_seed = empty_page_form_values();
3793 if let Some(obj) = page_seed.as_object_mut() {
3794 obj.insert("page_type_id".to_owned(), serde_json::json!(type_id));
3795 }
3796
3797 let mut ctx = Context::new();
3798 add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3799 add_admin_theme(&mut ctx, tenant.pool()).await;
3800 ctx.insert("mode", "new");
3801 ctx.insert("parent", &parent);
3802 ctx.insert("chosen_type", &chosen_type);
3803 ctx.insert("page", &page_seed);
3804 let review_required = !session_user.as_ref().is_some_and(|u| u.is_superuser)
3805 && crate::workflow::review_workflow_for_type(tenant.pool(), type_id).await?.is_some();
3806 ctx.insert("review_required", &review_required);
3807 ctx.insert("extra_tabs", &Vec::<crate::page_type::TabSpec>::new());
3811 ctx.insert("extension_fields", &Vec::<crate::widget::Widget>::new());
3816 ctx.insert(
3817 "picker_options",
3818 &crate::block::admin::picker_options(&state.tera),
3819 );
3820 ctx.insert("page_tags", &Vec::<String>::new());
3821 ctx.insert("page_tags_csv", "");
3822 ctx.insert("all_tags", &Vec::<serde_json::Value>::new());
3823 insert_category_choices(&mut ctx, tenant.pool(), None).await;
3824 render_with_csrf(&state, &headers, "rcms_admin/page_form.html", &mut ctx)
3825}
3826
3827pub(crate) fn slugify(raw: &str) -> String {
3836 let mut out = String::with_capacity(raw.len());
3837 let mut last_hyphen = true;
3838 for ch in raw.chars() {
3839 let c = ch.to_ascii_lowercase();
3840 if c.is_ascii_alphanumeric() {
3841 out.push(c);
3842 last_hyphen = false;
3843 } else if !last_hyphen {
3844 out.push('-');
3845 last_hyphen = true;
3846 }
3847 }
3848 while out.ends_with('-') {
3849 out.pop();
3850 }
3851 if out.len() > 60 {
3852 out.truncate(60);
3853 while out.ends_with('-') {
3854 out.pop();
3855 }
3856 }
3857 out
3858}
3859
3860pub(crate) async fn dedup_slug_under_parent(
3869 pool: &rustango::sql::Pool,
3870 parent_id: Option<i64>,
3871 candidate: &str,
3872) -> Result<String, AdminError> {
3873 let taken: std::collections::HashSet<String> = {
3874 let q = Page::objects();
3875 let rows = match parent_id {
3876 Some(pid) => q.where_(Page::parent_id.eq(pid)).fetch(pool).await?,
3877 None => q.where_(Page::parent_id.is_null()).fetch(pool).await?,
3878 };
3879 rows.into_iter().map(|p| p.slug).collect()
3880 };
3881
3882 if !taken.contains(candidate) {
3883 return Ok(candidate.to_owned());
3884 }
3885 let with_copy = format!("{candidate}-copy");
3886 if !taken.contains(&with_copy) {
3887 return Ok(with_copy);
3888 }
3889 for n in 2..50_u32 {
3890 let trial = format!("{candidate}-copy-{n}");
3891 if !taken.contains(&trial) {
3892 return Ok(trial);
3893 }
3894 }
3895 Err(AdminError::Validation(format!(
3896 "could not find a free slug for “{candidate}” after 50 -copy attempts"
3897 )))
3898}
3899
3900async fn front_page_taken(pool: &rustango::sql::Pool) -> Result<bool, AdminError> {
3902 use rustango::sql::CounterPool as _;
3903 let n = Page::objects()
3904 .where_(Page::parent_id.is_null())
3905 .where_(Page::slug.eq(String::new()))
3906 .count(pool)
3907 .await?;
3908 Ok(n > 0)
3909}
3910
3911async fn insert_category_choices(ctx: &mut tera::Context, pool: &rustango::sql::Pool, page_id: Option<i64>) {
3914 let (groups, checked) = match crate::category::assign::editor_groups(pool, page_id).await {
3915 Ok(v) => v,
3916 Err(e) => {
3917 tracing::warn!(error = %e, "category choices not loaded; the field is hidden");
3918 Default::default()
3919 }
3920 };
3921 ctx.insert("category_groups", &groups);
3922 ctx.insert("page_category_ids", &checked);
3923}
3924
3925pub async fn page_new_submit(
3930 State(_state): State<super::AdminState>,
3931 tenant: Tenant,
3932 headers: HeaderMap,
3933 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3934 Form(form): Form<PageForm>,
3935) -> Result<Response, AdminError> {
3936 if form.parent_id.is_none() {
3942 let types = PageType::objects().fetch(tenant.pool()).await?;
3943 if let Some(row) = types
3944 .iter()
3945 .find(|t| t.id.get().copied() == Some(form.page_type_id))
3946 {
3947 let parents = row.allowed_parents();
3948 if !parents.is_empty() {
3949 return Err(AdminError::Validation(format!(
3950 "`{}` can't be a root page — it may only be created under: {}",
3951 row.type_name,
3952 parents.join(", ")
3953 )));
3954 }
3955 }
3956 }
3957
3958 let mut effective_slug = if !form.slug.trim().is_empty() {
3962 slugify(&form.slug)
3963 } else if form.parent_id.is_none() && !front_page_taken(tenant.pool()).await? {
3964 String::new()
3965 } else {
3966 slugify(&form.title)
3967 };
3968 if !effective_slug.is_empty() {
3969 effective_slug =
3970 dedup_slug_under_parent(tenant.pool(), form.parent_id, &effective_slug).await?;
3971 }
3972
3973 let intended = derive_scheduled_status(form.parsed_status().as_str(), form.parsed_go_live_at());
3978 let mut held_back: Option<String> = None;
3979 if let Some(user) = session_user.as_ref().filter(|u| !u.is_superuser) {
3980 if crate::page::PageStatus::str_goes_live(crate::page::PageStatus::Draft.as_str(), &intended) {
3981 let uid = user.id.get().copied().unwrap_or_default();
3982 let req = super::route_perms::Requirement {
3983 codename: "cms_page.publish".to_owned(),
3984 page: form.parent_id.map(|pid| (pid, crate::permissions::Action::Publish)),
3985 };
3986 if let Some(wf) = crate::workflow::review_workflow_for_type(tenant.pool(), form.page_type_id).await? {
3987 held_back = Some(super::i18n::tr(
3988 &headers,
3989 "Saved as a draft: pages of this type go live after review (“{workflow}”). Click Submit for review.",
3990 &[("workflow", wf.name.as_str())],
3991 ));
3992 } else if !super::route_perms::allows_id(tenant.pool(), uid, false, &req).await {
3993 held_back = Some(super::i18n::tr(
3994 &headers,
3995 "Saved as a draft: you don't have permission to publish pages here.",
3996 &[],
3997 ));
3998 }
3999 }
4000 }
4001
4002 let new = NewPage::new(
4003 form.page_type_id,
4004 form.title.clone(),
4005 effective_slug.clone(),
4006 )
4007 .with_status(if held_back.is_some() { crate::page::PageStatus::Draft } else { form.parsed_status() })
4008 .with_seo(form.seo_title.clone(), form.seo_description.clone());
4009
4010 let mut page = match form.parent_id {
4011 Some(pid) => {
4012 let parent = Page::objects()
4013 .where_(Page::id.eq(pid))
4014 .first(tenant.pool())
4015 .await?
4016 .ok_or(AdminError::NotFound(pid))?;
4017 Page::create_child(&tenant, &parent, new).await?
4018 }
4019 None => Page::create_root(&tenant, new).await?,
4020 };
4021
4022 page.robots_index = form.parsed_robots_index();
4025 page.sitemap_priority = form.parsed_sitemap_priority();
4026 page.theme_id = form.theme_id;
4027 page.go_live_at = if held_back.is_some() { None } else { form.parsed_go_live_at() };
4030 page.expire_at = form.parsed_expire_at();
4031 page.status = derive_scheduled_status(&page.status, page.go_live_at);
4032 page.show_in_menus = form.parsed_show_in_menus();
4033 page.preview_path = form.preview_path.trim().to_owned();
4034 page.template_override = form.template_override.trim().to_owned();
4035 page.og_title = form.og_title.clone();
4037 page.og_description = form.og_description.clone();
4038 page.og_image_media_id = form.og_image_media_id;
4039 if let Some(tc) = form.twitter_card.as_deref() {
4040 if matches!(tc, "summary" | "summary_large_image") {
4041 page.twitter_card = tc.to_owned();
4042 }
4043 }
4044 page.save_pool(tenant.pool()).await?;
4045 let new_id = page.id.get().copied().unwrap_or_default();
4046 if let Some(raw) = form.tags.as_deref().filter(|t| !t.trim().is_empty()) {
4049 let names: Vec<String> = raw.split(',').map(str::to_owned).collect();
4050 crate::page_tag::replace_tags(tenant.pool(), new_id, &names).await?;
4051 }
4052 crate::category::assign::save_from_form(tenant.pool(), new_id, form.categories.as_deref()).await?;
4053
4054 crate::revision::capture(tenant.pool(), &page, None)
4057 .await
4058 .log_warn("revision not captured; the history has a gap");
4059
4060 let message = held_back.unwrap_or_else(|| {
4063 super::i18n::tr(&headers, "Created page “{title}”.", &[("title", page.title.as_str())])
4064 });
4065 redirect_after_page_save(
4066 &form.action,
4067 page.id.get().copied().unwrap_or_default(),
4068 page.parent_id,
4069 &message,
4070 &headers,
4071 )
4072}
4073
4074#[derive(Debug, Deserialize, Default)]
4079pub struct EditQuery {
4080 #[serde(default)]
4081 pub locale: Option<String>,
4082}
4083
4084pub async fn page_edit_form(
4085 State(state): State<super::AdminState>,
4086 tenant: Tenant,
4087 headers: HeaderMap,
4088 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
4089 Path(id): Path<i64>,
4090 Query(q): Query<EditQuery>,
4091) -> Result<Response, AdminError> {
4092 let page = Page::objects()
4093 .where_(Page::id.eq(id))
4094 .first(tenant.pool())
4095 .await?
4096 .ok_or(AdminError::NotFound(id))?;
4097
4098 if let Some(source_id) = page.alias_of {
4103 return redirect_named_with_params_and_message_args(
4104 "rcms-admin:pages:edit",
4105 &[("id", source_id.to_string())],
4106 MsgLevel::Info,
4107 "Editing the source — alias “{title}” shares content with this row.",
4108 &[("title", page.title.as_str())],
4109 &headers,
4110 );
4111 }
4112
4113 let locales: Vec<Locale> = Locale::objects()
4115 .where_(Locale::active.eq(true))
4116 .order_by(&[("is_default", false), ("code", false)])
4117 .fetch(tenant.pool())
4118 .await?;
4119 let editing_locale: Option<Locale> = match q.locale.as_deref() {
4120 Some(code) if !code.is_empty() => locales.iter().find(|l| l.code == code).cloned(),
4121 _ => None,
4122 };
4123 let translation_mode = editing_locale
4124 .as_ref()
4125 .map(|l| !l.is_default)
4126 .unwrap_or(false);
4127 let pending = crate::pending_change::for_page(tenant.pool(), id).await?;
4128 let existing_translations = if translation_mode {
4129 let lid = editing_locale
4130 .as_ref()
4131 .and_then(|l| l.id.get().copied())
4132 .unwrap_or(0);
4133 crate::translation::fetch_for(tenant.pool(), id, lid)
4134 .await
4135 .unwrap_or_default()
4136 } else {
4137 std::collections::HashMap::new()
4138 };
4139
4140 let themes_for_picker: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
4142 .order_by(&[("name", false)])
4143 .fetch(tenant.pool())
4144 .await?;
4145
4146 let chosen_type: PageType = PageType::objects()
4152 .where_(PageType::id.eq(page.page_type_id))
4153 .first(tenant.pool())
4154 .await?
4155 .ok_or_else(|| {
4156 AdminError::Validation(format!(
4157 "page_type_id {} on cms_page row has no cms_page_type row",
4158 page.page_type_id
4159 ))
4160 })?;
4161
4162 let ancestors = page.ancestors(tenant.pool()).await.unwrap_or_default();
4164 let mut segments: Vec<&str> = ancestors
4165 .iter()
4166 .filter(|a| !a.slug.is_empty())
4167 .map(|a| a.slug.as_str())
4168 .collect();
4169 if !page.slug.is_empty() {
4170 segments.push(page.slug.as_str());
4171 }
4172 let live_url = if segments.is_empty() {
4173 "/".to_owned()
4174 } else {
4175 format!("/{}", segments.join("/"))
4176 };
4177
4178 let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
4187 .where_(crate::revision::Revision::page_id.eq(id))
4188 .order_by(&[("sequence", true)]) .limit(20)
4190 .fetch(tenant.pool())
4191 .await?;
4192
4193 let core_fields = ["title", "seo_title", "seo_description"];
4198 let core_translations: std::collections::HashMap<String, String> = core_fields
4199 .iter()
4200 .map(|f| {
4201 (
4202 (*f).to_owned(),
4203 existing_translations.get(*f).cloned().unwrap_or_default(),
4204 )
4205 })
4206 .collect();
4207 let mut extra_translations: Vec<(String, String)> = existing_translations
4208 .iter()
4209 .filter(|(k, _)| !core_fields.contains(&k.as_str()))
4210 .map(|(k, v)| (k.clone(), v.clone()))
4211 .collect();
4212 extra_translations.sort_by(|a, b| a.0.cmp(&b.0));
4213
4214 let mut ctx = Context::new();
4215 add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
4216 add_admin_theme(&mut ctx, tenant.pool()).await;
4217 ctx.insert("mode", "edit");
4218 ctx.insert("parent", &Option::<Page>::None);
4219 ctx.insert("chosen_type", &chosen_type);
4220 ctx.insert("page", &page);
4221 ctx.insert("live_url", &live_url);
4222 let site_preview_base = match crate::preview_url::configured_base(tenant.pool()).await {
4235 Ok(base) => base,
4236 Err(e) => {
4237 tracing::warn!(
4238 target: "rustango_cms::admin",
4239 error = %e,
4240 "headless preview setting lookup failed",
4241 );
4242 None
4243 }
4244 };
4245 let headless_preview_url = if site_preview_base.is_some() || !page.preview_path.trim().is_empty()
4248 {
4249 crate::preview_token::mint(&tenant.org.slug, id, chrono::Utc::now().timestamp() + PREVIEW_TOKEN_TTL_SECS)
4250 .and_then(|token| {
4251 crate::preview_url::for_page(
4252 site_preview_base.as_deref(),
4253 &page.preview_path,
4254 &token,
4255 id,
4256 &page.url_path,
4257 )
4258 })
4259 } else {
4260 None
4261 };
4262 ctx.insert("headless_preview_url", &headless_preview_url);
4263 let ancestor_crumbs: Vec<serde_json::Value> = ancestors
4266 .iter()
4267 .map(|a| serde_json::json!({ "id": a.id.get().copied(), "title": a.title }))
4268 .collect();
4269 ctx.insert("ancestors", &ancestor_crumbs);
4270 ctx.insert(
4271 "parent_crumb",
4272 &ancestors
4273 .last()
4274 .map(|a| serde_json::json!({ "id": a.id.get().copied(), "title": a.title })),
4275 );
4276 ctx.insert(
4279 "plugin_page_action_menu_items",
4280 &crate::hooks::page_action_menu_items(id),
4281 );
4282 ctx.insert(
4284 "plugin_page_header_buttons",
4285 &crate::hooks::page_header_buttons(id),
4286 );
4287 let is_subscribed = match session_user.as_ref().and_then(|u| u.id.get().copied()) {
4291 Some(uid) => crate::page_subscription::is_subscribed(tenant.pool(), id, uid)
4292 .await
4293 .unwrap_or(false),
4294 None => false,
4295 };
4296 ctx.insert("is_subscribed", &is_subscribed);
4297 let page_tags: Vec<String> = crate::page_tag::tags_for_page(tenant.pool(), id)
4299 .await
4300 .unwrap_or_default()
4301 .into_iter()
4302 .map(|t| t.name)
4303 .collect();
4304 let page_tags_csv = page_tags.join(", ");
4305 ctx.insert("page_tags", &page_tags);
4306 ctx.insert("page_tags_csv", &page_tags_csv);
4307 let all_tags = crate::page_tag::all_tags(tenant.pool())
4308 .await
4309 .unwrap_or_default()
4310 .into_iter()
4311 .map(|(name, count)| serde_json::json!({ "name": name, "count": count }))
4312 .collect::<Vec<_>>();
4313 ctx.insert("all_tags", &all_tags);
4314 insert_category_choices(&mut ctx, tenant.pool(), Some(id)).await;
4315 let usage =
4319 crate::reference_index::usage_summary(tenant.pool(), crate::reference_index::KIND_PAGE, id)
4320 .await;
4321 ctx.insert("usage", &usage);
4322
4323 let a11y_violations = crate::a11y::check_page(&page, None);
4329 let (a11y_errors, a11y_warnings, a11y_infos) = crate::a11y::count_by_severity(&a11y_violations);
4330 ctx.insert("a11y_violations", &a11y_violations);
4331 ctx.insert("a11y_errors", &a11y_errors);
4332 ctx.insert("a11y_warnings", &a11y_warnings);
4333 ctx.insert("a11y_infos", &a11y_infos);
4334 let mut content_findings = crate::content_checks::run_all(&page);
4337 if content_findings.iter().any(|f| f.code == "missing_og_image")
4340 && crate::meta_tags::fallback_share_image(tenant.pool(), &page).await.is_some()
4341 {
4342 content_findings.retain(|f| f.code != "missing_og_image");
4343 }
4344 let (content_errors, content_warnings, content_infos) =
4345 crate::content_checks::count_by_severity(&content_findings);
4346 ctx.insert("content_findings", &content_findings);
4347 ctx.insert("content_errors", &content_errors);
4348 ctx.insert("content_warnings", &content_warnings);
4349 ctx.insert("content_infos", &content_infos);
4350 ctx.insert("revisions", &revisions);
4351
4352 let log_entries = crate::page_log::for_page(tenant.pool(), id, Some(100))
4356 .await
4357 .unwrap_or_default();
4358 let log_user_ids: std::collections::BTreeSet<i64> =
4359 log_entries.iter().filter_map(|e| e.actor_id).collect();
4360 let log_users: std::collections::HashMap<i64, String> = if log_user_ids.is_empty() {
4361 std::collections::HashMap::new()
4362 } else {
4363 rustango::tenancy::auth::User::objects()
4364 .where_(
4365 rustango::tenancy::auth::User::id
4366 .is_in(log_user_ids.into_iter().collect::<Vec<_>>()),
4367 )
4368 .fetch(tenant.pool())
4369 .await
4370 .unwrap_or_default()
4371 .into_iter()
4372 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
4373 .collect()
4374 };
4375 let log_view: Vec<serde_json::Value> = log_entries
4376 .iter()
4377 .map(|e| {
4378 serde_json::json!({
4379 "id": e.id.get().copied(),
4380 "action": e.action,
4381 "actor_id": e.actor_id,
4382 "actor_username": e.actor_id.and_then(|uid| log_users.get(&uid).cloned()),
4383 "message": e.message,
4384 "created_at": e.created_at.get().copied(),
4385 })
4386 })
4387 .collect();
4388 ctx.insert("page_log", &log_view);
4389
4390 ctx.insert("locales", &locales);
4391 ctx.insert("editing_locale", &editing_locale);
4392 ctx.insert("translation_mode", &translation_mode);
4393 ctx.insert("core_translations", &core_translations);
4394 ctx.insert("extra_translations", &extra_translations);
4395 ctx.insert("themes_for_picker", &themes_for_picker);
4396
4397 let resolved_handler: Option<Box<dyn crate::page_type::PageTypeHandler>> =
4407 find_handler(&chosen_type.type_name);
4408
4409 let preview_mode = {
4417 let kind = crate::page_view::kind_for(&chosen_type);
4418 let template_renders = !chosen_type.default_template.trim().is_empty()
4419 && state
4420 .tera
4421 .get_template_names()
4422 .any(|n| n == chosen_type.default_template);
4423 if kind.serves_json() && !kind.serves_html() {
4424 "json"
4425 } else if template_renders {
4426 "html"
4427 } else {
4428 "none"
4429 }
4430 };
4431 ctx.insert("preview_mode", preview_mode);
4432
4433 let raw_widgets: Vec<crate::widget::Widget> = match &resolved_handler {
4439 Some(h) => h.widgets(tenant.pool(), id).await.unwrap_or_default(),
4440 None => Vec::new(),
4441 };
4442
4443 let content_metrics =
4448 crate::metrics::analyze(&crate::metrics::collect_widget_text(&raw_widgets));
4449 ctx.insert("content_metrics", &content_metrics);
4450
4451 if translation_mode {
4458 let mut stream_translations: Vec<serde_json::Value> = Vec::new();
4459 let mut leaf_paths: std::collections::HashSet<String> = std::collections::HashSet::new();
4460 for w in &raw_widgets {
4461 if !matches!(w.kind, crate::widget::WidgetKind::Stream) {
4462 continue;
4463 }
4464 let base: serde_json::Value = serde_json::from_str(&w.value)
4465 .unwrap_or_else(|_| serde_json::Value::Array(Vec::new()));
4466 let leaves = crate::block::translate::collect_translatable_leaves(&w.name, &base);
4467 if leaves.is_empty() {
4468 continue;
4469 }
4470 let mut groups: Vec<serde_json::Value> = Vec::new();
4471 let mut cur_id = String::new();
4472 for leaf in &leaves {
4473 leaf_paths.insert(leaf.path.clone());
4474 let row = serde_json::json!({
4475 "path": leaf.path,
4476 "widget_kind": leaf.widget_kind.as_tag(),
4477 "field_label": leaf.field_label,
4478 "canonical": leaf.canonical_text,
4479 "canonical_html": translation_canonical_html(leaf.widget_kind.as_tag(), &leaf.canonical_text),
4480 "value": existing_translations.get(&leaf.path).cloned().unwrap_or_default(),
4481 });
4482 if leaf.block_id != cur_id {
4483 cur_id.clone_from(&leaf.block_id);
4484 groups.push(serde_json::json!({
4485 "block_type": leaf.block_type,
4486 "block_label": leaf.block_label,
4487 "block_id": leaf.block_id,
4488 "depth": leaf.depth,
4489 "leaves": [row],
4490 }));
4491 } else if let Some(arr) = groups
4492 .last_mut()
4493 .and_then(|g| g.get_mut("leaves"))
4494 .and_then(|v| v.as_array_mut())
4495 {
4496 arr.push(row);
4497 }
4498 }
4499 stream_translations.push(serde_json::json!({ "field": w.name, "label": w.label, "groups": groups }));
4500 }
4501 let field_rows: Vec<serde_json::Value> = raw_widgets
4507 .iter()
4508 .filter(|w| {
4509 use crate::widget::WidgetKind as K;
4510 matches!(w.kind, K::Text | K::Textarea | K::Markdown | K::RichText)
4511 && !w.name.starts_with(crate::page_builder::compile::FIELD_PREFIX)
4512 })
4513 .map(|w| {
4514 leaf_paths.insert(w.name.clone());
4515 serde_json::json!({
4516 "path": w.name,
4517 "widget_kind": w.kind.as_tag(),
4518 "field_label": w.label,
4519 "canonical": w.value,
4520 "canonical_html": translation_canonical_html(w.kind.as_tag(), &w.value),
4521 "value": existing_translations.get(&w.name).cloned().unwrap_or_default(),
4522 })
4523 })
4524 .collect();
4525 if !field_rows.is_empty() {
4526 stream_translations.insert(
4527 0,
4528 serde_json::json!({
4529 "field": "fields",
4530 "label": super::i18n::tr(&headers, "Fields", &[]),
4531 "groups": [{
4532 "block_type": "fields",
4533 "block_label": "",
4534 "block_id": "fields",
4535 "depth": 0,
4536 "leaves": field_rows,
4537 }],
4538 }),
4539 );
4540 }
4541 let (builder_groups, builder_paths) =
4545 builder_translation_groups(&tenant, id, page.page_type_id, &existing_translations)
4546 .await;
4547 if !builder_groups.is_empty() {
4548 leaf_paths.extend(builder_paths);
4549 stream_translations
4550 .push(serde_json::json!({
4551 "field": "builder",
4552 "label": super::i18n::tr(&headers, "Fields", &[]),
4553 "groups": builder_groups,
4554 }));
4555 }
4556 extra_translations.retain(|(k, _)| !leaf_paths.contains(k));
4560 ctx.insert("stream_translations", &stream_translations);
4561 ctx.insert("extra_translations", &extra_translations);
4562 }
4563
4564 let display_fields: Vec<crate::page_type::DisplayField> = match &resolved_handler {
4569 Some(h) => h
4570 .display_fields(tenant.pool(), id)
4571 .await
4572 .unwrap_or_default(),
4573 None => Vec::new(),
4574 };
4575 ctx.insert("display_fields", &display_fields);
4576
4577 let mut raw_extra_tabs: Vec<crate::page_type::TabSpec> = match &resolved_handler {
4581 Some(h) => h.extra_tabs(tenant.pool(), id).await.unwrap_or_default(),
4582 None => Vec::new(),
4583 };
4584
4585 let all_roles: Vec<rustango::tenancy::permissions::Role> =
4589 rustango::tenancy::permissions::Role::objects()
4590 .order_by(&[("name", false)])
4591 .fetch(tenant.pool())
4592 .await
4593 .unwrap_or_default();
4594
4595 {
4599 let grants: Vec<crate::permissions::PagePermission> =
4600 crate::permissions::PagePermission::objects()
4601 .where_(crate::permissions::PagePermission::page_id.eq(id))
4602 .fetch(tenant.pool())
4603 .await
4604 .unwrap_or_default();
4605 let granted: std::collections::HashSet<(i64, String)> = grants
4607 .iter()
4608 .map(|g| (g.role_id, g.permission.clone()))
4609 .collect();
4610 let actions: Vec<&str> = crate::permissions::Action::all()
4611 .iter()
4612 .map(|a| a.as_str())
4613 .collect();
4614 let perm_grid: Vec<serde_json::Value> = all_roles
4615 .iter()
4616 .map(|r| {
4617 let rid = r.id.get().copied().unwrap_or_default();
4618 let row_cells: Vec<serde_json::Value> = actions
4619 .iter()
4620 .map(|a| {
4621 serde_json::json!({
4622 "action": a,
4623 "granted": granted.contains(&(rid, (*a).to_owned())),
4624 })
4625 })
4626 .collect();
4627 serde_json::json!({
4628 "role_id": rid,
4629 "role_name": r.name,
4630 "role_description": r.description,
4631 "cells": row_cells,
4632 })
4633 })
4634 .collect();
4635 let perm_tab = crate::page_type::TabSpec::template(
4636 "permissions",
4637 "Permissions",
4638 "rcms_admin/_permissions_tab.html",
4639 )
4640 .with_icon("admin_panel_settings")
4641 .with_context_value(
4642 "perm_actions",
4643 serde_json::to_value(&actions).unwrap_or_default(),
4644 )
4645 .with_context_value(
4646 "perm_grid",
4647 serde_json::to_value(&perm_grid).unwrap_or_default(),
4648 )
4649 .with_context_value("perm_page_id", serde_json::Value::Number(id.into()));
4650 raw_extra_tabs.insert(0, perm_tab);
4651 }
4652 let extra_tabs: Vec<serde_json::Value> =
4660 render_extra_tabs(raw_extra_tabs, &state.tera, &ctx, &headers);
4661 ctx.insert("extra_tabs", &extra_tabs);
4662
4663 let mut extension_fields: Vec<crate::widget::Widget> = raw_widgets;
4664 let pending_form = pending.as_ref().filter(|_| !translation_mode).map(crate::pending_change::PendingChange::form_map);
4666 if let Some(form) = pending_form.as_ref() {
4667 overlay_pending_widgets(&mut extension_fields, form);
4668 }
4669 for w in &mut extension_fields {
4675 if matches!(w.kind, crate::widget::WidgetKind::Custom) {
4676 if let Some(reg) = crate::widget::registry::find_custom_widget(&w.custom_name) {
4677 let mut sub = Context::new();
4678 sub.insert("w", &w);
4679 w.custom_html = state.tera.render(reg.template, &sub).unwrap_or_else(|e| {
4680 tracing::warn!(
4681 target: "rustango_cms::widget",
4682 custom_name = %w.custom_name,
4683 template = reg.template,
4684 error = %e,
4685 "custom widget template render failed",
4686 );
4687 String::new()
4688 });
4689 }
4690 }
4691 }
4692
4693 for w in &mut extension_fields {
4700 if matches!(w.kind, crate::widget::WidgetKind::Stream) {
4701 w.custom_html =
4702 crate::block::admin::render_stream_editor(w, &state.tera);
4703 }
4704 }
4705 ctx.insert("extension_fields", &extension_fields);
4706
4707 if let Some((body_html, rules_json, upgraded)) = page_builder_editor_ctx(
4712 &tenant,
4713 &state.tera,
4714 id,
4715 page.page_type_id,
4716 pending_form.as_ref(),
4717 )
4718 .await
4719 {
4720 ctx.insert("builder_body_html", &body_html);
4721 ctx.insert("builder_rules_json", &rules_json);
4722 ctx.insert("builder_upgraded", &upgraded);
4723 }
4724
4725 let mut inline_panels: Vec<serde_json::Value> = Vec::new();
4729 if let Some(h) = resolved_handler.as_deref() {
4730 for spec in h.inline_panels() {
4731 let rows = h
4732 .load_inline_panel(tenant.pool(), id, &spec.name)
4733 .await
4734 .unwrap_or_default();
4735 inline_panels.push(serde_json::json!({
4736 "spec": spec,
4737 "rows": rows,
4738 }));
4739 }
4740 }
4741 ctx.insert("inline_panels", &inline_panels);
4742
4743 ctx.insert(
4747 "picker_options",
4748 &crate::block::admin::picker_options(&state.tera),
4749 );
4750
4751 let mut lock_banner: Option<serde_json::Value> = None;
4758 let mut lock_owned_by_me = false;
4759 let reviewing_elsewhere = match session_user.as_ref() {
4760 Some(u) => read_only_under_review(tenant.pool(), id, u).await?,
4761 None => false,
4762 };
4763 if let Some(viewer_id) = session_user
4764 .as_ref()
4765 .and_then(|u| u.id.get().copied())
4766 .filter(|_| !reviewing_elsewhere)
4767 {
4768 match crate::lock::acquire(tenant.pool(), id, viewer_id, false).await {
4769 Ok(crate::lock::AcquireOutcome::Acquired(_)) => {
4770 lock_owned_by_me = true;
4771 }
4772 Ok(crate::lock::AcquireOutcome::Held(other)) => {
4773 let holder_name = rustango::tenancy::auth::User::objects()
4774 .where_(rustango::tenancy::auth::User::id.eq(other.user_id))
4775 .fetch(tenant.pool())
4776 .await
4777 .ok()
4778 .and_then(|v| v.into_iter().next())
4779 .map(|u| u.username)
4780 .unwrap_or_else(|| format!("user#{}", other.user_id));
4781 lock_banner = Some(serde_json::json!({
4782 "holder_username": holder_name,
4783 "holder_id": other.user_id,
4784 "acquired_at": other.acquired_at.get().copied(),
4785 "expires_at": other.expires_at,
4786 }));
4787 }
4788 Err(e) => {
4789 tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "lock acquire failed");
4790 }
4791 }
4792 }
4793 ctx.insert("lock_banner", &lock_banner);
4794 ctx.insert("lock_owned_by_me", &lock_owned_by_me);
4795 ctx.insert("lock_heartbeat_secs", &crate::lock::HEARTBEAT_INTERVAL_SECS);
4796
4797 let workflow_slug: Option<String> = chosen_type.workflow_name();
4806 let mut workflow_ctx: Option<serde_json::Value> = None;
4807 let mut workflow_state_ctx: Option<serde_json::Value> = None;
4808 let mut workflow_current_task_ctx: Option<serde_json::Value> = None;
4809 let mut workflow_history_ctx: Vec<serde_json::Value> = Vec::new();
4810 let mut workflow_viewer_can_decide = false;
4811 if let Some(slug) = workflow_slug.as_deref() {
4812 let workflow = crate::workflow::find_by_name(tenant.pool(), slug)
4813 .await
4814 .unwrap_or(None);
4815 if let Some(wf) = workflow {
4816 let wf_id = wf.id.get().copied().unwrap_or_default();
4817 let tasks = crate::workflow::tasks_for(tenant.pool(), wf_id)
4818 .await
4819 .unwrap_or_default();
4820 workflow_ctx = Some(serde_json::json!({
4821 "id": wf_id,
4822 "name": wf.name,
4823 "description": wf.description,
4824 "task_count": tasks.len(),
4825 }));
4826 if let Some(state_row) = crate::workflow::latest_state_for_page(tenant.pool(), id)
4830 .await
4831 .unwrap_or(None)
4832 {
4833 let state_id = state_row.id.get().copied().unwrap_or_default();
4834 if let Some(current) = state_row
4836 .current_task_id
4837 .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
4838 {
4839 workflow_current_task_ctx = Some(serde_json::json!({
4840 "id": current.id.get().copied(),
4841 "name": current.name,
4842 "role_id": current.role_id,
4843 }));
4844 if let Some(viewer) = session_user.as_ref() {
4845 let viewer_id = viewer.id.get().copied().unwrap_or_default();
4846 workflow_viewer_can_decide = viewer.is_superuser
4847 || user_is_in_role(tenant.pool(), viewer_id, current.role_id)
4848 .await
4849 .unwrap_or(false);
4850 }
4851 }
4852 workflow_state_ctx = Some(serde_json::json!({
4853 "id": state_id,
4854 "status": state_row.status,
4855 "requested_by": state_row.requested_by,
4856 "requested_at": state_row.requested_at.get().copied(),
4857 "finished_at": state_row.finished_at,
4858 }));
4859 if let Ok(history) = crate::workflow::history_for_page(tenant.pool(), id).await {
4861 let reviewer_ids: Vec<i64> =
4863 history.iter().filter_map(|h| h.decided_by).collect();
4864 let reviewers: std::collections::HashMap<i64, String> =
4865 if reviewer_ids.is_empty() {
4866 std::collections::HashMap::new()
4867 } else {
4868 rustango::tenancy::auth::User::objects()
4869 .where_(rustango::tenancy::auth::User::id.is_in(reviewer_ids))
4870 .fetch(tenant.pool())
4871 .await
4872 .unwrap_or_default()
4873 .into_iter()
4874 .filter_map(|u| u.id.get().copied().map(|uid| (uid, u.username)))
4875 .collect()
4876 };
4877 let task_name_by_id: std::collections::HashMap<i64, String> = tasks
4878 .iter()
4879 .filter_map(|t| t.id.get().copied().map(|tid| (tid, t.name.clone())))
4880 .collect();
4881 workflow_history_ctx = history
4882 .iter()
4883 .map(|h| {
4884 serde_json::json!({
4885 "task_name": task_name_by_id
4886 .get(&h.task_id)
4887 .cloned()
4888 .unwrap_or_else(|| format!("task #{}", h.task_id)),
4889 "status": h.status,
4890 "comment": h.comment,
4891 "decided_by_username": h
4892 .decided_by
4893 .and_then(|uid| reviewers.get(&uid).cloned()),
4894 "decided_at": h.decided_at,
4895 })
4896 })
4897 .collect();
4898 }
4899 }
4900 }
4901 }
4902 let workflow_locked = workflow_state_ctx
4908 .as_ref()
4909 .and_then(|s| s.get("status"))
4910 .and_then(|v| v.as_str())
4911 .map(|s| s == crate::workflow::WorkflowStatus::InProgress.as_str())
4912 .unwrap_or(false)
4913 && !workflow_viewer_can_decide;
4914 ctx.insert("workflow_slug", &workflow_slug);
4915 ctx.insert("workflow", &workflow_ctx);
4916 ctx.insert("workflow_state", &workflow_state_ctx);
4917 ctx.insert("workflow_current_task", &workflow_current_task_ctx);
4918 ctx.insert("workflow_history", &workflow_history_ctx);
4919 ctx.insert("workflow_viewer_can_decide", &workflow_viewer_can_decide);
4920 ctx.insert("workflow_locked", &workflow_locked);
4921 let review_required = !session_user.as_ref().is_some_and(|u| u.is_superuser)
4922 && crate::workflow::review_workflow_for_type(tenant.pool(), page.page_type_id).await?.is_some();
4923 ctx.insert("review_required", &review_required);
4924 if let (Some(held), Some(form)) = (pending.as_ref(), pending_form.as_ref()) {
4925 ctx.insert("page", &overlay_pending_page(&page, form));
4926 let by = match held.created_by {
4927 Some(uid) => rustango::tenancy::auth::User::objects()
4928 .where_(rustango::tenancy::auth::User::id.eq(uid))
4929 .first(tenant.pool())
4930 .await?
4931 .map(|u| u.username),
4932 None => None,
4933 };
4934 ctx.insert(
4935 "pending_change",
4936 &serde_json::json!({ "by": by, "updated_at": held.updated_at.get().copied() }),
4937 );
4938 }
4939
4940 let view_restriction = crate::view_restriction::direct_for_page(tenant.pool(), id)
4942 .await
4943 .unwrap_or(None);
4944 let restriction_kind = view_restriction
4945 .as_ref()
4946 .map(|r| r.kind.clone())
4947 .unwrap_or_else(|| "none".to_owned());
4948 let restriction_groups = view_restriction
4949 .as_ref()
4950 .map(|r| r.parsed_groups())
4951 .unwrap_or_default();
4952 let restriction_groups_str = restriction_groups
4953 .iter()
4954 .map(i64::to_string)
4955 .collect::<Vec<_>>()
4956 .join(",");
4957 let role_choices: Vec<serde_json::Value> = all_roles
4960 .iter()
4961 .map(|r| {
4962 serde_json::json!({
4963 "id": r.id.get().copied(),
4964 "name": r.name,
4965 "checked": r.id.get().copied().is_some_and(|rid| restriction_groups.contains(&rid)),
4966 })
4967 })
4968 .collect();
4969 let restriction_codenames = view_restriction
4971 .as_ref()
4972 .map(|r| r.parsed_codenames())
4973 .unwrap_or_default();
4974 let restriction_codenames_str = restriction_codenames.join(",");
4975 let codename_choices: Vec<serde_json::Value> = super::resources::membership_codenames()
4976 .into_iter()
4977 .map(|(codename, label)| {
4978 serde_json::json!({
4979 "codename": codename,
4980 "label": label,
4981 "checked": restriction_codenames.contains(&codename),
4982 })
4983 })
4984 .collect();
4985 ctx.insert("restriction_kind", &restriction_kind);
4986 ctx.insert("restriction_groups_str", &restriction_groups_str);
4987 ctx.insert("restriction_role_choices", &role_choices);
4988 ctx.insert("restriction_codenames_str", &restriction_codenames_str);
4989 ctx.insert("restriction_codename_choices", &codename_choices);
4990 ctx.insert(
4991 "restriction_has_password",
4992 &view_restriction
4993 .as_ref()
4994 .map(|r| !r.password_hash.is_empty())
4995 .unwrap_or(false),
4996 );
4997
4998 let threads = crate::comment::threads_for_page(tenant.pool(), id)
5004 .await
5005 .unwrap_or_default();
5006 let thread_ids: Vec<i64> = threads.iter().filter_map(|c| c.id.get().copied()).collect();
5007 let replies_by_thread = crate::comment::replies_for_threads(tenant.pool(), &thread_ids)
5008 .await
5009 .unwrap_or_default();
5010 let mut comment_user_ids: std::collections::BTreeSet<i64> =
5011 threads.iter().map(|c| c.author_id).collect();
5012 for replies in replies_by_thread.values() {
5013 for r in replies {
5014 comment_user_ids.insert(r.author_id);
5015 }
5016 }
5017 let comment_users: std::collections::HashMap<i64, String> = if comment_user_ids.is_empty() {
5018 std::collections::HashMap::new()
5019 } else {
5020 rustango::tenancy::auth::User::objects()
5021 .where_(rustango::tenancy::auth::User::id.is_in(comment_user_ids.iter().copied()))
5022 .fetch(tenant.pool())
5023 .await
5024 .unwrap_or_default()
5025 .into_iter()
5026 .filter_map(|u| u.id.get().copied().map(|uid| (uid, u.username)))
5027 .collect()
5028 };
5029 let comment_threads: Vec<serde_json::Value> = threads
5030 .iter()
5031 .map(|c| {
5032 let tid = c.id.get().copied().unwrap_or_default();
5033 let replies = replies_by_thread.get(&tid).cloned().unwrap_or_default();
5034 let rendered_replies: Vec<serde_json::Value> = replies
5035 .iter()
5036 .map(|r| {
5037 serde_json::json!({
5038 "id": r.id.get().copied(),
5039 "author_username": comment_users.get(&r.author_id).cloned(),
5040 "body": r.body,
5041 "created_at": r.created_at.get().copied(),
5042 })
5043 })
5044 .collect();
5045 serde_json::json!({
5046 "id": tid,
5047 "field_path": c.field_path,
5048 "author_username": comment_users.get(&c.author_id).cloned(),
5049 "body": c.body,
5050 "created_at": c.created_at.get().copied(),
5051 "resolved_at": c.resolved_at,
5052 "replies": rendered_replies,
5053 "reply_count": replies.len(),
5054 })
5055 })
5056 .collect();
5057 ctx.insert("comment_threads", &comment_threads);
5058 ctx.insert(
5059 "comment_open_count",
5060 &comment_threads
5061 .iter()
5062 .filter(|t| t.get("resolved_at").map(|v| v.is_null()).unwrap_or(true))
5063 .count(),
5064 );
5065 ctx.insert(
5066 "comment_resolved_count",
5067 &comment_threads
5068 .iter()
5069 .filter(|t| t.get("resolved_at").map(|v| !v.is_null()).unwrap_or(false))
5070 .count(),
5071 );
5072 ctx.insert(
5074 "comment_field_choices",
5075 &serde_json::json!([
5076 {"value": "title", "label": "Title"},
5077 {"value": "slug", "label": "Slug"},
5078 {"value": "seo_title", "label": "SEO title"},
5079 {"value": "seo_description", "label": "SEO description"},
5080 {"value": "body", "label": "Body / stream content"},
5081 {"value": "general", "label": "General — whole page"},
5082 ]),
5083 );
5084
5085 render_with_csrf(&state, &headers, "rcms_admin/page_form.html", &mut ctx)
5086}
5087
5088pub async fn page_autosave_submit(
5102 State(_state): State<super::AdminState>,
5103 tenant: Tenant,
5104 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
5105 Path(id): Path<i64>,
5106 Form(form_map): Form<std::collections::HashMap<String, String>>,
5107) -> Result<Response, AdminError> {
5108 use rustango::sql::FetcherPool as _;
5109 let mut page = Page::objects()
5110 .where_(Page::id.eq(id))
5111 .first(tenant.pool())
5112 .await?
5113 .ok_or(AdminError::NotFound(id))?;
5114 if let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) {
5119 if let Ok(Some(lock)) = crate::lock::current(tenant.pool(), id).await {
5120 if lock.user_id != viewer_id {
5121 return Ok((axum::http::StatusCode::CONFLICT, "locked").into_response());
5122 }
5123 }
5124 }
5125 if page.status != crate::page::PageStatus::Draft.as_str() {
5130 return Ok((axum::http::StatusCode::NO_CONTENT, "").into_response());
5131 }
5132 if let Some(u) = session_user.as_ref() {
5133 if read_only_under_review(tenant.pool(), id, u).await? {
5134 return Ok((axum::http::StatusCode::CONFLICT, "under review").into_response());
5135 }
5136 }
5137 if let Some(v) = form_map.get("title") {
5144 page.title = v.clone();
5145 }
5146 if let Some(v) = form_map.get("seo_title") {
5147 page.seo_title = v.clone();
5148 }
5149 if let Some(v) = form_map.get("seo_description") {
5150 page.seo_description = v.clone();
5151 }
5152 let posted_status = form_map.get("status").cloned();
5156 page.save_pool(tenant.pool()).await?;
5157 let pts: Vec<PageType> = PageType::objects()
5159 .where_(PageType::id.eq(page.page_type_id))
5160 .fetch(tenant.pool())
5161 .await?;
5162 if let Some(pt) = pts.into_iter().next() {
5163 if let Some(handler) = find_handler(&pt.type_name) {
5164 let ext_form =
5165 sanitized_extension_form(handler.as_ref(), tenant.pool(), id, &form_map).await;
5166 handler.save_extension(tenant.pool(), id, &ext_form).await?;
5167 }
5168 }
5169 save_page_builder_values(tenant.pool(), page.page_type_id, id, &form_map).await?;
5171 let by = session_user.as_ref().and_then(|u| u.id.get().copied());
5174 if let Ok(mut rev) = crate::revision::capture(tenant.pool(), &page, by).await {
5175 if let serde_json::Value::Object(ref mut map) = rev.snapshot {
5179 map.insert("__autosave".to_owned(), serde_json::Value::Bool(true));
5180 if let Some(status) = posted_status {
5181 map.insert(
5182 "__autosave_posted_status".to_owned(),
5183 serde_json::Value::String(status),
5184 );
5185 }
5186 rev.save_pool(tenant.pool()).await.log_warn("autosave revision not stored");
5187 }
5188 }
5189 Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
5190}
5191
5192const PENDING_TEXT_KEYS: &[&str] = &[
5203 "title",
5204 "slug",
5205 "seo_title",
5206 "seo_description",
5207 "og_title",
5208 "og_description",
5209 "preview_path",
5210];
5211
5212fn overlay_pending_page(
5215 page: &Page,
5216 form: &std::collections::HashMap<String, String>,
5217) -> serde_json::Value {
5218 let mut value = serde_json::to_value(page).unwrap_or_default();
5219 if let Some(obj) = value.as_object_mut() {
5220 for key in PENDING_TEXT_KEYS {
5221 if let Some(v) = form.get(*key) {
5222 obj.insert((*key).to_owned(), serde_json::Value::String(v.clone()));
5223 }
5224 }
5225 }
5226 value
5227}
5228
5229fn overlay_pending_widgets(
5232 widgets: &mut [crate::widget::Widget],
5233 form: &std::collections::HashMap<String, String>,
5234) {
5235 for w in widgets {
5236 match form.get(&w.name) {
5237 Some(v) => w.value.clone_from(v),
5238 None if matches!(w.kind, crate::widget::WidgetKind::Boolean) => w.value.clear(),
5239 None => {}
5240 }
5241 }
5242}
5243
5244const PAGE_FORM_CANONICAL_KEYS: &[&str] = &[
5245 "title",
5246 "slug",
5247 "status",
5248 "seo_title",
5249 "seo_description",
5250 "robots_index",
5251 "sitemap_priority",
5252 "parent_id",
5253 "theme_id",
5254 "go_live_at",
5256 "expire_at",
5257 "show_in_menus",
5259 "preview_path",
5261 "template_override",
5263 "og_title",
5265 "og_description",
5266 "og_image_media_id",
5267 "twitter_card",
5268 "tags",
5270];
5271
5272pub(crate) struct PageEditActor {
5276 pub id: i64,
5277 pub username: String,
5278 pub is_superuser: bool,
5279}
5280
5281pub(crate) enum PageEditRefusal {
5285 WorkflowReview { task_name: String },
5287 LockedBy { holder: String },
5289 ArchivedUnpublish,
5291 PublishDenied,
5294 ReviewRequired { workflow: String },
5297}
5298
5299pub(crate) struct PageEditOutcome {
5301 pub page: Page,
5302 pub redirects_created: usize,
5303 pub reapproval_kicked: bool,
5304 pub held_for_review: bool,
5306}
5307
5308#[allow(clippy::too_many_arguments)]
5321pub(crate) async fn apply_page_edit(
5322 pool: &rustango::sql::Pool,
5323 org_slug: &str,
5324 invalidator: &std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator>,
5325 mailer: Option<&dyn rustango::email::Mailer>,
5326 mailer_from: &str,
5327 notify: bool,
5328 id: i64,
5329 form_map: &std::collections::HashMap<String, String>,
5330 actor: Option<&PageEditActor>,
5331) -> Result<Result<PageEditOutcome, PageEditRefusal>, AdminError> {
5332 if let Some(actor) = actor {
5338 if let Some(active) = crate::workflow::active_state_for_page(pool, id).await? {
5339 if active.status == crate::workflow::WorkflowStatus::InProgress.as_str()
5340 && !actor.is_superuser
5341 {
5342 let tasks = crate::workflow::tasks_for(pool, active.workflow_id).await?;
5343 if let Some(current_task) = active
5344 .current_task_id
5345 .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
5346 {
5347 if !user_is_in_role(pool, actor.id, current_task.role_id).await? {
5348 return Ok(Err(PageEditRefusal::WorkflowReview {
5349 task_name: current_task.name.clone(),
5350 }));
5351 }
5352 }
5353 }
5354 }
5355 }
5356
5357 if let Some(actor) = actor {
5364 match crate::lock::current(pool, id).await {
5365 Ok(Some(lock)) if lock.user_id != actor.id => {
5366 let holder = rustango::tenancy::auth::User::objects()
5367 .where_(rustango::tenancy::auth::User::id.eq(lock.user_id))
5368 .fetch(pool)
5369 .await
5370 .ok()
5371 .and_then(|v| v.into_iter().next())
5372 .map(|u| u.username)
5373 .unwrap_or_else(|| format!("user#{}", lock.user_id));
5374 return Ok(Err(PageEditRefusal::LockedBy { holder }));
5375 }
5376 _ => {}
5377 }
5378 }
5379
5380 let canonical_keys = PAGE_FORM_CANONICAL_KEYS;
5392 let mut canonical_only: std::collections::HashMap<&str, String> = form_map
5393 .iter()
5394 .filter(|(k, _)| canonical_keys.contains(&k.as_str()))
5395 .map(|(k, v)| (k.as_str(), v.clone()))
5396 .collect();
5397
5398 let mut page = Page::objects()
5399 .where_(Page::id.eq(id))
5400 .first(pool)
5401 .await?
5402 .ok_or(AdminError::NotFound(id))?;
5403
5404 let frozen_type_id = page.page_type_id.to_string();
5408 canonical_only.insert("page_type_id", frozen_type_id);
5409 let canonical_view: std::collections::HashMap<&str, &str> = canonical_only
5410 .iter()
5411 .map(|(k, v)| (*k, v.as_str()))
5412 .collect();
5413 let form: PageForm = serde_urlencoded::from_str(
5414 &serde_urlencoded::to_string(&canonical_view).unwrap_or_default(),
5415 )
5416 .map_err(|e| AdminError::Validation(format!("canonical form: {e}")))?;
5417
5418 if let Some(actor) = actor.filter(|a| !a.is_superuser) {
5423 if page.status == crate::page::PageStatus::Published.as_str() {
5424 if let Some(wf) = crate::workflow::review_workflow_for_type(pool, page.page_type_id)
5425 .await?
5426 .filter(|wf| wf.require_reapproval_on_edit)
5427 {
5428 crate::pending_change::hold(pool, id, form_map, Some(actor.id)).await?;
5429 let mut started = false;
5430 if crate::workflow::active_state_for_page(pool, id).await?.is_none() {
5431 let tasks =
5432 crate::workflow::tasks_for(pool, wf.id.get().copied().unwrap_or_default())
5433 .await?;
5434 crate::workflow::submit_for_review(pool, id, &wf, &tasks, actor.id).await?;
5435 started = true;
5436 }
5437 return Ok(Ok(PageEditOutcome {
5438 page,
5439 redirects_created: 0,
5440 reapproval_kicked: started,
5441 held_for_review: true,
5442 }));
5443 }
5444 }
5445 }
5446
5447 page.title = form.title.clone();
5448 let new_slug = if form.slug.trim().is_empty() {
5453 String::new()
5454 } else {
5455 slugify(&form.slug)
5456 };
5457 let slug_changed = page.slug != new_slug;
5458 if slug_changed && !new_slug.is_empty() {
5459 let sibling = Page::objects()
5460 .where_(Page::slug.eq(new_slug.clone()))
5461 .where_(Page::id.ne(id));
5462 let sibling = match page.parent_id {
5463 Some(pid) => sibling.where_(Page::parent_id.eq(pid)),
5464 None => sibling.where_(Page::parent_id.is_null()),
5465 };
5466 if sibling.first(pool).await?.is_some() {
5467 return Err(AdminError::Validation(format!(
5468 "another page under the same parent already uses the slug “{new_slug}”"
5469 )));
5470 }
5471 }
5472 let old_url_path = page.url_path.clone();
5476 page.slug = new_slug;
5477 let was_published = page.status == crate::page::PageStatus::Published.as_str();
5480 let was_archived = page.status == crate::page::PageStatus::Archived.as_str();
5484 let old_status = page.status.clone();
5485 page.status = form.parsed_status().as_str().to_owned();
5487 page.seo_title = form.seo_title.clone();
5488 page.seo_description = form.seo_description.clone();
5489 page.robots_index = form.parsed_robots_index();
5490 page.sitemap_priority = form.parsed_sitemap_priority();
5491 page.theme_id = form.theme_id;
5492 let new_go_live = form.parsed_go_live_at();
5495 if page.go_live_at != new_go_live {
5496 page.notification_pre_published_sent = false;
5497 }
5498 page.go_live_at = new_go_live;
5499 page.expire_at = form.parsed_expire_at();
5500 page.status = derive_scheduled_status(&page.status, page.go_live_at);
5505 page.show_in_menus = form.parsed_show_in_menus();
5506 page.preview_path = form.preview_path.trim().to_owned();
5507 page.template_override = form.template_override.trim().to_owned();
5508 if page.status == crate::page::PageStatus::Published.as_str() {
5514 let now = chrono::Utc::now();
5515 if page.published_at.is_none() {
5516 page.published_at = Some(now);
5517 }
5518 page.last_published_at = Some(now);
5519 }
5520 if was_archived && page.status == crate::page::PageStatus::Draft.as_str() {
5524 return Ok(Err(PageEditRefusal::ArchivedUnpublish));
5525 }
5526 if let Some(actor) = actor {
5532 if crate::page::PageStatus::str_goes_live(&old_status, &page.status) {
5533 if !actor.is_superuser {
5538 if let Some(wf) = crate::workflow::review_workflow_for_type(pool, page.page_type_id).await? {
5539 return Ok(Err(PageEditRefusal::ReviewRequired { workflow: wf.name }));
5540 }
5541 }
5542 let req = super::route_perms::Requirement {
5543 codename: "cms_page.publish".to_owned(),
5544 page: Some((id, crate::permissions::Action::Publish)),
5545 };
5546 if !super::route_perms::allows_id(pool, actor.id, actor.is_superuser, &req).await {
5547 return Ok(Err(PageEditRefusal::PublishDenied));
5548 }
5549 }
5550 }
5551 page.og_title = form.og_title.clone();
5553 page.og_description = form.og_description.clone();
5554 page.og_image_media_id = form.og_image_media_id;
5555 if let Some(tc) = form.twitter_card.as_deref() {
5556 if matches!(tc, "summary" | "summary_large_image") {
5557 page.twitter_card = tc.to_owned();
5558 }
5559 }
5560
5561 if slug_changed {
5566 let parent_url_path = match page.parent_id {
5567 None => None,
5568 Some(pid) => Page::objects()
5569 .where_(Page::id.eq(pid))
5570 .first(pool)
5571 .await?
5572 .map(|p| p.url_path),
5573 };
5574 page.url_path = crate::tree_ops::compute_url_path(parent_url_path.as_deref(), &page.slug);
5575 }
5576 let new_url_path = page.url_path.clone();
5577
5578 let invalidator = invalidator.clone();
5585 let tenant_slug = org_slug.to_owned();
5586 let purge_new = new_url_path.clone();
5587 let purge_old = old_url_path.clone();
5588 let (page, descendant_urls) = crate::tree_ops::atomic_tree(pool, move |tx| {
5589 Box::pin(async move {
5590 page.save_tx(tx).await?;
5591 let descendants: Vec<Page> = if slug_changed {
5592 crate::tree_ops::cascade_url_path_to_descendants(tx, &page).await?;
5593 Page::objects()
5594 .where_(Page::path.like(crate::tree::descendants_like(&page.path)))
5595 .where_(Page::path.ne(page.path.clone()))
5596 .fetch_tx(tx)
5597 .await?
5598 } else {
5599 Vec::new()
5600 };
5601 if slug_changed {
5605 let public = |p: &Page| matches!(p.status.as_str(), "published" | "archived");
5606 let mut moves = Vec::with_capacity(1 + descendants.len());
5607 if public(&page) {
5608 moves.push((page.id.get().copied().unwrap_or_default(), purge_old.clone(), purge_new.clone()));
5609 }
5610 for d in descendants.iter().filter(|d| public(d)) {
5611 if let Some(old) = crate::redirect::rebase_path(&d.url_path, &purge_new, &purge_old) {
5612 moves.push((d.id.get().copied().unwrap_or_default(), old, d.url_path.clone()));
5613 }
5614 }
5615 crate::redirect::record_renames_tx(tx, &moves).await?;
5616 }
5617 let descendant_urls: Vec<String> = descendants.into_iter().map(|d| d.url_path).collect();
5618 let mut urls = Vec::with_capacity(2 + descendant_urls.len());
5619 urls.push(purge_new.clone());
5620 if slug_changed && purge_old != purge_new && !purge_old.is_empty() {
5621 urls.push(purge_old);
5622 }
5623 urls.extend(descendant_urls.iter().cloned());
5624 crate::cache_invalidate::invalidate_urls_on_commit(invalidator, tenant_slug, urls);
5625 Ok((page, descendant_urls))
5626 })
5627 })
5628 .await?;
5629 if let Some(tags_raw) = form_map.get("tags") {
5641 let names: Vec<String> = if tags_raw.is_empty() {
5642 Vec::new()
5643 } else {
5644 tags_raw.split(',').map(|s| s.to_owned()).collect()
5645 };
5646 crate::page_tag::replace_tags(pool, id, &names).await?;
5647 }
5648 crate::category::assign::save_from_form(
5650 pool,
5651 id,
5652 form_map.get(crate::category::assign::FORM_KEY).map(String::as_str),
5653 )
5654 .await?;
5655 let pts: Vec<PageType> = PageType::objects()
5656 .where_(PageType::id.eq(page.page_type_id))
5657 .fetch(pool)
5658 .await?;
5659 let pt_opt: Option<PageType> = pts.into_iter().next();
5660 if let Some(pt) = &pt_opt {
5661 if let Some(handler) = find_handler(&pt.type_name) {
5662 let ext_form = sanitized_extension_form(handler.as_ref(), pool, id, &form_map).await;
5663 handler.save_extension(pool, id, &ext_form).await?;
5664 for spec in handler.inline_panels() {
5669 let rows = extract_inline_panel_rows(&form_map, &spec);
5670 handler.save_inline_panel(pool, id, &spec.name, &rows).await?;
5671 }
5672 }
5673 }
5674 save_page_builder_values(pool, page.page_type_id, id, &form_map).await?;
5676
5677 crate::revision::capture(pool, &page, actor.map(|a| a.id))
5680 .await
5681 .log_warn("revision not captured; the history has a gap");
5682
5683 {
5689 let mut refs: Vec<crate::reference_index::Reference> = Vec::new();
5690 for (key, value) in form_map {
5691 let mut found = crate::reference_index::scan(value, key);
5695 refs.append(&mut found);
5696 }
5697 let page_id = page.id.get().copied().unwrap_or_default();
5698 crate::task_queue::reindex_page(pool, org_slug, page_id, refs).await;
5699 }
5700
5701 crate::task_queue::sync_page_search(org_slug, &page).await;
5705
5706 let actor_id = actor.map(|a| a.id);
5708 if page.status == crate::page::PageStatus::Published.as_str() {
5709 crate::hooks::fire_after_publish_page(&page);
5710 if notify {
5712 let actor_name = actor.map(|a| a.username.as_str());
5713 crate::page_subscription::notify_publish(
5714 mailer,
5715 mailer_from,
5716 pool,
5717 org_slug,
5718 page.id.get().copied().unwrap_or_default(),
5719 &page.title,
5720 &page.url_path,
5721 actor_name,
5722 )
5723 .await;
5724 }
5725 crate::page_log::record_or_warn(
5727 pool,
5728 id,
5729 crate::page_log::ACTION_PUBLISH,
5730 actor_id,
5731 format!("Published “{}”.", page.title),
5732 None,
5733 )
5734 .await;
5735 } else {
5736 crate::page_log::record_or_warn(
5738 pool,
5739 id,
5740 crate::page_log::ACTION_EDIT,
5741 actor_id,
5742 format!("Edited “{}”.", page.title),
5743 Some(serde_json::json!({ "status": page.status })),
5744 )
5745 .await;
5746 }
5747
5748
5749 let mut redirects_created = 0usize;
5754 if slug_changed && old_url_path != new_url_path && !old_url_path.is_empty() {
5755 let new_prefix = if new_url_path == "/" {
5762 String::new()
5763 } else {
5764 new_url_path.clone()
5765 };
5766 let old_prefix = if old_url_path == "/" {
5767 String::new()
5768 } else {
5769 old_url_path.clone()
5770 };
5771 let mut pairs: Vec<(String, String)> = vec![(old_url_path.clone(), new_url_path.clone())];
5772 for new_d in &descendant_urls {
5773 if let Some(suffix) = new_d.strip_prefix(new_prefix.as_str()) {
5774 let old_d = format!("{old_prefix}{suffix}");
5775 if old_d != *new_d {
5776 pairs.push((old_d, new_d.clone()));
5777 }
5778 }
5779 }
5780 let now = chrono::Utc::now().to_rfc3339();
5786 for (old_path, new_path) in pairs {
5787 let existing: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
5789 .where_(crate::redirect::Redirect::from_path.eq(old_path.clone()))
5790 .fetch(pool)
5791 .await
5792 .unwrap_or_default();
5793 if let Some(mut r) = existing.into_iter().next() {
5794 if r.to_path != new_path {
5797 r.to_path = new_path.clone();
5798 r.is_permanent = true;
5799 r.note = format!("auto-updated on page rename at {now}");
5800 if r.from_page_id.is_none() {
5803 r.from_page_id = Some(id);
5804 }
5805 r.save_pool(pool).await.log_warn("redirect not linked to its source page");
5806 }
5807 continue;
5808 }
5809 let stale_chain: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
5813 .where_(crate::redirect::Redirect::to_path.eq(old_path.clone()))
5814 .fetch(pool)
5815 .await
5816 .unwrap_or_default();
5817 for mut r in stale_chain {
5818 if r.from_path == new_path {
5822 r.delete_pool(pool)
5823 .await
5824 .log_warn("self-redirect left after a rename back not deleted");
5825 continue;
5826 }
5827 r.to_path = new_path.clone();
5828 r.note = format!("auto-chained on page rename at {now}");
5829 r.save_pool(pool).await.log_warn("redirect chain not updated after a rename");
5830 }
5831 let mut row = crate::redirect::Redirect {
5833 id: rustango::sql::Auto::Unset,
5834 from_path: old_path,
5835 to_path: new_path,
5836 is_permanent: true,
5837 note: format!("auto-created on page rename at {now}"),
5838 hit_count: 0,
5839 overrides_live: false,
5840 from_page_id: Some(id),
5843 to_page_id: None,
5844 is_active: true,
5845 disabled_reason: String::new(),
5846 last_hit_at: None,
5847 created_at: rustango::sql::Auto::Unset,
5848 updated_at: rustango::sql::Auto::Unset,
5849 };
5850 if row.insert_pool(pool).await.is_ok() {
5851 redirects_created += 1;
5852 }
5853 }
5854 }
5855
5856 let mut reapproval_kicked = false;
5870 if let (Some(viewer_id), Some(pt)) = (actor.map(|a| a.id), pt_opt.as_ref()) {
5871 if let Some(slug) = pt.workflow_name() {
5872 if let Some(workflow) = crate::workflow::find_by_name(pool, &slug).await? {
5873 if workflow.require_reapproval_on_edit
5874 && crate::workflow::active_state_for_page(pool, id)
5875 .await?
5876 .is_none()
5877 && crate::workflow::has_prior_approval(pool, id).await?
5878 {
5879 let tasks = crate::workflow::tasks_for(
5880 pool,
5881 workflow.id.get().copied().unwrap_or_default(),
5882 )
5883 .await?;
5884 if !tasks.is_empty() {
5885 crate::workflow::submit_for_review(
5886 pool, id, &workflow, &tasks, viewer_id,
5887 )
5888 .await?;
5889 reapproval_kicked = true;
5890 }
5891 }
5892 }
5893 }
5894 }
5895
5896 let _ = (&new_url_path, slug_changed, &old_url_path, &descendant_urls);
5900 if was_published && page.status != crate::page::PageStatus::Published.as_str() {
5904 match crate::redirect::disable_for_page(
5905 pool,
5906 id,
5907 &format!("Linked page “{}” was unpublished", page.title),
5908 )
5909 .await
5910 {
5911 Ok(0) => {}
5912 Ok(n) => {
5913 tracing::info!(
5914 page_id = id,
5915 disabled = n,
5916 "disabled redirects for unpublished page"
5917 );
5918 }
5919 Err(e) => {
5920 tracing::warn!(page_id = id, error = %e, "failed to disable redirects for unpublished page");
5921 }
5922 }
5923 }
5924
5925 if actor.is_some() {
5928 crate::pending_change::discard(pool, id).await?;
5929 }
5930
5931 Ok(Ok(PageEditOutcome {
5932 page,
5933 redirects_created,
5934 reapproval_kicked,
5935 held_for_review: false,
5936 }))
5937}
5938
5939pub async fn page_edit_submit(
5940 State(_state): State<super::AdminState>,
5941 tenant: Tenant,
5942 headers: HeaderMap,
5943 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
5944 Path(id): Path<i64>,
5945 Form(form_map): Form<std::collections::HashMap<String, String>>,
5946) -> Result<Response, AdminError> {
5947 let actor = session_user.as_ref().map(|u| PageEditActor {
5948 id: u.id.get().copied().unwrap_or_default(),
5949 username: u.username.clone(),
5950 is_superuser: u.is_superuser,
5951 });
5952 let outcome = apply_page_edit(
5953 tenant.pool(),
5954 &tenant.org.slug,
5955 &_state.cache_invalidator,
5956 _state.mailer.as_deref(),
5957 &_state.mailer_from,
5958 true,
5959 id,
5960 &form_map,
5961 actor.as_ref(),
5962 )
5963 .await?;
5964 let PageEditOutcome {
5965 page,
5966 redirects_created,
5967 reapproval_kicked,
5968 held_for_review,
5969 } = match outcome {
5970 Ok(o) => o,
5971 Err(PageEditRefusal::WorkflowReview { task_name }) => {
5972 return redirect_named_with_params_and_message_args(
5973 "rcms-admin:pages:edit",
5974 &[("id", id.to_string())],
5975 MsgLevel::Error,
5976 "Couldn't save — page is under review on “{name}”. Only reviewers of that step can edit during review.",
5977 &[("name", task_name.as_str())],
5978 &headers,
5979 );
5980 }
5981 Err(PageEditRefusal::LockedBy { holder }) => {
5982 return redirect_named_with_params_and_message_args(
5983 "rcms-admin:pages:edit",
5984 &[("id", id.to_string())],
5985 MsgLevel::Error,
5986 "Couldn't save — “{holder}” is editing this page right now. Force-unlock to take over.",
5987 &[("holder", holder.as_str())],
5988 &headers,
5989 );
5990 }
5991 Err(PageEditRefusal::ArchivedUnpublish) => {
5992 return redirect_named_with_params_and_message_args(
5993 "rcms-admin:pages:edit",
5994 &[("id", id.to_string())],
5995 MsgLevel::Error,
5996 "Can't unpublish an archived page. Set it back to Published to unarchive, or delete it after unarchiving.",
5997 &[],
5998 &headers,
5999 );
6000 }
6001 Err(PageEditRefusal::PublishDenied) => {
6002 return redirect_named_with_params_and_message(
6003 "rcms-admin:pages:edit",
6004 &[("id", id.to_string())],
6005 MsgLevel::Error,
6006 "You don't have permission to publish this page — save it as a draft or submit it for review.",
6007 &headers,
6008 );
6009 }
6010 Err(PageEditRefusal::ReviewRequired { workflow }) => {
6011 return redirect_named_with_params_and_message_args(
6012 "rcms-admin:pages:edit",
6013 &[("id", id.to_string())],
6014 MsgLevel::Error,
6015 "Pages of this type go live after review (“{workflow}”). Save it as a draft and click Submit for review.",
6016 &[("workflow", workflow.as_str())],
6017 &headers,
6018 );
6019 }
6020 };
6021 if held_for_review {
6022 return redirect_after_page_save(
6023 form_map.get("_action").map_or("save", String::as_str),
6024 id,
6025 page.parent_id,
6026 &super::i18n::tr(
6027 &headers,
6028 "Your changes to “{title}” wait for review. Visitors see the live page until they are approved.",
6029 &[("title", page.title.as_str())],
6030 ),
6031 &headers,
6032 );
6033 }
6034 let mut message = if redirects_created > 0 {
6035 let count = redirects_created.to_string();
6036 super::i18n::tr_plural(
6037 &headers,
6038 "Saved “{title}”. Auto-created {count} redirect(s) from the old URL(s).",
6039 redirects_created as i64,
6040 &[("title", page.title.as_str()), ("count", count.as_str())],
6041 )
6042 } else {
6043 super::i18n::tr(
6044 &headers,
6045 "Saved “{title}”.",
6046 &[("title", page.title.as_str())],
6047 )
6048 };
6049 if reapproval_kicked {
6050 message.push(' ');
6051 message.push_str(&super::i18n::tr(
6052 &headers,
6053 "Workflow restarted — page enters review again.",
6054 &[],
6055 ));
6056 }
6057 redirect_after_page_save(
6058 form_map.get("_action").map_or("save", String::as_str),
6059 id,
6060 page.parent_id,
6061 &message,
6062 &headers,
6063 )
6064}
6065
6066pub(crate) async fn upsert_page_translations(
6082 pool: &rustango::sql::Pool,
6083 page_id: i64,
6084 locale_id: i64,
6085 updates: Vec<(String, String)>,
6086) -> Result<(), rustango::sql::ExecError> {
6087 rustango::atomic!(pool, |tx| {
6088 let mut guard = tx.lock().await?;
6089 let tx = &mut *guard;
6090 for (path, value) in updates {
6091 if value.is_empty() {
6092 let rows: Vec<crate::translation::Translation> =
6093 crate::translation::Translation::objects()
6094 .where_(crate::translation::Translation::page_id.eq(page_id))
6095 .where_(crate::translation::Translation::locale_id.eq(locale_id))
6096 .where_(crate::translation::Translation::field_path.eq(path.clone()))
6097 .fetch_tx(tx)
6098 .await?;
6099 for row in rows {
6100 row.delete_tx(tx).await?;
6101 }
6102 } else {
6103 let existing: Vec<crate::translation::Translation> =
6104 crate::translation::Translation::objects()
6105 .where_(crate::translation::Translation::page_id.eq(page_id))
6106 .where_(crate::translation::Translation::locale_id.eq(locale_id))
6107 .where_(crate::translation::Translation::field_path.eq(path.clone()))
6108 .fetch_tx(tx)
6109 .await?;
6110 if let Some(mut row) = existing.into_iter().next() {
6111 row.value = value;
6112 row.save_tx(tx).await?;
6113 } else {
6114 let mut row = crate::translation::Translation {
6115 id: rustango::sql::Auto::Unset,
6116 page_id,
6117 locale_id,
6118 field_path: path,
6119 value,
6120 updated_at: rustango::sql::Auto::Unset,
6121 };
6122 row.save_tx(tx).await?;
6123 }
6124 }
6125 }
6126 Ok::<_, rustango::sql::ExecError>(())
6127 })
6128 .await
6129}
6130
6131pub async fn page_translate_submit(
6132 State(_state): State<super::AdminState>,
6133 tenant: Tenant,
6134 Path(id): Path<i64>,
6135 Query(q): Query<EditQuery>,
6136 Form(form): Form<std::collections::HashMap<String, String>>,
6137) -> Result<Response, AdminError> {
6138 let code = q
6139 .locale
6140 .as_deref()
6141 .filter(|c| !c.is_empty())
6142 .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
6143 let locale = Locale::objects()
6144 .where_(Locale::code.eq(code.to_owned()))
6145 .where_(Locale::active.eq(true))
6146 .first(tenant.pool())
6147 .await?
6148 .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
6149 if locale.is_default {
6150 return Ok((
6151 axum::http::StatusCode::BAD_REQUEST,
6152 "cannot translate INTO the default locale; canonical content lives on cms_page",
6153 )
6154 .into_response());
6155 }
6156 let locale_id = locale
6157 .id
6158 .get()
6159 .copied()
6160 .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
6161 let _page = Page::objects()
6163 .where_(Page::id.eq(id))
6164 .first(tenant.pool())
6165 .await?
6166 .ok_or(AdminError::NotFound(id))?;
6167
6168 let mut updates: Vec<(String, String)> = Vec::new();
6172 for (k, v) in &form {
6173 if let Some(path) = k.strip_prefix("tr__") {
6174 if path.is_empty() {
6175 continue;
6176 }
6177 updates.push((path.to_owned(), v.clone()));
6178 }
6179 }
6180 let new_path = form
6181 .get("new_field_path")
6182 .map(|s| s.trim().to_owned())
6183 .unwrap_or_default();
6184 if !new_path.is_empty() {
6185 let new_value = form.get("new_field_value").cloned().unwrap_or_default();
6186 if let Ok(path) = crate::translation::validate_field_path(&new_path) {
6189 updates.push((path, new_value));
6190 }
6191 }
6192
6193 upsert_page_translations(tenant.pool(), id, locale_id, updates).await?;
6194
6195 let page = Page::objects()
6198 .where_(Page::id.eq(id))
6199 .first(tenant.pool())
6200 .await?
6201 .ok_or(AdminError::NotFound(id))?;
6202 let _ = (page, &code);
6206
6207 Ok(Redirect::to(&format!("/cms-admin/pages/{id}/edit?locale={code}")).into_response())
6208}
6209
6210pub async fn page_delete_submit(
6213 State(_state): State<super::AdminState>,
6214 tenant: Tenant,
6215 headers: HeaderMap,
6216 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6217 Path(id): Path<i64>,
6218) -> Result<Response, AdminError> {
6219 let page = Page::objects()
6220 .where_(Page::id.eq(id))
6221 .first(tenant.pool())
6222 .await?
6223 .ok_or(AdminError::NotFound(id))?;
6224
6225 if page.status == crate::page::PageStatus::Archived.as_str() {
6229 return redirect_named_with_message_args(
6230 "rcms-admin:pages:list",
6231 MsgLevel::Error,
6232 "Can't delete “{title}” while archived — unarchive it first.",
6233 &[("title", page.title.as_str())],
6234 &headers,
6235 );
6236 }
6237
6238 let child_count: Vec<Page> = Page::objects()
6239 .where_(Page::parent_id.eq(id))
6240 .fetch(tenant.pool())
6241 .await?;
6242 if !child_count.is_empty() {
6243 let count = child_count.len().to_string();
6244 return redirect_named_with_message_plural(
6245 "rcms-admin:pages:list",
6246 MsgLevel::Error,
6247 "Can't delete “{title}” — it has {count} child page(s). Delete or move them first.",
6248 child_count.len() as i64,
6249 &[("title", page.title.as_str()), ("count", count.as_str())],
6250 &headers,
6251 );
6252 }
6253
6254 let serving_hosts = crate::site::hosts_for_root(tenant.pool(), id).await?;
6260 if !serving_hosts.is_empty() {
6261 let hosts = serving_hosts.join(", ");
6262 return redirect_named_with_message_args(
6263 "rcms-admin:pages:list",
6264 MsgLevel::Error,
6265 "Can't delete “{title}” — it is the root served by {hosts}. Change that on the Sites screen first.",
6266 &[("title", page.title.as_str()), ("hosts", hosts.as_str())],
6267 &headers,
6268 );
6269 }
6270
6271 let aliases: Vec<Page> = Page::objects()
6278 .where_(Page::alias_of.eq(id))
6279 .fetch(tenant.pool())
6280 .await?;
6281 let alias_count = aliases.len();
6282 let title = page.title.clone();
6283 let url_path = page.url_path.clone();
6284
6285 let invalidator = _state.cache_invalidator.clone();
6293 let tenant_slug = tenant.org.slug.clone();
6294 let purge_url = url_path.clone();
6295 rustango::atomic!(tenant.pool(), |tx| {
6296 let mut guard = tx.lock().await?;
6297 let tx = &mut *guard;
6298 for mut alias in aliases {
6299 alias.alias_of = None;
6300 alias.title = page.title.clone();
6301 alias.seo_title = page.seo_title.clone();
6302 alias.seo_description = page.seo_description.clone();
6303 alias.status = page.status.clone();
6304 alias.published_at = page.published_at;
6305 alias.last_published_at = page.last_published_at;
6306 alias.theme_id = page.theme_id;
6307 alias.show_in_menus = page.show_in_menus;
6308 alias.save_tx(tx).await?;
6309 }
6310 crate::page_delete::clear_page_references_tx(tx, id).await?;
6313 page.delete_tx(tx).await?;
6314 crate::cache_invalidate::invalidate_urls_on_commit(
6315 invalidator,
6316 tenant_slug,
6317 vec![purge_url],
6318 );
6319 Ok(())
6320 })
6321 .await?;
6322 crate::task_queue::remove_page_search(&tenant.org.slug, id).await;
6325 if let Err(e) = crate::redirect::disable_for_page(
6328 tenant.pool(),
6329 id,
6330 &format!("Linked page “{title}” was deleted"),
6331 )
6332 .await
6333 {
6334 tracing::warn!(page_id = id, error = %e, "failed to disable redirects for deleted page");
6335 }
6336 if alias_count > 0 {
6337 redirect_named_with_message_plural(
6338 "rcms-admin:pages:list",
6339 MsgLevel::Success,
6340 "Deleted “{title}”. Promoted {count} alias(es) to standalone page(s) with the source's last content.",
6341 alias_count as i64,
6342 &[("title", title.as_str()), ("count", &alias_count.to_string())],
6343 &headers,
6344 )
6345 } else {
6346 redirect_named_with_message_args(
6347 "rcms-admin:pages:list",
6348 MsgLevel::Success,
6349 "Deleted “{title}”.",
6350 &[("title", title.as_str())],
6351 &headers,
6352 )
6353 }
6354}
6355
6356#[derive(Debug, Deserialize)]
6363pub struct MoveForm {
6364 pub new_parent: i64,
6368}
6369
6370pub async fn page_move_submit(
6374 State(_state): State<super::AdminState>,
6375 tenant: Tenant,
6376 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6377 Path(id): Path<i64>,
6378 Form(form): Form<MoveForm>,
6379) -> Result<Response, AdminError> {
6380 let mut page = Page::objects()
6381 .where_(Page::id.eq(id))
6382 .first(tenant.pool())
6383 .await?
6384 .ok_or(AdminError::NotFound(id))?;
6385 let new_parent: Option<Page> = if form.new_parent > 0 {
6386 Page::objects()
6387 .where_(Page::id.eq(form.new_parent))
6388 .first(tenant.pool())
6389 .await?
6390 } else {
6391 None
6392 };
6393 let old_url_path = page.url_path.clone();
6394 let old_descendant_urls: Vec<String> =
6395 page.descendants(tenant.pool()).await?.into_iter().map(|d| d.url_path).collect();
6396 page.move_to(&tenant, new_parent.as_ref()).await?;
6398 let new_url_path = page.url_path.clone();
6399
6400 let mut urls = old_descendant_urls;
6404 urls.push(old_url_path.clone());
6405 urls.push(new_url_path.clone());
6406 urls.extend(page.descendants(tenant.pool()).await?.into_iter().map(|d| d.url_path));
6407 let invalidator = _state.cache_invalidator.clone();
6408 let tenant_slug = tenant.org.slug.clone();
6409 rustango::__private_runtime::tokio::spawn(async move {
6410 crate::task_queue::purge_urls(invalidator, tenant_slug, urls).await;
6411 });
6412
6413 let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6415 crate::page_log::record_or_warn(
6416 tenant.pool(),
6417 id,
6418 crate::page_log::ACTION_MOVE,
6419 actor_id,
6420 format!(
6421 "Moved “{}” from {old_url_path} to {new_url_path}.",
6422 page.title
6423 ),
6424 Some(serde_json::json!({
6425 "old_url_path": old_url_path,
6426 "new_url_path": new_url_path,
6427 "new_parent_id": form.new_parent,
6428 })),
6429 )
6430 .await;
6431
6432 Ok((axum::http::StatusCode::OK, "ok").into_response())
6433}
6434
6435pub async fn page_clone_submit(
6453 State(state): State<super::AdminState>,
6454 tenant: Tenant,
6455 headers: HeaderMap,
6456 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6457 Path(id): Path<i64>,
6458) -> Result<Response, AdminError> {
6459 let source = Page::objects()
6460 .where_(Page::id.eq(id))
6461 .first(tenant.pool())
6462 .await?
6463 .ok_or(AdminError::NotFound(id))?;
6464
6465 let title = format!("{} (copy)", source.title);
6466 let base_slug = source.slug.trim_matches('-').to_owned();
6467 let slug = unique_sibling_slug(
6468 tenant.pool(),
6469 source.parent_id,
6470 &format!("{base_slug}-copy"),
6471 )
6472 .await?;
6473
6474 let new = crate::tree_ops::NewPage::new(source.page_type_id, title, slug)
6475 .with_status(crate::page::PageStatus::Draft)
6476 .with_seo(source.seo_title.clone(), source.seo_description.clone());
6477
6478 let clone = match source.parent_id {
6479 Some(pid) => {
6480 let parent = Page::objects()
6481 .where_(Page::id.eq(pid))
6482 .first(tenant.pool())
6483 .await?
6484 .ok_or(AdminError::NotFound(pid))?;
6485 Page::create_child(&tenant, &parent, new).await?
6486 }
6487 None => Page::create_root(&tenant, new).await?,
6488 };
6489 let new_id = clone.id.get().copied().unwrap_or_default();
6490
6491 let mut form = crate::page_form::prefill(tenant.pool(), &source).await;
6496 form.insert("title".into(), clone.title.clone());
6497 form.insert("slug".into(), clone.slug.clone());
6498 form.insert(
6499 "status".into(),
6500 crate::page::PageStatus::Draft.as_str().to_owned(),
6501 );
6502 form.remove("go_live_at");
6503 form.remove("expire_at");
6504 let actor = session_user.as_ref().map(|u| PageEditActor {
6505 id: u.id.get().copied().unwrap_or_default(),
6506 username: u.username.clone(),
6507 is_superuser: u.is_superuser,
6508 });
6509 let saved = apply_page_edit(
6510 tenant.pool(),
6511 &tenant.org.slug,
6512 &state.cache_invalidator,
6513 None,
6514 "",
6515 false,
6516 new_id,
6517 &form,
6518 actor.as_ref(),
6519 )
6520 .await?;
6521 if saved.is_err() {
6522 return Err(AdminError::Validation(
6524 "the copy was created but its content could not be saved".to_owned(),
6525 ));
6526 }
6527 let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6531 crate::page_log::record_or_warn(
6532 tenant.pool(),
6533 new_id,
6534 crate::page_log::ACTION_COPY,
6535 actor_id,
6536 format!("Cloned from “{}” (page #{id}).", source.title),
6537 Some(serde_json::json!({ "source_page_id": id })),
6538 )
6539 .await;
6540 crate::page_log::record_or_warn(
6541 tenant.pool(),
6542 id,
6543 crate::page_log::ACTION_COPY,
6544 actor_id,
6545 format!("Cloned to new draft page #{new_id}."),
6546 Some(serde_json::json!({ "clone_page_id": new_id })),
6547 )
6548 .await;
6549 redirect_named_with_params_and_message_args(
6550 "rcms-admin:pages:edit",
6551 &[("id", new_id.to_string())],
6552 MsgLevel::Success,
6553 "Cloned “{title}” as a draft. Review before publishing.",
6554 &[("title", source.title.as_str())],
6555 &headers,
6556 )
6557}
6558
6559#[derive(Deserialize)]
6565pub struct PrivacyForm {
6566 pub kind: String,
6567 #[serde(default)]
6568 pub password: String,
6569 #[serde(default)]
6570 pub group_ids: String,
6571 #[serde(default)]
6574 pub codenames: String,
6575}
6576
6577pub async fn page_privacy_submit(
6578 State(_state): State<super::AdminState>,
6579 tenant: Tenant,
6580 headers: HeaderMap,
6581 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6582 Path(id): Path<i64>,
6583 Form(form): Form<PrivacyForm>,
6584) -> Result<Response, AdminError> {
6585 use rustango::sql::Auto;
6586 let existing = crate::view_restriction::direct_for_page(tenant.pool(), id).await?;
6587 if form.kind == "none" {
6588 if let Some(row) = existing {
6589 row.delete_pool(tenant.pool()).await?;
6590 return redirect_named_with_params_and_message(
6591 "rcms-admin:pages:edit",
6592 &[("id", id.to_string())],
6593 MsgLevel::Success,
6594 "Removed view restriction — page is now public.",
6595 &headers,
6596 );
6597 }
6598 return redirect_named_with_params_and_message(
6599 "rcms-admin:pages:edit",
6600 &[("id", id.to_string())],
6601 MsgLevel::Info,
6602 "No restriction to remove.",
6603 &headers,
6604 );
6605 }
6606 let Some(kind) = crate::view_restriction::RestrictionKind::parse(&form.kind) else {
6607 return Err(AdminError::Validation(format!(
6608 "unknown restriction kind `{}`",
6609 form.kind
6610 )));
6611 };
6612 let password_hash = match kind {
6613 crate::view_restriction::RestrictionKind::Password => {
6614 if form.password.is_empty() {
6619 if let Some(row) = &existing {
6620 if row.kind == kind.as_str() {
6621 row.password_hash.clone()
6622 } else {
6623 return redirect_named_with_params_and_message(
6624 "rcms-admin:pages:edit",
6625 &[("id", id.to_string())],
6626 MsgLevel::Error,
6627 "Password is required when switching the restriction kind to password.",
6628 &headers,
6629 );
6630 }
6631 } else {
6632 return redirect_named_with_params_and_message(
6633 "rcms-admin:pages:edit",
6634 &[("id", id.to_string())],
6635 MsgLevel::Error,
6636 "Password is required for password-protected pages.",
6637 &headers,
6638 );
6639 }
6640 } else {
6641 crate::passwords::hash(&form.password).await
6642 .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?
6643 }
6644 }
6645 _ => String::new(),
6646 };
6647 let group_ids: Vec<i64> = if matches!(kind, crate::view_restriction::RestrictionKind::Groups) {
6648 form.group_ids
6649 .split(',')
6650 .filter_map(|s| s.trim().parse::<i64>().ok())
6651 .collect()
6652 } else {
6653 Vec::new()
6654 };
6655 let group_json = serde_json::json!(group_ids);
6656 let codenames: Vec<String> =
6657 if matches!(kind, crate::view_restriction::RestrictionKind::Permission) {
6658 form.codenames
6659 .split(',')
6660 .map(str::trim)
6661 .filter(|s| !s.is_empty())
6662 .map(str::to_owned)
6663 .collect()
6664 } else {
6665 Vec::new()
6666 };
6667 let codenames_json = serde_json::json!(codenames);
6668 match existing {
6669 Some(mut row) => {
6670 row.kind = kind.as_str().to_owned();
6671 row.password_hash = password_hash;
6672 row.group_ids = group_json;
6673 row.codenames = codenames_json;
6674 row.save_pool(tenant.pool()).await?;
6675 }
6676 None => {
6677 let mut row = crate::view_restriction::PageViewRestriction {
6678 id: Auto::Unset,
6679 page_id: id,
6680 kind: kind.as_str().to_owned(),
6681 password_hash,
6682 group_ids: group_json,
6683 codenames: codenames_json,
6684 created_at: Auto::Unset,
6685 updated_at: Auto::Unset,
6686 };
6687 row.insert_pool(tenant.pool()).await?;
6688 }
6689 }
6690 redirect_named_with_params_and_message_args(
6691 "rcms-admin:pages:edit",
6692 &[("id", id.to_string())],
6693 MsgLevel::Success,
6694 match kind {
6695 crate::view_restriction::RestrictionKind::Login => "Only signed-in people can see this page now.",
6696 crate::view_restriction::RestrictionKind::Groups => "Only the chosen roles can see this page now.",
6697 crate::view_restriction::RestrictionKind::Permission => "Only people with the chosen permissions can see this page now.",
6698 crate::view_restriction::RestrictionKind::Password => "This page asks for a password now.",
6699 },
6700 &[],
6701 &headers,
6702 )
6703}
6704
6705#[derive(Debug, Deserialize)]
6710pub struct CommentNewForm {
6711 pub field_path: String,
6712 pub body: String,
6713}
6714
6715pub async fn comment_new_submit(
6716 State(_state): State<super::AdminState>,
6717 tenant: Tenant,
6718 headers: HeaderMap,
6719 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6720 Path(id): Path<i64>,
6721 Form(form): Form<CommentNewForm>,
6722) -> Result<Response, AdminError> {
6723 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6724 return Ok(unauthorized_no_session());
6725 };
6726 let body = form.body.trim();
6727 let field_path = form.field_path.trim();
6728 if body.is_empty() || field_path.is_empty() {
6729 return redirect_named_with_params_and_message(
6730 "rcms-admin:pages:edit",
6731 &[("id", id.to_string())],
6732 MsgLevel::Warning,
6733 "Comment body and field are both required.",
6734 &headers,
6735 );
6736 }
6737 let mut row = crate::comment::Comment {
6738 id: rustango::sql::Auto::Unset,
6739 page_id: id,
6740 field_path: field_path.to_owned(),
6741 author_id: viewer_id,
6742 body: body.to_owned(),
6743 resolved_at: None,
6744 resolved_by: None,
6745 created_at: rustango::sql::Auto::Unset,
6746 };
6747 row.insert_pool(tenant.pool()).await?;
6748 redirect_named_with_params_and_message(
6749 "rcms-admin:pages:edit",
6750 &[("id", id.to_string())],
6751 MsgLevel::Success,
6752 "Comment posted.",
6753 &headers,
6754 )
6755}
6756
6757#[derive(Debug, Deserialize)]
6758pub struct CommentReplyForm {
6759 pub body: String,
6760}
6761
6762pub async fn comment_reply_submit(
6763 State(_state): State<super::AdminState>,
6764 tenant: Tenant,
6765 headers: HeaderMap,
6766 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6767 Path((id, comment_id)): Path<(i64, i64)>,
6768 Form(form): Form<CommentReplyForm>,
6769) -> Result<Response, AdminError> {
6770 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6771 return Ok(unauthorized_no_session());
6772 };
6773 let body = form.body.trim();
6774 if body.is_empty() {
6775 return redirect_named_with_params_and_message(
6776 "rcms-admin:pages:edit",
6777 &[("id", id.to_string())],
6778 MsgLevel::Warning,
6779 "Reply body is required.",
6780 &headers,
6781 );
6782 }
6783 let mut row = crate::comment::CommentReply {
6784 id: rustango::sql::Auto::Unset,
6785 comment_id,
6786 author_id: viewer_id,
6787 body: body.to_owned(),
6788 created_at: rustango::sql::Auto::Unset,
6789 };
6790 row.insert_pool(tenant.pool()).await?;
6791 redirect_named_with_params_and_message(
6792 "rcms-admin:pages:edit",
6793 &[("id", id.to_string())],
6794 MsgLevel::Success,
6795 "Reply posted.",
6796 &headers,
6797 )
6798}
6799
6800pub async fn comment_resolve_submit(
6801 State(_state): State<super::AdminState>,
6802 tenant: Tenant,
6803 headers: HeaderMap,
6804 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6805 Path((id, comment_id)): Path<(i64, i64)>,
6806) -> Result<Response, AdminError> {
6807 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6808 return Ok(unauthorized_no_session());
6809 };
6810 let mut row = crate::comment::Comment::objects()
6811 .where_(crate::comment::Comment::id.eq(comment_id))
6812 .where_(crate::comment::Comment::page_id.eq(id))
6813 .first(tenant.pool())
6814 .await?
6815 .ok_or(AdminError::NotFound(comment_id))?;
6816 row.resolved_at = Some(chrono::Utc::now());
6817 row.resolved_by = Some(viewer_id);
6818 row.save_pool(tenant.pool()).await?;
6819 redirect_named_with_params_and_message(
6820 "rcms-admin:pages:edit",
6821 &[("id", id.to_string())],
6822 MsgLevel::Success,
6823 "Comment resolved.",
6824 &headers,
6825 )
6826}
6827
6828pub async fn comment_reopen_submit(
6829 State(_state): State<super::AdminState>,
6830 tenant: Tenant,
6831 headers: HeaderMap,
6832 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6833 Path((id, comment_id)): Path<(i64, i64)>,
6834) -> Result<Response, AdminError> {
6835 let mut row = crate::comment::Comment::objects()
6836 .where_(crate::comment::Comment::id.eq(comment_id))
6837 .where_(crate::comment::Comment::page_id.eq(id))
6838 .first(tenant.pool())
6839 .await?
6840 .ok_or(AdminError::NotFound(comment_id))?;
6841 row.resolved_at = None;
6842 row.resolved_by = None;
6843 row.save_pool(tenant.pool()).await?;
6844 redirect_named_with_params_and_message(
6845 "rcms-admin:pages:edit",
6846 &[("id", id.to_string())],
6847 MsgLevel::Info,
6848 "Comment reopened.",
6849 &headers,
6850 )
6851}
6852
6853pub async fn page_alias_submit(
6867 State(state): State<super::AdminState>,
6868 tenant: Tenant,
6869 headers: HeaderMap,
6870 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6871 Path(id): Path<i64>,
6872) -> Result<Response, AdminError> {
6873 let source = Page::objects()
6874 .where_(Page::id.eq(id))
6875 .first(tenant.pool())
6876 .await?
6877 .ok_or(AdminError::NotFound(id))?;
6878
6879 if let Some(src_id) = source.alias_of {
6883 let src_id_str = src_id.to_string();
6884 return redirect_named_with_params_and_message_args(
6885 "rcms-admin:pages:edit",
6886 &[("id", id.to_string())],
6887 MsgLevel::Error,
6888 "Can't alias an alias — point your new alias at the underlying source page (#{source_id}) instead.",
6889 &[("source_id", src_id_str.as_str())],
6890 &headers,
6891 );
6892 }
6893
6894 let base_slug = source.slug.trim_matches('-').to_owned();
6895 let slug = unique_sibling_slug(
6896 tenant.pool(),
6897 source.parent_id,
6898 &if base_slug.is_empty() {
6899 "alias".to_owned()
6900 } else {
6901 format!("{base_slug}-alias")
6902 },
6903 )
6904 .await?;
6905
6906 let new = crate::tree_ops::NewPage::new(source.page_type_id, source.title.clone(), slug)
6910 .with_status(crate::page::PageStatus::Draft)
6911 .with_seo(source.seo_title.clone(), source.seo_description.clone());
6912
6913 let mut alias = match source.parent_id {
6914 Some(pid) => {
6915 let parent = Page::objects()
6916 .where_(Page::id.eq(pid))
6917 .first(tenant.pool())
6918 .await?
6919 .ok_or(AdminError::NotFound(pid))?;
6920 Page::create_child(&tenant, &parent, new).await?
6921 }
6922 None => Page::create_root(&tenant, new).await?,
6923 };
6924 alias.alias_of = Some(id);
6925 alias.status = source.status.clone();
6930 alias.published_at = source.published_at;
6931 alias.last_published_at = source.last_published_at;
6932 alias.theme_id = source.theme_id;
6933 alias.show_in_menus = source.show_in_menus;
6934 alias.save_pool(tenant.pool()).await?;
6935
6936 crate::revision::capture(tenant.pool(), &alias, None)
6937 .await
6938 .log_warn("revision not captured; the history has a gap");
6939 let new_id = alias.id.get().copied().unwrap_or_default();
6940 let _ = state;
6941 let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6943 crate::page_log::record_or_warn(
6944 tenant.pool(),
6945 new_id,
6946 crate::page_log::ACTION_ALIAS_CREATE,
6947 actor_id,
6948 format!("Alias of “{}” (page #{id}).", source.title),
6949 Some(serde_json::json!({ "alias_of": id })),
6950 )
6951 .await;
6952 crate::page_log::record_or_warn(
6953 tenant.pool(),
6954 id,
6955 crate::page_log::ACTION_ALIAS_CREATE,
6956 actor_id,
6957 format!("New alias #{new_id} pointing here."),
6958 Some(serde_json::json!({ "alias_page_id": new_id })),
6959 )
6960 .await;
6961 redirect_named_with_params_and_message_args(
6962 "rcms-admin:pages:list",
6963 &[],
6968 MsgLevel::Success,
6969 "Created alias of “{title}”. Edits to the source will propagate to every alias's URL.",
6970 &[("title", source.title.as_str())],
6971 &headers,
6972 )
6973}
6974
6975fn copy_fields_for(p: &Page) -> Vec<(&'static str, String)> {
6980 copy_translatable_fields(&p.title, &p.seo_title, &p.seo_description)
6981}
6982
6983fn copy_translatable_fields(
6987 title: &str,
6988 seo_title: &str,
6989 seo_description: &str,
6990) -> Vec<(&'static str, String)> {
6991 [
6992 ("title", title),
6993 ("seo_title", seo_title),
6994 ("seo_description", seo_description),
6995 ]
6996 .into_iter()
6997 .filter(|(_, v)| !v.trim().is_empty())
6998 .map(|(k, v)| (k, v.to_owned()))
6999 .collect()
7000}
7001
7002pub async fn page_bulk_submit(
7023 State(_state): State<super::AdminState>,
7024 tenant: Tenant,
7025 headers: HeaderMap,
7026 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7027 Form(form): Form<Vec<(String, String)>>,
7028) -> Result<Response, AdminError> {
7029 let action = form
7030 .iter()
7031 .find(|(k, _)| k == "action")
7032 .map(|(_, v)| v.clone())
7033 .unwrap_or_default();
7034 let ids: Vec<i64> = form
7035 .iter()
7036 .filter(|(k, _)| k == "ids" || k == "id")
7037 .filter_map(|(_, v)| v.parse::<i64>().ok())
7038 .collect();
7039 let new_parent_raw = form
7040 .iter()
7041 .find(|(k, _)| k == "new_parent")
7042 .and_then(|(_, v)| v.parse::<i64>().ok());
7043 let archive_cascade = form.iter().any(|(k, v)| {
7046 k == "archive_cascade" && matches!(v.as_str(), "1" | "on" | "subtree" | "true")
7047 });
7048
7049 if action.is_empty() || ids.is_empty() {
7050 return redirect_named_with_message(
7051 "rcms-admin:pages:list",
7052 MsgLevel::Warning,
7053 "Pick at least one row + an action before submitting.",
7054 &headers,
7055 );
7056 }
7057
7058 let pool = tenant.pool();
7063 let pages: Vec<Page> = {
7064 let mut out = Vec::with_capacity(ids.len());
7065 for id in &ids {
7066 if let Some(p) = Page::objects().where_(Page::id.eq(*id)).first(pool).await? {
7067 out.push(p);
7068 }
7069 }
7070 out
7071 };
7072 if pages.is_empty() {
7073 return redirect_named_with_message(
7074 "rcms-admin:pages:list",
7075 MsgLevel::Warning,
7076 "None of the selected ids matched a live page.",
7077 &headers,
7078 );
7079 }
7080
7081 let needs = match action.as_str() {
7084 "publish" | "unpublish" => crate::permissions::Action::Publish,
7085 "delete" => crate::permissions::Action::Delete,
7086 _ => crate::permissions::Action::Edit,
7087 };
7088 if let Some(user) = session_user.as_ref() {
7089 for p in &pages {
7090 let req = super::route_perms::Requirement {
7091 codename: format!("cms_page.{}", needs.as_str()),
7092 page: p.id.get().copied().map(|id| (id, needs)),
7093 };
7094 if !super::route_perms::allows(pool, user, &req).await {
7095 return redirect_named_with_message_args(
7096 "rcms-admin:pages:list",
7097 MsgLevel::Error,
7098 "You don't have permission to {action} “{title}”.",
7099 &[("action", action.as_str()), ("title", p.title.as_str())],
7100 &headers,
7101 );
7102 }
7103 }
7104 }
7105
7106 match action.as_str() {
7107 "publish" | "unpublish" => {
7108 let target = if action == "publish" {
7109 crate::page::PageStatus::Published
7110 } else {
7111 crate::page::PageStatus::Draft
7112 };
7113 let invalidator = _state.cache_invalidator.clone();
7114 let tenant_slug = tenant.org.slug.clone();
7115 let purge_urls: Vec<String> = pages.iter().map(|p| p.url_path.clone()).collect();
7116 let pages_for_tx = pages.clone();
7117 let touched = rustango::atomic!(pool, |tx| {
7121 let mut guard = tx.lock().await?;
7122 let tx = &mut *guard;
7123 let mut touched = 0usize;
7124 for mut p in pages_for_tx {
7125 if matches!(target, crate::page::PageStatus::Draft)
7129 && p.status == crate::page::PageStatus::Archived.as_str()
7130 {
7131 continue;
7132 }
7133 if p.status != target.as_str() {
7134 p.status = target.as_str().to_owned();
7135 if matches!(target, crate::page::PageStatus::Published) {
7136 let now = chrono::Utc::now();
7137 if p.published_at.is_none() {
7138 p.published_at = Some(now);
7139 }
7140 p.last_published_at = Some(now);
7142 }
7143 p.save_tx(tx).await?;
7144 touched += 1;
7145 }
7146 }
7147 crate::cache_invalidate::invalidate_urls_on_commit(
7148 invalidator,
7149 tenant_slug,
7150 purge_urls,
7151 );
7152 Ok::<usize, rustango::sql::ExecError>(touched)
7153 })
7154 .await?;
7155 for p in &pages {
7158 crate::revision::capture(pool, p, None)
7159 .await
7160 .log_warn("revision not captured; the history has a gap");
7161 }
7162 if !matches!(target, crate::page::PageStatus::Published) {
7166 for p in &pages {
7167 if p.status != crate::page::PageStatus::Published.as_str() {
7168 continue;
7169 }
7170 let pid = p.id.get().copied().unwrap_or_default();
7171 if let Err(e) = crate::redirect::disable_for_page(
7172 pool,
7173 pid,
7174 &format!("Linked page “{}” was unpublished", p.title),
7175 )
7176 .await
7177 {
7178 tracing::warn!(page_id = pid, error = %e, "failed to disable redirects for unpublished page");
7179 }
7180 }
7181 }
7182 if matches!(target, crate::page::PageStatus::Published) {
7184 for p in &pages {
7185 crate::hooks::fire_after_publish_page(p);
7186 }
7187 let actor = session_user.as_ref().map(|u| u.username.as_str());
7189 for p in &pages {
7190 crate::page_subscription::notify_publish(
7191 _state.mailer.as_deref(),
7192 &_state.mailer_from,
7193 pool,
7194 &tenant.org.slug,
7195 p.id.get().copied().unwrap_or_default(),
7196 &p.title,
7197 &p.url_path,
7198 actor,
7199 )
7200 .await;
7201 }
7202 }
7203 let already = (pages.len() - touched).to_string();
7204 let key = if action == "publish" {
7205 "Published {count} page(s) ({already} already in the target state)."
7206 } else {
7207 "Unpublished {count} page(s) ({already} already in the target state)."
7208 };
7209 redirect_named_with_message_plural(
7210 "rcms-admin:pages:list",
7211 MsgLevel::Success,
7212 key,
7213 touched as i64,
7214 &[("count", &touched.to_string()), ("already", already.as_str())],
7215 &headers,
7216 )
7217 }
7218 "delete" => {
7219 let archived_names: Vec<String> = pages
7224 .iter()
7225 .filter(|p| p.status == crate::page::PageStatus::Archived.as_str())
7226 .map(|p| format!("“{}”", p.title))
7227 .collect();
7228 if !archived_names.is_empty() {
7229 let list = archived_names.join(", ");
7230 return redirect_named_with_message_args(
7231 "rcms-admin:pages:list",
7232 MsgLevel::Error,
7233 "Can't delete archived page(s) {names} — unarchive them first.",
7234 &[("names", list.as_str())],
7235 &headers,
7236 );
7237 }
7238 let id_set: std::collections::HashSet<i64> =
7242 pages.iter().filter_map(|p| p.id.get().copied()).collect();
7243 let mut offenders: Vec<String> = Vec::new();
7244 for p in &pages {
7245 let pid = p.id.get().copied().unwrap_or_default();
7246 let children: Vec<Page> = Page::objects()
7247 .where_(Page::parent_id.eq(pid))
7248 .fetch(pool)
7249 .await?;
7250 let external_children = children
7254 .iter()
7255 .filter(|c| !id_set.contains(&c.id.get().copied().unwrap_or_default()))
7256 .count();
7257 if external_children > 0 {
7258 offenders.push(format!("#{pid} “{}” ({external_children})", p.title));
7259 }
7260 }
7261 if !offenders.is_empty() {
7262 let offenders_list = offenders.join(", ");
7263 return redirect_named_with_message_args(
7264 "rcms-admin:pages:list",
7265 MsgLevel::Error,
7266 "Bulk delete blocked — these page(s) still have external children: {offenders}.",
7267 &[("offenders", offenders_list.as_str())],
7268 &headers,
7269 );
7270 }
7271 let mut ordered = pages.clone();
7276 ordered.sort_by(|a, b| b.depth.cmp(&a.depth));
7277 let invalidator = _state.cache_invalidator.clone();
7278 let tenant_slug = tenant.org.slug.clone();
7279 let purge_urls: Vec<String> = pages.iter().map(|p| p.url_path.clone()).collect();
7283 rustango::atomic!(pool, |tx| {
7284 let mut guard = tx.lock().await?;
7285 let tx = &mut *guard;
7286 for p in &ordered {
7287 let pid = p.id.get().copied().unwrap_or_default();
7288 crate::page_delete::clear_page_references_tx(tx, pid).await?;
7289 }
7290 for p in ordered {
7291 p.delete_tx(tx).await?;
7292 }
7293 crate::cache_invalidate::invalidate_urls_on_commit(
7294 invalidator,
7295 tenant_slug,
7296 purge_urls,
7297 );
7298 Ok::<(), rustango::sql::ExecError>(())
7299 })
7300 .await?;
7301 for p in &pages {
7303 let pid = p.id.get().copied().unwrap_or_default();
7304 if let Err(e) = crate::redirect::disable_for_page(
7305 pool,
7306 pid,
7307 &format!("Linked page “{}” was deleted", p.title),
7308 )
7309 .await
7310 {
7311 tracing::warn!(page_id = pid, error = %e, "failed to disable redirects for deleted page");
7312 }
7313 }
7314 redirect_named_with_message_plural(
7315 "rcms-admin:pages:list",
7316 MsgLevel::Success,
7317 "Deleted {count} page(s).",
7318 pages.len() as i64,
7319 &[("count", &pages.len().to_string())],
7320 &headers,
7321 )
7322 }
7323 "move" => {
7324 let Some(new_parent_id) = new_parent_raw else {
7325 return redirect_named_with_message(
7326 "rcms-admin:pages:list",
7327 MsgLevel::Warning,
7328 "Bulk move requires a destination — pick a parent page.",
7329 &headers,
7330 );
7331 };
7332 let new_parent: Option<Page> = if new_parent_id > 0 {
7333 Page::objects()
7334 .where_(Page::id.eq(new_parent_id))
7335 .first(pool).await?
7336 } else {
7337 None
7338 };
7339 if let Some(np) = &new_parent {
7342 for p in &pages {
7343 if np.path.starts_with(&p.path) {
7344 return redirect_named_with_message_args(
7345 "rcms-admin:pages:list",
7346 MsgLevel::Error,
7347 "Can't move “{title}” under “{parent}” — destination is itself or a descendant.",
7348 &[("title", p.title.as_str()), ("parent", np.title.as_str())],
7349 &headers,
7350 );
7351 }
7352 }
7353 }
7354
7355 if let Some(np) = &new_parent {
7361 for p in &pages {
7362 if let Err(e) =
7363 crate::tree_ops::validate_child_placement(pool, np.page_type_id, p.page_type_id)
7364 .await
7365 {
7366 let err = e.to_string();
7367 return redirect_named_with_message_args(
7368 "rcms-admin:pages:list",
7369 MsgLevel::Error,
7370 "Move blocked — “{title}” can't live under “{parent}”: {error}",
7371 &[("title", p.title.as_str()), ("parent", np.title.as_str()), ("error", err.as_str())],
7372 &headers,
7373 );
7374 }
7375 }
7376 }
7377
7378 let mut to_move: Vec<(Page, Vec<Page>)> = Vec::with_capacity(pages.len());
7388 for p in pages.iter().cloned() {
7389 let subtree = p.descendants(pool).await?;
7390 to_move.push((p, subtree));
7391 }
7392 let moved = to_move.len();
7393 let invalidator = _state.cache_invalidator.clone();
7394 let tenant_slug = tenant.org.slug.clone();
7395 let np_for_tx = new_parent.clone();
7396 crate::tree_ops::atomic_tree(pool, move |tx| {
7397 Box::pin(async move {
7398 let mut purge: Vec<String> = Vec::new();
7399 for (mut p, subtree) in to_move {
7400 let old_url = p.url_path.clone();
7401 let descendant_old_urls: Vec<String> =
7402 subtree.iter().map(|d| d.url_path.clone()).collect();
7403 p.move_to_in_tx(np_for_tx.as_ref(), subtree, tx).await?;
7405 purge.push(old_url);
7406 purge.push(p.url_path.clone());
7407 purge.extend(descendant_old_urls);
7408 }
7409 crate::cache_invalidate::invalidate_urls_on_commit(
7410 invalidator,
7411 tenant_slug,
7412 purge,
7413 );
7414 Ok(())
7415 })
7416 })
7417 .await?;
7418 redirect_named_with_message_plural(
7419 "rcms-admin:pages:list",
7420 MsgLevel::Success,
7421 "Moved {count} page(s) under “{parent}”.",
7422 moved as i64,
7423 &[
7424 ("count", &moved.to_string()),
7425 (
7426 "parent",
7427 &new_parent.map(|p| p.title).unwrap_or_else(|| "Root".to_owned()),
7428 ),
7429 ],
7430 &headers,
7431 )
7432 }
7433 "copy-to-locale" => {
7434 let code = form
7439 .iter()
7440 .find(|(k, _)| k == "locale")
7441 .map(|(_, v)| v.as_str())
7442 .unwrap_or("");
7443 let locale = Locale::objects()
7444 .where_(Locale::code.eq(code.to_owned()))
7445 .where_(Locale::active.eq(true))
7446 .first(pool)
7447 .await?;
7448 let Some(locale) = locale.filter(|l| !l.is_default) else {
7449 return redirect_named_with_message(
7450 "rcms-admin:pages:list",
7451 MsgLevel::Warning,
7452 "Copy to locale needs a target locale (and not the default — canonical content already lives there).",
7453 &headers,
7454 );
7455 };
7456 let locale_id = locale.id.get().copied().unwrap_or_default();
7457 let pages_for_tx = pages.clone();
7458 let (seeded_pages, seeded_fields) = rustango::atomic!(pool, |tx| {
7459 let mut guard = tx.lock().await?;
7460 let tx = &mut *guard;
7461 let mut sp = 0usize;
7462 let mut sf = 0usize;
7463 for p in &pages_for_tx {
7464 let Some(pid) = p.id.get().copied() else {
7465 continue;
7466 };
7467 let existing: Vec<crate::translation::Translation> =
7470 crate::translation::Translation::objects()
7471 .where_(crate::translation::Translation::page_id.eq(pid))
7472 .where_(crate::translation::Translation::locale_id.eq(locale_id))
7473 .fetch_tx(tx)
7474 .await?;
7475 let have: std::collections::HashSet<String> =
7476 existing.into_iter().map(|t| t.field_path).collect();
7477 let mut touched = false;
7478 for (path, value) in copy_fields_for(p) {
7479 if have.contains(path) {
7480 continue;
7481 }
7482 let mut row = crate::translation::Translation {
7483 id: rustango::sql::Auto::Unset,
7484 page_id: pid,
7485 locale_id,
7486 field_path: path.to_owned(),
7487 value,
7488 updated_at: rustango::sql::Auto::Unset,
7489 };
7490 row.save_tx(tx).await?;
7491 sf += 1;
7492 touched = true;
7493 }
7494 if touched {
7495 sp += 1;
7496 }
7497 }
7498 Ok::<_, rustango::sql::ExecError>((sp, sf))
7499 })
7500 .await?;
7501 let fields = super::i18n::tr_plural(
7504 &headers,
7505 "{count} field(s)",
7506 seeded_fields as i64,
7507 &[("count", &seeded_fields.to_string())],
7508 );
7509 let pages_ph = super::i18n::tr_plural(
7510 &headers,
7511 "{count} page(s)",
7512 seeded_pages as i64,
7513 &[("count", &seeded_pages.to_string())],
7514 );
7515 redirect_named_with_message_args(
7516 "rcms-admin:pages:list",
7517 MsgLevel::Success,
7518 "Seeded {fields} across {pages} into “{locale}”. Existing translations were left untouched.",
7519 &[
7520 ("fields", fields.as_str()),
7521 ("pages", pages_ph.as_str()),
7522 ("locale", locale.name.as_str()),
7523 ],
7524 &headers,
7525 )
7526 }
7527 "archive" | "unarchive" => {
7528 let archive = action == "archive";
7534 let plan =
7535 crate::page::plan_archive(pool, &pages, archive, archive_cascade).await?;
7536 let invalidator = _state.cache_invalidator.clone();
7537 let tenant_slug = tenant.org.slug.clone();
7538 let purge = plan.changed_urls.clone();
7539 let flips = plan.to_flip.clone();
7540 let touched = rustango::atomic!(pool, |tx| {
7541 let mut guard = tx.lock().await?;
7542 let tx = &mut *guard;
7543 let mut n = 0usize;
7544 for mut p in flips {
7545 p.save_tx(tx).await?;
7546 n += 1;
7547 }
7548 crate::cache_invalidate::invalidate_urls_on_commit(
7549 invalidator,
7550 tenant_slug,
7551 purge,
7552 );
7553 Ok::<usize, rustango::sql::ExecError>(n)
7554 })
7555 .await?;
7556 for p in &plan.to_flip {
7560 crate::revision::capture(pool, p, None)
7561 .await
7562 .log_warn("revision not captured; the history has a gap");
7563 crate::task_queue::sync_page_search(&tenant.org.slug, p).await;
7564 }
7565 let key = if archive {
7566 "Archived {count} page(s)."
7567 } else {
7568 "Unarchived {count} page(s)."
7569 };
7570 redirect_named_with_message_plural(
7571 "rcms-admin:pages:list",
7572 MsgLevel::Success,
7573 key,
7574 touched as i64,
7575 &[("count", &touched.to_string())],
7576 &headers,
7577 )
7578 }
7579 other => Err(AdminError::Validation(format!(
7580 "unknown bulk action `{other}` (expected publish / unpublish / archive / unarchive / delete / move / copy-to-locale)"
7581 ))),
7582 }
7583}
7584
7585pub async fn page_lock_release(
7593 tenant: Tenant,
7594 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7595 Path(id): Path<i64>,
7596) -> Result<Response, AdminError> {
7597 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7598 return Ok(unauthorized_no_session());
7599 };
7600 crate::lock::release(tenant.pool(), id, viewer_id).await?;
7601 Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
7602}
7603
7604pub async fn page_unlock_submit(
7605 State(_state): State<super::AdminState>,
7606 tenant: Tenant,
7607 headers: HeaderMap,
7608 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7609 Path(id): Path<i64>,
7610) -> Result<Response, AdminError> {
7611 let released = crate::lock::force_release(tenant.pool(), id).await?;
7612 let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
7613 let message = if let Some(row) = released {
7614 let holder = rustango::tenancy::auth::User::objects()
7615 .where_(rustango::tenancy::auth::User::id.eq(row.user_id))
7616 .fetch(tenant.pool())
7617 .await
7618 .ok()
7619 .and_then(|v| v.into_iter().next())
7620 .map(|u| u.username)
7621 .unwrap_or_else(|| format!("user#{}", row.user_id));
7622 crate::page_log::record_or_warn(
7624 tenant.pool(),
7625 id,
7626 crate::page_log::ACTION_FORCE_UNLOCK,
7627 actor_id,
7628 format!("Force-unlocked — “{holder}” no longer holds the editor lock."),
7629 Some(serde_json::json!({ "previous_holder_user_id": row.user_id })),
7630 )
7631 .await;
7632 format!("Lock released — “{holder}” no longer holds the editor lock on this page.")
7633 } else {
7634 "Lock was already released.".to_owned()
7635 };
7636 redirect_named_with_params_and_message(
7637 "rcms-admin:pages:edit",
7638 &[("id", id.to_string())],
7639 MsgLevel::Success,
7640 &message,
7641 &headers,
7642 )
7643}
7644
7645pub async fn page_subscribe_submit(
7650 State(_state): State<super::AdminState>,
7651 tenant: Tenant,
7652 headers: HeaderMap,
7653 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7654 Path(id): Path<i64>,
7655) -> Result<Response, AdminError> {
7656 let Some(viewer) = session_user.as_ref() else {
7657 return Ok(unauthorized_no_session());
7658 };
7659 let viewer_id = viewer.id.get().copied().unwrap_or_default();
7660 crate::page_subscription::subscribe(tenant.pool(), id, viewer_id).await?;
7661 redirect_named_with_params_and_message(
7662 "rcms-admin:pages:edit",
7663 &[("id", id.to_string())],
7664 MsgLevel::Success,
7665 "Subscribed — you'll get an email when this page publishes.",
7666 &headers,
7667 )
7668}
7669
7670pub async fn page_unsubscribe_submit(
7673 State(_state): State<super::AdminState>,
7674 tenant: Tenant,
7675 headers: HeaderMap,
7676 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7677 Path(id): Path<i64>,
7678) -> Result<Response, AdminError> {
7679 let Some(viewer) = session_user.as_ref() else {
7680 return Ok(unauthorized_no_session());
7681 };
7682 let viewer_id = viewer.id.get().copied().unwrap_or_default();
7683 crate::page_subscription::unsubscribe(tenant.pool(), id, viewer_id).await?;
7684 redirect_named_with_params_and_message(
7685 "rcms-admin:pages:edit",
7686 &[("id", id.to_string())],
7687 MsgLevel::Success,
7688 "Unsubscribed — you won't get future publish notifications for this page.",
7689 &headers,
7690 )
7691}
7692
7693async fn read_only_under_review(
7698 pool: &rustango::sql::Pool,
7699 page_id: i64,
7700 user: &rustango::tenancy::auth::User,
7701) -> Result<bool, AdminError> {
7702 if user.is_superuser {
7703 return Ok(false);
7704 }
7705 let Some(state) = crate::workflow::active_state_for_page(pool, page_id).await? else {
7706 return Ok(false);
7707 };
7708 if state.status != crate::workflow::WorkflowStatus::InProgress.as_str() {
7709 return Ok(false);
7710 }
7711 let tasks = crate::workflow::tasks_for(pool, state.workflow_id).await?;
7712 let Some(task) = state
7713 .current_task_id
7714 .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
7715 else {
7716 return Ok(false);
7717 };
7718 let uid = user.id.get().copied().unwrap_or_default();
7719 Ok(!user_is_in_role(pool, uid, task.role_id).await?)
7720}
7721
7722#[derive(Debug, Deserialize)]
7733pub struct HeartbeatQuery {
7734 #[serde(default)]
7735 pub is_editing: Option<String>,
7736}
7737
7738pub async fn page_lock_heartbeat(
7739 State(_state): State<super::AdminState>,
7740 tenant: Tenant,
7741 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7742 Path(id): Path<i64>,
7743 Query(q): Query<HeartbeatQuery>,
7744) -> Result<Response, AdminError> {
7745 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7746 return Ok(unauthorized_no_session());
7747 };
7748
7749 let is_editing = q.is_editing.as_deref() == Some("1");
7752 if let Err(e) = crate::editing_session::touch(tenant.pool(), id, viewer_id, is_editing).await {
7753 tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "editing-session touch failed (continuing)");
7754 }
7755 if rand::random::<u8>() < 5 {
7758 crate::editing_session::gc_stale(tenant.pool())
7759 .await
7760 .log_warn("stale editing sessions not collected");
7761 }
7762
7763 if let Some(u) = session_user.as_ref() {
7765 if read_only_under_review(tenant.pool(), id, u).await? {
7766 return Ok((axum::http::StatusCode::NO_CONTENT, "").into_response());
7767 }
7768 }
7769 match crate::lock::acquire(tenant.pool(), id, viewer_id, false).await {
7770 Ok(crate::lock::AcquireOutcome::Acquired(_)) => {
7771 Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
7772 }
7773 Ok(crate::lock::AcquireOutcome::Held(_)) => Ok((
7774 axum::http::StatusCode::CONFLICT,
7775 "lock held by another editor",
7776 )
7777 .into_response()),
7778 Err(e) => {
7779 tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "lock heartbeat failed");
7780 Err(e.into())
7781 }
7782 }
7783}
7784
7785pub async fn page_sessions_json(
7789 State(_state): State<super::AdminState>,
7790 tenant: Tenant,
7791 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7792 Path(id): Path<i64>,
7793) -> Result<Response, AdminError> {
7794 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7795 return Ok(unauthorized_no_session());
7796 };
7797 let others = crate::editing_session::others_on_page(tenant.pool(), id, viewer_id)
7798 .await
7799 .unwrap_or_default();
7800 if others.is_empty() {
7801 return Ok(([(header::CONTENT_TYPE, "application/json")], "[]").into_response());
7802 }
7803 let user_ids: Vec<i64> = others.iter().map(|s| s.user_id).collect();
7805 let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
7806 .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
7807 .fetch(tenant.pool())
7808 .await
7809 .unwrap_or_default();
7810 let username_by_id: std::collections::HashMap<i64, String> = users
7811 .into_iter()
7812 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
7813 .collect();
7814 let payload: Vec<serde_json::Value> = others
7815 .iter()
7816 .map(|s| {
7817 serde_json::json!({
7818 "user_id": s.user_id,
7819 "username": username_by_id.get(&s.user_id).cloned(),
7820 "last_seen_at": s.last_seen_at,
7821 "is_editing": s.is_editing,
7822 })
7823 })
7824 .collect();
7825 let body = serde_json::to_string(&payload).unwrap_or_else(|_| "[]".to_owned());
7826 Ok(([(header::CONTENT_TYPE, "application/json")], body).into_response())
7827}
7828
7829async fn unique_sibling_slug(
7833 pool: &rustango::sql::Pool,
7834 parent_id: Option<i64>,
7835 desired: &str,
7836) -> Result<String, AdminError> {
7837 use rustango::core::Column as _;
7838 let qs = Page::objects().order_by(&[("slug", false)]);
7839 let siblings: Vec<Page> = match parent_id {
7840 Some(pid) => qs.where_(Page::parent_id.eq(pid)).fetch(pool).await?,
7841 None => qs.where_(Page::parent_id.is_null()).fetch(pool).await?,
7842 };
7843 let taken: std::collections::HashSet<String> = siblings.into_iter().map(|p| p.slug).collect();
7844 if !taken.contains(desired) {
7845 return Ok(desired.to_owned());
7846 }
7847 for n in 2..=100 {
7848 let candidate = format!("{desired}-{n}");
7849 if !taken.contains(&candidate) {
7850 return Ok(candidate);
7851 }
7852 }
7853 Err(AdminError::Validation(
7854 "Could not allocate a unique slug for the clone — over 100 siblings share the same base."
7855 .to_owned(),
7856 ))
7857}
7858
7859pub async fn page_revert_submit(
7868 State(_state): State<super::AdminState>,
7869 tenant: Tenant,
7870 headers: HeaderMap,
7871 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7872 Path((id, rev_id)): Path<(i64, i64)>,
7873) -> Result<Response, AdminError> {
7874 let mut page = Page::objects()
7875 .where_(Page::id.eq(id))
7876 .first(tenant.pool())
7877 .await?
7878 .ok_or(AdminError::NotFound(id))?;
7879 let rev = crate::revision::Revision::objects()
7880 .where_(crate::revision::Revision::id.eq(rev_id))
7881 .where_(crate::revision::Revision::page_id.eq(id))
7882 .first(tenant.pool())
7883 .await?
7884 .ok_or(AdminError::NotFound(rev_id))?;
7885
7886 let snapshot: Page = match serde_json::from_value(rev.snapshot.clone()) {
7891 Ok(p) => p,
7892 Err(e) => {
7893 return Ok((
7894 axum::http::StatusCode::BAD_REQUEST,
7895 format!("revision snapshot could not be decoded: {e}"),
7896 )
7897 .into_response());
7898 }
7899 };
7900
7901 let old_url_path = page.url_path.clone();
7902 page.title = snapshot.title;
7903 page.page_type_id = snapshot.page_type_id;
7904 page.status = snapshot.status;
7905 page.published_at = snapshot.published_at;
7906 page.go_live_at = snapshot.go_live_at;
7907 page.expire_at = snapshot.expire_at;
7908 page.seo_title = snapshot.seo_title;
7909 page.seo_description = snapshot.seo_description;
7910 page.robots_index = snapshot.robots_index;
7911 page.sitemap_priority = snapshot.sitemap_priority;
7912
7913 let mut tx = transaction_pool(tenant.pool()).await?;
7914 page.save_tx(&mut tx).await?;
7915 tx.commit().await?;
7916 crate::revision::capture(tenant.pool(), &page, None)
7917 .await
7918 .log_warn("revision not captured; the history has a gap");
7919
7920 let _ = old_url_path; let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
7923 crate::page_log::record_or_warn(
7924 tenant.pool(),
7925 id,
7926 crate::page_log::ACTION_RESTORE,
7927 actor_id,
7928 format!("Reverted to revision #{}.", rev.sequence),
7929 Some(serde_json::json!({ "revision_id": rev_id, "sequence": rev.sequence })),
7930 )
7931 .await;
7932 let sequence_str = rev.sequence.to_string();
7933 redirect_named_with_params_and_message_args(
7934 "rcms-admin:pages:edit",
7935 &[("id", id.to_string())],
7936 MsgLevel::Success,
7937 "Reverted to revision #{sequence}.",
7938 &[("sequence", sequence_str.as_str())],
7939 &headers,
7940 )
7941}
7942
7943fn stamp_no_cache(mut response: Response) -> Response {
7952 let h = response.headers_mut();
7953 h.insert(
7954 header::CACHE_CONTROL,
7955 HeaderValue::from_static("no-store, no-cache, must-revalidate, max-age=0"),
7956 );
7957 h.insert(header::PRAGMA, HeaderValue::from_static("no-cache"));
7958 h.insert(header::EXPIRES, HeaderValue::from_static("0"));
7959 h.insert(header::VARY, HeaderValue::from_static("*"));
7962 h.insert(
7965 header::X_FRAME_OPTIONS,
7966 HeaderValue::from_static("SAMEORIGIN"),
7967 );
7968 response
7969}
7970
7971async fn inject_axe_into_preview(response: Response) -> Response {
7984 let is_html = response
7986 .headers()
7987 .get(header::CONTENT_TYPE)
7988 .and_then(|v| v.to_str().ok())
7989 .is_some_and(|ct| ct.to_ascii_lowercase().contains("text/html"));
7990 if !is_html {
7991 return response;
7992 }
7993 let (parts, body) = response.into_parts();
7994 let bytes = match axum::body::to_bytes(body, 4 * 1024 * 1024).await {
7997 Ok(b) => b,
7998 Err(_) => {
7999 return (
8002 axum::http::StatusCode::INTERNAL_SERVER_ERROR,
8003 "preview body read failed",
8004 )
8005 .into_response();
8006 }
8007 };
8008 let body_str = match std::str::from_utf8(&bytes) {
8009 Ok(s) => s,
8010 Err(_) => {
8011 return axum::http::Response::from_parts(parts, axum::body::Body::from(bytes));
8013 }
8014 };
8015 let new_body = inject_axe_into_body_str(body_str);
8016 let mut resp = axum::http::Response::from_parts(parts, axum::body::Body::from(new_body));
8019 resp.headers_mut().remove(header::CONTENT_LENGTH);
8020 resp
8021}
8022
8023fn inject_axe_into_body_str(body: &str) -> String {
8030 let v = super::cms_asset_version();
8034 let scripts = format!(
8035 "<script src=\"/cms-admin/static/vendor/axe-core.min.js?v={v}\" defer></script>\n\
8036 <script src=\"/cms-admin/static/cms-preview-guard.js?v={v}\" defer></script>\n\
8037 <script src=\"/cms-admin/static/cms-axe-preview.js?v={v}\" defer></script>\n"
8038 );
8039 let lower = body.to_ascii_lowercase();
8040 if let Some(idx) = lower.rfind("</body>") {
8041 let mut out = String::with_capacity(body.len() + scripts.len());
8042 out.push_str(&body[..idx]);
8043 out.push_str(&scripts);
8044 out.push_str(&body[idx..]);
8045 out
8046 } else {
8047 let mut out = String::with_capacity(body.len() + scripts.len());
8048 out.push_str(body);
8049 out.push_str(&scripts);
8050 out
8051 }
8052}
8053
8054#[cfg(test)]
8055mod axe_injection_tests {
8056 use super::inject_axe_into_body_str;
8057
8058 #[test]
8059 fn splices_before_lowercase_body_close() {
8060 let html = "<html><body><h1>hi</h1></body></html>";
8061 let out = inject_axe_into_body_str(html);
8062 assert!(out.contains("axe-core.min.js"), "axe script missing: {out}");
8063 assert!(
8064 out.contains("cms-axe-preview.js"),
8065 "glue script missing: {out}"
8066 );
8067 assert!(
8068 out.contains("cms-preview-guard.js"),
8069 "preview-guard script missing: {out}"
8070 );
8071 let close = out.find("</body>").expect("body close kept");
8073 assert!(
8074 out[..close].contains("axe-core.min.js"),
8075 "axe script should be before </body>: {out}"
8076 );
8077 assert!(
8078 out[..close].contains("cms-axe-preview.js"),
8079 "glue script should be before </body>: {out}"
8080 );
8081 }
8082
8083 #[test]
8084 fn splices_before_uppercase_body_close() {
8085 let html = "<HTML><BODY><h1>hi</h1></BODY></HTML>";
8086 let out = inject_axe_into_body_str(html);
8087 let close = out.find("</BODY>").expect("uppercase body close kept");
8090 assert!(out[..close].contains("axe-core.min.js"));
8091 }
8092
8093 #[test]
8094 fn appends_when_no_body_close() {
8095 let html = "<html><h1>hi</h1>";
8096 let out = inject_axe_into_body_str(html);
8097 assert!(out.contains("cms-axe-preview.js?v="));
8100 assert!(out.trim_end().ends_with("defer></script>"));
8101 assert!(out.contains("axe-core.min.js"));
8102 assert!(out.starts_with("<html><h1>hi</h1>"));
8104 }
8105
8106 #[test]
8107 fn uses_rfind_for_nested_body_close_text() {
8108 let html = "<html><body><pre>literal: </body></pre></body></html>";
8112 let out = inject_axe_into_body_str(html);
8113 let close = out.rfind("</body>").unwrap();
8114 assert!(out[..close].contains("axe-core.min.js"));
8115 assert!(out.contains("literal: </body>"));
8117 }
8118
8119 #[test]
8120 fn empty_body_renders_clean() {
8121 let out = inject_axe_into_body_str("");
8122 assert!(out.contains("axe-core.min.js"));
8124 assert!(out.contains("cms-axe-preview.js"));
8125 }
8126}
8127
8128#[derive(serde::Deserialize, Default)]
8132pub struct PreviewLocaleQuery {
8133 #[serde(default)]
8134 locale: Option<String>,
8135 #[serde(default)]
8142 format: Option<String>,
8143}
8144
8145fn preview_tera(state: &super::AdminState, tenant: &Tenant) -> std::sync::Arc<tera::Tera> {
8160 crate::tenant_templates::installed()
8161 .map(|tt| tt.for_tenant(&tenant.org.slug))
8162 .unwrap_or_else(|| state.tera.clone())
8163}
8164
8165pub async fn page_preview(
8171 State(state): State<super::AdminState>,
8172 tenant: Tenant,
8173 Path(id): Path<i64>,
8174 axum::extract::Query(q): axum::extract::Query<PreviewLocaleQuery>,
8175) -> Result<Response, AdminError> {
8176 let page = Page::objects()
8177 .where_(Page::id.eq(id))
8178 .first(tenant.pool())
8179 .await?
8180 .ok_or(AdminError::NotFound(id))?;
8181 let response = crate::render::render(
8182 &tenant,
8183 &preview_tera(&state, &tenant),
8184 &page,
8185 "",
8186 "",
8189 q.locale.as_deref(),
8190 None,
8191 None,
8192 )
8193 .await;
8194 Ok(stamp_no_cache(inject_axe_into_preview(response).await))
8198}
8199
8200pub async fn page_preview_token(
8206 tenant: Tenant,
8207 Path(id): Path<i64>,
8208) -> Result<Response, AdminError> {
8209 let exists = Page::objects()
8210 .where_(Page::id.eq(id))
8211 .first(tenant.pool())
8212 .await?
8213 .is_some();
8214 if !exists {
8215 return Err(AdminError::NotFound(id));
8216 }
8217 let expires = chrono::Utc::now().timestamp() + PREVIEW_TOKEN_TTL_SECS;
8220 match crate::preview_token::mint(&tenant.org.slug, id, expires) {
8221 Some(token) => Ok(Json(serde_json::json!({
8222 "token": token,
8223 "expires_at": expires,
8224 "api_path": format!("/api/v2/pages/{id}/?preview_token={token}"),
8225 }))
8226 .into_response()),
8227 None => Err(AdminError::Validation(
8228 "Preview tokens are disabled — set RCMS_SECRET_KEY to enable headless draft preview."
8229 .to_owned(),
8230 )),
8231 }
8232}
8233
8234pub async fn page_preview_draft(
8239 State(state): State<super::AdminState>,
8240 tenant: Tenant,
8241 Path(id): Path<i64>,
8242 axum::extract::Query(q): axum::extract::Query<PreviewLocaleQuery>,
8243 headers: HeaderMap,
8244 Form(form_map): Form<std::collections::HashMap<String, String>>,
8245) -> Result<Response, AdminError> {
8246 let mut page = Page::objects()
8247 .where_(Page::id.eq(id))
8248 .first(tenant.pool())
8249 .await?
8250 .ok_or(AdminError::NotFound(id))?;
8251
8252 if let Some(v) = form_map.get("title") {
8256 page.title = v.clone();
8257 }
8258 if let Some(v) = form_map.get("slug") {
8259 page.slug = v.clone();
8260 }
8261 if let Some(v) = form_map
8262 .get("page_type_id")
8263 .and_then(|s| s.parse::<i64>().ok())
8264 {
8265 page.page_type_id = v;
8266 }
8267 if let Some(v) = form_map.get("status") {
8268 page.status = v.clone();
8269 }
8270 if let Some(v) = form_map.get("seo_title") {
8271 page.seo_title = v.clone();
8272 }
8273 if let Some(v) = form_map.get("seo_description") {
8274 page.seo_description = v.clone();
8275 }
8276 page.robots_index = form_map
8278 .get("robots_index")
8279 .map(|v| matches!(v.as_str(), "on" | "true" | "1"))
8280 .unwrap_or(page.robots_index);
8281 if let Some(v) = form_map
8282 .get("sitemap_priority")
8283 .and_then(|s| s.parse::<f32>().ok())
8284 {
8285 page.sitemap_priority = v;
8286 }
8287 if let Some(raw) = form_map.get("theme_id") {
8288 page.theme_id = if raw.is_empty() || raw == "0" {
8289 None
8290 } else {
8291 raw.parse::<i64>().ok()
8292 };
8293 }
8294
8295 let accept = crate::page_view::parse_accept(
8300 headers
8301 .get(axum::http::header::ACCEPT)
8302 .and_then(|v| v.to_str().ok()),
8303 );
8304 let force_json = q.format.as_deref() == Some("json");
8305 let response = crate::render::render_preview(
8306 &tenant,
8307 &preview_tera(&state, &tenant),
8308 &page,
8309 "",
8310 "",
8312 q.locale.as_deref(),
8313 &form_map,
8314 accept,
8315 force_json,
8316 )
8317 .await;
8318 Ok(stamp_no_cache(inject_axe_into_preview(response).await))
8322}
8323
8324#[derive(Debug, Deserialize, Default)]
8333pub struct LibraryListQuery {
8334 #[serde(default)]
8337 pub r#type: Option<String>,
8338 #[serde(default)]
8340 pub folder: Option<String>,
8341 #[serde(default)]
8344 pub q: Option<String>,
8345 #[serde(default)]
8347 pub page: Option<u32>,
8348 #[serde(default)]
8351 pub per_page: Option<usize>,
8352 #[serde(flatten)]
8355 pub raw_filters: std::collections::HashMap<String, String>,
8356}
8357
8358pub async fn library_list(
8359 State(state): State<super::AdminState>,
8360 tenant: Tenant,
8361 headers: HeaderMap,
8362 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8363 Query(q): Query<LibraryListQuery>,
8364 axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
8365) -> Result<Response, AdminError> {
8366 let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8371 .order_by(&[("type_name", false)])
8372 .fetch(tenant.pool())
8373 .await?
8374 .into_iter()
8375 .filter(|t| t.type_name != "form")
8376 .collect();
8377 let all_snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
8378 .fetch(tenant.pool())
8379 .await?;
8380 let mut counts_by_type: std::collections::HashMap<String, i64> =
8381 std::collections::HashMap::new();
8382 for s in &all_snippets {
8383 *counts_by_type.entry(s.type_name.clone()).or_default() += 1;
8384 }
8385
8386 let mut ctx = Context::new();
8387 add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8388 add_admin_theme(&mut ctx, tenant.pool()).await;
8389 ctx.insert("query_string", &raw_query.unwrap_or_default());
8392 ctx.insert("types", &types);
8393 ctx.insert("counts_by_type", &counts_by_type);
8394
8395 let Some(type_name) = q.r#type.as_deref().filter(|s| !s.is_empty()) else {
8397 ctx.insert("mode", "overview");
8398 return render_with_csrf(&state, &headers, "rcms_admin/library_list.html", &mut ctx);
8399 };
8400
8401 let handler = crate::library::find_handler(type_name);
8404 let list_display = handler
8405 .as_ref()
8406 .map(|h| h.list_display())
8407 .unwrap_or_else(|| {
8408 vec![
8409 crate::library::ListColumn::Field {
8410 column: "title",
8411 label: "Title",
8412 },
8413 crate::library::ListColumn::Field {
8414 column: "slug",
8415 label: "Slug",
8416 },
8417 crate::library::ListColumn::Field {
8418 column: "updated_at",
8419 label: "Updated",
8420 },
8421 ]
8422 });
8423 let search_fields = handler
8424 .as_ref()
8425 .map(|h| h.search_fields())
8426 .unwrap_or_else(|| vec!["title", "slug"]);
8427 let filter_keys = handler
8428 .as_ref()
8429 .map(|h| h.list_filter())
8430 .unwrap_or_default();
8431
8432 let folder = crate::snippet::normalize_folder(q.folder.as_deref().unwrap_or(""));
8436 let child_folders = crate::snippet::child_folders(tenant.pool(), &folder)
8437 .await
8438 .unwrap_or_default();
8439
8440 let mut filtered: Vec<crate::snippet::Snippet> = all_snippets
8444 .iter()
8445 .filter(|s| s.type_name == type_name && s.folder_path == folder)
8446 .filter(|s| handler.as_ref().map(|h| h.can_view(s)).unwrap_or(true))
8447 .cloned()
8448 .collect();
8449
8450 let search_q = q.q.as_deref().map(|s| s.trim()).filter(|s| !s.is_empty());
8452 if let Some(needle) = search_q {
8453 let needle_lower = needle.to_lowercase();
8454 filtered.retain(|s| {
8455 search_fields.iter().any(|field| {
8456 let hay = match *field {
8457 "title" => s.title.to_lowercase(),
8458 "slug" => s.slug.to_lowercase(),
8459 "body_markdown" => s.body_markdown.to_lowercase(),
8460 other => s
8461 .data
8462 .get(other)
8463 .and_then(serde_json::Value::as_str)
8464 .map(str::to_lowercase)
8465 .unwrap_or_default(),
8466 };
8467 hay.contains(&needle_lower)
8468 })
8469 });
8470 }
8471
8472 let mut active_filters: std::collections::HashMap<String, String> =
8475 std::collections::HashMap::new();
8476 for (k, v) in &q.raw_filters {
8477 if let Some(stripped) = k.strip_prefix("filter_") {
8478 if !v.is_empty() {
8479 active_filters.insert(stripped.to_owned(), v.clone());
8480 }
8481 }
8482 }
8483 if !active_filters.is_empty() {
8484 filtered.retain(|s| {
8485 active_filters.iter().all(|(key, want)| {
8486 let got = s
8487 .data
8488 .get(key)
8489 .map(|v| match v {
8490 serde_json::Value::String(s) => s.clone(),
8491 other => other.to_string(),
8492 })
8493 .unwrap_or_default();
8494 got == *want
8495 })
8496 });
8497 }
8498
8499 let filter_options: std::collections::HashMap<String, Vec<String>> = filter_keys
8501 .iter()
8502 .map(|k| {
8503 let mut opts: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
8504 for s in &all_snippets {
8505 if s.type_name != type_name {
8506 continue;
8507 }
8508 if let Some(v) = s.data.get(*k) {
8509 let s = match v {
8510 serde_json::Value::String(s) => s.clone(),
8511 other => other.to_string(),
8512 };
8513 if !s.is_empty() {
8514 opts.insert(s);
8515 }
8516 }
8517 }
8518 ((*k).to_owned(), opts.into_iter().collect())
8519 })
8520 .collect();
8521
8522 let total = filtered.len();
8528 let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
8529 let paginator = rustango::pagination::Paginator::new(total, page_size);
8530 let requested_page = q.page.unwrap_or(1).max(1) as i64;
8531 let page_obj = paginator.get_page(requested_page);
8532 let page = page_obj.number;
8533 let total_pages = paginator.num_pages().max(1);
8534 let page_rows: Vec<crate::snippet::Snippet> = if total == 0 {
8535 Vec::new()
8536 } else {
8537 let start = page_obj.start_index().saturating_sub(1);
8538 let end = page_obj.end_index();
8539 filtered[start..end].to_vec()
8540 };
8541
8542 let column_headers: Vec<serde_json::Value> = list_display
8546 .iter()
8547 .map(|c| {
8548 serde_json::json!({
8549 "key": c.key(),
8550 "label": c.label(),
8551 })
8552 })
8553 .collect();
8554 let rows_html: Vec<serde_json::Value> = page_rows
8555 .iter()
8556 .map(|row| {
8557 let cells: Vec<String> = list_display
8558 .iter()
8559 .map(|c| render_list_cell(c, row, handler.as_deref()))
8560 .collect();
8561 serde_json::json!({
8562 "id": row.id.get().copied().unwrap_or_default(),
8563 "slug": row.slug,
8564 "cells": cells,
8565 })
8566 })
8567 .collect();
8568
8569 let active_filters_json: Vec<serde_json::Value> = active_filters
8570 .iter()
8571 .map(|(k, v)| serde_json::json!({ "key": k, "value": v }))
8572 .collect();
8573
8574 let bulk_actions: Vec<serde_json::Value> = handler
8577 .as_ref()
8578 .map(|h| h.bulk_actions())
8579 .unwrap_or_default()
8580 .iter()
8581 .map(serialize_bulk_action)
8582 .collect();
8583 let row_actions: Vec<serde_json::Value> = handler
8584 .as_ref()
8585 .map(|h| h.row_actions())
8586 .unwrap_or_default()
8587 .iter()
8588 .map(serialize_bulk_action)
8589 .collect();
8590
8591 let plugin_bulk_actions: Vec<serde_json::Value> = crate::hooks::bulk_actions_for("cms_snippet")
8593 .into_iter()
8594 .map(|a| {
8595 serde_json::json!({
8596 "key": a.key,
8597 "label": a.label,
8598 "icon": a.icon,
8599 "danger": a.danger,
8600 "confirm_message": a.confirm_message,
8601 "action_url": a.action_url,
8602 })
8603 })
8604 .collect();
8605
8606 let folder_tree_paths = crate::snippet::folder_tree_for_type(tenant.pool(), type_name)
8611 .await
8612 .unwrap_or_default();
8613 let folder_tree: Vec<serde_json::Value> = folder_tree_paths
8614 .iter()
8615 .map(|p| {
8616 let depth = p.matches('/').count(); let display = if p.is_empty() {
8618 "Root".to_owned()
8619 } else {
8620 p.trim_end_matches('/')
8622 .rsplit('/')
8623 .next()
8624 .unwrap_or("")
8625 .to_owned()
8626 };
8627 serde_json::json!({
8628 "path": p,
8629 "name": display,
8630 "depth": depth,
8631 "active": *p == folder,
8632 })
8633 })
8634 .collect();
8635
8636 ctx.insert("mode", "type");
8637 ctx.insert("active_type", type_name);
8638 ctx.insert("folder", &folder);
8639 ctx.insert("child_folders", &child_folders);
8640 ctx.insert("folder_tree", &folder_tree);
8641 ctx.insert("column_headers", &column_headers);
8642 ctx.insert("rows", &rows_html);
8643 ctx.insert("plugin_bulk_actions", &plugin_bulk_actions);
8644 ctx.insert("page", &page);
8645 ctx.insert("total_pages", &total_pages);
8646 ctx.insert(
8649 "pagination",
8650 &crate::admin::pagination::context(page as i64, page_size, total),
8651 );
8652 ctx.insert("total", &total);
8653 ctx.insert("page_size", &page_size);
8654 ctx.insert("search_q", &search_q.unwrap_or(""));
8655 ctx.insert("filter_keys", &filter_keys);
8656 ctx.insert("filter_options", &filter_options);
8657 ctx.insert("active_filters", &active_filters_json);
8658 ctx.insert("bulk_actions", &bulk_actions);
8659 ctx.insert("row_actions", &row_actions);
8660 render_with_csrf(&state, &headers, "rcms_admin/library_list.html", &mut ctx)
8661}
8662
8663fn serialize_bulk_action(a: &crate::library::BulkAction) -> serde_json::Value {
8665 use crate::library::BulkActionStyle;
8666 let style_class = match a.style {
8667 BulkActionStyle::Primary => "btn",
8668 BulkActionStyle::Outlined => "btn btn-outlined",
8669 BulkActionStyle::Danger => "btn btn-danger",
8670 };
8671 serde_json::json!({
8672 "name": a.name,
8673 "label": a.label,
8674 "icon": a.icon,
8675 "confirm_message": a.confirm_message,
8676 "style_class": style_class,
8677 })
8678}
8679
8680pub async fn library_bulk_submit(
8686 State(_state): State<super::AdminState>,
8687 tenant: Tenant,
8688 headers: HeaderMap,
8689 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
8690 Path(type_name): Path<String>,
8691 Form(form): Form<Vec<(String, String)>>,
8692) -> Result<Response, AdminError> {
8693 let action = form
8694 .iter()
8695 .find(|(k, _)| k == "action")
8696 .map(|(_, v)| v.clone())
8697 .unwrap_or_default();
8698 let ids: Vec<i64> = form
8699 .iter()
8700 .filter(|(k, _)| k == "ids" || k == "id")
8701 .filter_map(|(_, v)| v.parse::<i64>().ok())
8702 .collect();
8703 if action.is_empty() || ids.is_empty() {
8704 return redirect_named_with_message(
8705 "rcms-admin:library:list",
8706 MsgLevel::Warning,
8707 "Pick at least one row + a bulk action before submitting.",
8708 &headers,
8709 );
8710 }
8711 let Some(handler) = crate::library::find_handler(&type_name) else {
8712 return Err(AdminError::Validation(format!(
8713 "unknown library type `{type_name}`"
8714 )));
8715 };
8716 let declared: std::collections::HashSet<&'static str> = handler
8719 .bulk_actions()
8720 .iter()
8721 .chain(handler.row_actions().iter())
8722 .map(|a| a.name)
8723 .collect();
8724 if !declared.contains(action.as_str()) {
8725 return Err(AdminError::Validation(format!(
8726 "library type `{type_name}` doesn't declare bulk action `{action}`"
8727 )));
8728 }
8729 let touched = handler
8730 .handle_bulk_action(tenant.pool(), &action, &ids)
8731 .await?;
8732 let count = touched.to_string();
8733 redirect_named_with_message_plural(
8734 "rcms-admin:library:list",
8735 MsgLevel::Success,
8736 "{action}: touched {count} row(s) in `{type_name}`.",
8737 touched as i64,
8738 &[
8739 ("action", action.as_str()),
8740 ("count", count.as_str()),
8741 ("type_name", type_name.as_str()),
8742 ],
8743 &headers,
8744 )
8745}
8746
8747fn render_list_cell(
8753 col: &crate::library::ListColumn,
8754 row: &crate::snippet::Snippet,
8755 handler: Option<&dyn crate::library::LibraryTypeHandler>,
8756) -> String {
8757 use crate::library::{ListColumn, ListColumnKind};
8758 match col {
8759 ListColumn::Field { column, .. } => match *column {
8760 "id" => row.id.get().copied().unwrap_or_default().to_string(),
8761 "type_name" => html_escape(&row.type_name),
8762 "slug" => format!("<code>{}</code>", html_escape(&row.slug)),
8763 "folder_path" => html_escape(&row.folder_path),
8764 "title" => format!("<strong>{}</strong>", html_escape(&row.title)),
8765 "body_markdown" => {
8766 let preview: String = row.body_markdown.chars().take(80).collect();
8767 format!("<span>{}</span>", html_escape(&preview))
8768 }
8769 "created_at" => row
8770 .created_at
8771 .get()
8772 .map(|d| d.format("%Y-%m-%d").to_string())
8773 .unwrap_or_default(),
8774 "updated_at" => row
8775 .updated_at
8776 .get()
8777 .map(|d| d.format("%Y-%m-%d").to_string())
8778 .unwrap_or_default(),
8779 other => format!("<em>(unknown field: {})</em>", html_escape(other)),
8780 },
8781 ListColumn::JsonField { key, kind, .. } => {
8782 let val = row.data.get(*key);
8783 match (kind, val) {
8784 (ListColumnKind::Bool, Some(serde_json::Value::Bool(b))) => bool_checkbox_html(*b),
8785 (_, Some(serde_json::Value::Bool(b))) => bool_checkbox_html(*b),
8786 (ListColumnKind::Integer, Some(serde_json::Value::Number(n)))
8787 | (ListColumnKind::Float, Some(serde_json::Value::Number(n))) => {
8788 html_escape(&n.to_string())
8789 }
8790 (_, Some(serde_json::Value::String(s))) => html_escape(s),
8791 (_, Some(other)) => html_escape(&other.to_string()),
8792 (_, None) => String::new(),
8793 }
8794 }
8795 ListColumn::Method { name, .. } | ListColumn::Computed { name, .. } => handler
8796 .map(|h| h.render_cell(name, row))
8797 .unwrap_or_default(),
8798 }
8799}
8800
8801fn html_escape(s: &str) -> String {
8802 s.replace('&', "&")
8803 .replace('<', "<")
8804 .replace('>', ">")
8805 .replace('"', """)
8806}
8807
8808fn bool_checkbox_html(b: bool) -> String {
8809 if b {
8810 r#"<span class="material-symbols-rounded sm filled" style="color: var(--accent);" aria-label="true">check_box</span>"#.to_owned()
8811 } else {
8812 r#"<span class="material-symbols-rounded sm" style="color: var(--muted-2);" aria-label="false">check_box_outline_blank</span>"#.to_owned()
8813 }
8814}
8815
8816#[derive(Debug, Deserialize)]
8820pub struct SnippetNewQuery {
8821 #[serde(default)]
8822 pub r#type: Option<String>,
8823 #[serde(default)]
8824 pub folder: Option<String>,
8825}
8826
8827pub async fn snippet_new_form(
8828 State(state): State<super::AdminState>,
8829 tenant: Tenant,
8830 headers: HeaderMap,
8831 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8832 Query(q): Query<SnippetNewQuery>,
8833) -> Result<Response, AdminError> {
8834 let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8835 .order_by(&[("type_name", false)])
8836 .fetch(tenant.pool())
8837 .await?;
8838 let mut ctx = Context::new();
8839 add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8840 add_admin_theme(&mut ctx, tenant.pool()).await;
8841 ctx.insert("mode", "new");
8842 ctx.insert("types", &types);
8843 ctx.insert("preselect_type", &q.r#type.unwrap_or_default());
8844 let folder = q.folder.unwrap_or_default();
8845 ctx.insert(
8846 "snippet",
8847 &serde_json::json!({
8848 "type_name": "",
8849 "slug": "",
8850 "title": "",
8851 "body_markdown": "",
8852 "folder_path": folder,
8853 }),
8854 );
8855 render_with_csrf(&state, &headers, "rcms_admin/snippet_form.html", &mut ctx)
8856}
8857
8858pub async fn snippet_edit_form(
8859 State(state): State<super::AdminState>,
8860 tenant: Tenant,
8861 headers: HeaderMap,
8862 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8863 Path(id): Path<i64>,
8864 Query(q): Query<EditQuery>,
8865) -> Result<Response, AdminError> {
8866 let snippet = crate::snippet::Snippet::objects()
8867 .where_(crate::snippet::Snippet::id.eq(id))
8868 .first(tenant.pool())
8869 .await?
8870 .ok_or(AdminError::NotFound(id))?;
8871 if snippet.type_name == "form" {
8875 let url = rustango::urls::reverse_owned(
8876 "rcms-admin:forms:build",
8877 &std::collections::HashMap::from([("id".to_owned(), id.to_string())]),
8878 )
8879 .map_err(|e| AdminError::Validation(format!("url reversal failed: {e}")))?;
8880 return Ok(axum::response::Redirect::to(&url).into_response());
8881 }
8882 let handler = crate::library::find_handler(&snippet.type_name);
8887 if let Some(h) = handler.as_ref() {
8888 if !h.can_view(&snippet) {
8889 return Err(AdminError::NotFound(id));
8890 }
8891 }
8892 let read_only = handler
8893 .as_ref()
8894 .map(|h| !h.can_edit(&snippet))
8895 .unwrap_or(false);
8896 let can_delete = handler
8897 .as_ref()
8898 .map(|h| h.can_delete(&snippet))
8899 .unwrap_or(true);
8900 let template_path = handler
8903 .as_ref()
8904 .and_then(|h| h.edit_template())
8905 .unwrap_or("rcms_admin/snippet_form.html");
8906
8907 let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8908 .order_by(&[("type_name", false)])
8909 .fetch(tenant.pool())
8910 .await?;
8911 let mut ctx = Context::new();
8912 add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8913 add_admin_theme(&mut ctx, tenant.pool()).await;
8914 ctx.insert("mode", "edit");
8915 ctx.insert("types", &types);
8916 ctx.insert("snippet", &snippet);
8917 ctx.insert("read_only", &read_only);
8918 ctx.insert("can_delete", &can_delete);
8919 ctx.insert(
8923 "allows_element_template",
8924 &handler
8925 .as_ref()
8926 .map(|h| h.allows_element_template())
8927 .unwrap_or(false),
8928 );
8929 let revisions_enabled = handler.as_ref().is_some_and(|h| h.revisions_enabled());
8933 let preview_enabled = handler.as_ref().is_some_and(|h| h.preview_enabled());
8934 let revisions: Vec<crate::snippet::SnippetRevision> = if revisions_enabled {
8935 crate::snippet::revisions_for(tenant.pool(), id)
8936 .await
8937 .unwrap_or_default()
8938 } else {
8939 Vec::new()
8940 };
8941 ctx.insert("revisions_enabled", &revisions_enabled);
8942 ctx.insert("preview_enabled", &preview_enabled);
8943 ctx.insert("snippet_revisions", &revisions);
8944 let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
8948 .where_(crate::locale::Locale::active.eq(true))
8949 .order_by(&[("sort_order", false), ("code", false)])
8950 .fetch(tenant.pool())
8951 .await?;
8952 let editing_locale = q
8953 .locale
8954 .as_deref()
8955 .filter(|c| !c.is_empty())
8956 .and_then(|code| locales.iter().find(|l| l.code == code).cloned());
8957 let translation_mode = editing_locale.as_ref().is_some_and(|l| !l.is_default);
8958 let mut core_translations: std::collections::HashMap<String, String> =
8959 std::collections::HashMap::new();
8960 let mut extra_translations: Vec<(String, String)> = Vec::new();
8961 if translation_mode {
8962 let lid = editing_locale
8963 .as_ref()
8964 .and_then(|l| l.id.get().copied())
8965 .unwrap_or_default();
8966 let existing = crate::snippet_translation::fetch_for(tenant.pool(), id, lid)
8967 .await
8968 .unwrap_or_default();
8969 let core_keys = ["title", "body_markdown"];
8970 core_translations = core_keys
8971 .iter()
8972 .map(|k| {
8973 (
8974 (*k).to_owned(),
8975 existing.get(*k).cloned().unwrap_or_default(),
8976 )
8977 })
8978 .collect();
8979 extra_translations = existing
8980 .iter()
8981 .filter(|(k, _)| !core_keys.contains(&k.as_str()))
8982 .map(|(k, v)| (k.clone(), v.clone()))
8983 .collect();
8984 }
8985 ctx.insert("locales", &locales);
8986 ctx.insert("editing_locale", &editing_locale);
8987 ctx.insert("translation_mode", &translation_mode);
8988 ctx.insert("core_translations", &core_translations);
8989 ctx.insert("extra_translations", &extra_translations);
8990 render_with_csrf(&state, &headers, template_path, &mut ctx)
8991}
8992
8993pub async fn snippet_translate_submit(
8999 State(_state): State<super::AdminState>,
9000 tenant: Tenant,
9001 Path(id): Path<i64>,
9002 Query(q): Query<EditQuery>,
9003 Form(form): Form<std::collections::HashMap<String, String>>,
9004) -> Result<Response, AdminError> {
9005 use crate::snippet_translation::SnippetTranslation;
9006 let code = q
9007 .locale
9008 .as_deref()
9009 .filter(|c| !c.is_empty())
9010 .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
9011 let locale = crate::locale::Locale::objects()
9012 .where_(crate::locale::Locale::code.eq(code.to_owned()))
9013 .where_(crate::locale::Locale::active.eq(true))
9014 .first(tenant.pool())
9015 .await?
9016 .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
9017 if locale.is_default {
9018 return Ok((
9019 axum::http::StatusCode::BAD_REQUEST,
9020 "cannot translate INTO the default locale; canonical content lives on cms_snippet",
9021 )
9022 .into_response());
9023 }
9024 let locale_id = locale
9025 .id
9026 .get()
9027 .copied()
9028 .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
9029 let snippet = crate::snippet::Snippet::objects()
9031 .where_(crate::snippet::Snippet::id.eq(id))
9032 .first(tenant.pool())
9033 .await?
9034 .ok_or(AdminError::NotFound(id))?;
9035
9036 let mut updates: Vec<(String, String)> = Vec::new();
9038 for (k, v) in &form {
9039 if let Some(path) = k.strip_prefix("tr__") {
9040 if !path.is_empty() {
9041 updates.push((path.to_owned(), v.clone()));
9042 }
9043 }
9044 }
9045 let new_path_raw = form.get("new_field_path").map(String::as_str).unwrap_or("");
9046 if !new_path_raw.trim().is_empty() {
9047 if let Ok(path) = crate::snippet_translation::validate_field_path(new_path_raw) {
9050 let value = form.get("new_field_value").cloned().unwrap_or_default();
9051 updates.push((path, value));
9052 }
9053 }
9054
9055 rustango::atomic!(tenant.pool(), |tx| {
9057 let mut guard = tx.lock().await?;
9058 let tx = &mut *guard;
9059 for (path, value) in updates {
9060 let existing: Vec<SnippetTranslation> = SnippetTranslation::objects()
9061 .where_(SnippetTranslation::snippet_id.eq(id))
9062 .where_(SnippetTranslation::locale_id.eq(locale_id))
9063 .where_(SnippetTranslation::field_path.eq(path.clone()))
9064 .fetch_tx(tx)
9065 .await?;
9066 if value.is_empty() {
9067 for row in existing {
9068 row.delete_tx(tx).await?;
9069 }
9070 } else if let Some(mut row) = existing.into_iter().next() {
9071 row.value = value;
9072 row.save_tx(tx).await?;
9073 } else {
9074 let mut row = SnippetTranslation {
9075 id: rustango::sql::Auto::Unset,
9076 snippet_id: id,
9077 locale_id,
9078 field_path: path,
9079 value,
9080 updated_at: rustango::sql::Auto::Unset,
9081 };
9082 row.save_tx(tx).await?;
9083 }
9084 }
9085 Ok::<_, rustango::sql::ExecError>(())
9086 })
9087 .await?;
9088
9089 let back = if snippet.type_name == "form" {
9092 format!("/cms-admin/forms/{id}/build?locale={code}")
9093 } else {
9094 format!("/cms-admin/library/{id}/edit?locale={code}")
9095 };
9096 Ok(Redirect::to(&back).into_response())
9097}
9098
9099pub async fn snippet_revert_submit(
9103 State(_state): State<super::AdminState>,
9104 tenant: Tenant,
9105 headers: HeaderMap,
9106 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9107 Path((id, sequence)): Path<(i64, i32)>,
9108) -> Result<Response, AdminError> {
9109 let Some(rev) = crate::snippet::revision_by_sequence(tenant.pool(), id, sequence).await? else {
9110 return Err(AdminError::NotFound(id));
9111 };
9112 let mut snippet = crate::snippet::Snippet::objects()
9113 .where_(crate::snippet::Snippet::id.eq(id))
9114 .first(tenant.pool())
9115 .await?
9116 .ok_or(AdminError::NotFound(id))?;
9117 let snap = &rev.snapshot;
9120 if let Some(v) = snap.get("title").and_then(|v| v.as_str()) {
9121 snippet.title = v.to_owned();
9122 }
9123 if let Some(v) = snap.get("slug").and_then(|v| v.as_str()) {
9124 snippet.slug = v.to_owned();
9125 }
9126 if let Some(v) = snap.get("body_markdown").and_then(|v| v.as_str()) {
9127 snippet.body_markdown = v.to_owned();
9128 }
9129 if let Some(v) = snap.get("folder_path").and_then(|v| v.as_str()) {
9130 snippet.folder_path = v.to_owned();
9131 }
9132 if let Some(v) = snap.get("type_name").and_then(|v| v.as_str()) {
9133 snippet.type_name = v.to_owned();
9134 }
9135 if let Some(v) = snap.get("data") {
9136 snippet.data = v.clone();
9137 }
9138 snippet.save_pool(tenant.pool()).await?;
9139 if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9141 if handler.revisions_enabled() {
9142 let captured_by = session_user.as_ref().and_then(|u| u.id.get().copied());
9143 crate::snippet::capture_revision(tenant.pool(), &snippet, captured_by)
9144 .await
9145 .log_warn("revision not captured; the history has a gap");
9146 }
9147 }
9148 let sequence_str = sequence.to_string();
9149 redirect_named_with_params_and_message_args(
9150 "rcms-admin:library:edit",
9151 &[("id", id.to_string())],
9152 MsgLevel::Success,
9153 "Reverted to revision #{sequence}.",
9154 &[("sequence", sequence_str.as_str())],
9155 &headers,
9156 )
9157}
9158
9159pub async fn snippet_create_submit(
9160 State(_state): State<super::AdminState>,
9161 tenant: Tenant,
9162 headers: HeaderMap,
9163 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9164 Form(form): Form<std::collections::HashMap<String, String>>,
9165) -> Result<Response, AdminError> {
9166 let type_name = form.get("type_name").cloned().unwrap_or_default();
9167 let slug = form.get("slug").cloned().unwrap_or_default();
9168 let title = form.get("title").cloned().unwrap_or_default();
9169 let body = form.get("body_markdown").cloned().unwrap_or_default();
9170 let folder_path = form
9171 .get("folder_path")
9172 .map(|s| crate::snippet::normalize_folder(s))
9173 .unwrap_or_default();
9174 if type_name.is_empty() || slug.is_empty() || title.is_empty() {
9175 return Err(AdminError::Validation(
9176 "type, slug, and title are all required".to_owned(),
9177 ));
9178 }
9179 let mut row = crate::snippet::Snippet {
9180 id: rustango::sql::Auto::Unset,
9181 type_name,
9182 slug,
9183 folder_path,
9184 title,
9185 body_markdown: body,
9186 data: serde_json::Value::Object(serde_json::Map::new()),
9187 created_at: rustango::sql::Auto::Unset,
9188 updated_at: rustango::sql::Auto::Unset,
9189 };
9190 row.save_pool(tenant.pool()).await?;
9191 if row.type_name == "form" {
9194 let id = row.id.get().copied().unwrap_or_default();
9195 return redirect_named_with_params_and_message(
9196 "rcms-admin:forms:build",
9197 &[("id", id.to_string())],
9198 MsgLevel::Success,
9199 &super::i18n::tr(
9200 &headers,
9201 "Created snippet “{title}”.",
9202 &[("title", row.title.as_str())],
9203 ),
9204 &headers,
9205 );
9206 }
9207 redirect_named_with_message_args(
9208 "rcms-admin:library:list",
9209 MsgLevel::Success,
9210 "Created snippet “{title}”.",
9211 &[("title", row.title.as_str())],
9212 &headers,
9213 )
9214}
9215
9216pub async fn snippet_edit_submit(
9217 State(_state): State<super::AdminState>,
9218 tenant: Tenant,
9219 headers: HeaderMap,
9220 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9221 Path(id): Path<i64>,
9222 Form(form): Form<std::collections::HashMap<String, String>>,
9223) -> Result<Response, AdminError> {
9224 let mut snippet = crate::snippet::Snippet::objects()
9225 .where_(crate::snippet::Snippet::id.eq(id))
9226 .first(tenant.pool())
9227 .await?
9228 .ok_or(AdminError::NotFound(id))?;
9229 if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9233 if !handler.can_edit(&snippet) {
9234 return Err(AdminError::Validation(format!(
9235 "Library type `{}` denies edit on this row.",
9236 snippet.type_name
9237 )));
9238 }
9239 if let Err(errors) = handler.validate(&form) {
9242 let summary: Vec<String> = errors
9243 .into_iter()
9244 .map(|(field, msg)| format!("{field}: {msg}"))
9245 .collect();
9246 return Err(AdminError::Validation(summary.join("; ")));
9247 }
9248 }
9249 if let Some(v) = form.get("type_name") {
9250 if !v.is_empty() {
9251 snippet.type_name = v.clone();
9252 }
9253 }
9254 if let Some(v) = form.get("slug") {
9255 if !v.is_empty() {
9256 snippet.slug = v.clone();
9257 }
9258 }
9259 if let Some(v) = form.get("title") {
9260 snippet.title = v.clone();
9261 }
9262 if let Some(v) = form.get("body_markdown") {
9263 snippet.body_markdown = v.clone();
9264 }
9265 if let Some(v) = form.get("folder_path") {
9266 snippet.folder_path = crate::snippet::normalize_folder(v);
9267 }
9268 if crate::library::find_handler(&snippet.type_name)
9274 .is_some_and(|h| h.allows_element_template())
9275 {
9276 if let Some(v) = form.get("data__template") {
9277 crate::snippet::set_element_template(&mut snippet.data, v.trim());
9278 }
9279 }
9280 snippet.save_pool(tenant.pool()).await?;
9281 if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9285 if handler.revisions_enabled() {
9286 let captured_by = session_user.as_ref().and_then(|u| u.id.get().copied());
9287 if let Err(e) =
9288 crate::snippet::capture_revision(tenant.pool(), &snippet, captured_by).await
9289 {
9290 tracing::warn!(
9291 target: "rustango_cms::admin",
9292 snippet_id = id,
9293 type_name = %snippet.type_name,
9294 error = %e,
9295 "snippet revision capture failed",
9296 );
9297 }
9298 }
9299 }
9300 {
9302 let mut refs: Vec<crate::reference_index::Reference> = Vec::new();
9303 for (key, value) in &form {
9304 let mut found = crate::reference_index::scan(value, key);
9305 refs.append(&mut found);
9306 }
9307 if let Err(e) = crate::reference_index::reindex_source(
9308 tenant.pool(),
9309 crate::reference_index::KIND_SNIPPET,
9310 id,
9311 refs,
9312 )
9313 .await
9314 {
9315 tracing::warn!(
9316 target: "rustango_cms::reference_index",
9317 snippet_id = id, error = %e,
9318 "snippet reindex failed (best-effort)"
9319 );
9320 }
9321 }
9322 redirect_named_with_message_args(
9323 "rcms-admin:library:list",
9324 MsgLevel::Success,
9325 "Saved snippet “{title}”.",
9326 &[("title", snippet.title.as_str())],
9327 &headers,
9328 )
9329}
9330
9331pub async fn snippet_delete_submit(
9332 State(_state): State<super::AdminState>,
9333 tenant: Tenant,
9334 headers: HeaderMap,
9335 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9336 Path(id): Path<i64>,
9337) -> Result<Response, AdminError> {
9338 let snippet = crate::snippet::Snippet::objects()
9339 .where_(crate::snippet::Snippet::id.eq(id))
9340 .first(tenant.pool())
9341 .await?
9342 .ok_or(AdminError::NotFound(id))?;
9343 if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9345 if !handler.can_delete(&snippet) {
9346 return Err(AdminError::Validation(format!(
9347 "Library type `{}` denies delete on this row.",
9348 snippet.type_name
9349 )));
9350 }
9351 }
9352 let title = snippet.title.clone();
9353 let is_form = snippet.type_name == "form";
9354 snippet.delete_pool(tenant.pool()).await?;
9355 if is_form {
9357 let body = super::i18n::tr(&headers, "Deleted snippet “{title}”.", &[("title", title.as_str())]);
9358 return Ok(rustango::messages::redirect_with_message(
9359 messages_secret(),
9360 &headers,
9361 MsgLevel::Success,
9362 &body,
9363 "/cms-admin/forms",
9364 ));
9365 }
9366 redirect_named_with_message_args(
9367 "rcms-admin:library:list",
9368 MsgLevel::Success,
9369 "Deleted snippet “{title}”.",
9370 &[("title", title.as_str())],
9371 &headers,
9372 )
9373}
9374
9375fn parse_date_floor(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
9382 let raw = raw?.trim();
9383 if raw.is_empty() {
9384 return None;
9385 }
9386 chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d")
9387 .ok()
9388 .map(|d| {
9389 chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
9390 d.and_hms_opt(0, 0, 0).unwrap_or_default(),
9391 chrono::Utc,
9392 )
9393 })
9394}
9395
9396fn parse_date_ceil(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
9399 let raw = raw?.trim();
9400 if raw.is_empty() {
9401 return None;
9402 }
9403 chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d")
9404 .ok()
9405 .map(|d| {
9406 chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
9407 d.and_hms_opt(23, 59, 59).unwrap_or_default(),
9408 chrono::Utc,
9409 )
9410 })
9411}
9412
9413#[derive(Debug, Deserialize)]
9417pub struct MediaListQuery {
9418 #[serde(default)]
9420 pub page: Option<i64>,
9421 #[serde(default)]
9423 pub per_page: Option<usize>,
9424 #[serde(default)]
9426 pub collection: Option<i64>,
9427 #[serde(default)]
9430 pub q: Option<String>,
9431 #[serde(default)]
9433 pub from: Option<String>,
9434 #[serde(default)]
9437 pub to: Option<String>,
9438}
9439
9440#[derive(Debug, Deserialize)]
9447pub struct CropForm {
9448 pub crop_x: u32,
9449 pub crop_y: u32,
9450 pub crop_w: u32,
9451 pub crop_h: u32,
9452 pub mode: String,
9455}
9456
9457pub async fn media_crop_submit(
9467 State(_state): State<super::AdminState>,
9468 tenant: Tenant,
9469 headers: HeaderMap,
9470 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9471 Path(id): Path<i64>,
9472 Form(form): Form<CropForm>,
9473) -> Result<Response, AdminError> {
9474 use rustango::sql::Auto;
9475 let mut media = Media::objects()
9476 .where_(Media::id.eq(id))
9477 .first(tenant.pool())
9478 .await?
9479 .ok_or(AdminError::NotFound(id))?;
9480 if media.kind != "image" {
9481 return Err(AdminError::Validation(
9482 "Crop applies to images only.".to_owned(),
9483 ));
9484 }
9485
9486 let bytes = crate::media_storage::disk_for(&tenant.org.slug)
9487 .load(&crate::media_storage::key(
9488 &tenant.org.slug,
9489 &media.storage_key,
9490 ))
9491 .await
9492 .map_err(|e| AdminError::Validation(format!("read source: {e}")))?;
9493 let (cropped_bytes, out_mime) = crate::rendition::crop_image_off_runtime(
9494 bytes,
9495 media.mime.clone(),
9496 (form.crop_x, form.crop_y, form.crop_w, form.crop_h),
9497 )
9498 .await
9499 .map_err(AdminError::Validation)?;
9500
9501 let new_hash = {
9502 use sha2::Digest;
9503 let mut hasher = sha2::Sha256::new();
9504 hasher.update(&cropped_bytes);
9505 let digest = hasher.finalize();
9506 let mut hex = String::with_capacity(digest.len() * 2);
9507 for b in digest.iter() {
9508 hex.push_str(&format!("{b:02x}"));
9509 }
9510 hex
9511 };
9512
9513 match form.mode.as_str() {
9514 "apply" => {
9515 crate::media_storage::disk_for(&tenant.org.slug)
9519 .save(
9520 &crate::media_storage::key(&tenant.org.slug, &media.storage_key),
9521 &cropped_bytes,
9522 )
9523 .await
9524 .map_err(|e| AdminError::Validation(format!("write crop: {e}")))?;
9525 let old_hash = media.content_hash.clone();
9526 media.content_hash = new_hash;
9527 media.size = cropped_bytes.len() as i64;
9528 media.mime = out_mime;
9529 media.width = Some(form.crop_w as i32);
9530 media.height = Some(form.crop_h as i32);
9531 media.focal_point_x = None;
9533 media.focal_point_y = None;
9534 media.save_pool(tenant.pool()).await?;
9535
9536 for r in crate::rendition::MediaRendition::objects()
9540 .where_(crate::rendition::MediaRendition::content_hash.eq(old_hash))
9541 .fetch(tenant.pool())
9542 .await?
9543 {
9544 crate::media_storage::disk_for(&tenant.org.slug)
9545 .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
9546 .await
9547 .log_warn("stored file not deleted; the blob is orphaned");
9548 r.delete_pool(tenant.pool()).await?;
9549 }
9550 let crop_w = form.crop_w.to_string();
9551 let crop_h = form.crop_h.to_string();
9552 redirect_named_with_params_and_message_args(
9553 "rcms-admin:media:edit",
9554 &[("id", id.to_string())],
9555 MsgLevel::Success,
9556 "Crop applied. New dimensions {width}×{height}; renditions purged.",
9557 &[("width", crop_w.as_str()), ("height", crop_h.as_str())],
9558 &headers,
9559 )
9560 }
9561 "clone" => {
9562 let ext = match out_mime.as_str() {
9567 "image/jpeg" => "jpg",
9568 "image/webp" => "webp",
9569 _ => "png",
9570 };
9571 let new_key = format!("{}-crop-{}.{ext}", &new_hash[..16.min(new_hash.len())], id);
9572 crate::media_storage::disk_for(&tenant.org.slug)
9573 .save(
9574 &crate::media_storage::key(&tenant.org.slug, &new_key),
9575 &cropped_bytes,
9576 )
9577 .await
9578 .map_err(|e| AdminError::Validation(format!("write clone: {e}")))?;
9579
9580 let clone_title = if media.title.contains(" — crop") {
9581 media.title.clone()
9582 } else {
9583 format!("{} — crop", media.title)
9584 };
9585 let mut clone = Media {
9586 id: Auto::Unset,
9587 filename: format!(
9588 "{}.crop.{ext}",
9589 std::path::Path::new(&media.filename)
9590 .file_stem()
9591 .map(|s| s.to_string_lossy().to_string())
9592 .unwrap_or_else(|| "crop".to_owned())
9593 ),
9594 content_hash: new_hash,
9595 mime: out_mime,
9596 size: cropped_bytes.len() as i64,
9597 kind: "image".to_owned(),
9598 width: Some(form.crop_w as i32),
9599 height: Some(form.crop_h as i32),
9600 storage_key: new_key,
9601 title: clone_title,
9602 alt_text: media.alt_text.clone(),
9603 description: media.description.clone(),
9604 uploaded_by: media.uploaded_by,
9605 collection_id: media.collection_id,
9606 focal_point_x: None,
9607 focal_point_y: None,
9608 uploaded_at: Auto::Unset,
9609 };
9610 clone.insert_pool(tenant.pool()).await?;
9611 let new_id = clone.id.get().copied().unwrap_or_default();
9612 let new_id_str = new_id.to_string();
9613 let crop_w = form.crop_w.to_string();
9614 let crop_h = form.crop_h.to_string();
9615 redirect_named_with_params_and_message_args(
9616 "rcms-admin:media:edit",
9617 &[("id", new_id.to_string())],
9618 MsgLevel::Success,
9619 "Saved cropped clone as new media #{id} ({width}×{height}).",
9620 &[
9621 ("id", new_id_str.as_str()),
9622 ("width", crop_w.as_str()),
9623 ("height", crop_h.as_str()),
9624 ],
9625 &headers,
9626 )
9627 }
9628 other => Err(AdminError::Validation(format!(
9629 "Unknown crop mode `{other}` — expected `apply` or `clone`."
9630 ))),
9631 }
9632}
9633
9634pub async fn media_replace_submit(
9650 State(_state): State<super::AdminState>,
9651 tenant: Tenant,
9652 headers: HeaderMap,
9653 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9654 Path(id): Path<i64>,
9655 mut multipart: axum::extract::Multipart,
9656) -> Result<Response, AdminError> {
9657 use sha2::{Digest, Sha256};
9658
9659 let mut media = Media::objects()
9660 .where_(Media::id.eq(id))
9661 .first(tenant.pool())
9662 .await?
9663 .ok_or(AdminError::NotFound(id))?;
9664
9665 let mut filename = String::new();
9666 let mut bytes: Vec<u8> = Vec::new();
9667 while let Some(field) = multipart
9668 .next_field()
9669 .await
9670 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
9671 {
9672 if field.name().unwrap_or("") == "file" {
9673 if let Some(fname) = field.file_name() {
9674 filename = sanitize_filename(fname);
9675 }
9676 bytes = field
9677 .bytes()
9678 .await
9679 .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
9680 .to_vec();
9681 } else {
9682 let _ = field.bytes().await;
9683 }
9684 }
9685 if filename.is_empty() || bytes.is_empty() {
9686 return Err(AdminError::Upload("no file submitted".into()));
9687 }
9688
9689 let new_mime = mime_guess::from_path(&filename)
9690 .first_or_octet_stream()
9691 .essence_str()
9692 .to_owned();
9693 refuse_active_upload(&new_mime)?;
9694 let new_kind = Media::classify_mime(&new_mime).to_owned();
9697 if new_kind != media.kind {
9698 return Err(AdminError::Validation(format!(
9699 "Replacement kind `{new_kind}` does not match existing `{}` — replace must keep the media type.",
9700 media.kind
9701 )));
9702 }
9703
9704 let (stored, decoded_dims) =
9706 crate::rendition::strip_exif_off_runtime(bytes, new_mime.clone()).await;
9707 bytes = stored;
9708
9709 let mut hasher = Sha256::new();
9710 hasher.update(&bytes);
9711 let digest = hasher.finalize();
9712 let new_hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
9713 use std::fmt::Write as _;
9714 let _ = write!(acc, "{b:02x}");
9715 acc
9716 });
9717
9718 let new_storage_key = format!("{}-{}", &new_hash[..16.min(new_hash.len())], filename);
9719 crate::media_storage::disk_for(&tenant.org.slug)
9720 .save(
9721 &crate::media_storage::key(&tenant.org.slug, &new_storage_key),
9722 &bytes,
9723 )
9724 .await
9725 .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
9726
9727 let old_storage_key = media.storage_key.clone();
9728 let old_hash = media.content_hash.clone();
9729
9730 let (new_w, new_h): (Option<i32>, Option<i32>) = decoded_dims
9731 .map(|(w, h)| (Some(w as i32), Some(h as i32)))
9732 .unwrap_or((None, None));
9733
9734 media.filename = filename;
9735 media.storage_key = new_storage_key;
9736 media.content_hash = new_hash;
9737 media.mime = new_mime;
9738 media.size = bytes.len() as i64;
9739 media.width = new_w;
9740 media.height = new_h;
9741 media.save_pool(tenant.pool()).await?;
9742
9743 if old_storage_key != media.storage_key {
9747 crate::media_storage::disk_for(&tenant.org.slug)
9748 .delete(&crate::media_storage::key(
9749 &tenant.org.slug,
9750 &old_storage_key,
9751 ))
9752 .await
9753 .log_warn("stored file not deleted; the blob is orphaned");
9754 }
9755
9756 if old_hash != media.content_hash {
9759 for r in crate::rendition::MediaRendition::objects()
9760 .where_(crate::rendition::MediaRendition::content_hash.eq(old_hash))
9761 .fetch(tenant.pool())
9762 .await?
9763 {
9764 crate::media_storage::disk_for(&tenant.org.slug)
9765 .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
9766 .await
9767 .log_warn("stored file not deleted; the blob is orphaned");
9768 r.delete_pool(tenant.pool()).await?;
9769 }
9770 }
9771
9772 redirect_named_with_params_and_message(
9773 "rcms-admin:media:edit",
9774 &[("id", id.to_string())],
9775 MsgLevel::Success,
9776 "Replaced. Old renditions purged; every page referencing this image now serves the new bytes.",
9777 &headers,
9778 )
9779}
9780
9781async fn pages_referencing_media(
9793 pool: &rustango::sql::Pool,
9794 media_id: i64,
9795) -> Result<Vec<(i64, String, String, String)>, rustango::sql::ExecError> {
9796 let pages: Vec<Page> = Page::objects().fetch(pool).await?;
9797 let mut hits: Vec<(i64, String, String, String)> = Vec::new();
9798 for p in &pages {
9799 let page_id = p.id.get().copied().unwrap_or_default();
9800 if page_id == 0 {
9801 continue;
9802 }
9803 let mut ids = std::collections::BTreeSet::new();
9804 if let Ok(v) = serde_json::to_value(p) {
9806 harvest_media_ids(&v, &mut ids);
9807 }
9808 if let Ok(pts) = PageType::objects()
9811 .where_(PageType::id.eq(p.page_type_id))
9812 .fetch(pool)
9813 .await
9814 {
9815 if let Some(pt_row) = pts.into_iter().next() {
9816 if let Some(handler) = crate::page_type::find_handler(&pt_row.type_name) {
9817 if let Ok(ext) = handler.load_extension(pool, page_id).await {
9818 harvest_media_ids(&ext, &mut ids);
9819 }
9820 }
9821 }
9822 }
9823 if ids.contains(&media_id) {
9824 hits.push((
9825 page_id,
9826 p.title.clone(),
9827 p.url_path.clone(),
9828 p.status.clone(),
9829 ));
9830 }
9831 }
9832 Ok(hits)
9833}
9834
9835pub async fn media_edit_form(
9836 State(state): State<super::AdminState>,
9837 tenant: Tenant,
9838 headers: HeaderMap,
9839 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9840 Path(id): Path<i64>,
9841) -> Result<Response, AdminError> {
9842 let media = Media::objects()
9843 .where_(Media::id.eq(id))
9844 .first(tenant.pool())
9845 .await?
9846 .ok_or(AdminError::NotFound(id))?;
9847 if media.kind != "image" {
9848 return Err(AdminError::NotFound(id));
9849 }
9850 let usages = pages_referencing_media(tenant.pool(), id)
9852 .await
9853 .unwrap_or_default();
9854 let usage_rows: Vec<serde_json::Value> = usages
9855 .iter()
9856 .map(|(pid, title, url_path, status)| {
9857 serde_json::json!({
9858 "id": pid,
9859 "title": title,
9860 "url_path": url_path,
9861 "status": status,
9862 })
9863 })
9864 .collect();
9865 let mut ctx = Context::new();
9866 add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
9867 add_admin_theme(&mut ctx, tenant.pool()).await;
9868 ctx.insert(
9869 "media",
9870 &serde_json::json!({
9871 "id": media.id.get().copied(),
9872 "title": media.title,
9873 "filename": media.filename,
9874 "alt_text": media.alt_text,
9875 "description": media.description,
9876 "mime": media.mime,
9877 "size": media.size,
9878 "width": media.width,
9879 "height": media.height,
9880 "focal_point_x": media.focal_point_x,
9881 "focal_point_y": media.focal_point_y,
9882 "uploaded_at": media.uploaded_at.get().copied(),
9883 "content_hash": media.content_hash,
9887 }),
9888 );
9889 ctx.insert("usages", &usage_rows);
9890 ctx.insert("usage_count", &(usage_rows.len() as i64));
9891 render_with_csrf(&state, &headers, "rcms_admin/media_edit.html", &mut ctx)
9892}
9893
9894#[derive(Debug, Deserialize)]
9898pub struct MediaEditForm {
9899 pub title: String,
9900 pub alt_text: String,
9901 #[serde(default)]
9902 pub description: String,
9903 #[serde(default)]
9904 pub focal_point_x: Option<String>,
9905 #[serde(default)]
9906 pub focal_point_y: Option<String>,
9907}
9908
9909pub async fn media_edit_submit(
9914 State(_state): State<super::AdminState>,
9915 tenant: Tenant,
9916 headers: HeaderMap,
9917 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9918 Path(id): Path<i64>,
9919 Form(form): Form<MediaEditForm>,
9920) -> Result<Response, AdminError> {
9921 let mut media = Media::objects()
9922 .where_(Media::id.eq(id))
9923 .first(tenant.pool())
9924 .await?
9925 .ok_or(AdminError::NotFound(id))?;
9926 if media.kind != "image" {
9927 return Err(AdminError::NotFound(id));
9928 }
9929 media.title = form.title.trim().to_owned();
9930 media.alt_text = form.alt_text.trim().to_owned();
9931 media.description = form.description.trim().to_owned();
9932
9933 let parse_fraction = |raw: Option<&str>| -> Option<f32> {
9934 raw.map(str::trim)
9935 .filter(|s| !s.is_empty())
9936 .and_then(|s| s.parse::<f32>().ok())
9937 .map(|f| f.clamp(0.0, 1.0))
9938 };
9939 let new_x = parse_fraction(form.focal_point_x.as_deref());
9940 let new_y = parse_fraction(form.focal_point_y.as_deref());
9941 let focal_changed = media.focal_point_x != new_x || media.focal_point_y != new_y;
9942 media.focal_point_x = new_x;
9943 media.focal_point_y = new_y;
9944 media.save_pool(tenant.pool()).await?;
9945
9946 if focal_changed {
9949 let renditions: Vec<crate::rendition::MediaRendition> =
9950 crate::rendition::MediaRendition::objects()
9951 .where_(
9952 crate::rendition::MediaRendition::content_hash.eq(media.content_hash.clone()),
9953 )
9954 .fetch(tenant.pool())
9955 .await?;
9956 for r in renditions {
9957 crate::media_storage::disk_for(&tenant.org.slug)
9960 .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
9961 .await
9962 .log_warn("stored file not deleted; the blob is orphaned");
9963 r.delete_pool(tenant.pool()).await?;
9964 }
9965 }
9966 redirect_named_with_params_and_message(
9967 "rcms-admin:media:edit",
9968 &[("id", id.to_string())],
9969 MsgLevel::Success,
9970 if focal_changed {
9971 "Saved. Renditions purged — next request regenerates with the new focal point."
9972 } else {
9973 "Saved."
9974 },
9975 &headers,
9976 )
9977}
9978
9979fn json_contains_needle(value: &serde_json::Value, needle: &str) -> bool {
9984 match value {
9985 serde_json::Value::String(s) => {
9986 if s.to_lowercase().contains(needle) {
9987 return true;
9988 }
9989 let trimmed = s.trim_start();
9992 if trimmed.starts_with('[') || trimmed.starts_with('{') {
9993 if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(s) {
9994 return json_contains_needle(&parsed, needle);
9995 }
9996 }
9997 false
9998 }
9999 serde_json::Value::Array(arr) => arr.iter().any(|v| json_contains_needle(v, needle)),
10000 serde_json::Value::Object(map) => map.values().any(|v| json_contains_needle(v, needle)),
10001 _ => false,
10002 }
10003}
10004
10005fn harvest_media_ids(value: &serde_json::Value, out: &mut std::collections::BTreeSet<i64>) {
10018 use serde_json::Value;
10019 match value {
10020 Value::Object(map) => {
10021 for (key, child) in map {
10022 let is_media_key = key == "media_id" || key.ends_with("_media_id");
10023 if is_media_key {
10024 match child {
10025 Value::Number(n) => {
10026 if let Some(id) = n.as_i64() {
10027 if id > 0 {
10028 out.insert(id);
10029 }
10030 }
10031 }
10032 Value::String(s) => {
10033 if let Ok(id) = s.parse::<i64>() {
10034 if id > 0 {
10035 out.insert(id);
10036 }
10037 }
10038 }
10039 _ => harvest_media_ids(child, out),
10040 }
10041 } else {
10042 harvest_media_ids(child, out);
10043 }
10044 }
10045 }
10046 Value::Array(arr) => {
10047 for item in arr {
10048 harvest_media_ids(item, out);
10049 }
10050 }
10051 Value::String(s) => {
10052 let trimmed = s.trim_start();
10053 if trimmed.starts_with('[') || trimmed.starts_with('{') {
10054 if let Ok(parsed) = serde_json::from_str::<Value>(s) {
10055 harvest_media_ids(&parsed, out);
10056 }
10057 }
10058 }
10059 _ => {}
10060 }
10061}
10062
10063pub async fn media_unused_report(
10068 State(state): State<super::AdminState>,
10069 tenant: Tenant,
10070 headers: HeaderMap,
10071 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10072) -> Result<Response, AdminError> {
10073 let all_media: Vec<Media> = Media::objects()
10074 .order_by(&[("uploaded_at", true)])
10075 .fetch(tenant.pool())
10076 .await?;
10077 let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
10078
10079 let mut used: std::collections::BTreeSet<i64> = std::collections::BTreeSet::new();
10080
10081 for p in &pages {
10085 if let Ok(v) = serde_json::to_value(p) {
10086 harvest_media_ids(&v, &mut used);
10087 }
10088 }
10089
10090 for p in &pages {
10095 let page_id = p.id.get().copied().unwrap_or_default();
10096 let pt: Vec<crate::page_type_model::PageType> = crate::page_type_model::PageType::objects()
10099 .where_(crate::page_type_model::PageType::id.eq(p.page_type_id))
10100 .fetch(tenant.pool())
10101 .await?;
10102 let Some(pt_row) = pt.into_iter().next() else {
10103 continue;
10104 };
10105 let Some(handler) = crate::page_type::find_handler(&pt_row.type_name) else {
10106 continue;
10107 };
10108 if let Ok(ext_value) = handler.load_extension(tenant.pool(), page_id).await {
10109 harvest_media_ids(&ext_value, &mut used);
10110 }
10111 }
10112
10113 let unused: Vec<&Media> = all_media
10115 .iter()
10116 .filter(|m| m.id.get().copied().is_some_and(|id| !used.contains(&id)))
10117 .collect();
10118
10119 let unused_view: Vec<serde_json::Value> = unused
10120 .iter()
10121 .map(|m| {
10122 serde_json::json!({
10123 "id": m.id.get().copied(),
10124 "title": m.title,
10125 "filename": m.filename,
10126 "kind": m.kind,
10127 "mime": m.mime,
10128 "size": m.size,
10129 "uploaded_at": m.uploaded_at.get().copied(),
10130 "uploaded_by": m.uploaded_by,
10131 })
10132 })
10133 .collect();
10134
10135 let mut ctx = Context::new();
10136 add_chrome(&mut ctx, &tenant, "media-unused", session_user.as_ref()).await;
10137 add_admin_theme(&mut ctx, tenant.pool()).await;
10138 ctx.insert("unused", &unused_view);
10139 ctx.insert("total_media", &all_media.len());
10140 ctx.insert("used_count", &used.len());
10141 render_with_csrf(&state, &headers, "rcms_admin/media_unused.html", &mut ctx)
10142}
10143
10144pub async fn media_unused_bulk_delete(
10150 State(_state): State<super::AdminState>,
10151 tenant: Tenant,
10152 headers: HeaderMap,
10153 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
10154 Form(form): Form<Vec<(String, String)>>,
10155) -> Result<Response, AdminError> {
10156 use rustango::sql::Auto;
10157 let ids: Vec<i64> = form
10158 .iter()
10159 .filter(|(k, _)| k == "id" || k == "ids")
10160 .filter_map(|(_, v)| v.parse::<i64>().ok())
10161 .collect();
10162 let mut deleted = 0usize;
10163 for id in ids {
10164 let row = Media::objects()
10165 .where_(Media::id.eq(id))
10166 .first(tenant.pool())
10167 .await?;
10168 if let Some(m) = row {
10169 let _ = Auto::Unset::<i64>; m.delete_pool(tenant.pool()).await?;
10174 deleted += 1;
10175 }
10176 }
10177 redirect_named_with_message_plural(
10178 "rcms-admin:media:unused",
10179 MsgLevel::Success,
10180 "Deleted {count} unused media item(s).",
10181 deleted as i64,
10182 &[("count", &deleted.to_string())],
10183 &headers,
10184 )
10185}
10186
10187pub async fn media_list(
10189 State(state): State<super::AdminState>,
10190 tenant: Tenant,
10191 headers: HeaderMap,
10192 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10193 Query(q): Query<MediaListQuery>,
10194 axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
10195) -> Result<Response, AdminError> {
10196 if rand::random::<u8>() < 5 {
10200 if let Ok(unlinked) = crate::uploaded_file::gc_stale(tenant.pool()).await {
10201 for key in unlinked {
10202 crate::media_storage::disk_for(&tenant.org.slug)
10203 .delete(&crate::media_storage::key(&tenant.org.slug, &key))
10204 .await
10205 .log_warn("stored file not deleted; the blob is orphaned");
10206 }
10207 }
10208 }
10209 render_media_list(
10210 &state,
10211 &tenant,
10212 &headers,
10213 session_user.as_ref(),
10214 "image",
10215 q,
10216 raw_query,
10217 )
10218 .await
10219}
10220
10221pub async fn documents_list(
10223 State(state): State<super::AdminState>,
10224 tenant: Tenant,
10225 headers: HeaderMap,
10226 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10227 Query(q): Query<MediaListQuery>,
10228 axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
10229) -> Result<Response, AdminError> {
10230 render_media_list(
10231 &state,
10232 &tenant,
10233 &headers,
10234 session_user.as_ref(),
10235 "document",
10236 q,
10237 raw_query,
10238 )
10239 .await
10240}
10241
10242async fn render_media_list(
10245 state: &super::AdminState,
10246 tenant: &Tenant,
10247 headers: &HeaderMap,
10248 session_user: Option<&rustango::tenancy::auth::User>,
10249 kind: &str,
10250 filters: MediaListQuery,
10251 raw_query: Option<String>,
10252) -> Result<Response, AdminError> {
10253 let collection_filter = filters.collection;
10254 let search = filters
10255 .q
10256 .as_deref()
10257 .map(str::trim)
10258 .filter(|s| !s.is_empty())
10259 .map(str::to_lowercase);
10260 let from_filter = parse_date_floor(filters.from.as_deref());
10261 let to_filter = parse_date_ceil(filters.to.as_deref());
10262 let all: Vec<Media> = Media::objects()
10266 .order_by(&[("uploaded_at", true)])
10267 .fetch(tenant.pool())
10268 .await?;
10269 let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
10270 .order_by(&[("sort_order", false), ("name", false)])
10271 .fetch(tenant.pool())
10272 .await?;
10273
10274 let items: Vec<&Media> = all
10275 .iter()
10276 .filter(|m| {
10277 let kind_match = if kind == "image" {
10278 m.kind == "image"
10279 } else {
10280 m.kind != "image"
10281 };
10282 let collection_match = match collection_filter {
10283 None => true,
10284 Some(cid) => m.collection_id == Some(cid),
10285 };
10286 let search_match = match &search {
10287 None => true,
10288 Some(needle) => {
10289 m.title.to_lowercase().contains(needle)
10290 || m.filename.to_lowercase().contains(needle)
10291 || m.alt_text.to_lowercase().contains(needle)
10292 }
10293 };
10294 let date_match = m.uploaded_at.get().is_none_or(|when| {
10295 let after_from = from_filter.is_none_or(|floor| *when >= floor);
10296 let before_to = to_filter.is_none_or(|ceil| *when <= ceil);
10297 after_from && before_to
10298 });
10299 kind_match && collection_match && search_match && date_match
10300 })
10301 .collect();
10302
10303 let per_page = crate::admin::pagination::clamp_per_page(filters.per_page);
10308 let requested_page = filters.page.unwrap_or(1);
10309 let total_items = items.len();
10310 let pagination = crate::admin::pagination::context(requested_page, per_page, total_items);
10311 let current_page = pagination["page"].as_i64().unwrap_or(1);
10312 let skip = crate::admin::pagination::offset(current_page, per_page) as usize;
10313 let items: Vec<&Media> = items.into_iter().skip(skip).take(per_page).collect();
10314
10315 let mut counts: std::collections::HashMap<Option<i64>, i64> = std::collections::HashMap::new();
10319 for m in &all {
10320 let in_kind = if kind == "image" {
10321 m.kind == "image"
10322 } else {
10323 m.kind != "image"
10324 };
10325 if in_kind {
10326 *counts.entry(m.collection_id).or_insert(0) += 1;
10327 }
10328 }
10329
10330 let collections_view: Vec<serde_json::Value> = collections
10331 .iter()
10332 .map(|c| {
10333 let id = c.id.get().copied();
10334 serde_json::json!({
10335 "id": id,
10336 "name": c.name,
10337 "parent_id": c.parent_id,
10338 "count": id.and_then(|i| counts.get(&Some(i)).copied()).unwrap_or(0),
10339 })
10340 })
10341 .collect();
10342 let uncategorized_count = counts.get(&None).copied().unwrap_or(0);
10343
10344 let mut ctx = Context::new();
10345 let active_tab = if kind == "image" {
10346 "media"
10347 } else {
10348 "documents"
10349 };
10350 add_chrome(&mut ctx, tenant, active_tab, session_user).await;
10351 add_admin_theme(&mut ctx, tenant.pool()).await;
10352 ctx.insert("items", &items);
10353 ctx.insert("collections", &collections_view);
10354 ctx.insert("collection_filter", &collection_filter);
10355 ctx.insert("uncategorized_count", &uncategorized_count);
10356 ctx.insert("search_q", &filters.q);
10357 ctx.insert("date_from", &filters.from);
10358 ctx.insert("date_to", &filters.to);
10359 ctx.insert(
10360 "is_filtered",
10361 &(collection_filter.is_some()
10362 || search.is_some()
10363 || from_filter.is_some()
10364 || to_filter.is_some()),
10365 );
10366 ctx.insert("filtered_count", &total_items);
10368 ctx.insert("pagination", &pagination);
10369 ctx.insert(
10370 "kind_label",
10371 if kind == "image" {
10372 "Media (images)"
10373 } else {
10374 "Documents"
10375 },
10376 );
10377 ctx.insert(
10378 "upload_kind",
10379 if kind == "image" { "image" } else { "document" },
10380 );
10381 ctx.insert(
10382 "self_url",
10383 if kind == "image" {
10384 "/cms-admin/media"
10385 } else {
10386 "/cms-admin/documents"
10387 },
10388 );
10389 ctx.insert("query_string", &raw_query.unwrap_or_default());
10395 ctx.insert("qs_none", &serde_json::Value::Null);
10396 render_with_csrf(state, headers, "rcms_admin/media_list.html", &mut ctx)
10397}
10398
10399pub async fn media_upload_form(
10401 State(state): State<super::AdminState>,
10402 tenant: Tenant,
10403 headers: HeaderMap,
10404 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10405 Query(q): Query<UploadFormQuery>,
10406) -> Result<Response, AdminError> {
10407 let kind_label = if q.kind.as_deref() == Some("document") {
10408 "Documents"
10409 } else {
10410 "Media (images)"
10411 };
10412 let mut ctx = Context::new();
10413 add_chrome(
10414 &mut ctx,
10415 &tenant,
10416 if q.kind.as_deref() == Some("document") {
10417 "documents"
10418 } else {
10419 "media"
10420 },
10421 session_user.as_ref(),
10422 )
10423 .await;
10424 let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
10427 .order_by(&[("sort_order", false), ("name", false)])
10428 .fetch(tenant.pool())
10429 .await?;
10430 let collections_view: Vec<serde_json::Value> = collections
10431 .iter()
10432 .map(|c| {
10433 serde_json::json!({
10434 "id": c.id.get().copied(),
10435 "name": c.name,
10436 })
10437 })
10438 .collect();
10439 ctx.insert("collections", &collections_view);
10440 ctx.insert("kind_label", kind_label);
10441 ctx.insert("upload_kind", &q.kind.as_deref().unwrap_or("image"));
10442 render_with_csrf(&state, &headers, "rcms_admin/media_upload.html", &mut ctx)
10443}
10444
10445#[derive(Debug, Deserialize)]
10446pub struct UploadFormQuery {
10447 #[serde(default)]
10448 pub kind: Option<String>,
10449}
10450
10451pub async fn media_upload_staged(
10464 State(_state): State<super::AdminState>,
10465 tenant: Tenant,
10466 headers: HeaderMap,
10467 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10468 mut multipart: axum::extract::Multipart,
10469) -> Result<Response, AdminError> {
10470 use sha2::{Digest, Sha256};
10471 let Some(viewer) = session_user.as_ref() else {
10472 return Ok(unauthorized_no_session_for(Some(&headers)));
10478 };
10479 let viewer_id = viewer.id.get().copied().unwrap_or_default();
10480 let mut filename = String::new();
10481 let mut bytes: Vec<u8> = Vec::new();
10482 while let Some(field) = multipart
10483 .next_field()
10484 .await
10485 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
10486 {
10487 if field.name().unwrap_or("") == "file" {
10488 if let Some(fname) = field.file_name() {
10489 filename = sanitize_filename(fname);
10490 }
10491 bytes = field
10492 .bytes()
10493 .await
10494 .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
10495 .to_vec();
10496 } else {
10497 let _ = field.bytes().await;
10498 }
10499 }
10500 if filename.is_empty() || bytes.is_empty() {
10501 return Err(AdminError::Upload("no file submitted".into()));
10502 }
10503 let mut hasher = Sha256::new();
10504 hasher.update(&bytes);
10505 let digest = hasher.finalize();
10506 let hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
10507 use std::fmt::Write as _;
10508 let _ = write!(acc, "{b:02x}");
10509 acc
10510 });
10511 let mime = mime_guess::from_path(&filename)
10512 .first_or_octet_stream()
10513 .essence_str()
10514 .to_owned();
10515 refuse_active_upload(&mime)?;
10516 {
10525 use rustango::core::Column as _;
10526 use rustango::sql::FetcherPool as _;
10527 let existing: Vec<crate::media::Media> = crate::media::Media::objects()
10528 .where_(crate::media::Media::content_hash.eq(hash.clone()))
10529 .fetch(tenant.pool())
10530 .await
10531 .unwrap_or_default();
10532 if let Some(existing_media) = existing.into_iter().next() {
10533 let existing_id = existing_media.id.get().copied().unwrap_or_default();
10534 let payload = serde_json::json!({
10535 "id": null,
10536 "duplicate_of": existing_id,
10537 "duplicate_title": existing_media.title,
10538 "duplicate_filename": existing_media.filename,
10539 "filename": filename,
10540 "mime": existing_media.mime,
10541 "size": existing_media.size,
10542 });
10543 return Ok((
10544 [(axum::http::header::CONTENT_TYPE, "application/json")],
10545 serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
10546 )
10547 .into_response());
10548 }
10549 }
10550 let storage_key = format!("scratch/{}-{filename}", &hash[..16]);
10551 crate::media_storage::disk_for(&tenant.org.slug)
10552 .save(
10553 &crate::media_storage::key(&tenant.org.slug, &storage_key),
10554 &bytes,
10555 )
10556 .await
10557 .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
10558 let size = bytes.len() as i64;
10559 let row = crate::uploaded_file::create(
10560 tenant.pool(),
10561 viewer_id,
10562 storage_key,
10563 filename,
10564 mime,
10565 size,
10566 hash,
10567 )
10568 .await?;
10569 let payload = serde_json::json!({
10570 "id": row.id.get().copied().unwrap_or_default(),
10571 "filename": row.original_filename,
10572 "mime": row.mime,
10573 "size": row.size,
10574 });
10575 Ok((
10576 [(axum::http::header::CONTENT_TYPE, "application/json")],
10577 serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
10578 )
10579 .into_response())
10580}
10581
10582#[derive(Debug, Deserialize)]
10584pub struct StagedCommitItem {
10585 pub uploaded_file_id: i64,
10586 #[serde(default)]
10587 pub title: String,
10588 #[serde(default)]
10589 pub alt_text: String,
10590 #[serde(default)]
10591 pub collection_id: Option<i64>,
10592}
10593
10594#[derive(Debug, Deserialize)]
10599pub struct StagedCommitPayload {
10600 pub items: Vec<StagedCommitItem>,
10601}
10602
10603pub async fn media_upload_staged_commit(
10617 State(_state): State<super::AdminState>,
10618 tenant: Tenant,
10619 headers: HeaderMap,
10620 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10621 Json(payload): Json<StagedCommitPayload>,
10622) -> Result<Response, AdminError> {
10623 use rustango::sql::Auto;
10624 let Some(viewer) = session_user.as_ref() else {
10625 return Ok(unauthorized_no_session_for(Some(&headers)));
10627 };
10628 let viewer_id = viewer.id.get().copied().unwrap_or_default();
10629 let media_slug = tenant.org.slug.clone();
10630
10631 let mut committed: Vec<i64> = Vec::new();
10632 let mut failed: Vec<serde_json::Value> = Vec::new();
10633
10634 for item in payload.items {
10635 let result: Result<i64, String> = async {
10636 let row = crate::uploaded_file::get(tenant.pool(), item.uploaded_file_id)
10637 .await
10638 .map_err(|e| format!("lookup: {e}"))?
10639 .ok_or_else(|| "scratch row missing".to_owned())?;
10640 if row.user_id != viewer_id && !viewer.is_superuser {
10641 return Err("not your upload".to_owned());
10642 }
10643
10644 let scratch_key = crate::media_storage::key(&media_slug, &row.storage_key);
10645 let mut bytes = crate::media_storage::disk_for(&media_slug)
10646 .load(&scratch_key)
10647 .await
10648 .map_err(|e| format!("read scratch: {e}"))?;
10649
10650 let (stored, decoded_dims) =
10652 crate::rendition::strip_exif_off_runtime(bytes, row.mime.clone()).await;
10653 bytes = stored;
10654
10655 let final_key = format!(
10659 "{}-{}",
10660 &row.content_hash[..16.min(row.content_hash.len())],
10661 row.original_filename
10662 );
10663 crate::media_storage::disk_for(&media_slug)
10664 .save(&crate::media_storage::key(&media_slug, &final_key), &bytes)
10665 .await
10666 .map_err(|e| format!("write final: {e}"))?;
10667
10668 let kind = Media::classify_mime(&row.mime).to_owned();
10669 let (width, height): (Option<i32>, Option<i32>) = decoded_dims
10670 .map(|(w, h)| (Some(w as i32), Some(h as i32)))
10671 .unwrap_or((None, None));
10672
10673 let title = if item.title.trim().is_empty() {
10674 row.original_filename
10675 .rsplit_once('.')
10676 .map(|(stem, _)| stem.to_owned())
10677 .unwrap_or_else(|| row.original_filename.clone())
10678 } else {
10679 item.title.trim().to_owned()
10680 };
10681
10682 let mut media_row = Media {
10683 id: Auto::Unset,
10684 filename: row.original_filename.clone(),
10685 content_hash: row.content_hash.clone(),
10686 mime: row.mime.clone(),
10687 size: bytes.len() as i64,
10688 kind,
10689 width,
10690 height,
10691 storage_key: final_key,
10692 title,
10693 alt_text: item.alt_text.trim().to_owned(),
10694 description: String::new(),
10695 uploaded_by: Some(viewer_id),
10696 collection_id: item.collection_id,
10697 focal_point_x: None,
10698 focal_point_y: None,
10699 uploaded_at: Auto::Unset,
10700 };
10701 media_row
10702 .insert_pool(tenant.pool())
10703 .await
10704 .map_err(|e| format!("insert media: {e}"))?;
10705 let new_id = media_row.id.get().copied().unwrap_or_default();
10706
10707 crate::media_storage::disk_for(&media_slug)
10712 .delete(&scratch_key)
10713 .await
10714 .log_warn("stored file not deleted; the blob is orphaned");
10715 crate::uploaded_file::delete(tenant.pool(), item.uploaded_file_id)
10716 .await
10717 .map_err(|e| format!("delete scratch: {e}"))?;
10718 Ok(new_id)
10719 }
10720 .await;
10721
10722 match result {
10723 Ok(id) => committed.push(id),
10724 Err(e) => {
10725 failed.push(serde_json::json!({
10726 "uploaded_file_id": item.uploaded_file_id,
10727 "error": e,
10728 }));
10729 }
10730 }
10731 }
10732
10733 let body = serde_json::json!({
10734 "committed": committed,
10735 "failed": failed,
10736 });
10737 Ok((
10738 [(axum::http::header::CONTENT_TYPE, "application/json")],
10739 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
10740 )
10741 .into_response())
10742}
10743
10744pub async fn media_upload_staged_cancel(
10747 State(_state): State<super::AdminState>,
10748 tenant: Tenant,
10749 headers: HeaderMap,
10750 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10751 Path(id): Path<i64>,
10752) -> Result<Response, AdminError> {
10753 let Some(viewer) = session_user.as_ref() else {
10754 return Ok(unauthorized_no_session_for(Some(&headers)));
10756 };
10757 let viewer_id = viewer.id.get().copied().unwrap_or_default();
10758 let Some(row) = crate::uploaded_file::get(tenant.pool(), id).await? else {
10759 return Ok((axum::http::StatusCode::NOT_FOUND, "not found").into_response());
10760 };
10761 if row.user_id != viewer_id && !viewer.is_superuser {
10762 return Ok((axum::http::StatusCode::FORBIDDEN, "not your upload").into_response());
10763 }
10764 crate::media_storage::disk_for(&tenant.org.slug)
10765 .delete(&crate::media_storage::key(
10766 &tenant.org.slug,
10767 &row.storage_key,
10768 ))
10769 .await
10770 .log_warn("stored file not deleted; the blob is orphaned");
10771 crate::uploaded_file::delete(tenant.pool(), id).await?;
10772 Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
10773}
10774
10775fn refuse_active_upload(mime: &str) -> Result<(), AdminError> {
10781 let active = matches!(
10782 mime,
10783 "text/html"
10784 | "application/xhtml+xml"
10785 | "text/javascript"
10786 | "application/javascript"
10787 | "application/ecmascript"
10788 | "text/xml"
10789 | "application/xml"
10790 | "text/xsl"
10791 | "application/xslt+xml"
10792 );
10793 if active {
10794 return Err(AdminError::Upload(format!(
10795 "files of type {mime} can't be uploaded: a browser would run them as a page"
10796 )));
10797 }
10798 Ok(())
10799}
10800
10801#[allow(clippy::too_many_arguments)]
10811pub(crate) async fn store_media(
10812 pool: &rustango::sql::Pool,
10813 org_slug: &str,
10814 mut bytes: Vec<u8>,
10815 raw_filename: &str,
10816 title: Option<&str>,
10817 alt_text: &str,
10818 collection_id: Option<i64>,
10819 uploaded_by: Option<i64>,
10820 dedupe: bool,
10821) -> Result<Media, AdminError> {
10822 use rustango::sql::Auto;
10823 use sha2::{Digest, Sha256};
10824
10825 let filename = sanitize_filename(raw_filename);
10826 if filename.is_empty() || bytes.is_empty() {
10827 return Err(AdminError::Upload("no file submitted".into()));
10828 }
10829
10830 let mime = mime_guess::from_path(&filename)
10831 .first_or_octet_stream()
10832 .essence_str()
10833 .to_owned();
10834 refuse_active_upload(&mime)?;
10835 let kind = Media::classify_mime(&mime).to_owned();
10836
10837 let (stored, decoded_dims) = crate::rendition::strip_exif_off_runtime(bytes, mime.clone()).await;
10840 bytes = stored;
10841
10842 let mut hasher = Sha256::new();
10843 hasher.update(&bytes);
10844 let digest = hasher.finalize();
10845 let hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
10846 use std::fmt::Write as _;
10847 let _ = write!(acc, "{b:02x}");
10848 acc
10849 });
10850
10851 if dedupe {
10852 if let Some(existing) = Media::objects()
10853 .where_(Media::content_hash.eq(hash.clone()))
10854 .first(pool)
10855 .await?
10856 {
10857 return Ok(existing);
10858 }
10859 }
10860
10861 let storage_key = format!("{}-{}", &hash[..16], filename);
10863 crate::media_storage::disk_for(&org_slug)
10864 .save(&crate::media_storage::key(org_slug, &storage_key), &bytes)
10865 .await
10866 .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
10867
10868 let title = match title {
10869 Some(t) if !t.is_empty() => t.to_owned(),
10870 _ => filename
10871 .rsplit_once('.')
10872 .map(|(stem, _)| stem.to_owned())
10873 .unwrap_or_else(|| filename.clone()),
10874 };
10875
10876 let (width, height): (Option<i32>, Option<i32>) = decoded_dims
10879 .map(|(w, h)| (Some(w as i32), Some(h as i32)))
10880 .unwrap_or((None, None));
10881
10882 let mut row = Media {
10883 id: Auto::Unset,
10884 filename,
10885 content_hash: hash,
10886 mime,
10887 size: bytes.len() as i64,
10888 kind,
10889 width,
10890 height,
10891 storage_key,
10892 title,
10893 alt_text: alt_text.to_owned(),
10894 description: String::new(),
10895 uploaded_by,
10896 collection_id,
10897 focal_point_x: None,
10898 focal_point_y: None,
10899 uploaded_at: Auto::Unset,
10900 };
10901 row.insert_pool(pool).await?;
10902 Ok(row)
10903}
10904
10905pub async fn media_upload_submit(
10906 State(_state): State<super::AdminState>,
10907 tenant: Tenant,
10908 mut multipart: axum::extract::Multipart,
10909) -> Result<Response, AdminError> {
10910 let mut filename = String::new();
10911 let mut bytes: Vec<u8> = Vec::new();
10912 let mut title = String::new();
10913 let mut alt_text = String::new();
10914 let mut crop_x: Option<u32> = None;
10919 let mut crop_y: Option<u32> = None;
10920 let mut crop_w: Option<u32> = None;
10921 let mut crop_h: Option<u32> = None;
10922
10923 while let Some(field) = multipart
10924 .next_field()
10925 .await
10926 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
10927 {
10928 let name = field.name().unwrap_or("").to_owned();
10929 match name.as_str() {
10930 "file" => {
10931 if let Some(fname) = field.file_name() {
10932 filename = sanitize_filename(fname);
10933 }
10934 bytes = field
10935 .bytes()
10936 .await
10937 .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
10938 .to_vec();
10939 }
10940 "title" => {
10941 title = field
10942 .text()
10943 .await
10944 .map_err(|e| AdminError::Upload(format!("read title: {e}")))?;
10945 }
10946 "alt_text" => {
10947 alt_text = field
10948 .text()
10949 .await
10950 .map_err(|e| AdminError::Upload(format!("read alt_text: {e}")))?;
10951 }
10952 "crop_x" | "crop_y" | "crop_w" | "crop_h" => {
10953 let value = field
10954 .text()
10955 .await
10956 .map_err(|e| AdminError::Upload(format!("read {name}: {e}")))?;
10957 let parsed: Option<u32> = value.trim().parse().ok();
10958 match name.as_str() {
10959 "crop_x" => crop_x = parsed,
10960 "crop_y" => crop_y = parsed,
10961 "crop_w" => crop_w = parsed,
10962 "crop_h" => crop_h = parsed,
10963 _ => {}
10964 }
10965 }
10966 _ => {
10967 let _ = field.bytes().await;
10968 }
10969 }
10970 }
10971
10972 if filename.is_empty() || bytes.is_empty() {
10973 return Err(AdminError::Upload("no file submitted".into()));
10974 }
10975
10976 if let (Some(x), Some(y), Some(w), Some(h)) = (crop_x, crop_y, crop_w, crop_h) {
10980 if w > 0 && h > 0 {
10981 let detected_mime = mime_guess::from_path(&filename)
10982 .first_or_octet_stream()
10983 .essence_str()
10984 .to_owned();
10985 refuse_active_upload(&detected_mime)?;
10986 if detected_mime == "image/svg+xml" {
10987 return Err(AdminError::Validation(
10988 "Cropping SVG sources isn't supported; upload uncropped, then edit the markup."
10989 .to_owned(),
10990 ));
10991 }
10992 if detected_mime.starts_with("image/") {
10993 let (cropped, _out_mime) = crate::rendition::crop_image_off_runtime(
10994 bytes,
10995 detected_mime.clone(),
10996 (x, y, w, h),
10997 )
10998 .await
10999 .map_err(AdminError::Validation)?;
11000 bytes = cropped;
11001 }
11002 }
11003 }
11004
11005 let row = store_media(
11009 tenant.pool(),
11010 &tenant.org.slug,
11011 bytes,
11012 &filename,
11013 (!title.is_empty()).then_some(title.as_str()),
11014 &alt_text,
11015 None,
11016 None,
11017 false,
11018 )
11019 .await?;
11020
11021 let redirect = if row.kind == "image" {
11022 "/cms-admin/media"
11023 } else {
11024 "/cms-admin/documents"
11025 };
11026 Ok(Redirect::to(redirect).into_response())
11027}
11028
11029pub async fn media_delete_submit(
11031 State(_state): State<super::AdminState>,
11032 tenant: Tenant,
11033 Path(id): Path<i64>,
11034) -> Result<Response, AdminError> {
11035 let row = Media::objects()
11036 .where_(Media::id.eq(id))
11037 .first(tenant.pool())
11038 .await?
11039 .ok_or(AdminError::NotFound(id))?;
11040 crate::media_storage::disk_for(&tenant.org.slug)
11042 .delete(&crate::media_storage::key(
11043 &tenant.org.slug,
11044 &row.storage_key,
11045 ))
11046 .await
11047 .log_warn("stored file not deleted; the blob is orphaned");
11048 let redirect = if row.kind == "image" {
11049 "/cms-admin/media"
11050 } else {
11051 "/cms-admin/documents"
11052 };
11053 row.delete_pool(tenant.pool()).await?;
11054 Ok(Redirect::to(redirect).into_response())
11055}
11056
11057fn sanitize_filename(raw: &str) -> String {
11058 raw.chars()
11059 .map(|c| {
11060 if c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_') {
11061 c
11062 } else {
11063 '_'
11064 }
11065 })
11066 .collect()
11067}
11068
11069pub async fn model_admin_list(
11080 State(state): State<super::AdminState>,
11081 tenant: Tenant,
11082 headers: HeaderMap,
11083 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11084 Path(slug): Path<String>,
11085) -> Result<Response, AdminError> {
11086 let Some(ma) = super::model_admin::find(&slug) else {
11087 return Ok((axum::http::StatusCode::NOT_FOUND, "unknown model admin").into_response());
11088 };
11089 let rows_json = (ma.list_rows)(tenant.pool().clone()).await;
11090 let columns = super::model_admin::list_columns(ma.schema);
11091 let header_labels: Vec<&str> = columns.iter().map(|(_, l)| l.as_str()).collect();
11092 let body_rows: Vec<Vec<String>> = rows_json
11093 .iter()
11094 .map(|r| {
11095 columns
11096 .iter()
11097 .map(|(name, _)| super::model_admin::row_cell(r, name))
11098 .collect()
11099 })
11100 .collect();
11101 let mut ctx = Context::new();
11102 add_chrome(&mut ctx, &tenant, "model-admin", session_user.as_ref()).await;
11103 add_admin_theme(&mut ctx, tenant.pool()).await;
11104 ctx.insert("model_label", ma.label);
11105 ctx.insert("model_slug", &slug);
11106 ctx.insert("columns", &header_labels);
11107 ctx.insert("rows", &body_rows);
11108 ctx.insert("total", &body_rows.len());
11109 render_with_csrf(
11110 &state,
11111 &headers,
11112 "rcms_admin/model_admin_list.html",
11113 &mut ctx,
11114 )
11115}
11116
11117#[derive(serde::Deserialize, Default)]
11119pub struct ReportQuery {
11120 pub format: Option<String>,
11121}
11122
11123pub async fn report_view(
11127 State(state): State<super::AdminState>,
11128 tenant: Tenant,
11129 headers: HeaderMap,
11130 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11131 Path(slug): Path<String>,
11132 Query(q): Query<ReportQuery>,
11133) -> Result<Response, AdminError> {
11134 let Some(report) = super::report::find_report(&slug) else {
11135 return Ok((axum::http::StatusCode::NOT_FOUND, "unknown report").into_response());
11136 };
11137 let user_id = session_user.as_ref().and_then(|u| u.id.get().copied());
11138 let columns = report.columns();
11139 let rows = report.rows(tenant.pool(), user_id).await;
11140
11141 if q.format.as_deref() == Some("csv") {
11143 let mut out = String::with_capacity(128 + rows.len() * 64);
11144 let header: Vec<String> = columns.iter().map(|c| csv_escape(c.label)).collect();
11145 out.push_str(&header.join(","));
11146 out.push('\n');
11147 for row in &rows {
11148 let line: Vec<String> = columns
11149 .iter()
11150 .map(|c| csv_escape(&report_cell_string(row.get(c.key))))
11151 .collect();
11152 out.push_str(&line.join(","));
11153 out.push('\n');
11154 }
11155 return Ok(csv_response(&slug, &out));
11156 }
11157
11158 let header_labels: Vec<&str> = columns.iter().map(|c| c.label).collect();
11159 let view_rows: Vec<serde_json::Value> = rows
11160 .iter()
11161 .map(|row| {
11162 let cells: Vec<serde_json::Value> = columns
11163 .iter()
11164 .map(|c| {
11165 serde_json::json!({
11166 "kind": c.kind.as_str(),
11167 "value": report_cell_string(row.get(c.key)),
11168 })
11169 })
11170 .collect();
11171 serde_json::json!({
11172 "edit_url": row.get("edit_url").and_then(|v| v.as_str()),
11173 "cells": cells,
11174 })
11175 })
11176 .collect();
11177
11178 let mut ctx = Context::new();
11179 add_chrome(
11180 &mut ctx,
11181 &tenant,
11182 &format!("report:{slug}"),
11183 session_user.as_ref(),
11184 )
11185 .await;
11186 add_admin_theme(&mut ctx, tenant.pool()).await;
11187 ctx.insert("report_title", report.title());
11188 ctx.insert("report_slug", &slug);
11189 ctx.insert("report_description", &report.description());
11190 ctx.insert("columns", &header_labels);
11191 ctx.insert("rows", &view_rows);
11192 ctx.insert("total", &view_rows.len());
11193 render_with_csrf(&state, &headers, "rcms_admin/report.html", &mut ctx)
11194}
11195
11196pub async fn forms_list(
11205 State(state): State<super::AdminState>,
11206 tenant: Tenant,
11207 headers: HeaderMap,
11208 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11209) -> Result<Response, AdminError> {
11210 let pool = tenant.pool();
11211 let rows = forms_list_rows(pool).await?;
11212
11213 let mut ctx = Context::new();
11214 add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11215 add_admin_theme(&mut ctx, pool).await;
11216 ctx.insert("rows", &rows);
11217 ctx.insert("total", &rows.len());
11218 render_with_csrf(&state, &headers, "rcms_admin/forms_list.html", &mut ctx)
11219}
11220
11221pub(crate) async fn forms_list_rows(
11225 pool: &rustango::sql::Pool,
11226) -> Result<Vec<serde_json::Value>, AdminError> {
11227 let mut forms: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
11228 .where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
11229 .fetch(pool)
11230 .await?;
11231 forms.sort_by(|a, b| {
11233 b.updated_at
11234 .get()
11235 .cloned()
11236 .cmp(&a.updated_at.get().cloned())
11237 });
11238
11239 let entries: Vec<crate::forms::submit::FormEntry> = crate::forms::submit::FormEntry::objects()
11243 .fetch(pool)
11244 .await?;
11245 let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
11246 let mut last_at: std::collections::HashMap<i64, String> = std::collections::HashMap::new();
11247 for e in &entries {
11248 *counts.entry(e.form_snippet_id).or_default() += 1;
11249 if let Some(at) = e.submitted_at.get() {
11250 let s = at.format("%Y-%m-%d %H:%M").to_string();
11251 let slot = last_at.entry(e.form_snippet_id).or_default();
11252 if s > *slot {
11253 *slot = s;
11254 }
11255 }
11256 }
11257
11258 let rows: Vec<serde_json::Value> = forms
11259 .iter()
11260 .map(|s| {
11261 let id = s.id.get().copied().unwrap_or_default();
11262 let parsed = crate::forms::schema::parse(&s.data).unwrap_or_default();
11263 serde_json::json!({
11264 "id": id,
11265 "title": s.title,
11266 "slug": s.slug,
11267 "fields": parsed.field_count(),
11268 "submissions": counts.get(&id).copied().unwrap_or(0),
11269 "last_submission": last_at.get(&id).cloned().unwrap_or_default(),
11270 "updated_at": s.updated_at.get().map(|d| d.format("%Y-%m-%d").to_string()).unwrap_or_default(),
11271 "build_url": format!("/cms-admin/forms/{id}/build"),
11272 "submissions_url": format!("/cms-admin/forms/{id}/submissions"),
11273 "delete_url": format!("/cms-admin/library/{id}/delete"),
11274 })
11275 })
11276 .collect();
11277 Ok(rows)
11278}
11279
11280pub async fn form_build_form(
11284 State(state): State<super::AdminState>,
11285 tenant: Tenant,
11286 headers: HeaderMap,
11287 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11288 Path(id): Path<i64>,
11289 Query(q): Query<EditQuery>,
11290) -> Result<Response, AdminError> {
11291 let snippet = crate::snippet::Snippet::objects()
11292 .where_(crate::snippet::Snippet::id.eq(id))
11293 .first(tenant.pool())
11294 .await?
11295 .ok_or(AdminError::NotFound(id))?;
11296 if snippet.type_name != "form" {
11297 return Err(AdminError::NotFound(id));
11298 }
11299 let mut ctx = Context::new();
11300 add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11301 add_admin_theme(&mut ctx, tenant.pool()).await;
11302 ctx.insert("title", &snippet.title);
11303 ctx.insert("form_id", &id);
11304 ctx.insert("build_url", &format!("/cms-admin/forms/{id}/build"));
11305
11306 let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
11308 .where_(crate::locale::Locale::active.eq(true))
11309 .where_(crate::locale::Locale::is_default.eq(false))
11310 .fetch(tenant.pool())
11311 .await
11312 .unwrap_or_default();
11313 ctx.insert(
11314 "locales",
11315 &locales
11316 .iter()
11317 .map(|l| serde_json::json!({"code": l.code, "name": l.name}))
11318 .collect::<Vec<_>>(),
11319 );
11320
11321 if let Some(code) = q.locale.as_deref().filter(|c| !c.is_empty()) {
11324 if let Some(loc) = locales.iter().find(|l| l.code == code) {
11325 let lid = loc.id.get().copied().unwrap_or(0);
11326 let form = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11327 let leaves = crate::forms::schema::translatable_leaves(&form);
11328 let existing = crate::snippet_translation::fetch_for(tenant.pool(), id, lid)
11329 .await
11330 .unwrap_or_default();
11331 let mut groups: Vec<serde_json::Value> = Vec::new();
11334 for l in &leaves {
11335 let row = serde_json::json!({
11336 "path": l.path,
11337 "part": l.part,
11338 "n": l.n.to_string(),
11339 "canonical": l.text,
11340 "value": existing.get(&l.path).cloned().unwrap_or_default(),
11341 });
11342 let same = groups
11343 .last()
11344 .is_some_and(|g| g["name"].as_str() == Some(l.group.as_str()));
11345 if same {
11346 if let Some(arr) = groups
11347 .last_mut()
11348 .and_then(|g| g.get_mut("leaves"))
11349 .and_then(|v| v.as_array_mut())
11350 {
11351 arr.push(row);
11352 }
11353 } else {
11354 groups.push(serde_json::json!({ "name": l.group, "leaves": [row] }));
11355 }
11356 }
11357 ctx.insert("editing_locale", &loc.name);
11358 ctx.insert("editing_code", &code);
11359 ctx.insert("trans_groups", &groups);
11360 ctx.insert(
11361 "translate_url",
11362 &format!("/cms-admin/library/{id}/translate"),
11363 );
11364 return render_with_csrf(&state, &headers, "rcms_admin/form_translate.html", &mut ctx);
11365 }
11366 }
11367
11368 ctx.insert("list_url", "/cms-admin/forms");
11374 ctx.insert("publish_url", &format!("/cms-admin/forms/{id}/publish"));
11376 ctx.insert(
11377 "has_unpublished",
11378 &crate::forms::schema::has_unpublished_changes(&snippet.data),
11379 );
11380 let mut draft = crate::forms::schema::parse_draft(&snippet.data);
11381 draft.sanitize_rich_text();
11382 let schema_json = serde_json::to_string(&crate::forms::schema::to_value(&draft))
11383 .unwrap_or_else(|_| "{}".to_owned());
11384 ctx.insert("schema_json", &schema_json);
11385 render_with_csrf(&state, &headers, "rcms_admin/form_builder.html", &mut ctx)
11386}
11387
11388#[derive(Debug, Deserialize)]
11389pub struct FormBuildSubmit {
11390 pub schema: String,
11391}
11392
11393#[derive(Debug, Deserialize)]
11395pub struct FormPageTypeCreate {
11396 #[serde(default)]
11397 pub verbose_name: String,
11398 #[serde(default)]
11399 pub type_name: String,
11400 #[serde(default)]
11401 pub allowed_parents: String,
11402 #[serde(default)]
11403 pub allowed_children: String,
11404 #[serde(default)]
11408 pub view_mode: String,
11409 #[serde(default)]
11411 pub workflow: String,
11412}
11413
11414#[derive(Debug, Deserialize)]
11417pub struct FormComponentSubmit {
11418 #[serde(default)]
11419 pub slug: String,
11420 #[serde(default)]
11421 pub label: String,
11422 #[serde(default)]
11423 pub icon: String,
11424 #[serde(default)]
11425 pub description: String,
11426 #[serde(default)]
11427 pub schema: String,
11428}
11429
11430pub async fn form_preview(
11444 tenant: Tenant,
11445 Path(id): Path<i64>,
11446 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11447) -> Result<Response, AdminError> {
11448 let snippet = load_form_snippet(&tenant, id).await?;
11449 let form = crate::forms::schema::parse_draft(&snippet.data);
11450 Ok(render_form_preview(id, &form))
11451}
11452
11453pub async fn form_preview_draft(
11457 tenant: Tenant,
11458 Path(id): Path<i64>,
11459 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11460 Form(body): Form<FormBuildSubmit>,
11461) -> Result<Response, AdminError> {
11462 let snippet = load_form_snippet(&tenant, id).await?;
11463 let form = crate::forms::schema::parse_str(&body.schema)
11467 .unwrap_or_else(|_| crate::forms::schema::parse_draft(&snippet.data));
11468 Ok(render_form_preview(id, &form))
11469}
11470
11471async fn load_form_snippet(
11473 tenant: &Tenant,
11474 id: i64,
11475) -> Result<crate::snippet::Snippet, AdminError> {
11476 let snippet = crate::snippet::Snippet::objects()
11477 .where_(crate::snippet::Snippet::id.eq(id))
11478 .first(tenant.pool())
11479 .await?
11480 .ok_or(AdminError::NotFound(id))?;
11481 if snippet.type_name != "form" {
11482 return Err(AdminError::NotFound(id));
11483 }
11484 Ok(snippet)
11485}
11486
11487fn render_form_preview(id: i64, form: &crate::forms::schema::Form) -> Response {
11488 let inner = crate::forms::render::render_form_html(form, id, "");
11491 let html = format!(
11492 "<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\">\
11493 <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\
11494 <title>Form preview</title>\
11495 <style>body{{margin:0;padding:24px;font:14px/1.5 system-ui,sans-serif;}}</style>\
11496 </head><body>{inner}</body></html>"
11497 );
11498 stamp_no_cache(
11499 (
11500 [(
11501 axum::http::header::CONTENT_TYPE,
11502 axum::http::HeaderValue::from_static("text/html; charset=utf-8"),
11503 )],
11504 html,
11505 )
11506 .into_response(),
11507 )
11508}
11509
11510pub async fn form_build_submit(
11512 State(_state): State<super::AdminState>,
11513 tenant: Tenant,
11514 headers: HeaderMap,
11515 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11516 Path(id): Path<i64>,
11517 Form(form): Form<FormBuildSubmit>,
11518) -> Result<Response, AdminError> {
11519 let mut snippet = crate::snippet::Snippet::objects()
11520 .where_(crate::snippet::Snippet::id.eq(id))
11521 .first(tenant.pool())
11522 .await?
11523 .ok_or(AdminError::NotFound(id))?;
11524 if snippet.type_name != "form" {
11525 return Err(AdminError::NotFound(id));
11526 }
11527 let mut parsed = crate::forms::schema::parse_str(&form.schema)
11528 .map_err(|e| AdminError::Validation(format!("invalid form schema: {e}")))?;
11529 parsed.sanitize_rich_text();
11530 let mut warnings = crate::forms::schema::validate(&parsed);
11531 snippet.data = crate::forms::schema::save_draft_value(&snippet.data, &parsed);
11534 snippet.save_pool(tenant.pool()).await?;
11535 if let Err(e) = crate::notify::targets::sync_form_email(
11538 tenant.pool(),
11539 id,
11540 &snippet.title,
11541 &parsed.settings.notify_emails,
11542 )
11543 .await
11544 {
11545 tracing::warn!(
11546 target: "rustango_cms::notify",
11547 error = %e, form_id = id,
11548 "could not sync the form's email notification target"
11549 );
11550 warnings.push(format!("Email notifications are off: {e}."));
11551 }
11552 let (level, msg) = if warnings.is_empty() {
11553 (MsgLevel::Success, "Draft saved.".to_owned())
11554 } else {
11555 (
11556 MsgLevel::Warning,
11557 format!("Draft saved with warnings: {}", warnings.join(" ")),
11558 )
11559 };
11560 redirect_named_with_params_and_message(
11561 "rcms-admin:forms:build",
11562 &[("id", id.to_string())],
11563 level,
11564 &msg,
11565 &headers,
11566 )
11567}
11568
11569pub async fn form_publish_submit(
11572 State(_state): State<super::AdminState>,
11573 tenant: Tenant,
11574 headers: HeaderMap,
11575 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11576 Path(id): Path<i64>,
11577 Form(form): Form<FormBuildSubmit>,
11578) -> Result<Response, AdminError> {
11579 let mut snippet = crate::snippet::Snippet::objects()
11580 .where_(crate::snippet::Snippet::id.eq(id))
11581 .first(tenant.pool())
11582 .await?
11583 .ok_or(AdminError::NotFound(id))?;
11584 if snippet.type_name != "form" {
11585 return Err(AdminError::NotFound(id));
11586 }
11587 let mut parsed = crate::forms::schema::parse_str(&form.schema)
11588 .map_err(|e| AdminError::Validation(format!("invalid form schema: {e}")))?;
11589 parsed.sanitize_rich_text();
11590 snippet.data = crate::forms::schema::publish_value(&parsed);
11591 snippet.save_pool(tenant.pool()).await?;
11592 if let Some(h) = crate::library::find_handler(&snippet.type_name) {
11593 if h.revisions_enabled() {
11594 let uid = session_user.as_ref().and_then(|u| u.id.get().copied());
11595 crate::snippet::capture_revision(tenant.pool(), &snippet, uid)
11596 .await
11597 .log_warn("revision not captured; the history has a gap");
11598 }
11599 }
11600 redirect_named_with_params_and_message(
11601 "rcms-admin:forms:build",
11602 &[("id", id.to_string())],
11603 MsgLevel::Success,
11604 "Form published — the live form is now up to date.",
11605 &headers,
11606 )
11607}
11608
11609async fn load_form_submissions(
11613 pool: &rustango::sql::Pool,
11614 form_id: i64,
11615) -> Result<
11616 (
11617 crate::snippet::Snippet,
11618 Vec<(String, String)>,
11619 Vec<crate::forms::submit::FormEntry>,
11620 std::collections::HashMap<i64, String>,
11621 ),
11622 AdminError,
11623> {
11624 let snippet = crate::snippet::Snippet::objects()
11625 .where_(crate::snippet::Snippet::id.eq(form_id))
11626 .where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
11627 .first(pool)
11628 .await?
11629 .ok_or(AdminError::NotFound(form_id))?;
11630 let form = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11631 let columns: Vec<(String, String)> = form
11632 .fields()
11633 .filter(|f| f.field_type.collects_value() && !f.key.is_empty())
11634 .map(|f| {
11635 (
11636 f.key.clone(),
11637 if f.label.is_empty() {
11638 f.key.clone()
11639 } else {
11640 f.label.clone()
11641 },
11642 )
11643 })
11644 .collect();
11645 let entries: Vec<crate::forms::submit::FormEntry> = crate::forms::submit::FormEntry::objects()
11646 .where_(crate::forms::submit::FormEntry::form_snippet_id.eq(form_id))
11647 .order_by(&[("submitted_at", true)])
11648 .fetch(pool)
11649 .await?;
11650 let mut page_urls = std::collections::HashMap::new();
11652 let ids: Vec<i64> = entries
11653 .iter()
11654 .map(|e| e.source_page_id)
11655 .filter(|i| *i != 0)
11656 .collect();
11657 if !ids.is_empty() {
11658 if let Ok(pages) = crate::page::Page::objects().fetch(pool).await {
11659 for p in pages {
11660 if let Some(pid) = p.id.get().copied() {
11661 if ids.contains(&pid) {
11662 page_urls.insert(pid, p.url_path.clone());
11663 }
11664 }
11665 }
11666 }
11667 }
11668 Ok((snippet, columns, entries, page_urls))
11669}
11670
11671fn submission_cell(data: &serde_json::Value, key: &str) -> String {
11673 match data.get(key) {
11674 Some(serde_json::Value::Array(items)) => items
11675 .iter()
11676 .filter_map(|v| v.as_str().map(str::to_owned))
11677 .collect::<Vec<_>>()
11678 .join("; "),
11679 Some(serde_json::Value::String(s)) => s.clone(),
11680 Some(other) => other.to_string(),
11681 None => String::new(),
11682 }
11683}
11684
11685pub async fn form_submissions_list(
11688 State(state): State<super::AdminState>,
11689 tenant: Tenant,
11690 headers: HeaderMap,
11691 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11692 Path(id): Path<i64>,
11693) -> Result<Response, AdminError> {
11694 let (snippet, columns, entries, page_urls) = load_form_submissions(tenant.pool(), id).await?;
11695 let parsed = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11697 let file_keys: std::collections::HashSet<String> = parsed
11698 .fields()
11699 .filter(|f| matches!(f.field_type, crate::forms::schema::FieldType::File))
11700 .map(|f| f.key.clone())
11701 .collect();
11702 let rows: Vec<serde_json::Value> = entries
11703 .iter()
11704 .map(|e| {
11705 let cells: Vec<serde_json::Value> = columns
11706 .iter()
11707 .map(|(k, _)| {
11708 let v = submission_cell(&e.data_json, k);
11709 if file_keys.contains(k) && !v.is_empty() {
11710 let name = v.splitn(2, '-').nth(1).unwrap_or(&v).to_owned();
11712 serde_json::json!({
11713 "value": name,
11714 "url": format!("/cms-admin/forms/{id}/submissions/file/{v}"),
11715 })
11716 } else {
11717 serde_json::json!({ "value": v })
11718 }
11719 })
11720 .collect();
11721 serde_json::json!({
11722 "submitted_at": e
11725 .submitted_at
11726 .get()
11727 .map(|t| t.to_rfc3339_opts(chrono::SecondsFormat::Secs, true))
11728 .unwrap_or_default(),
11729 "submitted_at_text": e
11730 .submitted_at
11731 .get()
11732 .map(|t| t.format("%Y-%m-%d %H:%M UTC").to_string())
11733 .unwrap_or_default(),
11734 "ip": e.ip,
11735 "source_page": if e.source_page_id == 0 {
11736 serde_json::Value::Null
11737 } else {
11738 serde_json::json!({
11739 "id": e.source_page_id,
11740 "url": page_urls.get(&e.source_page_id).cloned().unwrap_or_default(),
11741 })
11742 },
11743 "cells": cells,
11744 })
11745 })
11746 .collect();
11747 let mut ctx = Context::new();
11748 add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11749 add_admin_theme(&mut ctx, tenant.pool()).await;
11750 ctx.insert("form_title", &snippet.title);
11751 ctx.insert("form_id", &id);
11752 ctx.insert("build_url", &format!("/cms-admin/forms/{id}/build"));
11753 ctx.insert(
11754 "csv_url",
11755 &format!("/cms-admin/forms/{id}/submissions/export.csv"),
11756 );
11757 ctx.insert(
11758 "columns",
11759 &columns.iter().map(|(_, l)| l).collect::<Vec<_>>(),
11760 );
11761 ctx.insert("rows", &rows);
11762 ctx.insert("total", &entries.len());
11763 render_with_csrf(
11764 &state,
11765 &headers,
11766 "rcms_admin/form_submissions.html",
11767 &mut ctx,
11768 )
11769}
11770
11771pub async fn form_submissions_csv(
11773 State(_state): State<super::AdminState>,
11774 tenant: Tenant,
11775 Path(id): Path<i64>,
11776) -> Result<Response, AdminError> {
11777 let (snippet, columns, entries, page_urls) = load_form_submissions(tenant.pool(), id).await?;
11778 let mut out = String::new();
11779 out.push_str("submitted_at,source_page,ip");
11780 for (_, label) in &columns {
11781 out.push(',');
11782 out.push_str(&csv_escape(label));
11783 }
11784 out.push('\n');
11785 for e in &entries {
11786 let when = e
11787 .submitted_at
11788 .get()
11789 .map(ToString::to_string)
11790 .unwrap_or_default();
11791 let src = if e.source_page_id == 0 {
11792 String::new()
11793 } else {
11794 page_urls
11795 .get(&e.source_page_id)
11796 .cloned()
11797 .unwrap_or_default()
11798 };
11799 out.push_str(&csv_escape(&when));
11800 out.push(',');
11801 out.push_str(&csv_escape(&src));
11802 out.push(',');
11803 out.push_str(&csv_escape(&e.ip));
11804 for (k, _) in &columns {
11805 out.push(',');
11806 out.push_str(&csv_escape(&submission_cell(&e.data_json, k)));
11807 }
11808 out.push('\n');
11809 }
11810 let filename = format!("submissions-{}.csv", snippet.slug);
11811 Ok(csv_response(&filename, &out))
11812}
11813
11814pub async fn form_submission_file(
11818 State(_state): State<super::AdminState>,
11819 tenant: Tenant,
11820 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11821 Path((_id, key)): Path<(i64, String)>,
11822) -> Result<Response, AdminError> {
11823 if key.contains('/') || key.contains('\\') || key.contains("..") || key.is_empty() {
11824 return Err(AdminError::NotFound(0));
11825 }
11826 let path = std::path::PathBuf::from("./var/form-uploads")
11827 .join(&tenant.org.slug)
11828 .join(&key);
11829 let bytes = std::fs::read(&path).map_err(|_| AdminError::NotFound(0))?;
11830 let mime = mime_guess::from_path(&key)
11831 .first_or_octet_stream()
11832 .essence_str()
11833 .to_owned();
11834 let download = key.splitn(2, '-').nth(1).unwrap_or(&key).to_owned();
11835 Ok((
11836 [
11837 (header::CONTENT_TYPE, mime),
11838 (
11839 header::CONTENT_DISPOSITION,
11840 format!("attachment; filename=\"{download}\""),
11841 ),
11842 ],
11843 bytes,
11844 )
11845 .into_response())
11846}
11847
11848#[derive(Debug, Deserialize)]
11849pub struct SetLangQuery {
11850 pub lang: String,
11851}
11852
11853pub async fn admin_set_language(
11859 tenant: Tenant,
11860 headers: HeaderMap,
11861 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11862 Form(q): Form<SetLangQuery>,
11863) -> Response {
11864 let lang = if super::i18n::is_ui_locale(&q.lang) {
11865 q.lang
11866 } else {
11867 "en".to_owned()
11868 };
11869 if let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) {
11873 persist_user_admin_lang(tenant.pool(), uid, &lang)
11874 .await
11875 .log_warn("admin language preference not saved");
11876 }
11877 let back = headers
11881 .get(header::REFERER)
11882 .and_then(|v| v.to_str().ok())
11883 .and_then(|r| match r.split_once("://") {
11884 Some((_, rest)) => rest.find('/').map(|i| &rest[i..]),
11885 None => Some(r),
11886 })
11887 .and_then(rustango::auth_decorators::safe_next)
11888 .unwrap_or_else(|| "/cms-admin/".to_owned());
11889 let cookie = format!(
11890 "{}={lang}; Path=/; SameSite=Lax; Max-Age=31536000",
11891 super::i18n::ADMIN_LANG_COOKIE
11892 );
11893 let mut resp = axum::response::Redirect::to(&back).into_response();
11894 if let Ok(v) = HeaderValue::from_str(&cookie) {
11895 resp.headers_mut().append(header::SET_COOKIE, v);
11896 }
11897 resp
11898}
11899
11900fn csv_escape(s: &str) -> String {
11904 if s.contains(',') || s.contains('"') || s.contains('\n') || s.contains('\r') {
11905 let mut out = String::with_capacity(s.len() + 2);
11906 out.push('"');
11907 for c in s.chars() {
11908 if c == '"' {
11909 out.push('"');
11910 }
11911 out.push(c);
11912 }
11913 out.push('"');
11914 out
11915 } else {
11916 s.to_owned()
11917 }
11918}
11919
11920fn report_cell_string(v: Option<&serde_json::Value>) -> String {
11923 match v {
11924 Some(serde_json::Value::String(s)) => s.clone(),
11925 None | Some(serde_json::Value::Null) => String::new(),
11926 Some(other) => other.to_string(),
11927 }
11928}
11929
11930pub async fn locale_list(
11931 State(state): State<super::AdminState>,
11932 tenant: Tenant,
11933 headers: HeaderMap,
11934 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11935) -> Result<Response, AdminError> {
11936 let items: Vec<Locale> = Locale::objects()
11937 .order_by(&[("sort_order", false), ("code", false)])
11938 .fetch(tenant.pool())
11939 .await?;
11940 let rows: Vec<serde_json::Value> = items
11945 .iter()
11946 .map(|l| {
11947 let info = rustango::i18n::locale_info(&l.code);
11948 let ui = super::i18n::is_ui_locale(&l.code);
11949 let mut v = serde_json::to_value(l).unwrap_or_default();
11950 v["support"] = serde_json::json!({
11951 "ui_translated": ui,
11952 "known": info.known,
11953 "display_name": info.display_name,
11954 "has_plural_rules": info.has_plural_rules,
11955 "is_rtl": info.is_rtl,
11956 "content_only": !ui,
11957 });
11958 v
11959 })
11960 .collect();
11961 let mut ctx = Context::new();
11962 add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
11963 add_admin_theme(&mut ctx, tenant.pool()).await;
11964 ctx.insert("items", &rows);
11965 render_with_csrf(&state, &headers, "rcms_admin/locale_list.html", &mut ctx)
11966}
11967
11968fn insert_known_locales(ctx: &mut Context) {
11974 let known: Vec<serde_json::Value> = rustango::i18n::known_locales()
11975 .map(|(code, name)| serde_json::json!({ "code": code, "name": name }))
11976 .collect();
11977 let meta: serde_json::Map<String, serde_json::Value> = rustango::i18n::known_locales()
11978 .map(|(code, _)| {
11979 let info = rustango::i18n::locale_info(code);
11980 (
11981 code.to_owned(),
11982 serde_json::json!({
11983 "ui": super::i18n::is_ui_locale(code),
11984 "is_rtl": info.is_rtl,
11985 "has_plural_rules": info.has_plural_rules,
11986 }),
11987 )
11988 })
11989 .collect();
11990 ctx.insert("known_locales", &known);
11991 ctx.insert("known_locales_meta", &serde_json::Value::Object(meta));
11992}
11993
11994pub async fn locale_new_form(
11995 State(state): State<super::AdminState>,
11996 tenant: Tenant,
11997 headers: HeaderMap,
11998 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11999) -> Result<Response, AdminError> {
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 insert_known_locales(&mut ctx);
12004 ctx.insert("mode", "new");
12005 ctx.insert(
12006 "locale",
12007 &serde_json::json!({
12008 "code": "",
12009 "name": "",
12010 "is_default": false,
12011 "active": true,
12012 "sort_order": 100,
12013 }),
12014 );
12015 render_with_csrf(&state, &headers, "rcms_admin/locale_form.html", &mut ctx)
12016}
12017
12018#[derive(Debug, Deserialize)]
12019pub struct LocaleForm {
12020 pub code: String,
12021 pub name: String,
12022 #[serde(default)]
12023 pub is_default: Option<String>,
12024 #[serde(default)]
12025 pub active: Option<String>,
12026 #[serde(default)]
12027 pub sort_order: Option<i32>,
12028}
12029
12030impl LocaleForm {
12031 fn parsed_default(&self) -> bool {
12032 self.is_default.is_some()
12033 }
12034 fn parsed_active(&self) -> bool {
12035 self.active.is_some()
12036 }
12037 fn parsed_sort_order(&self) -> i32 {
12038 self.sort_order.unwrap_or(100)
12039 }
12040}
12041
12042pub async fn locale_new_submit(
12043 State(_state): State<super::AdminState>,
12044 tenant: Tenant,
12045 headers: HeaderMap,
12046 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12047 Form(form): Form<LocaleForm>,
12048) -> Result<Response, AdminError> {
12049 use rustango::sql::Auto;
12050 let name = form.name.trim().to_owned();
12051 if name.is_empty() {
12052 return Err(AdminError::Validation(
12053 "Display name is required.".to_owned(),
12054 ));
12055 }
12056 let mut row = Locale {
12057 id: Auto::Unset,
12058 code: crate::locale::validate_code(&form.code).map_err(AdminError::Validation)?,
12059 name,
12060 is_default: form.parsed_default(),
12061 active: form.parsed_active(),
12062 sort_order: form.parsed_sort_order(),
12063 created_at: Auto::Unset,
12064 };
12065 if row.is_default {
12066 clear_default_flag(&tenant, None).await?;
12067 }
12068 row.insert_pool(tenant.pool()).await?;
12069 redirect_named_with_message_args(
12070 "rcms-admin:locales:list",
12071 MsgLevel::Success,
12072 "Added locale {name} ({code}).",
12073 &[("name", row.name.as_str()), ("code", row.code.as_str())],
12074 &headers,
12075 )
12076}
12077
12078pub async fn locale_edit_form(
12079 State(state): State<super::AdminState>,
12080 tenant: Tenant,
12081 headers: HeaderMap,
12082 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12083 Path(id): Path<i64>,
12084) -> Result<Response, AdminError> {
12085 let row = Locale::objects()
12086 .where_(Locale::id.eq(id))
12087 .first(tenant.pool())
12088 .await?
12089 .ok_or(AdminError::NotFound(id))?;
12090 let mut ctx = Context::new();
12091 add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
12092 add_admin_theme(&mut ctx, tenant.pool()).await;
12093 insert_known_locales(&mut ctx);
12094 ctx.insert("mode", "edit");
12095 ctx.insert("locale", &row);
12096 render_with_csrf(&state, &headers, "rcms_admin/locale_form.html", &mut ctx)
12097}
12098
12099pub async fn locale_edit_submit(
12100 State(_state): State<super::AdminState>,
12101 tenant: Tenant,
12102 headers: HeaderMap,
12103 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12104 Path(id): Path<i64>,
12105 Form(form): Form<LocaleForm>,
12106) -> Result<Response, AdminError> {
12107 let mut row = Locale::objects()
12108 .where_(Locale::id.eq(id))
12109 .first(tenant.pool())
12110 .await?
12111 .ok_or(AdminError::NotFound(id))?;
12112 let name = form.name.trim().to_owned();
12113 if name.is_empty() {
12114 return Err(AdminError::Validation(
12115 "Display name is required.".to_owned(),
12116 ));
12117 }
12118 row.code = crate::locale::validate_code(&form.code).map_err(AdminError::Validation)?;
12119 row.name = name;
12120 row.is_default = form.parsed_default();
12121 row.active = form.parsed_active();
12122 row.sort_order = form.parsed_sort_order();
12123 if row.is_default {
12124 clear_default_flag(&tenant, Some(id)).await?;
12125 }
12126 row.save_pool(tenant.pool()).await?;
12127 redirect_named_with_message_args(
12128 "rcms-admin:locales:list",
12129 MsgLevel::Success,
12130 "Saved locale {name} ({code}).",
12131 &[("name", row.name.as_str()), ("code", row.code.as_str())],
12132 &headers,
12133 )
12134}
12135
12136pub async fn locale_delete_submit(
12137 State(_state): State<super::AdminState>,
12138 tenant: Tenant,
12139 headers: HeaderMap,
12140 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12141 Path(id): Path<i64>,
12142) -> Result<Response, AdminError> {
12143 let row = Locale::objects()
12144 .where_(Locale::id.eq(id))
12145 .first(tenant.pool())
12146 .await?
12147 .ok_or(AdminError::NotFound(id))?;
12148 if row.is_default {
12149 return redirect_named_with_message(
12150 "rcms-admin:locales:list",
12151 MsgLevel::Error,
12152 "Cannot delete the default locale — promote another locale to default first.",
12153 &headers,
12154 );
12155 }
12156 let label = format!("{} ({})", row.name, row.code);
12157 let pages = crate::translation::Translation::objects()
12160 .where_(crate::translation::Translation::locale_id.eq(id))
12161 .compile_delete()
12162 .map_err(rustango::sql::ExecError::from)?;
12163 let snippets = crate::snippet_translation::SnippetTranslation::objects()
12164 .where_(crate::snippet_translation::SnippetTranslation::locale_id.eq(id))
12165 .compile_delete()
12166 .map_err(rustango::sql::ExecError::from)?;
12167 let menus = crate::menu_item_translation::MenuItemTranslation::objects()
12168 .where_(crate::menu_item_translation::MenuItemTranslation::locale_id.eq(id))
12169 .compile_delete()
12170 .map_err(rustango::sql::ExecError::from)?;
12171 let categories = crate::category_translation::CategoryTranslation::objects()
12172 .where_(crate::category_translation::CategoryTranslation::locale_id.eq(id))
12173 .compile_delete()
12174 .map_err(rustango::sql::ExecError::from)?;
12175 rustango::atomic!(tenant.pool(), |tx| {
12176 let mut guard = tx.lock().await?;
12177 let tx = &mut *guard;
12178 for q in [&pages, &snippets, &menus, &categories] {
12179 rustango::sql::delete_tx(tx, q).await?;
12180 }
12181 row.delete_tx(tx).await?;
12182 Ok::<_, rustango::sql::ExecError>(())
12183 })
12184 .await?;
12185 redirect_named_with_message_args(
12186 "rcms-admin:locales:list",
12187 MsgLevel::Success,
12188 "Deleted locale {label}.",
12189 &[("label", label.as_str())],
12190 &headers,
12191 )
12192}
12193
12194const SSO_KINDS: &[(&str, &str)] = &[
12206 ("google", "Google"),
12207 ("microsoft", "Microsoft"),
12208 ("github", "GitHub"),
12209 ("gitlab", "GitLab"),
12210 ("discord", "Discord"),
12211 ("oidc", "Generic OpenID Connect"),
12212];
12213
12214fn sso_provider_json(p: &rustango::admin::SsoProvider) -> serde_json::Value {
12217 serde_json::json!({
12218 "id": p.id.get().copied().unwrap_or_default(),
12219 "slug": p.slug,
12220 "label": p.label,
12221 "kind": p.kind,
12222 "issuer_url": p.issuer_url,
12223 "client_id": p.client_id,
12224 "has_secret": !p.client_secret.is_empty(),
12227 "enabled": p.enabled,
12228 "sort_order": p.sort_order,
12229 "scopes": p.scopes,
12230 })
12231}
12232
12233pub async fn sso_provider_list(
12234 State(state): State<super::AdminState>,
12235 tenant: Tenant,
12236 headers: HeaderMap,
12237 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12238) -> Result<Response, AdminError> {
12239 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12241 return Ok(redirect);
12242 }
12243 use rustango::sql::FetcherPool as _;
12244 let mut items: Vec<rustango::admin::SsoProvider> = rustango::admin::SsoProvider::objects()
12245 .fetch(tenant.pool())
12246 .await
12247 .unwrap_or_default();
12248 items.sort_by(|a, b| a.sort_order.cmp(&b.sort_order).then(a.slug.cmp(&b.slug)));
12249 let rows: Vec<serde_json::Value> = items.iter().map(sso_provider_json).collect();
12250 let mut ctx = Context::new();
12251 add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12252 add_admin_theme(&mut ctx, tenant.pool()).await;
12253 ctx.insert("items", &rows);
12254 render_with_csrf(
12255 &state,
12256 &headers,
12257 "rcms_admin/sso_provider_list.html",
12258 &mut ctx,
12259 )
12260}
12261
12262#[derive(Deserialize)]
12263pub struct SsoProviderForm {
12264 pub slug: String,
12265 pub label: String,
12266 pub kind: String,
12267 #[serde(default)]
12268 pub issuer_url: String,
12269 pub client_id: String,
12270 #[serde(default)]
12273 pub client_secret: String,
12274 #[serde(default)]
12275 pub scopes: String,
12276 #[serde(default)]
12277 pub enabled: Option<String>,
12278 #[serde(default)]
12279 pub sort_order: Option<i32>,
12280}
12281
12282impl SsoProviderForm {
12283 fn validated(&self) -> Result<ValidatedProvider, String> {
12285 let slug = self.slug.trim().to_lowercase();
12286 if slug.is_empty()
12287 || !slug
12288 .chars()
12289 .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
12290 {
12291 return Err(
12292 "Slug is required and may only contain letters, numbers, - and _.".to_owned(),
12293 );
12294 }
12295 let label = self.label.trim().to_owned();
12296 if label.is_empty() {
12297 return Err("Button label is required.".to_owned());
12298 }
12299 let kind = self.kind.trim().to_lowercase();
12300 if !SSO_KINDS.iter().any(|(k, _)| *k == kind) {
12301 return Err("Pick a provider type.".to_owned());
12302 }
12303 let client_id = self.client_id.trim().to_owned();
12304 if client_id.is_empty() {
12305 return Err("Client ID is required.".to_owned());
12306 }
12307 let issuer = self.issuer_url.trim().to_owned();
12308 if kind == "oidc" && issuer.is_empty() {
12309 return Err("A generic OpenID Connect provider needs an issuer URL.".to_owned());
12310 }
12311 let scopes = self.scopes.trim().to_owned();
12312 Ok(ValidatedProvider {
12313 slug,
12314 label,
12315 kind,
12316 issuer_url: (!issuer.is_empty()).then_some(issuer),
12317 client_id,
12318 scopes: (!scopes.is_empty()).then_some(scopes),
12319 enabled: self.enabled.is_some(),
12320 sort_order: self.sort_order.unwrap_or(0),
12321 })
12322 }
12323}
12324
12325struct ValidatedProvider {
12326 slug: String,
12327 label: String,
12328 kind: String,
12329 issuer_url: Option<String>,
12330 client_id: String,
12331 scopes: Option<String>,
12332 enabled: bool,
12333 sort_order: i32,
12334}
12335
12336fn render_sso_provider_form(ctx: &mut Context, mode: &str, provider: serde_json::Value) {
12337 let kinds: Vec<serde_json::Value> = SSO_KINDS
12338 .iter()
12339 .map(|(k, name)| serde_json::json!({ "key": k, "name": name }))
12340 .collect();
12341 ctx.insert("mode", mode);
12342 ctx.insert("kinds", &kinds);
12343 ctx.insert("provider", &provider);
12344}
12345
12346pub async fn sso_provider_new_form(
12347 State(state): State<super::AdminState>,
12348 tenant: Tenant,
12349 headers: HeaderMap,
12350 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12351) -> Result<Response, AdminError> {
12352 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12354 return Ok(redirect);
12355 }
12356 let mut ctx = Context::new();
12357 add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12358 add_admin_theme(&mut ctx, tenant.pool()).await;
12359 render_sso_provider_form(
12360 &mut ctx,
12361 "new",
12362 serde_json::json!({
12363 "slug": "", "label": "", "kind": "google", "issuer_url": null,
12364 "client_id": "", "has_secret": false, "scopes": null,
12365 "enabled": true, "sort_order": 0,
12366 }),
12367 );
12368 render_with_csrf(
12369 &state,
12370 &headers,
12371 "rcms_admin/sso_provider_form.html",
12372 &mut ctx,
12373 )
12374}
12375
12376async fn find_sso_provider(
12377 tenant: &Tenant,
12378 id: i64,
12379) -> Result<rustango::admin::SsoProvider, AdminError> {
12380 use rustango::sql::FetcherPool as _;
12381 rustango::admin::SsoProvider::objects()
12382 .filter("id", id)
12383 .fetch(tenant.pool())
12384 .await
12385 .map_err(|e| AdminError::Validation(format!("db: {e}")))?
12386 .into_iter()
12387 .next()
12388 .ok_or(AdminError::NotFound(id))
12389}
12390
12391pub async fn sso_provider_edit_form(
12392 State(state): State<super::AdminState>,
12393 tenant: Tenant,
12394 headers: HeaderMap,
12395 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12396 Path(id): Path<i64>,
12397) -> Result<Response, AdminError> {
12398 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12400 return Ok(redirect);
12401 }
12402 let row = find_sso_provider(&tenant, id).await?;
12403 let mut ctx = Context::new();
12404 add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12405 add_admin_theme(&mut ctx, tenant.pool()).await;
12406 render_sso_provider_form(&mut ctx, "edit", sso_provider_json(&row));
12407 render_with_csrf(
12408 &state,
12409 &headers,
12410 "rcms_admin/sso_provider_form.html",
12411 &mut ctx,
12412 )
12413}
12414
12415pub async fn sso_provider_new_submit(
12416 State(_state): State<super::AdminState>,
12417 tenant: Tenant,
12418 headers: HeaderMap,
12419 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12420 Form(form): Form<SsoProviderForm>,
12421) -> Result<Response, AdminError> {
12422 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12424 return Ok(redirect);
12425 }
12426 let v = form.validated().map_err(AdminError::Validation)?;
12427 let secret = form.client_secret.trim().to_owned();
12428 if secret.is_empty() {
12429 return Err(AdminError::Validation(
12430 "Client secret is required.".to_owned(),
12431 ));
12432 }
12433 let mut row = rustango::admin::SsoProvider {
12434 id: rustango::sql::Auto::Unset,
12435 slug: v.slug,
12436 label: v.label,
12437 kind: v.kind,
12438 issuer_url: v.issuer_url,
12439 client_id: v.client_id,
12440 client_secret: rustango::casts::Cast::new(secret),
12441 enabled: v.enabled,
12442 sort_order: v.sort_order,
12443 scopes: v.scopes,
12444 allow_email_link: false,
12445 created_at: rustango::sql::Auto::Unset,
12446 updated_at: rustango::sql::Auto::Unset,
12447 };
12448 row.insert_pool(tenant.pool()).await?;
12449 redirect_named_with_message_args(
12450 "rcms-admin:sso-providers:list",
12451 MsgLevel::Success,
12452 "Added SSO provider {label}.",
12453 &[("label", row.label.as_str())],
12454 &headers,
12455 )
12456}
12457
12458pub async fn sso_provider_edit_submit(
12459 State(_state): State<super::AdminState>,
12460 tenant: Tenant,
12461 headers: HeaderMap,
12462 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12463 Path(id): Path<i64>,
12464 Form(form): Form<SsoProviderForm>,
12465) -> Result<Response, AdminError> {
12466 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12468 return Ok(redirect);
12469 }
12470 let mut row = find_sso_provider(&tenant, id).await?;
12471 let v = form.validated().map_err(AdminError::Validation)?;
12472 row.slug = v.slug;
12473 row.label = v.label;
12474 row.kind = v.kind;
12475 row.issuer_url = v.issuer_url;
12476 row.client_id = v.client_id;
12477 let new_secret = form.client_secret.trim();
12480 if !new_secret.is_empty() {
12481 row.client_secret = rustango::casts::Cast::new(new_secret.to_owned());
12482 }
12483 row.enabled = v.enabled;
12484 row.sort_order = v.sort_order;
12485 row.scopes = v.scopes;
12486 row.save_pool(tenant.pool()).await?;
12487 redirect_named_with_message_args(
12488 "rcms-admin:sso-providers:list",
12489 MsgLevel::Success,
12490 "Saved SSO provider {label}.",
12491 &[("label", row.label.as_str())],
12492 &headers,
12493 )
12494}
12495
12496pub async fn sso_provider_delete_submit(
12497 State(_state): State<super::AdminState>,
12498 tenant: Tenant,
12499 headers: HeaderMap,
12500 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12501 Path(id): Path<i64>,
12502) -> Result<Response, AdminError> {
12503 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12505 return Ok(redirect);
12506 }
12507 let row = find_sso_provider(&tenant, id).await?;
12508 let label = row.label.clone();
12509 row.delete_pool(tenant.pool()).await?;
12510 redirect_named_with_message_args(
12511 "rcms-admin:sso-providers:list",
12512 MsgLevel::Success,
12513 "Deleted SSO provider {label}.",
12514 &[("label", label.as_str())],
12515 &headers,
12516 )
12517}
12518
12519async fn clear_default_flag(tenant: &Tenant, except: Option<i64>) -> Result<(), AdminError> {
12523 let rows: Vec<Locale> = Locale::objects()
12524 .where_(Locale::is_default.eq(true))
12525 .fetch(tenant.pool())
12526 .await?;
12527 for mut r in rows {
12528 if let (Some(skip), Some(id)) = (except, r.id.get().copied()) {
12529 if skip == id {
12530 continue;
12531 }
12532 }
12533 r.is_default = false;
12534 r.save_pool(tenant.pool()).await?;
12535 }
12536 Ok(())
12537}
12538
12539pub async fn workflows_list(
12544 State(state): State<super::AdminState>,
12545 tenant: Tenant,
12546 headers: HeaderMap,
12547 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12548) -> Result<Response, AdminError> {
12549 let items: Vec<crate::workflow::Workflow> = crate::workflow::Workflow::objects()
12550 .order_by(&[("name", false)])
12551 .fetch(tenant.pool())
12552 .await?;
12553 let all_tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12556 .fetch(tenant.pool())
12557 .await?;
12558 let mut task_counts: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
12559 for t in &all_tasks {
12560 *task_counts.entry(t.workflow_id).or_insert(0) += 1;
12561 }
12562 let rows: Vec<serde_json::Value> = items
12563 .iter()
12564 .map(|w| {
12565 let id = w.id.get().copied().unwrap_or_default();
12566 serde_json::json!({
12567 "id": id,
12568 "name": w.name,
12569 "description": w.description,
12570 "active": w.active,
12571 "require_reapproval_on_edit": w.require_reapproval_on_edit,
12572 "task_count": task_counts.get(&id).copied().unwrap_or(0),
12573 "created_at": w.created_at.get().copied(),
12574 })
12575 })
12576 .collect();
12577 let mut ctx = Context::new();
12578 add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12579 add_admin_theme(&mut ctx, tenant.pool()).await;
12580 ctx.insert("items", &rows);
12581 render_with_csrf(&state, &headers, "rcms_admin/workflow_list.html", &mut ctx)
12582}
12583
12584pub async fn workflow_new_form(
12585 State(state): State<super::AdminState>,
12586 tenant: Tenant,
12587 headers: HeaderMap,
12588 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12589) -> Result<Response, AdminError> {
12590 let mut ctx = Context::new();
12591 add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12592 add_admin_theme(&mut ctx, tenant.pool()).await;
12593 ctx.insert("mode", "new");
12594 ctx.insert(
12595 "workflow",
12596 &serde_json::json!({
12597 "name": "",
12598 "description": "",
12599 "active": true,
12600 "require_reapproval_on_edit": false,
12601 }),
12602 );
12603 ctx.insert("tasks", &Vec::<serde_json::Value>::new());
12604 ctx.insert("roles", &Vec::<serde_json::Value>::new());
12605 render_with_csrf(&state, &headers, "rcms_admin/workflow_form.html", &mut ctx)
12606}
12607
12608#[derive(Debug, Deserialize)]
12609pub struct WorkflowForm {
12610 pub name: String,
12611 #[serde(default)]
12612 pub description: String,
12613 #[serde(default)]
12614 pub active: Option<String>,
12615 #[serde(default)]
12616 pub require_reapproval_on_edit: Option<String>,
12617}
12618
12619impl WorkflowForm {
12620 fn parsed_active(&self) -> bool {
12621 self.active.is_some()
12622 }
12623 fn parsed_reapproval(&self) -> bool {
12624 self.require_reapproval_on_edit.is_some()
12625 }
12626}
12627
12628pub async fn workflow_new_submit(
12629 State(_state): State<super::AdminState>,
12630 tenant: Tenant,
12631 headers: HeaderMap,
12632 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12633 Form(form): Form<WorkflowForm>,
12634) -> Result<Response, AdminError> {
12635 use rustango::sql::Auto;
12636 let name = form.name.trim().to_owned();
12637 if name.is_empty() {
12638 return redirect_named_with_message(
12639 "rcms-admin:workflows:list",
12640 MsgLevel::Error,
12641 "Workflow name is required.",
12642 &headers,
12643 );
12644 }
12645 let mut row = crate::workflow::Workflow {
12646 id: Auto::Unset,
12647 name: name.clone(),
12648 description: form.description.trim().to_owned(),
12649 active: form.parsed_active(),
12650 require_reapproval_on_edit: form.parsed_reapproval(),
12651 created_at: Auto::Unset,
12652 updated_at: Auto::Unset,
12653 };
12654 row.insert_pool(tenant.pool()).await?;
12655 let id = row.id.get().copied().unwrap_or_default();
12656 redirect_named_with_params_and_message_args(
12657 "rcms-admin:workflows:edit",
12658 &[("id", id.to_string())],
12659 MsgLevel::Success,
12660 "Created workflow “{name}”. Add review steps below.",
12661 &[("name", name.as_str())],
12662 &headers,
12663 )
12664}
12665
12666pub async fn workflow_edit_form(
12667 State(state): State<super::AdminState>,
12668 tenant: Tenant,
12669 headers: HeaderMap,
12670 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12671 Path(id): Path<i64>,
12672) -> Result<Response, AdminError> {
12673 let row = crate::workflow::Workflow::objects()
12674 .where_(crate::workflow::Workflow::id.eq(id))
12675 .first(tenant.pool())
12676 .await?
12677 .ok_or(AdminError::NotFound(id))?;
12678 let tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12679 .where_(crate::workflow::WorkflowTask::workflow_id.eq(id))
12680 .order_by(&[("sort_order", false), ("id", false)])
12681 .fetch(tenant.pool())
12682 .await?;
12683 let roles: Vec<rustango::tenancy::permissions::Role> =
12686 rustango::tenancy::permissions::Role::objects()
12687 .order_by(&[("name", false)])
12688 .fetch(tenant.pool())
12689 .await?;
12690 let role_rows: Vec<serde_json::Value> = roles
12691 .iter()
12692 .map(|r| {
12693 serde_json::json!({
12694 "id": r.id.get().copied(),
12695 "name": r.name,
12696 })
12697 })
12698 .collect();
12699 let role_by_id: std::collections::HashMap<i64, String> = roles
12700 .iter()
12701 .filter_map(|r| r.id.get().copied().map(|id| (id, r.name.clone())))
12702 .collect();
12703 let task_rows: Vec<serde_json::Value> = tasks
12704 .iter()
12705 .map(|t| {
12706 serde_json::json!({
12707 "id": t.id.get().copied(),
12708 "name": t.name,
12709 "role_id": t.role_id,
12710 "role_name": role_by_id.get(&t.role_id).cloned().unwrap_or_default(),
12711 "sort_order": t.sort_order,
12712 "kind": t.kind,
12713 "webhook_url": t.webhook_url,
12714 })
12715 })
12716 .collect();
12717 let mut task_kinds: Vec<serde_json::Value> = crate::task_kind::registered_kinds()
12722 .iter()
12723 .map(|k| {
12724 serde_json::json!({
12725 "name": k.kind_name(),
12726 "verbose_name": k.verbose_name(),
12727 })
12728 })
12729 .collect();
12730 task_kinds.sort_by_key(|k| k["name"] != "group_approval");
12731 let kind_label = |name: &str| {
12732 crate::task_kind::registered_kinds()
12733 .iter()
12734 .find(|k| k.kind_name() == name)
12735 .map_or_else(|| name.to_owned(), |k| k.verbose_name().to_owned())
12736 };
12737 let task_rows: Vec<serde_json::Value> = task_rows
12738 .into_iter()
12739 .map(|mut t| {
12740 let label = kind_label(t["kind"].as_str().unwrap_or_default());
12741 t["kind_label"] = serde_json::Value::String(label);
12742 t
12743 })
12744 .collect();
12745 let mut ctx = Context::new();
12746 add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12747 add_admin_theme(&mut ctx, tenant.pool()).await;
12748 ctx.insert("mode", "edit");
12749 ctx.insert("workflow", &row);
12750 ctx.insert("tasks", &task_rows);
12751 ctx.insert("roles", &role_rows);
12752 ctx.insert("task_kinds", &task_kinds);
12753 render_with_csrf(&state, &headers, "rcms_admin/workflow_form.html", &mut ctx)
12754}
12755
12756pub async fn workflow_edit_submit(
12757 State(_state): State<super::AdminState>,
12758 tenant: Tenant,
12759 headers: HeaderMap,
12760 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12761 Path(id): Path<i64>,
12762 Form(form): Form<WorkflowForm>,
12763) -> Result<Response, AdminError> {
12764 let mut row = crate::workflow::Workflow::objects()
12765 .where_(crate::workflow::Workflow::id.eq(id))
12766 .first(tenant.pool())
12767 .await?
12768 .ok_or(AdminError::NotFound(id))?;
12769 let old_name = row.name.clone();
12770 row.name = form.name.trim().to_owned();
12771 row.description = form.description.trim().to_owned();
12772 row.active = form.parsed_active();
12773 row.require_reapproval_on_edit = form.parsed_reapproval();
12774 row.save_pool(tenant.pool()).await?;
12775 if old_name != row.name {
12778 crate::workflow::rebind_page_types(tenant.pool(), &old_name, &row.name).await?;
12779 }
12780 redirect_named_with_params_and_message_args(
12781 "rcms-admin:workflows:edit",
12782 &[("id", id.to_string())],
12783 MsgLevel::Success,
12784 "Saved workflow “{name}”.",
12785 &[("name", row.name.as_str())],
12786 &headers,
12787 )
12788}
12789
12790pub async fn workflow_delete_submit(
12791 State(_state): State<super::AdminState>,
12792 tenant: Tenant,
12793 headers: HeaderMap,
12794 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12795 Path(id): Path<i64>,
12796) -> Result<Response, AdminError> {
12797 let row = crate::workflow::Workflow::objects()
12798 .where_(crate::workflow::Workflow::id.eq(id))
12799 .first(tenant.pool())
12800 .await?
12801 .ok_or(AdminError::NotFound(id))?;
12802 let users: Vec<String> = crate::workflow::page_types_using(tenant.pool(), &row.name)
12804 .await?
12805 .into_iter()
12806 .map(|pt| pt.verbose_name)
12807 .collect();
12808 if !users.is_empty() {
12809 let types = users.join(", ");
12810 return redirect_named_with_message_args(
12811 "rcms-admin:workflows:list",
12812 MsgLevel::Error,
12813 "Can't delete “{title}” — the page types {types} use it. Choose another workflow for them first.",
12814 &[("title", row.name.as_str()), ("types", types.as_str())],
12815 &headers,
12816 );
12817 }
12818 let in_use: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
12822 .where_(crate::workflow::WorkflowState::workflow_id.eq(id))
12823 .fetch(tenant.pool())
12824 .await?;
12825 if !in_use.is_empty() {
12826 let count = in_use.len().to_string();
12827 return redirect_named_with_message_plural(
12828 "rcms-admin:workflows:list",
12829 MsgLevel::Error,
12830 "Can't delete “{title}” — {count} page(s) have history under it. Toggle Active off instead.",
12831 in_use.len() as i64,
12832 &[("title", row.name.as_str()), ("count", count.as_str())],
12833 &headers,
12834 );
12835 }
12836 let tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12838 .where_(crate::workflow::WorkflowTask::workflow_id.eq(id))
12839 .fetch(tenant.pool())
12840 .await?;
12841 for t in tasks {
12842 t.delete_pool(tenant.pool()).await?;
12843 }
12844 let name = row.name.clone();
12845 row.delete_pool(tenant.pool()).await?;
12846 redirect_named_with_message_args(
12847 "rcms-admin:workflows:list",
12848 MsgLevel::Success,
12849 "Deleted workflow “{name}”.",
12850 &[("name", name.as_str())],
12851 &headers,
12852 )
12853}
12854
12855#[derive(Debug, Deserialize)]
12856pub struct WorkflowTaskForm {
12857 pub name: String,
12858 pub role_id: i64,
12859 #[serde(default)]
12863 pub kind: Option<String>,
12864 #[serde(default)]
12865 pub webhook_url: Option<String>,
12866}
12867
12868pub async fn workflow_task_add(
12869 State(_state): State<super::AdminState>,
12870 tenant: Tenant,
12871 headers: HeaderMap,
12872 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12873 Path(workflow_id): Path<i64>,
12874 Form(form): Form<WorkflowTaskForm>,
12875) -> Result<Response, AdminError> {
12876 use rustango::sql::Auto;
12877 let name = form.name.trim().to_owned();
12878 if name.is_empty() {
12879 return redirect_named_with_params_and_message(
12880 "rcms-admin:workflows:edit",
12881 &[("id", workflow_id.to_string())],
12882 MsgLevel::Error,
12883 "Step name is required.",
12884 &headers,
12885 );
12886 }
12887 let existing: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12888 .where_(crate::workflow::WorkflowTask::workflow_id.eq(workflow_id))
12889 .order_by(&[("sort_order", true)]) .fetch(tenant.pool())
12891 .await?;
12892 let next_order = existing.first().map_or(10, |t| t.sort_order + 10);
12893 let kind = form
12894 .kind
12895 .as_deref()
12896 .map(str::trim)
12897 .filter(|s| !s.is_empty())
12898 .filter(|s| crate::task_kind::find(s).is_some())
12899 .unwrap_or("group_approval")
12900 .to_owned();
12901 let webhook_url = form
12902 .webhook_url
12903 .as_deref()
12904 .map(str::trim)
12905 .unwrap_or("")
12906 .to_owned();
12907 let mut row = crate::workflow::WorkflowTask {
12908 id: Auto::Unset,
12909 workflow_id,
12910 name: name.clone(),
12911 role_id: form.role_id,
12912 sort_order: next_order,
12913 kind,
12914 webhook_url,
12915 };
12916 row.insert_pool(tenant.pool()).await?;
12917 redirect_named_with_params_and_message_args(
12918 "rcms-admin:workflows:edit",
12919 &[("id", workflow_id.to_string())],
12920 MsgLevel::Success,
12921 "Added step “{name}”.",
12922 &[("name", name.as_str())],
12923 &headers,
12924 )
12925}
12926
12927pub async fn workflow_task_delete(
12928 State(_state): State<super::AdminState>,
12929 tenant: Tenant,
12930 headers: HeaderMap,
12931 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12932 Path((workflow_id, task_id)): Path<(i64, i64)>,
12933) -> Result<Response, AdminError> {
12934 let row = crate::workflow::WorkflowTask::objects()
12935 .where_(crate::workflow::WorkflowTask::id.eq(task_id))
12936 .where_(crate::workflow::WorkflowTask::workflow_id.eq(workflow_id))
12937 .first(tenant.pool())
12938 .await?
12939 .ok_or(AdminError::NotFound(task_id))?;
12940 let name = row.name.clone();
12941 row.delete_pool(tenant.pool()).await?;
12942 redirect_named_with_params_and_message_args(
12943 "rcms-admin:workflows:edit",
12944 &[("id", workflow_id.to_string())],
12945 MsgLevel::Success,
12946 "Removed step “{name}”.",
12947 &[("name", name.as_str())],
12948 &headers,
12949 )
12950}
12951
12952#[derive(Debug, Deserialize)]
12963pub struct WorkflowDecisionForm {
12964 #[serde(default)]
12965 pub comment: String,
12966 #[serde(default)]
12970 pub task_id: Option<i64>,
12971}
12972
12973fn step_already_decided(page_id: i64, headers: &HeaderMap) -> Result<Response, AdminError> {
12976 redirect_named_with_params_and_message(
12977 "rcms-admin:pages:edit",
12978 &[("id", page_id.to_string())],
12979 MsgLevel::Error,
12980 "That review step was already decided — check the page's current step before deciding again.",
12981 headers,
12982 )
12983}
12984
12985async fn user_is_in_role(
12986 pool: &rustango::sql::Pool,
12987 user_id: i64,
12988 role_id: i64,
12989) -> Result<bool, rustango::sql::ExecError> {
12990 use rustango::core::Column as _;
12991 use rustango::sql::FetcherPool as _;
12992 let rows: Vec<rustango::tenancy::permissions::UserRole> =
12993 rustango::tenancy::permissions::UserRole::objects()
12994 .where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
12995 .where_(rustango::tenancy::permissions::UserRole::role_id.eq(role_id))
12996 .fetch(pool)
12997 .await?;
12998 Ok(!rows.is_empty())
12999}
13000
13001pub async fn page_workflow_submit(
13002 State(_state): State<super::AdminState>,
13003 tenant: Tenant,
13004 headers: HeaderMap,
13005 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13006 Path(id): Path<i64>,
13007) -> Result<Response, AdminError> {
13008 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
13009 return Ok(unauthorized_no_session());
13010 };
13011 let page = Page::objects()
13012 .where_(Page::id.eq(id))
13013 .first(tenant.pool())
13014 .await?
13015 .ok_or(AdminError::NotFound(id))?;
13016 let pts: Vec<PageType> = PageType::objects()
13018 .where_(PageType::id.eq(page.page_type_id))
13019 .fetch(tenant.pool())
13020 .await?;
13021 let Some(pt) = pts.into_iter().next() else {
13022 return redirect_named_with_params_and_message(
13023 "rcms-admin:pages:edit",
13024 &[("id", id.to_string())],
13025 MsgLevel::Error,
13026 "Page type row not found.",
13027 &headers,
13028 );
13029 };
13030 let Some(slug) = pt.workflow_name() else {
13031 return redirect_named_with_params_and_message(
13032 "rcms-admin:pages:edit",
13033 &[("id", id.to_string())],
13034 MsgLevel::Error,
13035 "This page type isn't bound to a workflow — nothing to submit.",
13036 &headers,
13037 );
13038 };
13039 let Some(workflow) = crate::workflow::find_by_name(tenant.pool(), &slug).await? else {
13040 return redirect_named_with_params_and_message_args(
13041 "rcms-admin:pages:edit",
13042 &[("id", id.to_string())],
13043 MsgLevel::Error,
13044 "Workflow `{slug}` not found or inactive — ask an admin to enable it.",
13045 &[("slug", slug.as_str())],
13046 &headers,
13047 );
13048 };
13049 let tasks = crate::workflow::tasks_for(
13050 tenant.pool(),
13051 workflow.id.get().copied().unwrap_or_default(),
13052 )
13053 .await?;
13054 if tasks.is_empty() {
13055 return redirect_named_with_params_and_message(
13056 "rcms-admin:pages:edit",
13057 &[("id", id.to_string())],
13058 MsgLevel::Error,
13059 "Workflow has no review steps yet — ask an admin to add at least one step.",
13060 &headers,
13061 );
13062 }
13063 if let Some(active) = crate::workflow::active_state_for_page(tenant.pool(), id).await? {
13068 if active.status == crate::workflow::WorkflowStatus::InProgress.as_str() {
13069 return redirect_named_with_params_and_message(
13070 "rcms-admin:pages:edit",
13071 &[("id", id.to_string())],
13072 MsgLevel::Warning,
13073 "This page is already under review.",
13074 &headers,
13075 );
13076 }
13077 }
13078 crate::workflow::submit_for_review(tenant.pool(), id, &workflow, &tasks, viewer_id).await?;
13079 crate::lock::release(tenant.pool(), id, viewer_id)
13082 .await
13083 .log_warn("editor lock not released on submit");
13084
13085 crate::page_log::record_or_warn(
13087 tenant.pool(),
13088 id,
13089 crate::page_log::ACTION_WORKFLOW_SUBMIT,
13090 Some(viewer_id),
13091 format!(
13092 "Submitted for review — workflow “{}”, first step “{}”.",
13093 workflow.name, tasks[0].name
13094 ),
13095 Some(serde_json::json!({
13096 "workflow_id": workflow.id.get().copied(),
13097 "workflow_name": workflow.name,
13098 "first_task": tasks[0].name,
13099 })),
13100 )
13101 .await;
13102
13103 notify_workflow(
13106 _state.mailer.as_deref(),
13107 &_state.mailer_from,
13108 tenant.pool(),
13109 &tenant.org.slug,
13110 "submit",
13111 &workflow.name,
13112 &page.title,
13113 id,
13114 Some(&tasks[0].name),
13115 session_user.as_ref().map(|u| u.username.as_str()),
13116 None,
13117 WorkflowRecipients::Role(tasks[0].role_id),
13118 )
13119 .await;
13120
13121 redirect_named_with_params_and_message_args(
13122 "rcms-admin:pages:edit",
13123 &[("id", id.to_string())],
13124 MsgLevel::Success,
13125 "Submitted for review — first step: “{name}”.",
13126 &[("name", tasks[0].name.as_str())],
13127 &headers,
13128 )
13129}
13130
13131enum WorkflowRecipients {
13133 Role(i64),
13135 User(i64),
13138}
13139
13140#[allow(clippy::too_many_arguments)]
13145async fn notify_workflow(
13146 mailer: Option<&dyn rustango::email::Mailer>,
13147 from: &str,
13148 pool: &rustango::sql::Pool,
13149 tenant_slug: &str,
13150 event: &str,
13151 workflow_name: &str,
13152 page_title: &str,
13153 page_id: i64,
13154 task_name: Option<&str>,
13155 actor_username: Option<&str>,
13156 comment: Option<&str>,
13157 recipients: WorkflowRecipients,
13158) {
13159 let Some(mailer) = mailer else {
13160 return;
13161 };
13162 let kind = crate::notification_pref::pref_kind_for_workflow_event(event);
13166 let candidate_user_ids: Vec<i64> = match recipients {
13167 WorkflowRecipients::Role(role_id) => {
13168 crate::workflow_mail::role_member_user_ids(pool, role_id)
13169 .await
13170 .unwrap_or_default()
13171 }
13172 WorkflowRecipients::User(user_id) => vec![user_id],
13173 };
13174 let allowed_ids = crate::notification_pref::filter_enabled(pool, &candidate_user_ids, kind)
13175 .await
13176 .unwrap_or(candidate_user_ids);
13177 let mut pairs: Vec<(String, String)> = Vec::with_capacity(allowed_ids.len());
13178 for uid in allowed_ids {
13179 if let Ok(Some(pair)) = crate::workflow_mail::user_email(pool, uid, tenant_slug).await {
13180 pairs.push(pair);
13181 }
13182 }
13183 if pairs.is_empty() {
13184 return;
13185 }
13186 let (subject, body) = crate::workflow_mail::render_notification(
13187 event,
13188 workflow_name,
13189 page_title,
13190 page_id,
13191 task_name,
13192 actor_username,
13193 comment,
13194 );
13195 crate::workflow_mail::notify_many(mailer, from, &pairs, &subject, &body).await;
13196}
13197
13198pub async fn page_workflow_approve(
13199 State(_state): State<super::AdminState>,
13200 tenant: Tenant,
13201 headers: HeaderMap,
13202 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13203 Path(id): Path<i64>,
13204 Form(form): Form<WorkflowDecisionForm>,
13205) -> Result<Response, AdminError> {
13206 let Some(viewer) = session_user.as_ref() else {
13207 return Ok(unauthorized_no_session());
13208 };
13209 let viewer_id = viewer.id.get().copied().unwrap_or_default();
13210 let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13211 return redirect_named_with_params_and_message(
13212 "rcms-admin:pages:edit",
13213 &[("id", id.to_string())],
13214 MsgLevel::Error,
13215 "No active workflow on this page.",
13216 &headers,
13217 );
13218 };
13219 let tasks = crate::workflow::tasks_for(tenant.pool(), state.workflow_id).await?;
13220 let Some(current_task) = state
13221 .current_task_id
13222 .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
13223 else {
13224 return redirect_named_with_params_and_message(
13225 "rcms-admin:pages:edit",
13226 &[("id", id.to_string())],
13227 MsgLevel::Error,
13228 "Workflow has no current task — refresh the page.",
13229 &headers,
13230 );
13231 };
13232 if !viewer.is_superuser
13233 && !user_is_in_role(tenant.pool(), viewer_id, current_task.role_id).await?
13234 {
13235 return redirect_named_with_params_and_message_args(
13236 "rcms-admin:pages:edit",
13237 &[("id", id.to_string())],
13238 MsgLevel::Error,
13239 "Only members of the task's role can approve “{name}”.",
13240 &[("name", current_task.name.as_str())],
13241 &headers,
13242 );
13243 }
13244 if form.task_id.is_some_and(|t| current_task.id.get().copied() != Some(t)) {
13245 return step_already_decided(id, &headers);
13246 }
13247 let submitter_id = state.requested_by;
13250 let page_title: String = Page::objects()
13251 .where_(Page::id.eq(id))
13252 .fetch(tenant.pool())
13253 .await
13254 .ok()
13255 .and_then(|v| v.into_iter().next())
13256 .map(|p| p.title)
13257 .unwrap_or_else(|| format!("page #{id}"));
13258 let workflow_name: String = crate::workflow::Workflow::objects()
13259 .where_(crate::workflow::Workflow::id.eq(state.workflow_id))
13260 .fetch(tenant.pool())
13261 .await
13262 .ok()
13263 .and_then(|v| v.into_iter().next())
13264 .map(|w| w.name)
13265 .unwrap_or_else(|| "Workflow".to_owned());
13266 let outcome = crate::workflow::approve_current(
13267 tenant.pool(),
13268 &mut state,
13269 &tasks,
13270 viewer_id,
13271 &form.comment,
13272 )
13273 .await?;
13274 let msg = match outcome {
13275 crate::workflow::ApproveOutcome::AlreadyDecided => {
13276 return step_already_decided(id, &headers);
13277 }
13278 crate::workflow::ApproveOutcome::Advanced { next_task_id } => {
13279 let next = tasks
13280 .iter()
13281 .find(|t| t.id.get().copied() == Some(next_task_id));
13282 let next_name = next.map(|t| t.name.as_str()).unwrap_or("next step");
13283 if let Some(nt) = next {
13285 notify_workflow(
13286 _state.mailer.as_deref(),
13287 &_state.mailer_from,
13288 tenant.pool(),
13289 &tenant.org.slug,
13290 "approve_advance",
13291 &workflow_name,
13292 &page_title,
13293 id,
13294 Some(&nt.name),
13295 Some(&viewer.username),
13296 Some(&form.comment),
13297 WorkflowRecipients::Role(nt.role_id),
13298 )
13299 .await;
13300 }
13301 crate::page_log::record_or_warn(
13303 tenant.pool(),
13304 id,
13305 crate::page_log::ACTION_WORKFLOW_APPROVE,
13306 Some(viewer_id),
13307 format!(
13308 "Approved “{}” — advanced to “{next_name}”.",
13309 current_task.name
13310 ),
13311 Some(serde_json::json!({
13312 "outcome": "advanced",
13313 "task_name": current_task.name,
13314 "next_task_name": next_name,
13315 "comment": form.comment,
13316 })),
13317 )
13318 .await;
13319 format!("Approved “{}” — moved to “{next_name}”.", current_task.name)
13320 }
13321 crate::workflow::ApproveOutcome::Finished => {
13322 if let Some(pending) = crate::pending_change::for_page(tenant.pool(), id).await? {
13325 match apply_page_edit(
13326 tenant.pool(),
13327 &tenant.org.slug,
13328 &_state.cache_invalidator,
13329 _state.mailer.as_deref(),
13330 &_state.mailer_from,
13331 false,
13332 id,
13333 &pending.form_map(),
13334 None,
13335 )
13336 .await
13337 {
13338 Ok(Ok(_)) => crate::pending_change::discard(tenant.pool(), id).await?,
13339 Ok(Err(_)) | Err(_) => {
13340 tracing::warn!(page_id = id, "held change could not be applied on approval");
13341 }
13342 }
13343 }
13344 if let Some(mut page) = Page::objects()
13346 .where_(Page::id.eq(id))
13347 .first(tenant.pool())
13348 .await?
13349 {
13350 page.status = crate::page::PageStatus::Published.as_str().to_owned();
13351 let now = chrono::Utc::now();
13352 if page.published_at.is_none() {
13353 page.published_at = Some(now);
13354 }
13355 page.last_published_at = Some(now);
13357 page.save_pool(tenant.pool()).await?;
13358 crate::page::went_live_effects(&tenant.org.slug, &page).await;
13362 crate::task_queue::purge_urls(
13363 _state.cache_invalidator.clone(),
13364 tenant.org.slug.clone(),
13365 vec![page.url_path.clone()],
13366 )
13367 .await;
13368 crate::page_subscription::notify_publish(
13370 _state.mailer.as_deref(),
13371 &_state.mailer_from,
13372 tenant.pool(),
13373 &tenant.org.slug,
13374 id,
13375 &page.title,
13376 &page.url_path,
13377 Some(&viewer.username),
13378 )
13379 .await;
13380 }
13381 notify_workflow(
13383 _state.mailer.as_deref(),
13384 &_state.mailer_from,
13385 tenant.pool(),
13386 &tenant.org.slug,
13387 "approve_finish",
13388 &workflow_name,
13389 &page_title,
13390 id,
13391 Some(¤t_task.name),
13392 Some(&viewer.username),
13393 Some(&form.comment),
13394 WorkflowRecipients::User(submitter_id),
13395 )
13396 .await;
13397 crate::page_log::record_or_warn(
13400 tenant.pool(),
13401 id,
13402 crate::page_log::ACTION_WORKFLOW_APPROVE,
13403 Some(viewer_id),
13404 format!(
13405 "Approved “{}” — workflow complete; page auto-published.",
13406 current_task.name
13407 ),
13408 Some(serde_json::json!({
13409 "outcome": "finished",
13410 "task_name": current_task.name,
13411 "comment": form.comment,
13412 })),
13413 )
13414 .await;
13415 crate::page_log::record_or_warn(
13416 tenant.pool(),
13417 id,
13418 crate::page_log::ACTION_PUBLISH,
13419 Some(viewer_id),
13420 "Published via workflow approval.",
13421 Some(serde_json::json!({ "via": "workflow" })),
13422 )
13423 .await;
13424 format!(
13425 "Approved “{}” — workflow complete, page published.",
13426 current_task.name
13427 )
13428 }
13429 };
13430 redirect_named_with_params_and_message(
13431 "rcms-admin:pages:edit",
13432 &[("id", id.to_string())],
13433 MsgLevel::Success,
13434 &msg,
13435 &headers,
13436 )
13437}
13438
13439pub async fn page_workflow_reject(
13440 State(_state): State<super::AdminState>,
13441 tenant: Tenant,
13442 headers: HeaderMap,
13443 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13444 Path(id): Path<i64>,
13445 Form(form): Form<WorkflowDecisionForm>,
13446) -> Result<Response, AdminError> {
13447 let Some(viewer) = session_user.as_ref() else {
13448 return Ok(unauthorized_no_session());
13449 };
13450 let viewer_id = viewer.id.get().copied().unwrap_or_default();
13451 let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13452 return redirect_named_with_params_and_message(
13453 "rcms-admin:pages:edit",
13454 &[("id", id.to_string())],
13455 MsgLevel::Error,
13456 "No active workflow on this page.",
13457 &headers,
13458 );
13459 };
13460 let tasks = crate::workflow::tasks_for(tenant.pool(), state.workflow_id).await?;
13461 let Some(current_task) = state
13462 .current_task_id
13463 .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
13464 else {
13465 return redirect_named_with_params_and_message(
13466 "rcms-admin:pages:edit",
13467 &[("id", id.to_string())],
13468 MsgLevel::Error,
13469 "Workflow has no current task — refresh the page.",
13470 &headers,
13471 );
13472 };
13473 if !viewer.is_superuser
13474 && !user_is_in_role(tenant.pool(), viewer_id, current_task.role_id).await?
13475 {
13476 return redirect_named_with_params_and_message_args(
13477 "rcms-admin:pages:edit",
13478 &[("id", id.to_string())],
13479 MsgLevel::Error,
13480 "Only members of the task's role can reject “{name}”.",
13481 &[("name", current_task.name.as_str())],
13482 &headers,
13483 );
13484 }
13485 if form.task_id.is_some_and(|t| current_task.id.get().copied() != Some(t)) {
13486 return step_already_decided(id, &headers);
13487 }
13488 if form.comment.trim().is_empty() {
13489 return redirect_named_with_params_and_message(
13490 "rcms-admin:pages:edit",
13491 &[("id", id.to_string())],
13492 MsgLevel::Error,
13493 "Say what should change — the author sees it in the review history.",
13494 &headers,
13495 );
13496 }
13497 let submitter_id = state.requested_by;
13498 let workflow_id = state.workflow_id;
13499 if !crate::workflow::reject_current(tenant.pool(), &mut state, viewer_id, &form.comment).await? {
13500 return step_already_decided(id, &headers);
13501 }
13502 crate::page_log::record_or_warn(
13504 tenant.pool(),
13505 id,
13506 crate::page_log::ACTION_WORKFLOW_REJECT,
13507 Some(viewer_id),
13508 format!("Rejected “{}” — changes requested.", current_task.name),
13509 Some(serde_json::json!({
13510 "task_name": current_task.name,
13511 "comment": form.comment,
13512 })),
13513 )
13514 .await;
13515 let workflow_name: String = crate::workflow::Workflow::objects()
13517 .where_(crate::workflow::Workflow::id.eq(workflow_id))
13518 .fetch(tenant.pool())
13519 .await
13520 .ok()
13521 .and_then(|v| v.into_iter().next())
13522 .map(|w| w.name)
13523 .unwrap_or_else(|| "Workflow".to_owned());
13524 let page_title: String = Page::objects()
13525 .where_(Page::id.eq(id))
13526 .fetch(tenant.pool())
13527 .await
13528 .ok()
13529 .and_then(|v| v.into_iter().next())
13530 .map(|p| p.title)
13531 .unwrap_or_else(|| format!("page #{id}"));
13532 notify_workflow(
13533 _state.mailer.as_deref(),
13534 &_state.mailer_from,
13535 tenant.pool(),
13536 &tenant.org.slug,
13537 "reject",
13538 &workflow_name,
13539 &page_title,
13540 id,
13541 Some(¤t_task.name),
13542 Some(&viewer.username),
13543 Some(&form.comment),
13544 WorkflowRecipients::User(submitter_id),
13545 )
13546 .await;
13547 redirect_named_with_params_and_message_args(
13548 "rcms-admin:pages:edit",
13549 &[("id", id.to_string())],
13550 MsgLevel::Success,
13551 "Rejected “{name}” — page returned to author for changes.",
13552 &[("name", current_task.name.as_str())],
13553 &headers,
13554 )
13555}
13556
13557pub async fn page_workflow_cancel(
13558 State(_state): State<super::AdminState>,
13559 tenant: Tenant,
13560 headers: HeaderMap,
13561 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13562 Path(id): Path<i64>,
13563) -> Result<Response, AdminError> {
13564 let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
13565 return Ok(unauthorized_no_session());
13566 };
13567 let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13568 return redirect_named_with_params_and_message(
13569 "rcms-admin:pages:edit",
13570 &[("id", id.to_string())],
13571 MsgLevel::Warning,
13572 "This page isn't currently under review.",
13573 &headers,
13574 );
13575 };
13576 let submitter_id = state.requested_by;
13577 let workflow_id = state.workflow_id;
13578 crate::workflow::cancel(tenant.pool(), &mut state, viewer_id).await?;
13579 crate::page_log::record_or_warn(
13581 tenant.pool(),
13582 id,
13583 crate::page_log::ACTION_WORKFLOW_CANCEL,
13584 Some(viewer_id),
13585 "Workflow cancelled.",
13586 Some(serde_json::json!({ "workflow_id": workflow_id })),
13587 )
13588 .await;
13589 let workflow_name: String = crate::workflow::Workflow::objects()
13593 .where_(crate::workflow::Workflow::id.eq(workflow_id))
13594 .fetch(tenant.pool())
13595 .await
13596 .ok()
13597 .and_then(|v| v.into_iter().next())
13598 .map(|w| w.name)
13599 .unwrap_or_else(|| "Workflow".to_owned());
13600 let page_title: String = Page::objects()
13601 .where_(Page::id.eq(id))
13602 .fetch(tenant.pool())
13603 .await
13604 .ok()
13605 .and_then(|v| v.into_iter().next())
13606 .map(|p| p.title)
13607 .unwrap_or_else(|| format!("page #{id}"));
13608 let actor_username = session_user.as_ref().map(|u| u.username.as_str());
13609 notify_workflow(
13610 _state.mailer.as_deref(),
13611 &_state.mailer_from,
13612 tenant.pool(),
13613 &tenant.org.slug,
13614 "cancel",
13615 &workflow_name,
13616 &page_title,
13617 id,
13618 None,
13619 actor_username,
13620 None,
13621 WorkflowRecipients::User(submitter_id),
13622 )
13623 .await;
13624 redirect_named_with_params_and_message(
13625 "rcms-admin:pages:edit",
13626 &[("id", id.to_string())],
13627 MsgLevel::Success,
13628 "Workflow cancelled.",
13629 &headers,
13630 )
13631}
13632
13633pub async fn page_log_csv(
13642 State(_state): State<super::AdminState>,
13643 tenant: Tenant,
13644 Path(id): Path<i64>,
13645) -> Result<Response, AdminError> {
13646 let entries = crate::page_log::for_page(tenant.pool(), id, None).await?;
13647 let user_ids: std::collections::BTreeSet<i64> =
13648 entries.iter().filter_map(|e| e.actor_id).collect();
13649 let users: std::collections::HashMap<i64, String> = if user_ids.is_empty() {
13650 std::collections::HashMap::new()
13651 } else {
13652 rustango::tenancy::auth::User::objects()
13653 .where_(
13654 rustango::tenancy::auth::User::id.is_in(user_ids.into_iter().collect::<Vec<_>>()),
13655 )
13656 .fetch(tenant.pool())
13657 .await?
13658 .into_iter()
13659 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
13660 .collect()
13661 };
13662
13663 let mut out = String::with_capacity(4096);
13664 out.push_str("timestamp,action,actor_id,actor_username,message,data_json\n");
13665 for e in entries {
13666 let ts = e
13667 .created_at
13668 .get()
13669 .map(|t| t.to_rfc3339())
13670 .unwrap_or_default();
13671 let actor_id = e.actor_id.map(|i| i.to_string()).unwrap_or_default();
13672 let actor_username = e
13673 .actor_id
13674 .and_then(|uid| users.get(&uid).cloned())
13675 .unwrap_or_default();
13676 out.push_str(&csv_escape(&ts));
13677 out.push(',');
13678 out.push_str(&csv_escape(&e.action));
13679 out.push(',');
13680 out.push_str(&csv_escape(&actor_id));
13681 out.push(',');
13682 out.push_str(&csv_escape(&actor_username));
13683 out.push(',');
13684 out.push_str(&csv_escape(&e.message));
13685 out.push(',');
13686 out.push_str(&csv_escape(&e.data_json));
13687 out.push('\n');
13688 }
13689
13690 let filename = format!("page-{id}-audit-log.csv");
13691 Ok((
13692 [
13693 (
13694 axum::http::header::CONTENT_TYPE,
13695 "text/csv; charset=utf-8".to_owned(),
13696 ),
13697 (
13698 axum::http::header::CONTENT_DISPOSITION,
13699 format!("attachment; filename=\"{filename}\""),
13700 ),
13701 ],
13702 out,
13703 )
13704 .into_response())
13705}
13706
13707#[derive(Debug, Deserialize)]
13715pub struct HistoryQuery {
13716 #[serde(default)]
13717 pub page_id: Option<i64>,
13718 #[serde(default)]
13719 pub user_id: Option<i64>,
13720 #[serde(default)]
13721 pub page: Option<u32>,
13722 #[serde(default)]
13724 pub per_page: Option<usize>,
13725}
13726
13727pub async fn history_page(
13733 State(state): State<super::AdminState>,
13734 tenant: Tenant,
13735 headers: HeaderMap,
13736 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13737 Query(q): Query<HistoryQuery>,
13738 axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
13739) -> Result<Response, AdminError> {
13740 let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
13741
13742 let mut revisions_query =
13746 crate::revision::Revision::objects().order_by(&[("created_at", true)]); if let Some(pid) = q.page_id {
13748 revisions_query = revisions_query.where_(crate::revision::Revision::page_id.eq(pid));
13749 }
13750 if let Some(uid) = q.user_id {
13751 revisions_query =
13752 revisions_query.where_(crate::revision::Revision::created_by.eq(Some(uid)));
13753 }
13754
13755 let all: Vec<crate::revision::Revision> = revisions_query.fetch(tenant.pool()).await?;
13761 let total = all.len();
13762 let paginator = rustango::pagination::Paginator::new(total, page_size);
13763 let page_obj = paginator.get_page(q.page.unwrap_or(1).max(1) as i64);
13764 let current_page = page_obj.number as u32;
13765 let has_next = page_obj.has_next();
13766 let has_prev = page_obj.has_previous();
13767 let revisions: Vec<crate::revision::Revision> = if total == 0 {
13768 Vec::new()
13769 } else {
13770 all[page_obj.start_index().saturating_sub(1)..page_obj.end_index()].to_vec()
13771 };
13772
13773 let page_ids: std::collections::BTreeSet<i64> = revisions.iter().map(|r| r.page_id).collect();
13775 let user_ids: std::collections::BTreeSet<i64> =
13776 revisions.iter().filter_map(|r| r.created_by).collect();
13777
13778 let pages: Vec<Page> = if page_ids.is_empty() {
13779 Vec::new()
13780 } else {
13781 Page::objects()
13782 .where_(Page::id.is_in(page_ids.iter().copied()))
13783 .fetch(tenant.pool())
13784 .await?
13785 };
13786 let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
13787 Vec::new()
13788 } else {
13789 rustango::tenancy::auth::User::objects()
13790 .where_(rustango::tenancy::auth::User::id.is_in(user_ids.iter().copied()))
13791 .fetch(tenant.pool())
13792 .await?
13793 };
13794
13795 let pages_by_id: std::collections::HashMap<i64, &Page> = pages
13796 .iter()
13797 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
13798 .collect();
13799 let users_by_id: std::collections::HashMap<i64, &rustango::tenancy::auth::User> = users
13800 .iter()
13801 .filter_map(|u| u.id.get().copied().map(|id| (id, u)))
13802 .collect();
13803
13804 let mut latest_seq_by_page: std::collections::HashMap<i64, i32> =
13809 std::collections::HashMap::new();
13810 for r in &all {
13811 let cur = latest_seq_by_page.entry(r.page_id).or_insert(r.sequence);
13812 if r.sequence > *cur {
13813 *cur = r.sequence;
13814 }
13815 }
13816 let mut by_page: std::collections::HashMap<i64, Vec<&crate::revision::Revision>> =
13822 std::collections::HashMap::new();
13823 for r in &all {
13824 by_page.entry(r.page_id).or_default().push(r);
13825 }
13826 let mut prev_by_id: std::collections::HashMap<i64, (i64, i32)> =
13827 std::collections::HashMap::new();
13828 for (_pid, mut list) in by_page {
13829 list.sort_by_key(|r| r.sequence);
13830 for window in list.windows(2) {
13831 let earlier = window[0];
13832 let later = window[1];
13833 if let (Some(later_id), Some(earlier_id)) =
13834 (later.id.get().copied(), earlier.id.get().copied())
13835 {
13836 prev_by_id.insert(later_id, (earlier_id, earlier.sequence));
13837 }
13838 }
13839 }
13840
13841 let rows: Vec<serde_json::Value> = revisions
13842 .iter()
13843 .map(|r| {
13844 let page = pages_by_id.get(&r.page_id);
13845 let user = r.created_by.and_then(|uid| users_by_id.get(&uid));
13846 let created_at = r.created_at.get().copied();
13847 let (prev_id, prev_sequence) =
13848 r.id.get()
13849 .copied()
13850 .and_then(|id| prev_by_id.get(&id).copied())
13851 .map(|(a, b)| (Some(a), Some(b)))
13852 .unwrap_or((None, None));
13853 let is_latest = latest_seq_by_page
13854 .get(&r.page_id)
13855 .is_some_and(|s| *s == r.sequence);
13856 serde_json::json!({
13857 "id": r.id.get().copied(),
13858 "page_id": r.page_id,
13859 "sequence": r.sequence,
13860 "created_at": created_at,
13861 "page_title": page.map(|p| p.title.clone()),
13862 "page_url_path": page.map(|p| p.url_path.clone()),
13863 "page_status": page.map(|p| p.status.as_str()),
13864 "username": user.map(|u| u.username.clone()),
13865 "system_user": r.created_by.is_none(),
13866 "is_latest": is_latest,
13867 "prev_id": prev_id,
13868 "prev_sequence": prev_sequence,
13869 })
13870 })
13871 .collect();
13872
13873 let mut ctx = Context::new();
13874 add_chrome(&mut ctx, &tenant, "history", session_user.as_ref()).await;
13875 add_admin_theme(&mut ctx, tenant.pool()).await;
13876 ctx.insert("rows", &rows);
13877 ctx.insert("filter_page_id", &q.page_id);
13878 ctx.insert("filter_user_id", &q.user_id);
13879 ctx.insert("query_string", &raw_query.unwrap_or_default());
13882 ctx.insert("current_page", ¤t_page);
13883 ctx.insert("has_next", &has_next);
13884 ctx.insert("has_prev", &has_prev);
13885 ctx.insert("total", &total);
13886 ctx.insert("page_size", &page_size);
13887 ctx.insert(
13888 "pagination",
13889 &crate::admin::pagination::context(current_page as i64, page_size, total),
13890 );
13891 render_with_csrf(&state, &headers, "rcms_admin/history.html", &mut ctx)
13892}
13893
13894#[derive(Debug, Deserialize)]
13898pub struct HistoryDiffQuery {
13899 pub a: i64,
13900 pub b: i64,
13901 #[serde(default)]
13902 pub all: Option<String>,
13903}
13904
13905pub async fn history_diff(
13910 State(state): State<super::AdminState>,
13911 tenant: Tenant,
13912 headers: HeaderMap,
13913 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13914 Path(page_id): Path<i64>,
13915 Query(q): Query<HistoryDiffQuery>,
13916) -> Result<Response, AdminError> {
13917 let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
13918 .where_(crate::revision::Revision::page_id.eq(page_id))
13919 .where_(crate::revision::Revision::id.is_in([q.a, q.b]))
13920 .fetch(tenant.pool())
13921 .await?;
13922 let a_row = revisions
13923 .iter()
13924 .find(|r| r.id.get().copied() == Some(q.a))
13925 .cloned()
13926 .ok_or(AdminError::NotFound(q.a))?;
13927 let b_row = revisions
13928 .iter()
13929 .find(|r| r.id.get().copied() == Some(q.b))
13930 .cloned()
13931 .ok_or(AdminError::NotFound(q.b))?;
13932
13933 let page = Page::objects()
13934 .where_(Page::id.eq(page_id))
13935 .first(tenant.pool())
13936 .await?
13937 .ok_or(AdminError::NotFound(page_id))?;
13938
13939 let user_ids: Vec<i64> = [a_row.created_by, b_row.created_by]
13941 .into_iter()
13942 .flatten()
13943 .collect();
13944 let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
13945 Vec::new()
13946 } else {
13947 rustango::tenancy::auth::User::objects()
13948 .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
13949 .fetch(tenant.pool())
13950 .await?
13951 };
13952 let username_for = |uid: Option<i64>| -> Option<String> {
13953 uid.and_then(|id| {
13954 users
13955 .iter()
13956 .find(|u| u.id.get().copied() == Some(id))
13957 .map(|u| u.username.clone())
13958 })
13959 };
13960
13961 let diffs = crate::revision::diff_snapshots(&a_row.snapshot, &b_row.snapshot);
13962 let changed_count = diffs.iter().filter(|d| d.is_change()).count();
13963 let only_changes = q.all.is_none();
13964
13965 let mut ctx = Context::new();
13966 add_chrome(&mut ctx, &tenant, "history", session_user.as_ref()).await;
13967 add_admin_theme(&mut ctx, tenant.pool()).await;
13968 ctx.insert("page", &page);
13969 ctx.insert(
13970 "rev_a",
13971 &serde_json::json!({
13972 "id": a_row.id.get().copied(),
13973 "sequence": a_row.sequence,
13974 "created_at": a_row.created_at.get().copied(),
13975 "username": username_for(a_row.created_by),
13976 }),
13977 );
13978 ctx.insert(
13979 "rev_b",
13980 &serde_json::json!({
13981 "id": b_row.id.get().copied(),
13982 "sequence": b_row.sequence,
13983 "created_at": b_row.created_at.get().copied(),
13984 "username": username_for(b_row.created_by),
13985 }),
13986 );
13987 ctx.insert("diffs", &diffs);
13988 ctx.insert("changed_count", &changed_count);
13989 ctx.insert("only_changes", &only_changes);
13990 render_with_csrf(&state, &headers, "rcms_admin/history_diff.html", &mut ctx)
13991}
13992
13993#[derive(Debug, Deserialize)]
13998pub struct AnalyticsQuery {
13999 #[serde(default)]
14001 pub days: Option<i64>,
14002}
14003
14004pub async fn analytics_dashboard(
14008 State(state): State<super::AdminState>,
14009 tenant: Tenant,
14010 headers: HeaderMap,
14011 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14012 Query(q): Query<AnalyticsQuery>,
14013) -> Result<Response, AdminError> {
14014 let days = q.days.unwrap_or(30).clamp(1, 365);
14015 let to = chrono::Utc::now();
14016 let from = to - chrono::Duration::days(days);
14017 let metrics = crate::analytics::query::compute(tenant.pool(), from, to).await?;
14018 let host = headers
14019 .get(header::HOST)
14020 .and_then(|v| v.to_str().ok())
14021 .unwrap_or("");
14022 let active_now = crate::analytics::presence_count(host);
14023 let series_max = metrics
14026 .series
14027 .iter()
14028 .map(|p| p.pageviews)
14029 .max()
14030 .unwrap_or(0)
14031 .max(1);
14032
14033 let mut ctx = Context::new();
14034 add_chrome(&mut ctx, &tenant, "analytics", session_user.as_ref()).await;
14035 add_admin_theme(&mut ctx, tenant.pool()).await;
14036 ctx.insert("metrics", &metrics);
14037 ctx.insert("active_now", &active_now);
14038 ctx.insert("series_max", &series_max);
14039 ctx.insert("days", &days);
14040 render_with_csrf(&state, &headers, "rcms_admin/analytics.html", &mut ctx)
14041}
14042
14043#[derive(Debug, Deserialize)]
14044pub struct AgingQuery {
14045 #[serde(default)]
14047 pub min_days: Option<i64>,
14048 #[serde(default)]
14050 pub status: Option<String>,
14051 #[serde(default)]
14053 pub page: Option<u32>,
14054 #[serde(default)]
14056 pub per_page: Option<usize>,
14057}
14058
14059pub async fn aging_pages_report(
14063 State(state): State<super::AdminState>,
14064 tenant: Tenant,
14065 headers: HeaderMap,
14066 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14067 Query(q): Query<AgingQuery>,
14068 axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
14069) -> Result<Response, AdminError> {
14070 let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
14071 let min_days = q.min_days.unwrap_or(90).max(0);
14072 let status_filter = q
14073 .status
14074 .as_deref()
14075 .map(str::trim)
14076 .filter(|s| !s.is_empty() && *s != "all")
14077 .map(str::to_owned)
14078 .unwrap_or_else(|| "published".to_owned());
14079
14080 let now = chrono::Utc::now();
14081 let mut q_pages = Page::objects().order_by(&[("updated_at", false)]); if status_filter != "all" {
14083 q_pages = q_pages.where_(Page::status.eq(status_filter.clone()));
14084 }
14085 let all: Vec<Page> = q_pages.fetch(tenant.pool()).await?;
14086
14087 let stale: Vec<&Page> = all
14089 .iter()
14090 .filter(|p| match p.updated_at.get().copied() {
14091 Some(ts) => {
14092 let delta = now.signed_duration_since(ts).num_days();
14093 delta >= min_days
14094 }
14095 None => false,
14096 })
14097 .collect();
14098 let total = stale.len();
14099 let paginator = rustango::pagination::Paginator::new(total, page_size);
14103 let page_obj = paginator.get_page(q.page.unwrap_or(1).max(1) as i64);
14104 let current_page = page_obj.number as u32;
14105 let has_next = page_obj.has_next();
14106 let has_prev = page_obj.has_previous();
14107 let slice: Vec<&&Page> = if total == 0 {
14108 Vec::new()
14109 } else {
14110 stale[page_obj.start_index().saturating_sub(1)..page_obj.end_index()]
14111 .iter()
14112 .collect()
14113 };
14114
14115 let page_ids: Vec<i64> = slice.iter().filter_map(|p| p.id.get().copied()).collect();
14118 let revisions: Vec<crate::revision::Revision> = if page_ids.is_empty() {
14119 Vec::new()
14120 } else {
14121 crate::revision::Revision::objects()
14122 .where_(crate::revision::Revision::page_id.is_in(page_ids.iter().copied()))
14123 .order_by(&[("sequence", true)]) .fetch(tenant.pool())
14125 .await
14126 .unwrap_or_default()
14127 };
14128 let mut last_editor_by_page: std::collections::HashMap<i64, Option<i64>> =
14129 std::collections::HashMap::new();
14130 for r in &revisions {
14131 last_editor_by_page.entry(r.page_id).or_insert(r.created_by);
14134 }
14135 let user_ids: Vec<i64> = last_editor_by_page
14136 .values()
14137 .filter_map(|opt| *opt)
14138 .collect();
14139 let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
14140 Vec::new()
14141 } else {
14142 rustango::tenancy::auth::User::objects()
14143 .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
14144 .fetch(tenant.pool())
14145 .await
14146 .unwrap_or_default()
14147 };
14148 let username_by_id: std::collections::HashMap<i64, String> = users
14149 .into_iter()
14150 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
14151 .collect();
14152
14153 let rows: Vec<serde_json::Value> = slice
14154 .iter()
14155 .map(|p| {
14156 let pid = p.id.get().copied().unwrap_or_default();
14157 let updated = p.updated_at.get().copied();
14158 let days_stale = updated.map(|ts| now.signed_duration_since(ts).num_days());
14159 let editor = last_editor_by_page
14160 .get(&pid)
14161 .and_then(|v| *v)
14162 .and_then(|uid| username_by_id.get(&uid).cloned());
14163 serde_json::json!({
14164 "id": pid,
14165 "title": p.title,
14166 "url_path": p.url_path,
14167 "status": p.status,
14168 "updated_at": updated,
14169 "days_stale": days_stale,
14170 "last_editor": editor,
14171 })
14172 })
14173 .collect();
14174
14175 let mut ctx = Context::new();
14176 add_chrome(&mut ctx, &tenant, "reports", session_user.as_ref()).await;
14177 add_admin_theme(&mut ctx, tenant.pool()).await;
14178 ctx.insert("rows", &rows);
14179 ctx.insert("min_days", &min_days);
14180 ctx.insert("status_filter", &status_filter);
14181 ctx.insert("query_string", &raw_query.unwrap_or_default());
14184 ctx.insert("current_page", ¤t_page);
14185 ctx.insert("has_next", &has_next);
14186 ctx.insert("has_prev", &has_prev);
14187 ctx.insert("total", &total);
14188 ctx.insert("page_size", &page_size);
14189 ctx.insert(
14190 "pagination",
14191 &crate::admin::pagination::context(current_page as i64, page_size, total),
14192 );
14193 render_with_csrf(&state, &headers, "rcms_admin/aging_pages.html", &mut ctx)
14194}
14195
14196pub async fn aging_pages_csv(
14200 State(_state): State<super::AdminState>,
14201 tenant: Tenant,
14202 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14203 Query(q): Query<AgingQuery>,
14204) -> Result<Response, AdminError> {
14205 let min_days = q.min_days.unwrap_or(90).max(0);
14206 let status_filter = q
14207 .status
14208 .as_deref()
14209 .map(str::trim)
14210 .filter(|s| !s.is_empty() && *s != "all")
14211 .map(str::to_owned)
14212 .unwrap_or_else(|| "published".to_owned());
14213 let now = chrono::Utc::now();
14214 let mut q_pages = Page::objects().order_by(&[("updated_at", false)]);
14215 if status_filter != "all" {
14216 q_pages = q_pages.where_(Page::status.eq(status_filter.clone()));
14217 }
14218 let all: Vec<Page> = q_pages.fetch(tenant.pool()).await?;
14219 let stale: Vec<&Page> = all
14220 .iter()
14221 .filter(|p| match p.updated_at.get().copied() {
14222 Some(ts) => now.signed_duration_since(ts).num_days() >= min_days,
14223 None => false,
14224 })
14225 .collect();
14226
14227 let mut out = String::with_capacity(256 + stale.len() * 96);
14228 out.push_str("page_id,title,url_path,status,updated_at,days_stale\n");
14229 for p in stale {
14230 let pid = p.id.get().copied().unwrap_or_default();
14231 let updated = p.updated_at.get().copied();
14232 let days = updated
14233 .map(|ts| now.signed_duration_since(ts).num_days())
14234 .unwrap_or_default();
14235 let when = updated.map(|t| t.to_rfc3339()).unwrap_or_default();
14236 out.push_str(&format!(
14237 "{},{},{},{},{},{}\n",
14238 pid,
14239 csv_escape(&p.title),
14240 csv_escape(&p.url_path),
14241 csv_escape(&p.status),
14242 csv_escape(&when),
14243 days
14244 ));
14245 }
14246 Ok(csv_response("aging-pages", &out))
14247}
14248
14249fn csv_response(name: &str, body: &str) -> Response {
14251 let filename = format!("{name}-{}.csv", chrono::Utc::now().format("%Y%m%d"));
14252 let mut response = (
14253 [(header::CONTENT_TYPE, "text/csv; charset=utf-8")],
14254 body.to_owned(),
14255 )
14256 .into_response();
14257 if let Ok(v) = HeaderValue::from_str(&format!("attachment; filename=\"{filename}\"")) {
14258 response
14259 .headers_mut()
14260 .insert(header::CONTENT_DISPOSITION, v);
14261 }
14262 response
14263}
14264
14265pub async fn site_settings_list(
14270 State(state): State<super::AdminState>,
14271 tenant: Tenant,
14272 headers: HeaderMap,
14273 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14274) -> Result<Response, AdminError> {
14275 let rows = crate::site_setting::list_all(tenant.pool())
14276 .await
14277 .unwrap_or_default();
14278 let by_scope: std::collections::HashMap<&str, &crate::site_setting::SiteSetting> =
14279 rows.iter().map(|r| (r.scope.as_str(), r)).collect();
14280 let mut view: Vec<serde_json::Value> = Vec::new();
14284 for schema in crate::site_setting::registered_schemas() {
14285 let row = by_scope.get(schema.scope).copied();
14286 view.push(serde_json::json!({
14287 "scope": schema.scope,
14288 "label": schema.label,
14289 "typed": true,
14290 "configured": row.is_some(),
14291 "preview": row
14292 .map(|r| serde_json::to_string(&r.value_json).unwrap_or_default())
14293 .unwrap_or_default(),
14294 "updated_at": row.and_then(|r| r.updated_at.get().copied()),
14295 }));
14296 }
14297 for s in &rows {
14298 if crate::site_setting::schema_for(&s.scope).is_some() {
14299 continue;
14300 }
14301 view.push(serde_json::json!({
14302 "scope": s.scope,
14303 "label": s.scope,
14304 "typed": false,
14305 "configured": true,
14306 "preview": serde_json::to_string(&s.value_json).unwrap_or_default(),
14307 "updated_at": s.updated_at.get().copied(),
14308 }));
14309 }
14310 let mut ctx = Context::new();
14311 add_chrome(&mut ctx, &tenant, "site-settings", session_user.as_ref()).await;
14312 add_admin_theme(&mut ctx, tenant.pool()).await;
14313 ctx.insert("rows", &view);
14314 render_with_csrf(
14315 &state,
14316 &headers,
14317 "rcms_admin/site_settings_list.html",
14318 &mut ctx,
14319 )
14320}
14321
14322pub async fn site_setting_edit_form(
14323 State(state): State<super::AdminState>,
14324 tenant: Tenant,
14325 headers: HeaderMap,
14326 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14327 Path(scope): Path<String>,
14328 Query(q): Query<EditQuery>,
14329) -> Result<Response, AdminError> {
14330 let row = crate::site_setting::get(tenant.pool(), &scope)
14331 .await
14332 .unwrap_or(None);
14333 let stored = row
14334 .as_ref()
14335 .map(|s| s.value_json.clone())
14336 .unwrap_or_else(|| serde_json::json!({}));
14337 let mut ctx = Context::new();
14338 add_chrome(&mut ctx, &tenant, "site-settings", session_user.as_ref()).await;
14339 add_admin_theme(&mut ctx, tenant.pool()).await;
14340 ctx.insert("scope", &scope);
14341 ctx.insert("is_new", &row.is_none());
14342 if let Some(schema) = crate::site_setting::schema_for(&scope) {
14345 let widgets = crate::site_setting::prefill_widgets((schema.fields)(), &stored);
14346 ctx.insert("typed", &true);
14347 ctx.insert("schema_label", schema.label);
14348 let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
14350 .where_(crate::locale::Locale::active.eq(true))
14351 .order_by(&[("sort_order", false), ("code", false)])
14352 .fetch(tenant.pool())
14353 .await?;
14354 let editing = q
14355 .locale
14356 .as_deref()
14357 .and_then(|c| locales.iter().find(|l| l.code == c && !l.is_default).cloned());
14358 if let (Some(loc), false) = (&editing, row.is_none()) {
14359 let tr = crate::site_setting::translations(&stored, &loc.code);
14360 let rows: Vec<serde_json::Value> = widgets
14361 .iter()
14362 .filter(|w| site_setting_translatable(w))
14363 .map(|w| {
14364 serde_json::json!({
14365 "name": w.name,
14366 "label": w.label,
14367 "canonical": w.value,
14368 "multiline": !matches!(w.kind, crate::widget::WidgetKind::Text),
14369 "value": tr.get(&w.name).and_then(|v| v.as_str()).unwrap_or(""),
14370 })
14371 })
14372 .collect();
14373 ctx.insert("translation_mode", &true);
14374 ctx.insert("editing_locale", loc);
14375 ctx.insert("tr_rows", &rows);
14376 }
14377 ctx.insert("locales", &locales);
14378 ctx.insert("widgets", &widgets);
14379 } else {
14380 ctx.insert("typed", &false);
14381 let body = serde_json::to_string_pretty(&stored).unwrap_or_else(|_| "{}".to_owned());
14382 ctx.insert("value_pretty", &body);
14383 }
14384 render_with_csrf(
14385 &state,
14386 &headers,
14387 "rcms_admin/site_setting_form.html",
14388 &mut ctx,
14389 )
14390}
14391
14392pub async fn site_setting_edit_submit(
14393 State(_state): State<super::AdminState>,
14394 tenant: Tenant,
14395 headers: HeaderMap,
14396 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14397 Path(scope): Path<String>,
14398 Form(form): Form<std::collections::HashMap<String, String>>,
14399) -> Result<Response, AdminError> {
14400 let parsed: serde_json::Value = if let Some(schema) = crate::site_setting::schema_for(&scope) {
14403 let fields = (schema.fields)();
14404 let missing = crate::site_setting::missing_required(&fields, &form);
14405 if !missing.is_empty() {
14406 return Err(AdminError::Validation(format!(
14407 "These required fields are empty: {}.",
14408 missing.join(", ")
14409 )));
14410 }
14411 let mut value = crate::site_setting::value_json_from_form(&fields, &form);
14412 if let Ok(Some(old)) = crate::site_setting::get(tenant.pool(), &scope).await {
14413 crate::site_setting::keep_translations(&old.value_json, &mut value);
14414 }
14415 value
14416 } else {
14417 let raw = form.get("value_json").map_or("", |s| s.trim());
14418 if raw.is_empty() {
14419 serde_json::json!({})
14420 } else {
14421 serde_json::from_str(raw)
14422 .map_err(|e| AdminError::Validation(format!("value_json isn't valid JSON: {e}")))?
14423 }
14424 };
14425 crate::site_setting::upsert(tenant.pool(), &scope, parsed).await?;
14426 redirect_named_with_message_args(
14427 "rcms-admin:site-settings:list",
14428 MsgLevel::Success,
14429 "Saved site setting “{scope}”.",
14430 &[("scope", scope.as_str())],
14431 &headers,
14432 )
14433}
14434
14435fn site_setting_translatable(w: &crate::widget::Widget) -> bool {
14437 use crate::widget::WidgetKind as K;
14438 matches!(w.kind, K::Text | K::Textarea | K::Markdown | K::RichText)
14439}
14440
14441pub async fn site_setting_translate_submit(
14444 State(_state): State<super::AdminState>,
14445 tenant: Tenant,
14446 headers: HeaderMap,
14447 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14448 Path(scope): Path<String>,
14449 Query(q): Query<EditQuery>,
14450 Form(form): Form<std::collections::HashMap<String, String>>,
14451) -> Result<Response, AdminError> {
14452 let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
14453 let schema = crate::site_setting::schema_for(&scope)
14454 .ok_or_else(|| AdminError::Validation(format!("`{scope}` has no typed fields to translate")))?;
14455 let row = crate::site_setting::get(tenant.pool(), &scope)
14456 .await?
14457 .ok_or_else(|| AdminError::Validation(format!("save `{scope}` before translating it")))?;
14458 let fields: serde_json::Map<String, serde_json::Value> = (schema.fields)()
14459 .iter()
14460 .filter(|w| site_setting_translatable(w))
14461 .filter_map(|w| {
14462 form.get(&format!("tr__{}", w.name))
14463 .map(|v| (w.name.clone(), serde_json::Value::String(v.trim().to_owned())))
14464 })
14465 .collect();
14466 let mut value = row.value_json;
14467 crate::site_setting::set_translations(&mut value, &locale.code, fields);
14468 crate::site_setting::upsert(tenant.pool(), &scope, value).await?;
14469 Ok(rustango::messages::redirect_with_message(
14470 messages_secret(),
14471 &headers,
14472 MsgLevel::Success,
14473 &super::i18n::tr(&headers, "Translations saved.", &[]),
14474 &format!("/cms-admin/site-settings/{scope}/edit?locale={}", locale.code),
14475 ))
14476}
14477
14478pub async fn site_setting_delete_submit(
14479 State(_state): State<super::AdminState>,
14480 tenant: Tenant,
14481 headers: HeaderMap,
14482 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14483 Path(scope): Path<String>,
14484) -> Result<Response, AdminError> {
14485 if let Some(row) = crate::site_setting::get(tenant.pool(), &scope)
14486 .await
14487 .unwrap_or(None)
14488 {
14489 row.delete_pool(tenant.pool()).await?;
14490 }
14491 redirect_named_with_message_args(
14492 "rcms-admin:site-settings:list",
14493 MsgLevel::Success,
14494 "Deleted site setting “{scope}”.",
14495 &[("scope", scope.as_str())],
14496 &headers,
14497 )
14498}
14499
14500pub async fn search_promotions_report(
14509 State(state): State<super::AdminState>,
14510 tenant: Tenant,
14511 headers: HeaderMap,
14512 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14513) -> Result<Response, AdminError> {
14514 let top = crate::search_promotion::top_queries(tenant.pool(), 100)
14515 .await
14516 .unwrap_or_default();
14517 let mut rows: Vec<serde_json::Value> = Vec::with_capacity(top.len());
14519 for q in top {
14520 let qid = q.id.get().copied().unwrap_or_default();
14521 let promos = crate::search_promotion::promotions_for_query(tenant.pool(), qid)
14522 .await
14523 .unwrap_or_default();
14524 rows.push(serde_json::json!({
14525 "id": qid,
14526 "raw": q.raw,
14527 "normalized": q.normalized,
14528 "hits": q.hits,
14529 "last_seen_at": q.last_seen_at.get().copied(),
14530 "promotion_count": promos.len(),
14531 }));
14532 }
14533 let mut ctx = Context::new();
14534 add_chrome(&mut ctx, &tenant, "reports-search", session_user.as_ref()).await;
14535 add_admin_theme(&mut ctx, tenant.pool()).await;
14536 ctx.insert("rows", &rows);
14537 render_with_csrf(
14538 &state,
14539 &headers,
14540 "rcms_admin/search_promotions_report.html",
14541 &mut ctx,
14542 )
14543}
14544
14545pub async fn search_promotion_edit_form(
14548 State(state): State<super::AdminState>,
14549 tenant: Tenant,
14550 headers: HeaderMap,
14551 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14552 Path(query_id): Path<i64>,
14553) -> Result<Response, AdminError> {
14554 use rustango::core::Column as _;
14555 use rustango::sql::FetcherPool as _;
14556 let queries: Vec<crate::search_promotion::SearchQuery> =
14557 crate::search_promotion::SearchQuery::objects()
14558 .where_(crate::search_promotion::SearchQuery::id.eq(query_id))
14559 .fetch(tenant.pool())
14560 .await?;
14561 let Some(query) = queries.into_iter().next() else {
14562 return Err(AdminError::NotFound(query_id));
14563 };
14564 let promotions = crate::search_promotion::promotions_for_query(tenant.pool(), query_id)
14565 .await
14566 .unwrap_or_default();
14567 let pages: Vec<Page> = Page::objects()
14568 .where_(Page::status.eq("published".to_owned()))
14569 .order_by(&[("title", false)])
14570 .fetch(tenant.pool())
14571 .await
14572 .unwrap_or_default();
14573 let mut ctx = Context::new();
14574 add_chrome(&mut ctx, &tenant, "reports-search", session_user.as_ref()).await;
14575 add_admin_theme(&mut ctx, tenant.pool()).await;
14576 ctx.insert("query", &query);
14577 ctx.insert("promotions", &promotions);
14578 ctx.insert("pages", &pages);
14579 render_with_csrf(
14580 &state,
14581 &headers,
14582 "rcms_admin/search_promotion_edit.html",
14583 &mut ctx,
14584 )
14585}
14586
14587#[derive(Debug, Deserialize)]
14588pub struct SearchPromotionForm {
14589 #[serde(default)]
14591 pub page_ids: String,
14592 #[serde(default)]
14593 pub descriptions: String,
14594}
14595
14596pub async fn search_promotion_edit_submit(
14599 State(_state): State<super::AdminState>,
14600 tenant: Tenant,
14601 headers: HeaderMap,
14602 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14603 Path(query_id): Path<i64>,
14604 Form(form): Form<SearchPromotionForm>,
14605) -> Result<Response, AdminError> {
14606 use rustango::core::Column as _;
14607 use rustango::sql::Auto;
14608 use rustango::sql::FetcherPool as _;
14609 let existing: Vec<crate::search_promotion::SearchPromotion> =
14612 crate::search_promotion::SearchPromotion::objects()
14613 .where_(crate::search_promotion::SearchPromotion::query_id.eq(query_id))
14614 .fetch(tenant.pool())
14615 .await?;
14616 for row in existing {
14617 row.delete_pool(tenant.pool()).await.log_warn("old search promotion not deleted");
14618 }
14619 let ids: Vec<i64> = form
14620 .page_ids
14621 .split(',')
14622 .map(str::trim)
14623 .filter(|s| !s.is_empty())
14624 .filter_map(|s| s.parse::<i64>().ok())
14625 .collect();
14626 let descriptions: Vec<String> = form
14627 .descriptions
14628 .split('\n')
14629 .map(|s| s.trim().to_owned())
14630 .collect();
14631 for (idx, page_id) in ids.iter().enumerate() {
14632 let mut row = crate::search_promotion::SearchPromotion {
14633 id: Auto::Unset,
14634 query_id,
14635 page_id: *page_id,
14636 sort_order: idx as i32,
14637 description: descriptions.get(idx).cloned().unwrap_or_default(),
14638 created_at: Auto::Unset,
14639 };
14640 row.insert_pool(tenant.pool()).await.log_warn("search promotion not saved");
14641 }
14642 redirect_named_with_message_plural(
14643 "rcms-admin:reports:search",
14644 MsgLevel::Success,
14645 "Saved {count} pinned result(s).",
14646 ids.len() as i64,
14647 &[("count", &ids.len().to_string())],
14648 &headers,
14649 )
14650}
14651
14652pub(crate) fn derive_scheduled_status(
14668 current: &str,
14669 go_live_at: Option<chrono::DateTime<chrono::Utc>>,
14670) -> String {
14671 let archived = crate::page::PageStatus::Archived.as_str();
14672 if current == archived {
14673 return current.to_owned();
14674 }
14675 let now = chrono::Utc::now();
14676 let future = go_live_at.is_some_and(|t| t > now);
14677 let scheduled = crate::page::PageStatus::Scheduled.as_str();
14678 let draft = crate::page::PageStatus::Draft.as_str();
14679 match (current, future, go_live_at) {
14680 (_, true, _) => scheduled.to_owned(),
14681 (s, false, None) if s == scheduled => draft.to_owned(),
14682 _ => current.to_owned(),
14683 }
14684}
14685
14686#[cfg(test)]
14687mod scheduled_status_tests {
14688 use super::derive_scheduled_status;
14689 use chrono::{Duration, Utc};
14690
14691 #[test]
14692 fn future_go_live_promotes_draft_to_scheduled() {
14693 let go = Utc::now() + Duration::hours(1);
14694 assert_eq!(derive_scheduled_status("draft", Some(go)), "scheduled");
14695 }
14696
14697 #[test]
14698 fn future_go_live_also_promotes_published() {
14699 let go = Utc::now() + Duration::hours(2);
14702 assert_eq!(derive_scheduled_status("published", Some(go)), "scheduled");
14703 }
14704
14705 #[test]
14706 fn cleared_go_live_demotes_scheduled_to_draft() {
14707 assert_eq!(derive_scheduled_status("scheduled", None), "draft");
14708 }
14709
14710 #[test]
14711 fn past_go_live_on_scheduled_left_alone_for_sweep() {
14712 let past = Utc::now() - Duration::hours(1);
14713 assert_eq!(
14714 derive_scheduled_status("scheduled", Some(past)),
14715 "scheduled",
14716 );
14717 }
14718
14719 #[test]
14720 fn archived_preserved_regardless_of_go_live() {
14721 let go = Utc::now() + Duration::hours(1);
14722 assert_eq!(derive_scheduled_status("archived", Some(go)), "archived");
14723 assert_eq!(derive_scheduled_status("archived", None), "archived");
14724 }
14725
14726 #[test]
14727 fn draft_with_no_go_live_unchanged() {
14728 assert_eq!(derive_scheduled_status("draft", None), "draft");
14729 }
14730
14731 #[test]
14732 fn published_with_no_go_live_unchanged() {
14733 assert_eq!(derive_scheduled_status("published", None), "published");
14734 }
14735}
14736
14737async fn scheduled_pages_rows(
14742 pool: &rustango::sql::Pool,
14743) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
14744 use rustango::sql::FetcherPool as _;
14745 let pages: Vec<Page> = Page::objects().fetch(pool).await?;
14746 let now = chrono::Utc::now();
14747 let mut rows: Vec<serde_json::Value> = Vec::new();
14748 for p in &pages {
14749 let pid = p.id.get().copied().unwrap_or_default();
14750 if let Some(go) = p.go_live_at {
14751 if go > now
14759 && p.status != crate::page::PageStatus::Archived.as_str()
14760 && p.status != crate::page::PageStatus::Expired.as_str()
14761 {
14762 let countdown = (go - now).num_seconds();
14763 rows.push(serde_json::json!({
14764 "kind": "publish",
14765 "when": go,
14766 "countdown_secs": countdown,
14767 "page_id": pid,
14768 "title": p.title,
14769 "url_path": p.url_path,
14770 "status": p.status,
14771 }));
14772 }
14773 }
14774 if let Some(exp) = p.expire_at {
14775 if exp > now
14777 && (p.status == crate::page::PageStatus::Published.as_str()
14778 || p.status == crate::page::PageStatus::Scheduled.as_str())
14779 {
14780 let countdown = (exp - now).num_seconds();
14781 rows.push(serde_json::json!({
14782 "kind": "expire",
14783 "when": exp,
14784 "countdown_secs": countdown,
14785 "page_id": pid,
14786 "title": p.title,
14787 "url_path": p.url_path,
14788 "status": p.status,
14789 }));
14790 }
14791 }
14792 }
14793 rows.sort_by_key(|r| {
14794 r.get("countdown_secs")
14795 .and_then(|v| v.as_i64())
14796 .unwrap_or(i64::MAX)
14797 });
14798 Ok(rows)
14799}
14800
14801pub async fn scheduled_report(
14802 State(state): State<super::AdminState>,
14803 tenant: Tenant,
14804 headers: HeaderMap,
14805 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14806) -> Result<Response, AdminError> {
14807 let rows = scheduled_pages_rows(tenant.pool())
14808 .await
14809 .unwrap_or_default();
14810 let mut ctx = Context::new();
14811 add_chrome(
14812 &mut ctx,
14813 &tenant,
14814 "reports-scheduled",
14815 session_user.as_ref(),
14816 )
14817 .await;
14818 add_admin_theme(&mut ctx, tenant.pool()).await;
14819 ctx.insert("rows", &rows);
14820 render_with_csrf(
14821 &state,
14822 &headers,
14823 "rcms_admin/scheduled_report.html",
14824 &mut ctx,
14825 )
14826}
14827
14828pub async fn scheduled_report_csv(
14829 State(_state): State<super::AdminState>,
14830 tenant: Tenant,
14831 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14832) -> Result<Response, AdminError> {
14833 let rows = scheduled_pages_rows(tenant.pool())
14834 .await
14835 .unwrap_or_default();
14836 let mut out = String::with_capacity(256 + rows.len() * 160);
14837 out.push_str("kind,page_id,title,url_path,status,when,countdown_secs\n");
14838 for r in &rows {
14839 out.push_str(&format!(
14840 "{},{},{},{},{},{},{}\n",
14841 csv_escape(r.get("kind").and_then(|v| v.as_str()).unwrap_or_default()),
14842 r.get("page_id")
14843 .and_then(|v| v.as_i64())
14844 .unwrap_or_default(),
14845 csv_escape(r.get("title").and_then(|v| v.as_str()).unwrap_or_default()),
14846 csv_escape(
14847 r.get("url_path")
14848 .and_then(|v| v.as_str())
14849 .unwrap_or_default()
14850 ),
14851 csv_escape(r.get("status").and_then(|v| v.as_str()).unwrap_or_default()),
14852 csv_escape(&r.get("when").map(ToString::to_string).unwrap_or_default()),
14853 r.get("countdown_secs")
14854 .and_then(|v| v.as_i64())
14855 .unwrap_or_default(),
14856 ));
14857 }
14858 Ok(csv_response("scheduled-pages", &out))
14859}
14860
14861async fn locked_pages_rows(
14865 pool: &rustango::sql::Pool,
14866) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
14867 use rustango::sql::FetcherPool as _;
14868 let locks: Vec<crate::lock::PageLock> = crate::lock::PageLock::objects()
14869 .order_by(&[("acquired_at", true)]) .fetch(pool)
14871 .await?;
14872 let now = chrono::Utc::now();
14873 let live: Vec<&crate::lock::PageLock> = locks.iter().filter(|l| !l.is_stale(now)).collect();
14874 if live.is_empty() {
14875 return Ok(Vec::new());
14876 }
14877 let page_ids: Vec<i64> = live.iter().map(|l| l.page_id).collect();
14878 let user_ids: Vec<i64> = live.iter().map(|l| l.user_id).collect();
14879 let pages: Vec<Page> = Page::objects()
14880 .where_(Page::id.is_in(page_ids))
14881 .fetch(pool)
14882 .await
14883 .unwrap_or_default();
14884 let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
14885 .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
14886 .fetch(pool)
14887 .await
14888 .unwrap_or_default();
14889 let page_by_id: std::collections::HashMap<i64, &Page> = pages
14890 .iter()
14891 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
14892 .collect();
14893 let user_by_id: std::collections::HashMap<i64, String> = users
14894 .into_iter()
14895 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
14896 .collect();
14897 Ok(live
14898 .into_iter()
14899 .map(|l| {
14900 let title = page_by_id
14901 .get(&l.page_id)
14902 .map(|p| p.title.clone())
14903 .unwrap_or_else(|| format!("page #{}", l.page_id));
14904 let url_path = page_by_id
14905 .get(&l.page_id)
14906 .map(|p| p.url_path.clone())
14907 .unwrap_or_default();
14908 let username = user_by_id
14909 .get(&l.user_id)
14910 .cloned()
14911 .unwrap_or_else(|| format!("user#{}", l.user_id));
14912 let ttl_remaining = (l.expires_at - now).num_seconds();
14913 serde_json::json!({
14914 "page_id": l.page_id,
14915 "title": title,
14916 "url_path": url_path,
14917 "user_id": l.user_id,
14918 "username": username,
14919 "acquired_at": l.acquired_at.get().copied(),
14920 "expires_at": l.expires_at,
14921 "ttl_remaining_secs": ttl_remaining,
14922 })
14923 })
14924 .collect())
14925}
14926
14927pub async fn locked_pages_report(
14928 State(state): State<super::AdminState>,
14929 tenant: Tenant,
14930 headers: HeaderMap,
14931 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14932) -> Result<Response, AdminError> {
14933 let rows = locked_pages_rows(tenant.pool()).await.unwrap_or_default();
14934 let mut ctx = Context::new();
14935 add_chrome(&mut ctx, &tenant, "reports-locked", session_user.as_ref()).await;
14936 add_admin_theme(&mut ctx, tenant.pool()).await;
14937 ctx.insert("rows", &rows);
14938 render_with_csrf(&state, &headers, "rcms_admin/locked_pages.html", &mut ctx)
14939}
14940
14941pub async fn locked_pages_csv(
14942 State(_state): State<super::AdminState>,
14943 tenant: Tenant,
14944 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14945) -> Result<Response, AdminError> {
14946 let rows = locked_pages_rows(tenant.pool()).await.unwrap_or_default();
14947 let mut out = String::with_capacity(256 + rows.len() * 128);
14948 out.push_str("page_id,title,url_path,username,acquired_at,expires_at\n");
14949 for r in &rows {
14950 out.push_str(&format!(
14951 "{},{},{},{},{},{}\n",
14952 r.get("page_id")
14953 .and_then(|v| v.as_i64())
14954 .unwrap_or_default(),
14955 csv_escape(r.get("title").and_then(|v| v.as_str()).unwrap_or_default()),
14956 csv_escape(
14957 r.get("url_path")
14958 .and_then(|v| v.as_str())
14959 .unwrap_or_default()
14960 ),
14961 csv_escape(
14962 r.get("username")
14963 .and_then(|v| v.as_str())
14964 .unwrap_or_default()
14965 ),
14966 csv_escape(
14967 r.get("acquired_at")
14968 .and_then(|v| v.as_str())
14969 .unwrap_or_default()
14970 ),
14971 csv_escape(
14972 r.get("expires_at")
14973 .and_then(|v| v.as_str())
14974 .unwrap_or_default()
14975 ),
14976 ));
14977 }
14978 Ok(csv_response("locked-pages", &out))
14979}
14980
14981async fn workflows_report_rows(
14986 pool: &rustango::sql::Pool,
14987) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
14988 use rustango::sql::FetcherPool as _;
14989 let states: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
14990 .order_by(&[("requested_at", true)]) .fetch(pool)
14992 .await?;
14993 if states.is_empty() {
14994 return Ok(Vec::new());
14995 }
14996 let workflow_ids: Vec<i64> = states.iter().map(|s| s.workflow_id).collect();
14997 let page_ids: Vec<i64> = states.iter().map(|s| s.page_id).collect();
14998 let user_ids: Vec<i64> = states.iter().map(|s| s.requested_by).collect();
14999 let workflows: Vec<crate::workflow::Workflow> = crate::workflow::Workflow::objects()
15000 .where_(crate::workflow::Workflow::id.is_in(workflow_ids))
15001 .fetch(pool)
15002 .await
15003 .unwrap_or_default();
15004 let pages: Vec<Page> = Page::objects()
15005 .where_(Page::id.is_in(page_ids))
15006 .fetch(pool)
15007 .await
15008 .unwrap_or_default();
15009 let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
15010 .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
15011 .fetch(pool)
15012 .await
15013 .unwrap_or_default();
15014 let task_ids: Vec<i64> = states.iter().filter_map(|s| s.current_task_id).collect();
15015 let tasks: Vec<crate::workflow::WorkflowTask> = if task_ids.is_empty() {
15016 Vec::new()
15017 } else {
15018 crate::workflow::WorkflowTask::objects()
15019 .where_(crate::workflow::WorkflowTask::id.is_in(task_ids))
15020 .fetch(pool)
15021 .await
15022 .unwrap_or_default()
15023 };
15024 let workflow_by_id: std::collections::HashMap<i64, String> = workflows
15025 .into_iter()
15026 .filter_map(|w| w.id.get().copied().map(|id| (id, w.name)))
15027 .collect();
15028 let page_by_id: std::collections::HashMap<i64, &Page> = pages
15029 .iter()
15030 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
15031 .collect();
15032 let user_by_id: std::collections::HashMap<i64, String> = users
15033 .into_iter()
15034 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
15035 .collect();
15036 let task_by_id: std::collections::HashMap<i64, String> = tasks
15037 .into_iter()
15038 .filter_map(|t| t.id.get().copied().map(|id| (id, t.name)))
15039 .collect();
15040 Ok(states
15041 .iter()
15042 .map(|s| {
15043 serde_json::json!({
15044 "id": s.id.get().copied(),
15045 "workflow_name": workflow_by_id.get(&s.workflow_id).cloned().unwrap_or_else(|| format!("workflow #{}", s.workflow_id)),
15046 "page_id": s.page_id,
15047 "page_title": page_by_id.get(&s.page_id).map(|p| p.title.clone()).unwrap_or_else(|| format!("page #{}", s.page_id)),
15048 "page_url_path": page_by_id.get(&s.page_id).map(|p| p.url_path.clone()).unwrap_or_default(),
15049 "status": s.status,
15050 "current_task_name": s.current_task_id.and_then(|tid| task_by_id.get(&tid).cloned()),
15051 "requested_by_username": user_by_id.get(&s.requested_by).cloned(),
15052 "requested_at": s.requested_at.get().copied(),
15053 "finished_at": s.finished_at,
15054 })
15055 })
15056 .collect())
15057}
15058
15059pub async fn workflows_report(
15060 State(state): State<super::AdminState>,
15061 tenant: Tenant,
15062 headers: HeaderMap,
15063 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15064) -> Result<Response, AdminError> {
15065 let rows = workflows_report_rows(tenant.pool())
15066 .await
15067 .unwrap_or_default();
15068 let mut ctx = Context::new();
15069 add_chrome(
15070 &mut ctx,
15071 &tenant,
15072 "reports-workflows",
15073 session_user.as_ref(),
15074 )
15075 .await;
15076 add_admin_theme(&mut ctx, tenant.pool()).await;
15077 ctx.insert("rows", &rows);
15078 render_with_csrf(
15079 &state,
15080 &headers,
15081 "rcms_admin/workflow_report.html",
15082 &mut ctx,
15083 )
15084}
15085
15086pub async fn revisions_report(
15094 State(state): State<super::AdminState>,
15095 tenant: Tenant,
15096 headers: HeaderMap,
15097 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15098) -> Result<Response, AdminError> {
15099 use rustango::sql::FetcherPool as _;
15100 let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
15101 let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
15102 .fetch(tenant.pool())
15103 .await
15104 .unwrap_or_default();
15105 let mut count_by_page: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
15106 for r in &revisions {
15107 *count_by_page.entry(r.page_id).or_default() += 1;
15108 }
15109 let mut rows: Vec<serde_json::Value> = pages
15110 .into_iter()
15111 .filter_map(|p| {
15112 let pid = p.id.get().copied()?;
15113 let count = count_by_page.get(&pid).copied().unwrap_or(0);
15114 if count == 0 {
15115 return None;
15116 }
15117 Some(serde_json::json!({
15118 "page_id": pid,
15119 "title": p.title,
15120 "url_path": p.url_path,
15121 "status": p.status,
15122 "revision_count": count,
15123 }))
15124 })
15125 .collect();
15126 rows.sort_by(|a, b| {
15127 let ac = a
15128 .get("revision_count")
15129 .and_then(|v| v.as_u64())
15130 .unwrap_or(0);
15131 let bc = b
15132 .get("revision_count")
15133 .and_then(|v| v.as_u64())
15134 .unwrap_or(0);
15135 bc.cmp(&ac)
15136 });
15137 let total_revisions = revisions.len();
15138 let mut ctx = Context::new();
15139 add_chrome(
15140 &mut ctx,
15141 &tenant,
15142 "reports-revisions",
15143 session_user.as_ref(),
15144 )
15145 .await;
15146 add_admin_theme(&mut ctx, tenant.pool()).await;
15147 ctx.insert("rows", &rows);
15148 ctx.insert("total_revisions", &total_revisions);
15149 ctx.insert("default_keep_latest", &crate::revision::DEFAULT_KEEP_LATEST);
15150 render_with_csrf(
15151 &state,
15152 &headers,
15153 "rcms_admin/revisions_report.html",
15154 &mut ctx,
15155 )
15156}
15157
15158#[derive(Debug, Deserialize)]
15160pub struct RevisionsPruneForm {
15161 #[serde(default)]
15162 pub keep_latest: Option<usize>,
15163 #[serde(default)]
15164 pub include_published: Option<String>,
15165}
15166
15167pub async fn revisions_report_prune(
15171 State(_state): State<super::AdminState>,
15172 tenant: Tenant,
15173 headers: HeaderMap,
15174 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
15175 Form(form): Form<RevisionsPruneForm>,
15176) -> Result<Response, AdminError> {
15177 let keep_latest = form
15178 .keep_latest
15179 .unwrap_or(crate::revision::DEFAULT_KEEP_LATEST)
15180 .max(1);
15181 let keep_published = form.include_published.as_deref() != Some("1");
15185 let (pages_scanned, rows_deleted) =
15186 crate::revision::prune_all_pages(tenant.pool(), keep_latest, keep_published)
15187 .await
15188 .unwrap_or((0, 0));
15189 let revisions = super::i18n::tr_plural(
15190 &headers,
15191 "{count} revision(s)",
15192 rows_deleted as i64,
15193 &[("count", &rows_deleted.to_string())],
15194 );
15195 let pages_ph = super::i18n::tr_plural(
15196 &headers,
15197 "{count} page(s)",
15198 pages_scanned as i64,
15199 &[("count", &pages_scanned.to_string())],
15200 );
15201 let kl = keep_latest.to_string();
15202 let kp = keep_published.to_string();
15203 redirect_named_with_message_args(
15204 "rcms-admin:reports:revisions",
15205 MsgLevel::Success,
15206 "Pruned {revisions} across {pages} (keep_latest={keep_latest}, keep_published={keep_published}).",
15207 &[
15208 ("revisions", revisions.as_str()),
15209 ("pages", pages_ph.as_str()),
15210 ("keep_latest", kl.as_str()),
15211 ("keep_published", kp.as_str()),
15212 ],
15213 &headers,
15214 )
15215}
15216
15217pub async fn workflows_report_csv(
15218 State(_state): State<super::AdminState>,
15219 tenant: Tenant,
15220 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
15221) -> Result<Response, AdminError> {
15222 let rows = workflows_report_rows(tenant.pool())
15223 .await
15224 .unwrap_or_default();
15225 let mut out = String::with_capacity(256 + rows.len() * 192);
15226 out.push_str("workflow,page_id,page_title,page_url,status,current_task,requested_by,requested_at,finished_at\n");
15227 for r in &rows {
15228 out.push_str(&format!(
15229 "{},{},{},{},{},{},{},{},{}\n",
15230 csv_escape(
15231 r.get("workflow_name")
15232 .and_then(|v| v.as_str())
15233 .unwrap_or_default()
15234 ),
15235 r.get("page_id")
15236 .and_then(|v| v.as_i64())
15237 .unwrap_or_default(),
15238 csv_escape(
15239 r.get("page_title")
15240 .and_then(|v| v.as_str())
15241 .unwrap_or_default()
15242 ),
15243 csv_escape(
15244 r.get("page_url_path")
15245 .and_then(|v| v.as_str())
15246 .unwrap_or_default()
15247 ),
15248 csv_escape(r.get("status").and_then(|v| v.as_str()).unwrap_or_default()),
15249 csv_escape(
15250 r.get("current_task_name")
15251 .and_then(|v| v.as_str())
15252 .unwrap_or_default()
15253 ),
15254 csv_escape(
15255 r.get("requested_by_username")
15256 .and_then(|v| v.as_str())
15257 .unwrap_or_default()
15258 ),
15259 csv_escape(
15260 r.get("requested_at")
15261 .and_then(|v| v.as_str())
15262 .unwrap_or_default()
15263 ),
15264 csv_escape(
15265 r.get("finished_at")
15266 .and_then(|v| v.as_str())
15267 .unwrap_or_default()
15268 ),
15269 ));
15270 }
15271 Ok(csv_response("workflow-report", &out))
15272}
15273
15274#[derive(Debug, Deserialize)]
15282pub struct AdminSearchQuery {
15283 #[serde(default)]
15284 pub q: Option<String>,
15285 #[serde(default)]
15286 pub autocomplete: Option<String>,
15287}
15288
15289#[derive(Debug, Deserialize)]
15291pub struct PageChooserQuery {
15292 #[serde(default)]
15293 pub q: Option<String>,
15294}
15295
15296#[derive(Debug, Default, Deserialize)]
15298pub struct ChooserSearchQuery {
15299 #[serde(default)]
15300 pub q: Option<String>,
15301}
15302
15303pub async fn chooser_search_json(
15308 State(_state): State<super::AdminState>,
15309 tenant: Tenant,
15310 Path(slug): Path<String>,
15311 Query(q): Query<ChooserSearchQuery>,
15312) -> Result<Response, AdminError> {
15313 let Some(cvs) = super::chooser::find(&slug) else {
15314 return Ok((axum::http::StatusCode::NOT_FOUND, "unknown chooser").into_response());
15315 };
15316 let items = (cvs.search_rows)(tenant.pool().clone(), q.q.unwrap_or_default()).await;
15317 let body = serde_json::json!({ "items": items });
15318 Ok((
15319 [(header::CONTENT_TYPE, "application/json")],
15320 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15321 )
15322 .into_response())
15323}
15324
15325#[derive(Debug, Default, Deserialize)]
15327pub struct MediaPickerQuery {
15328 #[serde(default)]
15329 pub q: Option<String>,
15330 #[serde(default)]
15333 pub collection: Option<i64>,
15334 #[serde(default)]
15336 pub kind: Option<String>,
15337 #[serde(default)]
15341 pub ids: Option<String>,
15342 #[serde(default)]
15343 pub limit: Option<usize>,
15344 #[serde(default)]
15345 pub offset: Option<usize>,
15346}
15347
15348pub async fn media_picker_json(
15359 State(_state): State<super::AdminState>,
15360 tenant: Tenant,
15361 Query(q): Query<MediaPickerQuery>,
15362) -> Result<Response, AdminError> {
15363 let body = media_picker_payload(tenant.pool(), &q).await?;
15364 Ok((
15365 [(header::CONTENT_TYPE, "application/json")],
15366 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15367 )
15368 .into_response())
15369}
15370
15371pub(crate) async fn media_picker_payload(
15375 pool: &rustango::sql::Pool,
15376 q: &MediaPickerQuery,
15377) -> Result<serde_json::Value, AdminError> {
15378 let mut rows: Vec<Media> = Media::objects()
15379 .order_by(&[("uploaded_at", true)])
15380 .fetch(pool)
15381 .await?;
15382
15383 let id_set: Option<std::collections::HashSet<i64>> = q.ids.as_deref().map(|s| {
15386 s.split(',')
15387 .filter_map(|t| t.trim().parse::<i64>().ok())
15388 .collect()
15389 });
15390 if let Some(ids) = &id_set {
15391 rows.retain(|m| m.id.get().copied().is_some_and(|id| ids.contains(&id)));
15392 }
15393 let kind = q
15396 .kind
15397 .as_deref()
15398 .unwrap_or(if id_set.is_some() { "any" } else { "image" });
15399 if kind != "any" {
15400 rows.retain(|m| m.kind == kind);
15401 }
15402 let mut collection_counts: std::collections::HashMap<i64, i64> =
15406 std::collections::HashMap::new();
15407 let mut uncategorized_count: i64 = 0;
15408 for m in &rows {
15409 match m.collection_id {
15410 Some(cid) => *collection_counts.entry(cid).or_default() += 1,
15411 None => uncategorized_count += 1,
15412 }
15413 }
15414 match q.collection {
15415 Some(0) => rows.retain(|m| m.collection_id.is_none()),
15416 Some(cid) => rows.retain(|m| m.collection_id == Some(cid)),
15417 None => {}
15418 }
15419 if let Some(needle) = q.q.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
15420 let needle = needle.to_lowercase();
15421 rows.retain(|m| {
15422 m.title.to_lowercase().contains(&needle)
15423 || m.filename.to_lowercase().contains(&needle)
15424 || m.alt_text.to_lowercase().contains(&needle)
15425 || m.description.to_lowercase().contains(&needle)
15426 });
15427 }
15428
15429 let total = rows.len();
15430 let limit = q.limit.unwrap_or(60).min(200);
15431 let offset = q.offset.unwrap_or(0).min(total);
15432 let has_more = offset + limit < total;
15433 let page: Vec<serde_json::Value> = rows[offset..(offset + limit).min(total)]
15434 .iter()
15435 .map(|m| {
15436 let id = m.id.get().copied().unwrap_or_default();
15437 let is_image = m.kind == "image";
15438 let thumb_url = is_image
15439 .then(|| {
15440 crate::rendition::rendition_url_for(
15441 id,
15442 "fill-320x320|format-webp|quality-70",
15443 Some(m.content_hash.as_str()),
15444 )
15445 })
15446 .flatten();
15447 let preview_url = is_image
15448 .then(|| {
15449 crate::rendition::rendition_url_for(
15450 id,
15451 "max-640x480|format-webp|quality-80",
15452 Some(m.content_hash.as_str()),
15453 )
15454 })
15455 .flatten();
15456 serde_json::json!({
15457 "id": id,
15458 "title": if m.title.is_empty() { m.filename.clone() } else { m.title.clone() },
15459 "filename": m.filename,
15460 "kind": m.kind,
15461 "mime": m.mime,
15462 "size": m.size,
15463 "width": m.width,
15464 "height": m.height,
15465 "collection_id": m.collection_id,
15466 "alt_text": m.alt_text,
15467 "uploaded_at": m.uploaded_at,
15468 "thumb_url": thumb_url,
15469 "preview_url": preview_url,
15470 })
15471 })
15472 .collect();
15473
15474 let cols: Vec<crate::media::MediaCollection> =
15478 crate::media::MediaCollection::objects().fetch(pool).await?;
15479 let mut children: std::collections::HashMap<Option<i64>, Vec<&crate::media::MediaCollection>> =
15480 std::collections::HashMap::new();
15481 for c in &cols {
15482 children.entry(c.parent_id).or_default().push(c);
15483 }
15484 for v in children.values_mut() {
15485 v.sort_by(|a, b| a.sort_order.cmp(&b.sort_order).then(a.name.cmp(&b.name)));
15486 }
15487 let mut ordered: Vec<serde_json::Value> = Vec::with_capacity(cols.len());
15488 let mut visited: std::collections::HashSet<i64> = std::collections::HashSet::new();
15489 let mut stack: Vec<(i64, usize)> = children
15490 .get(&None)
15491 .map(|roots| {
15492 roots
15493 .iter()
15494 .rev()
15495 .filter_map(|c| c.id.get().copied())
15496 .map(|id| (id, 0))
15497 .collect()
15498 })
15499 .unwrap_or_default();
15500 let by_id: std::collections::HashMap<i64, &crate::media::MediaCollection> = cols
15501 .iter()
15502 .filter_map(|c| c.id.get().copied().map(|id| (id, c)))
15503 .collect();
15504 while let Some((id, depth)) = stack.pop() {
15505 if !visited.insert(id) {
15506 continue;
15507 }
15508 if let Some(c) = by_id.get(&id) {
15509 ordered.push(serde_json::json!({
15510 "id": id,
15511 "name": c.name,
15512 "depth": depth,
15513 "count": collection_counts.get(&id).copied().unwrap_or(0),
15514 }));
15515 if let Some(kids) = children.get(&Some(id)) {
15516 for k in kids.iter().rev() {
15517 if let Some(kid) = k.id.get().copied() {
15518 stack.push((kid, depth + 1));
15519 }
15520 }
15521 }
15522 }
15523 }
15524
15525 Ok(serde_json::json!({
15526 "items": page,
15527 "collections": ordered,
15528 "uncategorized_count": uncategorized_count,
15529 "total": total,
15530 "has_more": has_more,
15531 }))
15532}
15533
15534pub async fn page_chooser_json(
15540 State(_state): State<super::AdminState>,
15541 tenant: Tenant,
15542 Query(q): Query<PageChooserQuery>,
15543) -> Result<Response, AdminError> {
15544 let needle =
15545 q.q.as_deref()
15546 .map(str::trim)
15547 .filter(|s| !s.is_empty())
15548 .map(str::to_lowercase);
15549
15550 let mut pages: Vec<Page> = Page::objects()
15551 .order_by(&[("updated_at", true)])
15552 .fetch(tenant.pool())
15553 .await
15554 .unwrap_or_default();
15555
15556 if let Some(n) = needle.as_ref() {
15557 pages.retain(|p| {
15558 p.title.to_lowercase().contains(n)
15559 || p.slug.to_lowercase().contains(n)
15560 || p.url_path.to_lowercase().contains(n)
15561 });
15562 }
15563
15564 let items: Vec<serde_json::Value> = pages
15565 .iter()
15566 .take(50)
15567 .map(|p| {
15568 serde_json::json!({
15569 "id": p.id.get().copied(),
15570 "title": p.title,
15571 "slug": p.slug,
15572 "url_path": p.url_path,
15573 "depth": p.depth,
15574 "parent_id": p.parent_id,
15575 "status": p.status,
15576 })
15577 })
15578 .collect();
15579
15580 let body = serde_json::json!({ "items": items });
15581 Ok((
15582 [(header::CONTENT_TYPE, "application/json")],
15583 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15584 )
15585 .into_response())
15586}
15587
15588#[derive(Debug, Deserialize)]
15592pub struct SnippetChooserQuery {
15593 #[serde(default)]
15594 pub q: Option<String>,
15595 #[serde(default)]
15596 pub type_name: Option<String>,
15597 #[serde(default)]
15601 pub ids: Option<String>,
15602}
15603
15604pub async fn snippet_chooser_json(
15609 State(_state): State<super::AdminState>,
15610 tenant: Tenant,
15611 Query(q): Query<SnippetChooserQuery>,
15612) -> Result<Response, AdminError> {
15613 let needle =
15614 q.q.as_deref()
15615 .map(str::trim)
15616 .filter(|s| !s.is_empty())
15617 .map(str::to_lowercase);
15618 let type_filter = q
15619 .type_name
15620 .as_deref()
15621 .map(str::trim)
15622 .filter(|s| !s.is_empty())
15623 .map(str::to_owned);
15624
15625 let mut snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
15626 .order_by(&[("updated_at", true)])
15627 .fetch(tenant.pool())
15628 .await
15629 .unwrap_or_default();
15630
15631 if let Some(ids) = q.ids.as_deref() {
15632 let id_set: std::collections::HashSet<i64> = ids
15633 .split(',')
15634 .filter_map(|t| t.trim().parse::<i64>().ok())
15635 .collect();
15636 snippets.retain(|s| s.id.get().copied().is_some_and(|id| id_set.contains(&id)));
15637 }
15638 if let Some(tn) = type_filter.as_ref() {
15639 snippets.retain(|s| &s.type_name == tn);
15640 }
15641 if let Some(n) = needle.as_ref() {
15642 snippets
15643 .retain(|s| s.title.to_lowercase().contains(n) || s.slug.to_lowercase().contains(n));
15644 }
15645
15646 let items: Vec<serde_json::Value> = snippets
15647 .iter()
15648 .take(50)
15649 .map(|s| {
15650 serde_json::json!({
15651 "id": s.id.get().copied(),
15652 "title": s.title,
15653 "slug": s.slug,
15654 "type_name": s.type_name,
15655 })
15656 })
15657 .collect();
15658
15659 let body = serde_json::json!({ "items": items });
15660 Ok((
15661 [(header::CONTENT_TYPE, "application/json")],
15662 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15663 )
15664 .into_response())
15665}
15666
15667#[derive(Debug, Deserialize)]
15669pub struct DocumentChooserQuery {
15670 #[serde(default)]
15671 pub q: Option<String>,
15672}
15673
15674pub async fn document_chooser_json(
15679 State(_state): State<super::AdminState>,
15680 tenant: Tenant,
15681 Query(q): Query<DocumentChooserQuery>,
15682) -> Result<Response, AdminError> {
15683 let needle =
15684 q.q.as_deref()
15685 .map(str::trim)
15686 .filter(|s| !s.is_empty())
15687 .map(str::to_lowercase);
15688
15689 let mut rows: Vec<Media> = Media::objects()
15690 .where_(Media::kind.eq("document".to_owned()))
15691 .order_by(&[("uploaded_at", true)])
15692 .fetch(tenant.pool())
15693 .await
15694 .unwrap_or_default();
15695
15696 if let Some(n) = needle.as_ref() {
15697 rows.retain(|m| {
15698 m.title.to_lowercase().contains(n) || m.filename.to_lowercase().contains(n)
15699 });
15700 }
15701
15702 let items: Vec<serde_json::Value> = rows
15703 .iter()
15704 .take(50)
15705 .map(|m| {
15706 serde_json::json!({
15707 "id": m.id.get().copied(),
15708 "title": m.title,
15709 "filename": m.filename,
15710 "kind": m.kind,
15711 "mime": m.mime,
15712 })
15713 })
15714 .collect();
15715
15716 let body = serde_json::json!({ "items": items });
15717 Ok((
15718 [(header::CONTENT_TYPE, "application/json")],
15719 serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15720 )
15721 .into_response())
15722}
15723
15724pub async fn admin_search(
15729 State(state): State<super::AdminState>,
15730 tenant: Tenant,
15731 headers: HeaderMap,
15732 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15733 Query(q): Query<AdminSearchQuery>,
15734) -> Result<Response, AdminError> {
15735 let needle =
15736 q.q.as_deref()
15737 .map(str::trim)
15738 .filter(|s| !s.is_empty())
15739 .map(str::to_lowercase);
15740 let autocomplete = q.autocomplete.as_deref() == Some("1");
15741
15742 if !autocomplete {
15746 if let Some(raw) = q.q.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
15747 if let Err(e) = crate::search_promotion::log_query(tenant.pool(), raw).await {
15748 tracing::debug!(
15749 target: "rustango_cms::search",
15750 error = %e,
15751 "search query log failed (best-effort)",
15752 );
15753 }
15754 }
15755 }
15756
15757 let mut pages_out: Vec<serde_json::Value> = Vec::new();
15758 let mut snippets_out: Vec<serde_json::Value> = Vec::new();
15759 let mut media_out: Vec<serde_json::Value> = Vec::new();
15760
15761 if let Some(needle) = needle.as_ref() {
15762 let all_pages: Vec<Page> = Page::objects()
15768 .order_by(&[("updated_at", true)])
15769 .fetch(tenant.pool())
15770 .await
15771 .unwrap_or_default();
15772 let page_types: Vec<PageType> = PageType::objects()
15773 .fetch(tenant.pool())
15774 .await
15775 .unwrap_or_default();
15776 let page_type_by_id: std::collections::HashMap<i64, String> = page_types
15777 .into_iter()
15778 .filter_map(|pt| pt.id.get().copied().map(|id| (id, pt.type_name)))
15779 .collect();
15780 let mut title_hits: Vec<serde_json::Value> = Vec::new();
15781 let mut body_hits: Vec<serde_json::Value> = Vec::new();
15782 for p in all_pages {
15783 if title_hits.len() + body_hits.len() >= 20 {
15784 break;
15785 }
15786 let title = p.title.to_lowercase();
15787 let slug = p.slug.to_lowercase();
15788 let url_path = p.url_path.to_lowercase();
15789 let primary_hit =
15790 title.contains(needle) || slug.contains(needle) || url_path.contains(needle);
15791
15792 let mut body_match = false;
15794 if !primary_hit {
15795 if p.seo_title.to_lowercase().contains(needle)
15796 || p.seo_description.to_lowercase().contains(needle)
15797 || p.og_title.to_lowercase().contains(needle)
15798 || p.og_description.to_lowercase().contains(needle)
15799 {
15800 body_match = true;
15801 }
15802 if !body_match {
15803 if let Some(type_name) = page_type_by_id.get(&p.page_type_id) {
15804 if let Some(handler) = crate::page_type::find_handler(type_name) {
15805 let page_id = p.id.get().copied().unwrap_or_default();
15806 if let Ok(ext) = handler.load_extension(tenant.pool(), page_id).await {
15807 body_match = json_contains_needle(&ext, needle);
15808 }
15809 }
15810 }
15811 }
15812 }
15813
15814 if primary_hit || body_match {
15815 let row = serde_json::json!({
15816 "id": p.id.get().copied(),
15817 "title": p.title,
15818 "slug": p.slug,
15819 "url_path": p.url_path,
15820 "status": p.status,
15821 });
15822 if primary_hit {
15823 title_hits.push(row);
15824 } else {
15825 body_hits.push(row);
15826 }
15827 }
15828 }
15829 pages_out.extend(title_hits);
15831 pages_out.extend(body_hits);
15832 if pages_out.len() > 20 {
15833 pages_out.truncate(20);
15834 }
15835
15836 let all_snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
15838 .order_by(&[("updated_at", true)])
15839 .fetch(tenant.pool())
15840 .await
15841 .unwrap_or_default();
15842 for s in all_snippets {
15843 if snippets_out.len() >= 20 {
15844 break;
15845 }
15846 let title = s.title.to_lowercase();
15847 let slug = s.slug.to_lowercase();
15848 if title.contains(needle) || slug.contains(needle) {
15849 snippets_out.push(serde_json::json!({
15850 "id": s.id.get().copied(),
15851 "title": s.title,
15852 "slug": s.slug,
15853 "type_name": s.type_name,
15854 }));
15855 }
15856 }
15857
15858 let all_media: Vec<crate::media::Media> = crate::media::Media::objects()
15860 .order_by(&[("created_at", true)])
15861 .fetch(tenant.pool())
15862 .await
15863 .unwrap_or_default();
15864 for m in all_media {
15865 if media_out.len() >= 20 {
15866 break;
15867 }
15868 let title = m.title.to_lowercase();
15869 let filename = m.filename.to_lowercase();
15870 let alt = m.alt_text.to_lowercase();
15871 if title.contains(needle) || filename.contains(needle) || alt.contains(needle) {
15872 media_out.push(serde_json::json!({
15873 "id": m.id.get().copied(),
15874 "title": m.title,
15875 "filename": m.filename,
15876 "alt_text": m.alt_text,
15877 "kind": m.kind,
15878 }));
15879 }
15880 }
15881 }
15882
15883 let plugin_areas: Vec<serde_json::Value> = if let Some(query) = q.q.as_deref() {
15887 let trimmed = query.trim();
15888 if trimmed.is_empty() {
15889 Vec::new()
15890 } else {
15891 crate::hooks::run_admin_search_areas(trimmed)
15892 .into_iter()
15893 .map(|(label, hits)| {
15894 serde_json::json!({
15895 "label": label,
15896 "hits": hits,
15897 })
15898 })
15899 .collect()
15900 }
15901 } else {
15902 Vec::new()
15903 };
15904
15905 if autocomplete {
15906 let payload = serde_json::json!({
15908 "q": q.q,
15909 "pages": pages_out.iter().take(5).collect::<Vec<_>>(),
15910 "snippets": snippets_out.iter().take(5).collect::<Vec<_>>(),
15911 "media": media_out.iter().take(5).collect::<Vec<_>>(),
15912 "plugin_areas": plugin_areas,
15913 });
15914 return Ok((
15915 [(header::CONTENT_TYPE, "application/json")],
15916 serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
15917 )
15918 .into_response());
15919 }
15920
15921 let mut ctx = Context::new();
15922 add_chrome(&mut ctx, &tenant, "search", session_user.as_ref()).await;
15923 add_admin_theme(&mut ctx, tenant.pool()).await;
15924 ctx.insert("query", &q.q.unwrap_or_default());
15925 ctx.insert("pages", &pages_out);
15926 ctx.insert("snippets", &snippets_out);
15927 ctx.insert("media", &media_out);
15928 let plugin_hit_count: usize = plugin_areas
15929 .iter()
15930 .filter_map(|a| a.get("hits").and_then(|h| h.as_array()).map(Vec::len))
15931 .sum();
15932 ctx.insert("plugin_search_areas", &plugin_areas);
15933 ctx.insert(
15934 "total_hits",
15935 &(pages_out.len() + snippets_out.len() + media_out.len() + plugin_hit_count),
15936 );
15937 render_with_csrf(&state, &headers, "rcms_admin/admin_search.html", &mut ctx)
15938}
15939
15940pub async fn navigation_list(
15946 State(state): State<super::AdminState>,
15947 tenant: Tenant,
15948 headers: HeaderMap,
15949 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15950) -> Result<Response, AdminError> {
15951 let menus: Vec<crate::navigation::Menu> = crate::navigation::Menu::objects()
15952 .order_by(&[("name", false)])
15953 .fetch(tenant.pool())
15954 .await?;
15955 let all_items: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
15957 .fetch(tenant.pool())
15958 .await?;
15959 let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
15960 for it in &all_items {
15961 *counts.entry(it.menu_id).or_insert(0) += 1;
15962 }
15963 let rows: Vec<serde_json::Value> = menus
15964 .iter()
15965 .map(|m| {
15966 let id = m.id.get().copied().unwrap_or_default();
15967 serde_json::json!({
15968 "id": id,
15969 "slug": m.slug,
15970 "name": m.name,
15971 "item_count": counts.get(&id).copied().unwrap_or(0),
15972 "created_at": m.created_at.get().copied(),
15973 })
15974 })
15975 .collect();
15976
15977 let mut ctx = Context::new();
15978 add_chrome(&mut ctx, &tenant, "navigation", session_user.as_ref()).await;
15979 add_admin_theme(&mut ctx, tenant.pool()).await;
15980 ctx.insert("menus", &rows);
15981 render_with_csrf(
15982 &state,
15983 &headers,
15984 "rcms_admin/navigation_list.html",
15985 &mut ctx,
15986 )
15987}
15988
15989#[derive(Debug, Deserialize)]
15991pub struct MenuForm {
15992 pub slug: String,
15993 pub name: String,
15994}
15995
15996pub async fn navigation_create_submit(
15998 State(_state): State<super::AdminState>,
15999 tenant: Tenant,
16000 headers: HeaderMap,
16001 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16002 Form(form): Form<MenuForm>,
16003) -> Result<Response, AdminError> {
16004 let slug = form.slug.trim().to_lowercase();
16005 let name = form.name.trim().to_owned();
16006 if slug.is_empty() || name.is_empty() {
16007 return redirect_named_with_message(
16008 "rcms-admin:navigation:list",
16009 MsgLevel::Warning,
16010 "Menu slug + name are both required.",
16011 &headers,
16012 );
16013 }
16014 let mut row = crate::navigation::Menu {
16015 id: rustango::sql::Auto::Unset,
16016 slug: slug.clone(),
16017 name,
16018 created_at: rustango::sql::Auto::Unset,
16019 };
16020 row.insert_pool(tenant.pool()).await?;
16021 redirect_named_with_message_args(
16022 "rcms-admin:navigation:list",
16023 MsgLevel::Success,
16024 "Menu “{slug}” created.",
16025 &[("slug", slug.as_str())],
16026 &headers,
16027 )
16028}
16029
16030pub async fn navigation_delete_submit(
16033 State(_state): State<super::AdminState>,
16034 tenant: Tenant,
16035 headers: HeaderMap,
16036 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16037 Path(id): Path<i64>,
16038) -> Result<Response, AdminError> {
16039 let menu = crate::navigation::Menu::objects()
16040 .where_(crate::navigation::Menu::id.eq(id))
16041 .first(tenant.pool())
16042 .await?
16043 .ok_or(AdminError::NotFound(id))?;
16044 let items: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16049 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16050 .fetch(tenant.pool())
16051 .await?;
16052 rustango::atomic!(tenant.pool(), |tx| {
16053 let mut guard = tx.lock().await?;
16054 let tx = &mut *guard;
16055 delete_menu_items_tx(tx, items).await?;
16056 menu.delete_tx(tx).await?;
16057 Ok::<_, rustango::sql::ExecError>(())
16058 })
16059 .await?;
16060 redirect_named_with_message(
16061 "rcms-admin:navigation:list",
16062 MsgLevel::Success,
16063 "Menu deleted.",
16064 &headers,
16065 )
16066}
16067
16068pub async fn navigation_clone_submit(
16075 State(_state): State<super::AdminState>,
16076 tenant: Tenant,
16077 headers: HeaderMap,
16078 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16079 Path(id): Path<i64>,
16080) -> Result<Response, AdminError> {
16081 let source = crate::navigation::Menu::objects()
16082 .where_(crate::navigation::Menu::id.eq(id))
16083 .first(tenant.pool())
16084 .await?
16085 .ok_or(AdminError::NotFound(id))?;
16086
16087 let base = source.slug.trim_matches('-').to_owned();
16089 let desired = format!("{base}-copy");
16090 let existing_slugs: std::collections::HashSet<String> = crate::navigation::Menu::objects()
16091 .fetch(tenant.pool())
16092 .await?
16093 .into_iter()
16094 .map(|m| m.slug)
16095 .collect();
16096 let slug = if !existing_slugs.contains(&desired) {
16097 desired
16098 } else {
16099 let mut chosen = None;
16100 for n in 2..=100 {
16101 let candidate = format!("{desired}-{n}");
16102 if !existing_slugs.contains(&candidate) {
16103 chosen = Some(candidate);
16104 break;
16105 }
16106 }
16107 chosen.ok_or_else(|| {
16108 AdminError::Validation(
16109 "Could not allocate a unique slug for the cloned menu.".to_owned(),
16110 )
16111 })?
16112 };
16113
16114 let mut clone_menu = crate::navigation::Menu {
16115 id: rustango::sql::Auto::Unset,
16116 slug,
16117 name: format!("{} (copy)", source.name),
16118 created_at: rustango::sql::Auto::Unset,
16119 };
16120 let items = crate::navigation::order_pre_order(
16130 crate::navigation::MenuItem::objects()
16131 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16132 .order_by(&[("sort_order", false), ("id", false)])
16133 .fetch(tenant.pool())
16134 .await?,
16135 );
16136 let count = items.len().to_string();
16137
16138 let new_menu_id = rustango::atomic!(tenant.pool(), |tx| {
16141 let mut guard = tx.lock().await?;
16142 let tx = &mut *guard;
16143 clone_menu.save_tx(tx).await?;
16144 let new_menu_id = clone_menu.id.get().copied().unwrap_or_default();
16145
16146 let mut id_map: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
16147 for item in &items {
16148 let old_id = item.id.get().copied().unwrap_or_default();
16149 let new_parent = item.parent_id.and_then(|p| id_map.get(&p).copied());
16155 let mut clone_item = crate::navigation::MenuItem {
16156 id: rustango::sql::Auto::Unset,
16157 menu_id: new_menu_id,
16158 parent_id: new_parent,
16159 sort_order: item.sort_order,
16160 label: item.label.clone(),
16161 page_id: item.page_id,
16162 external_url: item.external_url.clone(),
16163 open_in_new_tab: item.open_in_new_tab,
16164 };
16165 clone_item.save_tx(tx).await?;
16166 id_map.insert(old_id, clone_item.id.get().copied().unwrap_or_default());
16167 }
16168 Ok::<_, rustango::sql::ExecError>(new_menu_id)
16169 })
16170 .await?;
16171
16172 redirect_named_with_params_and_message_args(
16173 "rcms-admin:navigation:edit",
16174 &[("id", new_menu_id.to_string())],
16175 MsgLevel::Success,
16176 "Cloned “{name}” with {count} items.",
16177 &[("name", source.name.as_str()), ("count", count.as_str())],
16178 &headers,
16179 )
16180}
16181
16182pub async fn navigation_seed_from_pages_submit(
16196 State(_state): State<super::AdminState>,
16197 tenant: Tenant,
16198 headers: HeaderMap,
16199 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16200 Path(id): Path<i64>,
16201) -> Result<Response, AdminError> {
16202 use rustango::core::Column as _;
16203 use rustango::sql::FetcherPool as _;
16204
16205 let menu = crate::navigation::Menu::objects()
16206 .where_(crate::navigation::Menu::id.eq(id))
16207 .first(tenant.pool())
16208 .await?
16209 .ok_or(AdminError::NotFound(id))?;
16210
16211 let existing: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16217 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16218 .fetch(tenant.pool())
16219 .await?;
16220
16221 let mut pages: Vec<crate::page::Page> = crate::page::Page::objects()
16226 .where_(crate::page::Page::show_in_menus.eq(true))
16227 .where_(crate::page::Page::status.eq("published".to_owned()))
16228 .order_by(&[("path", false), ("id", false)])
16229 .fetch(tenant.pool())
16230 .await?;
16231 let error_tid = crate::error_pages::error_page_type_id(tenant.pool()).await;
16235 pages.retain(|p| error_tid.is_none_or(|tid| p.page_type_id != tid));
16236
16237 let mut page_to_item: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
16242 let mut sibling_counter: std::collections::HashMap<Option<i64>, i32> =
16243 std::collections::HashMap::new();
16244 let inserted = pages.len();
16248 rustango::atomic!(tenant.pool(), |tx| {
16249 let mut guard = tx.lock().await?;
16250 let tx = &mut *guard;
16251 delete_menu_items_tx(tx, existing).await?;
16252 for page in &pages {
16253 let page_id = page.id.get().copied().unwrap_or_default();
16254 let parent_menu_item_id: Option<i64> = page
16255 .parent_id
16256 .and_then(|pid| page_to_item.get(&pid).copied());
16257 let bucket = parent_menu_item_id;
16261 let sort_order = *sibling_counter
16262 .entry(bucket)
16263 .and_modify(|n| *n += 1)
16264 .or_insert(0);
16265 let mut item = crate::navigation::MenuItem {
16266 id: rustango::sql::Auto::Unset,
16267 menu_id: id,
16268 parent_id: parent_menu_item_id,
16269 sort_order,
16270 label: page.title.clone(),
16271 page_id: Some(page_id),
16272 external_url: None,
16273 open_in_new_tab: false,
16274 };
16275 item.save_tx(tx).await?;
16276 let new_item_id = item.id.get().copied().unwrap_or_default();
16277 page_to_item.insert(page_id, new_item_id);
16278 }
16279 Ok::<_, rustango::sql::ExecError>(())
16280 })
16281 .await?;
16282
16283 redirect_named_with_params_and_message_plural(
16284 "rcms-admin:navigation:edit",
16285 &[("id", id.to_string())],
16286 MsgLevel::Success,
16287 "Seeded “{name}” with {count} item(s) from pages marked Show in menus.",
16288 inserted as i64,
16289 &[
16290 ("name", menu.name.as_str()),
16291 ("count", &inserted.to_string()),
16292 ],
16293 &headers,
16294 )
16295}
16296
16297async fn delete_menu_items_tx(
16306 tx: &mut rustango::sql::PoolTx<'_>,
16307 items: Vec<crate::navigation::MenuItem>,
16308) -> Result<(), rustango::sql::ExecError> {
16309 use crate::menu_item_translation::MenuItemTranslation;
16310 if items.is_empty() {
16311 return Ok(());
16312 }
16313 let ids: Vec<i64> = items.iter().filter_map(|it| it.id.get().copied()).collect();
16314 if !ids.is_empty() {
16315 let orphans: Vec<MenuItemTranslation> = MenuItemTranslation::objects()
16316 .where_(MenuItemTranslation::item_id.is_in(ids))
16317 .fetch_tx(tx)
16318 .await?;
16319 for row in orphans {
16320 row.delete_tx(tx).await?;
16321 }
16322 }
16323 for it in crate::navigation::order_deepest_first(items) {
16324 it.delete_tx(tx).await?;
16325 }
16326 Ok(())
16327}
16328
16329#[derive(Debug, Deserialize)]
16350pub struct SaveTreeItem {
16351 #[serde(default)]
16356 pub id: Option<i64>,
16357 pub local_id: i32,
16359 #[serde(default)]
16361 pub parent_local_id: Option<i32>,
16362 pub label: String,
16363 #[serde(default)]
16364 pub page_id: Option<i64>,
16365 #[serde(default)]
16366 pub external_url: Option<String>,
16367 #[serde(default)]
16368 pub open_in_new_tab: bool,
16369}
16370
16371#[derive(Debug, Deserialize)]
16372pub struct SaveTreePayload {
16373 pub items: Vec<SaveTreeItem>,
16374}
16375
16376pub async fn navigation_save_tree_submit(
16377 State(_state): State<super::AdminState>,
16378 tenant: Tenant,
16379 Path(id): Path<i64>,
16380 axum::Json(payload): axum::Json<SaveTreePayload>,
16381) -> Result<Response, AdminError> {
16382 for (i, item) in payload.items.iter().enumerate() {
16385 if item.local_id as usize != i {
16386 return Err(AdminError::Validation(format!(
16387 "items[{i}].local_id must equal its array index"
16388 )));
16389 }
16390 if let Some(p) = item.parent_local_id {
16391 if (p as usize) >= i {
16392 return Err(AdminError::Validation(format!(
16393 "items[{i}].parent_local_id {p} must reference an earlier item"
16394 )));
16395 }
16396 }
16397 }
16398
16399 for (i, item) in payload.items.iter().enumerate() {
16407 let external = item
16408 .external_url
16409 .as_deref()
16410 .map(str::trim)
16411 .filter(|s| !s.is_empty());
16412 match (item.page_id, external) {
16413 (Some(_), Some(_)) => {
16414 return Err(AdminError::Validation(format!(
16415 "items[{i}] sets both a page and an external URL — pick one"
16416 )))
16417 }
16418 (None, None) => {
16419 return Err(AdminError::Validation(format!(
16420 "items[{i}] has no link target — set a page or an external URL"
16421 )))
16422 }
16423 _ => {}
16424 }
16425 if item.label.chars().count() > 200 {
16426 return Err(AdminError::Validation(format!(
16427 "items[{i}].label is too long (max 200 characters)"
16428 )));
16429 }
16430 if external.is_some_and(|u| u.chars().count() > 500) {
16431 return Err(AdminError::Validation(format!(
16432 "items[{i}].external_url is too long (max 500 characters)"
16433 )));
16434 }
16435 }
16436
16437 let mut seen: std::collections::HashSet<i64> = std::collections::HashSet::new();
16441 for (i, item) in payload.items.iter().enumerate() {
16442 if let Some(iid) = item.id {
16443 if !seen.insert(iid) {
16444 return Err(AdminError::Validation(format!(
16445 "items[{i}].id {iid} appears more than once"
16446 )));
16447 }
16448 }
16449 }
16450
16451 if crate::navigation::Menu::objects()
16456 .where_(crate::navigation::Menu::id.eq(id))
16457 .first(tenant.pool())
16458 .await?
16459 .is_none()
16460 {
16461 return Err(AdminError::NotFound(id));
16462 }
16463
16464 let existing: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16465 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16466 .fetch(tenant.pool())
16467 .await?;
16468 let mut existing_by_id: std::collections::HashMap<i64, crate::navigation::MenuItem> = existing
16469 .into_iter()
16470 .filter_map(|it| it.id.get().copied().map(|iid| (iid, it)))
16471 .collect();
16472
16473 let plan: Vec<Option<crate::navigation::MenuItem>> = payload
16479 .items
16480 .iter()
16481 .map(|it| it.id.and_then(|iid| existing_by_id.remove(&iid)))
16482 .collect();
16483
16484 let items_saved = payload.items.len();
16485 rustango::atomic!(tenant.pool(), |tx| {
16486 let mut guard = tx.lock().await?;
16487 let tx = &mut *guard;
16488 let mut resolved: Vec<i64> = Vec::with_capacity(payload.items.len());
16495 for ((i, item), claimed) in payload.items.iter().enumerate().zip(plan) {
16496 let parent_id = item.parent_local_id.map(|p| resolved[p as usize]);
16497 let external_url = item
16498 .external_url
16499 .as_ref()
16500 .filter(|s| !s.trim().is_empty())
16501 .cloned();
16502 let sort_order = (i as i32) * 10;
16503
16504 let new_id = match claimed {
16505 Some(mut row) => {
16506 let iid = row.id.get().copied().unwrap_or_default();
16509 row.parent_id = parent_id;
16510 row.sort_order = sort_order;
16511 row.label = item.label.clone();
16512 row.page_id = item.page_id;
16513 row.external_url = external_url;
16514 row.open_in_new_tab = item.open_in_new_tab;
16515 row.save_tx(tx).await?;
16516 iid
16517 }
16518 None => {
16519 let mut row = crate::navigation::MenuItem {
16520 id: rustango::sql::Auto::Unset,
16521 menu_id: id,
16522 parent_id,
16523 sort_order,
16524 label: item.label.clone(),
16525 page_id: item.page_id,
16526 external_url,
16527 open_in_new_tab: item.open_in_new_tab,
16528 };
16529 row.save_tx(tx).await?;
16530 row.id.get().copied().unwrap_or_default()
16531 }
16532 };
16533 resolved.push(new_id);
16534 }
16535
16536 delete_menu_items_tx(tx, existing_by_id.into_values().collect()).await?;
16542 Ok::<_, rustango::sql::ExecError>(())
16543 })
16544 .await?;
16545
16546 Ok(axum::Json(serde_json::json!({
16547 "ok": true,
16548 "items_saved": items_saved,
16549 }))
16550 .into_response())
16551}
16552
16553pub async fn navigation_edit_form(
16555 State(state): State<super::AdminState>,
16556 tenant: Tenant,
16557 headers: HeaderMap,
16558 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
16559 Path(id): Path<i64>,
16560 Query(q): Query<EditQuery>,
16561) -> Result<Response, AdminError> {
16562 let menu = crate::navigation::Menu::objects()
16563 .where_(crate::navigation::Menu::id.eq(id))
16564 .first(tenant.pool())
16565 .await?
16566 .ok_or(AdminError::NotFound(id))?;
16567 let items = crate::navigation::order_pre_order(
16572 crate::navigation::MenuItem::objects()
16573 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16574 .order_by(&[("sort_order", false), ("id", false)])
16575 .fetch(tenant.pool())
16576 .await?,
16577 );
16578 let suggested: Vec<Page> = Page::objects()
16582 .where_(Page::show_in_menus.eq(true))
16583 .order_by(&[("title", false)])
16584 .fetch(tenant.pool())
16585 .await?;
16586 let all_pages: Vec<Page> = Page::objects()
16591 .order_by(&[("title", false)])
16592 .fetch(tenant.pool())
16593 .await?;
16594
16595 let by_page_id: std::collections::HashMap<i64, &Page> = all_pages
16598 .iter()
16599 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
16600 .collect();
16601 let locales: Vec<Locale> = Locale::objects()
16607 .where_(Locale::active.eq(true))
16608 .order_by(&[("is_default", true), ("code", false)])
16609 .fetch(tenant.pool())
16610 .await?;
16611 let editing_locale: Option<Locale> = match q.locale.as_deref().filter(|c| !c.is_empty()) {
16612 Some(code) => locales.iter().find(|l| l.code == code).cloned(),
16613 None => None,
16614 };
16615 let translation_mode = editing_locale.as_ref().is_some_and(|l| !l.is_default);
16616 let item_translations = match editing_locale.as_ref().filter(|l| !l.is_default) {
16617 Some(loc) => {
16618 let lid = loc.id.get().copied().unwrap_or_default();
16619 let ids: Vec<i64> = items.iter().filter_map(|it| it.id.get().copied()).collect();
16620 crate::menu_item_translation::fetch_for_items(tenant.pool(), &ids, lid).await?
16621 }
16622 None => std::collections::HashMap::new(),
16623 };
16624
16625 let item_rows: Vec<serde_json::Value> = items
16626 .iter()
16627 .map(|it| {
16628 let resolved_label = if it.label.trim().is_empty() {
16629 it.page_id
16630 .and_then(|pid| by_page_id.get(&pid).map(|p| p.title.clone()))
16631 .unwrap_or_default()
16632 } else {
16633 it.label.clone()
16634 };
16635 let resolved_url = match (it.page_id, it.external_url.clone()) {
16636 (Some(pid), _) => by_page_id
16637 .get(&pid)
16638 .map(|p| p.url_path.clone())
16639 .unwrap_or_else(|| "—".to_owned()),
16640 (None, Some(url)) => url,
16641 _ => "—".to_owned(),
16642 };
16643 let tr = it
16644 .id
16645 .get()
16646 .and_then(|iid| item_translations.get(iid));
16647 serde_json::json!({
16648 "id": it.id.get().copied(),
16649 "label": it.label,
16650 "resolved_label": resolved_label,
16651 "page_id": it.page_id,
16652 "external_url": it.external_url,
16653 "parent_id": it.parent_id,
16654 "sort_order": it.sort_order,
16655 "open_in_new_tab": it.open_in_new_tab,
16656 "resolved_url": resolved_url,
16657 "tr_label": tr.and_then(|m| m.get("label")).cloned().unwrap_or_default(),
16658 "tr_external_url": tr
16659 .and_then(|m| m.get("external_url"))
16660 .cloned()
16661 .unwrap_or_default(),
16662 })
16663 })
16664 .collect();
16665
16666 let error_tid = crate::error_pages::error_page_type_id(tenant.pool()).await;
16668 let linkable = |p: &&Page| error_tid.map_or(true, |tid| p.page_type_id != tid);
16669 let picker_pages: Vec<serde_json::Value> = all_pages
16670 .iter()
16671 .filter(linkable)
16672 .map(|p| {
16673 serde_json::json!({
16674 "id": p.id.get().copied(),
16675 "title": p.title,
16676 "url_path": p.url_path,
16677 })
16678 })
16679 .collect();
16680
16681 let recent_pages_raw: Vec<Page> = Page::objects()
16687 .order_by(&[("updated_at", true)])
16688 .fetch(tenant.pool())
16689 .await?;
16690 let picker_recent: Vec<serde_json::Value> = recent_pages_raw
16691 .iter()
16692 .filter(linkable)
16693 .take(20)
16694 .map(|p| {
16695 serde_json::json!({
16696 "id": p.id.get().copied(),
16697 "title": p.title,
16698 "url_path": p.url_path,
16699 "updated_at": p.updated_at,
16700 })
16701 })
16702 .collect();
16703
16704 let mut picker_library: Vec<serde_json::Value> = Vec::new();
16711 for handler in crate::library::registered_handlers() {
16712 let entries = handler
16713 .menu_picker_entries(tenant.pool())
16714 .await
16715 .map_err(|e| {
16716 AdminError::Validation(format!(
16717 "library `{}::menu_picker_entries` failed: {e}",
16718 handler.type_name()
16719 ))
16720 })?;
16721 for entry in entries {
16722 picker_library.push(serde_json::json!({
16723 "label": entry.label,
16724 "url": entry.url,
16725 "kind_hint": entry.kind_hint,
16726 "library_type": handler.verbose_name(),
16727 }));
16728 }
16729 }
16730
16731 let mut ctx = Context::new();
16732 add_chrome(&mut ctx, &tenant, "navigation", session_user.as_ref()).await;
16733 add_admin_theme(&mut ctx, tenant.pool()).await;
16734 ctx.insert("menu_id", &menu.id.get().copied());
16735 ctx.insert("menu_slug", &menu.slug);
16736 ctx.insert("menu_name", &menu.name);
16737 ctx.insert("items", &item_rows);
16738 ctx.insert("picker_pages", &picker_pages);
16739 ctx.insert("picker_recent", &picker_recent);
16740 ctx.insert("picker_library", &picker_library);
16741 ctx.insert("has_library_picker", &!picker_library.is_empty());
16742 ctx.insert("has_curated_picker", &!suggested.is_empty());
16743 ctx.insert("locales", &locales);
16744 ctx.insert("editing_locale", &editing_locale);
16745 ctx.insert("translation_mode", &translation_mode);
16746 render_with_csrf(
16747 &state,
16748 &headers,
16749 "rcms_admin/navigation_edit.html",
16750 &mut ctx,
16751 )
16752}
16753
16754pub async fn navigation_translate_submit(
16766 State(_state): State<super::AdminState>,
16767 tenant: Tenant,
16768 Path(id): Path<i64>,
16769 Query(q): Query<EditQuery>,
16770 Form(form): Form<std::collections::HashMap<String, String>>,
16771) -> Result<Response, AdminError> {
16772 use crate::menu_item_translation::MenuItemTranslation;
16773
16774 let code = q
16775 .locale
16776 .as_deref()
16777 .filter(|c| !c.is_empty())
16778 .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
16779 let locale = Locale::objects()
16780 .where_(Locale::code.eq(code.to_owned()))
16781 .where_(Locale::active.eq(true))
16782 .first(tenant.pool())
16783 .await?
16784 .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
16785 if locale.is_default {
16786 return Ok((
16787 axum::http::StatusCode::BAD_REQUEST,
16788 "cannot translate INTO the default locale; canonical labels live on cms_menu_item",
16789 )
16790 .into_response());
16791 }
16792 let locale_id = locale
16793 .id
16794 .get()
16795 .copied()
16796 .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
16797
16798 let own_items: std::collections::HashSet<i64> = crate::navigation::MenuItem::objects()
16802 .where_(crate::navigation::MenuItem::menu_id.eq(id))
16803 .fetch(tenant.pool())
16804 .await?
16805 .iter()
16806 .filter_map(|it| it.id.get().copied())
16807 .collect();
16808
16809 let mut updates: Vec<(i64, String, String)> = Vec::new();
16810 for (k, v) in &form {
16811 let Some(rest) = k.strip_prefix("tr__") else {
16812 continue;
16813 };
16814 let Some((raw_id, raw_field)) = rest.split_once("__") else {
16815 continue;
16816 };
16817 let Ok(item_id) = raw_id.parse::<i64>() else {
16818 continue;
16819 };
16820 if !own_items.contains(&item_id) {
16821 continue;
16822 }
16823 if let Ok(field) = crate::menu_item_translation::validate_field_path(raw_field) {
16826 updates.push((item_id, field, v.trim().to_owned()));
16827 }
16828 }
16829
16830 rustango::atomic!(tenant.pool(), |tx| {
16831 let mut guard = tx.lock().await?;
16832 let tx = &mut *guard;
16833 for (item_id, field, value) in updates {
16834 let existing: Vec<MenuItemTranslation> = MenuItemTranslation::objects()
16835 .where_(MenuItemTranslation::item_id.eq(item_id))
16836 .where_(MenuItemTranslation::locale_id.eq(locale_id))
16837 .where_(MenuItemTranslation::field_path.eq(field.clone()))
16838 .fetch_tx(tx)
16839 .await?;
16840 if value.is_empty() {
16841 for row in existing {
16842 row.delete_tx(tx).await?;
16843 }
16844 } else if let Some(mut row) = existing.into_iter().next() {
16845 row.value = value;
16846 row.save_tx(tx).await?;
16847 } else {
16848 let mut row = MenuItemTranslation {
16849 id: rustango::sql::Auto::Unset,
16850 item_id,
16851 locale_id,
16852 field_path: field,
16853 value,
16854 updated_at: rustango::sql::Auto::Unset,
16855 };
16856 row.save_tx(tx).await?;
16857 }
16858 }
16859 Ok::<_, rustango::sql::ExecError>(())
16860 })
16861 .await?;
16862
16863 Ok(Redirect::to(&format!(
16864 "/cms-admin/navigation/{id}/edit?locale={code}"
16865 ))
16866 .into_response())
16867}
16868
16869#[derive(Debug, Deserialize)]
16873pub struct MenuItemForm {
16874 pub label: String,
16875 #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
16876 pub page_id: Option<i64>,
16877 #[serde(default)]
16878 pub external_url: Option<String>,
16879 #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
16880 pub parent_id: Option<i64>,
16881 #[serde(default)]
16882 pub sort_order: Option<i32>,
16883 #[serde(default)]
16884 pub open_in_new_tab: Option<String>,
16885}
16886
16887async fn validate_menu_parent(
16896 tenant: &Tenant,
16897 menu_id: i64,
16898 parent_id: Option<i64>,
16899) -> Result<(), AdminError> {
16900 let Some(pid) = parent_id else {
16901 return Ok(());
16902 };
16903 let parent = crate::navigation::MenuItem::objects()
16904 .where_(crate::navigation::MenuItem::id.eq(pid))
16905 .first(tenant.pool())
16906 .await?;
16907 match parent {
16908 Some(p) if p.menu_id == menu_id => Ok(()),
16909 Some(_) => Err(AdminError::Validation(
16910 "That parent item belongs to a different menu.".to_owned(),
16911 )),
16912 None => Err(AdminError::Validation(
16913 "That parent item no longer exists.".to_owned(),
16914 )),
16915 }
16916}
16917
16918impl MenuItemForm {
16919 fn parsed_external_url(&self) -> Option<String> {
16920 self.external_url
16921 .as_deref()
16922 .map(str::trim)
16923 .filter(|s| !s.is_empty())
16924 .map(str::to_owned)
16925 }
16926}
16927
16928pub async fn navigation_item_create(
16930 State(_state): State<super::AdminState>,
16931 tenant: Tenant,
16932 headers: HeaderMap,
16933 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16934 Path(menu_id): Path<i64>,
16935 Form(form): Form<MenuItemForm>,
16936) -> Result<Response, AdminError> {
16937 let external = form.parsed_external_url();
16938 if form.page_id.is_some() == external.is_some() {
16941 return redirect_named_with_params_and_message(
16942 "rcms-admin:navigation:edit",
16943 &[("id", menu_id.to_string())],
16944 MsgLevel::Warning,
16945 "Pick exactly one of: a page link, or a custom URL.",
16946 &headers,
16947 );
16948 }
16949 validate_menu_parent(&tenant, menu_id, form.parent_id).await?;
16951 let mut row = crate::navigation::MenuItem {
16952 id: rustango::sql::Auto::Unset,
16953 menu_id,
16954 parent_id: form.parent_id,
16955 sort_order: form.sort_order.unwrap_or(100),
16956 label: form.label.trim().to_owned(),
16957 page_id: form.page_id,
16958 external_url: external,
16959 open_in_new_tab: form.open_in_new_tab.is_some(),
16960 };
16961 row.insert_pool(tenant.pool()).await?;
16962 redirect_named_with_params_and_message(
16963 "rcms-admin:navigation:edit",
16964 &[("id", menu_id.to_string())],
16965 MsgLevel::Success,
16966 "Item added.",
16967 &headers,
16968 )
16969}
16970
16971pub async fn navigation_item_delete(
16973 State(_state): State<super::AdminState>,
16974 tenant: Tenant,
16975 headers: HeaderMap,
16976 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16977 Path((menu_id, id)): Path<(i64, i64)>,
16978) -> Result<Response, AdminError> {
16979 let row = crate::navigation::MenuItem::objects()
16980 .where_(crate::navigation::MenuItem::id.eq(id))
16981 .where_(crate::navigation::MenuItem::menu_id.eq(menu_id))
16982 .first(tenant.pool())
16983 .await?
16984 .ok_or(AdminError::NotFound(id))?;
16985 let children: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16988 .where_(crate::navigation::MenuItem::parent_id.eq(Some(id)))
16989 .fetch(tenant.pool())
16990 .await?;
16991 for mut c in children {
16992 c.parent_id = row.parent_id;
16993 c.save_pool(tenant.pool()).await?;
16994 }
16995 row.delete_pool(tenant.pool()).await?;
16996 redirect_named_with_params_and_message(
16997 "rcms-admin:navigation:edit",
16998 &[("id", menu_id.to_string())],
16999 MsgLevel::Success,
17000 "Item deleted.",
17001 &headers,
17002 )
17003}
17004
17005pub async fn page_types_dashboard(
17014 State(state): State<super::AdminState>,
17015 tenant: Tenant,
17016 headers: HeaderMap,
17017 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17018) -> Result<Response, AdminError> {
17019 let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
17023 let page_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
17024
17025 let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17026 let mut latest: std::collections::HashMap<i64, chrono::DateTime<chrono::Utc>> =
17027 std::collections::HashMap::new();
17028 for p in &pages {
17029 *counts.entry(p.page_type_id).or_insert(0) += 1;
17030 if let Some(when) = p.published_at.or_else(|| p.created_at.get().copied()) {
17031 latest
17032 .entry(p.page_type_id)
17033 .and_modify(|cur| {
17034 if when > *cur {
17035 *cur = when;
17036 }
17037 })
17038 .or_insert(when);
17039 }
17040 }
17041
17042 let type_id_by_name: std::collections::HashMap<&str, i64> = page_types
17043 .iter()
17044 .filter_map(|t| t.id.get().copied().map(|id| (t.type_name.as_str(), id)))
17045 .collect();
17046
17047 let mut handler_names = std::collections::BTreeSet::new();
17052 let mut rows: Vec<serde_json::Value> = Vec::new();
17053 for handler in crate::page_type::registered_handlers() {
17054 let name = handler.type_name().to_owned();
17055 handler_names.insert(name.clone());
17056 let row_id = type_id_by_name.get(name.as_str()).copied();
17057 let count = row_id.and_then(|id| counts.get(&id).copied()).unwrap_or(0);
17058 let last = row_id.and_then(|id| latest.get(&id).copied());
17059 rows.push(serde_json::json!({
17060 "type_name": name,
17061 "verbose_name": handler.verbose_name(),
17062 "app_label": handler.app_label(),
17063 "icon": handler.icon(),
17064 "description": handler.description(),
17065 "default_template": handler.default_template(),
17066 "feed_kind": handler.feed_kind(),
17067 "allowed_parents": handler.allowed_parent_types(),
17068 "allowed_children": handler.allowed_child_types(),
17069 "is_creatable": handler.is_creatable(),
17070 "count": count,
17071 "latest": last,
17072 "registered": true,
17073 "row_id": row_id,
17074 }));
17075 }
17076
17077 for t in &page_types {
17084 if !handler_names.contains(&t.type_name) {
17085 let id = t.id.get().copied().unwrap_or_default();
17086 let count = counts.get(&id).copied().unwrap_or(0);
17087 let ui_type = t.app_label == "cms_ui";
17088 rows.push(serde_json::json!({
17089 "type_name": t.type_name,
17090 "verbose_name": t.verbose_name,
17091 "app_label": t.app_label,
17092 "icon": if ui_type { serde_json::Value::String("dashboard_customize".to_owned()) } else { serde_json::Value::Null },
17093 "description": serde_json::Value::Null,
17094 "default_template": t.default_template,
17095 "feed_kind": serde_json::Value::Null,
17096 "allowed_parents": t.allowed_parent_types.clone(),
17097 "allowed_children": t.allowed_child_types.clone(),
17098 "is_creatable": ui_type && t.is_creatable,
17099 "count": count,
17100 "latest": latest.get(&id).copied(),
17101 "registered": false,
17102 "row_id": id,
17103 "ui_type": ui_type,
17104 "deletable": ui_type && count == 0,
17105 }));
17106 }
17107 }
17108 rows.sort_by(|a, b| {
17110 let ac = a.get("count").and_then(|v| v.as_i64()).unwrap_or(0);
17111 let bc = b.get("count").and_then(|v| v.as_i64()).unwrap_or(0);
17112 bc.cmp(&ac).then_with(|| {
17113 a.get("verbose_name")
17114 .and_then(|v| v.as_str())
17115 .unwrap_or("")
17116 .cmp(b.get("verbose_name").and_then(|v| v.as_str()).unwrap_or(""))
17117 })
17118 });
17119
17120 let mut ctx = Context::new();
17121 add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
17122 add_admin_theme(&mut ctx, tenant.pool()).await;
17123 ctx.insert("rows", &rows);
17124 ctx.insert("total_pages", &pages.len());
17125 ctx.insert("total_types", &rows.len());
17126 let can_build = session_user.as_ref().is_some_and(|u| u.is_superuser)
17129 || crate::permissions::user_codenames(
17130 tenant.pool(),
17131 session_user
17132 .as_ref()
17133 .and_then(|u| u.id.get().copied())
17134 .unwrap_or_default(),
17135 )
17136 .await
17137 .unwrap_or_default()
17138 .contains("cms_page_type.build");
17139 ctx.insert("can_build_types", &can_build);
17140 ctx.insert("new_type_url", "/cms-admin/page-types/new");
17141 render_with_csrf(&state, &headers, "rcms_admin/page_types.html", &mut ctx)
17142}
17143
17144fn require_superuser_for_user_admin(
17171 user: Option<&rustango::tenancy::auth::User>,
17172) -> Option<Response> {
17173 use axum::response::{IntoResponse, Redirect};
17174 user_admin_denial_target(user.map(|u| u.is_superuser))
17175 .map(|path| Redirect::to(path).into_response())
17176}
17177
17178fn user_admin_denial_target(is_superuser: Option<bool>) -> Option<&'static str> {
17185 match is_superuser {
17186 Some(true) => None,
17187 Some(false) => Some("/cms-admin/no-access"),
17188 None => Some("/login"),
17189 }
17190}
17191
17192pub async fn users_list(
17195 State(state): State<super::AdminState>,
17196 tenant: Tenant,
17197 headers: HeaderMap,
17198 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17199) -> Result<Response, AdminError> {
17200 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17201 return Ok(redirect);
17202 }
17203 let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
17204 .order_by(&[("username", false)])
17205 .fetch(tenant.pool())
17206 .await?;
17207 let roles: Vec<rustango::tenancy::permissions::Role> =
17208 rustango::tenancy::permissions::Role::objects()
17209 .fetch(tenant.pool())
17210 .await?;
17211 let user_roles: Vec<rustango::tenancy::permissions::UserRole> =
17212 rustango::tenancy::permissions::UserRole::objects()
17213 .fetch(tenant.pool())
17214 .await?;
17215
17216 let roles_by_id: std::collections::HashMap<i64, &rustango::tenancy::permissions::Role> = roles
17217 .iter()
17218 .filter_map(|r| r.id.get().copied().map(|id| (id, r)))
17219 .collect();
17220 let mut roles_by_user: std::collections::HashMap<i64, Vec<String>> =
17221 std::collections::HashMap::new();
17222 for ur in &user_roles {
17223 if let Some(role) = roles_by_id.get(&ur.role_id) {
17224 roles_by_user
17225 .entry(ur.user_id)
17226 .or_default()
17227 .push(role.name.clone());
17228 }
17229 }
17230
17231 let rows: Vec<serde_json::Value> = users
17232 .iter()
17233 .map(|u| {
17234 let id = u.id.get().copied();
17235 serde_json::json!({
17236 "id": id,
17237 "username": u.username,
17238 "email": user_email(u),
17239 "is_superuser": u.is_superuser,
17240 "active": u.active,
17241 "created_at": u.created_at,
17242 "password_changed_at": u.password_changed_at,
17243 "roles": id.and_then(|i| roles_by_user.get(&i).cloned()).unwrap_or_default(),
17244 })
17245 })
17246 .collect();
17247
17248 let mut ctx = Context::new();
17249 add_chrome(&mut ctx, &tenant, "users", session_user.as_ref()).await;
17250 add_admin_theme(&mut ctx, tenant.pool()).await;
17251 ctx.insert("users", &rows);
17252 ctx.insert("total_users", &users.len());
17253 ctx.insert("active_users", &users.iter().filter(|u| u.active).count());
17254 render_with_csrf(&state, &headers, "rcms_admin/users_list.html", &mut ctx)
17255}
17256
17257pub async fn roles_list(
17260 State(state): State<super::AdminState>,
17261 tenant: Tenant,
17262 headers: HeaderMap,
17263 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17264) -> Result<Response, AdminError> {
17265 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17267 return Ok(redirect);
17268 }
17269 let roles: Vec<rustango::tenancy::permissions::Role> =
17270 rustango::tenancy::permissions::Role::objects()
17271 .order_by(&[("name", false)])
17272 .fetch(tenant.pool())
17273 .await?;
17274 let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17275 rustango::tenancy::permissions::RolePermission::objects()
17276 .fetch(tenant.pool())
17277 .await?;
17278 let user_roles: Vec<rustango::tenancy::permissions::UserRole> =
17279 rustango::tenancy::permissions::UserRole::objects()
17280 .fetch(tenant.pool())
17281 .await?;
17282
17283 let mut perm_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17284 for p in &perms {
17285 *perm_counts.entry(p.role_id).or_insert(0) += 1;
17286 }
17287 let mut member_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17288 for ur in &user_roles {
17289 *member_counts.entry(ur.role_id).or_insert(0) += 1;
17290 }
17291
17292 let rows: Vec<serde_json::Value> = roles
17293 .iter()
17294 .map(|r| {
17295 let id = r.id.get().copied().unwrap_or_default();
17296 serde_json::json!({
17297 "id": id,
17298 "name": r.name,
17299 "description": r.description,
17300 "perm_count": perm_counts.get(&id).copied().unwrap_or(0),
17301 "member_count": member_counts.get(&id).copied().unwrap_or(0),
17302 })
17303 })
17304 .collect();
17305 let mut ctx = Context::new();
17306 add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17307 add_admin_theme(&mut ctx, tenant.pool()).await;
17308 ctx.insert("roles", &rows);
17309 render_with_csrf(&state, &headers, "rcms_admin/roles_list.html", &mut ctx)
17310}
17311
17312pub async fn permissions_overview(
17318 State(state): State<super::AdminState>,
17319 tenant: Tenant,
17320 headers: HeaderMap,
17321 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17322) -> Result<Response, AdminError> {
17323 let roles: Vec<rustango::tenancy::permissions::Role> =
17324 rustango::tenancy::permissions::Role::objects()
17325 .order_by(&[("name", false)])
17326 .fetch(tenant.pool())
17327 .await?;
17328 let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17329 rustango::tenancy::permissions::RolePermission::objects()
17330 .fetch(tenant.pool())
17331 .await?;
17332 let granted: std::collections::HashSet<(i64, String)> = perms
17333 .iter()
17334 .map(|p| (p.role_id, p.codename.clone()))
17335 .collect();
17336
17337 let role_headers: Vec<serde_json::Value> = roles
17338 .iter()
17339 .map(|r| {
17340 serde_json::json!({
17341 "id": r.id.get().copied().unwrap_or_default(),
17342 "name": r.name,
17343 })
17344 })
17345 .collect();
17346
17347 let sections: Vec<serde_json::Value> = super::resources::grouped()
17349 .into_iter()
17350 .map(|(section, resources)| {
17351 let rows: Vec<serde_json::Value> = resources
17352 .iter()
17353 .map(|res| {
17354 let cells: Vec<serde_json::Value> = roles
17355 .iter()
17356 .map(|r| {
17357 let rid = r.id.get().copied().unwrap_or_default();
17358 let actions = super::resources::granted_actions(res, rid, &granted);
17359 serde_json::json!({
17360 "actions": actions,
17361 "any": !actions.is_empty(),
17362 })
17363 })
17364 .collect();
17365 serde_json::json!({
17366 "label": res.label,
17367 "key": res.key,
17368 "cells": cells,
17369 })
17370 })
17371 .collect();
17372 serde_json::json!({
17373 "label": section.label(),
17374 "rows": rows,
17375 })
17376 })
17377 .collect();
17378
17379 let mut ctx = Context::new();
17380 add_chrome(&mut ctx, &tenant, "permissions", session_user.as_ref()).await;
17381 add_admin_theme(&mut ctx, tenant.pool()).await;
17382 ctx.insert("roles", &role_headers);
17383 ctx.insert("sections", §ions);
17384 ctx.insert("role_count", &role_headers.len());
17385 render_with_csrf(
17386 &state,
17387 &headers,
17388 "rcms_admin/permissions_overview.html",
17389 &mut ctx,
17390 )
17391}
17392
17393pub async fn roles_new_form(
17395 State(state): State<super::AdminState>,
17396 tenant: Tenant,
17397 headers: HeaderMap,
17398 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17399) -> Result<Response, AdminError> {
17400 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17402 return Ok(redirect);
17403 }
17404 let mut ctx = Context::new();
17405 add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17406 add_admin_theme(&mut ctx, tenant.pool()).await;
17407 ctx.insert("mode", "new");
17408 ctx.insert(
17409 "role",
17410 &serde_json::json!({ "id": serde_json::Value::Null, "name": "", "description": "", "permissions": [] }),
17411 );
17412 ctx.insert("matrix", &build_permission_matrix(&[]));
17413 ctx.insert("legacy_codenames", &Vec::<String>::new());
17414 render_with_csrf(&state, &headers, "rcms_admin/role_form.html", &mut ctx)
17415}
17416
17417pub async fn roles_edit_form(
17420 State(state): State<super::AdminState>,
17421 tenant: Tenant,
17422 headers: HeaderMap,
17423 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17424 Path(id): Path<i64>,
17425) -> Result<Response, AdminError> {
17426 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17428 return Ok(redirect);
17429 }
17430 let role = rustango::tenancy::permissions::Role::objects()
17431 .where_(rustango::tenancy::permissions::Role::id.eq(id))
17432 .first(tenant.pool())
17433 .await?
17434 .ok_or(AdminError::NotFound(id))?;
17435 let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17436 rustango::tenancy::permissions::RolePermission::objects()
17437 .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17438 .order_by(&[("codename", false)])
17439 .fetch(tenant.pool())
17440 .await?;
17441 let codenames: Vec<String> = perms.iter().map(|p| p.codename.clone()).collect();
17442 let (_matched, legacy) = split_matrix_codenames(&codenames);
17443 let mut ctx = Context::new();
17444 add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17445 add_admin_theme(&mut ctx, tenant.pool()).await;
17446 ctx.insert("mode", "edit");
17447 ctx.insert(
17448 "role",
17449 &serde_json::json!({
17450 "id": role.id.get().copied(),
17451 "name": role.name,
17452 "description": role.description,
17453 "permissions": codenames,
17454 }),
17455 );
17456 ctx.insert("matrix", &build_permission_matrix(&codenames));
17457 ctx.insert("legacy_codenames", &legacy);
17458 render_with_csrf(&state, &headers, "rcms_admin/role_form.html", &mut ctx)
17459}
17460
17461fn build_permission_matrix(granted: &[String]) -> serde_json::Value {
17471 use super::resources::{codename, grouped};
17472 use crate::permissions::Action;
17473
17474 let granted_set: std::collections::HashSet<&str> = granted.iter().map(String::as_str).collect();
17475
17476 let mut sections = Vec::new();
17477 for (section, rows) in grouped() {
17478 let rows_json: Vec<serde_json::Value> = rows
17479 .iter()
17480 .map(|r| {
17481 let applicable: Vec<&str> = r.actions.iter().map(|a| a.as_str()).collect();
17482 let granted_actions: Vec<&str> = [
17483 Action::Access,
17484 Action::AccessAdmin,
17485 Action::View,
17486 Action::Add,
17487 Action::Edit,
17488 Action::Publish,
17489 Action::Delete,
17490 ]
17491 .iter()
17492 .copied()
17493 .filter(|action| {
17494 r.actions.contains(action)
17495 && granted_set.contains(codename(r, *action).as_str())
17496 })
17497 .map(|a| a.as_str())
17498 .collect();
17499 serde_json::json!({
17500 "key": r.key,
17501 "label": r.label,
17502 "applicable": applicable,
17503 "granted": granted_actions,
17504 })
17505 })
17506 .collect();
17507 sections.push(serde_json::json!({
17508 "section_label": section.label(),
17509 "rows": rows_json,
17510 }));
17511 }
17512 serde_json::Value::Array(sections)
17513}
17514
17515fn split_matrix_codenames(granted: &[String]) -> (Vec<String>, Vec<String>) {
17522 use super::resources::{all_resources, codename};
17523 use crate::permissions::Action;
17524
17525 let known: std::collections::HashSet<String> = all_resources()
17526 .iter()
17527 .flat_map(|r| {
17528 r.actions
17529 .iter()
17530 .copied()
17531 .filter(|a| {
17532 matches!(
17536 a,
17537 Action::View
17538 | Action::Add
17539 | Action::Edit
17540 | Action::Publish
17541 | Action::Delete
17542 | Action::Access
17543 | Action::AccessAdmin
17544 )
17545 })
17546 .map(|a| codename(r, a))
17547 .collect::<Vec<_>>()
17548 })
17549 .collect();
17550 let (matched, legacy): (Vec<String>, Vec<String>) =
17551 granted.iter().cloned().partition(|c| known.contains(c));
17552 (matched, legacy)
17553}
17554
17555fn parse_matrix_form(form: &std::collections::HashMap<String, String>) -> Vec<String> {
17559 use super::resources::{all_resources, codename};
17560 use crate::permissions::Action;
17561
17562 let resources = all_resources();
17563 let resource_by_key: std::collections::HashMap<&str, &super::resources::AdminResource> =
17564 resources.iter().map(|r| (r.key.as_str(), r)).collect();
17565
17566 let mut out = Vec::new();
17567 for (raw_key, value) in form {
17568 let Some(rest) = raw_key.strip_prefix("perm[") else {
17572 continue;
17573 };
17574 let Some((key, rest)) = rest.split_once("][") else {
17575 continue;
17576 };
17577 let Some(action_str) = rest.strip_suffix(']') else {
17578 continue;
17579 };
17580 if value.is_empty() || value == "0" || value.eq_ignore_ascii_case("off") {
17584 continue;
17585 }
17586 let Some(resource) = resource_by_key.get(key) else {
17587 continue;
17588 };
17589 let action = match action_str {
17590 "view" => Action::View,
17591 "add" => Action::Add,
17592 "edit" => Action::Edit,
17593 "publish" => Action::Publish,
17594 "delete" => Action::Delete,
17595 "access" => Action::Access,
17596 "access_admin" => Action::AccessAdmin,
17597 _ => continue,
17598 };
17599 if !resource.actions.contains(&action) {
17600 continue;
17601 }
17602 out.push(codename(resource, action));
17603 }
17604 out.sort();
17605 out.dedup();
17606 out
17607}
17608
17609async fn sync_role_codenames(
17612 pool: &rustango::sql::Pool,
17613 role_id: i64,
17614 new_codenames: &[String],
17615) -> Result<(), AdminError> {
17616 let existing: Vec<rustango::tenancy::permissions::RolePermission> =
17617 rustango::tenancy::permissions::RolePermission::objects()
17618 .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(role_id))
17619 .fetch(pool)
17620 .await?;
17621 let want: std::collections::BTreeSet<&str> = new_codenames.iter().map(String::as_str).collect();
17622 let have: std::collections::BTreeSet<&str> =
17623 existing.iter().map(|p| p.codename.as_str()).collect();
17624 for p in &existing {
17626 if !want.contains(p.codename.as_str()) {
17627 p.clone().delete_pool(pool).await?;
17628 }
17629 }
17630 for codename in new_codenames {
17632 if !have.contains(codename.as_str()) {
17633 let mut row = rustango::tenancy::permissions::RolePermission {
17634 id: rustango::sql::Auto::Unset,
17635 role_id,
17636 codename: codename.clone(),
17637 };
17638 row.insert_pool(pool).await?;
17639 }
17640 }
17641 Ok(())
17642}
17643
17644pub async fn roles_create_submit(
17648 State(_state): State<super::AdminState>,
17649 tenant: Tenant,
17650 headers: HeaderMap,
17651 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17652 Form(form): Form<std::collections::HashMap<String, String>>,
17653) -> Result<Response, AdminError> {
17654 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17656 return Ok(redirect);
17657 }
17658 let name = form.get("name").map(|s| s.trim()).unwrap_or("").to_owned();
17659 if name.is_empty() {
17660 return Err(AdminError::Validation("Role name is required.".to_owned()));
17661 }
17662 let description = form
17663 .get("description")
17664 .map(|s| s.trim())
17665 .unwrap_or("")
17666 .to_owned();
17667 let mut row = rustango::tenancy::permissions::Role {
17668 id: rustango::sql::Auto::Unset,
17669 name: name.clone(),
17670 description,
17671 data: serde_json::Value::Object(serde_json::Map::new()),
17672 };
17673 row.insert_pool(tenant.pool()).await?;
17674 let role_id = row.id.get().copied().unwrap_or_default();
17675 let codenames = parse_matrix_form(&form);
17676 sync_role_codenames(tenant.pool(), role_id, &codenames).await?;
17677 redirect_named_with_message_args(
17678 "rcms-admin:roles",
17679 MsgLevel::Success,
17680 "Role “{name}” created.",
17681 &[("name", name.as_str())],
17682 &headers,
17683 )
17684}
17685
17686pub async fn roles_edit_submit(
17690 State(_state): State<super::AdminState>,
17691 tenant: Tenant,
17692 headers: HeaderMap,
17693 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17694 Path(id): Path<i64>,
17695 Form(form): Form<std::collections::HashMap<String, String>>,
17696) -> Result<Response, AdminError> {
17697 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17699 return Ok(redirect);
17700 }
17701 let mut role = rustango::tenancy::permissions::Role::objects()
17702 .where_(rustango::tenancy::permissions::Role::id.eq(id))
17703 .first(tenant.pool())
17704 .await?
17705 .ok_or(AdminError::NotFound(id))?;
17706 let name = form.get("name").map(|s| s.trim()).unwrap_or("").to_owned();
17707 if name.is_empty() {
17708 return Err(AdminError::Validation("Role name is required.".to_owned()));
17709 }
17710 let description = form
17711 .get("description")
17712 .map(|s| s.trim())
17713 .unwrap_or("")
17714 .to_owned();
17715 role.name = name.clone();
17716 role.description = description;
17717 role.save_pool(tenant.pool()).await?;
17718 let existing: Vec<rustango::tenancy::permissions::RolePermission> =
17722 rustango::tenancy::permissions::RolePermission::objects()
17723 .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17724 .fetch(tenant.pool())
17725 .await?;
17726 let existing_codenames: Vec<String> = existing.into_iter().map(|p| p.codename).collect();
17727 let (_old_matrix, legacy) = split_matrix_codenames(&existing_codenames);
17728 let mut codenames = parse_matrix_form(&form);
17729 codenames.extend(legacy);
17730 codenames.sort();
17731 codenames.dedup();
17732 sync_role_codenames(tenant.pool(), id, &codenames).await?;
17733 redirect_named_with_message_args(
17734 "rcms-admin:roles",
17735 MsgLevel::Success,
17736 "Role “{name}” saved.",
17737 &[("name", name.as_str())],
17738 &headers,
17739 )
17740}
17741
17742pub async fn roles_delete_submit(
17745 State(_state): State<super::AdminState>,
17746 tenant: Tenant,
17747 headers: HeaderMap,
17748 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17749 Path(id): Path<i64>,
17750) -> Result<Response, AdminError> {
17751 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17753 return Ok(redirect);
17754 }
17755 let role = rustango::tenancy::permissions::Role::objects()
17756 .where_(rustango::tenancy::permissions::Role::id.eq(id))
17757 .first(tenant.pool())
17758 .await?
17759 .ok_or(AdminError::NotFound(id))?;
17760 let name = role.name.clone();
17761 for p in rustango::tenancy::permissions::RolePermission::objects()
17763 .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17764 .fetch(tenant.pool())
17765 .await?
17766 {
17767 p.delete_pool(tenant.pool()).await?;
17768 }
17769 for ur in rustango::tenancy::permissions::UserRole::objects()
17770 .where_(rustango::tenancy::permissions::UserRole::role_id.eq(id))
17771 .fetch(tenant.pool())
17772 .await?
17773 {
17774 ur.delete_pool(tenant.pool()).await?;
17775 }
17776 role.delete_pool(tenant.pool()).await?;
17777 redirect_named_with_message_args(
17778 "rcms-admin:roles",
17779 MsgLevel::Success,
17780 "Role “{name}” deleted.",
17781 &[("name", name.as_str())],
17782 &headers,
17783 )
17784}
17785
17786pub async fn users_new_form(
17788 State(state): State<super::AdminState>,
17789 tenant: Tenant,
17790 headers: HeaderMap,
17791 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17792) -> Result<Response, AdminError> {
17793 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17794 return Ok(redirect);
17795 }
17796 let mut ctx = Context::new();
17797 add_chrome(&mut ctx, &tenant, "users", session_user.as_ref()).await;
17798 add_admin_theme(&mut ctx, tenant.pool()).await;
17799 ctx.insert("mode", "new");
17800 ctx.insert(
17801 "user",
17802 &serde_json::json!({
17803 "id": serde_json::Value::Null,
17804 "username": "",
17805 "is_superuser": false,
17806 "active": true,
17807 }),
17808 );
17809 let role_choices: Vec<serde_json::Value> = rustango::tenancy::permissions::Role::objects()
17811 .order_by(&[("name", false)])
17812 .fetch(tenant.pool())
17813 .await?
17814 .iter()
17815 .map(|r| {
17816 serde_json::json!({
17817 "id": r.id.get().copied().unwrap_or_default(),
17818 "name": r.name,
17819 "description": r.description,
17820 "assigned": false,
17821 })
17822 })
17823 .collect();
17824 ctx.insert("role_choices", &role_choices);
17825 render_with_csrf(&state, &headers, "rcms_admin/user_form.html", &mut ctx)
17826}
17827
17828pub async fn users_edit_form(
17833 State(state): State<super::AdminState>,
17834 tenant: Tenant,
17835 headers: HeaderMap,
17836 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17837 Path(id): Path<i64>,
17838) -> Result<Response, AdminError> {
17839 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17840 return Ok(redirect);
17841 }
17842 render_user_edit_page(&state, &tenant, &headers, session_user.as_ref(), id, None).await
17843}
17844
17845async fn render_user_edit_page(
17846 state: &super::AdminState,
17847 tenant: &Tenant,
17848 headers: &HeaderMap,
17849 session_user: Option<&rustango::tenancy::auth::User>,
17850 id: i64,
17851 mcp_one_time: Option<serde_json::Value>,
17852) -> Result<Response, AdminError> {
17853 let user = rustango::tenancy::auth::User::objects()
17854 .where_(rustango::tenancy::auth::User::id.eq(id))
17855 .first(tenant.pool())
17856 .await?
17857 .ok_or(AdminError::NotFound(id))?;
17858 let roles: Vec<rustango::tenancy::permissions::Role> =
17859 rustango::tenancy::permissions::Role::objects()
17860 .order_by(&[("name", false)])
17861 .fetch(tenant.pool())
17862 .await?;
17863 let memberships: Vec<rustango::tenancy::permissions::UserRole> =
17864 rustango::tenancy::permissions::UserRole::objects()
17865 .where_(rustango::tenancy::permissions::UserRole::user_id.eq(id))
17866 .fetch(tenant.pool())
17867 .await?;
17868 let assigned: std::collections::BTreeSet<i64> = memberships.iter().map(|m| m.role_id).collect();
17869
17870 let role_choices: Vec<serde_json::Value> = roles
17871 .iter()
17872 .map(|r| {
17873 let rid = r.id.get().copied().unwrap_or_default();
17874 serde_json::json!({
17875 "id": rid,
17876 "name": r.name,
17877 "description": r.description,
17878 "assigned": assigned.contains(&rid),
17879 })
17880 })
17881 .collect();
17882
17883 let user_timezone = user
17888 .data
17889 .get("timezone")
17890 .and_then(serde_json::Value::as_str)
17891 .unwrap_or("")
17892 .to_owned();
17893 let user_email = user_email(&user);
17894
17895 let mut ctx = Context::new();
17896 add_chrome(&mut ctx, tenant, "users", session_user).await;
17897 add_admin_theme(&mut ctx, tenant.pool()).await;
17898 ctx.insert("mode", "edit");
17899 ctx.insert(
17900 "user",
17901 &serde_json::json!({
17902 "id": user.id.get().copied(),
17903 "username": user.username,
17904 "email": user_email,
17905 "is_superuser": user.is_superuser,
17906 "active": user.active,
17907 "timezone": user_timezone,
17908 "password_changed_at": user.password_changed_at,
17909 "created_at": user.created_at,
17910 }),
17911 );
17912 ctx.insert("role_choices", &role_choices);
17913 let (keys, skills) = mcp_keys_ctx(tenant.pool(), id).await;
17916 ctx.insert("mcp_keys", &keys);
17917 ctx.insert("mcp_skills", &skills);
17918 if let Some(one_time) = &mcp_one_time {
17919 ctx.insert("mcp_one_time", one_time);
17920 }
17921 render_with_csrf(state, headers, "rcms_admin/user_form.html", &mut ctx)
17922}
17923
17924fn parse_mcp_key_form(pairs: &[(String, String)]) -> (String, Vec<String>) {
17929 let label = pairs
17930 .iter()
17931 .find(|(k, _)| k == "label")
17932 .map(|(_, v)| v.trim())
17933 .filter(|v| !v.is_empty())
17934 .unwrap_or("MCP key")
17935 .to_owned();
17936 let skills: Vec<String> = pairs
17937 .iter()
17938 .filter(|(k, v)| k == "skill" && !v.trim().is_empty())
17939 .map(|(_, v)| v.trim().to_owned())
17940 .collect();
17941 (label, skills)
17942}
17943
17944async fn audit_mcp_key(
17947 pool: &rustango::sql::Pool,
17948 actor_id: i64,
17949 what: &str,
17950 detail: serde_json::Value,
17951) {
17952 let entry = rustango::audit::PendingEntry {
17953 entity_table: "rustango_agents",
17954 entity_pk: detail
17955 .get("key_id")
17956 .and_then(serde_json::Value::as_i64)
17957 .map(|i| i.to_string())
17958 .unwrap_or_default(),
17959 operation: rustango::audit::AuditOp::Action,
17960 source: rustango::audit::AuditSource::User {
17961 id: actor_id.to_string(),
17962 },
17963 changes: serde_json::json!({ "event": what, "detail": detail }),
17964 };
17965 if let Err(e) = rustango::audit::emit_one_pool(pool, &entry).await {
17966 tracing::warn!(error = %e, "mcp key audit emit failed");
17967 }
17968}
17969
17970async fn mint_mcp_key(
17973 pool: &rustango::sql::Pool,
17974 actor_id: i64,
17975 owner_id: i64,
17976 label: &str,
17977 skills: &[String],
17978) -> Result<serde_json::Value, String> {
17979 match rustango::tenancy::create_user_key_pool(pool, owner_id, label, skills).await {
17980 Ok(issued) => {
17981 let key_id = issued.agent.id.get().copied().unwrap_or_default();
17982 audit_mcp_key(
17983 pool,
17984 actor_id,
17985 "created",
17986 serde_json::json!({ "key_id": key_id, "owner_id": owner_id, "label": label, "scope": skills }),
17987 )
17988 .await;
17989 Ok(serde_json::json!({ "token": issued.token, "label": label }))
17990 }
17991 Err(e) => Err(e.to_string()),
17992 }
17993}
17994
17995pub async fn account_mcp_key_create(
17999 State(state): State<super::AdminState>,
18000 tenant: Tenant,
18001 headers: HeaderMap,
18002 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18003 Form(pairs): Form<Vec<(String, String)>>,
18004) -> Result<Response, AdminError> {
18005 let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18006 return Ok(unauthorized_no_session());
18007 };
18008 let (label, skills) = parse_mcp_key_form(&pairs);
18009 match mint_mcp_key(tenant.pool(), uid, uid, &label, &skills).await {
18010 Ok(one_time) => {
18011 render_account_page(
18012 &state,
18013 &tenant,
18014 &headers,
18015 session_user.as_ref(),
18016 Some(one_time),
18017 )
18018 .await
18019 }
18020 Err(msg) => redirect_named_with_message_args(
18021 "rcms-admin:account",
18022 MsgLevel::Error,
18023 "Couldn't create the key: {error}",
18024 &[("error", msg.as_str())],
18025 &headers,
18026 ),
18027 }
18028}
18029
18030pub async fn account_mcp_key_revoke(
18033 State(_state): State<super::AdminState>,
18034 tenant: Tenant,
18035 headers: HeaderMap,
18036 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18037 Path(key_id): Path<i64>,
18038) -> Result<Response, AdminError> {
18039 let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18040 return Ok(unauthorized_no_session());
18041 };
18042 match rustango::tenancy::revoke_user_key_pool(tenant.pool(), uid, key_id).await {
18043 Ok(()) => {
18044 audit_mcp_key(
18045 tenant.pool(),
18046 uid,
18047 "revoked",
18048 serde_json::json!({ "key_id": key_id, "owner_id": uid }),
18049 )
18050 .await;
18051 redirect_named_with_message_args(
18052 "rcms-admin:account",
18053 MsgLevel::Success,
18054 "MCP key revoked.",
18055 &[],
18056 &headers,
18057 )
18058 }
18059 Err(e) => {
18060 let msg = e.to_string();
18061 redirect_named_with_message_args(
18062 "rcms-admin:account",
18063 MsgLevel::Error,
18064 "Couldn't revoke the key: {error}",
18065 &[("error", msg.as_str())],
18066 &headers,
18067 )
18068 }
18069 }
18070}
18071
18072pub async fn users_mcp_key_create(
18078 State(state): State<super::AdminState>,
18079 tenant: Tenant,
18080 headers: HeaderMap,
18081 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18082 Path(user_id): Path<i64>,
18083 Form(pairs): Form<Vec<(String, String)>>,
18084) -> Result<Response, AdminError> {
18085 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18091 return Ok(redirect);
18092 }
18093 let Some(actor_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18094 return Ok(unauthorized_no_session());
18095 };
18096 let (label, skills) = parse_mcp_key_form(&pairs);
18097 match mint_mcp_key(tenant.pool(), actor_id, user_id, &label, &skills).await {
18098 Ok(one_time) => {
18099 render_user_edit_page(
18100 &state,
18101 &tenant,
18102 &headers,
18103 session_user.as_ref(),
18104 user_id,
18105 Some(one_time),
18106 )
18107 .await
18108 }
18109 Err(msg) => redirect_named_with_params_and_message_args(
18110 "rcms-admin:users:edit",
18111 &[("id", user_id.to_string())],
18112 MsgLevel::Error,
18113 "Couldn't create the key: {error}",
18114 &[("error", msg.as_str())],
18115 &headers,
18116 ),
18117 }
18118}
18119
18120pub async fn users_mcp_key_revoke(
18123 State(_state): State<super::AdminState>,
18124 tenant: Tenant,
18125 headers: HeaderMap,
18126 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18127 Path((user_id, key_id)): Path<(i64, i64)>,
18128) -> Result<Response, AdminError> {
18129 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18135 return Ok(redirect);
18136 }
18137 let Some(actor_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18138 return Ok(unauthorized_no_session());
18139 };
18140 match rustango::tenancy::revoke_user_key_pool(tenant.pool(), user_id, key_id).await {
18141 Ok(()) => {
18142 audit_mcp_key(
18143 tenant.pool(),
18144 actor_id,
18145 "revoked",
18146 serde_json::json!({ "key_id": key_id, "owner_id": user_id }),
18147 )
18148 .await;
18149 redirect_named_with_params_and_message_args(
18150 "rcms-admin:users:edit",
18151 &[("id", user_id.to_string())],
18152 MsgLevel::Success,
18153 "MCP key revoked.",
18154 &[],
18155 &headers,
18156 )
18157 }
18158 Err(e) => {
18159 let msg = e.to_string();
18160 redirect_named_with_params_and_message_args(
18161 "rcms-admin:users:edit",
18162 &[("id", user_id.to_string())],
18163 MsgLevel::Error,
18164 "Couldn't revoke the key: {error}",
18165 &[("error", msg.as_str())],
18166 &headers,
18167 )
18168 }
18169 }
18170}
18171
18172#[derive(Deserialize)]
18176pub struct UserForm {
18177 pub username: String,
18178 #[serde(default)]
18179 pub email: Option<String>,
18180 #[serde(default)]
18181 pub password: Option<String>,
18182 #[serde(default)]
18183 pub is_superuser: Option<String>,
18184 #[serde(default)]
18185 pub active: Option<String>,
18186}
18187
18188fn validate_optional_email(raw: Option<&str>) -> Result<String, String> {
18192 let e = raw.map(str::trim).unwrap_or("");
18193 if e.is_empty() {
18194 return Ok(String::new());
18195 }
18196 let ok = e.split('@').count() == 2
18197 && e.split('@').all(|p| !p.is_empty())
18198 && !e.contains(char::is_whitespace);
18199 if ok {
18200 Ok(e.to_owned())
18201 } else {
18202 Err(format!("“{e}” is not a valid email address."))
18203 }
18204}
18205
18206pub async fn users_create_submit(
18209 State(_state): State<super::AdminState>,
18210 tenant: Tenant,
18211 headers: HeaderMap,
18212 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18213 Form(pairs): Form<Vec<(String, String)>>,
18214) -> Result<Response, AdminError> {
18215 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18216 return Ok(redirect);
18217 }
18218 use rustango::sql::Auto;
18219 let single = |k: &str| pairs.iter().find(|(n, _)| n == k).map(|(_, v)| v.clone());
18222 let form = UserForm {
18223 username: single("username").unwrap_or_default(),
18224 email: single("email"),
18225 password: single("password"),
18226 is_superuser: single("is_superuser"),
18227 active: single("active"),
18228 };
18229 let role_ids: Vec<i64> = pairs
18230 .iter()
18231 .filter(|(k, _)| k == "role_id")
18232 .filter_map(|(_, v)| v.parse::<i64>().ok())
18233 .collect();
18234 let username = form.username.trim().to_owned();
18235 let password = form
18236 .password
18237 .as_deref()
18238 .map(str::trim)
18239 .filter(|s| !s.is_empty())
18240 .map(str::to_owned);
18241 if username.is_empty() || password.is_none() {
18242 return Err(AdminError::Validation(
18243 "Username and initial password are both required.".to_owned(),
18244 ));
18245 }
18246 let hash = crate::passwords::hash(password.as_deref().unwrap_or_default()).await
18247 .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
18248 let email = validate_optional_email(form.email.as_deref()).map_err(AdminError::Validation)?;
18249 let email_col = (!email.is_empty()).then(|| email.clone());
18253
18254 let mut data = serde_json::Map::new();
18257 if !email.is_empty() {
18258 data.insert("email".to_owned(), serde_json::Value::String(email));
18259 }
18260 let mut row = rustango::tenancy::auth::User {
18261 id: Auto::Unset,
18262 username: username.clone(),
18263 password_hash: hash,
18264 email: email_col,
18265 is_superuser: form.is_superuser.is_some(),
18266 active: form.active.is_some(),
18267 created_at: chrono::Utc::now(),
18268 data: serde_json::Value::Object(data),
18269 password_changed_at: Some(chrono::Utc::now()),
18270 sessions_revoked_at: None,
18271 };
18272 row.insert_pool(tenant.pool()).await?;
18273 if let Some(new_id) = row.id.get().copied() {
18274 sync_user_roles(tenant.pool(), new_id, &role_ids).await?;
18275 }
18276 redirect_named_with_message_args(
18277 "rcms-admin:users",
18278 MsgLevel::Success,
18279 "User “{username}” created.",
18280 &[("username", username.as_str())],
18281 &headers,
18282 )
18283}
18284
18285pub async fn users_edit_submit(
18293 State(_state): State<super::AdminState>,
18294 tenant: Tenant,
18295 headers: HeaderMap,
18296 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18297 Path(id): Path<i64>,
18298 Form(form): Form<Vec<(String, String)>>,
18299) -> Result<Response, AdminError> {
18300 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18301 return Ok(redirect);
18302 }
18303 let single = |key: &str| -> Option<String> {
18306 form.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
18307 };
18308 let username_raw = single("username").unwrap_or_default();
18309 let username = username_raw.trim().to_owned();
18310 if username.is_empty() {
18311 return Err(AdminError::Validation(
18312 "Username cannot be empty.".to_owned(),
18313 ));
18314 }
18315 let password = single("password");
18316 let is_superuser = form.iter().any(|(k, _)| k == "is_superuser");
18317 let active = form.iter().any(|(k, _)| k == "active");
18318 let timezone_raw = single("timezone").unwrap_or_default();
18319 let timezone = timezone_raw.trim().to_owned();
18320 let email =
18322 validate_optional_email(single("email").as_deref()).map_err(AdminError::Validation)?;
18323 let role_ids: Vec<i64> = form
18324 .iter()
18325 .filter(|(k, _)| k == "role_id")
18326 .filter_map(|(_, v)| v.parse::<i64>().ok())
18327 .collect();
18328
18329 let mut user = rustango::tenancy::auth::User::objects()
18330 .where_(rustango::tenancy::auth::User::id.eq(id))
18331 .first(tenant.pool())
18332 .await?
18333 .ok_or(AdminError::NotFound(id))?;
18334 user.username = username.clone();
18335 user.is_superuser = is_superuser;
18336 user.active = active;
18337 {
18340 let map = user.data.as_object_mut().ok_or_else(|| {
18341 AdminError::Validation(
18342 "User.data is not a JSON object — refusing to overwrite.".to_owned(),
18343 )
18344 })?;
18345 if timezone.is_empty() {
18346 map.remove("timezone");
18347 } else {
18348 map.insert(
18349 "timezone".to_owned(),
18350 serde_json::Value::String(timezone.clone()),
18351 );
18352 }
18353 if email.is_empty() {
18354 map.remove("email");
18355 } else {
18356 map.insert("email".to_owned(), serde_json::Value::String(email.clone()));
18357 }
18358 }
18359 user.email = (!email.is_empty()).then(|| email.clone());
18362
18363 let rotated = password.as_deref().map(str::trim).filter(|s| !s.is_empty());
18364 if let Some(new_pw) = rotated {
18365 let hash = crate::passwords::hash(new_pw).await
18366 .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
18367 user.password_hash = hash;
18368 user.password_changed_at = Some(chrono::Utc::now());
18369 }
18370 user.save_pool(tenant.pool()).await?;
18371 sync_user_roles(tenant.pool(), id, &role_ids).await?;
18372 if rotated.is_some() {
18373 redirect_named_with_message_args(
18374 "rcms-admin:users",
18375 MsgLevel::Success,
18376 "User “{username}” saved (password rotated).",
18377 &[("username", username.as_str())],
18378 &headers,
18379 )
18380 } else {
18381 redirect_named_with_message_args(
18382 "rcms-admin:users",
18383 MsgLevel::Success,
18384 "User “{username}” saved.",
18385 &[("username", username.as_str())],
18386 &headers,
18387 )
18388 }
18389}
18390
18391async fn sync_user_roles(
18394 pool: &rustango::sql::Pool,
18395 user_id: i64,
18396 new_role_ids: &[i64],
18397) -> Result<(), AdminError> {
18398 let existing: Vec<rustango::tenancy::permissions::UserRole> =
18399 rustango::tenancy::permissions::UserRole::objects()
18400 .where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
18401 .fetch(pool)
18402 .await?;
18403 let want: std::collections::BTreeSet<i64> = new_role_ids.iter().copied().collect();
18404 let have: std::collections::BTreeSet<i64> = existing.iter().map(|m| m.role_id).collect();
18405 for m in &existing {
18406 if !want.contains(&m.role_id) {
18407 m.clone().delete_pool(pool).await?;
18408 }
18409 }
18410 for role_id in new_role_ids {
18411 if !have.contains(role_id) {
18412 let mut row = rustango::tenancy::permissions::UserRole {
18413 id: rustango::sql::Auto::Unset,
18414 user_id,
18415 role_id: *role_id,
18416 };
18417 row.insert_pool(pool).await?;
18418 }
18419 }
18420 Ok(())
18421}
18422
18423pub async fn users_deactivate_submit(
18426 State(_state): State<super::AdminState>,
18427 tenant: Tenant,
18428 headers: HeaderMap,
18429 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18430 Path(id): Path<i64>,
18431) -> Result<Response, AdminError> {
18432 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18433 return Ok(redirect);
18434 }
18435 let mut user = rustango::tenancy::auth::User::objects()
18436 .where_(rustango::tenancy::auth::User::id.eq(id))
18437 .first(tenant.pool())
18438 .await?
18439 .ok_or(AdminError::NotFound(id))?;
18440 user.active = false;
18441 user.save_pool(tenant.pool()).await?;
18442 redirect_named_with_message_args(
18443 "rcms-admin:users",
18444 MsgLevel::Success,
18445 "User “{username}” deactivated.",
18446 &[("username", user.username.as_str())],
18447 &headers,
18448 )
18449}
18450
18451pub async fn users_bulk_submit(
18456 State(_state): State<super::AdminState>,
18457 tenant: Tenant,
18458 headers: HeaderMap,
18459 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18460 Form(pairs): Form<Vec<(String, String)>>,
18461) -> Result<Response, AdminError> {
18462 if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18463 return Ok(redirect);
18464 }
18465 let mut ids: Vec<i64> = Vec::new();
18466 let mut action = String::new();
18467 for (k, v) in &pairs {
18468 match k.as_str() {
18469 "user_id" => {
18470 if let Ok(id) = v.parse::<i64>() {
18471 ids.push(id);
18472 }
18473 }
18474 "action" => action = v.clone(),
18475 _ => {}
18476 }
18477 }
18478 let target_active = match action.as_str() {
18479 "enable" => true,
18480 "disable" => false,
18481 _ => {
18482 return redirect_named_with_message(
18483 "rcms-admin:users",
18484 MsgLevel::Error,
18485 "Unknown bulk action.",
18486 &headers,
18487 );
18488 }
18489 };
18490 if ids.is_empty() {
18491 return redirect_named_with_message(
18492 "rcms-admin:users",
18493 MsgLevel::Info,
18494 "No users selected.",
18495 &headers,
18496 );
18497 }
18498 let me = session_user.as_ref().and_then(|u| u.id.get().copied());
18499 let mut changed = 0usize;
18500 let mut skipped_self = false;
18501 for id in ids {
18502 if !target_active && Some(id) == me {
18504 skipped_self = true;
18505 continue;
18506 }
18507 if let Some(mut user) = rustango::tenancy::auth::User::objects()
18508 .where_(rustango::tenancy::auth::User::id.eq(id))
18509 .first(tenant.pool())
18510 .await?
18511 {
18512 if user.active != target_active {
18513 user.active = target_active;
18514 user.save_pool(tenant.pool()).await?;
18515 changed += 1;
18516 }
18517 }
18518 }
18519 let verb = if target_active { "Enabled" } else { "Disabled" };
18520 let mut msg = format!("{verb} {changed} user(s).");
18521 if skipped_self {
18522 msg.push_str(" (Skipped your own account.)");
18523 }
18524 redirect_named_with_message("rcms-admin:users", MsgLevel::Success, &msg, &headers)
18525}
18526
18527pub async fn settings_page(
18532 State(state): State<super::AdminState>,
18533 tenant: Tenant,
18534 headers: HeaderMap,
18535 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18536) -> Result<Response, AdminError> {
18537 let locales: Vec<Locale> = Locale::objects()
18538 .order_by(&[("sort_order", false), ("code", false)])
18539 .fetch(tenant.pool())
18540 .await?;
18541 let media_count: Vec<Media> = Media::objects().fetch(tenant.pool()).await?;
18542 let themes: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
18545 .order_by(&[("name", false)])
18546 .fetch(tenant.pool())
18547 .await?;
18548 let theme_rows: Vec<serde_json::Value> = themes
18549 .iter()
18550 .map(|t| {
18551 serde_json::json!({
18552 "id": t.id.get().copied(),
18553 "name": t.name,
18554 "slug": t.slug,
18555 "is_admin_default": t.is_admin_default,
18556 "is_default": t.is_default,
18557 "color_bg": t.color_bg,
18558 "color_surface": t.color_surface,
18559 "color_text_primary": t.color_text_primary,
18560 "color_link": t.color_link,
18561 })
18562 })
18563 .collect();
18564 let mut ctx = Context::new();
18565 add_chrome(&mut ctx, &tenant, "settings", session_user.as_ref()).await;
18566 add_admin_theme(&mut ctx, tenant.pool()).await;
18567 ctx.insert("locales", &locales);
18568 ctx.insert("media_count", &media_count.len());
18569 ctx.insert("org_slug", &tenant.org.slug);
18570 ctx.insert("org_display_name", &tenant.org.display_name);
18571 ctx.insert("themes", &theme_rows);
18572
18573 if let Ok(Some(row)) = crate::site_setting::get(tenant.pool(), "branding").await {
18577 let logo_key = row
18578 .value_json
18579 .get("logo_storage_key")
18580 .and_then(|v| v.as_str())
18581 .unwrap_or("")
18582 .to_owned();
18583 let favicon_key = row
18584 .value_json
18585 .get("favicon_storage_key")
18586 .and_then(|v| v.as_str())
18587 .unwrap_or("")
18588 .to_owned();
18589 ctx.insert("branding_logo_filename", &logo_key);
18590 ctx.insert("branding_favicon_filename", &favicon_key);
18591 ctx.insert(
18592 "branding_site_name",
18593 row.value_json.get("site_name").and_then(|v| v.as_str()).unwrap_or(""),
18594 );
18595 }
18596
18597 render_with_csrf(&state, &headers, "rcms_admin/settings.html", &mut ctx)
18598}
18599
18600pub async fn richtext_preview(
18614 State(_state): State<super::AdminState>,
18615 _tenant: Tenant,
18616 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18617 Form(form): Form<std::collections::HashMap<String, String>>,
18618) -> Result<Response, AdminError> {
18619 if session_user.is_none() {
18620 return Ok(unauthorized_no_session());
18621 }
18622 let src = form.get("body").map(String::as_str).unwrap_or("");
18623 let html = crate::markdown::sanitize_html(src);
18624 Ok((
18625 axum::http::StatusCode::OK,
18626 [(axum::http::header::CONTENT_TYPE, "text/html; charset=utf-8")],
18627 html,
18628 )
18629 .into_response())
18630}
18631
18632pub async fn settings_branding_submit(
18637 State(_state): State<super::AdminState>,
18638 tenant: Tenant,
18639 headers: HeaderMap,
18640 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
18641 mut multipart: axum::extract::Multipart,
18642) -> Result<Response, AdminError> {
18643 let mut logo_filename: Option<String> = None;
18644 let mut favicon_filename: Option<String> = None;
18645 let mut site_name: Option<String> = None;
18646
18647 while let Some(field) = multipart
18648 .next_field()
18649 .await
18650 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
18651 {
18652 let field_name = field.name().unwrap_or("").to_owned();
18653 let original = field.file_name().map(|s| s.to_owned());
18654 let bytes = field
18655 .bytes()
18656 .await
18657 .map_err(|e| AdminError::Upload(format!("read field {field_name}: {e}")))?;
18658 if field_name == "site_name" {
18660 site_name = Some(String::from_utf8_lossy(&bytes).trim().chars().take(120).collect());
18661 continue;
18662 }
18663 if bytes.is_empty() {
18664 continue;
18665 }
18666 let (slot, default_ext) = match field_name.as_str() {
18667 "logo" => (&mut logo_filename, "png"),
18668 "favicon" => (&mut favicon_filename, "ico"),
18669 _ => continue,
18670 };
18671 let safe_ext = original
18672 .as_deref()
18673 .and_then(|n| n.rsplit_once('.'))
18674 .map(|(_, ext)| ext)
18675 .filter(|ext| ext.len() <= 8 && ext.chars().all(|c| c.is_ascii_alphanumeric()))
18676 .map(str::to_ascii_lowercase)
18677 .unwrap_or_else(|| default_ext.to_owned());
18678 let storage_name = format!("{field_name}.{safe_ext}");
18679 crate::media_storage::disk_for(&tenant.org.slug)
18680 .save(
18681 &crate::media_storage::key(&tenant.org.slug, &format!("branding/{storage_name}")),
18682 &bytes,
18683 )
18684 .await
18685 .map_err(|e| AdminError::Upload(format!("write {field_name}: {e}")))?;
18686 *slot = Some(storage_name);
18687 }
18688
18689 let existing = crate::site_setting::get(tenant.pool(), "branding")
18692 .await
18693 .unwrap_or_default()
18694 .map(|r| r.value_json)
18695 .unwrap_or_else(|| serde_json::json!({}));
18696 let mut value = existing.as_object().cloned().unwrap_or_default();
18697 if let Some(name) = logo_filename {
18698 value.insert("logo_storage_key".to_owned(), serde_json::json!(name));
18699 }
18700 if let Some(name) = favicon_filename {
18701 value.insert("favicon_storage_key".to_owned(), serde_json::json!(name));
18702 }
18703 match site_name {
18704 Some(n) if n.is_empty() => {
18705 value.remove("site_name");
18706 }
18707 Some(n) => {
18708 value.insert("site_name".to_owned(), serde_json::json!(n));
18709 }
18710 None => {}
18711 }
18712 let _ =
18713 crate::site_setting::upsert(tenant.pool(), "branding", serde_json::Value::Object(value))
18714 .await?;
18715
18716 redirect_named_with_message(
18717 "rcms-admin:settings",
18718 MsgLevel::Success,
18719 "Branding saved. Reload to see the new logo / favicon.",
18720 &headers,
18721 )
18722}
18723
18724pub async fn settings_branding_serve_logo(headers: HeaderMap, tenant: Tenant) -> Response {
18728 serve_branding_asset(&headers, &tenant, "logo_storage_key").await
18729}
18730
18731pub async fn settings_branding_serve_favicon(headers: HeaderMap, tenant: Tenant) -> Response {
18733 serve_branding_asset(&headers, &tenant, "favicon_storage_key").await
18734}
18735
18736async fn serve_branding_asset(headers: &HeaderMap, tenant: &Tenant, slot: &str) -> Response {
18737 let setting = match crate::site_setting::get(tenant.pool(), "branding").await {
18738 Ok(Some(s)) => s,
18739 _ => {
18740 return (axum::http::StatusCode::NOT_FOUND, "no branding set").into_response();
18741 }
18742 };
18743 let storage_name = match setting.value_json.get(slot).and_then(|v| v.as_str()) {
18744 Some(s) if !s.is_empty() => s.to_owned(),
18745 _ => {
18746 return (axum::http::StatusCode::NOT_FOUND, "asset not set").into_response();
18747 }
18748 };
18749 if storage_name.contains('/') || storage_name.contains("..") {
18752 return (axum::http::StatusCode::BAD_REQUEST, "invalid storage name").into_response();
18753 }
18754 let bytes = match crate::media_storage::disk_for(&tenant.org.slug)
18755 .load(&crate::media_storage::key(
18756 &tenant.org.slug,
18757 &format!("branding/{storage_name}"),
18758 ))
18759 .await
18760 {
18761 Ok(b) => b,
18762 Err(_) => {
18763 return (axum::http::StatusCode::NOT_FOUND, "branding bytes missing").into_response();
18764 }
18765 };
18766 let mime = mime_guess::from_path(&storage_name)
18767 .first_or_octet_stream()
18768 .essence_str()
18769 .to_owned();
18770 revalidated_asset(headers, mime, bytes)
18776}
18777
18778fn revalidated_asset(headers: &HeaderMap, mime: String, bytes: Vec<u8>) -> Response {
18784 use sha2::{Digest, Sha256};
18785 let digest = Sha256::digest(&bytes);
18786 let mut etag = String::with_capacity(34);
18787 etag.push('"');
18788 for b in digest.iter().take(16) {
18789 use std::fmt::Write as _;
18790 let _ = write!(etag, "{b:02x}");
18791 }
18792 etag.push('"');
18793 let matches_etag = headers
18794 .get(axum::http::header::IF_NONE_MATCH)
18795 .and_then(|v| v.to_str().ok())
18796 .is_some_and(|inm| inm.split(',').any(|t| t.trim() == etag));
18797 if matches_etag {
18798 return (
18799 axum::http::StatusCode::NOT_MODIFIED,
18800 [
18801 (axum::http::header::ETAG, etag),
18802 (axum::http::header::CACHE_CONTROL, "no-cache".to_owned()),
18803 ],
18804 )
18805 .into_response();
18806 }
18807 (
18808 [
18809 (axum::http::header::CONTENT_TYPE, mime),
18810 (axum::http::header::CACHE_CONTROL, "no-cache".to_owned()),
18811 (axum::http::header::ETAG, etag),
18812 ],
18813 bytes,
18814 )
18815 .into_response()
18816}
18817
18818#[derive(Debug, Deserialize)]
18827pub struct ThemeSwitchForm {
18828 pub surface: String,
18829 pub theme_id: i64,
18830}
18831
18832pub async fn settings_theme_switch(
18833 State(_state): State<super::AdminState>,
18834 tenant: Tenant,
18835 headers: HeaderMap,
18836 Form(form): Form<ThemeSwitchForm>,
18837) -> Result<Response, AdminError> {
18838 if form.surface != "admin" && form.surface != "public" {
18843 return Err(AdminError::Validation(format!(
18844 "Unknown surface `{}` — expected `admin` or `public`.",
18845 form.surface
18846 )));
18847 }
18848 let target = crate::theme::Theme::objects()
18849 .where_(crate::theme::Theme::id.eq(form.theme_id))
18850 .first(tenant.pool())
18851 .await?
18852 .ok_or(AdminError::NotFound(form.theme_id))?;
18853
18854 let all_themes: Vec<crate::theme::Theme> =
18859 crate::theme::Theme::objects().fetch(tenant.pool()).await?;
18860 for mut t in all_themes {
18861 let target_id = target.id.get().copied().unwrap_or_default();
18862 let this_id = t.id.get().copied().unwrap_or_default();
18863 if form.surface == "admin" {
18864 t.is_admin_default = this_id == target_id;
18865 } else {
18866 t.is_default = this_id == target_id;
18867 }
18868 t.save_pool(tenant.pool()).await?;
18869 }
18870 if wants_json_response(&headers) && form.surface == "admin" {
18879 let target_id = target.id.get().copied().unwrap_or_default();
18880 let brand_colors: Vec<crate::theme::BrandColor> = crate::theme::BrandColor::objects()
18881 .where_(crate::theme::BrandColor::theme_id.eq(target_id))
18882 .order_by(&[("sort_order", false)])
18883 .fetch(tenant.pool())
18884 .await
18885 .unwrap_or_default();
18886 let css = crate::theme::emit_css(&target, &brand_colors);
18887 return Ok(Json(serde_json::json!({
18888 "ok": true,
18889 "id": target_id,
18890 "slug": target.slug,
18891 "name": target.name,
18892 "default_mode": target.default_mode,
18893 "css": css,
18894 "message": format!("Admin theme switched to “{}”.", target.name),
18895 }))
18896 .into_response());
18897 }
18898 let redirect_target = if form.surface == "admin" {
18902 "rcms-admin:account"
18903 } else {
18904 "rcms-admin:settings"
18905 };
18906 let theme_flash = if form.surface == "admin" {
18907 "Admin theme switched to “{name}”."
18908 } else {
18909 "Public theme switched to “{name}”."
18910 };
18911 redirect_named_with_message_args(
18912 redirect_target,
18913 MsgLevel::Success,
18914 theme_flash,
18915 &[("name", target.name.as_str())],
18916 &headers,
18917 )
18918}
18919
18920fn wants_json_response(headers: &HeaderMap) -> bool {
18926 let accept = headers
18927 .get(header::ACCEPT)
18928 .and_then(|v| v.to_str().ok())
18929 .unwrap_or("");
18930 if accept.contains("application/json") {
18931 return true;
18932 }
18933 headers
18934 .get("x-requested-with")
18935 .and_then(|v| v.to_str().ok())
18936 .is_some_and(|v| v.eq_ignore_ascii_case("XMLHttpRequest"))
18937}
18938
18939#[derive(Debug, Deserialize)]
18946pub struct RedirectForm {
18947 pub from_path: String,
18948 pub to_path: String,
18949 #[serde(default)]
18952 pub is_permanent: Option<String>,
18953 #[serde(default)]
18954 pub note: Option<String>,
18955 #[serde(default)]
18958 pub overrides_live: Option<String>,
18959 #[serde(default)]
18961 pub from_page_id: Option<String>,
18962 #[serde(default)]
18963 pub to_page_id: Option<String>,
18964}
18965
18966impl RedirectForm {
18967 fn parsed_permanent(&self) -> bool {
18968 self.is_permanent.is_some()
18969 }
18970 fn parsed_overrides_live(&self) -> bool {
18971 self.overrides_live.is_some()
18972 }
18973 fn parsed_page_id(raw: &Option<String>) -> Option<i64> {
18974 raw.as_deref()
18975 .and_then(|s| s.trim().parse::<i64>().ok())
18976 .filter(|id| *id > 0)
18977 }
18978 fn parsed_from_page_id(&self) -> Option<i64> {
18979 Self::parsed_page_id(&self.from_page_id)
18980 }
18981 fn parsed_to_page_id(&self) -> Option<i64> {
18982 Self::parsed_page_id(&self.to_page_id)
18983 }
18984}
18985
18986async fn redirect_form_paths(
18993 pool: &rustango::sql::Pool,
18994 form: &RedirectForm,
18995) -> Result<(String, String), AdminError> {
18996 let mut from = form.from_path.trim().to_owned();
18997 let mut to = form.to_path.trim().to_owned();
18998 if let Some(pid) = form.parsed_from_page_id() {
18999 if let Some(p) = Page::objects().where_(Page::id.eq(pid)).first(pool).await? {
19000 from = p.url_path;
19001 }
19002 }
19003 if let Some(pid) = form.parsed_to_page_id() {
19004 if let Some(p) = Page::objects().where_(Page::id.eq(pid)).first(pool).await? {
19005 to = p.url_path;
19006 }
19007 }
19008 Ok((from, to))
19009}
19010
19011async fn redirect_is_shadowed(tenant: &Tenant, from_path: &str, overrides_live: bool) -> bool {
19016 if overrides_live || crate::redirect::is_wildcard(from_path) {
19017 return false;
19020 }
19021 matches!(
19022 crate::resolver::resolve_path(tenant, from_path).await,
19023 Ok(Some(_))
19024 )
19025}
19026
19027fn redirect_pattern_error(from_path: &str, to_path: &str) -> Option<&'static str> {
19031 if from_path.matches('*').count() > 1 {
19032 Some("The from-path may contain at most one “*” wildcard (e.g. /old/* or */feed).")
19033 } else if crate::redirect::redirect_loops(from_path, to_path) {
19034 Some("That redirect points back at its own from-path, so visitors would loop.")
19035 } else {
19036 None
19037 }
19038}
19039
19040#[derive(Debug, Deserialize, Default)]
19043pub struct RedirectListQuery {
19044 #[serde(default)]
19045 pub q: Option<String>,
19046 #[serde(default)]
19048 pub filter: Option<String>,
19049 #[serde(default)]
19051 pub sort: Option<String>,
19052 #[serde(default)]
19054 pub dir: Option<String>,
19055 #[serde(default)]
19056 pub page: Option<i64>,
19057}
19058
19059const REDIRECTS_PER_PAGE: usize = 50;
19060
19061pub async fn redirect_list(
19062 State(state): State<super::AdminState>,
19063 tenant: Tenant,
19064 headers: HeaderMap,
19065 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19066 Query(q): Query<RedirectListQuery>,
19067) -> Result<Response, AdminError> {
19068 let mut all: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
19072 .fetch(tenant.pool())
19073 .await?;
19074 let now = chrono::Utc::now();
19075
19076 let needle = q.q.as_deref().unwrap_or("").trim().to_lowercase();
19077 if !needle.is_empty() {
19078 all.retain(|r| {
19079 r.from_path.to_lowercase().contains(&needle)
19080 || r.to_path.to_lowercase().contains(&needle)
19081 || r.note.to_lowercase().contains(&needle)
19082 });
19083 }
19084
19085 let count_all = all.len();
19087 let count_active = all.iter().filter(|r| r.is_active).count();
19088 let count_disabled = all.iter().filter(|r| !r.is_active).count();
19089 let count_stale = all
19090 .iter()
19091 .filter(|r| matches!(crate::redirect::staleness(r, now), "stale" | "unused"))
19092 .count();
19093
19094 let filter = q.filter.as_deref().unwrap_or("all");
19095 all.retain(|r| match filter {
19096 "active" => r.is_active,
19097 "disabled" => !r.is_active,
19098 "stale" => matches!(crate::redirect::staleness(r, now), "stale" | "unused"),
19099 _ => true,
19100 });
19101
19102 let sort = q.sort.as_deref().unwrap_or("from");
19103 let desc = q.dir.as_deref() == Some("desc");
19104 all.sort_by(|a, b| {
19105 let o = match sort {
19106 "last_used" => a.last_hit_at.cmp(&b.last_hit_at),
19107 "created" => a.created_at.get().cmp(&b.created_at.get()),
19108 "hits" => a.hit_count.cmp(&b.hit_count),
19109 "staleness" => {
19110 let rank = |r: &crate::redirect::Redirect| match crate::redirect::staleness(r, now)
19111 {
19112 "disabled" => 0u8,
19113 "unused" => 1,
19114 "stale" => 2,
19115 _ => 3,
19116 };
19117 rank(a).cmp(&rank(b))
19118 }
19119 _ => a.from_path.cmp(&b.from_path),
19120 };
19121 if desc {
19122 o.reverse()
19123 } else {
19124 o
19125 }
19126 });
19127
19128 let total = all.len();
19129 let total_pages = total.div_ceil(REDIRECTS_PER_PAGE).max(1);
19130 let page = q.page.unwrap_or(1).clamp(1, total_pages as i64) as usize;
19131 let start = (page - 1) * REDIRECTS_PER_PAGE;
19132 let items: Vec<crate::redirect::Redirect> = all
19133 .into_iter()
19134 .skip(start)
19135 .take(REDIRECTS_PER_PAGE)
19136 .collect();
19137
19138 let mut ctx = Context::new();
19139 add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19140 add_admin_theme(&mut ctx, tenant.pool()).await;
19141 ctx.insert("items", &items);
19142 ctx.insert("q", &needle);
19143 ctx.insert("filter", filter);
19144 ctx.insert("sort", sort);
19145 ctx.insert("dir", if desc { "desc" } else { "asc" });
19146 ctx.insert("current_page", &page);
19147 ctx.insert("total_pages", &total_pages);
19148 ctx.insert("total", &total);
19149 ctx.insert("count_all", &count_all);
19150 ctx.insert("count_active", &count_active);
19151 ctx.insert("count_disabled", &count_disabled);
19152 ctx.insert("count_stale", &count_stale);
19153 render_with_csrf(&state, &headers, "rcms_admin/redirect_list.html", &mut ctx)
19154}
19155
19156pub async fn redirect_new_form(
19157 State(state): State<super::AdminState>,
19158 tenant: Tenant,
19159 headers: HeaderMap,
19160 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19161) -> Result<Response, AdminError> {
19162 let mut ctx = Context::new();
19163 add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19164 add_admin_theme(&mut ctx, tenant.pool()).await;
19165 ctx.insert("mode", "new");
19166 ctx.insert(
19167 "redirect",
19168 &serde_json::json!({
19169 "from_path": "",
19170 "to_path": "",
19171 "is_permanent": true,
19172 "note": "",
19173 "hit_count": 0,
19174 "overrides_live": false,
19175 "from_page_id": null,
19176 "to_page_id": null,
19177 }),
19178 );
19179 render_with_csrf(&state, &headers, "rcms_admin/redirect_form.html", &mut ctx)
19180}
19181
19182pub async fn redirect_new_submit(
19183 State(_state): State<super::AdminState>,
19184 tenant: Tenant,
19185 headers: HeaderMap,
19186 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19187 Form(form): Form<RedirectForm>,
19188) -> Result<Response, AdminError> {
19189 use rustango::sql::Auto;
19190 let (from, to) = redirect_form_paths(tenant.pool(), &form).await?;
19191 if from.is_empty() || to.is_empty() {
19192 return redirect_named_with_message(
19193 "rcms-admin:redirects:list",
19194 MsgLevel::Error,
19195 "From-path and to-path are both required.",
19196 &headers,
19197 );
19198 }
19199 if let Some(msg) = redirect_pattern_error(&from, &to) {
19200 return redirect_named_with_message(
19201 "rcms-admin:redirects:list",
19202 MsgLevel::Error,
19203 msg,
19204 &headers,
19205 );
19206 }
19207 let overrides_live = form.parsed_overrides_live();
19208 let is_permanent = form.parsed_permanent();
19209 let from_page_id = form.parsed_from_page_id();
19210 let to_page_id = form.parsed_to_page_id();
19211 let mut row = crate::redirect::Redirect {
19212 id: Auto::Unset,
19213 from_path: from,
19214 to_path: to,
19215 is_permanent,
19216 note: form.note.unwrap_or_default().trim().to_owned(),
19217 hit_count: 0,
19218 overrides_live,
19219 from_page_id,
19220 to_page_id,
19221 is_active: true,
19222 disabled_reason: String::new(),
19223 last_hit_at: None,
19224 created_at: Auto::Unset,
19225 updated_at: Auto::Unset,
19226 };
19227 row.insert_pool(tenant.pool()).await?;
19228 redirect_save_response(&tenant, &row, overrides_live, true, &headers).await
19229}
19230
19231async fn redirect_save_response(
19237 tenant: &Tenant,
19238 row: &crate::redirect::Redirect,
19239 overrides_live: bool,
19240 is_new: bool,
19241 headers: &HeaderMap,
19242) -> Result<Response, AdminError> {
19243 let args = &[
19244 ("from", row.from_path.as_str()),
19245 ("to", row.to_path.as_str()),
19246 ];
19247 if overrides_live && crate::redirect::is_wildcard(&row.from_path) {
19248 let key = if is_new {
19249 "Added redirect {from} → {to} — heads up: a wildcard override can shadow many live pages under this pattern. Double-check the pattern."
19250 } else {
19251 "Saved redirect {from} → {to} — heads up: a wildcard override can shadow many live pages under this pattern. Double-check the pattern."
19252 };
19253 return redirect_named_with_message_args(
19254 "rcms-admin:redirects:list",
19255 MsgLevel::Warning,
19256 key,
19257 args,
19258 headers,
19259 );
19260 }
19261 if redirect_is_shadowed(tenant, &row.from_path, overrides_live).await {
19262 let key = if is_new {
19263 "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”)."
19264 } else {
19265 "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”)."
19266 };
19267 return redirect_named_with_message_args(
19268 "rcms-admin:redirects:list",
19269 MsgLevel::Warning,
19270 key,
19271 args,
19272 headers,
19273 );
19274 }
19275 let key = if is_new {
19276 "Added redirect {from} → {to}."
19277 } else {
19278 "Saved redirect {from} → {to}."
19279 };
19280 redirect_named_with_message_args(
19281 "rcms-admin:redirects:list",
19282 MsgLevel::Success,
19283 key,
19284 args,
19285 headers,
19286 )
19287}
19288
19289#[derive(Debug)]
19295struct SnippetImportRow {
19296 slug: String,
19297 title: String,
19298 body_markdown: String,
19299 folder_path: String,
19300 data: serde_json::Map<String, serde_json::Value>,
19301}
19302
19303fn parse_snippet_csv(text: &str) -> Vec<SnippetImportRow> {
19304 let delimiter = if text.contains('\t') { '\t' } else { ',' };
19307 let mut lines = text.lines();
19308 let header = match lines.next() {
19309 Some(h) => h,
19310 None => return Vec::new(),
19311 };
19312 let cols: Vec<String> = header
19313 .split(delimiter)
19314 .map(|s| s.trim().to_ascii_lowercase())
19315 .collect();
19316 let slug_idx = cols.iter().position(|c| c == "slug" || c == "key");
19318 let title_idx = cols.iter().position(|c| c == "title" || c == "name");
19319 let (Some(slug_idx), Some(title_idx)) = (slug_idx, title_idx) else {
19320 return Vec::new();
19321 };
19322 let body_idx = cols
19323 .iter()
19324 .position(|c| c == "body_markdown" || c == "body" || c == "content");
19325 let folder_idx = cols
19326 .iter()
19327 .position(|c| c == "folder_path" || c == "folder" || c == "path");
19328 let mut out = Vec::new();
19329 for raw in lines {
19330 let trimmed = raw.trim();
19331 if trimmed.is_empty() {
19332 continue;
19333 }
19334 let parts: Vec<&str> = trimmed.split(delimiter).map(str::trim).collect();
19335 let slug = parts.get(slug_idx).copied().unwrap_or("");
19336 let title = parts.get(title_idx).copied().unwrap_or("");
19337 if slug.is_empty() || title.is_empty() {
19338 continue;
19339 }
19340 let body_markdown = body_idx
19341 .and_then(|i| parts.get(i))
19342 .copied()
19343 .unwrap_or("")
19344 .to_owned();
19345 let folder_path = folder_idx
19346 .and_then(|i| parts.get(i))
19347 .copied()
19348 .unwrap_or("")
19349 .to_owned();
19350 let mut data = serde_json::Map::new();
19352 for (i, col) in cols.iter().enumerate() {
19353 if Some(i) == Some(slug_idx)
19354 || Some(i) == Some(title_idx)
19355 || Some(i) == body_idx
19356 || Some(i) == folder_idx
19357 {
19358 continue;
19359 }
19360 if col.is_empty() {
19361 continue;
19362 }
19363 let v = parts.get(i).copied().unwrap_or("");
19364 if !v.is_empty() {
19365 data.insert(col.clone(), serde_json::Value::String(v.to_owned()));
19366 }
19367 }
19368 out.push(SnippetImportRow {
19369 slug: slug.to_owned(),
19370 title: title.to_owned(),
19371 body_markdown,
19372 folder_path: crate::snippet::normalize_folder(&folder_path),
19373 data,
19374 });
19375 }
19376 out
19377}
19378
19379pub async fn snippet_import_form(
19381 State(state): State<super::AdminState>,
19382 tenant: Tenant,
19383 headers: HeaderMap,
19384 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19385 Path(type_name): Path<String>,
19386) -> Result<Response, AdminError> {
19387 let mut ctx = Context::new();
19388 add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
19389 add_admin_theme(&mut ctx, tenant.pool()).await;
19390 ctx.insert("type_name", &type_name);
19391 render_with_csrf(&state, &headers, "rcms_admin/snippet_import.html", &mut ctx)
19392}
19393
19394pub async fn snippet_import_submit(
19397 State(_state): State<super::AdminState>,
19398 tenant: Tenant,
19399 headers: HeaderMap,
19400 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19401 Path(type_name): Path<String>,
19402 mut multipart: axum::extract::Multipart,
19403) -> Result<Response, AdminError> {
19404 use rustango::sql::Auto;
19405 let mut bytes: Vec<u8> = Vec::new();
19406 let mut filename = String::new();
19407 while let Some(field) = multipart
19408 .next_field()
19409 .await
19410 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
19411 {
19412 if field.name().unwrap_or("") == "file" {
19413 if let Some(name) = field.file_name() {
19414 filename = name.to_owned();
19415 }
19416 bytes = field
19417 .bytes()
19418 .await
19419 .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
19420 .to_vec();
19421 } else {
19422 let _ = field.bytes().await;
19423 }
19424 }
19425 if bytes.is_empty() {
19426 return redirect_named_with_message(
19427 "rcms-admin:library:list",
19428 MsgLevel::Error,
19429 "No file uploaded.",
19430 &headers,
19431 );
19432 }
19433 let text = String::from_utf8_lossy(&bytes);
19434 let rows = parse_snippet_csv(&text);
19435 let total = rows.len();
19436 if total == 0 {
19437 return redirect_named_with_message(
19438 "rcms-admin:library:list",
19439 MsgLevel::Error,
19440 "Imported 0 snippets — CSV must have a header row with `slug` + `title` columns.",
19441 &headers,
19442 );
19443 }
19444 let mut inserted = 0usize;
19445 let mut skipped = 0usize;
19446 let _ = filename; for row in rows {
19448 let mut snippet = crate::snippet::Snippet {
19449 id: Auto::Unset,
19450 type_name: type_name.clone(),
19451 folder_path: row.folder_path,
19452 slug: row.slug,
19453 title: row.title,
19454 body_markdown: row.body_markdown,
19455 data: serde_json::Value::Object(row.data),
19456 created_at: Auto::Unset,
19457 updated_at: Auto::Unset,
19458 };
19459 match snippet.insert_pool(tenant.pool()).await {
19460 Ok(_) => inserted += 1,
19461 Err(_) => skipped += 1,
19462 }
19463 }
19464 let inserted_str = inserted.to_string();
19465 let total_str = total.to_string();
19466 let skipped_str = skipped.to_string();
19467 redirect_named_with_message_args(
19468 "rcms-admin:library:list",
19469 MsgLevel::Success,
19470 "Imported {inserted}/{total} snippets ({skipped} skipped — likely duplicate slugs).",
19471 &[
19472 ("inserted", inserted_str.as_str()),
19473 ("total", total_str.as_str()),
19474 ("skipped", skipped_str.as_str()),
19475 ],
19476 &headers,
19477 )
19478}
19479
19480pub async fn redirect_import_form(
19482 State(state): State<super::AdminState>,
19483 tenant: Tenant,
19484 headers: HeaderMap,
19485 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19486) -> Result<Response, AdminError> {
19487 let mut ctx = Context::new();
19488 add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19489 add_admin_theme(&mut ctx, tenant.pool()).await;
19490 render_with_csrf(
19491 &state,
19492 &headers,
19493 "rcms_admin/redirect_import.html",
19494 &mut ctx,
19495 )
19496}
19497
19498#[derive(Debug)]
19502struct RedirectImportRow {
19503 from_path: String,
19504 to_path: String,
19505 is_permanent: bool,
19506}
19507
19508fn parse_redirect_csv(text: &str) -> Vec<RedirectImportRow> {
19509 let delimiter = if text.contains('\t') { '\t' } else { ',' };
19514 let mut out = Vec::new();
19515 for (lineno, raw) in text.lines().enumerate() {
19516 let trimmed = raw.trim();
19517 if trimmed.is_empty() {
19518 continue;
19519 }
19520 let parts: Vec<&str> = trimmed.split(delimiter).map(str::trim).collect();
19521 if lineno == 0 {
19524 let h0 = parts.first().copied().unwrap_or("").to_ascii_lowercase();
19525 if h0 == "from_path" || h0 == "from" || h0 == "old" || h0 == "source" {
19526 continue;
19527 }
19528 }
19529 if parts.len() < 2 {
19530 continue;
19531 }
19532 let from = parts[0];
19533 let to = parts[1];
19534 if from.is_empty() || to.is_empty() {
19535 continue;
19536 }
19537 let is_permanent = parts
19538 .get(2)
19539 .map(|s| {
19540 let v = s.to_ascii_lowercase();
19541 !matches!(v.as_str(), "false" | "0" | "302" | "no")
19542 })
19543 .unwrap_or(true);
19544 out.push(RedirectImportRow {
19545 from_path: from.to_owned(),
19546 to_path: to.to_owned(),
19547 is_permanent,
19548 });
19549 }
19550 out
19551}
19552
19553fn redirects_csv(items: &[crate::redirect::Redirect]) -> String {
19557 let mut out = String::from("from_path,to_path,is_permanent\n");
19558 for r in items {
19559 out.push_str(&csv_escape(&r.from_path));
19560 out.push(',');
19561 out.push_str(&csv_escape(&r.to_path));
19562 out.push(',');
19563 out.push_str(if r.is_permanent { "301" } else { "302" });
19564 out.push('\n');
19565 }
19566 out
19567}
19568
19569pub async fn redirect_export_csv(
19572 State(_state): State<super::AdminState>,
19573 tenant: Tenant,
19574 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19575) -> Result<Response, AdminError> {
19576 let items: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
19577 .order_by(&[("from_path", false)])
19578 .fetch(tenant.pool())
19579 .await?;
19580 let body = redirects_csv(&items);
19581 let filename = format!("redirects-{}.csv", chrono::Utc::now().format("%Y%m%d"));
19582 let mut response = ([(header::CONTENT_TYPE, "text/csv; charset=utf-8")], body).into_response();
19583 if let Ok(v) = HeaderValue::from_str(&format!("attachment; filename=\"{filename}\"")) {
19584 response
19585 .headers_mut()
19586 .insert(header::CONTENT_DISPOSITION, v);
19587 }
19588 Ok(response)
19589}
19590
19591#[cfg(test)]
19592mod user_email_column_tests {
19593 use super::user_email;
19594
19595 fn user(email: Option<&str>, data: serde_json::Value) -> rustango::tenancy::auth::User {
19596 rustango::tenancy::auth::User {
19597 id: rustango::sql::Auto::Set(1),
19598 username: "u".into(),
19599 password_hash: String::new(),
19600 email: email.map(ToOwned::to_owned),
19601 is_superuser: false,
19602 active: true,
19603 created_at: chrono::Utc::now(),
19604 data,
19605 password_changed_at: None,
19606 sessions_revoked_at: None,
19607 }
19608 }
19609
19610 #[test]
19611 fn column_first_then_legacy_data_bag() {
19612 assert_eq!(user_email(&user(Some("a@x.example"), serde_json::json!({}))), "a@x.example");
19614 assert_eq!(user_email(&user(None, serde_json::json!({"email": "b@x.example"}))), "b@x.example");
19616 assert_eq!(
19617 user_email(&user(Some("a@x.example"), serde_json::json!({"email": "old@x.example"}))),
19618 "a@x.example"
19619 );
19620 assert_eq!(user_email(&user(Some(" "), serde_json::json!({}))), "");
19621 }
19622}
19623
19624#[cfg(test)]
19625mod translation_canonical_html_tests {
19626 use super::translation_canonical_html;
19627
19628 #[test]
19629 fn rich_text_is_sanitized_html_other_kinds_empty() {
19630 let html = translation_canonical_html("richtext", "<p>A jar</p><script>x()</script>");
19631 assert_eq!(html, "<p>A jar</p>");
19632 assert_eq!(translation_canonical_html("richtext", " "), "");
19633 assert_eq!(translation_canonical_html("textarea", "<p>A jar</p>"), "");
19634 assert_eq!(translation_canonical_html("text", "Moon jar"), "");
19635 }
19636}
19637
19638#[cfg(test)]
19639mod user_email_tests {
19640 use super::validate_optional_email;
19641
19642 #[test]
19643 fn accepts_valid_and_empty() {
19644 assert_eq!(validate_optional_email(Some("a@b.com")).unwrap(), "a@b.com");
19645 assert_eq!(
19646 validate_optional_email(Some(" a@b.com ")).unwrap(),
19647 "a@b.com"
19648 ); assert_eq!(validate_optional_email(None).unwrap(), ""); assert_eq!(validate_optional_email(Some(" ")).unwrap(), ""); }
19652
19653 #[test]
19654 fn rejects_malformed() {
19655 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()); }
19661}
19662
19663#[cfg(test)]
19664mod copy_to_locale_tests {
19665 use super::copy_translatable_fields;
19666
19667 #[test]
19668 fn selects_nonempty_canonical_fields() {
19669 let out = copy_translatable_fields("Home", "", " Welcome ");
19670 assert_eq!(
19672 out,
19673 vec![
19674 ("title", "Home".to_owned()),
19675 ("seo_description", " Welcome ".to_owned()),
19676 ]
19677 );
19678 }
19679
19680 #[test]
19681 fn all_empty_yields_nothing_to_seed() {
19682 assert!(copy_translatable_fields("", " ", "").is_empty());
19683 }
19684}
19685
19686#[cfg(test)]
19687mod redirect_csv_tests {
19688 use super::*;
19689 use rustango::sql::Auto;
19690
19691 fn row(from: &str, to: &str, permanent: bool) -> crate::redirect::Redirect {
19692 crate::redirect::Redirect {
19693 id: Auto::Unset,
19694 from_path: from.to_owned(),
19695 to_path: to.to_owned(),
19696 is_permanent: permanent,
19697 note: String::new(),
19698 hit_count: 0,
19699 overrides_live: false,
19700 from_page_id: None,
19701 to_page_id: None,
19702 is_active: true,
19703 disabled_reason: String::new(),
19704 last_hit_at: None,
19705 created_at: Auto::Unset,
19706 updated_at: Auto::Unset,
19707 }
19708 }
19709
19710 #[test]
19711 fn redirects_csv_header_and_301_302_mapping() {
19712 let csv = redirects_csv(&[row("/old", "/new", true), row("/tmp", "/dst", false)]);
19713 let mut lines = csv.lines();
19714 assert_eq!(lines.next(), Some("from_path,to_path,is_permanent"));
19715 assert_eq!(lines.next(), Some("/old,/new,301"));
19716 assert_eq!(lines.next(), Some("/tmp,/dst,302"));
19717 assert_eq!(lines.next(), None);
19718 }
19719
19720 #[test]
19721 fn redirects_csv_empty_is_header_only() {
19722 assert_eq!(redirects_csv(&[]), "from_path,to_path,is_permanent\n");
19723 }
19724}
19725
19726pub async fn redirect_import_submit(
19729 State(_state): State<super::AdminState>,
19730 tenant: Tenant,
19731 headers: HeaderMap,
19732 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19733 mut multipart: axum::extract::Multipart,
19734) -> Result<Response, AdminError> {
19735 use rustango::sql::Auto;
19736 let mut bytes: Vec<u8> = Vec::new();
19737 let mut filename = String::new();
19738 while let Some(field) = multipart
19739 .next_field()
19740 .await
19741 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
19742 {
19743 if field.name().unwrap_or("") == "file" {
19744 if let Some(name) = field.file_name() {
19745 filename = name.to_owned();
19746 }
19747 bytes = field
19748 .bytes()
19749 .await
19750 .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
19751 .to_vec();
19752 } else {
19753 let _ = field.bytes().await;
19754 }
19755 }
19756 if bytes.is_empty() {
19757 return redirect_named_with_message(
19758 "rcms-admin:redirects:list",
19759 MsgLevel::Error,
19760 "No file uploaded.",
19761 &headers,
19762 );
19763 }
19764 let text = String::from_utf8_lossy(&bytes);
19765 let rows = parse_redirect_csv(&text);
19766 let total = rows.len();
19767 let mut inserted = 0usize;
19768 let mut skipped = 0usize;
19769 for row in rows {
19770 if redirect_pattern_error(&row.from_path, &row.to_path).is_some() {
19771 skipped += 1;
19772 continue;
19773 }
19774 let mut redirect = crate::redirect::Redirect {
19775 id: Auto::Unset,
19776 from_path: row.from_path,
19777 to_path: row.to_path,
19778 is_permanent: row.is_permanent,
19779 note: format!("Imported from {filename}"),
19780 hit_count: 0,
19781 overrides_live: false,
19782 from_page_id: None,
19783 to_page_id: None,
19784 is_active: true,
19785 disabled_reason: String::new(),
19786 last_hit_at: None,
19787 created_at: Auto::Unset,
19788 updated_at: Auto::Unset,
19789 };
19790 match redirect.insert_pool(tenant.pool()).await {
19791 Ok(_) => inserted += 1,
19792 Err(_) => skipped += 1,
19793 }
19794 }
19795 let inserted_str = inserted.to_string();
19796 let total_str = total.to_string();
19797 let skipped_str = skipped.to_string();
19798 redirect_named_with_message_args(
19799 "rcms-admin:redirects:list",
19800 MsgLevel::Success,
19801 "Imported {inserted}/{total} redirects ({skipped} skipped — likely duplicates).",
19802 &[
19803 ("inserted", inserted_str.as_str()),
19804 ("total", total_str.as_str()),
19805 ("skipped", skipped_str.as_str()),
19806 ],
19807 &headers,
19808 )
19809}
19810
19811pub async fn redirect_edit_form(
19812 State(state): State<super::AdminState>,
19813 tenant: Tenant,
19814 headers: HeaderMap,
19815 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19816 Path(id): Path<i64>,
19817) -> Result<Response, AdminError> {
19818 let row = crate::redirect::Redirect::objects()
19819 .where_(crate::redirect::Redirect::id.eq(id))
19820 .first(tenant.pool())
19821 .await?
19822 .ok_or(AdminError::NotFound(id))?;
19823 let mut ctx = Context::new();
19824 add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19825 add_admin_theme(&mut ctx, tenant.pool()).await;
19826 ctx.insert("mode", "edit");
19827 ctx.insert("redirect", &row);
19828 render_with_csrf(&state, &headers, "rcms_admin/redirect_form.html", &mut ctx)
19829}
19830
19831pub async fn redirect_edit_submit(
19832 State(_state): State<super::AdminState>,
19833 tenant: Tenant,
19834 headers: HeaderMap,
19835 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19836 Path(id): Path<i64>,
19837 Form(form): Form<RedirectForm>,
19838) -> Result<Response, AdminError> {
19839 let mut row = crate::redirect::Redirect::objects()
19840 .where_(crate::redirect::Redirect::id.eq(id))
19841 .first(tenant.pool())
19842 .await?
19843 .ok_or(AdminError::NotFound(id))?;
19844 let (from, to) = redirect_form_paths(tenant.pool(), &form).await?;
19845 if from.is_empty() || to.is_empty() {
19846 return redirect_named_with_message(
19847 "rcms-admin:redirects:list",
19848 MsgLevel::Error,
19849 "From-path and to-path are both required.",
19850 &headers,
19851 );
19852 }
19853 if let Some(msg) = redirect_pattern_error(&from, &to) {
19854 return redirect_named_with_message(
19855 "rcms-admin:redirects:list",
19856 MsgLevel::Error,
19857 msg,
19858 &headers,
19859 );
19860 }
19861 row.from_path = from;
19862 row.to_path = to;
19863 row.is_permanent = form.parsed_permanent();
19864 row.overrides_live = form.parsed_overrides_live();
19865 row.from_page_id = form.parsed_from_page_id();
19866 row.to_page_id = form.parsed_to_page_id();
19867 row.note = form.note.unwrap_or_default().trim().to_owned();
19868 row.save_pool(tenant.pool()).await?;
19869 let overrides_live = row.overrides_live;
19870 redirect_save_response(&tenant, &row, overrides_live, false, &headers).await
19871}
19872
19873pub async fn redirect_enable_submit(
19876 State(_state): State<super::AdminState>,
19877 tenant: Tenant,
19878 headers: HeaderMap,
19879 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19880 Path(id): Path<i64>,
19881) -> Result<Response, AdminError> {
19882 let mut row = crate::redirect::Redirect::objects()
19883 .where_(crate::redirect::Redirect::id.eq(id))
19884 .first(tenant.pool())
19885 .await?
19886 .ok_or(AdminError::NotFound(id))?;
19887 row.is_active = true;
19888 row.disabled_reason = String::new();
19889 row.save_pool(tenant.pool()).await?;
19890 redirect_named_with_message_args(
19891 "rcms-admin:redirects:list",
19892 MsgLevel::Success,
19893 "Re-enabled redirect {from} → {to}.",
19894 &[
19895 ("from", row.from_path.as_str()),
19896 ("to", row.to_path.as_str()),
19897 ],
19898 &headers,
19899 )
19900}
19901
19902pub async fn redirect_delete_submit(
19903 State(_state): State<super::AdminState>,
19904 tenant: Tenant,
19905 headers: HeaderMap,
19906 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19907 Path(id): Path<i64>,
19908) -> Result<Response, AdminError> {
19909 let row = crate::redirect::Redirect::objects()
19910 .where_(crate::redirect::Redirect::id.eq(id))
19911 .first(tenant.pool())
19912 .await?
19913 .ok_or(AdminError::NotFound(id))?;
19914 let label = format!("{} → {}", row.from_path, row.to_path);
19915 row.delete_pool(tenant.pool()).await?;
19916 redirect_named_with_message_args(
19917 "rcms-admin:redirects:list",
19918 MsgLevel::Success,
19919 "Deleted redirect {label}.",
19920 &[("label", label.as_str())],
19921 &headers,
19922 )
19923}
19924
19925pub(crate) fn creatable_types(all: &[PageType]) -> Vec<PageType> {
19935 all.iter()
19936 .filter(|t| {
19937 find_handler(&t.type_name)
19938 .map(|h| h.is_creatable())
19939 .unwrap_or(t.is_creatable)
19940 })
19941 .cloned()
19942 .collect()
19943}
19944
19945pub(crate) fn allowed_root_types(all: &[PageType]) -> Vec<PageType> {
19954 creatable_types(all)
19955 .into_iter()
19956 .filter(|t| t.allowed_parents().is_empty())
19957 .collect()
19958}
19959
19960pub(crate) fn allowed_children_for(parent: &Page, all: &[PageType]) -> Vec<PageType> {
19965 let parent_row = all
19966 .iter()
19967 .find(|t| t.id.get().copied() == Some(parent.page_type_id));
19968 let parent_type_name = parent_row.map(|t| t.type_name.clone()).unwrap_or_default();
19969 let parent_allowed_children = parent_row.map(PageType::allowed_children).unwrap_or_default();
19971
19972 creatable_types(all)
19973 .into_iter()
19974 .filter(|cand| {
19975 if !parent_allowed_children.is_empty()
19977 && !parent_allowed_children.iter().any(|t| t == &cand.type_name)
19978 {
19979 return false;
19980 }
19981 let allowed_parents = cand.allowed_parents();
19983 allowed_parents.is_empty() || allowed_parents.iter().any(|p| *p == parent_type_name)
19984 })
19985 .collect()
19986}
19987
19988fn empty_page_form_values() -> serde_json::Value {
19991 serde_json::json!({
19992 "title": "",
19993 "slug": "",
19994 "page_type_id": 0,
19995 "status": "draft",
19996 "seo_title": "",
19997 "seo_description": "",
19998 "robots_index": true,
19999 "sitemap_priority": 0.5,
20000 "show_in_menus": true,
20001 "go_live_at": serde_json::Value::Null,
20002 "expire_at": serde_json::Value::Null,
20003 "og_title": "",
20004 "og_description": "",
20005 "og_image_media_id": serde_json::Value::Null,
20006 "twitter_card": "summary_large_image",
20007 })
20008}
20009
20010pub async fn cms_logout_submit() -> Response {
20037 let mut resp = Redirect::to("/login").into_response();
20038 let cookies = [
20042 "rustango_admin_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20043 "rustango_tenant_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20044 "rustango_op_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20045 ];
20046 for c in cookies {
20047 if let Ok(v) = HeaderValue::from_str(c) {
20048 resp.headers_mut().append(header::SET_COOKIE, v);
20049 }
20050 }
20051 resp
20052}
20053
20054pub async fn no_access_page(
20065 State(state): State<super::AdminState>,
20066 headers: HeaderMap,
20067 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
20068) -> Result<Response, AdminError> {
20069 let mut ctx = Context::new();
20070 ctx.insert("admin_title", &"CMS Admin");
20071 render_with_csrf(&state, &headers, "rcms_admin/no_access.html", &mut ctx)
20072}
20073
20074pub async fn dismissible_submit(
20083 State(_state): State<super::AdminState>,
20084 tenant: Tenant,
20085 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20086 Path(key): Path<String>,
20087) -> Result<Response, AdminError> {
20088 let Some(viewer) = session_user.as_ref() else {
20089 return Ok(unauthorized_no_session());
20090 };
20091 let viewer_id = viewer.id.get().copied().unwrap_or_default();
20092 crate::dismissible::dismiss(tenant.pool(), viewer_id, &key).await?;
20093 Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
20094}
20095
20096pub async fn dashboard(
20101 State(state): State<super::AdminState>,
20102 tenant: Tenant,
20103 headers: HeaderMap,
20104 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20105) -> Result<Response, AdminError> {
20106 let pool = tenant.pool();
20107 let viewer_id = session_user.as_ref().and_then(|u| u.id.get().copied());
20108
20109 let all_pages: Vec<Page> = Page::objects().fetch(pool).await.unwrap_or_default();
20111 let mut count_drafts = 0usize;
20112 let mut count_published = 0usize;
20113 let mut count_scheduled = 0usize;
20114 let mut count_archived = 0usize;
20115 for p in &all_pages {
20116 match p.status.as_str() {
20117 "draft" => count_drafts += 1,
20118 "published" => count_published += 1,
20119 "scheduled" => count_scheduled += 1,
20120 "archived" => count_archived += 1,
20121 _ => {}
20122 }
20123 }
20124 let snippet_count: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
20125 .fetch(pool)
20126 .await
20127 .unwrap_or_default();
20128 let media_rows: Vec<Media> = Media::objects().fetch(pool).await.unwrap_or_default();
20129 let media_images = media_rows.iter().filter(|m| m.kind == "image").count();
20130 let media_docs = media_rows.len() - media_images;
20131
20132 let revs: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
20134 .order_by(&[("created_at", true)]) .limit(10)
20136 .fetch(pool)
20137 .await
20138 .unwrap_or_default();
20139 let user_ids: std::collections::BTreeSet<i64> = revs.iter().filter_map(|r| r.created_by).collect();
20141 let usernames: std::collections::HashMap<i64, String> = if user_ids.is_empty() {
20142 std::collections::HashMap::new()
20143 } else {
20144 rustango::tenancy::auth::User::objects()
20145 .where_(rustango::tenancy::auth::User::id.is_in(user_ids.into_iter()))
20146 .fetch(pool)
20147 .await
20148 .unwrap_or_default()
20149 .into_iter()
20150 .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
20151 .collect()
20152 };
20153 let page_by_id: std::collections::HashMap<i64, &Page> = all_pages
20154 .iter()
20155 .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
20156 .collect();
20157 let recent_edits: Vec<serde_json::Value> = revs
20158 .iter()
20159 .filter_map(|r| {
20160 let p = page_by_id.get(&r.page_id)?;
20161 Some(serde_json::json!({
20162 "page_id": r.page_id,
20163 "title": p.title,
20164 "url_path": p.url_path,
20165 "sequence": r.sequence,
20166 "created_at": r.created_at.get().copied(),
20167 "created_by": r.created_by.and_then(|id| usernames.get(&id).cloned()),
20168 }))
20169 })
20170 .collect();
20171
20172 let locks: Vec<crate::lock::PageLock> = crate::lock::PageLock::objects()
20174 .fetch(pool)
20175 .await
20176 .unwrap_or_default();
20177 let now = chrono::Utc::now();
20178 let mine_locked: Vec<serde_json::Value> = locks
20179 .iter()
20180 .filter(|l| !l.is_stale(now))
20181 .filter(|l| Some(l.user_id) == viewer_id)
20182 .filter_map(|l| {
20183 let p = page_by_id.get(&l.page_id)?;
20184 Some(serde_json::json!({
20185 "page_id": l.page_id,
20186 "title": p.title,
20187 "url_path": p.url_path,
20188 "acquired_at": l.acquired_at.get().copied(),
20189 }))
20190 })
20191 .collect();
20192
20193 let mut review_rows: Vec<serde_json::Value> = Vec::new();
20198 if let Some(viewer) = session_user.as_ref() {
20199 let states: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
20200 .where_(crate::workflow::WorkflowState::status.eq(crate::workflow::WorkflowStatus::InProgress.as_str().to_owned()))
20201 .fetch(pool)
20202 .await
20203 .unwrap_or_default();
20204 if !states.is_empty() {
20205 let my_roles: std::collections::BTreeSet<i64> = rustango::tenancy::permissions::UserRole::objects()
20206 .where_(rustango::tenancy::permissions::UserRole::user_id.eq(viewer_id.unwrap_or_default()))
20207 .fetch(pool)
20208 .await
20209 .unwrap_or_default()
20210 .into_iter()
20211 .map(|m| m.role_id)
20212 .collect();
20213 let task_ids: Vec<i64> = states.iter().filter_map(|st| st.current_task_id).collect();
20214 let tasks: std::collections::HashMap<i64, crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
20215 .where_(crate::workflow::WorkflowTask::id.is_in(task_ids.into_iter()))
20216 .fetch(pool)
20217 .await
20218 .unwrap_or_default()
20219 .into_iter()
20220 .filter_map(|t| t.id.get().copied().map(|id| (id, t)))
20221 .collect();
20222 for st in &states {
20223 let Some(task) = st.current_task_id.and_then(|id| tasks.get(&id)) else { continue };
20224 if !viewer.is_superuser && !my_roles.contains(&task.role_id) {
20225 continue;
20226 }
20227 let Some(p) = page_by_id.get(&st.page_id) else { continue };
20228 review_rows.push(serde_json::json!({
20229 "page_id": st.page_id,
20230 "title": p.title,
20231 "url_path": p.url_path,
20232 "step": task.name,
20233 "requested_at": st.requested_at.get().copied(),
20234 }));
20235 }
20236 }
20237 }
20238
20239 let mut scheduled: Vec<&Page> = all_pages
20241 .iter()
20242 .filter(|p| {
20243 p.status == "scheduled" && p.go_live_at.is_some() && p.go_live_at.unwrap() > now
20244 })
20245 .collect();
20246 scheduled.sort_by_key(|p| p.go_live_at);
20247 scheduled.truncate(5);
20248 let scheduled_rows: Vec<serde_json::Value> = scheduled
20249 .into_iter()
20250 .map(|p| {
20251 serde_json::json!({
20252 "page_id": p.id.get().copied().unwrap_or_default(),
20253 "title": p.title,
20254 "url_path": p.url_path,
20255 "go_live_at": p.go_live_at,
20256 })
20257 })
20258 .collect();
20259
20260 let plugin_widgets: Vec<serde_json::Value> = crate::hooks::dashboard_widgets()
20262 .into_iter()
20263 .map(|w| {
20264 serde_json::json!({
20265 "key": w.key,
20266 "label": w.label,
20267 "icon": w.icon,
20268 "html": w.html,
20269 })
20270 })
20271 .collect();
20272
20273 let mut ctx = Context::new();
20274 add_chrome(&mut ctx, &tenant, "dashboard", session_user.as_ref()).await;
20275 add_admin_theme(&mut ctx, tenant.pool()).await;
20276 ctx.insert("review_rows", &review_rows);
20277 ctx.insert("count_drafts", &count_drafts);
20278 ctx.insert("count_published", &count_published);
20279 ctx.insert("count_scheduled", &count_scheduled);
20280 ctx.insert("count_archived", &count_archived);
20281 ctx.insert("count_snippets", &snippet_count.len());
20282 ctx.insert("count_images", &media_images);
20283 ctx.insert("count_documents", &media_docs);
20284 ctx.insert("recent_edits", &recent_edits);
20285 ctx.insert("mine_locked", &mine_locked);
20286 ctx.insert("scheduled_rows", &scheduled_rows);
20287 ctx.insert("plugin_widgets", &plugin_widgets);
20288 render_with_csrf(&state, &headers, "rcms_admin/dashboard.html", &mut ctx)
20289}
20290
20291pub async fn styleguide(
20294 State(state): State<super::AdminState>,
20295 tenant: Tenant,
20296 headers: HeaderMap,
20297 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20298) -> Result<Response, AdminError> {
20299 let mut ctx = Context::new();
20300 add_chrome(&mut ctx, &tenant, "styleguide", session_user.as_ref()).await;
20301 add_admin_theme(&mut ctx, tenant.pool()).await;
20302
20303 let blocks: Vec<serde_json::Value> = crate::block::registered_blocks()
20307 .map(|b| {
20308 serde_json::json!({
20309 "type_name": b.type_name(),
20310 "verbose_name": b.verbose_name(),
20311 "icon": b.icon(),
20312 "group": b.group(),
20313 "field_count": b.fields().len(),
20314 })
20315 })
20316 .collect();
20317 ctx.insert("blocks", &blocks);
20318
20319 let page_types: Vec<serde_json::Value> = crate::page_type::registered_handlers()
20321 .map(|h| {
20322 serde_json::json!({
20323 "type_name": h.type_name(),
20324 "verbose_name": h.verbose_name(),
20325 "icon": h.icon(),
20326 "description": h.description(),
20327 })
20328 })
20329 .collect();
20330 ctx.insert("page_types", &page_types);
20331
20332 let library_types: Vec<serde_json::Value> = crate::library::registered_handlers()
20334 .map(|h| {
20335 serde_json::json!({
20336 "type_name": h.type_name(),
20337 "verbose_name": h.verbose_name(),
20338 })
20339 })
20340 .collect();
20341 ctx.insert("library_types", &library_types);
20342
20343 render_with_csrf(&state, &headers, "rcms_admin/styleguide.html", &mut ctx)
20344}
20345
20346pub async fn account_preferences(
20347 State(state): State<super::AdminState>,
20348 tenant: Tenant,
20349 headers: HeaderMap,
20350 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20351) -> Result<Response, AdminError> {
20352 render_account_page(&state, &tenant, &headers, session_user.as_ref(), None).await
20353}
20354
20355async fn mcp_keys_ctx(
20358 pool: &rustango::sql::Pool,
20359 owner_id: i64,
20360) -> (Vec<serde_json::Value>, Vec<serde_json::Value>) {
20361 use rustango::tenancy::{AgentGrant, AgentSkill};
20362
20363 let keys = rustango::tenancy::list_user_keys_pool(pool, owner_id)
20364 .await
20365 .unwrap_or_default();
20366 let skills: Vec<AgentSkill> = rustango::tenancy::list_skills_pool(pool)
20367 .await
20368 .unwrap_or_default();
20369 let skill_name = |sid: i64| -> Option<String> {
20370 skills
20371 .iter()
20372 .find(|s| s.id.get().copied() == Some(sid))
20373 .map(|s| s.codename.clone())
20374 };
20375 let mut rows = Vec::with_capacity(keys.len());
20376 for key in &keys {
20377 let key_id = key.id.get().copied().unwrap_or_default();
20378 let grants: Vec<AgentGrant> = AgentGrant::objects()
20379 .where_(AgentGrant::agent_id.eq(key_id))
20380 .fetch(pool)
20381 .await
20382 .unwrap_or_default();
20383 let scope: Vec<String> = grants
20384 .iter()
20385 .filter_map(|g| skill_name(g.skill_id))
20386 .collect();
20387 rows.push(serde_json::json!({
20388 "id": key_id,
20389 "label": key.data.get("label").and_then(|v| v.as_str()).unwrap_or(&key.name),
20390 "prefix": key.secret_prefix,
20391 "active": key.active,
20392 "created_at": key.created_at.get().map(|t| t.format("%Y-%m-%d %H:%M").to_string()),
20393 "scope": scope,
20394 }));
20395 }
20396 let skill_rows: Vec<serde_json::Value> = skills
20397 .iter()
20398 .map(|s| {
20399 serde_json::json!({
20400 "codename": s.codename,
20401 "name": s.name,
20402 "description": s.description,
20403 })
20404 })
20405 .collect();
20406 (rows, skill_rows)
20407}
20408
20409async fn render_account_page(
20410 state: &super::AdminState,
20411 tenant: &Tenant,
20412 headers: &HeaderMap,
20413 session_user: Option<&rustango::tenancy::auth::User>,
20414 mcp_one_time: Option<serde_json::Value>,
20415) -> Result<Response, AdminError> {
20416 let (current_email, pending_email, mailer_wired) = {
20419 let mailer = state.mailer.is_some();
20420 let user_data = session_user
20421 .map(|u| u.data.clone())
20422 .unwrap_or_else(|| serde_json::json!({}));
20423 let cur = session_user.map(user_email).unwrap_or_default();
20424 let pending = user_data
20425 .get("pending_email")
20426 .and_then(|v| v.as_str())
20427 .unwrap_or("")
20428 .to_owned();
20429 (cur, pending, mailer)
20430 };
20431 let mut ctx = Context::new();
20432 add_chrome(&mut ctx, tenant, "", session_user).await;
20433 add_admin_theme(&mut ctx, tenant.pool()).await;
20434 let themes: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
20438 .order_by(&[("name", false)])
20439 .fetch(tenant.pool())
20440 .await
20441 .unwrap_or_default();
20442 let theme_rows: Vec<serde_json::Value> = themes
20443 .iter()
20444 .map(|t| {
20445 serde_json::json!({
20446 "id": t.id.get().copied(),
20447 "name": t.name,
20448 "slug": t.slug,
20449 "is_admin_default": t.is_admin_default,
20450 "color_bg": t.color_bg,
20451 "color_surface": t.color_surface,
20452 "color_text_primary": t.color_text_primary,
20453 "color_link": t.color_link,
20454 })
20455 })
20456 .collect();
20457 ctx.insert("themes", &theme_rows);
20458 let account_panels: Vec<serde_json::Value> = crate::hooks::account_settings_panels()
20461 .into_iter()
20462 .map(|p| {
20463 serde_json::json!({
20464 "key": p.key,
20465 "label": p.label,
20466 "icon": p.icon,
20467 "html": p.html,
20468 })
20469 })
20470 .collect();
20471 ctx.insert("account_panels", &account_panels);
20472
20473 let pref_map = session_user
20478 .and_then(|u| u.id.get().copied())
20479 .map(|uid| crate::notification_pref::map_for_user(tenant.pool(), uid))
20480 .map(|fut| async move { fut.await.unwrap_or_default() });
20481 let pref_lookup: std::collections::HashMap<String, bool> = match pref_map {
20482 Some(f) => f.await,
20483 None => std::collections::HashMap::new(),
20484 };
20485 let notification_rows: Vec<serde_json::Value> = crate::notification_pref::ALL_KINDS
20486 .iter()
20487 .map(|(label, kind, hint)| {
20488 let enabled = pref_lookup.get(*kind).copied().unwrap_or(true);
20489 serde_json::json!({
20490 "label": label,
20491 "kind": kind,
20492 "hint": hint,
20493 "enabled": enabled,
20494 })
20495 })
20496 .collect();
20497 ctx.insert("notification_prefs", ¬ification_rows);
20498
20499 ctx.insert("account_email", ¤t_email);
20500 ctx.insert("account_pending_email", &pending_email);
20501 ctx.insert("account_mailer_wired", &mailer_wired);
20502
20503 if let Some(uid) = session_user.and_then(|u| u.id.get().copied()) {
20507 let (keys, skills) = mcp_keys_ctx(tenant.pool(), uid).await;
20508 ctx.insert("mcp_keys", &keys);
20509 ctx.insert("mcp_skills", &skills);
20510 }
20511 if let Some(one_time) = &mcp_one_time {
20512 ctx.insert("mcp_one_time", one_time);
20513 }
20514
20515 render_with_csrf(
20516 state,
20517 headers,
20518 "rcms_admin/account_preferences.html",
20519 &mut ctx,
20520 )
20521}
20522
20523pub async fn account_notifications_submit(
20528 State(_state): State<super::AdminState>,
20529 tenant: Tenant,
20530 headers: HeaderMap,
20531 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20532 Form(form): Form<std::collections::HashMap<String, String>>,
20533) -> Result<Response, AdminError> {
20534 let Some(viewer) = session_user.as_ref() else {
20535 return Ok(unauthorized_no_session());
20536 };
20537 let Some(uid) = viewer.id.get().copied() else {
20538 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20539 };
20540 for (_label, kind, _hint) in crate::notification_pref::ALL_KINDS {
20541 let key = format!("kind_{kind}");
20542 let enabled = form
20543 .get(&key)
20544 .map(|v| matches!(v.as_str(), "on" | "true" | "1" | "yes"))
20545 .unwrap_or(false);
20546 crate::notification_pref::set_enabled(tenant.pool(), uid, kind, enabled).await?;
20547 }
20548 redirect_named_with_params_and_message(
20549 "rcms-admin:account",
20550 &[],
20551 MsgLevel::Success,
20552 "Notification preferences saved.",
20553 &headers,
20554 )
20555}
20556
20557pub async fn account_profile_submit(
20564 State(_state): State<super::AdminState>,
20565 tenant: Tenant,
20566 headers: HeaderMap,
20567 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20568 mut multipart: axum::extract::Multipart,
20569) -> Result<Response, AdminError> {
20570 let Some(viewer) = session_user.as_ref() else {
20571 return Ok(unauthorized_no_session());
20572 };
20573 let Some(uid) = viewer.id.get().copied() else {
20574 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20575 };
20576
20577 let mut new_display_name: Option<String> = None;
20578 let mut new_avatar_path: Option<String> = None;
20579 let avatar_dir = std::path::PathBuf::from("./var/avatars").join(&tenant.org.slug);
20583
20584 while let Some(field) = multipart
20585 .next_field()
20586 .await
20587 .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
20588 {
20589 let field_name = field.name().unwrap_or("").to_owned();
20590 match field_name.as_str() {
20591 "display_name" => {
20592 new_display_name = Some(
20593 field
20594 .text()
20595 .await
20596 .map_err(|e| AdminError::Upload(format!("read display_name: {e}")))?
20597 .trim()
20598 .to_owned(),
20599 );
20600 }
20601 "avatar" => {
20602 let original = field.file_name().map(|s| s.to_owned());
20603 let bytes = field
20604 .bytes()
20605 .await
20606 .map_err(|e| AdminError::Upload(format!("read avatar: {e}")))?;
20607 if bytes.is_empty() {
20608 continue;
20609 }
20610 let ext = original
20611 .as_deref()
20612 .and_then(|n| n.rsplit_once('.'))
20613 .map(|(_, ext)| ext)
20614 .filter(|ext| ext.len() <= 8 && ext.chars().all(|c| c.is_ascii_alphanumeric()))
20615 .map(str::to_ascii_lowercase)
20616 .unwrap_or_else(|| "png".to_owned());
20617 std::fs::create_dir_all(&avatar_dir)
20618 .map_err(|e| AdminError::Upload(format!("create avatar dir: {e}")))?;
20619 let storage_name = format!("{uid}.{ext}");
20620 let path = avatar_dir.join(&storage_name);
20621 std::fs::write(&path, &bytes)
20622 .map_err(|e| AdminError::Upload(format!("write avatar: {e}")))?;
20623 new_avatar_path = Some(storage_name);
20624 }
20625 _ => {
20626 let _ = field.bytes().await;
20627 }
20628 }
20629 }
20630
20631 let mut user_rows: Vec<rustango::tenancy::auth::User> =
20635 rustango::tenancy::auth::User::objects()
20636 .where_(rustango::tenancy::auth::User::id.eq(uid))
20637 .fetch(tenant.pool())
20638 .await?;
20639 let Some(mut user) = user_rows.pop() else {
20640 return Ok((axum::http::StatusCode::NOT_FOUND, "user not found").into_response());
20641 };
20642
20643 let mut data = user.data.as_object().cloned().unwrap_or_default();
20644 if let Some(name) = new_display_name {
20645 if name.is_empty() {
20646 data.remove("display_name");
20647 } else {
20648 data.insert("display_name".to_owned(), serde_json::json!(name));
20649 }
20650 }
20651 if let Some(path) = new_avatar_path {
20652 data.insert("avatar_path".to_owned(), serde_json::json!(path));
20653 }
20654 user.data = serde_json::Value::Object(data);
20655 user.save_pool(tenant.pool()).await?;
20656
20657 redirect_named_with_message(
20658 "rcms-admin:account",
20659 MsgLevel::Success,
20660 "Profile saved.",
20661 &headers,
20662 )
20663}
20664
20665async fn persist_user_admin_lang(
20669 pool: &rustango::sql::Pool,
20670 uid: i64,
20671 lang: &str,
20672) -> Result<(), AdminError> {
20673 let mut rows: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
20674 .where_(rustango::tenancy::auth::User::id.eq(uid))
20675 .fetch(pool)
20676 .await?;
20677 if let Some(mut user) = rows.pop() {
20678 let mut data = user.data.as_object().cloned().unwrap_or_default();
20679 data.insert("admin_lang".to_owned(), serde_json::json!(lang));
20680 user.data = serde_json::Value::Object(data);
20681 user.save_pool(pool).await?;
20682 }
20683 Ok(())
20684}
20685
20686#[derive(Debug, Deserialize)]
20688pub struct AccountLanguageForm {
20689 pub lang: String,
20690}
20691
20692pub async fn account_language_submit(
20698 State(_state): State<super::AdminState>,
20699 tenant: Tenant,
20700 headers: HeaderMap,
20701 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20702 Form(form): Form<AccountLanguageForm>,
20703) -> Result<Response, AdminError> {
20704 let Some(viewer) = session_user.as_ref() else {
20705 return Ok(unauthorized_no_session());
20706 };
20707 let Some(uid) = viewer.id.get().copied() else {
20708 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20709 };
20710 let lang = if super::i18n::is_ui_locale(&form.lang) {
20711 form.lang.clone()
20712 } else {
20713 "en".to_owned()
20714 };
20715 persist_user_admin_lang(tenant.pool(), uid, &lang).await?;
20716
20717 let mut resp = redirect_named_with_message(
20718 "rcms-admin:account",
20719 MsgLevel::Success,
20720 "Language updated.",
20721 &headers,
20722 )?;
20723 let cookie = format!(
20724 "{}={lang}; Path=/; SameSite=Lax; Max-Age=31536000",
20725 super::i18n::ADMIN_LANG_COOKIE
20726 );
20727 if let Ok(v) = HeaderValue::from_str(&cookie) {
20728 resp.headers_mut().append(header::SET_COOKIE, v);
20729 }
20730 Ok(resp)
20731}
20732
20733#[derive(Debug, Deserialize)]
20735pub struct AccountEmailForm {
20736 pub new_email: String,
20737}
20738
20739pub async fn account_email_submit(
20749 State(state): State<super::AdminState>,
20750 tenant: Tenant,
20751 headers: HeaderMap,
20752 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20753 Form(form): Form<AccountEmailForm>,
20754) -> Result<Response, AdminError> {
20755 let Some(viewer) = session_user.as_ref() else {
20756 return Ok(unauthorized_no_session());
20757 };
20758 let Some(uid) = viewer.id.get().copied() else {
20759 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20760 };
20761
20762 let new_email = form.new_email.trim().to_owned();
20763 if new_email.is_empty() || !new_email.contains('@') {
20764 return redirect_named_with_message(
20765 "rcms-admin:account",
20766 MsgLevel::Error,
20767 "Enter a valid email address.",
20768 &headers,
20769 );
20770 }
20771
20772 let mut user = rustango::tenancy::auth::User::objects()
20773 .where_(rustango::tenancy::auth::User::id.eq(uid))
20774 .first(tenant.pool())
20775 .await?
20776 .ok_or(AdminError::NotFound(uid))?;
20777 let mut data = user.data.as_object().cloned().unwrap_or_default();
20778
20779 if state.mailer.is_none() {
20780 data.insert("email".to_owned(), serde_json::json!(new_email));
20782 user.email = Some(new_email.clone());
20783 data.remove("pending_email");
20785 user.data = serde_json::Value::Object(data);
20786 user.save_pool(tenant.pool()).await?;
20787 return redirect_named_with_message(
20788 "rcms-admin:account",
20789 MsgLevel::Warning,
20790 "Email updated. No confirmation email was sent — the host hasn't wired a mailer.",
20791 &headers,
20792 );
20793 }
20794
20795 data.insert(
20801 "pending_email".to_owned(),
20802 serde_json::json!(new_email.clone()),
20803 );
20804 data.remove("pending_email_token");
20805 data.remove("pending_email_expires_at");
20806 user.data = serde_json::Value::Object(data);
20807 user.save_pool(tenant.pool()).await?;
20808
20809 if let Some(mailer) = state.mailer.as_deref() {
20814 let link = rustango::auth_flows::EmailVerification::issue(
20815 "/cms-admin/me/email/confirm",
20816 uid,
20817 &new_email,
20818 state.signing_secret.as_slice(),
20819 std::time::Duration::from_secs(3600),
20820 );
20821 let subject = "Confirm your CMS email change";
20822 let body = format!(
20823 "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",
20824 );
20825 let email = rustango::email::Email::new()
20826 .from((*state.mailer_from).clone())
20827 .to(new_email.clone())
20828 .subject(subject.to_owned())
20829 .body(body);
20830 if let Err(e) = mailer.send(&email).await {
20831 tracing::warn!(
20832 target: "rustango_cms::admin::account",
20833 user_id = uid, error = %e,
20834 "email-change confirmation send failed (pending_email stashed; user can re-request)"
20835 );
20836 }
20837 }
20838
20839 redirect_named_with_message(
20840 "rcms-admin:account",
20841 MsgLevel::Success,
20842 "Confirmation link sent to the new email. Click it within an hour to finalize the change.",
20843 &headers,
20844 )
20845}
20846
20847pub async fn account_email_confirm(
20854 State(state): State<super::AdminState>,
20855 tenant: Tenant,
20856 headers: HeaderMap,
20857 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20858 axum::extract::OriginalUri(uri): axum::extract::OriginalUri,
20859) -> Result<Response, AdminError> {
20860 let Some(viewer) = session_user.as_ref() else {
20861 return Ok(unauthorized_no_session());
20862 };
20863 let Some(uid) = viewer.id.get().copied() else {
20864 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20865 };
20866
20867 let path_and_query = uri
20868 .path_and_query()
20869 .map(|p| p.as_str())
20870 .unwrap_or_default()
20871 .to_owned();
20872 let (token_uid, signed_email) = match rustango::auth_flows::EmailVerification::verify(
20873 &path_and_query,
20874 state.signing_secret.as_slice(),
20875 ) {
20876 Ok(pair) => pair,
20877 Err(_) => {
20878 return redirect_named_with_message(
20879 "rcms-admin:account",
20880 MsgLevel::Error,
20881 "Confirmation link is invalid or has expired. Request a new one.",
20882 &headers,
20883 );
20884 }
20885 };
20886 if token_uid != uid {
20892 return redirect_named_with_message(
20893 "rcms-admin:account",
20894 MsgLevel::Error,
20895 "Confirmation link belongs to a different account. Sign in as that account to confirm.",
20896 &headers,
20897 );
20898 }
20899
20900 let mut user = rustango::tenancy::auth::User::objects()
20901 .where_(rustango::tenancy::auth::User::id.eq(uid))
20902 .first(tenant.pool())
20903 .await?
20904 .ok_or(AdminError::NotFound(uid))?;
20905 let mut data = user.data.as_object().cloned().unwrap_or_default();
20906 let pending = data
20910 .get("pending_email")
20911 .and_then(|v| v.as_str())
20912 .unwrap_or("");
20913 if pending != signed_email {
20914 return redirect_named_with_message(
20915 "rcms-admin:account",
20916 MsgLevel::Error,
20917 "This link is for a different email change than the one currently pending. Request a fresh confirmation.",
20918 &headers,
20919 );
20920 }
20921
20922 data.insert("email".to_owned(), serde_json::json!(signed_email));
20923 user.email = Some(signed_email.clone());
20924 data.remove("pending_email");
20925 data.remove("pending_email_token");
20928 data.remove("pending_email_expires_at");
20929 user.data = serde_json::Value::Object(data);
20930 user.save_pool(tenant.pool()).await?;
20931
20932 redirect_named_with_message(
20933 "rcms-admin:account",
20934 MsgLevel::Success,
20935 "Email confirmed. Notifications go to the new address from now on.",
20936 &headers,
20937 )
20938}
20939
20940#[derive(Deserialize)]
20942pub struct AccountPasswordForm {
20943 pub current_password: String,
20944 pub new_password: String,
20945 pub new_password_confirm: String,
20946}
20947
20948pub async fn account_password_submit(
20951 State(_state): State<super::AdminState>,
20952 tenant: Tenant,
20953 headers: HeaderMap,
20954 rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20955 Form(form): Form<AccountPasswordForm>,
20956) -> Result<Response, AdminError> {
20957 let Some(viewer) = session_user.as_ref() else {
20958 return Ok(unauthorized_no_session());
20959 };
20960 let Some(uid) = viewer.id.get().copied() else {
20961 return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20962 };
20963 if form.new_password.len() < 12 {
20964 return redirect_named_with_message(
20965 "rcms-admin:account",
20966 MsgLevel::Error,
20967 "New password must be at least 12 characters.",
20968 &headers,
20969 );
20970 }
20971 if form.new_password != form.new_password_confirm {
20972 return redirect_named_with_message(
20973 "rcms-admin:account",
20974 MsgLevel::Error,
20975 "New password and confirmation don't match.",
20976 &headers,
20977 );
20978 }
20979
20980 let mut user = rustango::tenancy::auth::User::objects()
20981 .where_(rustango::tenancy::auth::User::id.eq(uid))
20982 .first(tenant.pool())
20983 .await?
20984 .ok_or(AdminError::NotFound(uid))?;
20985
20986 let verified =
20987 crate::passwords::verify(&form.current_password, &user.password_hash).await.unwrap_or(false);
20988 if !verified {
20989 return redirect_named_with_message(
20990 "rcms-admin:account",
20991 MsgLevel::Error,
20992 "Current password is incorrect.",
20993 &headers,
20994 );
20995 }
20996 let hash = crate::passwords::hash(&form.new_password).await
20997 .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
20998 user.password_hash = hash;
20999 user.password_changed_at = Some(chrono::Utc::now());
21000 user.save_pool(tenant.pool()).await?;
21001
21002 redirect_named_with_message(
21003 "rcms-admin:account",
21004 MsgLevel::Success,
21005 "Password changed. Old sessions on other devices will be signed out on next request.",
21006 &headers,
21007 )
21008}
21009
21010pub async fn account_avatar_serve(
21014 headers: HeaderMap,
21015 tenant: Tenant,
21016 Path(user_id): Path<i64>,
21017) -> Response {
21018 let user_rows: Vec<rustango::tenancy::auth::User> =
21019 match rustango::tenancy::auth::User::objects()
21020 .where_(rustango::tenancy::auth::User::id.eq(user_id))
21021 .fetch(tenant.pool())
21022 .await
21023 {
21024 Ok(v) => v,
21025 Err(_) => {
21026 return (
21027 axum::http::StatusCode::INTERNAL_SERVER_ERROR,
21028 "user lookup failed",
21029 )
21030 .into_response();
21031 }
21032 };
21033 let Some(user) = user_rows.into_iter().next() else {
21034 return (axum::http::StatusCode::NOT_FOUND, "user not found").into_response();
21035 };
21036 let storage_name = match user.data.get("avatar_path").and_then(|v| v.as_str()) {
21037 Some(s) if !s.is_empty() => s.to_owned(),
21038 _ => return (axum::http::StatusCode::NOT_FOUND, "no avatar").into_response(),
21039 };
21040 if storage_name.contains('/') || storage_name.contains("..") {
21041 return (axum::http::StatusCode::BAD_REQUEST, "invalid storage name").into_response();
21042 }
21043 let path = std::path::PathBuf::from("./var/avatars")
21046 .join(&tenant.org.slug)
21047 .join(&storage_name);
21048 let bytes = match std::fs::read(&path) {
21049 Ok(b) => b,
21050 Err(_) => {
21051 return (axum::http::StatusCode::NOT_FOUND, "avatar bytes missing").into_response()
21052 }
21053 };
21054 let mime = mime_guess::from_path(&storage_name)
21055 .first_or_octet_stream()
21056 .essence_str()
21057 .to_owned();
21058 revalidated_asset(&headers, mime, bytes)
21061}
21062
21063pub async fn cms_login_form(
21064 State(state): State<super::AdminState>,
21065 headers: HeaderMap,
21066 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21067 tenant: Tenant,
21068 Query(q): Query<std::collections::HashMap<String, String>>,
21069) -> Result<Response, AdminError> {
21070 let mut ctx = Context::new();
21071 ctx.insert("action", &"/login");
21075 ctx.insert("admin_title", &"CMS Admin");
21076 let next = q
21089 .get("next")
21090 .map(String::as_str)
21091 .filter(|s| !s.is_empty())
21092 .unwrap_or("/cms-admin/");
21093 ctx.insert("next", next);
21094 if let Some(err) = q.get("error") {
21096 ctx.insert("error", err);
21097 }
21098 let sso_providers = rustango::admin::sso_provider::list_enabled(tenant.pool(), "/login").await;
21105 ctx.insert("sso_enabled", &!sso_providers.is_empty());
21106 ctx.insert("sso_providers", &sso_providers);
21107 if let Some(err) = q.get("sso_error") {
21109 ctx.insert("sso_error", err);
21110 }
21111 add_branding_urls(&mut ctx, &tenant).await;
21115 render_with_csrf(&state, &headers, "login.html", &mut ctx)
21116}
21117
21118pub async fn password_reset_request_form(
21120 State(state): State<super::AdminState>,
21121 headers: HeaderMap,
21122 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21123) -> Result<Response, AdminError> {
21124 let mut ctx = Context::new();
21125 render_with_csrf(
21126 &state,
21127 &headers,
21128 "rcms_admin/password_reset_request.html",
21129 &mut ctx,
21130 )
21131}
21132
21133fn password_reset_key(secret: &[u8], tenant_slug: &str, password_hash: &str) -> Vec<u8> {
21145 let msg = format!("rcms-password-reset\0{tenant_slug}\0{password_hash}");
21146 crate::signing::hmac_sha256_hex(secret, msg.as_bytes()).into_bytes()
21147}
21148
21149async fn password_reset_user(
21155 tenant: &Tenant,
21156 secret: &[u8],
21157 signed_url: &str,
21158) -> Option<rustango::tenancy::auth::User> {
21159 let claimed: i64 = signed_url
21160 .split_once('?')?
21161 .1
21162 .split('&')
21163 .find_map(|kv| kv.strip_prefix("user_id="))?
21164 .parse()
21165 .ok()?;
21166 let user = rustango::tenancy::auth::User::objects()
21167 .where_(rustango::tenancy::auth::User::id.eq(claimed))
21168 .where_(rustango::tenancy::auth::User::active.eq(true))
21169 .first(tenant.pool())
21170 .await
21171 .ok()??;
21172 let key = password_reset_key(secret, &tenant.org.slug, &user.password_hash);
21173 match rustango::auth_flows::PasswordReset::verify(signed_url, &key) {
21174 Ok(uid) if uid == claimed => Some(user),
21175 _ => None,
21176 }
21177}
21178
21179pub async fn password_reset_request_submit(
21180 State(state): State<super::AdminState>,
21181 tenant: Tenant,
21182 headers: HeaderMap,
21183 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21184 Form(form): Form<std::collections::HashMap<String, String>>,
21185) -> Result<Response, AdminError> {
21186 let username = form.get("username").cloned().unwrap_or_default();
21187 if !username.trim().is_empty() {
21188 let user: Option<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
21192 .where_(rustango::tenancy::auth::User::username.eq(username.clone()))
21193 .where_(rustango::tenancy::auth::User::active.eq(true))
21194 .fetch(tenant.pool())
21195 .await
21196 .unwrap_or_default()
21197 .into_iter()
21198 .next();
21199 if let Some(u) = user {
21200 let user_id = u.id.get().copied().unwrap_or(0);
21201 let to_email = Some(user_email(&u)).filter(|e| !e.is_empty());
21206 match to_email {
21207 Some(to) => {
21208 let key = password_reset_key(
21211 state.signing_secret.as_slice(),
21212 &tenant.org.slug,
21213 &u.password_hash,
21214 );
21215 let token_url = rustango::auth_flows::PasswordReset::issue(
21216 "/cms-admin/password-reset/confirm",
21217 user_id,
21218 &key,
21219 std::time::Duration::from_secs(3600),
21220 );
21221 send_reset_email(
21222 state.mailer.as_deref(),
21223 &state.mailer_from,
21224 &to,
21225 &u.username,
21226 &token_url,
21227 )
21228 .await;
21229 }
21230 None => {
21231 tracing::info!(
21232 username = %u.username,
21233 "password reset requested but the account has no email on file; nothing sent"
21234 );
21235 }
21236 }
21237 }
21238 }
21239 let mut ctx = Context::new();
21240 render_with_csrf(
21241 &state,
21242 &headers,
21243 "rcms_admin/password_reset_sent.html",
21244 &mut ctx,
21245 )
21246}
21247
21248pub async fn password_reset_confirm_form(
21252 State(state): State<super::AdminState>,
21253 tenant: Tenant,
21254 headers: HeaderMap,
21255 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21256 axum::extract::OriginalUri(uri): axum::extract::OriginalUri,
21257) -> Result<Response, AdminError> {
21258 let path_and_query = uri
21259 .path_and_query()
21260 .map(|p| p.as_str())
21261 .unwrap_or_default()
21262 .to_owned();
21263 let mut ctx = Context::new();
21264 match password_reset_user(&tenant, state.signing_secret.as_slice(), &path_and_query).await {
21265 Some(_) => {
21266 ctx.insert("signed_token", &path_and_query);
21269 render_with_csrf(
21270 &state,
21271 &headers,
21272 "rcms_admin/password_reset_confirm.html",
21273 &mut ctx,
21274 )
21275 }
21276 None => {
21277 ctx.insert(
21278 "error",
21279 &"This reset link is invalid or has expired. Request a fresh one.",
21280 );
21281 render_with_csrf(
21282 &state,
21283 &headers,
21284 "rcms_admin/password_reset_request.html",
21285 &mut ctx,
21286 )
21287 }
21288 }
21289}
21290
21291pub async fn password_reset_confirm_submit(
21295 State(state): State<super::AdminState>,
21296 tenant: Tenant,
21297 headers: HeaderMap,
21298 rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21299 Form(form): Form<std::collections::HashMap<String, String>>,
21300) -> Result<Response, AdminError> {
21301 let token = form.get("token").cloned().unwrap_or_default();
21302 let password = form.get("password").cloned().unwrap_or_default();
21303 let password_confirm = form.get("password_confirm").cloned().unwrap_or_default();
21304
21305 let mut ctx = Context::new();
21306 let render_confirm_with_error = |state: &super::AdminState,
21307 headers: &HeaderMap,
21308 token: &str,
21309 msg: &str|
21310 -> Result<Response, AdminError> {
21311 let mut c = Context::new();
21312 c.insert("signed_token", &token);
21313 c.insert("error", &msg);
21314 render_with_csrf(
21315 state,
21316 headers,
21317 "rcms_admin/password_reset_confirm.html",
21318 &mut c,
21319 )
21320 };
21321
21322 if password.len() < 12 {
21323 return render_confirm_with_error(
21324 &state,
21325 &headers,
21326 &token,
21327 "Password must be at least 12 characters.",
21328 );
21329 }
21330 if password != password_confirm {
21331 return render_confirm_with_error(
21332 &state,
21333 &headers,
21334 &token,
21335 "Password confirmation didn't match.",
21336 );
21337 }
21338
21339 let Some(mut user) = password_reset_user(&tenant, state.signing_secret.as_slice(), &token).await
21342 else {
21343 ctx.insert(
21344 "error",
21345 &"This reset link is invalid or has expired. Request a fresh one.",
21346 );
21347 return render_with_csrf(
21348 &state,
21349 &headers,
21350 "rcms_admin/password_reset_request.html",
21351 &mut ctx,
21352 );
21353 };
21354 let new_hash = match crate::passwords::hash(&password).await {
21355 Ok(h) => h,
21356 Err(e) => {
21357 tracing::warn!(error = %e, "password hash failed");
21358 return render_confirm_with_error(
21359 &state,
21360 &headers,
21361 &token,
21362 "Could not save the new password. Try again.",
21363 );
21364 }
21365 };
21366 user.password_hash = new_hash;
21367 if user.save_pool(tenant.pool()).await.is_err() {
21368 return render_confirm_with_error(
21369 &state,
21370 &headers,
21371 &token,
21372 "Could not save the new password. Try again.",
21373 );
21374 }
21375
21376 render_with_csrf(
21377 &state,
21378 &headers,
21379 "rcms_admin/password_reset_done.html",
21380 &mut ctx,
21381 )
21382}
21383
21384async fn send_reset_email(
21394 mailer: Option<&dyn rustango::email::Mailer>,
21395 mailer_from: &str,
21396 to_email: &str,
21397 username: &str,
21398 reset_url: &str,
21399) {
21400 let from = if mailer_from.trim().is_empty() {
21401 "noreply@cms.local"
21402 } else {
21403 mailer_from
21404 };
21405 let email = rustango::email::Email::new()
21406 .to(to_email)
21407 .from(from)
21408 .subject("Reset your CMS password")
21409 .body(format!(
21410 "Hi {username},\n\n\
21411 We received a request to reset your CMS password.\n\
21412 Click the link below within the next hour to set a new one:\n\n\
21413 {reset_url}\n\n\
21414 If you didn't request this, you can safely ignore this email.\n"
21415 ));
21416 let result = match mailer {
21417 Some(m) => m.send(&email).await,
21418 None => {
21419 let console = rustango::email::ConsoleMailer;
21420 <rustango::email::ConsoleMailer as rustango::email::Mailer>::send(&console, &email)
21421 .await
21422 }
21423 };
21424 if let Err(e) = result {
21425 tracing::warn!(error = %e, username = %username, "password-reset mail send failed");
21426 }
21427 tracing::info!(username = %username, "issued password-reset link");
21428}
21429
21430#[cfg(test)]
21431mod tests {
21432 use super::*;
21435
21436 #[test]
21437 fn parse_matrix_form_translates_brackets_to_codenames() {
21438 let mut form = std::collections::HashMap::new();
21439 form.insert("name".to_owned(), "Editor".to_owned());
21440 form.insert("perm[pages][view]".to_owned(), "1".to_owned());
21441 form.insert("perm[pages][add]".to_owned(), "1".to_owned());
21442 form.insert("perm[pages][edit]".to_owned(), "1".to_owned());
21443 form.insert("perm[history][view]".to_owned(), "1".to_owned());
21445 form.insert("perm[history][edit]".to_owned(), "1".to_owned());
21448 form.insert("perm[redirects][delete]".to_owned(), "0".to_owned());
21450 form.insert("perm[bogus][view]".to_owned(), "1".to_owned());
21452 form.insert("perm[pages]".to_owned(), "1".to_owned());
21454
21455 let codenames = parse_matrix_form(&form);
21456 assert!(codenames.contains(&"cms_page.view".to_owned()));
21457 assert!(codenames.contains(&"cms_page.add".to_owned()));
21458 assert!(codenames.contains(&"cms_page.edit".to_owned()));
21459 assert!(codenames.contains(&"cms_history.view".to_owned()));
21460 assert!(!codenames.contains(&"cms_history.edit".to_owned()));
21461 assert!(!codenames.contains(&"cms_redirect.delete".to_owned()));
21462 assert!(!codenames.iter().any(|c| c.contains("bogus")));
21464 }
21465
21466 #[test]
21467 fn split_matrix_codenames_isolates_legacy() {
21468 let granted = vec![
21469 "cms_page.view".to_owned(),
21470 "cms_page.edit".to_owned(),
21471 "rustango_roles.view".to_owned(),
21472 "acme_custom.do_thing".to_owned(),
21473 "free_form_string".to_owned(),
21474 ];
21475 let (matched, legacy) = split_matrix_codenames(&granted);
21476 assert!(matched.contains(&"cms_page.view".to_owned()));
21477 assert!(matched.contains(&"cms_page.edit".to_owned()));
21478 assert!(matched.contains(&"rustango_roles.view".to_owned()));
21479 assert!(legacy.contains(&"acme_custom.do_thing".to_owned()));
21480 assert!(legacy.contains(&"free_form_string".to_owned()));
21481 }
21482
21483 #[test]
21484 fn build_permission_matrix_marks_granted_cells() {
21485 let granted = vec![
21486 "cms_page.view".to_owned(),
21487 "cms_page.add".to_owned(),
21488 "cms_media.view".to_owned(),
21489 ];
21490 let matrix = build_permission_matrix(&granted);
21491 let arr = matrix.as_array().expect("matrix is an array of sections");
21492 let pages_row = arr
21494 .iter()
21495 .flat_map(|s| s["rows"].as_array().unwrap().iter())
21496 .find(|r| r["key"] == "pages")
21497 .expect("pages row present");
21498 let granted_actions: Vec<&str> = pages_row["granted"]
21499 .as_array()
21500 .unwrap()
21501 .iter()
21502 .map(|v| v.as_str().unwrap())
21503 .collect();
21504 assert!(granted_actions.contains(&"view"));
21505 assert!(granted_actions.contains(&"add"));
21506 assert!(!granted_actions.contains(&"edit"));
21507 assert!(!granted_actions.contains(&"delete"));
21508 }
21509
21510 #[test]
21511 fn round_trip_form_to_codenames_to_matrix() {
21512 let mut form = std::collections::HashMap::new();
21515 form.insert("perm[pages][view]".to_owned(), "1".to_owned());
21516 form.insert("perm[pages][publish]".to_owned(), "1".to_owned());
21517 form.insert("perm[media][view]".to_owned(), "1".to_owned());
21518 let codenames = parse_matrix_form(&form);
21519 let matrix = build_permission_matrix(&codenames);
21520
21521 let pages = matrix
21522 .as_array()
21523 .unwrap()
21524 .iter()
21525 .flat_map(|s| s["rows"].as_array().unwrap().iter())
21526 .find(|r| r["key"] == "pages")
21527 .unwrap();
21528 let granted: Vec<&str> = pages["granted"]
21529 .as_array()
21530 .unwrap()
21531 .iter()
21532 .map(|v| v.as_str().unwrap())
21533 .collect();
21534 assert_eq!(granted, vec!["view", "publish"]);
21535 }
21536
21537 fn sample_spec() -> crate::page_type::InlinePanelSpec {
21540 crate::page_type::InlinePanelSpec::new(
21541 "team",
21542 "Team",
21543 vec![
21544 crate::page_type::ExtensionField {
21545 name: "name".to_owned(),
21546 label: "Name".to_owned(),
21547 kind: crate::page_type::ExtensionFieldKind::Text,
21548 value: String::new(),
21549 help: String::new(),
21550 max_length: None,
21551 },
21552 crate::page_type::ExtensionField {
21553 name: "role".to_owned(),
21554 label: "Role".to_owned(),
21555 kind: crate::page_type::ExtensionFieldKind::Text,
21556 value: String::new(),
21557 help: String::new(),
21558 max_length: None,
21559 },
21560 ],
21561 )
21562 }
21563
21564 #[test]
21565 fn inline_extractor_groups_by_row_index() {
21566 let spec = sample_spec();
21567 let mut form = std::collections::HashMap::new();
21568 form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21569 form.insert("inline__team__0__role".to_owned(), "Engineer".to_owned());
21570 form.insert("inline__team__1__name".to_owned(), "Bob".to_owned());
21571 form.insert("inline__team__1__role".to_owned(), "Designer".to_owned());
21572 let rows = extract_inline_panel_rows(&form, &spec);
21573 assert_eq!(rows.len(), 2);
21574 assert_eq!(rows[0]["name"], "Ada");
21575 assert_eq!(rows[1]["role"], "Designer");
21576 }
21577
21578 #[test]
21579 fn inline_extractor_drops_tombstoned_rows() {
21580 let spec = sample_spec();
21581 let mut form = std::collections::HashMap::new();
21582 form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21583 form.insert("inline__team__1__name".to_owned(), "Bob".to_owned());
21584 form.insert("inline__team__1____deleted".to_owned(), "1".to_owned());
21585 let rows = extract_inline_panel_rows(&form, &spec);
21586 assert_eq!(rows.len(), 1);
21587 assert_eq!(rows[0]["name"], "Ada");
21588 }
21589
21590 #[test]
21591 fn inline_extractor_ignores_unknown_field_names() {
21592 let spec = sample_spec();
21593 let mut form = std::collections::HashMap::new();
21594 form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21595 form.insert("inline__team__0__bogus".to_owned(), "x".to_owned());
21596 let rows = extract_inline_panel_rows(&form, &spec);
21597 assert_eq!(rows.len(), 1);
21598 assert!(!rows[0].contains_key("bogus"));
21599 }
21600
21601 #[test]
21602 fn inline_extractor_ignores_unrelated_form_keys() {
21603 let spec = sample_spec();
21604 let mut form = std::collections::HashMap::new();
21605 form.insert("title".to_owned(), "irrelevant".to_owned());
21606 form.insert("inline__other_panel__0__name".to_owned(), "x".to_owned());
21607 let rows = extract_inline_panel_rows(&form, &spec);
21608 assert!(rows.is_empty());
21609 }
21610
21611 #[test]
21620 fn page_form_canonical_keys_include_schedule_and_menu_fields() {
21621 assert!(
21622 PAGE_FORM_CANONICAL_KEYS.contains(&"go_live_at"),
21623 "go_live_at must be in canonical keys — see #268"
21624 );
21625 assert!(
21626 PAGE_FORM_CANONICAL_KEYS.contains(&"expire_at"),
21627 "expire_at must be in canonical keys — see #268"
21628 );
21629 assert!(
21630 PAGE_FORM_CANONICAL_KEYS.contains(&"show_in_menus"),
21631 "show_in_menus must be in canonical keys — see #268"
21632 );
21633 }
21634}
21635
21636#[cfg(all(test, feature = "sqlite"))]
21637mod media_picker_tests {
21638 use super::{media_picker_payload, MediaPickerQuery};
21642 use crate::media::{Media, MediaCollection};
21643 use rustango::core::Model as _;
21644 use rustango::sql::{Auto, FetcherPool as _, Pool};
21645
21646 async fn mem_pool() -> Pool {
21647 let pool = Pool::connect("sqlite::memory:")
21648 .await
21649 .expect("in-memory sqlite");
21650 for schema in [&Media::SCHEMA, &MediaCollection::SCHEMA] {
21651 let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
21652 pool.dialect(),
21653 schema,
21654 );
21655 for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
21656 rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
21657 .await
21658 .expect("ddl");
21659 }
21660 }
21661 pool
21662 }
21663
21664 async fn mk_collection(pool: &Pool, name: &str, parent_id: Option<i64>, sort: i32) -> i64 {
21665 MediaCollection {
21666 id: Auto::Unset,
21667 name: name.to_owned(),
21668 parent_id,
21669 sort_order: sort,
21670 created_at: Auto::Unset,
21671 }
21672 .insert_pool(pool)
21673 .await
21674 .expect("collection insert");
21675 MediaCollection::objects()
21676 .fetch(pool)
21677 .await
21678 .expect("fetch")
21679 .into_iter()
21680 .find(|c| c.name == name)
21681 .and_then(|c| c.id.get().copied())
21682 .expect("collection id")
21683 }
21684
21685 async fn mk_media(
21686 pool: &Pool,
21687 title: &str,
21688 filename: &str,
21689 kind: &str,
21690 collection_id: Option<i64>,
21691 alt: &str,
21692 ) {
21693 Media {
21694 id: Auto::Unset,
21695 filename: filename.to_owned(),
21696 content_hash: format!("{:0>64}", title.len()),
21697 mime: if kind == "image" {
21698 "image/png"
21699 } else {
21700 "application/pdf"
21701 }
21702 .to_owned(),
21703 size: 123,
21704 kind: kind.to_owned(),
21705 width: (kind == "image").then_some(100),
21706 height: (kind == "image").then_some(80),
21707 storage_key: format!("k-{filename}"),
21708 title: title.to_owned(),
21709 alt_text: alt.to_owned(),
21710 description: String::new(),
21711 uploaded_by: None,
21712 collection_id,
21713 focal_point_x: None,
21714 focal_point_y: None,
21715 uploaded_at: Auto::Unset,
21716 }
21717 .insert_pool(pool)
21718 .await
21719 .expect("media insert");
21720 }
21721
21722 #[tokio::test]
21723 async fn default_kind_excludes_documents() {
21724 let pool = mem_pool().await;
21725 mk_media(&pool, "Photo", "p.png", "image", None, "").await;
21726 mk_media(&pool, "Spec", "s.pdf", "document", None, "").await;
21727 let body = media_picker_payload(&pool, &MediaPickerQuery::default())
21728 .await
21729 .expect("payload");
21730 let items = body["items"].as_array().expect("items");
21731 assert_eq!(items.len(), 1);
21732 assert_eq!(items[0]["kind"], "image");
21733 let q = MediaPickerQuery {
21735 kind: Some("any".to_owned()),
21736 ..Default::default()
21737 };
21738 let body = media_picker_payload(&pool, &q).await.expect("payload");
21739 assert_eq!(body["items"].as_array().expect("items").len(), 2);
21740 }
21741
21742 #[tokio::test]
21743 async fn collection_zero_means_uncategorized_only() {
21744 let pool = mem_pool().await;
21745 let cid = mk_collection(&pool, "Root", None, 0).await;
21746 mk_media(&pool, "In", "in.png", "image", Some(cid), "").await;
21747 mk_media(&pool, "Loose", "loose.png", "image", None, "").await;
21748 let q = MediaPickerQuery {
21749 collection: Some(0),
21750 ..Default::default()
21751 };
21752 let body = media_picker_payload(&pool, &q).await.expect("payload");
21753 let items = body["items"].as_array().expect("items");
21754 assert_eq!(items.len(), 1);
21755 assert_eq!(items[0]["title"], "Loose");
21756 assert_eq!(body["uncategorized_count"], 1);
21757 let q = MediaPickerQuery {
21759 collection: Some(cid),
21760 ..Default::default()
21761 };
21762 let body = media_picker_payload(&pool, &q).await.expect("payload");
21763 assert_eq!(body["items"].as_array().expect("items").len(), 1);
21764 assert_eq!(body["items"][0]["title"], "In");
21765 }
21766
21767 #[tokio::test]
21768 async fn search_matches_alt_text() {
21769 let pool = mem_pool().await;
21770 mk_media(
21771 &pool,
21772 "IMG_0001",
21773 "a.png",
21774 "image",
21775 None,
21776 "sunset glow over harbour",
21777 )
21778 .await;
21779 mk_media(&pool, "IMG_0002", "b.png", "image", None, "office desk").await;
21780 let q = MediaPickerQuery {
21781 q: Some("Sunset".to_owned()),
21782 ..Default::default()
21783 };
21784 let body = media_picker_payload(&pool, &q).await.expect("payload");
21785 let items = body["items"].as_array().expect("items");
21786 assert_eq!(items.len(), 1);
21787 assert_eq!(items[0]["title"], "IMG_0001");
21788 }
21789
21790 #[tokio::test]
21791 async fn pagination_math_and_has_more() {
21792 let pool = mem_pool().await;
21793 for i in 0..5 {
21794 mk_media(
21795 &pool,
21796 &format!("M{i}"),
21797 &format!("m{i}.png"),
21798 "image",
21799 None,
21800 "",
21801 )
21802 .await;
21803 }
21804 let q = MediaPickerQuery {
21805 limit: Some(2),
21806 offset: Some(0),
21807 ..Default::default()
21808 };
21809 let body = media_picker_payload(&pool, &q).await.expect("payload");
21810 assert_eq!(body["items"].as_array().expect("items").len(), 2);
21811 assert_eq!(body["total"], 5);
21812 assert_eq!(body["has_more"], true);
21813 let q = MediaPickerQuery {
21814 limit: Some(2),
21815 offset: Some(4),
21816 ..Default::default()
21817 };
21818 let body = media_picker_payload(&pool, &q).await.expect("payload");
21819 assert_eq!(body["items"].as_array().expect("items").len(), 1);
21820 assert_eq!(body["has_more"], false);
21821 let q = MediaPickerQuery {
21823 limit: Some(2),
21824 offset: Some(99),
21825 ..Default::default()
21826 };
21827 let body = media_picker_payload(&pool, &q).await.expect("payload");
21828 assert_eq!(body["items"].as_array().expect("items").len(), 0);
21829 }
21830
21831 #[tokio::test]
21832 async fn collections_come_back_in_dfs_order_with_depth() {
21833 let pool = mem_pool().await;
21834 let root_a = mk_collection(&pool, "Alpha", None, 0).await;
21835 let _sub = mk_collection(&pool, "Alpha Child", Some(root_a), 0).await;
21836 let _root_b = mk_collection(&pool, "Beta", None, 1).await;
21837 mk_media(&pool, "In A", "a.png", "image", Some(root_a), "").await;
21838 let body = media_picker_payload(&pool, &MediaPickerQuery::default())
21839 .await
21840 .expect("payload");
21841 let cols = body["collections"].as_array().expect("collections");
21842 let names: Vec<&str> = cols.iter().map(|c| c["name"].as_str().unwrap()).collect();
21843 assert_eq!(names, ["Alpha", "Alpha Child", "Beta"]);
21844 assert_eq!(cols[0]["depth"], 0);
21845 assert_eq!(cols[1]["depth"], 1);
21846 assert_eq!(cols[2]["depth"], 0);
21847 assert_eq!(cols[0]["count"], 1);
21848 assert_eq!(cols[2]["count"], 0);
21849 }
21850
21851 #[tokio::test]
21852 async fn ids_lookup_resolves_any_kind() {
21853 let pool = mem_pool().await;
21856 mk_media(&pool, "Photo", "p.png", "image", None, "").await;
21857 mk_media(&pool, "Spec", "s.pdf", "document", None, "").await;
21858 let all = media_picker_payload(
21859 &pool,
21860 &MediaPickerQuery {
21861 kind: Some("any".to_owned()),
21862 ..Default::default()
21863 },
21864 )
21865 .await
21866 .expect("payload");
21867 let ids: Vec<i64> = all["items"]
21868 .as_array()
21869 .unwrap()
21870 .iter()
21871 .map(|i| i["id"].as_i64().unwrap())
21872 .collect();
21873 let q = MediaPickerQuery {
21874 ids: Some(
21875 ids.iter()
21876 .map(|i| i.to_string())
21877 .collect::<Vec<_>>()
21878 .join(","),
21879 ),
21880 ..Default::default()
21881 };
21882 let body = media_picker_payload(&pool, &q).await.expect("payload");
21883 let items = body["items"].as_array().expect("items");
21884 assert_eq!(
21885 items.len(),
21886 2,
21887 "document resolves too when ids are explicit"
21888 );
21889 let q = MediaPickerQuery {
21891 ids: Some(
21892 ids.iter()
21893 .map(|i| i.to_string())
21894 .collect::<Vec<_>>()
21895 .join(","),
21896 ),
21897 kind: Some("image".to_owned()),
21898 ..Default::default()
21899 };
21900 let body = media_picker_payload(&pool, &q).await.expect("payload");
21901 assert_eq!(body["items"].as_array().expect("items").len(), 1);
21902 }
21903
21904 #[tokio::test]
21905 async fn image_items_carry_rendition_thumb_urls() {
21906 let pool = mem_pool().await;
21907 mk_media(&pool, "Pic", "p.png", "image", None, "").await;
21908 let body = media_picker_payload(&pool, &MediaPickerQuery::default())
21909 .await
21910 .expect("payload");
21911 let item = &body["items"][0];
21912 let thumb = item["thumb_url"].as_str().expect("thumb_url");
21913 assert!(
21914 thumb.starts_with("/__media__/fill-320x320"),
21915 "spec-first URL: {thumb}"
21916 );
21917 assert!(thumb.contains("v="), "cache-buster present: {thumb}");
21918 let preview = item["preview_url"].as_str().expect("preview_url");
21919 assert!(preview.contains("max-640x480"), "{preview}");
21920 }
21921}
21922
21923#[cfg(all(test, feature = "sqlite"))]
21924mod forms_list_tests {
21925 use super::forms_list_rows;
21927 use crate::forms::submit::FormEntry;
21928 use crate::snippet::Snippet;
21929 use rustango::core::Model as _;
21930 use rustango::sql::{Auto, FetcherPool as _, Pool};
21931
21932 async fn mem_pool() -> Pool {
21933 let pool = Pool::connect("sqlite::memory:")
21934 .await
21935 .expect("in-memory sqlite");
21936 for schema in [&Snippet::SCHEMA, &FormEntry::SCHEMA] {
21937 let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
21938 pool.dialect(),
21939 schema,
21940 );
21941 for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
21942 rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
21943 .await
21944 .expect("ddl");
21945 }
21946 }
21947 pool
21948 }
21949
21950 async fn mk_form(pool: &Pool, slug: &str, title: &str, fields: usize) -> i64 {
21951 let field_json: Vec<serde_json::Value> = (0..fields)
21952 .map(|i| serde_json::json!({"id": format!("f{i}"), "key": format!("k{i}"), "type": "text", "label": "F"}))
21953 .collect();
21954 Snippet {
21955 id: Auto::Unset,
21956 type_name: "form".to_owned(),
21957 folder_path: String::new(),
21958 slug: slug.to_owned(),
21959 title: title.to_owned(),
21960 body_markdown: String::new(),
21961 data: serde_json::json!({
21962 "settings": {},
21963 "pages": [{"id": "p1", "sections": [{"id": "s1", "rows": [{"id": "r1",
21964 "columns": [{"id": "c1", "width": 12, "fields": field_json}]}]}]}]
21965 }),
21966 created_at: Auto::Unset,
21967 updated_at: Auto::Unset,
21968 }
21969 .insert_pool(pool)
21970 .await
21971 .expect("form insert");
21972 Snippet::objects()
21973 .fetch(pool)
21974 .await
21975 .expect("fetch")
21976 .into_iter()
21977 .find(|s| s.slug == slug)
21978 .and_then(|s| s.id.get().copied())
21979 .expect("form id")
21980 }
21981
21982 async fn mk_entry(pool: &Pool, form_id: i64) {
21983 FormEntry {
21984 id: Auto::Unset,
21985 form_snippet_id: form_id,
21986 form_version: 1,
21987 source_page_id: 0,
21988 source_url: "/contact".to_owned(),
21989 data_json: serde_json::json!({"k0": "hi"}),
21990 locale: "en".to_owned(),
21991 ip: String::new(),
21992 submitted_at: Auto::Unset,
21993 }
21994 .insert_pool(pool)
21995 .await
21996 .expect("entry insert");
21997 }
21998
21999 #[tokio::test]
22000 async fn rows_carry_field_and_submission_counts() {
22001 let pool = mem_pool().await;
22002 let a = mk_form(&pool, "contact", "Contact", 3).await;
22003 let b = mk_form(&pool, "rsvp", "RSVP", 1).await;
22004 mk_entry(&pool, a).await;
22005 mk_entry(&pool, a).await;
22006 let rows = forms_list_rows(&pool).await.expect("rows");
22007 assert_eq!(rows.len(), 2);
22008 let by_slug = |slug: &str| rows.iter().find(|r| r["slug"] == slug).expect("row");
22009 let ra = by_slug("contact");
22010 assert_eq!(ra["fields"], 3);
22011 assert_eq!(ra["submissions"], 2);
22012 assert!(
22013 ra["last_submission"].as_str().unwrap().len() >= 16,
22014 "has a timestamp"
22015 );
22016 assert_eq!(ra["build_url"], format!("/cms-admin/forms/{a}/build"));
22017 assert_eq!(
22018 ra["submissions_url"],
22019 format!("/cms-admin/forms/{a}/submissions")
22020 );
22021 let rb = by_slug("rsvp");
22022 assert_eq!(rb["fields"], 1);
22023 assert_eq!(rb["submissions"], 0);
22024 assert_eq!(rb["last_submission"], "");
22025 assert_eq!(rb["delete_url"], format!("/cms-admin/library/{b}/delete"));
22026 }
22027
22028 #[tokio::test]
22029 async fn only_form_snippets_appear() {
22030 let pool = mem_pool().await;
22031 mk_form(&pool, "contact", "Contact", 1).await;
22032 Snippet {
22033 id: Auto::Unset,
22034 type_name: "branding".to_owned(),
22035 folder_path: String::new(),
22036 slug: "site-branding".to_owned(),
22037 title: "Branding".to_owned(),
22038 body_markdown: String::new(),
22039 data: serde_json::json!({}),
22040 created_at: Auto::Unset,
22041 updated_at: Auto::Unset,
22042 }
22043 .insert_pool(&pool)
22044 .await
22045 .expect("snippet insert");
22046 let rows = forms_list_rows(&pool).await.expect("rows");
22047 assert_eq!(rows.len(), 1);
22048 assert_eq!(rows[0]["slug"], "contact");
22049 }
22050
22051 #[test]
22052 fn user_admin_is_superuser_only() {
22053 assert_eq!(super::user_admin_denial_target(Some(true)), None);
22059 assert_eq!(
22060 super::user_admin_denial_target(Some(false)),
22061 Some("/cms-admin/no-access")
22062 );
22063 assert_eq!(super::user_admin_denial_target(None), Some("/login"));
22064 }
22065
22066 #[test]
22067 fn mcp_key_admin_handlers_enforce_the_superuser_gate() {
22068 let src = include_str!("handlers.rs");
22075 for name in ["users_mcp_key_create", "users_mcp_key_revoke"] {
22076 let start = src
22077 .find(&format!("pub async fn {name}("))
22078 .unwrap_or_else(|| panic!("handler {name} not found"));
22079 let rest = &src[start + 1..];
22081 let end = rest.find("\npub async fn ").unwrap_or(rest.len());
22082 assert!(
22083 rest[..end].contains("require_superuser_for_user_admin(session_user.as_ref())"),
22084 "{name} is missing the superuser gate (#646)"
22085 );
22086 }
22087 }
22088}
22089
22090#[cfg(test)]
22091mod password_reset_key_tests {
22092 use super::password_reset_key;
22093 use rustango::auth_flows::PasswordReset;
22094 use std::time::Duration;
22095
22096 const SECRET: &[u8] = b"process-wide-signing-secret";
22097 const BASE: &str = "/cms-admin/password-reset/confirm";
22098
22099 fn link(tenant: &str, hash: &str) -> String {
22100 PasswordReset::issue(BASE, 1, &password_reset_key(SECRET, tenant, hash), Duration::from_secs(3600))
22101 }
22102
22103 #[test]
22104 fn a_link_verifies_for_the_tenant_and_password_it_was_issued_for() {
22105 let url = link("acme", "$argon2id$v=19$old");
22106 let key = password_reset_key(SECRET, "acme", "$argon2id$v=19$old");
22107 assert_eq!(PasswordReset::verify(&url, &key).ok(), Some(1));
22108 }
22109
22110 #[test]
22111 fn a_link_issued_on_one_tenant_does_not_verify_on_another() {
22112 let url = link("acme", "$argon2id$v=19$same");
22114 let other = password_reset_key(SECRET, "globex", "$argon2id$v=19$same");
22115 assert!(PasswordReset::verify(&url, &other).is_err());
22116 }
22117
22118 #[test]
22119 fn a_link_stops_verifying_once_the_password_changes() {
22120 let url = link("acme", "$argon2id$v=19$before");
22121 let after = password_reset_key(SECRET, "acme", "$argon2id$v=19$after");
22122 assert!(PasswordReset::verify(&url, &after).is_err());
22123 }
22124}
22125
22126#[cfg(all(test, feature = "sqlite"))]
22127mod publish_gate_tests {
22128 use super::{apply_page_edit, PageEditActor, PageEditRefusal};
22131 use crate::page::{Page, PageStatus};
22132 use crate::page_type_model::PageType;
22133 use rustango::core::Column as _;
22134 use rustango::sql::{Auto, Pool};
22135
22136 async fn mem_pool() -> Pool {
22137 let pool = Pool::connect("sqlite::memory:").await.expect("in-memory sqlite");
22138 for entry in inventory::iter::<rustango::core::ModelEntry> {
22139 if !entry.schema.managed {
22140 continue;
22141 }
22142 let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
22143 pool.dialect(),
22144 entry.schema,
22145 );
22146 for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
22147 rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
22148 .await
22149 .expect("ddl");
22150 }
22151 }
22152 pool
22153 }
22154
22155 async fn draft(pool: &Pool) -> Page {
22156 let mut pt = PageType {
22157 id: Auto::Unset,
22158 app_label: "cms".to_owned(),
22159 type_name: "TestPage".to_owned(),
22160 verbose_name: "Test page".to_owned(),
22161 default_template: "page.html".to_owned(),
22162 view_mode: "auto".to_owned(),
22163 is_creatable: true,
22164 allowed_parent_types: serde_json::json!([]),
22165 allowed_child_types: serde_json::json!([]),
22166 workflow: String::new(),
22167 created_at: Auto::Unset,
22168 updated_at: Auto::Unset,
22169 };
22170 pt.save_pool(pool).await.expect("page type");
22171 let mut p = draft_template(pt.id.get().copied().expect("type id"));
22172 p.save_pool(pool).await.expect("page");
22173 p
22174 }
22175
22176 fn draft_template(type_id: i64) -> Page {
22177 Page {
22178 id: Auto::Unset,
22179 page_type_id: type_id,
22180 title: "Draft".to_owned(),
22181 slug: "draft".to_owned(),
22182 path: "0001/".to_owned(),
22183 url_path: "/draft".to_owned(),
22184 preview_path: String::new(),
22185 template_override: String::new(),
22186 depth: 1,
22187 parent_id: None,
22188 locale_variant_of: None,
22189 alias_of: None,
22190 theme_id: None,
22191 sort_order: 0,
22192 status: PageStatus::Draft.as_str().to_owned(),
22193 published_at: None,
22194 last_published_at: None,
22195 go_live_at: None,
22196 expire_at: None,
22197 seo_title: String::new(),
22198 seo_description: String::new(),
22199 robots_index: true,
22200 sitemap_priority: 0.5,
22201 show_in_menus: true,
22202 og_title: String::new(),
22203 og_description: String::new(),
22204 og_image_media_id: None,
22205 twitter_card: "summary".to_owned(),
22206 notification_pre_published_sent: false,
22207 created_at: Auto::Unset,
22208 updated_at: Auto::Unset,
22209 }
22210 }
22211
22212 async fn save(
22213 pool: &Pool,
22214 page: &Page,
22215 status: &str,
22216 go_live_days: Option<i64>,
22217 superuser: bool,
22218 ) -> Result<String, &'static str> {
22219 let mut form = crate::page_form::prefill(pool, page).await;
22220 form.insert("status".into(), status.to_owned());
22221 match go_live_days {
22222 Some(d) => form.insert(
22223 "go_live_at".into(),
22224 (chrono::Utc::now() + chrono::Duration::days(d))
22225 .format("%Y-%m-%dT%H:%M")
22226 .to_string(),
22227 ),
22228 None => form.remove("go_live_at"),
22229 };
22230 let actor = PageEditActor { id: 999, username: "editor".to_owned(), is_superuser: superuser };
22232 let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
22233 std::sync::Arc::new(crate::cache_invalidate::Noop);
22234 let id = page.id.get().copied().expect("id");
22235 match apply_page_edit(pool, "t", &invalidator, None, "", false, id, &form, Some(&actor))
22236 .await
22237 .expect("save")
22238 {
22239 Ok(o) => Ok(o.page.status),
22240 Err(PageEditRefusal::PublishDenied) => Err("publish denied"),
22241 Err(PageEditRefusal::ReviewRequired { .. }) => Err("review required"),
22242 Err(_) => Err("other refusal"),
22243 }
22244 }
22245
22246 async fn stored_status(pool: &Pool, page: &Page) -> String {
22247 Page::objects()
22248 .where_(Page::id.eq(page.id.get().copied().expect("id")))
22249 .first(pool)
22250 .await
22251 .expect("query")
22252 .expect("page")
22253 .status
22254 }
22255
22256 #[tokio::test]
22257 async fn going_live_by_any_route_needs_the_publish_right() {
22258 let pool = mem_pool().await;
22259 let page = draft(&pool).await;
22260 for (status, go_live) in [
22261 ("archived", None),
22262 ("published", None),
22263 ("draft", Some(1)),
22265 ("scheduled", Some(-1)),
22267 ] {
22268 assert_eq!(
22269 save(&pool, &page, status, go_live, false).await,
22270 Err("publish denied"),
22271 "{status} / {go_live:?}"
22272 );
22273 assert_eq!(stored_status(&pool, &page).await, "draft", "nothing written");
22274 }
22275 assert_eq!(
22276 save(&pool, &page, "scheduled", None, false).await,
22277 Ok("draft".to_owned()),
22278 "scheduled without a date is parked as a draft, so it is allowed"
22279 );
22280 assert_eq!(
22281 save(&pool, &page, "draft", Some(1), true).await,
22282 Ok("scheduled".to_owned()),
22283 "the publish right schedules"
22284 );
22285 }
22286
22287 async fn bind_review(pool: &Pool, type_id: i64, reapproval: bool) -> crate::workflow::Workflow {
22292 let mut wf = crate::workflow::Workflow {
22293 id: Auto::Unset,
22294 name: "Owner review".to_owned(),
22295 description: String::new(),
22296 active: true,
22297 require_reapproval_on_edit: reapproval,
22298 created_at: Auto::Unset,
22299 updated_at: Auto::Unset,
22300 };
22301 wf.save_pool(pool).await.expect("workflow");
22302 rustango::sql::raw_execute_pool(pool, "INSERT INTO rustango_roles (id, name, description) VALUES (1, 'Owner', '')", Vec::new())
22303 .await
22304 .expect("role");
22305 let mut task = crate::workflow::WorkflowTask {
22306 id: Auto::Unset,
22307 workflow_id: wf.id.get().copied().expect("id"),
22308 name: "Owner checks".to_owned(),
22309 role_id: 1,
22310 sort_order: 10,
22311 kind: "group_approval".to_owned(),
22312 webhook_url: String::new(),
22313 };
22314 task.save_pool(pool).await.expect("task");
22315 let mut pt = PageType::objects()
22316 .where_(PageType::id.eq(type_id))
22317 .first(pool)
22318 .await
22319 .expect("q")
22320 .expect("type");
22321 pt.workflow = "Owner review".to_owned();
22322 pt.save_pool(pool).await.expect("bind");
22323 wf
22324 }
22325
22326 #[tokio::test]
22327 async fn a_review_workflow_cannot_be_published_around() {
22328 let pool = mem_pool().await;
22329 let page = draft(&pool).await;
22330 let mut wf = bind_review(&pool, page.page_type_id, false).await;
22331
22332 assert_eq!(save(&pool, &page, "published", None, false).await, Err("review required"));
22333 assert_eq!(save(&pool, &page, "draft", Some(1), false).await, Err("review required"), "nor scheduled");
22334 assert_eq!(stored_status(&pool, &page).await, "draft");
22335 assert_eq!(save(&pool, &page, "draft", None, false).await, Ok("draft".to_owned()), "drafts still save");
22336 assert_eq!(save(&pool, &page, "published", None, true).await, Ok("published".to_owned()), "the owner can");
22337
22338 let other = draft_named(&pool, page.page_type_id, "second").await;
22340 wf.name = "Studio review".to_owned();
22341 wf.save_pool(&pool).await.expect("rename");
22342 assert_eq!(crate::workflow::rebind_page_types(&pool, "Owner review", "Studio review").await.expect("rebind"), 1);
22343 assert_eq!(save(&pool, &other, "published", None, false).await, Err("review required"));
22344 }
22345
22346 async fn retitle(pool: &Pool, page: &Page, title: &str, actor: Option<&PageEditActor>) -> super::PageEditOutcome {
22348 let mut form = crate::page_form::prefill(pool, page).await;
22349 form.insert("title".into(), title.to_owned());
22350 let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
22351 std::sync::Arc::new(crate::cache_invalidate::Noop);
22352 let id = page.id.get().copied().expect("id");
22353 match apply_page_edit(pool, "t", &invalidator, None, "", false, id, &form, actor).await.expect("save") {
22354 Ok(o) => o,
22355 Err(_) => panic!("refused"),
22356 }
22357 }
22358
22359 async fn stored_title(pool: &Pool, page: &Page) -> String {
22360 Page::objects()
22361 .where_(Page::id.eq(page.id.get().copied().expect("id")))
22362 .first(pool)
22363 .await
22364 .expect("query")
22365 .expect("page")
22366 .title
22367 }
22368
22369 #[tokio::test]
22373 async fn a_live_page_edit_waits_for_review() {
22374 let pool = mem_pool().await;
22375 let page = draft(&pool).await;
22376 bind_review(&pool, page.page_type_id, true).await;
22377 assert_eq!(save(&pool, &page, "published", None, true).await, Ok("published".to_owned()));
22378 let id = page.id.get().copied().expect("id");
22379 let mut mia = rustango::tenancy::auth::User {
22380 id: Auto::Unset,
22381 username: "mia".to_owned(),
22382 password_hash: String::new(),
22383 email: None,
22384 is_superuser: false,
22385 active: true,
22386 created_at: chrono::Utc::now(),
22387 data: serde_json::json!({}),
22388 password_changed_at: None,
22389 sessions_revoked_at: None,
22390 };
22391 mia.save_pool(&pool).await.expect("user");
22392 let editor = PageEditActor { id: mia.id.get().copied().expect("id"), username: "mia".to_owned(), is_superuser: false };
22393
22394 let out = retitle(&pool, &page, "Proposed", Some(&editor)).await;
22395 assert!(out.held_for_review && out.reapproval_kicked);
22396 assert_eq!(stored_title(&pool, &page).await, "Draft", "the live page is unchanged");
22397 let held = crate::pending_change::for_page(&pool, id).await.expect("q").expect("held");
22398 assert_eq!(held.form_map().get("title").map(String::as_str), Some("Proposed"));
22399 let mut state = crate::workflow::active_state_for_page(&pool, id).await.expect("q").expect("review started");
22400
22401 let tasks = crate::workflow::tasks_for(&pool, state.workflow_id).await.expect("tasks");
22403 crate::workflow::approve_current(&pool, &mut state, &tasks, editor.id, "").await.expect("approve");
22404 let applied = retitle(&pool, &page, "Proposed", None).await;
22405 assert!(!applied.held_for_review);
22406 assert_eq!(stored_title(&pool, &page).await, "Proposed");
22407
22408 retitle(&pool, &page, "Second try", Some(&editor)).await;
22410 let mut state = crate::workflow::active_state_for_page(&pool, id).await.expect("q").expect("review restarted");
22411 crate::workflow::cancel(&pool, &mut state, editor.id).await.expect("cancel");
22412 assert!(crate::pending_change::for_page(&pool, id).await.expect("q").is_none());
22413
22414 retitle(&pool, &page, "Third try", Some(&editor)).await;
22416 let owner = PageEditActor { id: 1, username: "owner".to_owned(), is_superuser: true };
22417 assert!(!retitle(&pool, &page, "Owner's", Some(&owner)).await.held_for_review);
22418 assert_eq!(stored_title(&pool, &page).await, "Owner's");
22419 assert!(crate::pending_change::for_page(&pool, id).await.expect("q").is_none());
22420 }
22421
22422 async fn draft_named(pool: &Pool, type_id: i64, slug: &str) -> Page {
22423 let mut p = draft_template(type_id);
22424 slug.clone_into(&mut p.slug);
22425 p.path = "0002/".to_owned();
22426 p.url_path = format!("/{slug}");
22427 p.save_pool(pool).await.expect("page");
22428 p
22429 }
22430}
22431
22432#[cfg(test)]
22433mod active_upload_tests {
22434 use super::refuse_active_upload;
22435
22436 #[test]
22437 fn page_like_types_are_refused_and_media_is_not() {
22438 for bad in ["text/html", "application/xhtml+xml", "text/javascript", "application/xml"] {
22439 assert!(refuse_active_upload(bad).is_err(), "{bad}");
22440 }
22441 for ok in ["image/png", "image/svg+xml", "application/pdf", "text/plain", "video/mp4"] {
22442 assert!(refuse_active_upload(ok).is_ok(), "{ok}");
22443 }
22444 }
22445}