Skip to main content

rustango_cms/admin/
handlers.rs

1//! Admin route handlers — `/cms-admin/...`.
2
3use crate::log_err::LogErr as _;
4use super::{AdminError, PageForm};
5use crate::locale::Locale;
6use crate::media::Media;
7use crate::page::Page;
8use crate::page_type::find_handler;
9use crate::page_type_model::PageType;
10use crate::tree_ops::NewPage;
11use axum::extract::{Form, Path, Query, State};
12use axum::http::{header, HeaderMap, HeaderValue};
13use axum::response::{Html, IntoResponse, Redirect, Response};
14use axum::Json;
15use rustango::core::Column as _;
16use rustango::extractors::Tenant;
17use rustango::messages::Level as MsgLevel;
18use rustango::sql::{transaction_pool, FetcherPool as _, FetcherTx as _};
19use serde::Deserialize;
20use std::sync::OnceLock;
21use tera::Context;
22use crate::security_log::Entry as SecurityEntry;
23
24/// HMAC key for the flash-messages cookie, derived from the CMS signing
25/// secret so every replica — and the same server after a restart — reads
26/// the flash another one set.
27fn messages_secret() -> &'static [u8] {
28    static SECRET: OnceLock<Vec<u8>> = OnceLock::new();
29    SECRET.get_or_init(|| crate::signing::derived_key("rcms:flash"))
30}
31
32/// Sanitize WYSIWYG (RichText-widget) HTML server-side before it
33/// reaches a page-type handler's `save_extension`. The TipTap editor
34/// produces constrained HTML, but a bypassed client could POST anything,
35/// so we ammonia-clean every RichText-kind field value (looked up by the
36/// handler's own widget definitions) before persisting. This is the
37/// on-save enforcement point for extension fields; stream rich-text blocks
38/// + markdown bodies already sanitize on their own render paths, and the
39/// `| richtext` filter stays a pure linktype-rewriter that trusts the now-
40/// sanitized stored HTML. Returns a sanitized clone of `form_map`.
41async fn sanitized_extension_form(
42    handler: &dyn crate::page_type::PageTypeHandler,
43    pool: &rustango::sql::Pool,
44    page_id: i64,
45    form_map: &std::collections::HashMap<String, String>,
46) -> std::collections::HashMap<String, String> {
47    let mut out = form_map.clone();
48    if let Ok(widgets) = handler.widgets(pool, page_id).await {
49        for w in widgets {
50            if w.kind == crate::widget::WidgetKind::RichText {
51                if let Some(raw) = out.get(&w.name) {
52                    let cleaned = crate::markdown::sanitize_html(raw);
53                    out.insert(w.name.clone(), cleaned);
54                }
55            }
56        }
57    }
58    out
59}
60
61/// How long a preview token stays valid: long enough for an editor to
62/// click through and iterate, short enough that a URL pasted into a chat
63/// stops working before it becomes a way in.
64const PREVIEW_TOKEN_TTL_SECS: i64 = 3600;
65
66/// Render a CMS-admin Tera template with the CSRF token + drained
67/// flash messages stamped into the context. Returns a `Response`
68/// that carries:
69///   - any `Set-Cookie` the CSRF middleware needs to mint a fresh
70///     token (first GET per session, or when the cookie was
71///     invalidated);
72///   - the clear-cookie that empties the messages store so each
73///     flash renders exactly once.
74///
75/// Every form-rendering admin handler routes through this helper so
76/// `{{ csrf_token | csrf_input | safe }}` and
77/// `{% for msg in messages %}…{% endfor %}` in templates always
78/// resolve correctly.
79pub(crate) fn render_with_csrf(
80    state: &super::AdminState,
81    headers: &HeaderMap,
82    template: &str,
83    ctx: &mut Context,
84) -> Result<Response, AdminError> {
85    // #525/#526 — resolve the admin UI locale per request and expose it to the
86    // template. Done here so every admin page picks it up without threading
87    // through each handler. Precedence: sticky cookie → per-user preference
88    // (#526, surfaced into the ctx by `add_user_chrome`) → Accept-Language →
89    // per-tenant default (#526) → English.
90    let user_pref = ctx
91        .get("user_lang_pref")
92        .and_then(|v| v.as_str())
93        .map(str::to_owned);
94    let tenant_default = super::i18n::tenant_default_locale();
95    let lang = super::i18n::negotiate(
96        headers.get(header::COOKIE).and_then(|v| v.to_str().ok()),
97        headers
98            .get(header::ACCEPT_LANGUAGE)
99            .and_then(|v| v.to_str().ok()),
100        user_pref.as_deref(),
101        tenant_default.as_deref(),
102    );
103    let lang_dir = rustango::i18n::text_direction(&lang);
104    ctx.insert("LANG", &lang);
105    ctx.insert("LANG_DIR", lang_dir);
106    let csrf_cookie = rustango::forms::csrf::stamp_into_context(headers, ctx);
107    let msg_clear = rustango::messages::stamp_into_context(messages_secret(), headers, ctx);
108    let html = state.tera.render(template, ctx)?;
109    let mut resp = Html(html).into_response();
110    if let Some(c) = csrf_cookie {
111        if let Ok(v) = HeaderValue::from_str(&c) {
112            resp.headers_mut().append(header::SET_COOKIE, v);
113        }
114    }
115    if let Some(c) = msg_clear {
116        if let Ok(v) = HeaderValue::from_str(&c) {
117            resp.headers_mut().append(header::SET_COOKIE, v);
118        }
119    }
120    Ok(resp)
121}
122
123/// Redirect to a named route registered in [`crate::urls`] AND
124/// stage a flash message ([`rustango::messages`]) in the response
125/// cookie so the next GET at the destination renders it through
126/// the `messages` Tera context variable. The standard "POST → 303
127/// → render flash" idiom — every cms-admin POST handler returns
128/// through this (or its `_with_params` cousin) so editors get
129/// real feedback instead of a silent navigation.
130fn redirect_named_with_message(
131    name: &'static str,
132    level: MsgLevel,
133    body: &str,
134    headers: &HeaderMap,
135) -> Result<Response, AdminError> {
136    let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
137        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
138    // #528 — localize the flash for the request's admin locale (English source
139    // is the key; untranslated → unchanged).
140    let body = super::i18n::tr(headers, body, &[]);
141    Ok(rustango::messages::redirect_with_message(
142        messages_secret(),
143        headers,
144        level,
145        &body,
146        &url,
147    ))
148}
149
150/// Like [`redirect_named_with_message`] but the message is a **parameterized**
151/// translation key: the English source — with `{name}` placeholders — is
152/// the catalog key, localized + interpolated for the request locale before
153/// staging. Use instead of `&format!(…)` so the flash localizes. The framework
154/// substitutes placeholders into the source-string fallback too, so English
155/// (empty catalog) renders correctly without a catalog entry.
156fn redirect_named_with_message_args(
157    name: &'static str,
158    level: MsgLevel,
159    key: &str,
160    args: &[(&str, &str)],
161    headers: &HeaderMap,
162) -> Result<Response, AdminError> {
163    let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
164        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
165    let body = super::i18n::tr(headers, key, args);
166    Ok(rustango::messages::redirect_with_message(
167        messages_secret(),
168        headers,
169        level,
170        &body,
171        &url,
172    ))
173}
174
175/// Count-aware cousin of [`redirect_named_with_message_args`]:
176/// `key` is a plural source key, the form is chosen for `n` in the request
177/// locale (CLDR rules) and `args` interpolated. Pass the count as an arg too
178/// (e.g. `("count", &n.to_string())`) so the chosen form's `{count}` fills in.
179fn redirect_named_with_message_plural(
180    name: &'static str,
181    level: MsgLevel,
182    key: &str,
183    n: i64,
184    args: &[(&str, &str)],
185    headers: &HeaderMap,
186) -> Result<Response, AdminError> {
187    let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
188        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
189    let body = super::i18n::tr_plural(headers, key, n, args);
190    Ok(rustango::messages::redirect_with_message(
191        messages_secret(),
192        headers,
193        level,
194        &body,
195        &url,
196    ))
197}
198
199/// Plural cousin of [`redirect_named_with_params_and_message`] —
200/// for routes with path params AND a count-aware message.
201fn redirect_named_with_params_and_message_plural(
202    name: &'static str,
203    params: &[(&str, String)],
204    level: MsgLevel,
205    key: &str,
206    n: i64,
207    args: &[(&str, &str)],
208    headers: &HeaderMap,
209) -> Result<Response, AdminError> {
210    let owned: std::collections::HashMap<String, String> = params
211        .iter()
212        .map(|(k, v)| ((*k).to_owned(), v.clone()))
213        .collect();
214    let url = rustango::urls::reverse_owned(name, &owned)
215        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
216    let body = super::i18n::tr_plural(headers, key, n, args);
217    Ok(rustango::messages::redirect_with_message(
218        messages_secret(),
219        headers,
220        level,
221        &body,
222        &url,
223    ))
224}
225
226/// Friendly 401 response for handlers that bail when
227/// `SessionUser` resolves to `None`. Two content-types based on
228/// `Accept`:
229///
230/// - **`application/json`** — JSON `{ error: "session_expired",
231///   message, login_url }`. XHR / fetch clients (notably the bulk
232///   media uploader) used to inline-dump the HTML page into a toast,
233///   which read as garbage. JSON lets the client render a clean
234///   "Sign in again to keep uploading" banner instead.
235/// - **Anything else** — the HTML explainer page below, useful for
236///   `<form>` POSTs that hit Submit after the cookie went stale.
237///
238/// The middleware-level `with_login_required` layer already
239/// 302s anonymous GETs to /login. A POST hitting this guard means
240/// the cookie was DECODED as anonymous (expired / wrong tenant /
241/// stale), so a hard 401 with an explanation lands better than a
242/// redirect loop.
243fn unauthorized_no_session() -> Response {
244    unauthorized_no_session_for(None)
245}
246
247/// Content-negotiating variant of [`unauthorized_no_session`]. Pass
248/// the request `HeaderMap` so the client's `Accept` (and the legacy
249/// `X-Requested-With: XMLHttpRequest`) can pick between the JSON
250/// payload and the HTML page.
251fn unauthorized_no_session_for(headers: Option<&HeaderMap>) -> Response {
252    let wants_json = headers
253        .map(|h| {
254            let accept = h
255                .get(header::ACCEPT)
256                .and_then(|v| v.to_str().ok())
257                .unwrap_or("");
258            if accept.contains("application/json") {
259                return true;
260            }
261            h.get("x-requested-with")
262                .and_then(|v| v.to_str().ok())
263                .is_some_and(|v| v.eq_ignore_ascii_case("XMLHttpRequest"))
264        })
265        .unwrap_or(false);
266    // #528 — localize for the request's admin locale when headers are present
267    // (this is the one polished user-facing admin error page); English otherwise.
268    let t = |key: &str| -> String {
269        match headers {
270            Some(h) => super::i18n::tr(h, key, &[]),
271            None => key.to_owned(),
272        }
273    };
274    if wants_json {
275        let payload = serde_json::json!({
276            "error": "session_expired",
277            "message": t("Sign in again to keep uploading."),
278            "login_url": "/login?next=/cms-admin/",
279        });
280        return (
281            axum::http::StatusCode::UNAUTHORIZED,
282            [(axum::http::header::CONTENT_TYPE, "application/json")],
283            serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
284        )
285            .into_response();
286    }
287    let lang = headers
288        .map(|h| {
289            super::i18n::negotiate(
290                h.get(header::COOKIE).and_then(|v| v.to_str().ok()),
291                h.get(header::ACCEPT_LANGUAGE).and_then(|v| v.to_str().ok()),
292                None,
293                super::i18n::tenant_default_locale().as_deref(),
294            )
295        })
296        .unwrap_or_else(|| "en".to_owned());
297    let dir = rustango::i18n::text_direction(&lang);
298    const STYLE: &str = r#"<style>
299body{font:14px/1.5 -apple-system,system-ui,sans-serif;color:#222;background:#fafafa;margin:0;padding:48px 20px}
300.box{max-width:560px;margin:0 auto;padding:32px;background:#fff;border-radius:12px;box-shadow:0 2px 8px rgba(0,0,0,.08)}
301h1{font-size:18px;margin:0 0 12px}
302p{margin:0 0 12px;color:#444}
303ul{margin:0 0 12px;padding-left:20px;color:#444}
304li{margin:4px 0}
305a{color:#1565c0}
306</style>"#;
307    let mut body = String::with_capacity(STYLE.len() + 1024);
308    body.push_str("<!doctype html>\n<html lang=\"");
309    body.push_str(&crate::forms::render::html_escape(&lang));
310    body.push_str("\" dir=\"");
311    body.push_str(dir);
312    body.push_str("\"><head><meta charset=\"utf-8\"><title>");
313    body.push_str(&crate::forms::render::html_escape(&t("Session expired")));
314    body.push_str(" — ");
315    body.push_str(&crate::forms::render::html_escape(&t("CMS Admin")));
316    body.push_str("</title>");
317    body.push_str(STYLE);
318    body.push_str("</head><body><div class=\"box\">\n<h1>");
319    body.push_str(&crate::forms::render::html_escape(&t(
320        "Your session has expired",
321    )));
322    body.push_str("</h1>\n<p>");
323    body.push_str(&crate::forms::render::html_escape(&t(
324        "The form couldn't be saved because your admin session decoded as anonymous. The most likely causes:",
325    )));
326    body.push_str("</p>\n<ul>\n<li>");
327    body.push_str(&crate::forms::render::html_escape(&t(
328        "Your login session expired or was signed out from another tab.",
329    )));
330    body.push_str("</li>\n<li>");
331    body.push_str(&crate::forms::render::html_escape(&t(
332        "The cookie was issued for a different tenant slug.",
333    )));
334    body.push_str("</li>\n<li>");
335    body.push_str(&crate::forms::render::html_escape(&t(
336        "On sqlite/mysql builds the framework's tenant session store may not be wired up yet (see issue #259).",
337    )));
338    body.push_str("</li>\n</ul>\n<p><a href=\"/login?next=/cms-admin/\">");
339    body.push_str(&crate::forms::render::html_escape(&t("Sign back in")));
340    body.push_str("</a>");
341    body.push_str(&crate::forms::render::html_escape(&t(
342        ", then re-submit the form.",
343    )));
344    body.push_str("</p>\n</div></body></html>");
345    (
346        axum::http::StatusCode::UNAUTHORIZED,
347        [(axum::http::header::CONTENT_TYPE, "text/html; charset=utf-8")],
348        body,
349    )
350        .into_response()
351}
352
353/// Like [`redirect_named_with_message`], but for routes with path
354/// parameters (e.g. `rcms-admin:pages:edit` needing `{id}`).
355pub(crate) fn redirect_named_with_params_and_message(
356    name: &'static str,
357    params: &[(&str, String)],
358    level: MsgLevel,
359    body: &str,
360    headers: &HeaderMap,
361) -> Result<Response, AdminError> {
362    let owned: std::collections::HashMap<String, String> = params
363        .iter()
364        .map(|(k, v)| ((*k).to_owned(), v.clone()))
365        .collect();
366    let url = rustango::urls::reverse_owned(name, &owned)
367        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
368    // #528 — localize the flash for the request's admin locale.
369    let body = super::i18n::tr(headers, body, &[]);
370    Ok(rustango::messages::redirect_with_message(
371        messages_secret(),
372        headers,
373        level,
374        &body,
375        &url,
376    ))
377}
378
379/// Parameterized-key cousin of [`redirect_named_with_params_and_message`]
380/// for routes that take path params AND a localized message with `{name}`
381/// interpolation.
382pub(crate) fn redirect_named_with_params_and_message_args(
383    name: &'static str,
384    params: &[(&str, String)],
385    level: MsgLevel,
386    key: &str,
387    args: &[(&str, &str)],
388    headers: &HeaderMap,
389) -> Result<Response, AdminError> {
390    let owned: std::collections::HashMap<String, String> = params
391        .iter()
392        .map(|(k, v)| ((*k).to_owned(), v.clone()))
393        .collect();
394    let url = rustango::urls::reverse_owned(name, &owned)
395        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
396    let body = super::i18n::tr(headers, key, args);
397    Ok(rustango::messages::redirect_with_message(
398        messages_secret(),
399        headers,
400        level,
401        &body,
402        &url,
403    ))
404}
405
406/// Resolve the post-save redirect from the three-action save
407/// footer (`_save` / `_continue` /
408/// `_addanother`). Shared by `page_new_submit` and `page_edit_submit`
409/// so both honour the same button the editor pressed:
410///
411/// * `continue`   → back to **this** page's edit form (keep editing).
412/// * `addanother` → a fresh new-page form, preselecting the same parent
413///   so the next page lands as a sibling (`pages:new` honours
414///   `?parent=<id>`); root pages omit the query.
415/// * anything else (incl. the default `save` / missing) → the page list.
416///
417/// `body` must already be localized by the caller (via `tr` / `tr_plural`) —
418/// this dispatcher only resolves the destination URL and stages the message,
419/// so every branch (including `addanother`) treats `body` identically.
420fn redirect_after_page_save(
421    action: &str,
422    page_id: i64,
423    parent_id: Option<i64>,
424    body: &str,
425    headers: &HeaderMap,
426) -> Result<Response, AdminError> {
427    let url = match action {
428        "continue" => rustango::urls::reverse_owned(
429            "rcms-admin:pages:edit",
430            &std::iter::once(("id".to_owned(), page_id.to_string())).collect(),
431        )
432        .map_err(|e| AdminError::Validation(format!("url reversal of `pages:edit` failed: {e}")))?,
433        "addanother" => {
434            let base =
435                rustango::urls::reverse("rcms-admin:pages:new", &std::collections::HashMap::new())
436                    .map_err(|e| {
437                        AdminError::Validation(format!("url reversal of `pages:new` failed: {e}"))
438                    })?;
439            match parent_id {
440                Some(pid) => format!("{base}?parent={pid}"),
441                None => base,
442            }
443        }
444        _ => rustango::urls::reverse("rcms-admin:pages:list", &std::collections::HashMap::new())
445            .map_err(|e| {
446                AdminError::Validation(format!("url reversal of `pages:list` failed: {e}"))
447            })?,
448    };
449    Ok(rustango::messages::redirect_with_message(
450        messages_secret(),
451        headers,
452        MsgLevel::Success,
453        body,
454        &url,
455    ))
456}
457
458/// A user's email: the `email` column — what member sign-in, SSO and
459/// sign-up use — else the address older admin versions kept in
460/// `data.email`. Empty when neither is set.
461pub(crate) fn user_email(u: &rustango::tenancy::auth::User) -> String {
462    u.email
463        .as_deref()
464        .map(str::trim)
465        .filter(|e| !e.is_empty())
466        .or_else(|| u.data.get("email").and_then(|v| v.as_str()).map(str::trim))
467        .unwrap_or("")
468        .to_owned()
469}
470
471/// Add the chrome variables every section template reads from
472/// `_base.html`: which sidebar tab is active, the brand-display
473/// name, the current tenant slug, and — when a [`SessionUser`](rustango::extractors::SessionUser) is
474/// in scope — the sidebar gating set + per-user timezone.
475///
476/// Pass `session_user.as_ref()` from the handler signature; pass
477/// `None` for anon flows (login / password-reset). When `None`,
478/// `sidebar_gating` stays `false` so every sidebar item renders.
479///
480/// Public so a host application's [`AdminPageHandler`] can render inside
481/// the admin chrome. Without it the extension point only works for a page
482/// that does NOT extend `rcms_admin/_base.html`, since that template
483/// dereferences roughly two dozen chrome variables — and hand-supplying
484/// them in a host app is a copy that drifts silently on every release.
485///
486/// [`AdminPageHandler`]: super::admin_page::AdminPageHandler
487pub async fn add_chrome(
488    ctx: &mut Context,
489    tenant: &Tenant,
490    active_tab: &str,
491    session_user: Option<&rustango::tenancy::auth::User>,
492) {
493    add_chrome_sync(ctx, tenant, active_tab);
494    if let Some(user) = session_user {
495        add_user_chrome(ctx, user, tenant.pool()).await;
496    }
497    // #199 — per-tenant logo + favicon URLs (see [`add_branding_urls`]).
498    add_branding_urls(ctx, tenant).await;
499}
500
501/// Inject the per-tenant admin logo + favicon URLs from the `branding`
502/// site setting into a template context. Missing/empty rows leave the ctx slots
503/// unset, so templates fall back to the brand-name text + default icon. Shared
504/// by the authenticated chrome ([`add_chrome`]) and the pre-auth login /
505/// password-reset screens (which have no `add_chrome`), so those can show the
506/// tenant's branding too. The serve routes (`/__cms-branding/*`) live in
507/// `public_router` so the images load before sign-in.
508pub(crate) async fn add_branding_urls(ctx: &mut Context, tenant: &Tenant) {
509    // The site's name as visitors know it: the owner's Branding "Site
510    // name", else the tenant's display name (set by the operator).
511    let mut site_name = tenant.org.display_name.clone();
512    if let Ok(Some(row)) = crate::site_setting::get(tenant.pool(), "branding").await {
513        if let Some(n) = row.value_json.get("site_name").and_then(|v| v.as_str()).filter(|n| !n.trim().is_empty()) {
514            n.trim().clone_into(&mut site_name);
515        }
516        let is_set = |key: &str| {
517            row.value_json
518                .get(key)
519                .and_then(|v| v.as_str())
520                .is_some_and(|s| !s.is_empty())
521        };
522        if is_set("logo_storage_key") {
523            ctx.insert("branding_logo_url", "/__cms-branding/logo");
524        }
525        if is_set("favicon_storage_key") {
526            ctx.insert("branding_favicon_url", "/__cms-branding/favicon");
527        }
528    }
529    ctx.insert("site_name", &site_name);
530}
531
532/// Sync core of [`add_chrome`] — every call site benefits from
533/// re-using it, so it's broken out for clarity. Stuffs the static
534/// chrome bits (tab, tenant, brand, default tz, registered admin
535/// pages) into the context.
536fn add_chrome_sync(ctx: &mut Context, tenant: &Tenant, active_tab: &str) {
537    ctx.insert("active_tab", active_tab);
538    ctx.insert("tenant_slug", &tenant.org.slug);
539    // #524 — admin UI locale + text direction for `<html lang/dir>` and the
540    // `translate(locale=LANG)` calls. The default here is overridden per
541    // request by `render_with_csrf` (#525 negotiation).
542    ctx.insert("LANG", "en");
543    ctx.insert("LANG_DIR", "ltr");
544    // #525 — the shipped UI locales, for the language switcher.
545    ctx.insert(
546        "ui_locales",
547        &super::i18n::UI_LOCALES
548            .iter()
549            .map(|(c, n)| serde_json::json!({ "code": c, "name": n }))
550            .collect::<Vec<_>>(),
551    );
552    let brand = tenant
553        .org
554        .brand_name
555        .clone()
556        .filter(|s| !s.is_empty())
557        .unwrap_or_else(|| tenant.org.display_name.clone());
558    ctx.insert("brand_name", &brand);
559    // user_timezone defaults to empty; PG-authenticated requests
560    // get it filled in via `add_user_chrome` (called explicitly by
561    // handlers that have a SessionUser extractor in scope).
562    ctx.insert("user_timezone", "");
563    // #13 V2 — tenant default timezone. Sourced from
564    // `RUSTANGO_CMS_DEFAULT_TIMEZONE` so multi-tenant deployments can
565    // pin a sensible regional default without a schema change. The
566    // boot script in _base.html resolves in order:
567    //   user pref → tenant default → browser default.
568    // Process configuration, read once rather than on every admin page.
569    static DEFAULT_TZ: std::sync::OnceLock<String> = std::sync::OnceLock::new();
570    let tenant_default_tz = DEFAULT_TZ
571        .get_or_init(|| crate::config::var("DEFAULT_TIMEZONE").unwrap_or_default())
572        .clone();
573    ctx.insert("tenant_default_timezone", &tenant_default_tz);
574
575    // Custom admin pages (#23) — bucket every registered handler by
576    // its declared sidebar section so `_base.html` can group them
577    // under the right heading. Sort within each bucket by
578    // `(sort_order, label)` so authors can pin position.
579    let mut by_section: std::collections::BTreeMap<String, Vec<serde_json::Value>> =
580        std::collections::BTreeMap::new();
581    for handler in super::admin_page::registered_admin_pages() {
582        let section = handler.section().label().to_owned();
583        by_section
584            .entry(section)
585            .or_default()
586            .push(serde_json::json!({
587                "slug": handler.slug(),
588                "label": handler.label(),
589                "icon": handler.icon(),
590                "sort_order": handler.sort_order(),
591            }));
592    }
593    for items in by_section.values_mut() {
594        items.sort_by(|a, b| {
595            let ao = a.get("sort_order").and_then(|v| v.as_i64()).unwrap_or(100);
596            let bo = b.get("sort_order").and_then(|v| v.as_i64()).unwrap_or(100);
597            ao.cmp(&bo).then_with(|| {
598                a.get("label")
599                    .and_then(|v| v.as_str())
600                    .unwrap_or("")
601                    .cmp(b.get("label").and_then(|v| v.as_str()).unwrap_or(""))
602            })
603        });
604    }
605    ctx.insert("extra_admin_pages_by_section", &by_section);
606    // #439 — registry-driven report links. `_base.html` lists these
607    // under the Reports group below the built-in reports, so a
608    // `register_report!`ed report shows up in the nav with no template
609    // edit. Already title-sorted by `registered_reports()`.
610    let reports_nav: Vec<serde_json::Value> = super::report::registered_reports()
611        .iter()
612        .map(|r| {
613            serde_json::json!({
614                "slug": r.slug(),
615                "title": r.title(),
616                "icon": r.icon(),
617            })
618        })
619        .collect();
620    ctx.insert("registered_reports", &reports_nav);
621    // #107 — plugin-contributed admin menu items (runtime hook B13).
622    // Rendered at the bottom of the sidebar in stable key order.
623    let plugin_menu_items: Vec<serde_json::Value> = crate::hooks::admin_menu_items()
624        .into_iter()
625        .map(|i| {
626            serde_json::json!({
627                "key": i.key,
628                "label": i.label,
629                "icon": i.icon,
630                "href": i.href,
631            })
632        })
633        .collect();
634    ctx.insert("plugin_admin_menu_items", &plugin_menu_items);
635    // #127 — help-menu entries. Rendered in a
636    // dedicated "Help" sidebar section above Plugins.
637    let help_menu_items: Vec<serde_json::Value> = crate::hooks::help_menu_items()
638        .into_iter()
639        .map(|i| {
640            serde_json::json!({
641                "key": i.key,
642                "label": i.label,
643                "icon": i.icon,
644                "href": i.href,
645            })
646        })
647        .collect();
648    ctx.insert("help_menu_items", &help_menu_items);
649    // #422 — plugin-injected global admin CSS / JS. `_base.html` emits each blob inside
650    // a <style> / <script> tag.
651    ctx.insert("admin_css_blobs", &crate::hooks::admin_css());
652    ctx.insert("admin_js_blobs", &crate::hooks::admin_js());
653    // Sidebar gating defaults: when no SessionUser is in scope (anon
654    // public_router flows like login + password-reset), keep every
655    // sidebar item visible. Handlers with a `SessionUser` extractor
656    // override this via `add_user_chrome` below.
657    ctx.insert("sidebar_gating", &false);
658    ctx.insert("user_is_superuser", &false);
659    ctx.insert(
660        "allowed_resources",
661        &std::collections::HashSet::<String>::new(),
662    );
663}
664
665/// Per-request chrome extension for authenticated requests. Fills in
666/// the bits `add_chrome` can't compute without a user in scope:
667///
668/// - `user_timezone` from `User.data.timezone`. Empty when
669///   unset so the no-flash JS falls back to the browser TZ.
670/// - `allowed_resources`: the union of role codenames the user
671///   inherits, used to gate sidebar items + admin-side CRUD chips.
672///   Superusers skip the gating set entirely (the sidebar
673///   template checks `user_is_superuser` first).
674/// - `user_is_superuser`: short-circuit flag exposed to templates so
675///   they don't iterate the codename set when access is unconditional.
676/// - `sidebar_gating: true`: tells `_base.html` to start honoring
677///   the gating set (anon flows leave this `false` so login pages
678///   render their full chrome).
679pub(crate) async fn add_user_chrome(
680    ctx: &mut Context,
681    user: &rustango::tenancy::auth::User,
682    pool: &rustango::sql::Pool,
683) {
684    let user_timezone = user
685        .data
686        .get("timezone")
687        .and_then(serde_json::Value::as_str)
688        .unwrap_or("")
689        .to_owned();
690    ctx.insert("user_timezone", &user_timezone);
691    // #526 — durable per-user admin UI language. Surfaced into the ctx here (the
692    // one place with the authenticated user) so `render_with_csrf` can fold it
693    // into locale negotiation without threading the user through every handler.
694    if let Some(pref) = user
695        .data
696        .get("admin_lang")
697        .and_then(serde_json::Value::as_str)
698        .filter(|s| super::i18n::is_ui_locale(s))
699    {
700        ctx.insert("user_lang_pref", pref);
701    }
702    ctx.insert("user_is_superuser", &user.is_superuser);
703    ctx.insert("user_username", &user.username);
704    // #201 — profile chrome. The display name lives in
705    // rustango_users.data.display_name; fall back to the username.
706    // Avatar lives at /__cms-avatar/<user_id> when the user uploaded
707    // one (avatar_path is set as a side-effect of the upload route).
708    let display_name = user
709        .data
710        .get("display_name")
711        .and_then(serde_json::Value::as_str)
712        .filter(|s| !s.is_empty())
713        .unwrap_or(&user.username)
714        .to_owned();
715    ctx.insert("user_display_name", &display_name);
716    let has_avatar = user
717        .data
718        .get("avatar_path")
719        .and_then(serde_json::Value::as_str)
720        .map(|s| !s.is_empty())
721        .unwrap_or(false);
722    if has_avatar {
723        let uid = user.id.get().copied().unwrap_or(0);
724        ctx.insert("user_avatar_url", &format!("/__cms-avatar/{uid}"));
725    }
726    let codenames = if user.is_superuser {
727        // Superusers bypass gating; we still hand the template an
728        // empty set so unconditional checks work without branching.
729        std::collections::HashSet::<String>::new()
730    } else {
731        let uid = user.id.get().copied().unwrap_or(0);
732        crate::permissions::user_codenames(pool, uid)
733            .await
734            .unwrap_or_default()
735    };
736    ctx.insert("allowed_resources", &codenames);
737    ctx.insert("sidebar_gating", &true);
738}
739
740/// GET /cms-admin/media/collections — manage every collection in the
741/// tenant. Tree view with depth-indented names, per-row rename /
742/// delete + a "new" form per parent.
743pub async fn collections_list(
744    State(state): State<super::AdminState>,
745    tenant: Tenant,
746    headers: HeaderMap,
747    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
748) -> Result<Response, AdminError> {
749    let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
750        .order_by(&[("parent_id", false), ("sort_order", false), ("name", false)])
751        .fetch(tenant.pool())
752        .await?;
753    // Walk into a depth-tagged tree so the template can render
754    // indented names without computing the depth itself.
755    let by_id: std::collections::HashMap<i64, &crate::media::MediaCollection> = collections
756        .iter()
757        .filter_map(|c| c.id.get().copied().map(|id| (id, c)))
758        .collect();
759    fn depth(
760        c: &crate::media::MediaCollection,
761        by_id: &std::collections::HashMap<i64, &crate::media::MediaCollection>,
762        cache: &mut std::collections::HashMap<i64, i32>,
763    ) -> i32 {
764        let id = c.id.get().copied().unwrap_or_default();
765        if let Some(d) = cache.get(&id) {
766            return *d;
767        }
768        let d = match c.parent_id {
769            None => 0,
770            Some(pid) => match by_id.get(&pid) {
771                Some(parent) => depth(parent, by_id, cache) + 1,
772                None => 0,
773            },
774        };
775        cache.insert(id, d);
776        d
777    }
778    // Media counts per collection so editors see usage at a glance.
779    let media: Vec<Media> = Media::objects().fetch(tenant.pool()).await?;
780    let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
781    for m in &media {
782        if let Some(cid) = m.collection_id {
783            *counts.entry(cid).or_insert(0) += 1;
784        }
785    }
786    let mut depth_cache: std::collections::HashMap<i64, i32> = std::collections::HashMap::new();
787    let rows: Vec<serde_json::Value> = collections
788        .iter()
789        .map(|c| {
790            let id = c.id.get().copied().unwrap_or_default();
791            serde_json::json!({
792                "id": id,
793                "name": c.name,
794                "parent_id": c.parent_id,
795                // #318 — resolve the parent FK to its display name so the
796                // list shows "Photos" instead of a raw `#17`.
797                "parent_name": c.parent_id.and_then(|pid| by_id.get(&pid)).map(|p| p.name.clone()),
798                "sort_order": c.sort_order,
799                "depth": depth(c, &by_id, &mut depth_cache),
800                "media_count": counts.get(&id).copied().unwrap_or(0),
801                "created_at": c.created_at.get().copied(),
802            })
803        })
804        .collect();
805
806    let mut ctx = Context::new();
807    add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
808    add_admin_theme(&mut ctx, tenant.pool()).await;
809    ctx.insert("collections", &rows);
810    render_with_csrf(
811        &state,
812        &headers,
813        "rcms_admin/collections_list.html",
814        &mut ctx,
815    )
816}
817
818/// Form payload for create / rename of a collection.
819#[derive(Debug, Deserialize)]
820pub struct CollectionForm {
821    pub name: String,
822    #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
823    pub parent_id: Option<i64>,
824    #[serde(default)]
825    pub sort_order: Option<i32>,
826}
827
828/// POST /cms-admin/media/collections/new — create.
829pub async fn collections_create(
830    State(_state): State<super::AdminState>,
831    tenant: Tenant,
832    headers: HeaderMap,
833    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
834    Form(form): Form<CollectionForm>,
835) -> Result<Response, AdminError> {
836    let name = form.name.trim().to_owned();
837    if name.is_empty() {
838        return Err(AdminError::Validation(
839            "Collection name is required.".to_owned(),
840        ));
841    }
842    let mut row = crate::media::MediaCollection {
843        id: rustango::sql::Auto::Unset,
844        name: name.clone(),
845        parent_id: form.parent_id,
846        sort_order: form.sort_order.unwrap_or(100),
847        created_at: rustango::sql::Auto::Unset,
848    };
849    row.insert_pool(tenant.pool()).await?;
850    redirect_named_with_message_args(
851        "rcms-admin:media:collections",
852        MsgLevel::Success,
853        "Collection “{name}” created.",
854        &[("name", name.as_str())],
855        &headers,
856    )
857}
858
859/// POST /cms-admin/media/collections/{id}/edit — rename + re-parent
860/// + reorder. The form posts all three fields; missing parent_id
861/// (empty / "0") sends the collection to the root.
862pub async fn collections_edit(
863    State(_state): State<super::AdminState>,
864    tenant: Tenant,
865    headers: HeaderMap,
866    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
867    Path(id): Path<i64>,
868    Form(form): Form<CollectionForm>,
869) -> Result<Response, AdminError> {
870    let mut row = crate::media::MediaCollection::objects()
871        .where_(crate::media::MediaCollection::id.eq(id))
872        .first(tenant.pool())
873        .await?
874        .ok_or(AdminError::NotFound(id))?;
875    let name = form.name.trim().to_owned();
876    if name.is_empty() {
877        return Err(AdminError::Validation(
878            "Collection name is required.".to_owned(),
879        ));
880    }
881    // Guard against parent_id = self (would orphan the row from
882    // the tree walk).
883    if form.parent_id == Some(id) {
884        return Err(AdminError::Validation(
885            "A collection cannot be its own parent.".to_owned(),
886        ));
887    }
888    row.name = name;
889    row.parent_id = form.parent_id;
890    if let Some(so) = form.sort_order {
891        row.sort_order = so;
892    }
893    row.save_pool(tenant.pool()).await?;
894    redirect_named_with_message(
895        "rcms-admin:media:collections",
896        MsgLevel::Success,
897        "Collection saved.",
898        &headers,
899    )
900}
901
902/// POST /cms-admin/media/collections/{id}/delete — soft delete via
903/// re-parent then delete. Child collections are re-parented to the
904/// deleted row's parent; media rows lose their collection_id (FK
905/// nulls).
906pub async fn collections_delete(
907    State(_state): State<super::AdminState>,
908    tenant: Tenant,
909    headers: HeaderMap,
910    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
911    Path(id): Path<i64>,
912) -> Result<Response, AdminError> {
913    let row = crate::media::MediaCollection::objects()
914        .where_(crate::media::MediaCollection::id.eq(id))
915        .first(tenant.pool())
916        .await?
917        .ok_or(AdminError::NotFound(id))?;
918    let parent = row.parent_id;
919    let name = row.name.clone();
920    // Re-parent children so the subtree doesn't dangle.
921    for mut child in crate::media::MediaCollection::objects()
922        .where_(crate::media::MediaCollection::parent_id.eq(Some(id)))
923        .fetch(tenant.pool())
924        .await?
925    {
926        child.parent_id = parent;
927        child.save_pool(tenant.pool()).await?;
928    }
929    // Null out media references — media doesn't get deleted, just
930    // moves to "uncategorized".
931    for mut m in Media::objects()
932        .where_(Media::collection_id.eq(Some(id)))
933        .fetch(tenant.pool())
934        .await?
935    {
936        m.collection_id = None;
937        m.save_pool(tenant.pool()).await?;
938    }
939    row.delete_pool(tenant.pool()).await?;
940    redirect_named_with_message_args(
941        "rcms-admin:media:collections",
942        MsgLevel::Success,
943        "Collection “{name}” deleted. Children re-parented; media moved to Uncategorized.",
944        &[("name", name.as_str())],
945        &headers,
946    )
947}
948
949// ============================================================
950// #557 — Categories / Taxonomies admin
951//
952// One vocabulary registry (`cms_taxonomy`) + a per-vocabulary tree of
953// `cms_category` rows. The category editor renders as a `Vec<Widget>`
954// through the shared `_widget.html` macro — the same engine the page
955// editor uses: base fields (name/slug/description + featured-image /
956// thumbnail MediaPickers + parent Select) plus any extension widgets a
957// custom vocabulary's handler contributes.
958// ============================================================
959
960use crate::category::model::{self as category_model, Category, CategoryError};
961
962/// Flash-redirect back to a vocabulary's category tree.
963fn category_tree_redirect(
964    slug: &str,
965    headers: &HeaderMap,
966    level: MsgLevel,
967    key: &str,
968    args: &[(&str, &str)],
969) -> Result<Response, AdminError> {
970    let body = super::i18n::tr(headers, key, args);
971    let url = format!("/cms-admin/taxonomies/{slug}");
972    Ok(rustango::messages::redirect_with_message(
973        messages_secret(),
974        headers,
975        level,
976        &body,
977        &url,
978    ))
979}
980
981fn opt_i64_from_form(form: &std::collections::HashMap<String, String>, key: &str) -> Option<i64> {
982    form.get(key)
983        .map(|s| s.trim())
984        .filter(|s| !s.is_empty())
985        .and_then(|s| s.parse::<i64>().ok())
986}
987
988/// The category editor's base fields as widgets (rendered via
989/// `_widget.html`, same as page extension fields). `parent_opts` are the
990/// selectable parents (excludes self on edit).
991fn category_base_widgets(
992    cat: Option<&Category>,
993    parent_opts: Vec<(String, String)>,
994) -> Vec<crate::widget::Widget> {
995    use crate::widget::{Widget, WidgetKind};
996    let mut opts = vec![(String::new(), "— none (top level) —".to_owned())];
997    opts.extend(parent_opts);
998    vec![
999        Widget::new(WidgetKind::Text, "name", "Name")
1000            .required()
1001            .with_value(cat.map(|c| c.name.clone()).unwrap_or_default()),
1002        Widget::new(WidgetKind::Text, "slug", "Slug")
1003            .with_help("URL identifier — auto-generated from the name if left blank.")
1004            .with_value(cat.map(|c| c.slug.clone()).unwrap_or_default()),
1005        Widget::new(WidgetKind::Textarea, "description", "Description")
1006            .with_value(cat.map(|c| c.description.clone()).unwrap_or_default()),
1007        Widget::new(
1008            WidgetKind::MediaPicker,
1009            "featured_image_id",
1010            "Featured image",
1011        )
1012        .with_value(
1013            cat.and_then(|c| c.featured_image_id)
1014                .map(|i| i.to_string())
1015                .unwrap_or_default(),
1016        ),
1017        Widget::new(WidgetKind::MediaPicker, "thumbnail_id", "Thumbnail").with_value(
1018            cat.and_then(|c| c.thumbnail_id)
1019                .map(|i| i.to_string())
1020                .unwrap_or_default(),
1021        ),
1022        Widget::new(WidgetKind::Select, "parent_id", "Parent")
1023            .with_options(opts)
1024            .with_help("Nest this category under another (siblings share a parent).")
1025            .with_value(
1026                cat.and_then(|c| c.parent_id)
1027                    .map(|i| i.to_string())
1028                    .unwrap_or_default(),
1029            ),
1030    ]
1031}
1032
1033/// Build indented `(id, "— — Name")` parent options for a vocabulary,
1034/// optionally excluding `exclude` (and, on edit, its descendants can't be
1035/// picked — the move guard rejects that at save, so we only drop self here).
1036async fn category_parent_options(
1037    pool: &rustango::sql::Pool,
1038    taxonomy_id: i64,
1039    exclude: Option<i64>,
1040) -> Result<Vec<(String, String)>, AdminError> {
1041    let cats = category_model::all_in_taxonomy(pool, taxonomy_id)
1042        .await
1043        .map_err(|e| AdminError::Validation(e.to_string()))?;
1044    Ok(cats
1045        .iter()
1046        .filter(|c| c.id.get().copied() != exclude)
1047        .map(|c| {
1048            let indent = "— ".repeat((c.depth.max(1) - 1) as usize);
1049            (
1050                c.id.get().copied().unwrap_or_default().to_string(),
1051                format!("{indent}{}", c.name),
1052            )
1053        })
1054        .collect())
1055}
1056
1057/// GET /cms-admin/taxonomies — the vocabulary index.
1058pub async fn taxonomies_index(
1059    State(state): State<super::AdminState>,
1060    tenant: Tenant,
1061    headers: HeaderMap,
1062    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1063) -> Result<Response, AdminError> {
1064    let taxes = crate::category::taxonomies(tenant.pool())
1065        .await
1066        .map_err(|e| AdminError::Validation(e.to_string()))?;
1067    let all_cats: Vec<Category> = Category::objects().fetch(tenant.pool()).await?;
1068    let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
1069    for c in &all_cats {
1070        *counts.entry(c.taxonomy_id).or_insert(0) += 1;
1071    }
1072    let rows: Vec<serde_json::Value> = taxes
1073        .iter()
1074        .map(|t| {
1075            serde_json::json!({
1076                "slug": t.slug,
1077                "verbose_name": t.verbose_name,
1078                "icon": if t.icon.is_empty() { "sell".to_owned() } else { t.icon.clone() },
1079                "description": t.description,
1080                "hierarchical": t.hierarchical,
1081                "count": counts.get(&t.id.get().copied().unwrap_or_default()).copied().unwrap_or(0),
1082            })
1083        })
1084        .collect();
1085    let mut ctx = Context::new();
1086    add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1087    add_admin_theme(&mut ctx, tenant.pool()).await;
1088    ctx.insert("taxonomies", &rows);
1089    render_with_csrf(
1090        &state,
1091        &headers,
1092        "rcms_admin/taxonomies_list.html",
1093        &mut ctx,
1094    )
1095}
1096
1097/// GET /cms-admin/taxonomies/{slug} — one vocabulary's category tree.
1098pub async fn category_tree(
1099    State(state): State<super::AdminState>,
1100    tenant: Tenant,
1101    headers: HeaderMap,
1102    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1103    Path(slug): Path<String>,
1104) -> Result<Response, AdminError> {
1105    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1106        .await
1107        .map_err(|e| AdminError::Validation(e.to_string()))?
1108        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1109    let cats =
1110        category_model::all_in_taxonomy(tenant.pool(), tax.id.get().copied().unwrap_or_default())
1111            .await
1112            .map_err(|e| AdminError::Validation(e.to_string()))?;
1113    let rows: Vec<serde_json::Value> = cats
1114        .iter()
1115        .map(|c| {
1116            serde_json::json!({
1117                "id": c.id.get().copied(),
1118                "name": c.name,
1119                "slug": c.slug,
1120                "description": c.description,
1121                "depth": c.depth,
1122                "thumbnail_id": c.thumbnail_id,
1123                "featured_image_id": c.featured_image_id,
1124            })
1125        })
1126        .collect();
1127    let mut ctx = Context::new();
1128    add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1129    add_admin_theme(&mut ctx, tenant.pool()).await;
1130    ctx.insert("taxonomy_slug", &tax.slug);
1131    ctx.insert("taxonomy_name", &tax.verbose_name);
1132    ctx.insert("categories", &rows);
1133    render_with_csrf(&state, &headers, "rcms_admin/category_tree.html", &mut ctx)
1134}
1135
1136/// GET /cms-admin/taxonomies/{slug}/categories/new — create form.
1137pub async fn category_new_form(
1138    State(state): State<super::AdminState>,
1139    tenant: Tenant,
1140    headers: HeaderMap,
1141    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1142    Path(slug): Path<String>,
1143) -> Result<Response, AdminError> {
1144    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1145        .await
1146        .map_err(|e| AdminError::Validation(e.to_string()))?
1147        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1148    let tid = tax.id.get().copied().unwrap_or_default();
1149    let mut fields = if tax.hierarchical {
1150        category_base_widgets(
1151            None,
1152            category_parent_options(tenant.pool(), tid, None).await?,
1153        )
1154    } else {
1155        // Flat vocabulary — drop the parent picker.
1156        let mut w = category_base_widgets(None, Vec::new());
1157        w.pop();
1158        w
1159    };
1160    // Extension fields are edited after create (they key on the new id).
1161    let _ = &mut fields;
1162    let mut ctx = Context::new();
1163    add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1164    add_admin_theme(&mut ctx, tenant.pool()).await;
1165    ctx.insert("taxonomy_slug", &tax.slug);
1166    ctx.insert("taxonomy_name", &tax.verbose_name);
1167    ctx.insert("mode", "new");
1168    ctx.insert("fields", &fields);
1169    render_with_csrf(&state, &headers, "rcms_admin/category_form.html", &mut ctx)
1170}
1171
1172/// POST /cms-admin/taxonomies/{slug}/categories/new — create.
1173pub async fn category_create(
1174    State(_state): State<super::AdminState>,
1175    tenant: Tenant,
1176    headers: HeaderMap,
1177    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1178    Path(slug): Path<String>,
1179    Form(form): Form<std::collections::HashMap<String, String>>,
1180) -> Result<Response, AdminError> {
1181    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1182        .await
1183        .map_err(|e| AdminError::Validation(e.to_string()))?
1184        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1185    let tid = tax.id.get().copied().unwrap_or_default();
1186    let new = category_model::NewCategory {
1187        name: form
1188            .get("name")
1189            .cloned()
1190            .unwrap_or_default()
1191            .trim()
1192            .to_owned(),
1193        slug: form.get("slug").cloned().unwrap_or_default(),
1194        description: form.get("description").cloned().unwrap_or_default(),
1195        featured_image_id: opt_i64_from_form(&form, "featured_image_id"),
1196        thumbnail_id: opt_i64_from_form(&form, "thumbnail_id"),
1197        parent_id: opt_i64_from_form(&form, "parent_id"),
1198    };
1199    if new.name.is_empty() {
1200        return category_tree_redirect(
1201            &slug,
1202            &headers,
1203            MsgLevel::Error,
1204            "Category name is required.",
1205            &[],
1206        );
1207    }
1208    match category_model::create(tenant.pool(), tid, new).await {
1209        Ok(cat) => {
1210            let id = cat.id.get().copied().unwrap_or_default();
1211            let body = super::i18n::tr(
1212                &headers,
1213                "Category “{name}” created.",
1214                &[("name", cat.name.as_str())],
1215            );
1216            let url = format!("/cms-admin/taxonomies/{slug}/categories/{id}/edit");
1217            Ok(rustango::messages::redirect_with_message(
1218                messages_secret(),
1219                &headers,
1220                MsgLevel::Success,
1221                &body,
1222                &url,
1223            ))
1224        }
1225        Err(e) => category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]),
1226    }
1227}
1228
1229/// GET /cms-admin/taxonomies/{slug}/categories/{id}/edit — edit form.
1230pub async fn category_edit_form(
1231    State(state): State<super::AdminState>,
1232    tenant: Tenant,
1233    headers: HeaderMap,
1234    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1235    Path((slug, id)): Path<(String, i64)>,
1236    Query(q): Query<EditQuery>,
1237) -> Result<Response, AdminError> {
1238    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1239        .await
1240        .map_err(|e| AdminError::Validation(e.to_string()))?
1241        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1242    let tid = tax.id.get().copied().unwrap_or_default();
1243    let cat = Category::objects()
1244        .where_(Category::id.eq(id))
1245        .where_(Category::taxonomy_id.eq(tid))
1246        .first(tenant.pool())
1247        .await?
1248        .ok_or(AdminError::NotFound(id))?;
1249    let mut fields = if tax.hierarchical {
1250        category_base_widgets(
1251            Some(&cat),
1252            category_parent_options(tenant.pool(), tid, Some(id)).await?,
1253        )
1254    } else {
1255        let mut w = category_base_widgets(Some(&cat), Vec::new());
1256        w.pop();
1257        w
1258    };
1259    // Extension widgets from the vocabulary's handler (custom typed fields).
1260    if let Some(handler) = crate::category::find_handler(&slug) {
1261        if let Ok(ext) = handler.ext_widgets(tenant.pool(), id).await {
1262            fields.extend(ext);
1263        }
1264    }
1265    let mut ctx = Context::new();
1266    add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1267    add_admin_theme(&mut ctx, tenant.pool()).await;
1268    ctx.insert("taxonomy_slug", &tax.slug);
1269    ctx.insert("taxonomy_name", &tax.verbose_name);
1270    ctx.insert("mode", "edit");
1271    ctx.insert("category_id", &id);
1272    ctx.insert("fields", &fields);
1273    // #862 — `?locale=<code>` (a non-default active locale) shows the
1274    // name's translation beside the original, like pages and snippets.
1275    let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
1276        .where_(crate::locale::Locale::active.eq(true))
1277        .order_by(&[("sort_order", false), ("code", false)])
1278        .fetch(tenant.pool())
1279        .await?;
1280    let editing_locale = q
1281        .locale
1282        .as_deref()
1283        .filter(|c| !c.is_empty())
1284        .and_then(|code| locales.iter().find(|l| l.code == code && !l.is_default).cloned());
1285    if let Some(loc) = &editing_locale {
1286        let lid = loc.id.get().copied().unwrap_or_default();
1287        let mut existing = crate::category_translation::fetch_for_categories(tenant.pool(), &[id], lid)
1288            .await
1289            .unwrap_or_default();
1290        ctx.insert("translation_mode", &true);
1291        ctx.insert("editing_locale", loc);
1292        ctx.insert("category_name", &cat.name);
1293        ctx.insert("tr_name", &existing.remove(&id).and_then(|mut f| f.remove("name")).unwrap_or_default());
1294    }
1295    ctx.insert("locales", &locales);
1296    render_with_csrf(&state, &headers, "rcms_admin/category_form.html", &mut ctx)
1297}
1298
1299/// POST /cms-admin/taxonomies/{slug}/categories/{id}/translate?locale=<code>
1300/// — save a category's per-locale name. An empty box deletes the
1301/// row, so the original shows again.
1302pub async fn category_translate_submit(
1303    State(_state): State<super::AdminState>,
1304    tenant: Tenant,
1305    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1306    Path((slug, id)): Path<(String, i64)>,
1307    Query(q): Query<EditQuery>,
1308    Form(form): Form<std::collections::HashMap<String, String>>,
1309) -> Result<Response, AdminError> {
1310    use crate::category_translation::{CategoryTranslation, TRANSLATABLE_FIELDS};
1311    let code = q
1312        .locale
1313        .as_deref()
1314        .filter(|c| !c.is_empty())
1315        .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
1316    let locale = crate::locale::Locale::objects()
1317        .where_(crate::locale::Locale::code.eq(code.to_owned()))
1318        .where_(crate::locale::Locale::active.eq(true))
1319        .where_(crate::locale::Locale::is_default.eq(false))
1320        .first(tenant.pool())
1321        .await?
1322        .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
1323    let locale_id = locale.id.get().copied().unwrap_or_default();
1324    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1325        .await
1326        .map_err(|e| AdminError::Validation(e.to_string()))?
1327        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1328    Category::objects()
1329        .where_(Category::id.eq(id))
1330        .where_(Category::taxonomy_id.eq(tax.id.get().copied().unwrap_or_default()))
1331        .first(tenant.pool())
1332        .await?
1333        .ok_or(AdminError::NotFound(id))?;
1334    rustango::atomic!(tenant.pool(), |tx| {
1335        let mut guard = tx.lock().await?;
1336        let tx = &mut *guard;
1337        for field in TRANSLATABLE_FIELDS {
1338            let Some(value) = form.get(&format!("tr__{field}")) else {
1339                continue;
1340            };
1341            let value = value.trim().to_owned();
1342            let existing: Vec<CategoryTranslation> = CategoryTranslation::objects()
1343                .where_(CategoryTranslation::category_id.eq(id))
1344                .where_(CategoryTranslation::locale_id.eq(locale_id))
1345                .where_(CategoryTranslation::field_path.eq(field.to_owned()))
1346                .fetch_tx(tx)
1347                .await?;
1348            if value.is_empty() {
1349                for row in existing {
1350                    row.delete_tx(tx).await?;
1351                }
1352            } else if let Some(mut row) = existing.into_iter().next() {
1353                row.value = value;
1354                row.save_tx(tx).await?;
1355            } else {
1356                let mut row = CategoryTranslation {
1357                    id: rustango::sql::Auto::Unset,
1358                    category_id: id,
1359                    locale_id,
1360                    field_path: field.to_owned(),
1361                    value,
1362                    updated_at: rustango::sql::Auto::Unset,
1363                };
1364                row.save_tx(tx).await?;
1365            }
1366        }
1367        Ok::<_, rustango::sql::ExecError>(())
1368    })
1369    .await?;
1370    Ok(Redirect::to(&format!("/cms-admin/taxonomies/{slug}/categories/{id}/edit?locale={code}")).into_response())
1371}
1372
1373/// POST /cms-admin/taxonomies/{slug}/categories/{id}/edit — update.
1374pub async fn category_update(
1375    State(_state): State<super::AdminState>,
1376    tenant: Tenant,
1377    headers: HeaderMap,
1378    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1379    Path((slug, id)): Path<(String, i64)>,
1380    Form(form): Form<std::collections::HashMap<String, String>>,
1381) -> Result<Response, AdminError> {
1382    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1383        .await
1384        .map_err(|e| AdminError::Validation(e.to_string()))?
1385        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1386    let tid = tax.id.get().copied().unwrap_or_default();
1387    let new = category_model::NewCategory {
1388        name: form
1389            .get("name")
1390            .cloned()
1391            .unwrap_or_default()
1392            .trim()
1393            .to_owned(),
1394        slug: form.get("slug").cloned().unwrap_or_default(),
1395        description: form.get("description").cloned().unwrap_or_default(),
1396        featured_image_id: opt_i64_from_form(&form, "featured_image_id"),
1397        thumbnail_id: opt_i64_from_form(&form, "thumbnail_id"),
1398        parent_id: opt_i64_from_form(&form, "parent_id"),
1399    };
1400    if new.name.is_empty() {
1401        return category_tree_redirect(
1402            &slug,
1403            &headers,
1404            MsgLevel::Error,
1405            "Category name is required.",
1406            &[],
1407        );
1408    }
1409    let new_parent = new.parent_id;
1410    if let Err(e) = category_model::update(tenant.pool(), tid, id, new).await {
1411        return category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]);
1412    }
1413    // Re-parent if the parent changed (cycle-guarded inside move_to;
1414    // a no-op when the parent is unchanged).
1415    if let Err(e) = category_model::move_to(tenant.pool(), tid, id, new_parent).await {
1416        return category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]);
1417    }
1418    // Extension row (custom vocabularies).
1419    if let Some(handler) = crate::category::find_handler(&slug) {
1420        if let Err(e) = handler.save_ext(tenant.pool(), id, &form).await {
1421            tracing::warn!(category_id = id, error = %e, "category extension save failed");
1422        }
1423    }
1424    category_tree_redirect(&slug, &headers, MsgLevel::Success, "Category saved.", &[])
1425}
1426
1427/// POST /cms-admin/taxonomies/{slug}/categories/{id}/delete.
1428pub async fn category_delete(
1429    State(_state): State<super::AdminState>,
1430    tenant: Tenant,
1431    headers: HeaderMap,
1432    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1433    Path((slug, id)): Path<(String, i64)>,
1434) -> Result<Response, AdminError> {
1435    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1436        .await
1437        .map_err(|e| AdminError::Validation(e.to_string()))?
1438        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1439    let tid = tax.id.get().copied().unwrap_or_default();
1440    match category_model::delete(tenant.pool(), tid, id, false).await {
1441        Ok(_) => {
1442            category_tree_redirect(&slug, &headers, MsgLevel::Success, "Category deleted.", &[])
1443        }
1444        Err(CategoryError::HasChildren(_, n)) => {
1445            let n = n.to_string();
1446            category_tree_redirect(
1447                &slug,
1448                &headers,
1449                MsgLevel::Error,
1450                "Can't delete a category with {count} child categor(ies) — delete or move them first.",
1451                &[("count", n.as_str())],
1452            )
1453        }
1454        Err(e) => category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]),
1455    }
1456}
1457
1458// ============================================================
1459// #559/#562 — Page-type field builder (visual schema constructor)
1460//
1461// A Developer authors a page type's body schema in the builder; save
1462// writes a DRAFT row, publish flips it live (versioned). Gated on the
1463// `cms_page_type.build` codename at the handler level (superuser bypass).
1464// ============================================================
1465
1466/// Deny access to the builder unless the user is a superuser or holds
1467/// `cms_page_type.build`. Returns `Some(redirect)` when denied (anon →
1468/// login, otherwise → no-access), `None` when allowed.
1469async fn ensure_builder_access(
1470    tenant: &Tenant,
1471    user: Option<&rustango::tenancy::auth::User>,
1472) -> Option<Response> {
1473    super::codename_gate(tenant, user, "cms_page_type.build").await
1474}
1475
1476/// GET /cms-admin/page-types/{id}/build — the visual builder.
1477pub async fn page_type_build_form(
1478    State(state): State<super::AdminState>,
1479    tenant: Tenant,
1480    headers: HeaderMap,
1481    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1482    Path(id): Path<i64>,
1483) -> Result<Response, AdminError> {
1484    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1485        return Ok(r);
1486    }
1487    let pt = crate::page_type_model::PageType::objects()
1488        .where_(crate::page_type_model::PageType::id.eq(id))
1489        .first(tenant.pool())
1490        .await?
1491        .ok_or(AdminError::NotFound(id))?;
1492
1493    let draft = crate::page_builder::model::draft_for(tenant.pool(), id).await?;
1494    let published = crate::page_builder::model::published_for(tenant.pool(), id).await?;
1495    // Seed the canvas from the draft, else the live published schema,
1496    // else an empty document.
1497    let doc_value = draft
1498        .as_ref()
1499        .map(|d| d.document.clone())
1500        .or_else(|| published.as_ref().map(|p| p.document.clone()))
1501        .unwrap_or_else(|| serde_json::json!({ "nodes": [] }));
1502    let schema_json =
1503        serde_json::to_string(&doc_value).unwrap_or_else(|_| "{\"nodes\":[]}".to_owned());
1504
1505    let components: Vec<serde_json::Value> =
1506        crate::page_builder::model::all_components(tenant.pool())
1507            .await?
1508            .iter()
1509            .map(|c| serde_json::json!({ "slug": c.slug, "label": c.label }))
1510            .collect();
1511    let components_json = serde_json::to_string(&components).unwrap_or_else(|_| "[]".to_owned());
1512    let versions: Vec<serde_json::Value> =
1513        crate::page_builder::model::list_versions(tenant.pool(), id)
1514            .await?
1515            .iter()
1516            .map(|v| {
1517                serde_json::json!({
1518                    "version": v.version,
1519                    "status": v.status,
1520                    "updated_at": v.updated_at.get().copied(),
1521                })
1522            })
1523            .collect();
1524
1525    // #566 — deleting a UI-created type is a danger-zone action on this
1526    // page (not an inline row action). Only for `cms_ui` types, and only
1527    // while no pages use the type.
1528    let is_ui_type = pt.app_label == "cms_ui";
1529    let page_count = if is_ui_type {
1530        Page::objects()
1531            .where_(Page::page_type_id.eq(id))
1532            .fetch(tenant.pool())
1533            .await
1534            .map(|v| v.len())
1535            .unwrap_or(0)
1536    } else {
1537        0
1538    };
1539
1540    let mut ctx = Context::new();
1541    add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
1542    add_admin_theme(&mut ctx, tenant.pool()).await;
1543    ctx.insert("page_type_id", &id);
1544    ctx.insert("title", &pt.verbose_name);
1545    ctx.insert("schema_json", &schema_json);
1546    ctx.insert("build_url", &format!("/cms-admin/page-types/{id}/build"));
1547    ctx.insert(
1548        "publish_url",
1549        &format!("/cms-admin/page-types/{id}/build/publish"),
1550    );
1551    ctx.insert("delete_url", &format!("/cms-admin/page-types/{id}/delete"));
1552    ctx.insert("list_url", "/cms-admin/page-types");
1553    ctx.insert("components_json", &components_json);
1554    ctx.insert("versions", &versions);
1555    ctx.insert("has_unpublished", &draft.is_some());
1556    // #863 — the Translate menu: other languages, once the schema is live.
1557    let translate_locales: Vec<crate::locale::Locale> = if published.is_some() {
1558        crate::locale::Locale::objects()
1559            .where_(crate::locale::Locale::active.eq(true))
1560            .where_(crate::locale::Locale::is_default.eq(false))
1561            .order_by(&[("sort_order", false), ("code", false)])
1562            .fetch(tenant.pool())
1563            .await?
1564    } else {
1565        Vec::new()
1566    };
1567    ctx.insert("translate_locales", &translate_locales);
1568    ctx.insert("translate_url", &format!("/cms-admin/page-types/{id}/translate"));
1569    ctx.insert("is_ui_type", &is_ui_type);
1570    ctx.insert("page_count", &page_count);
1571    ctx.insert("deletable", &(is_ui_type && page_count == 0));
1572    render_with_csrf(
1573        &state,
1574        &headers,
1575        "rcms_admin/page_type_builder.html",
1576        &mut ctx,
1577    )
1578}
1579
1580/// GET /cms-admin/page-types/{id}/translate?locale=<code> — the labels of
1581/// the type's choice options in another language, side by side
1582/// with the originals like every other translation screen.
1583pub async fn page_type_translate_form(
1584    State(state): State<super::AdminState>,
1585    tenant: Tenant,
1586    headers: HeaderMap,
1587    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1588    Path(id): Path<i64>,
1589    Query(q): Query<EditQuery>,
1590) -> Result<Response, AdminError> {
1591    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1592        return Ok(r);
1593    }
1594    let pt = crate::page_type_model::PageType::objects()
1595        .where_(crate::page_type_model::PageType::id.eq(id))
1596        .first(tenant.pool())
1597        .await?
1598        .ok_or(AdminError::NotFound(id))?;
1599    let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
1600    let published = crate::page_builder::model::published_for(tenant.pool(), id).await?;
1601    let fields = published
1602        .as_ref()
1603        .map(|p| crate::page_builder::choice_i18n::choice_fields(&p.document, &locale.code))
1604        .unwrap_or_default();
1605    let mut ctx = Context::new();
1606    add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
1607    add_admin_theme(&mut ctx, tenant.pool()).await;
1608    ctx.insert("title", &pt.verbose_name);
1609    ctx.insert("editing_locale", &locale);
1610    ctx.insert("choice_fields", &fields);
1611    ctx.insert("build_url", &format!("/cms-admin/page-types/{id}/build"));
1612    ctx.insert("translate_url", &format!("/cms-admin/page-types/{id}/translate"));
1613    render_with_csrf(&state, &headers, "rcms_admin/page_type_translate.html", &mut ctx)
1614}
1615
1616/// POST /cms-admin/page-types/{id}/translate?locale=<code> — store the
1617/// option labels (`tr__<field path>__<option value>`) on the published
1618/// schema and on the draft, if one is open, so publishing it keeps them.
1619pub async fn page_type_translate_submit(
1620    State(_state): State<super::AdminState>,
1621    tenant: Tenant,
1622    headers: HeaderMap,
1623    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1624    Path(id): Path<i64>,
1625    Query(q): Query<EditQuery>,
1626    Form(form): Form<Vec<(String, String)>>,
1627) -> Result<Response, AdminError> {
1628    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1629        return Ok(r);
1630    }
1631    let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
1632    let labels: std::collections::HashMap<(String, String), String> = form
1633        .into_iter()
1634        .filter_map(|(k, v)| {
1635            let rest = k.strip_prefix("tr__")?;
1636            let (path, value) = rest.split_once("__")?;
1637            Some(((path.to_owned(), value.to_owned()), v))
1638        })
1639        .collect();
1640    for row in [
1641        crate::page_builder::model::published_for(tenant.pool(), id).await?,
1642        crate::page_builder::model::draft_for(tenant.pool(), id).await?,
1643    ]
1644    .into_iter()
1645    .flatten()
1646    {
1647        let mut row = row;
1648        if crate::page_builder::choice_i18n::set_choice_labels(&mut row.document, &locale.code, &labels) > 0 {
1649            row.save_pool(tenant.pool()).await?;
1650        }
1651    }
1652    let back = format!("/cms-admin/page-types/{id}/translate?locale={}", locale.code);
1653    Ok(rustango::messages::redirect_with_message(
1654        messages_secret(),
1655        &headers,
1656        MsgLevel::Success,
1657        &super::i18n::tr(&headers, "Translations saved.", &[]),
1658        &back,
1659    ))
1660}
1661
1662/// The active, non-default locale named by `?locale=`, for the
1663/// translation screens.
1664async fn translate_locale(tenant: &Tenant, code: Option<&str>) -> Result<crate::locale::Locale, AdminError> {
1665    let code = code
1666        .filter(|c| !c.is_empty())
1667        .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
1668    crate::locale::Locale::objects()
1669        .where_(crate::locale::Locale::code.eq(code.to_owned()))
1670        .where_(crate::locale::Locale::active.eq(true))
1671        .where_(crate::locale::Locale::is_default.eq(false))
1672        .first(tenant.pool())
1673        .await?
1674        .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))
1675}
1676
1677/// Shared body for save/publish: gate, load the page type, parse +
1678/// validate the posted schema. Returns the validated document + the
1679/// problem list, or an early access/redirect / not-found response.
1680async fn parse_builder_submit(
1681    tenant: &Tenant,
1682    user: Option<&rustango::tenancy::auth::User>,
1683    id: i64,
1684    schema_str: &str,
1685) -> Result<Result<(crate::page_builder::Document, Vec<String>), Response>, AdminError> {
1686    if let Some(r) = ensure_builder_access(tenant, user).await {
1687        return Ok(Err(r));
1688    }
1689    // Ensure the page type exists.
1690    let exists = crate::page_type_model::PageType::objects()
1691        .where_(crate::page_type_model::PageType::id.eq(id))
1692        .first(tenant.pool())
1693        .await?
1694        .is_some();
1695    if !exists {
1696        return Err(AdminError::NotFound(id));
1697    }
1698    let value: serde_json::Value = serde_json::from_str(schema_str)
1699        .map_err(|e| AdminError::Validation(format!("invalid schema JSON: {e}")))?;
1700    let doc = crate::page_builder::parse_schema(&value)
1701        .map_err(|e| AdminError::Validation(format!("invalid schema document: {e}")))?;
1702    let components = crate::page_builder::model::component_map(tenant.pool()).await?;
1703    let problems = crate::page_builder::validate_schema(&doc, &components);
1704    Ok(Ok((doc, problems)))
1705}
1706
1707/// POST /cms-admin/page-types/{id}/build — save the schema as a draft.
1708/// Warnings are non-blocking (surfaced in the flash).
1709pub async fn page_type_build_submit(
1710    State(_state): State<super::AdminState>,
1711    tenant: Tenant,
1712    headers: HeaderMap,
1713    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1714    Path(id): Path<i64>,
1715    Form(form): Form<FormBuildSubmit>,
1716) -> Result<Response, AdminError> {
1717    let (doc, problems) =
1718        match parse_builder_submit(&tenant, session_user.as_ref(), id, &form.schema).await? {
1719            Ok(v) => v,
1720            Err(resp) => return Ok(resp),
1721        };
1722    let document =
1723        serde_json::to_value(&doc).unwrap_or_else(|_| serde_json::json!({ "nodes": [] }));
1724    let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
1725    crate::page_builder::model::save_draft(tenant.pool(), id, document, created_by).await?;
1726    let (level, msg) = if problems.is_empty() {
1727        (MsgLevel::Success, "Draft saved.".to_owned())
1728    } else {
1729        (
1730            MsgLevel::Warning,
1731            format!("Draft saved with warnings: {}", problems.join(" ")),
1732        )
1733    };
1734    redirect_named_with_params_and_message(
1735        "rcms-admin:page-types:build",
1736        &[("id", id.to_string())],
1737        level,
1738        &msg,
1739        &headers,
1740    )
1741}
1742
1743/// POST /cms-admin/page-types/{id}/build/publish — validate + publish the
1744/// schema. Validation errors block the publish (draft is still saved).
1745pub async fn page_type_publish_submit(
1746    State(_state): State<super::AdminState>,
1747    tenant: Tenant,
1748    headers: HeaderMap,
1749    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1750    Path(id): Path<i64>,
1751    Form(form): Form<FormBuildSubmit>,
1752) -> Result<Response, AdminError> {
1753    let (doc, problems) =
1754        match parse_builder_submit(&tenant, session_user.as_ref(), id, &form.schema).await? {
1755            Ok(v) => v,
1756            Err(resp) => return Ok(resp),
1757        };
1758    // Persist what's on screen as the draft first, so a blocked publish
1759    // still saves the editor's work.
1760    let document =
1761        serde_json::to_value(&doc).unwrap_or_else(|_| serde_json::json!({ "nodes": [] }));
1762    let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
1763    crate::page_builder::model::save_draft(tenant.pool(), id, document, created_by).await?;
1764    if !problems.is_empty() {
1765        return redirect_named_with_params_and_message(
1766            "rcms-admin:page-types:build",
1767            &[("id", id.to_string())],
1768            MsgLevel::Error,
1769            &format!("Can't publish — fix these first: {}", problems.join(" ")),
1770            &headers,
1771        );
1772    }
1773    crate::page_builder::model::publish(tenant.pool(), id).await?;
1774    redirect_named_with_params_and_message(
1775        "rcms-admin:page-types:build",
1776        &[("id", id.to_string())],
1777        MsgLevel::Success,
1778        "Schema published — the page editor now uses this structure.",
1779        &headers,
1780    )
1781}
1782
1783/// Persist a page's page-builder body values from a posted form, when
1784/// its page type has a published schema. Additive to any code
1785/// handler's `save_extension` — runs regardless of whether a handler
1786/// exists.
1787///
1788/// # Errors
1789/// A failed schema/component lookup or value write. A type with no
1790/// published schema, or one that no longer parses, has nothing to save.
1791pub(crate) async fn save_page_builder_values(
1792    pool: &rustango::sql::Pool,
1793    page_type_id: i64,
1794    page_id: i64,
1795    form_map: &std::collections::HashMap<String, String>,
1796) -> Result<(), rustango::sql::ExecError> {
1797    let Some(row) = crate::page_builder::model::published_for(pool, page_type_id).await? else {
1798        return Ok(());
1799    };
1800    let Ok(doc) = crate::page_builder::parse_schema(&row.document) else {
1801        return Ok(());
1802    };
1803    let components = crate::page_builder::model::component_map(pool).await?;
1804    let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
1805    crate::page_builder::values::save_from_form(pool, page_id, &compiled, form_map).await
1806}
1807
1808/// Save a page's type-specific content from a posted page form: the
1809/// handler's extension row and inline panels, then the page-builder
1810/// body values. Shared by the new-page and edit submits.
1811async fn save_type_content(
1812    pool: &rustango::sql::Pool,
1813    page_type: Option<&PageType>,
1814    page_type_id: i64,
1815    page_id: i64,
1816    form_map: &std::collections::HashMap<String, String>,
1817) -> Result<(), AdminError> {
1818    if let Some(handler) = page_type.and_then(|pt| find_handler(&pt.type_name)) {
1819        let ext_form = sanitized_extension_form(handler.as_ref(), pool, page_id, form_map).await;
1820        handler.save_extension(pool, page_id, &ext_form).await?;
1821        // #117 — inline panels. Reassemble row dicts from the
1822        // posted `inline__<panel>__<idx>__<field>` keys and hand
1823        // them to the handler. Handler is responsible for the
1824        // upsert / delete-removed semantics.
1825        for spec in handler.inline_panels() {
1826            let rows = extract_inline_panel_rows(form_map, &spec);
1827            handler.save_inline_panel(pool, page_id, &spec.name, &rows).await?;
1828        }
1829    }
1830    // #564 — page-builder body values (additive to any code handler).
1831    save_page_builder_values(pool, page_type_id, page_id, form_map).await?;
1832    Ok(())
1833}
1834
1835/// #146 — reindex the reference graph from the just-saved form
1836/// values. The (cheap, in-memory) scan stays here where the form is
1837/// in hand; #432 moves the (DB-write) reindex onto the task queue
1838/// via `reindex_page` — dispatched + retried when a sink is
1839/// installed, inline otherwise. Best-effort either way.
1840async fn reindex_from_form(
1841    pool: &rustango::sql::Pool,
1842    org_slug: &str,
1843    page_id: i64,
1844    form_map: &std::collections::HashMap<String, String>,
1845) {
1846    let mut refs: Vec<crate::reference_index::Reference> = Vec::new();
1847    for (key, value) in form_map {
1848        // Scan every form field for /__media__/... + page/snippet
1849        // links. Field-scoped so the index records which input
1850        // produced each reference.
1851        let mut found = crate::reference_index::scan(value, key);
1852        refs.append(&mut found);
1853    }
1854    crate::task_queue::reindex_page(pool, org_slug, page_id, refs).await;
1855}
1856
1857/// The page type's own editor fields — the handler's widgets (custom and
1858/// stream widgets pre-rendered), the page-builder body and the inline
1859/// panels — into `ctx`. `page_id` 0 is a page not created yet: every
1860/// field shows its default. `held` is a change held for review, shown in
1861/// place of the stored values.
1862#[allow(clippy::too_many_arguments)]
1863async fn insert_type_fields(
1864    ctx: &mut Context,
1865    tera: &tera::Tera,
1866    pool: &rustango::sql::Pool,
1867    handler: Option<&dyn crate::page_type::PageTypeHandler>,
1868    mut widgets: Vec<crate::widget::Widget>,
1869    page_id: i64,
1870    page_type_id: i64,
1871    held: Option<&std::collections::HashMap<String, String>>,
1872) {
1873    if let Some(form) = held {
1874        overlay_pending_widgets(&mut widgets, form);
1875    }
1876    // Pre-render `Custom`-kind widgets via the inventory registry.
1877    // Tera's `{% include %}` requires a string literal, so we
1878    // render once on the Rust side and stash the result on each
1879    // widget — same shape `cms_snippet` uses for its
1880    // pre-fetched-snippet HTML map.
1881    for w in &mut widgets {
1882        if matches!(w.kind, crate::widget::WidgetKind::Custom) {
1883            if let Some(reg) = crate::widget::registry::find_custom_widget(&w.custom_name) {
1884                let mut sub = Context::new();
1885                sub.insert("w", &w);
1886                w.custom_html = tera.render(reg.template, &sub).unwrap_or_else(|e| {
1887                    tracing::warn!(
1888                        target: "rustango_cms::widget",
1889                        custom_name = %w.custom_name,
1890                        template = reg.template,
1891                        error = %e,
1892                        "custom widget template render failed",
1893                    );
1894                    String::new()
1895                });
1896            }
1897        }
1898    }
1899
1900    // -- StreamField pre-render --------------------------------------
1901    // Walk each `Widget::Stream` once: parse its stored JSON, render
1902    // every contained block's editor markup + `<template>` clones
1903    // for each allowed type. The output lives on `w.custom_html`
1904    // (same stash slot the Custom widget arm uses); the `_widget.html`
1905    // macro emits it `| safe` for the stream arm.
1906    for w in &mut widgets {
1907        if matches!(w.kind, crate::widget::WidgetKind::Stream) {
1908            w.custom_html = crate::block::admin::render_stream_editor(w, tera);
1909        }
1910    }
1911    ctx.insert("extension_fields", &widgets);
1912
1913    // #564 — page-builder body. When the page type has a published
1914    // schema, pre-render its fixed fields/rows/groups + repeater/flex
1915    // stream editors (prefilled + lazily upgraded) into one HTML blob the
1916    // Body fieldset emits, plus a conditional-rules island.
1917    if let Some((body_html, rules_json, upgraded)) =
1918        page_builder_editor_ctx(pool, tera, page_id, page_type_id, held).await
1919    {
1920        ctx.insert("builder_body_html", &body_html);
1921        ctx.insert("builder_rules_json", &rules_json);
1922        ctx.insert("builder_upgraded", &upgraded);
1923    }
1924
1925    // #117 — inline panels. Collect each spec the handler declared
1926    // and the persisted rows behind it. Each panel renders as a
1927    // section with N rows; per-row fields come from the spec.
1928    let mut inline_panels: Vec<serde_json::Value> = Vec::new();
1929    if let Some(h) = handler {
1930        for spec in h.inline_panels() {
1931            let rows = h
1932                .load_inline_panel(pool, page_id, &spec.name)
1933                .await
1934                .unwrap_or_default();
1935            inline_panels.push(serde_json::json!({
1936                "spec": spec,
1937                "rows": rows,
1938            }));
1939        }
1940    }
1941    ctx.insert("inline_panels", &inline_panels);
1942}
1943
1944/// GET-side: build the editor HTML + rules island + upgrade flag for a
1945/// page whose type has a published schema. Returns `None` when
1946/// the type has no published schema.
1947async fn page_builder_editor_ctx(
1948    pool: &rustango::sql::Pool,
1949    tera: &tera::Tera,
1950    page_id: i64,
1951    page_type_id: i64,
1952    held: Option<&std::collections::HashMap<String, String>>,
1953) -> Option<(String, String, bool)> {
1954    let row = crate::page_builder::model::published_for(pool, page_type_id)
1955        .await
1956        .ok()??;
1957    let doc = crate::page_builder::parse_schema(&row.document).ok()?;
1958    let components = crate::page_builder::model::component_map(pool)
1959        .await
1960        .unwrap_or_default();
1961    let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
1962    let (mut values, report) =
1963        crate::page_builder::values::load_upgraded(pool, page_id, &compiled)
1964            .await
1965            .unwrap_or_else(|_| (serde_json::json!({}), Default::default()));
1966    // A change held for review shows in place of the stored values.
1967    if let Some(form) = held {
1968        values = serde_json::Value::Object(crate::page_builder::values::build_values(&compiled, form));
1969    }
1970    let html =
1971        crate::page_builder::values::render_body(&compiled, &values, tera);
1972    // Conditional-rules island: `[{field, rule}]` for page_builder_rules.js.
1973    let rules: Vec<serde_json::Value> = compiled
1974        .rules
1975        .iter()
1976        .map(|r| serde_json::json!({ "field": r.field, "rule": r.rule }))
1977        .collect();
1978    let rules_json = serde_json::to_string(&rules).unwrap_or_else(|_| "[]".to_owned());
1979    Some((html, rules_json, report.upgraded))
1980}
1981
1982// ---- #563 reusable components library -----------------------------------
1983
1984/// GET /cms-admin/components — the library list (Developer-gated).
1985pub async fn components_index(
1986    State(state): State<super::AdminState>,
1987    tenant: Tenant,
1988    headers: HeaderMap,
1989    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1990) -> Result<Response, AdminError> {
1991    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1992        return Ok(r);
1993    }
1994    let comps = crate::page_builder::model::all_components(tenant.pool()).await?;
1995    let mut rows = Vec::with_capacity(comps.len());
1996    for c in &comps {
1997        let refs = crate::page_builder::model::component_references(tenant.pool(), &c.slug)
1998            .await
1999            .unwrap_or_default();
2000        rows.push(serde_json::json!({
2001            "id": c.id.get().copied(),
2002            "slug": c.slug,
2003            "label": c.label,
2004            "icon": if c.icon.is_empty() { "extension".to_owned() } else { c.icon.clone() },
2005            "description": c.description,
2006            "version": c.version,
2007            "ref_count": refs.len(),
2008        }));
2009    }
2010    let mut ctx = Context::new();
2011    add_chrome(&mut ctx, &tenant, "components", session_user.as_ref()).await;
2012    add_admin_theme(&mut ctx, tenant.pool()).await;
2013    ctx.insert("components", &rows);
2014    ctx.insert("new_url", "/cms-admin/components/new");
2015    render_with_csrf(
2016        &state,
2017        &headers,
2018        "rcms_admin/components_list.html",
2019        &mut ctx,
2020    )
2021}
2022
2023/// Shared render of the component builder shell (new + edit + error re-render).
2024#[allow(clippy::too_many_arguments)]
2025async fn render_component_builder(
2026    state: &super::AdminState,
2027    headers: &HeaderMap,
2028    tenant: &Tenant,
2029    user: Option<&rustango::tenancy::auth::User>,
2030    id: Option<i64>,
2031    slug: &str,
2032    label: &str,
2033    icon: &str,
2034    description: &str,
2035    schema_json: &str,
2036    error: Option<&str>,
2037) -> Result<Response, AdminError> {
2038    let mut ctx = Context::new();
2039    add_chrome(&mut ctx, tenant, "components", user).await;
2040    add_admin_theme(&mut ctx, tenant.pool()).await;
2041    ctx.insert("component_id", &id);
2042    ctx.insert("slug", slug);
2043    ctx.insert("label", label);
2044    ctx.insert("icon", icon);
2045    ctx.insert("description", description);
2046    ctx.insert("schema_json", schema_json);
2047    ctx.insert("is_edit", &id.is_some());
2048    let save_url = match id {
2049        Some(cid) => format!("/cms-admin/components/{cid}/edit"),
2050        None => "/cms-admin/components/new".to_owned(),
2051    };
2052    ctx.insert("save_url", &save_url);
2053    ctx.insert("list_url", "/cms-admin/components");
2054    if let Some(e) = error {
2055        ctx.insert("error", e);
2056    }
2057    render_with_csrf(
2058        state,
2059        headers,
2060        "rcms_admin/component_builder.html",
2061        &mut ctx,
2062    )
2063}
2064
2065/// GET /cms-admin/components/new — empty component builder (fields + rows).
2066pub async fn component_new_form(
2067    State(state): State<super::AdminState>,
2068    tenant: Tenant,
2069    headers: HeaderMap,
2070    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2071) -> Result<Response, AdminError> {
2072    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2073        return Ok(r);
2074    }
2075    render_component_builder(
2076        &state,
2077        &headers,
2078        &tenant,
2079        session_user.as_ref(),
2080        None,
2081        "",
2082        "",
2083        "",
2084        "",
2085        "{\"nodes\":[]}",
2086        None,
2087    )
2088    .await
2089}
2090
2091/// GET /cms-admin/components/{id}/edit — builder seeded from the stored doc.
2092pub async fn component_edit_form(
2093    State(state): State<super::AdminState>,
2094    tenant: Tenant,
2095    headers: HeaderMap,
2096    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2097    Path(id): Path<i64>,
2098) -> Result<Response, AdminError> {
2099    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2100        return Ok(r);
2101    }
2102    let c = crate::page_builder::model::component_by_id(tenant.pool(), id)
2103        .await?
2104        .ok_or(AdminError::NotFound(id))?;
2105    // The builder JS reads `{nodes:[…]}`; a component doc stores `children`.
2106    let doc: crate::page_builder::schema::ComponentDoc =
2107        serde_json::from_value(c.document.clone()).unwrap_or_default();
2108    let schema_json =
2109        serde_json::to_string(&serde_json::json!({ "nodes": doc.children })).unwrap_or_default();
2110    render_component_builder(
2111        &state,
2112        &headers,
2113        &tenant,
2114        session_user.as_ref(),
2115        Some(id),
2116        &c.slug,
2117        &c.label,
2118        &c.icon,
2119        &c.description,
2120        &schema_json,
2121        None,
2122    )
2123    .await
2124}
2125
2126/// Parse the posted `{nodes:[…]}` into a validated [`ComponentDoc`].
2127/// `Ok(doc)` on success; `Err(problems)` with the editor-facing errors.
2128fn parse_component_doc(
2129    schema_str: &str,
2130) -> Result<crate::page_builder::schema::ComponentDoc, String> {
2131    let value: serde_json::Value =
2132        serde_json::from_str(schema_str).map_err(|e| format!("invalid schema JSON: {e}"))?;
2133    let doc = crate::page_builder::parse_schema(&value)
2134        .map_err(|e| format!("invalid schema document: {e}"))?;
2135    let cdoc = crate::page_builder::schema::ComponentDoc {
2136        label_format: None,
2137        children: doc.nodes,
2138    };
2139    let problems = crate::page_builder::schema::validate_component(&cdoc);
2140    if problems.is_empty() {
2141        Ok(cdoc)
2142    } else {
2143        Err(problems.join(" "))
2144    }
2145}
2146
2147/// POST /cms-admin/components/new — create a component (version 1).
2148pub async fn component_create(
2149    State(state): State<super::AdminState>,
2150    tenant: Tenant,
2151    headers: HeaderMap,
2152    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2153    Form(form): Form<FormComponentSubmit>,
2154) -> Result<Response, AdminError> {
2155    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2156        return Ok(r);
2157    }
2158    let slug = crate::forms::schema::slugify_key(&form.slug);
2159    // Validate slug → label → document, in order; first failure wins.
2160    let checked: Result<crate::page_builder::schema::ComponentDoc, String> =
2161        if !crate::forms::schema::is_valid_key(&slug) {
2162            Err(
2163                "Slug is invalid — use letters/digits/underscores, starting with a letter."
2164                    .to_owned(),
2165            )
2166        } else if form.label.trim().is_empty() {
2167            Err("Label is required.".to_owned())
2168        } else {
2169            parse_component_doc(&form.schema)
2170        };
2171    // On success, create; a unique-slug clash re-shows with a clear error.
2172    let msg: Option<String> = match checked {
2173        Ok(cdoc) => {
2174            let document = serde_json::to_value(&cdoc).unwrap_or_else(|_| serde_json::json!({}));
2175            match crate::page_builder::model::create_component(
2176                tenant.pool(),
2177                &slug,
2178                form.label.trim(),
2179                form.icon.trim(),
2180                form.description.trim(),
2181                document,
2182            )
2183            .await
2184            {
2185                Ok(_) => {
2186                    return redirect_named_with_message(
2187                        "rcms-admin:components:index",
2188                        MsgLevel::Success,
2189                        "Component created.",
2190                        &headers,
2191                    )
2192                }
2193                Err(_) => Some(format!(
2194                    "Could not create — a component with slug `{slug}` may already exist."
2195                )),
2196            }
2197        }
2198        Err(e) => Some(e),
2199    };
2200    render_component_builder(
2201        &state,
2202        &headers,
2203        &tenant,
2204        session_user.as_ref(),
2205        None,
2206        &form.slug,
2207        &form.label,
2208        &form.icon,
2209        &form.description,
2210        &form.schema,
2211        msg.as_deref(),
2212    )
2213    .await
2214}
2215
2216/// POST /cms-admin/components/{id}/edit — update + bump version.
2217pub async fn component_update(
2218    State(state): State<super::AdminState>,
2219    tenant: Tenant,
2220    headers: HeaderMap,
2221    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2222    Path(id): Path<i64>,
2223    Form(form): Form<FormComponentSubmit>,
2224) -> Result<Response, AdminError> {
2225    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2226        return Ok(r);
2227    }
2228    let existing = crate::page_builder::model::component_by_id(tenant.pool(), id)
2229        .await?
2230        .ok_or(AdminError::NotFound(id))?;
2231    if form.label.trim().is_empty() {
2232        return render_component_builder(
2233            &state,
2234            &headers,
2235            &tenant,
2236            session_user.as_ref(),
2237            Some(id),
2238            &existing.slug,
2239            &form.label,
2240            &form.icon,
2241            &form.description,
2242            &form.schema,
2243            Some("Label is required."),
2244        )
2245        .await;
2246    }
2247    let cdoc = match parse_component_doc(&form.schema) {
2248        Ok(d) => d,
2249        Err(e) => {
2250            return render_component_builder(
2251                &state,
2252                &headers,
2253                &tenant,
2254                session_user.as_ref(),
2255                Some(id),
2256                &existing.slug,
2257                &form.label,
2258                &form.icon,
2259                &form.description,
2260                &form.schema,
2261                Some(&e),
2262            )
2263            .await
2264        }
2265    };
2266    let document = serde_json::to_value(&cdoc).unwrap_or_else(|_| serde_json::json!({}));
2267    crate::page_builder::model::update_component(
2268        tenant.pool(),
2269        id,
2270        form.label.trim(),
2271        form.icon.trim(),
2272        form.description.trim(),
2273        document,
2274    )
2275    .await?;
2276    redirect_named_with_message(
2277        "rcms-admin:components:index",
2278        MsgLevel::Success,
2279        "Component saved — referencing page types pick it up on next open.",
2280        &headers,
2281    )
2282}
2283
2284/// POST /cms-admin/components/{id}/delete — blocked while referenced.
2285pub async fn component_delete(
2286    State(_state): State<super::AdminState>,
2287    tenant: Tenant,
2288    headers: HeaderMap,
2289    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2290    Path(id): Path<i64>,
2291) -> Result<Response, AdminError> {
2292    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2293        return Ok(r);
2294    }
2295    let c = crate::page_builder::model::component_by_id(tenant.pool(), id)
2296        .await?
2297        .ok_or(AdminError::NotFound(id))?;
2298    let refs = crate::page_builder::model::component_references(tenant.pool(), &c.slug).await?;
2299    if !refs.is_empty() {
2300        // Resolve referencing page-type names for a clear error.
2301        let ids: Vec<i64> = refs.iter().map(|(pt, _)| *pt).collect();
2302        let pts: Vec<PageType> = PageType::objects()
2303            .where_(PageType::id.is_in(ids))
2304            .fetch(tenant.pool())
2305            .await
2306            .unwrap_or_default();
2307        let names: Vec<String> = pts.iter().map(|p| p.verbose_name.clone()).collect();
2308        let listed = if names.is_empty() {
2309            format!("{} page type(s)", refs.len())
2310        } else {
2311            names.join(", ")
2312        };
2313        return redirect_named_with_message(
2314            "rcms-admin:components:index",
2315            MsgLevel::Error,
2316            &format!("Can't delete `{}` — still used by: {listed}.", c.slug),
2317            &headers,
2318        );
2319    }
2320    crate::page_builder::model::delete_component(tenant.pool(), id).await?;
2321    redirect_named_with_message(
2322        "rcms-admin:components:index",
2323        MsgLevel::Success,
2324        "Component deleted.",
2325        &headers,
2326    )
2327}
2328
2329// ---- #566 UI-created page types -----------------------------------------
2330
2331/// GET /cms-admin/page-types/new — the create-a-type form.
2332pub async fn page_type_new_form(
2333    State(state): State<super::AdminState>,
2334    tenant: Tenant,
2335    headers: HeaderMap,
2336    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2337) -> Result<Response, AdminError> {
2338    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2339        return Ok(r);
2340    }
2341    let mut ctx = Context::new();
2342    add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2343    add_admin_theme(&mut ctx, tenant.pool()).await;
2344    ctx.insert("list_url", "/cms-admin/page-types");
2345    insert_workflow_choices(&mut ctx, tenant.pool()).await;
2346    render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx)
2347}
2348
2349/// The active workflows, by name, for the page-type form's Workflow field.
2350/// A failed lookup leaves only "publish directly".
2351async fn insert_workflow_choices(ctx: &mut Context, pool: &rustango::sql::Pool) {
2352    let names: Vec<String> = crate::workflow::Workflow::objects()
2353        .where_(crate::workflow::Workflow::active.eq(true))
2354        .order_by(&[("name", false)])
2355        .fetch(pool)
2356        .await
2357        .unwrap_or_default()
2358        .into_iter()
2359        .map(|w| w.name)
2360        .collect();
2361    ctx.insert("workflows", &names);
2362}
2363
2364/// A comma-separated list of type identifiers as the JSON array a page-type
2365/// row stores (empty = no rule).
2366fn type_list_json(raw: &str) -> serde_json::Value {
2367    serde_json::Value::Array(
2368        raw.split(',')
2369            .map(str::trim)
2370            .filter(|s| !s.is_empty())
2371            .map(|s| serde_json::Value::String(s.to_owned()))
2372            .collect(),
2373    )
2374}
2375
2376/// An admin-made page type by id; `None` for a missing or code type, whose
2377/// settings are re-seeded from its handler at every boot.
2378async fn ui_page_type(
2379    pool: &rustango::sql::Pool,
2380    id: i64,
2381) -> Result<Option<crate::page_type_model::PageType>, AdminError> {
2382    Ok(crate::page_type_model::PageType::objects()
2383        .where_(crate::page_type_model::PageType::id.eq(id))
2384        .first(pool)
2385        .await?
2386        .filter(|t| crate::page_type::find_handler(&t.type_name).is_none()))
2387}
2388
2389/// GET /cms-admin/page-types/{id}/edit — an admin-made type's settings.
2390pub async fn page_type_edit_form(
2391    State(state): State<super::AdminState>,
2392    tenant: Tenant,
2393    headers: HeaderMap,
2394    Path(id): Path<i64>,
2395    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2396) -> Result<Response, AdminError> {
2397    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2398        return Ok(r);
2399    }
2400    let Some(pt) = ui_page_type(tenant.pool(), id).await? else {
2401        return Err(AdminError::NotFound(id));
2402    };
2403    let mut ctx = Context::new();
2404    add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2405    add_admin_theme(&mut ctx, tenant.pool()).await;
2406    ctx.insert("list_url", "/cms-admin/page-types");
2407    ctx.insert("edit_id", &id);
2408    ctx.insert("form_verbose_name", &pt.verbose_name);
2409    ctx.insert("form_type_name", &pt.type_name);
2410    ctx.insert("form_allowed_parents", &pt.allowed_parents().join(", "));
2411    ctx.insert("form_allowed_children", &pt.allowed_children().join(", "));
2412    ctx.insert("form_workflow", &pt.workflow);
2413    insert_workflow_choices(&mut ctx, tenant.pool()).await;
2414    render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx)
2415}
2416
2417/// POST /cms-admin/page-types/{id}/edit — save an admin-made type's name,
2418/// parent/child rules and workflow. The identifier can't change.
2419pub async fn page_type_update(
2420    tenant: Tenant,
2421    headers: HeaderMap,
2422    Path(id): Path<i64>,
2423    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2424    Form(form): Form<FormPageTypeCreate>,
2425) -> Result<Response, AdminError> {
2426    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2427        return Ok(r);
2428    }
2429    let Some(mut pt) = ui_page_type(tenant.pool(), id).await? else {
2430        return Err(AdminError::NotFound(id));
2431    };
2432    if form.verbose_name.trim().is_empty() {
2433        return Err(AdminError::Validation("Name is required.".to_owned()));
2434    }
2435    pt.verbose_name = form.verbose_name.trim().to_owned();
2436    pt.allowed_parent_types = type_list_json(&form.allowed_parents);
2437    pt.allowed_child_types = type_list_json(&form.allowed_children);
2438    pt.workflow = form.workflow.trim().to_owned();
2439    pt.save_pool(tenant.pool()).await?;
2440    redirect_named_with_message(
2441        "rcms-admin:page-types",
2442        MsgLevel::Success,
2443        "Page type settings saved.",
2444        &headers,
2445    )
2446}
2447
2448/// POST /cms-admin/page-types/new — create a UI page type
2449/// (`app_label = "cms_ui"`) + an empty draft schema, then jump to the
2450/// field builder so the Developer designs its body immediately.
2451pub async fn page_type_create(
2452    State(state): State<super::AdminState>,
2453    tenant: Tenant,
2454    headers: HeaderMap,
2455    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2456    Form(form): Form<FormPageTypeCreate>,
2457) -> Result<Response, AdminError> {
2458    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2459        return Ok(r);
2460    }
2461    // Blank identifier derives from the name — `slugify_key` is a FIELD-key
2462    // slugifier whose empty-input fallback is the literal "field", which made
2463    // every no-identifier type `cms_ui.field` (and the second one collide).
2464    let ident_src = if form.type_name.trim().is_empty() {
2465        form.verbose_name.as_str()
2466    } else {
2467        form.type_name.as_str()
2468    };
2469    let slug = crate::forms::schema::slugify_key(ident_src);
2470    let err: Option<String> = if form.verbose_name.trim().is_empty() {
2471        Some("Name is required.".to_owned())
2472    } else if !crate::forms::schema::is_valid_key(&slug) {
2473        Some(
2474            "Identifier is invalid — use letters/digits/underscores, starting with a letter."
2475                .to_owned(),
2476        )
2477    } else if crate::page_type_model::PageType::objects()
2478        .where_(crate::page_type_model::PageType::type_name.eq(slug.clone()))
2479        .first(tenant.pool())
2480        .await?
2481        .is_some()
2482        || crate::page_type::find_handler(&slug).is_some()
2483    {
2484        Some(format!(
2485            "A page type with identifier `{slug}` already exists."
2486        ))
2487    } else {
2488        None
2489    };
2490    if let Some(msg) = err {
2491        let mut ctx = Context::new();
2492        add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2493        add_admin_theme(&mut ctx, tenant.pool()).await;
2494        ctx.insert("list_url", "/cms-admin/page-types");
2495        ctx.insert("error", &msg);
2496        ctx.insert("form_verbose_name", &form.verbose_name);
2497        ctx.insert("form_type_name", &form.type_name);
2498        ctx.insert("form_allowed_parents", &form.allowed_parents);
2499        ctx.insert("form_allowed_children", &form.allowed_children);
2500        ctx.insert("form_workflow", &form.workflow);
2501        insert_workflow_choices(&mut ctx, tenant.pool()).await;
2502        return render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx);
2503    }
2504    // An API type has no HTML representation, so it gets the blank
2505    // template sentinel rather than the generic schema template —
2506    // otherwise `page_view::resolve_kind` would see a template and
2507    // never reach the JSON branch.
2508    let view_mode = crate::page_view::PageViewMode::parse(&form.view_mode);
2509    let default_template = if view_mode == crate::page_view::PageViewMode::Api {
2510        String::new()
2511    } else {
2512        crate::page_builder::DEFAULT_SCHEMA_TEMPLATE.to_owned()
2513    };
2514    let mut row = crate::page_type_model::PageType {
2515        id: rustango::sql::Auto::Unset,
2516        app_label: "cms_ui".to_owned(),
2517        type_name: slug.clone(),
2518        verbose_name: form.verbose_name.trim().to_owned(),
2519        default_template,
2520        view_mode: view_mode.as_str().to_owned(),
2521        is_creatable: true,
2522        allowed_parent_types: type_list_json(&form.allowed_parents),
2523        allowed_child_types: type_list_json(&form.allowed_children),
2524        workflow: form.workflow.trim().to_owned(),
2525        created_at: rustango::sql::Auto::Unset,
2526        updated_at: rustango::sql::Auto::Unset,
2527    };
2528    row.insert_pool(tenant.pool()).await?;
2529    let new_id = row.id.get().copied().unwrap_or_default();
2530    // Seed an empty draft schema so the builder opens cleanly.
2531    let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
2532    crate::page_builder::model::save_draft(
2533        tenant.pool(),
2534        new_id,
2535        serde_json::json!({ "nodes": [] }),
2536        created_by,
2537    )
2538    .await
2539        .log_warn("empty builder draft not seeded");
2540    redirect_named_with_params_and_message(
2541        "rcms-admin:page-types:build",
2542        &[("id", new_id.to_string())],
2543        MsgLevel::Success,
2544        "Page type created — design its body, then Publish.",
2545        &headers,
2546    )
2547}
2548
2549/// POST /cms-admin/page-types/{id}/delete — delete a UI-created type.
2550/// Refused for code types and for types with existing pages.
2551pub async fn page_type_delete(
2552    State(_state): State<super::AdminState>,
2553    tenant: Tenant,
2554    headers: HeaderMap,
2555    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2556    Path(id): Path<i64>,
2557) -> Result<Response, AdminError> {
2558    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2559        return Ok(r);
2560    }
2561    let pt = crate::page_type_model::PageType::objects()
2562        .where_(crate::page_type_model::PageType::id.eq(id))
2563        .first(tenant.pool())
2564        .await?
2565        .ok_or(AdminError::NotFound(id))?;
2566    // Only UI-created types are deletable; code types never are.
2567    if pt.app_label != "cms_ui" {
2568        return redirect_named_with_message(
2569            "rcms-admin:page-types",
2570            MsgLevel::Error,
2571            "Only UI-created page types can be deleted.",
2572            &headers,
2573        );
2574    }
2575    let page_count = Page::objects()
2576        .where_(Page::page_type_id.eq(id))
2577        .fetch(tenant.pool())
2578        .await
2579        .map(|v| v.len())
2580        .unwrap_or(0);
2581    if page_count > 0 {
2582        return redirect_named_with_message(
2583            "rcms-admin:page-types",
2584            MsgLevel::Error,
2585            "Can't delete — pages still use this type. Delete or move them first.",
2586            &headers,
2587        );
2588    }
2589    // Drop the type's schema rows (draft/published/archived) then the row.
2590    for row in crate::page_builder::model::list_versions(tenant.pool(), id)
2591        .await
2592        .unwrap_or_default()
2593    {
2594        row.delete_pool(tenant.pool()).await.log_warn("page-builder schema version not deleted");
2595    }
2596    pt.delete_pool(tenant.pool()).await?;
2597    redirect_named_with_message(
2598        "rcms-admin:page-types",
2599        MsgLevel::Success,
2600        "Page type deleted.",
2601        &headers,
2602    )
2603}
2604
2605/// The canonical column of a translation row shows rich text formatted,
2606/// not as `<p>…</p>` markup. Sanitized: it is author content rendered
2607/// into the admin. Empty for every other widget kind (shown as text).
2608fn translation_canonical_html(widget_tag: &str, canonical: &str) -> String {
2609    if widget_tag == "richtext" && !canonical.trim().is_empty() {
2610        crate::markdown::sanitize_html(canonical)
2611    } else {
2612        String::new()
2613    }
2614}
2615
2616/// Translation-surface groups for a page's builder body: the
2617/// canonical text leaves (fixed fields, group members, zone stream
2618/// blocks) grouped like the StreamField leaf rows, each prefilled with
2619/// its existing per-locale override. Returns `[]` when the type has no
2620/// published schema. Paths are `builder.<…>` (see `values::…leaves`).
2621async fn builder_translation_groups(
2622    tenant: &Tenant,
2623    page_id: i64,
2624    page_type_id: i64,
2625    existing: &std::collections::HashMap<String, String>,
2626) -> (Vec<serde_json::Value>, std::collections::HashSet<String>) {
2627    let mut paths = std::collections::HashSet::new();
2628    let Ok(Some(row)) =
2629        crate::page_builder::model::published_for(tenant.pool(), page_type_id).await
2630    else {
2631        return (Vec::new(), paths);
2632    };
2633    let Ok(doc) = crate::page_builder::parse_schema(&row.document) else {
2634        return (Vec::new(), paths);
2635    };
2636    let components = crate::page_builder::model::component_map(tenant.pool())
2637        .await
2638        .unwrap_or_default();
2639    let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
2640    let (values, _) = crate::page_builder::values::load_upgraded(tenant.pool(), page_id, &compiled)
2641        .await
2642        .unwrap_or_else(|_| (serde_json::json!({}), Default::default()));
2643    let leaves = crate::page_builder::values::builder_translatable_leaves(&compiled, &values);
2644    // Group consecutively by block instance, mirroring stream_translations.
2645    let mut groups: Vec<serde_json::Value> = Vec::new();
2646    let mut cur = String::new();
2647    for leaf in &leaves {
2648        paths.insert(leaf.path.clone());
2649        let rowv = serde_json::json!({
2650            "path": leaf.path,
2651            "widget_kind": leaf.widget_kind.as_tag(),
2652            "field_label": leaf.field_label,
2653            "canonical": leaf.canonical_text,
2654            "canonical_html": translation_canonical_html(leaf.widget_kind.as_tag(), &leaf.canonical_text),
2655            "value": existing.get(&leaf.path).cloned().unwrap_or_default(),
2656        });
2657        if leaf.block_id != cur {
2658            cur.clone_from(&leaf.block_id);
2659            groups.push(serde_json::json!({
2660                "block_type": leaf.block_type,
2661                "block_label": leaf.block_label,
2662                "block_id": leaf.block_id,
2663                "depth": leaf.depth,
2664                "leaves": [rowv],
2665            }));
2666        } else if let Some(arr) = groups
2667            .last_mut()
2668            .and_then(|g| g.get_mut("leaves"))
2669            .and_then(|v| v.as_array_mut())
2670        {
2671            arr.push(rowv);
2672        }
2673    }
2674    (groups, paths)
2675}
2676
2677/// POST /cms-admin/media/bulk-move-collection — move every checked
2678/// media id into the selected `collection_id` (or NULL for
2679/// uncategorized).
2680pub async fn media_bulk_move_collection(
2681    State(_state): State<super::AdminState>,
2682    tenant: Tenant,
2683    headers: HeaderMap,
2684    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
2685    Form(form): Form<Vec<(String, String)>>,
2686) -> Result<Response, AdminError> {
2687    let target: Option<i64> = form
2688        .iter()
2689        .find(|(k, _)| k == "collection_id")
2690        .and_then(|(_, v)| v.parse::<i64>().ok())
2691        .filter(|id| *id > 0);
2692    let ids: Vec<i64> = form
2693        .iter()
2694        .filter(|(k, _)| k == "ids" || k == "id")
2695        .filter_map(|(_, v)| v.parse::<i64>().ok())
2696        .collect();
2697    let kind = form
2698        .iter()
2699        .find(|(k, _)| k == "kind")
2700        .map(|(_, v)| v.clone())
2701        .unwrap_or_else(|| "image".to_owned());
2702    let mut touched = 0;
2703    for id in ids {
2704        if let Some(mut m) = Media::objects()
2705            .where_(Media::id.eq(id))
2706            .first(tenant.pool())
2707            .await?
2708        {
2709            m.collection_id = target;
2710            m.save_pool(tenant.pool()).await?;
2711            touched += 1;
2712        }
2713    }
2714    let redirect_url = if kind == "document" {
2715        "rcms-admin:documents:list"
2716    } else {
2717        "rcms-admin:media:list"
2718    };
2719    let dest = match target {
2720        Some(id) => format!("to collection #{id}"),
2721        None => "to Uncategorized".to_owned(),
2722    };
2723    redirect_named_with_message_plural(
2724        redirect_url,
2725        MsgLevel::Success,
2726        "Moved {count} item(s) {dest}.",
2727        touched as i64,
2728        &[("count", &touched.to_string()), ("dest", &dest)],
2729        &headers,
2730    )
2731}
2732
2733/// GET /cms-admin/media/collections/{id}/permissions — per-collection
2734/// permission editor. Same role × action grid shape as the
2735/// page permissions tab, just retargeted at `cms_collection_permission`.
2736pub async fn collection_permissions_form(
2737    State(state): State<super::AdminState>,
2738    tenant: Tenant,
2739    headers: HeaderMap,
2740    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2741    Path(id): Path<i64>,
2742) -> Result<Response, AdminError> {
2743    let collection = crate::media::MediaCollection::objects()
2744        .where_(crate::media::MediaCollection::id.eq(id))
2745        .first(tenant.pool())
2746        .await?
2747        .ok_or(AdminError::NotFound(id))?;
2748    let roles: Vec<rustango::tenancy::permissions::Role> =
2749        rustango::tenancy::permissions::Role::objects()
2750            .order_by(&[("name", false)])
2751            .fetch(tenant.pool())
2752            .await?;
2753    let grants: Vec<crate::permissions::CollectionPermission> =
2754        crate::permissions::CollectionPermission::objects()
2755            .where_(crate::permissions::CollectionPermission::collection_id.eq(id))
2756            .fetch(tenant.pool())
2757            .await?;
2758    let granted: std::collections::HashSet<(i64, String)> = grants
2759        .iter()
2760        .map(|g| (g.role_id, g.permission.clone()))
2761        .collect();
2762    let actions: Vec<&str> = crate::permissions::Action::all()
2763        .iter()
2764        .map(|a| a.as_str())
2765        .collect();
2766    let perm_grid: Vec<serde_json::Value> = roles
2767        .iter()
2768        .map(|r| {
2769            let rid = r.id.get().copied().unwrap_or_default();
2770            let row_cells: Vec<serde_json::Value> = actions
2771                .iter()
2772                .map(|a| {
2773                    serde_json::json!({
2774                        "action": a,
2775                        "granted": granted.contains(&(rid, (*a).to_owned())),
2776                    })
2777                })
2778                .collect();
2779            serde_json::json!({
2780                "role_id": rid,
2781                "role_name": r.name,
2782                "role_description": r.description,
2783                "cells": row_cells,
2784            })
2785        })
2786        .collect();
2787
2788    let mut ctx = Context::new();
2789    add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
2790    add_admin_theme(&mut ctx, tenant.pool()).await;
2791    ctx.insert("collection_id", &id);
2792    ctx.insert("collection_name", &collection.name);
2793    ctx.insert("perm_actions", &actions);
2794    ctx.insert("perm_grid", &perm_grid);
2795
2796    // #195 — view restriction picker. Surface the current direct
2797    // restriction (if any) and the role list for the groups option.
2798    let restriction = crate::collection_view_restriction::direct_for_collection(tenant.pool(), id)
2799        .await
2800        .unwrap_or_default();
2801    let restriction_kind = restriction
2802        .as_ref()
2803        .map(|r| r.kind.clone())
2804        .unwrap_or_else(|| "none".to_owned());
2805    let restriction_groups: std::collections::HashSet<i64> = restriction
2806        .as_ref()
2807        .map(|r| r.parsed_groups().into_iter().collect())
2808        .unwrap_or_default();
2809    let restriction_has_password = restriction
2810        .as_ref()
2811        .map(|r| !r.password_hash.is_empty())
2812        .unwrap_or(false);
2813    let role_options: Vec<serde_json::Value> = roles
2814        .iter()
2815        .map(|r| {
2816            let rid = r.id.get().copied().unwrap_or_default();
2817            serde_json::json!({
2818                "id": rid,
2819                "name": r.name,
2820                "selected": restriction_groups.contains(&rid),
2821            })
2822        })
2823        .collect();
2824    // #members — permission-codename picker (the permission-engine gate).
2825    let restriction_codenames: Vec<String> = restriction
2826        .as_ref()
2827        .map(|r| r.parsed_codenames())
2828        .unwrap_or_default();
2829    let restriction_codenames_str = restriction_codenames.join(",");
2830    let codename_choices: Vec<serde_json::Value> = super::resources::membership_codenames()
2831        .into_iter()
2832        .map(|(codename, label)| {
2833            serde_json::json!({
2834                "codename": codename,
2835                "label": label,
2836                "checked": restriction_codenames.contains(&codename),
2837            })
2838        })
2839        .collect();
2840    ctx.insert("restriction_kind", &restriction_kind);
2841    ctx.insert("restriction_has_password", &restriction_has_password);
2842    ctx.insert("restriction_roles", &role_options);
2843    ctx.insert("restriction_codenames_str", &restriction_codenames_str);
2844    ctx.insert("restriction_codename_choices", &codename_choices);
2845
2846    render_with_csrf(
2847        &state,
2848        &headers,
2849        "rcms_admin/collection_permissions.html",
2850        &mut ctx,
2851    )
2852}
2853
2854/// Form body for `POST /cms-admin/media/collections/{id}/privacy`.
2855#[derive(Deserialize)]
2856pub struct CollectionPrivacyForm {
2857    pub kind: String,
2858    #[serde(default)]
2859    pub password: String,
2860    #[serde(default)]
2861    pub group_ids: String,
2862    /// Comma-separated permission codenames — used when `kind =
2863    /// permission` (the permission-engine gate). Empty otherwise.
2864    #[serde(default)]
2865    pub codenames: String,
2866}
2867
2868/// POST /cms-admin/media/collections/{id}/privacy — upsert the view
2869/// restriction for a collection. `kind=none` deletes the row.
2870/// Mirrors the page-privacy submit handler exactly.
2871pub async fn collection_privacy_submit(
2872    State(_state): State<super::AdminState>,
2873    tenant: Tenant,
2874    headers: HeaderMap,
2875    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
2876    Path(id): Path<i64>,
2877    Form(form): Form<CollectionPrivacyForm>,
2878) -> Result<Response, AdminError> {
2879    use rustango::sql::Auto;
2880    let existing =
2881        crate::collection_view_restriction::direct_for_collection(tenant.pool(), id).await?;
2882    if form.kind == "none" {
2883        if let Some(row) = existing {
2884            row.delete_pool(tenant.pool()).await?;
2885            return redirect_named_with_params_and_message(
2886                "rcms-admin:media:collection-permissions",
2887                &[("id", id.to_string())],
2888                MsgLevel::Success,
2889                "Removed view restriction — collection is now public.",
2890                &headers,
2891            );
2892        }
2893        return redirect_named_with_params_and_message(
2894            "rcms-admin:media:collection-permissions",
2895            &[("id", id.to_string())],
2896            MsgLevel::Info,
2897            "No restriction to remove.",
2898            &headers,
2899        );
2900    }
2901    let Some(kind) = crate::collection_view_restriction::RestrictionKind::parse(&form.kind) else {
2902        return Err(AdminError::Validation(format!(
2903            "unknown restriction kind `{}`",
2904            form.kind
2905        )));
2906    };
2907    let password_hash = match kind {
2908        crate::collection_view_restriction::RestrictionKind::Password => {
2909            if form.password.is_empty() {
2910                if let Some(row) = &existing {
2911                    if row.kind == kind.as_str() {
2912                        row.password_hash.clone()
2913                    } else {
2914                        return redirect_named_with_params_and_message(
2915                            "rcms-admin:media:collection-permissions",
2916                            &[("id", id.to_string())],
2917                            MsgLevel::Error,
2918                            "Password is required when switching the restriction kind to password.",
2919                            &headers,
2920                        );
2921                    }
2922                } else {
2923                    return redirect_named_with_params_and_message(
2924                        "rcms-admin:media:collection-permissions",
2925                        &[("id", id.to_string())],
2926                        MsgLevel::Error,
2927                        "Password is required for password-protected collections.",
2928                        &headers,
2929                    );
2930                }
2931            } else {
2932                crate::passwords::hash(&form.password).await
2933                    .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?
2934            }
2935        }
2936        _ => String::new(),
2937    };
2938    let group_ids: Vec<i64> = if matches!(
2939        kind,
2940        crate::collection_view_restriction::RestrictionKind::Groups
2941    ) {
2942        form.group_ids
2943            .split(',')
2944            .filter_map(|s| s.trim().parse::<i64>().ok())
2945            .collect()
2946    } else {
2947        Vec::new()
2948    };
2949    let group_json = serde_json::json!(group_ids);
2950    let codenames: Vec<String> = if matches!(
2951        kind,
2952        crate::collection_view_restriction::RestrictionKind::Permission
2953    ) {
2954        form.codenames
2955            .split(',')
2956            .map(str::trim)
2957            .filter(|s| !s.is_empty())
2958            .map(str::to_owned)
2959            .collect()
2960    } else {
2961        Vec::new()
2962    };
2963    let codenames_json = serde_json::json!(codenames);
2964    match existing {
2965        Some(mut row) => {
2966            row.kind = kind.as_str().to_owned();
2967            row.password_hash = password_hash;
2968            row.group_ids = group_json;
2969            row.codenames = codenames_json;
2970            row.save_pool(tenant.pool()).await?;
2971        }
2972        None => {
2973            let mut row = crate::collection_view_restriction::CollectionViewRestriction {
2974                id: Auto::Unset,
2975                collection_id: id,
2976                kind: kind.as_str().to_owned(),
2977                password_hash,
2978                group_ids: group_json,
2979                codenames: codenames_json,
2980                created_at: Auto::Unset,
2981                updated_at: Auto::Unset,
2982            };
2983            row.insert_pool(tenant.pool()).await?;
2984        }
2985    }
2986    redirect_named_with_params_and_message(
2987        "rcms-admin:media:collection-permissions",
2988        &[("id", id.to_string())],
2989        MsgLevel::Success,
2990        "Collection privacy updated. New requests to /__media__/<spec>/<id> will enforce it.",
2991        &headers,
2992    )
2993}
2994
2995/// POST /cms-admin/media/collections/{id}/permissions — replace the
2996/// collection's permission set with the JSON body's grant list.
2997/// Idempotent want/have diff, returns 204 on success. Mirrors the
2998/// page-permission save endpoint exactly.
2999pub async fn collection_permissions_submit(
3000    State(_state): State<super::AdminState>,
3001    tenant: Tenant,
3002    Path(collection_id): Path<i64>,
3003    axum::Json(payload): axum::Json<PagePermissionsPayload>,
3004) -> Result<Response, AdminError> {
3005    use rustango::sql::Auto;
3006    let valid_actions: std::collections::HashSet<&str> = crate::permissions::Action::all()
3007        .iter()
3008        .map(|a| a.as_str())
3009        .collect();
3010    let want: std::collections::BTreeSet<(i64, String)> = payload
3011        .grants
3012        .iter()
3013        .filter(|g| valid_actions.contains(g.action.as_str()))
3014        .map(|g| (g.role_id, g.action.clone()))
3015        .collect();
3016
3017    let existing: Vec<crate::permissions::CollectionPermission> =
3018        crate::permissions::CollectionPermission::objects()
3019            .where_(crate::permissions::CollectionPermission::collection_id.eq(collection_id))
3020            .fetch(tenant.pool())
3021            .await?;
3022    let have: std::collections::BTreeSet<(i64, String)> = existing
3023        .iter()
3024        .map(|p| (p.role_id, p.permission.clone()))
3025        .collect();
3026
3027    for p in &existing {
3028        let key = (p.role_id, p.permission.clone());
3029        if !want.contains(&key) {
3030            p.clone().delete_pool(tenant.pool()).await?;
3031        }
3032    }
3033    for (role_id, action) in &want {
3034        if !have.contains(&(*role_id, action.clone())) {
3035            let mut row = crate::permissions::CollectionPermission {
3036                id: Auto::Unset,
3037                collection_id,
3038                role_id: *role_id,
3039                permission: action.clone(),
3040                created_at: Auto::Unset,
3041            };
3042            row.insert_pool(tenant.pool()).await?;
3043        }
3044    }
3045    Ok(axum::http::StatusCode::NO_CONTENT.into_response())
3046}
3047
3048/// JSON payload for the permission tab's bulk save endpoint —
3049/// the grid POSTs a list of `(role_id, action)` pairs and the
3050/// handler replaces the page's grant set with that list.
3051#[derive(Debug, Deserialize)]
3052pub struct PagePermissionsPayload {
3053    pub grants: Vec<PagePermissionGrant>,
3054}
3055#[derive(Debug, Deserialize)]
3056pub struct PagePermissionGrant {
3057    pub role_id: i64,
3058    pub action: String,
3059}
3060
3061/// POST /cms-admin/pages/{id}/permissions — replace the page's
3062/// permission set with the list in the JSON body. Idempotent;
3063/// computes the want/have diff and applies the minimum INSERTs +
3064/// DELETEs. Returns 204 on success.
3065pub async fn page_permissions_submit(
3066    State(_state): State<super::AdminState>,
3067    tenant: Tenant,
3068    Path(page_id): Path<i64>,
3069    axum::Json(payload): axum::Json<PagePermissionsPayload>,
3070) -> Result<Response, AdminError> {
3071    use rustango::sql::Auto;
3072    let valid_actions: std::collections::HashSet<&str> = crate::permissions::Action::all()
3073        .iter()
3074        .map(|a| a.as_str())
3075        .collect();
3076    let want: std::collections::BTreeSet<(i64, String)> = payload
3077        .grants
3078        .iter()
3079        .filter(|g| valid_actions.contains(g.action.as_str()))
3080        .map(|g| (g.role_id, g.action.clone()))
3081        .collect();
3082
3083    let existing: Vec<crate::permissions::PagePermission> =
3084        crate::permissions::PagePermission::objects()
3085            .where_(crate::permissions::PagePermission::page_id.eq(page_id))
3086            .fetch(tenant.pool())
3087            .await?;
3088    let have: std::collections::BTreeSet<(i64, String)> = existing
3089        .iter()
3090        .map(|p| (p.role_id, p.permission.clone()))
3091        .collect();
3092
3093    // Drop rows that aren't wanted.
3094    for p in &existing {
3095        let key = (p.role_id, p.permission.clone());
3096        if !want.contains(&key) {
3097            p.clone().delete_pool(tenant.pool()).await?;
3098        }
3099    }
3100    // Insert rows that don't exist yet.
3101    for (role_id, action) in &want {
3102        if !have.contains(&(*role_id, action.clone())) {
3103            let mut row = crate::permissions::PagePermission {
3104                id: Auto::Unset,
3105                page_id,
3106                role_id: *role_id,
3107                permission: action.clone(),
3108                created_at: Auto::Unset,
3109            };
3110            row.insert_pool(tenant.pool()).await?;
3111        }
3112    }
3113
3114    Ok(axum::http::StatusCode::NO_CONTENT.into_response())
3115}
3116
3117/// Resolve every [`TabSpec`](crate::page_type::TabSpec) variant
3118/// into the flat shape page_form.html iterates: `{name, label, icon,
3119/// badge, html}`. Failures on `Template` / `Widgets` rendering
3120/// fall back to an inline error banner instead of crashing the page
3121/// editor — the author sees the Tera message + can fix the template.
3122fn render_extra_tabs(
3123    specs: Vec<crate::page_type::TabSpec>,
3124    tera: &std::sync::Arc<tera::Tera>,
3125    base_ctx: &Context,
3126    headers: &HeaderMap,
3127) -> Vec<serde_json::Value> {
3128    use crate::page_type::TabBody;
3129    specs
3130        .into_iter()
3131        .map(|spec| {
3132            let html = match spec.body {
3133                TabBody::Html(s) => s,
3134                TabBody::Template { path, context } => {
3135                    let mut tab_ctx = base_ctx.clone();
3136                    for (k, v) in context {
3137                        tab_ctx.insert(&k, &v);
3138                    }
3139                    tera.render(&path, &tab_ctx).unwrap_or_else(|e| {
3140                        format!(
3141                            r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3142    <span class="rcms-flash-body"><strong>{label}</strong> {failed} <code>{path}</code>: {e}</span>
3143</div>"#,
3144                            label = tera::escape_html(&super::i18n::tr(headers, "Tab template error:", &[])),
3145                            failed = tera::escape_html(&super::i18n::tr(headers, "failed to render", &[])),
3146                            path = tera::escape_html(&path),
3147                            e = tera::escape_html(&e.to_string()),
3148                        )
3149                    })
3150                }
3151                TabBody::Widgets(widgets) => {
3152                    let mut ctx = Context::new();
3153                    ctx.insert("widgets", &widgets);
3154                    tera.render("rcms_admin/_widget_group.html", &ctx)
3155                        .unwrap_or_else(|e| {
3156                            format!(
3157                                r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3158    <span class="rcms-flash-body"><strong>{label}</strong> {e}</span>
3159</div>"#,
3160                                label = tera::escape_html(&super::i18n::tr(headers, "Widget-group tab error:", &[])),
3161                                e = tera::escape_html(&e.to_string()),
3162                            )
3163                        })
3164                }
3165                TabBody::Group { heading, help, layout, widgets } => {
3166                    // Field group panel (column or row layout).
3167                    // Wrap the same _widget_group output in a
3168                    // <fieldset> with a heading + (optional) help
3169                    // paragraph + layout class.
3170                    let mut ctx = Context::new();
3171                    ctx.insert("widgets", &widgets);
3172                    let inner = tera
3173                        .render("rcms_admin/_widget_group.html", &ctx)
3174                        .unwrap_or_else(|e| {
3175                            format!(
3176                                r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3177    <span class="rcms-flash-body"><strong>{label}</strong> {e}</span>
3178</div>"#,
3179                                label = tera::escape_html(&super::i18n::tr(headers, "Panel-group tab error:", &[])),
3180                                e = tera::escape_html(&e.to_string()),
3181                            )
3182                        });
3183                    let help_html = if help.is_empty() {
3184                        String::new()
3185                    } else {
3186                        format!(
3187                            r#"<p class="rcms-hint rcms-panel-group-help">{}</p>"#,
3188                            tera::escape_html(&help),
3189                        )
3190                    };
3191                    format!(
3192                        r#"<fieldset class="rcms-panel-group rcms-panel-group--{layout}">
3193    <legend>{heading}</legend>
3194    {help_html}
3195    <div class="rcms-panel-group-body">{inner}</div>
3196</fieldset>"#,
3197                        layout = layout.class_suffix(),
3198                        heading = tera::escape_html(&heading),
3199                        help_html = help_html,
3200                        inner = inner,
3201                    )
3202                }
3203                TabBody::Help { content } => {
3204                    // Static help block. Author-supplied HTML; emit
3205                    // raw inside a hint-styled container.
3206                    format!(
3207                        r#"<div class="rcms-panel-help">{content}</div>"#,
3208                        content = content,
3209                    )
3210                }
3211            };
3212            serde_json::json!({
3213                "name": spec.name,
3214                "label": spec.label,
3215                "icon": spec.icon,
3216                "badge": spec.badge,
3217                "html": html,
3218            })
3219        })
3220        .collect()
3221}
3222
3223/// GET /cms-admin/x/{slug} — custom admin page dispatcher. Looks up the
3224/// registered [`AdminPageHandler`](super::admin_page::AdminPageHandler)
3225/// matching `slug` and forwards to its `render`. Unknown slugs map
3226/// to 404.
3227pub async fn admin_page_dispatch(
3228    State(state): State<super::AdminState>,
3229    tenant: Tenant,
3230    headers: HeaderMap,
3231    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3232    Path(slug): Path<String>,
3233) -> Result<Response, AdminError> {
3234    match super::admin_page::find_admin_page(&slug) {
3235        Some(handler) => Ok(handler
3236            .render(super::admin_page::AdminPageCtx {
3237                tera: &state.tera,
3238                tenant: &tenant,
3239                headers: &headers,
3240                user: session_user.as_ref(),
3241            })
3242            .await),
3243        None => Err(AdminError::NotFound(0)),
3244    }
3245}
3246
3247/// Load the active admin theme + its brand colors and stuff the
3248/// rendered CSS / data-attrs into the Tera context so `_base.html`
3249/// can drop them straight into the page chrome. Falls back gracefully
3250/// if no theme is configured (admin renders with built-in defaults).
3251pub(crate) async fn add_admin_theme(ctx: &mut Context, pool: &rustango::sql::Pool) {
3252    // Pick the row flagged `is_admin_default`; if none, fall back to
3253    // whichever is `is_default`; if still none, the first row.
3254    let mut admin_default: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3255        .where_(crate::theme::Theme::is_admin_default.eq(true))
3256        .fetch(pool)
3257        .await
3258        .unwrap_or_default();
3259    let theme = if let Some(t) = admin_default.pop() {
3260        t
3261    } else {
3262        let mut any: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3263            .where_(crate::theme::Theme::is_default.eq(true))
3264            .fetch(pool)
3265            .await
3266            .unwrap_or_default();
3267        match any.pop() {
3268            Some(t) => t,
3269            None => {
3270                let mut first: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3271                    .order_by(&[("name", false)])
3272                    .fetch(pool)
3273                    .await
3274                    .unwrap_or_default();
3275                let Some(t) = first.pop() else {
3276                    // No themes at all — set empty strings so the
3277                    // template's `{% if %}` guards short-circuit.
3278                    ctx.insert("theme_css", &String::new());
3279                    ctx.insert("theme_slug", &String::new());
3280                    ctx.insert("theme_default_mode", &"light");
3281                    ctx.insert("theme_font_url", &String::new());
3282                    return;
3283                };
3284                t
3285            }
3286        }
3287    };
3288    let theme_id = theme.id.get().copied().unwrap_or_default();
3289    let brand_colors: Vec<crate::theme::BrandColor> = crate::theme::BrandColor::objects()
3290        .where_(crate::theme::BrandColor::theme_id.eq(theme_id))
3291        .order_by(&[("sort_order", false)])
3292        .fetch(pool)
3293        .await
3294        .unwrap_or_default();
3295    let css = crate::theme::emit_css(&theme, &brand_colors);
3296    ctx.insert("theme_css", &css);
3297    ctx.insert("theme_slug", &theme.slug);
3298    ctx.insert("theme_name", &theme.name);
3299    ctx.insert("theme_default_mode", &theme.default_mode);
3300    ctx.insert("theme_font_url", &theme.font_url);
3301}
3302
3303/// Query string for the page list / search view.
3304#[derive(Debug, Deserialize)]
3305pub struct ListQuery {
3306    /// Filter children of this parent only. Omitted = root listing.
3307    /// Ignored when `q` is set — search always spans the full tree.
3308    #[serde(default)]
3309    pub parent: Option<i64>,
3310    /// Full-tree search query. Case-insensitive substring match
3311    /// across title, slug, and url_path. Empty string skips the
3312    /// search path and shows the current parent's children.
3313    #[serde(default)]
3314    pub q: Option<String>,
3315    /// Filter results by page type slug — pairs with `q` or stands
3316    /// alone. Matches `cms_page_type.type_name`.
3317    #[serde(default)]
3318    pub r#type: Option<String>,
3319    /// Filter results by status (`draft|scheduled|published|archived`).
3320    #[serde(default)]
3321    pub status: Option<String>,
3322}
3323
3324/// GET /cms-admin/pages — flat list of pages directly under the
3325/// current parent (root by default). Editors drill into a subtree
3326/// via the per-row "View children" action; the breadcrumb trail
3327/// at the top lets them navigate back up. Replaces the previous
3328/// indented full-tree view.
3329///
3330/// Per-page permissions: when the request carries a
3331/// session cookie, the resolver filters out rows the user can't
3332/// `view`. Superusers + anonymous / no-session contexts (sqlite
3333/// dev) see every row.
3334pub async fn page_list(
3335    State(state): State<super::AdminState>,
3336    tenant: Tenant,
3337    headers: HeaderMap,
3338    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3339    Query(q): Query<ListQuery>,
3340) -> Result<Response, AdminError> {
3341    // Best-effort schedule sweep so editors always see current state.
3342    // #207 — uses the mailer-aware variant so the pre-publish
3343    // reminder pass runs on the same tick.
3344    match crate::page::run_schedule_sweep_with_mailer(
3345        tenant.pool(),
3346        state.mailer.as_deref(),
3347        &state.mailer_from,
3348        &tenant.org.slug,
3349    )
3350    .await
3351    {
3352        // A page this sweep put live or took down must leave the cache
3353        // too, as the timed sweep's purge does (#692).
3354        Ok(result) if !result.changed_urls.is_empty() => {
3355            crate::task_queue::purge_urls(
3356                state.cache_invalidator.clone(),
3357                tenant.org.slug.clone(),
3358                result.changed_urls,
3359            )
3360            .await;
3361        }
3362        Ok(_) => {}
3363        Err(e) => tracing::warn!(target: "rustango_cms::admin", error = %e, "schedule sweep failed"),
3364    }
3365
3366    // Pull every page once — we need the full list both for
3367    // breadcrumb computation (walk ancestors of `parent`) and child
3368    // counts (how many pages live under each row in the current
3369    // listing). Tenants stay in the small-N range; the materialized
3370    // list is cheap.
3371    let all_pages: Vec<Page> = Page::objects()
3372        .order_by(&[("path", false), ("sort_order", false)])
3373        .fetch(tenant.pool())
3374        .await?;
3375
3376    // Index pages by id for ancestor walk.
3377    let by_id: std::collections::HashMap<i64, &Page> = all_pages
3378        .iter()
3379        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
3380        .collect();
3381
3382    // Current parent — None means root listing.
3383    let parent_page: Option<&Page> = q.parent.and_then(|pid| by_id.get(&pid).copied());
3384
3385    // Breadcrumb: walk parent chain up to root, then reverse.
3386    let mut breadcrumbs: Vec<serde_json::Value> = Vec::new();
3387    if let Some(mut cur) = parent_page {
3388        breadcrumbs.push(serde_json::json!({
3389            "id": cur.id.get().copied(),
3390            "title": cur.title.clone(),
3391        }));
3392        while let Some(ppid) = cur.parent_id {
3393            if let Some(p) = by_id.get(&ppid).copied() {
3394                breadcrumbs.push(serde_json::json!({
3395                    "id": p.id.get().copied(),
3396                    "title": p.title.clone(),
3397                }));
3398                cur = p;
3399            } else {
3400                break;
3401            }
3402        }
3403        breadcrumbs.reverse();
3404    }
3405
3406    // Determine the working set:
3407    //   - search mode (`q`): full tree, filtered by ILIKE on title/slug/url_path
3408    //   - browse mode (no `q`): direct children of `parent` only
3409    let search_query =
3410        q.q.as_deref()
3411            .map(str::trim)
3412            .filter(|s| !s.is_empty())
3413            .map(str::to_owned);
3414    let status_filter = q
3415        .status
3416        .as_deref()
3417        .map(str::trim)
3418        .filter(|s| !s.is_empty())
3419        .map(str::to_owned);
3420    let type_filter_slug = q
3421        .r#type
3422        .as_deref()
3423        .map(str::trim)
3424        .filter(|s| !s.is_empty())
3425        .map(str::to_owned);
3426
3427    // Per-page permissions filter (#18 phase 3). Skipped when the
3428    // request is anonymous (sqlite dev / no session) or the user
3429    // is a tenant superuser — both paths see every page. For
3430    // authenticated, non-superuser sessions we pre-compute the
3431    // viewable set so the browse/search filter below can apply it.
3432    let viewer_user_id: Option<i64> = session_user
3433        .as_ref()
3434        .filter(|u| u.active)
3435        .and_then(|u| u.id.get().copied());
3436    let viewer_is_superuser = session_user.as_ref().is_some_and(|u| u.is_superuser);
3437    let permission_filter_enabled = viewer_user_id.is_some() && !viewer_is_superuser;
3438    let viewable_ids: Option<std::collections::HashSet<i64>> = match viewer_user_id {
3439        Some(uid) if permission_filter_enabled => {
3440            let pages: Vec<(i64, Option<i64>)> = all_pages
3441                .iter()
3442                .filter_map(|p| p.id.get().copied().map(|id| (id, p.parent_id)))
3443                .collect();
3444            Some(
3445                crate::permissions::viewable_page_ids(tenant.pool(), uid, &pages)
3446                    .await
3447                    .unwrap_or_default(),
3448            )
3449        }
3450        _ => None,
3451    };
3452
3453    // #408 — relevance-ranked, all-status admin search on Postgres: FTS
3454    // finds stemmed / word-boundary matches the substring filter misses
3455    // (across drafts too) and orders by relevance. `None` on non-PG / a
3456    // query error → the substring filter below stands.
3457    let fts_rank: Option<std::collections::HashMap<i64, usize>> = match search_query.as_deref() {
3458        Some(q) => crate::search::search_page_ids_all_statuses(tenant.pool(), q, 1000)
3459            .await
3460            .map(|ids| ids.iter().enumerate().map(|(i, id)| (*id, i)).collect()),
3461        None => None,
3462    };
3463    let visible: Vec<&Page> = if search_query.is_some()
3464        || status_filter.is_some()
3465        || type_filter_slug.is_some()
3466    {
3467        // Search / filter mode — full-tree.
3468        let q_lower = search_query.as_deref().map(str::to_lowercase);
3469        // Resolve type slug → id via the not-yet-fetched type list.
3470        // We pull `cms_page_type` below for the verbose-name map
3471        // either way; do it inline here for the filter id.
3472        let prefetch_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3473        let type_id_by_slug: std::collections::HashMap<String, i64> = prefetch_types
3474            .iter()
3475            .filter_map(|t| t.id.get().copied().map(|id| (t.type_name.clone(), id)))
3476            .collect();
3477        let type_id_filter = type_filter_slug
3478            .as_deref()
3479            .and_then(|s| type_id_by_slug.get(s).copied());
3480        all_pages
3481            .iter()
3482            .filter(|p| {
3483                // A full-text hit OR a substring match (#702): full-text finds
3484                // stemmed words, but not a partial word, a slug fragment or a
3485                // URL path, so on Postgres it must add to the substring match
3486                // the other backends use, not replace it. Relevance order is
3487                // the re-sort below; substring-only hits follow the ranked ones.
3488                let matches_search = match &q_lower {
3489                    None => true,
3490                    Some(needle) => {
3491                        fts_rank.as_ref().is_some_and(|rank| {
3492                            p.id.get().copied().is_some_and(|id| rank.contains_key(&id))
3493                        }) || p.title.to_lowercase().contains(needle)
3494                            || p.slug.to_lowercase().contains(needle)
3495                            || p.url_path.to_lowercase().contains(needle)
3496                    }
3497                };
3498                let matches_status = match &status_filter {
3499                    None => true,
3500                    Some(s) => p.status == *s,
3501                };
3502                let matches_type = match type_id_filter {
3503                    None => true,
3504                    Some(id) => p.page_type_id == id,
3505                };
3506                matches_search && matches_status && matches_type
3507            })
3508            .collect()
3509    } else {
3510        // Browse mode — direct children only.
3511        all_pages
3512            .iter()
3513            .filter(|p| p.parent_id == q.parent)
3514            .collect()
3515    };
3516    // Snapshot the pre-permission visible count so the empty-state
3517    // copy can distinguish "tree is empty here" from "you can't see
3518    // any of these pages" (#70).
3519    let visible_before_permission_filter = visible.len();
3520    // Apply per-page view filter as a final pass — affects both
3521    // search and browse modes uniformly.
3522    let visible: Vec<&Page> = match &viewable_ids {
3523        None => visible,
3524        Some(set) => visible
3525            .into_iter()
3526            .filter(|p| p.id.get().copied().is_some_and(|id| set.contains(&id)))
3527            .collect(),
3528    };
3529    // #408 — when FTS drove the search, order results by relevance
3530    // (overriding the default path order in search mode).
3531    let visible: Vec<&Page> = if let Some(rank) = &fts_rank {
3532        let mut v = visible;
3533        v.sort_by_key(|p| {
3534            p.id.get()
3535                .copied()
3536                .and_then(|id| rank.get(&id).copied())
3537                .unwrap_or(usize::MAX)
3538        });
3539        v
3540    } else {
3541        visible
3542    };
3543    let is_search_mode =
3544        search_query.is_some() || status_filter.is_some() || type_filter_slug.is_some();
3545    // #70 — empty-state classification. Exactly one of these is
3546    // surfaced into the template when `rows | length == 0`:
3547    //   * `empty_filtered`         — search/filter mode dropped every row
3548    //   * `empty_hidden_by_perms`  — per-page permissions dropped every row
3549    //                                that would otherwise be visible
3550    //   * (default)                — genuinely empty section
3551    let empty_filtered = is_search_mode && visible.is_empty();
3552    let empty_hidden_by_perms = !is_search_mode
3553        && visible.is_empty()
3554        && visible_before_permission_filter > 0
3555        && permission_filter_enabled;
3556
3557    // Child counts — for the "View children" CTA.
3558    let mut child_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
3559    for p in &all_pages {
3560        if let Some(ppid) = p.parent_id {
3561            *child_counts.entry(ppid).or_insert(0) += 1;
3562        }
3563    }
3564
3565    let types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3566    let type_map: std::collections::HashMap<i64, String> = types
3567        .iter()
3568        .filter_map(|t| t.id.get().copied().map(|id| (id, t.verbose_name.clone())))
3569        .collect();
3570
3571    let live_urls = build_live_url_map(&all_pages);
3572
3573    // Helper: walk a page's parent chain into a list of `{id, title}`
3574    // crumbs (root → page). Only computed in search mode where the
3575    // editor needs context for results that live deep in the tree.
3576    let ancestors_for = |p: &Page| -> Vec<serde_json::Value> {
3577        let mut chain: Vec<serde_json::Value> = Vec::new();
3578        let mut cur_parent = p.parent_id;
3579        while let Some(pid) = cur_parent {
3580            match by_id.get(&pid).copied() {
3581                Some(ancestor) => {
3582                    chain.push(serde_json::json!({
3583                        "id": ancestor.id.get().copied(),
3584                        "title": ancestor.title.clone(),
3585                    }));
3586                    cur_parent = ancestor.parent_id;
3587                }
3588                None => break,
3589            }
3590        }
3591        chain.reverse();
3592        chain
3593    };
3594
3595    let rows: Vec<serde_json::Value> = visible
3596        .iter()
3597        .map(|p| {
3598            let id = p.id.get().copied();
3599            let ancestors = if is_search_mode {
3600                ancestors_for(p)
3601            } else {
3602                Vec::new()
3603            };
3604            serde_json::json!({
3605                "id": id,
3606                "title": p.title,
3607                "slug": p.slug,
3608                "path": p.path,
3609                "url_path": p.url_path,
3610                "status": p.status,
3611                "page_type_id": p.page_type_id,
3612                "go_live_at": p.go_live_at,
3613                "expire_at": p.expire_at,
3614                "updated_at": p.updated_at.get().copied(),
3615                "published_at": p.published_at,
3616                "locale_variant_of": p.locale_variant_of,
3617                "alias_of": p.alias_of,
3618                "child_count": id.and_then(|i| child_counts.get(&i).copied()).unwrap_or(0),
3619                "ancestors": ancestors,
3620            })
3621        })
3622        .collect();
3623
3624    let mut ctx = Context::new();
3625    add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3626    add_admin_theme(&mut ctx, tenant.pool()).await;
3627    ctx.insert("rows", &rows);
3628    ctx.insert("type_map", &type_map);
3629    // #614 — the "+ New root page" menu must offer only root-legal types.
3630    ctx.insert("creatable_types", &allowed_root_types(&types));
3631    ctx.insert("live_urls", &live_urls);
3632    ctx.insert("breadcrumbs", &breadcrumbs);
3633    ctx.insert("parent_id", &q.parent);
3634    ctx.insert("parent_title", &parent_page.map(|p| p.title.clone()));
3635    ctx.insert("search_query", &search_query);
3636    ctx.insert("status_filter", &status_filter);
3637    ctx.insert("type_filter", &type_filter_slug);
3638    ctx.insert("is_search_mode", &is_search_mode);
3639    ctx.insert("empty_filtered", &empty_filtered);
3640    ctx.insert("empty_hidden_by_perms", &empty_hidden_by_perms);
3641    // For the type/status filter dropdowns the template renders, we
3642    // pass a slug → verbose-name map and a sorted slug list.
3643    let mut type_slugs: Vec<(String, String)> = types
3644        .iter()
3645        .map(|t| (t.type_name.clone(), t.verbose_name.clone()))
3646        .collect();
3647    type_slugs.sort_by(|a, b| a.1.cmp(&b.1));
3648    ctx.insert("type_choices", &type_slugs);
3649
3650    // #65 — Move-to destination picker for the bulk action bar.
3651    // Every page (any depth) is a valid parent except the visible
3652    // selection itself; we expose the full tree pre-formatted with
3653    // an indent prefix so the dropdown reads as a tree. JS filters
3654    // out self/descendants of the actual selection at click time.
3655    let move_choices: Vec<serde_json::Value> = all_pages
3656        .iter()
3657        .map(|p| {
3658            let indent = "—".repeat(p.depth.max(1) as usize - 1);
3659            let label = if indent.is_empty() {
3660                p.title.clone()
3661            } else {
3662                format!("{indent} {}", p.title)
3663            };
3664            serde_json::json!({
3665                "id": p.id.get().copied(),
3666                "label": label,
3667                "path": p.path.clone(),
3668            })
3669        })
3670        .collect();
3671    ctx.insert("move_choices", &move_choices);
3672    // #107 — plugin-contributed per-row buttons. Hand the raw button
3673    // templates over; the template substitutes `{page_id}` per row.
3674    ctx.insert(
3675        "plugin_page_listing_buttons",
3676        &crate::hooks::page_listing_buttons_raw(),
3677    );
3678    // #134 — plugin-contributed bulk actions targeting `cms_page`.
3679    let plugin_bulk_actions: Vec<serde_json::Value> = crate::hooks::bulk_actions_for("cms_page")
3680        .into_iter()
3681        .map(|a| {
3682            serde_json::json!({
3683                "key": a.key,
3684                "label": a.label,
3685                "icon": a.icon,
3686                "danger": a.danger,
3687                "confirm_message": a.confirm_message,
3688                "action_url": a.action_url,
3689            })
3690        })
3691        .collect();
3692    ctx.insert("plugin_bulk_actions", &plugin_bulk_actions);
3693    // #438 — active non-default locales for the copy-to-locale bulk
3694    // action (the default locale already holds canonical content).
3695    let copy_locales: Vec<Locale> = Locale::objects()
3696        .where_(Locale::active.eq(true))
3697        .order_by(&[("sort_order", false), ("code", false)])
3698        .fetch(tenant.pool())
3699        .await
3700        .unwrap_or_default()
3701        .into_iter()
3702        .filter(|l| !l.is_default)
3703        .collect();
3704    ctx.insert("copy_locales", &copy_locales);
3705    render_with_csrf(&state, &headers, "rcms_admin/page_list.html", &mut ctx)
3706}
3707
3708/// Build a map of `page_id → public URL` for every row in `pages`.
3709/// Walks the list once in tree order (the list is already sorted by
3710/// `path` + `sort_order`), so each parent's URL is computed before
3711/// its children. Root pages with empty slug map to `/`.
3712/// Reassemble inline-panel rows from the posted form map.
3713///
3714/// Form keys are shaped `inline__<panel>__<row_idx>__<field>`. The
3715/// extractor iterates the spec's fields (so unknown / extraneous
3716/// keys are ignored), groups them by `row_idx`, and returns rows in
3717/// `row_idx` order so the handler can persist sort_order from the
3718/// position in the slice.
3719///
3720/// Rows are emitted whenever ANY of the spec's fields appears for
3721/// that index. The optional `inline__<panel>__<row_idx>____deleted`
3722/// sentinel hides a row entirely (so the editor can remove rows
3723/// without re-numbering everything).
3724fn extract_inline_panel_rows(
3725    form: &std::collections::HashMap<String, String>,
3726    spec: &crate::page_type::InlinePanelSpec,
3727) -> Vec<serde_json::Map<String, serde_json::Value>> {
3728    let mut by_idx: std::collections::BTreeMap<usize, serde_json::Map<String, serde_json::Value>> =
3729        std::collections::BTreeMap::new();
3730    let prefix = format!("inline__{}__", spec.name);
3731    for (key, value) in form {
3732        let Some(rest) = key.strip_prefix(&prefix) else {
3733            continue;
3734        };
3735        let Some((idx_str, field_name)) = rest.split_once("__") else {
3736            continue;
3737        };
3738        let Ok(idx) = idx_str.parse::<usize>() else {
3739            continue;
3740        };
3741        if field_name == "__deleted" && value == "1" {
3742            by_idx.remove(&idx);
3743            // Mark this index as tombstone — any later entries for
3744            // it get re-inserted into a fresh row that we then drop
3745            // at the end. Use a sentinel key to track.
3746            let mut row = serde_json::Map::new();
3747            row.insert("__deleted".to_owned(), serde_json::Value::Bool(true));
3748            by_idx.insert(idx, row);
3749            continue;
3750        }
3751        if !spec.fields.iter().any(|f| f.name == field_name) {
3752            continue;
3753        }
3754        let row = by_idx.entry(idx).or_default();
3755        if row.contains_key("__deleted") {
3756            continue;
3757        }
3758        row.insert(
3759            field_name.to_owned(),
3760            serde_json::Value::String(value.clone()),
3761        );
3762    }
3763    by_idx
3764        .into_iter()
3765        .filter_map(|(_, row)| {
3766            if row.contains_key("__deleted") {
3767                None
3768            } else {
3769                Some(row)
3770            }
3771        })
3772        .collect()
3773}
3774
3775fn build_live_url_map(pages: &[Page]) -> std::collections::HashMap<String, String> {
3776    let mut by_id: std::collections::HashMap<String, String> = std::collections::HashMap::new();
3777    for p in pages {
3778        let Some(pid) = p.id.get().copied() else {
3779            continue;
3780        };
3781        let url = match p.parent_id {
3782            None => {
3783                if p.slug.is_empty() {
3784                    "/".to_owned()
3785                } else {
3786                    format!("/{}", p.slug)
3787                }
3788            }
3789            Some(parent_id) => {
3790                let parent_url = by_id
3791                    .get(&parent_id.to_string())
3792                    .cloned()
3793                    .unwrap_or_else(|| "/".to_owned());
3794                if p.slug.is_empty() {
3795                    parent_url
3796                } else if parent_url == "/" {
3797                    format!("/{}", p.slug)
3798                } else {
3799                    format!("{}/{}", parent_url, p.slug)
3800                }
3801            }
3802        };
3803        // Stringify the id key so Tera's `m[page.id]` lookup works
3804        // when the serializer flattens to JSON.
3805        by_id.insert(pid.to_string(), url);
3806    }
3807    by_id
3808}
3809
3810/// GET /cms-admin/pages/new[?parent=<id>][&type=<page_type_id>] —
3811/// create flow. Two steps:
3812///
3813/// 1. Without `?type=`, render the page-type picker — a tile grid of
3814///    every creatable type (filtered to the parent's `allowed_child_
3815///    types` when `?parent=` is set). Picking a tile sends the
3816///    editor to step 2.
3817/// 2. With `?type=<id>`, render the page form with the chosen type
3818///    locked. The hidden `page_type_id` input carries it through to
3819///    the POST; the editor can NOT change it after this point.
3820///
3821/// Splitting the type selection out of the form is what makes the
3822/// "page-type is permanent" guarantee actually visible to authors —
3823/// once they're filling fields they're committed to the type.
3824#[derive(Debug, Deserialize)]
3825pub struct NewQuery {
3826    #[serde(default)]
3827    pub parent: Option<i64>,
3828    #[serde(default, rename = "type")]
3829    pub type_id: Option<i64>,
3830}
3831
3832pub async fn page_new_form(
3833    State(state): State<super::AdminState>,
3834    tenant: Tenant,
3835    headers: HeaderMap,
3836    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3837    Query(q): Query<NewQuery>,
3838) -> Result<Response, AdminError> {
3839    let all_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3840
3841    let (parent, allowed_types) = match q.parent {
3842        Some(pid) => {
3843            let parent_row = Page::objects()
3844                .where_(Page::id.eq(pid))
3845                .first(tenant.pool())
3846                .await?
3847                .ok_or(AdminError::NotFound(pid))?;
3848            let allowed = allowed_children_for(&parent_row, &all_types);
3849            (Some(parent_row), allowed)
3850        }
3851        // Root: only types that may legally be roots (#614).
3852        None => (None, allowed_root_types(&all_types)),
3853    };
3854
3855    // Step 1: no type picked yet → show the picker tile grid.
3856    let Some(type_id) = q.type_id else {
3857        // Enrich each PageType row with the registered handler's
3858        // `icon()` + `description()` so the picker can show them.
3859        // Plain `PageType` rows only carry table-level metadata
3860        // (type_name, verbose_name).
3861        #[derive(serde::Serialize)]
3862        struct PickerType<'a> {
3863            id: i64,
3864            type_name: &'a str,
3865            verbose_name: &'a str,
3866            icon: Option<&'static str>,
3867            description: Option<&'static str>,
3868        }
3869        let allowed_enriched: Vec<PickerType<'_>> = allowed_types
3870            .iter()
3871            .map(|t| {
3872                let handler = find_handler(&t.type_name);
3873                PickerType {
3874                    id: t.id.get().copied().unwrap_or_default(),
3875                    type_name: t.type_name.as_str(),
3876                    verbose_name: t.verbose_name.as_str(),
3877                    icon: handler.as_ref().and_then(|h| h.icon()),
3878                    description: handler.as_ref().and_then(|h| h.description()),
3879                }
3880            })
3881            .collect();
3882
3883        let mut ctx = Context::new();
3884        add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3885        add_admin_theme(&mut ctx, tenant.pool()).await;
3886        ctx.insert("parent", &parent);
3887        ctx.insert("allowed_types", &allowed_enriched);
3888        return render_with_csrf(
3889            &state,
3890            &headers,
3891            "rcms_admin/page_type_picker.html",
3892            &mut ctx,
3893        );
3894    };
3895
3896    // Step 2: type picked → validate it sits in the allowed set for
3897    // this parent, then render the form with the type locked. Reject
3898    // out-of-set selections so a hand-crafted URL can't bypass the
3899    // parent's whitelist.
3900    let chosen_type = allowed_types
3901        .iter()
3902        .find(|t| t.id.get().copied() == Some(type_id))
3903        .cloned()
3904        .ok_or_else(|| {
3905            AdminError::Validation(format!(
3906                "page type {type_id} is not creatable under the chosen parent"
3907            ))
3908        })?;
3909
3910    let mut page_seed = empty_page_form_values();
3911    if let Some(obj) = page_seed.as_object_mut() {
3912        obj.insert("page_type_id".to_owned(), serde_json::json!(type_id));
3913    }
3914
3915    let mut ctx = Context::new();
3916    add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3917    add_admin_theme(&mut ctx, tenant.pool()).await;
3918    ctx.insert("mode", "new");
3919    ctx.insert("parent", &parent);
3920    ctx.insert("chosen_type", &chosen_type);
3921    ctx.insert("page", &page_seed);
3922    let review_required = !session_user.as_ref().is_some_and(|u| u.is_superuser)
3923        && crate::workflow::review_workflow_for_type(tenant.pool(), type_id).await?.is_some();
3924    ctx.insert("review_required", &review_required);
3925    // Custom tabs — only the existing-page editor
3926    // calls the handler for them. New-page mode shows the built-in
3927    // tabs only.
3928    ctx.insert("extra_tabs", &Vec::<crate::page_type::TabSpec>::new());
3929    // The type's own fields, at their defaults, so they can be filled
3930    // in before the first save (#857).
3931    let handler = find_handler(&chosen_type.type_name);
3932    let widgets = match &handler {
3933        Some(h) => h.widgets(tenant.pool(), 0).await.unwrap_or_default(),
3934        None => Vec::new(),
3935    };
3936    insert_type_fields(&mut ctx, &state.tera, tenant.pool(), handler.as_deref(), widgets, 0, type_id, None).await;
3937    // Stream-field picker options — every registered block surfaces
3938    // as an option even on the new-page form (so authors can drop
3939    // blocks before the first save).
3940    ctx.insert(
3941        "picker_options",
3942        &crate::block::admin::picker_options(&state.tera),
3943    );
3944    ctx.insert("page_tags", &Vec::<String>::new());
3945    ctx.insert("page_tags_csv", "");
3946    ctx.insert("all_tags", &Vec::<serde_json::Value>::new());
3947    insert_category_choices(&mut ctx, tenant.pool(), None).await;
3948    render_with_csrf(&state, &headers, "rcms_admin/page_form.html", &mut ctx)
3949}
3950
3951/// Slugify a raw string for the `cms_page.slug` column. Mirrors the
3952/// JS-side slugifier in `page_form.html` so the auto-fill the
3953/// editor sees stays consistent with what the server would have
3954/// generated.
3955///
3956/// Lowercase ASCII, hyphens for whitespace, drop everything else,
3957/// collapse runs of hyphens, trim leading / trailing hyphens, cap
3958/// length at 60 chars.
3959pub(crate) fn slugify(raw: &str) -> String {
3960    let mut out = String::with_capacity(raw.len());
3961    let mut last_hyphen = true;
3962    for ch in raw.chars() {
3963        let c = ch.to_ascii_lowercase();
3964        if c.is_ascii_alphanumeric() {
3965            out.push(c);
3966            last_hyphen = false;
3967        } else if !last_hyphen {
3968            out.push('-');
3969            last_hyphen = true;
3970        }
3971    }
3972    while out.ends_with('-') {
3973        out.pop();
3974    }
3975    if out.len() > 60 {
3976        out.truncate(60);
3977        while out.ends_with('-') {
3978            out.pop();
3979        }
3980    }
3981    out
3982}
3983
3984/// Pick a slug that doesn't collide with any sibling of
3985/// `parent_id`. If `candidate` is free, return it unchanged. If
3986/// taken, try `<base>-copy`, then `<base>-copy-2`, `<base>-copy-3`,
3987/// … up to a safety limit of 50 attempts (past which we surface an
3988/// error so the editor sees the collision).
3989///
3990/// Roots compare against other roots (`parent_id IS NULL`); children
3991/// compare against same-parent siblings only.
3992pub(crate) async fn dedup_slug_under_parent(
3993    pool: &rustango::sql::Pool,
3994    parent_id: Option<i64>,
3995    candidate: &str,
3996) -> Result<String, AdminError> {
3997    let taken: std::collections::HashSet<String> = {
3998        let q = Page::objects();
3999        let rows = match parent_id {
4000            Some(pid) => q.where_(Page::parent_id.eq(pid)).fetch(pool).await?,
4001            None => q.where_(Page::parent_id.is_null()).fetch(pool).await?,
4002        };
4003        rows.into_iter().map(|p| p.slug).collect()
4004    };
4005
4006    if !taken.contains(candidate) {
4007        return Ok(candidate.to_owned());
4008    }
4009    let with_copy = format!("{candidate}-copy");
4010    if !taken.contains(&with_copy) {
4011        return Ok(with_copy);
4012    }
4013    for n in 2..50_u32 {
4014        let trial = format!("{candidate}-copy-{n}");
4015        if !taken.contains(&trial) {
4016            return Ok(trial);
4017        }
4018    }
4019    Err(AdminError::Validation(format!(
4020        "could not find a free slug for “{candidate}” after 50 -copy attempts"
4021    )))
4022}
4023
4024/// Whether a root page already has the empty slug, i.e. serves "/".
4025async fn front_page_taken(pool: &rustango::sql::Pool) -> Result<bool, AdminError> {
4026    use rustango::sql::CounterPool as _;
4027    let n = Page::objects()
4028        .where_(Page::parent_id.is_null())
4029        .where_(Page::slug.eq(String::new()))
4030        .count(pool)
4031        .await?;
4032    Ok(n > 0)
4033}
4034
4035/// The page editor's Categories field. A failed lookup leaves the
4036/// field out rather than failing the form.
4037async fn insert_category_choices(ctx: &mut tera::Context, pool: &rustango::sql::Pool, page_id: Option<i64>) {
4038    let (groups, checked) = match crate::category::assign::editor_groups(pool, page_id).await {
4039        Ok(v) => v,
4040        Err(e) => {
4041            tracing::warn!(error = %e, "category choices not loaded; the field is hidden");
4042            Default::default()
4043        }
4044    };
4045    ctx.insert("category_groups", &groups);
4046    ctx.insert("page_category_ids", &checked);
4047}
4048
4049/// POST /cms-admin/pages/new — submit. Dispatches to
4050/// `Page::create_root` when no parent_id is in the form, otherwise
4051/// `Page::create_child`. Both paths compute path/depth/sort_order
4052/// and enforce the type whitelist.
4053pub async fn page_new_submit(
4054    State(_state): State<super::AdminState>,
4055    tenant: Tenant,
4056    headers: HeaderMap,
4057    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
4058    Form(form_map): Form<std::collections::HashMap<String, String>>,
4059) -> Result<Response, AdminError> {
4060    // The raw map also carries the type's own fields (#857), saved once
4061    // the page exists.
4062    let form: PageForm = serde_urlencoded::from_str(
4063        &serde_urlencoded::to_string(&form_map).unwrap_or_default(),
4064    )
4065    .map_err(|e| AdminError::Validation(format!("page form: {e}")))?;
4066    // #614 — a type that names `allowed_parent_types` may only live under one
4067    // of those parents, so it can never be a root. The picker now hides such
4068    // types at the root, but `page_type_id` arrives in the form (and the
4069    // picker is reachable as `?type=<id>`), so re-check it here rather than
4070    // trusting the UI.
4071    if form.parent_id.is_none() {
4072        let types = PageType::objects().fetch(tenant.pool()).await?;
4073        if let Some(row) = types
4074            .iter()
4075            .find(|t| t.id.get().copied() == Some(form.page_type_id))
4076        {
4077            let parents = row.allowed_parents();
4078            if !parents.is_empty() {
4079                return Err(AdminError::Validation(format!(
4080                    "`{}` can't be a root page — it may only be created under: {}",
4081                    row.type_name,
4082                    parents.join(", ")
4083                )));
4084            }
4085        }
4086    }
4087
4088    // An empty slug on a root page makes it the front page ("/"), as the
4089    // form's hint says — unless another root already is; otherwise the
4090    // slug comes from the title.
4091    let mut effective_slug = if !form.slug.trim().is_empty() {
4092        slugify(&form.slug)
4093    } else if form.parent_id.is_none() && !front_page_taken(tenant.pool()).await? {
4094        String::new()
4095    } else {
4096        slugify(&form.title)
4097    };
4098    if !effective_slug.is_empty() {
4099        effective_slug =
4100            dedup_slug_under_parent(tenant.pool(), form.parent_id, &effective_slug).await?;
4101    }
4102
4103    // A new page that would go live takes the publish right (#761, as on
4104    // edit), and a type with a review workflow goes live only through
4105    // it. Decided before the insert and saved as a draft instead, so the
4106    // page is never live for a moment and nothing typed is lost.
4107    let intended = derive_scheduled_status(form.parsed_status().as_str(), form.parsed_go_live_at());
4108    let mut held_back: Option<String> = None;
4109    if let Some(user) = session_user.as_ref().filter(|u| !u.is_superuser) {
4110        if crate::page::PageStatus::str_goes_live(crate::page::PageStatus::Draft.as_str(), &intended) {
4111            let uid = user.id.get().copied().unwrap_or_default();
4112            let req = super::route_perms::Requirement {
4113                codename: "cms_page.publish".to_owned(),
4114                page: form.parent_id.map(|pid| (pid, crate::permissions::Action::Publish)),
4115            };
4116            if let Some(wf) = crate::workflow::review_workflow_for_type(tenant.pool(), form.page_type_id).await? {
4117                held_back = Some(super::i18n::tr(
4118                    &headers,
4119                    "Saved as a draft: pages of this type go live after review (“{workflow}”). Click Submit for review.",
4120                    &[("workflow", wf.name.as_str())],
4121                ));
4122            } else if !super::route_perms::allows_id(tenant.pool(), uid, false, &req).await {
4123                held_back = Some(super::i18n::tr(
4124                    &headers,
4125                    "Saved as a draft: you don't have permission to publish pages here.",
4126                    &[],
4127                ));
4128            }
4129        }
4130    }
4131
4132    let new = NewPage::new(
4133        form.page_type_id,
4134        form.title.clone(),
4135        effective_slug.clone(),
4136    )
4137    .with_status(if held_back.is_some() { crate::page::PageStatus::Draft } else { form.parsed_status() })
4138    .with_seo(form.seo_title.clone(), form.seo_description.clone());
4139
4140    let mut page = match form.parent_id {
4141        Some(pid) => {
4142            let parent = Page::objects()
4143                .where_(Page::id.eq(pid))
4144                .first(tenant.pool())
4145                .await?
4146                .ok_or(AdminError::NotFound(pid))?;
4147            Page::create_child(&tenant, &parent, new).await?
4148        }
4149        None => Page::create_root(&tenant, new).await?,
4150    };
4151
4152    // Apply the non-tree-shape fields that NewPage doesn't carry
4153    // (robots, sitemap_priority) via a follow-up save.
4154    page.robots_index = form.parsed_robots_index();
4155    page.sitemap_priority = form.parsed_sitemap_priority();
4156    page.theme_id = form.theme_id.flatten();
4157    // A held-back page keeps no go-live date: a dated draft would be
4158    // scheduled, and go live without the review.
4159    page.go_live_at = if held_back.is_some() { None } else { form.parsed_go_live_at() };
4160    page.expire_at = form.parsed_expire_at();
4161    page.status = derive_scheduled_status(&page.status, page.go_live_at);
4162    page.show_in_menus = form.parsed_show_in_menus();
4163    page.preview_path = form.preview_path.trim().to_owned();
4164    page.template_override = form.template_override.trim().to_owned();
4165    // #183 — social sharing fields.
4166    page.og_title = form.og_title.clone();
4167    page.og_description = form.og_description.clone();
4168    page.og_image_media_id = form.og_image_media_id;
4169    if let Some(tc) = form.twitter_card.as_deref() {
4170        if matches!(tc, "summary" | "summary_large_image") {
4171            page.twitter_card = tc.to_owned();
4172        }
4173    }
4174    page.save_pool(tenant.pool()).await?;
4175    let new_id = page.id.get().copied().unwrap_or_default();
4176    // Tags and categories are on the new-page form too; they used to be
4177    // dropped here, and only an edit saved them.
4178    if let Some(raw) = form.tags.as_deref().filter(|t| !t.trim().is_empty()) {
4179        let names: Vec<String> = raw.split(',').map(str::to_owned).collect();
4180        crate::page_tag::replace_tags(tenant.pool(), new_id, &names).await?;
4181    }
4182    crate::category::assign::save_from_form(tenant.pool(), new_id, form.categories.as_deref()).await?;
4183    let page_type: Option<PageType> = PageType::objects()
4184        .where_(PageType::id.eq(page.page_type_id))
4185        .first(tenant.pool())
4186        .await?;
4187    save_type_content(tenant.pool(), page_type.as_ref(), page.page_type_id, new_id, &form_map).await?;
4188
4189    // Capture revision #1 for this page so the history
4190    // panel has something to show from the moment a page is born.
4191    crate::revision::capture(tenant.pool(), &page, None)
4192        .await
4193        .log_warn("revision not captured; the history has a gap");
4194    reindex_from_form(tenant.pool(), &tenant.org.slug, new_id, &form_map).await;
4195
4196    // Public render cache (rustango::cache_page::CachePageLayer)
4197    // expires on TTL; no manual invalidation needed here.
4198    let message = held_back.unwrap_or_else(|| {
4199        super::i18n::tr(&headers, "Created page “{title}”.", &[("title", page.title.as_str())])
4200    });
4201    redirect_after_page_save(
4202        &form.action,
4203        page.id.get().copied().unwrap_or_default(),
4204        page.parent_id,
4205        &message,
4206        &headers,
4207    )
4208}
4209
4210/// GET /cms-admin/pages/{id}/edit — load and render the form.
4211/// Query string for the page-edit form. `locale=<code>` flips the
4212/// editor into translation mode for that locale; absent OR pointing
4213/// at the default locale shows the canonical edit form.
4214#[derive(Debug, Deserialize, Default)]
4215pub struct EditQuery {
4216    #[serde(default)]
4217    pub locale: Option<String>,
4218}
4219
4220pub async fn page_edit_form(
4221    State(state): State<super::AdminState>,
4222    tenant: Tenant,
4223    headers: HeaderMap,
4224    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
4225    Path(id): Path<i64>,
4226    Query(q): Query<EditQuery>,
4227) -> Result<Response, AdminError> {
4228    let page = Page::objects()
4229        .where_(Page::id.eq(id))
4230        .first(tenant.pool())
4231        .await?
4232        .ok_or(AdminError::NotFound(id))?;
4233
4234    // #75 — alias proxy. Editing an alias means editing the source;
4235    // bounce the editor there so they're never tweaking a row that
4236    // can't actually accept content changes. Flash explains the
4237    // redirect so it isn't surprising.
4238    if let Some(source_id) = page.alias_of {
4239        return redirect_named_with_params_and_message_args(
4240            "rcms-admin:pages:edit",
4241            &[("id", source_id.to_string())],
4242            MsgLevel::Info,
4243            "Editing the source — alias “{title}” shares content with this row.",
4244            &[("title", page.title.as_str())],
4245            &headers,
4246        );
4247    }
4248
4249    // Load all active locales for the picker + translation lookup.
4250    let locales: Vec<Locale> = Locale::objects()
4251        .where_(Locale::active.eq(true))
4252        .order_by(&[("is_default", false), ("code", false)])
4253        .fetch(tenant.pool())
4254        .await?;
4255    let editing_locale: Option<Locale> = match q.locale.as_deref() {
4256        Some(code) if !code.is_empty() => locales.iter().find(|l| l.code == code).cloned(),
4257        _ => None,
4258    };
4259    let translation_mode = editing_locale
4260        .as_ref()
4261        .map(|l| !l.is_default)
4262        .unwrap_or(false);
4263    let pending = crate::pending_change::for_page(tenant.pool(), id).await?;
4264    let existing_translations = if translation_mode {
4265        let lid = editing_locale
4266            .as_ref()
4267            .and_then(|l| l.id.get().copied())
4268            .unwrap_or(0);
4269        crate::translation::fetch_for(tenant.pool(), id, lid)
4270            .await
4271            .unwrap_or_default()
4272    } else {
4273        std::collections::HashMap::new()
4274    };
4275
4276    // Theme picker dropdown options.
4277    let themes_for_picker: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
4278        .order_by(&[("name", false)])
4279        .fetch(tenant.pool())
4280        .await?;
4281
4282    // Page type is permanent — assigned once at create-time, never
4283    // reassigned. We surface the type as a read-only chip in the
4284    // form so authors can still see what they're editing; the edit
4285    // submit handler also strips `page_type_id` from its canonical
4286    // keys as a defense-in-depth measure.
4287    let chosen_type: PageType = PageType::objects()
4288        .where_(PageType::id.eq(page.page_type_id))
4289        .first(tenant.pool())
4290        .await?
4291        .ok_or_else(|| {
4292            AdminError::Validation(format!(
4293                "page_type_id {} on cms_page row has no cms_page_type row",
4294                page.page_type_id
4295            ))
4296        })?;
4297
4298    // Public URL for the "View live" link in the edit form chrome.
4299    let ancestors = page.ancestors(tenant.pool()).await.unwrap_or_default();
4300    let mut segments: Vec<&str> = ancestors
4301        .iter()
4302        .filter(|a| !a.slug.is_empty())
4303        .map(|a| a.slug.as_str())
4304        .collect();
4305    if !page.slug.is_empty() {
4306        segments.push(page.slug.as_str());
4307    }
4308    let live_url = if segments.is_empty() {
4309        "/".to_owned()
4310    } else {
4311        format!("/{}", segments.join("/"))
4312    };
4313
4314    // Fetch the revision history for the sidebar
4315    // panel. Sorted newest first, capped at 20 for the panel; older
4316    // revisions stay queryable via direct URL.
4317    //
4318    // The cap is applied in SQL (`.limit`), not after the fetch: every
4319    // `Revision` row carries a full JSON `snapshot` of the page, so
4320    // fetching the whole history to show 20 grew the edit-form cost with
4321    // every save (a page edited 300 times pulled 300 page snapshots).
4322    let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
4323        .where_(crate::revision::Revision::page_id.eq(id))
4324        .order_by(&[("sequence", true)]) // desc
4325        .limit(20)
4326        .fetch(tenant.pool())
4327        .await?;
4328
4329    // Sort existing translations into "core" (title / seo_title /
4330    // seo_description) and "extra" so the template can render the
4331    // core fields side-by-side with the canonical, and list the rest
4332    // as editable rows below.
4333    let core_fields = ["title", "seo_title", "seo_description"];
4334    let core_translations: std::collections::HashMap<String, String> = core_fields
4335        .iter()
4336        .map(|f| {
4337            (
4338                (*f).to_owned(),
4339                existing_translations.get(*f).cloned().unwrap_or_default(),
4340            )
4341        })
4342        .collect();
4343    let mut extra_translations: Vec<(String, String)> = existing_translations
4344        .iter()
4345        .filter(|(k, _)| !core_fields.contains(&k.as_str()))
4346        .map(|(k, v)| (k.clone(), v.clone()))
4347        .collect();
4348    extra_translations.sort_by(|a, b| a.0.cmp(&b.0));
4349
4350    let mut ctx = Context::new();
4351    add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
4352    add_admin_theme(&mut ctx, tenant.pool()).await;
4353    ctx.insert("mode", "edit");
4354    ctx.insert("parent", &Option::<Page>::None);
4355    ctx.insert("chosen_type", &chosen_type);
4356    ctx.insert("page", &page);
4357    ctx.insert("live_url", &live_url);
4358    // Headless preview: when the tenant has configured a decoupled
4359    // frontend, mint a token now and hand the editor a link that carries
4360    // it. The mint endpoint is inside the session-gated admin, so an
4361    // editor could otherwise only use preview by copying a token by hand
4362    // — which meant decoupled sites had no working preview at all.
4363    //
4364    // Minted per render rather than per click: the token is short-lived
4365    // and page-scoped, and generating it here keeps the link a plain
4366    // anchor instead of requiring JS. `None` (no frontend set) simply
4367    // hides the action.
4368    // The site-wide template, which the page may override. A lookup
4369    // failure is not fatal — it costs the preview action, not the editor.
4370    let site_preview_base = match crate::preview_url::configured_base(tenant.pool()).await {
4371        Ok(base) => base,
4372        Err(e) => {
4373            tracing::warn!(
4374                target: "rustango_cms::admin",
4375                error = %e,
4376                "headless preview setting lookup failed",
4377            );
4378            None
4379        }
4380    };
4381    // Minted only when there is somewhere to send it: a page with no
4382    // override on a tenant with no frontend has no preview URL at all.
4383    let headless_preview_url = if site_preview_base.is_some() || !page.preview_path.trim().is_empty()
4384    {
4385        let token = crate::preview_token::mint(
4386            &tenant.org.slug,
4387            id,
4388            chrono::Utc::now().timestamp() + PREVIEW_TOKEN_TTL_SECS,
4389        );
4390        crate::preview_url::for_page(
4391            site_preview_base.as_deref(),
4392            &page.preview_path,
4393            &token,
4394            id,
4395            &page.url_path,
4396        )
4397    } else {
4398        None
4399    };
4400    ctx.insert("headless_preview_url", &headless_preview_url);
4401    // #532 — full ancestor trail for the editor breadcrumb (each crumb links
4402    // to that level's children list); plus the immediate parent for "back".
4403    let ancestor_crumbs: Vec<serde_json::Value> = ancestors
4404        .iter()
4405        .map(|a| serde_json::json!({ "id": a.id.get().copied(), "title": a.title }))
4406        .collect();
4407    ctx.insert("ancestors", &ancestor_crumbs);
4408    ctx.insert(
4409        "parent_crumb",
4410        &ancestors
4411            .last()
4412            .map(|a| serde_json::json!({ "id": a.id.get().copied(), "title": a.title })),
4413    );
4414    // #107 — plugin-contributed kebab entries. Server-side substitutes the
4415    // page id into each entry's `href_template`.
4416    ctx.insert(
4417        "plugin_page_action_menu_items",
4418        &crate::hooks::page_action_menu_items(id),
4419    );
4420    // #140 — plugin-contributed page header buttons (next to Save).
4421    ctx.insert(
4422        "plugin_page_header_buttons",
4423        &crate::hooks::page_header_buttons(id),
4424    );
4425    // #115 — is the viewing user subscribed to publish events on
4426    // this page? Drives the Subscribe / Unsubscribe toggle on the
4427    // Status field.
4428    let is_subscribed = match session_user.as_ref().and_then(|u| u.id.get().copied()) {
4429        Some(uid) => crate::page_subscription::is_subscribed(tenant.pool(), id, uid)
4430            .await
4431            .unwrap_or(false),
4432        None => false,
4433    };
4434    ctx.insert("is_subscribed", &is_subscribed);
4435    // #189 — page tags.
4436    let page_tags: Vec<String> = crate::page_tag::tags_for_page(tenant.pool(), id)
4437        .await
4438        .unwrap_or_default()
4439        .into_iter()
4440        .map(|t| t.name)
4441        .collect();
4442    let page_tags_csv = page_tags.join(", ");
4443    ctx.insert("page_tags", &page_tags);
4444    ctx.insert("page_tags_csv", &page_tags_csv);
4445    let all_tags = crate::page_tag::all_tags(tenant.pool())
4446        .await
4447        .unwrap_or_default()
4448        .into_iter()
4449        .map(|(name, count)| serde_json::json!({ "name": name, "count": count }))
4450        .collect::<Vec<_>>();
4451    ctx.insert("all_tags", &all_tags);
4452    insert_category_choices(&mut ctx, tenant.pool(), Some(id)).await;
4453    // #146/#419 — inbound usage ("what links here"), aggregated per
4454    // referrer with resolved titles + a "used in N places" count.
4455    // Best-effort; failure leaves the panel empty.
4456    let usage =
4457        crate::reference_index::usage_summary(tenant.pool(), crate::reference_index::KIND_PAGE, id)
4458            .await;
4459    ctx.insert("usage", &usage);
4460
4461    // #116 — accessibility heuristics. Run server-side on every
4462    // page editor open. `body_html` comes from the handler's
4463    // `load_extension`-rendered HTML when one is available; only the
4464    // canonical Page fields are checked, since extension shape is
4465    // per-handler.
4466    let a11y_violations = crate::a11y::check_page(&page, None);
4467    let (a11y_errors, a11y_warnings, a11y_infos) = crate::a11y::count_by_severity(&a11y_violations);
4468    ctx.insert("a11y_violations", &a11y_violations);
4469    ctx.insert("a11y_errors", &a11y_errors);
4470    ctx.insert("a11y_warnings", &a11y_warnings);
4471    ctx.insert("a11y_infos", &a11y_infos);
4472    // #417 — extensible content/SEO checks (registry-driven). Rendered
4473    // in a sibling "Content & SEO" panel; same Severity buckets as a11y.
4474    let mut content_findings = crate::content_checks::run_all(&page);
4475    // No share image chosen is fine when the page has a photo: the public
4476    // page uses it (see `meta_tags::fallback_share_image`).
4477    if content_findings.iter().any(|f| f.code == "missing_og_image")
4478        && crate::meta_tags::fallback_share_image(tenant.pool(), &page).await.is_some()
4479    {
4480        content_findings.retain(|f| f.code != "missing_og_image");
4481    }
4482    let (content_errors, content_warnings, content_infos) =
4483        crate::content_checks::count_by_severity(&content_findings);
4484    ctx.insert("content_findings", &content_findings);
4485    ctx.insert("content_errors", &content_errors);
4486    ctx.insert("content_warnings", &content_warnings);
4487    ctx.insert("content_infos", &content_infos);
4488    ctx.insert("revisions", &revisions);
4489
4490    // #192 — audit-log timeline for this page. Capped at 100 entries
4491    // for the inline table; the full set is downloadable via the CSV
4492    // export endpoint linked alongside the table.
4493    let log_entries = crate::page_log::for_page(tenant.pool(), id, Some(100))
4494        .await
4495        .unwrap_or_default();
4496    let log_user_ids: std::collections::BTreeSet<i64> =
4497        log_entries.iter().filter_map(|e| e.actor_id).collect();
4498    let log_users: std::collections::HashMap<i64, String> = if log_user_ids.is_empty() {
4499        std::collections::HashMap::new()
4500    } else {
4501        rustango::tenancy::auth::User::objects()
4502            .where_(
4503                rustango::tenancy::auth::User::id
4504                    .is_in(log_user_ids.into_iter().collect::<Vec<_>>()),
4505            )
4506            .fetch(tenant.pool())
4507            .await
4508            .unwrap_or_default()
4509            .into_iter()
4510            .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
4511            .collect()
4512    };
4513    let log_view: Vec<serde_json::Value> = log_entries
4514        .iter()
4515        .map(|e| {
4516            serde_json::json!({
4517                "id": e.id.get().copied(),
4518                "action": e.action,
4519                "actor_id": e.actor_id,
4520                "actor_username": e.actor_id.and_then(|uid| log_users.get(&uid).cloned()),
4521                "message": e.message,
4522                "created_at": e.created_at.get().copied(),
4523            })
4524        })
4525        .collect();
4526    ctx.insert("page_log", &log_view);
4527
4528    ctx.insert("locales", &locales);
4529    ctx.insert("editing_locale", &editing_locale);
4530    ctx.insert("translation_mode", &translation_mode);
4531    ctx.insert("core_translations", &core_translations);
4532    ctx.insert("extra_translations", &extra_translations);
4533    ctx.insert("themes_for_picker", &themes_for_picker);
4534
4535    // Extension fields contributed by the page-type handler — typed
4536    // body / hero / etc. The admin form renders one widget per entry
4537    // alongside the canonical fields so authors edit "Content" in
4538    // one place.
4539    // Resolve the registered handler for this page's type once —
4540    // both `extension_fields` and `display_fields` come off the
4541    // same instance.
4542    // Reuses `chosen_type` (fetched above for the read-only type chip)
4543    // instead of re-querying the identical `cms_page_type` row.
4544    let resolved_handler: Option<Box<dyn crate::page_type::PageTypeHandler>> =
4545        find_handler(&chosen_type.type_name);
4546
4547    // Which preview surface the pane should render: the iframe, the JSON
4548    // body, or a plain "not available" notice.
4549    //
4550    // "No template" is not just an empty string — a non-empty name that
4551    // was never registered in Tera fails identically at render time, so
4552    // both cases have to count or the pane would lazy-load an iframe
4553    // that can only 500.
4554    let preview_mode = {
4555        let kind = crate::page_view::kind_for(&chosen_type);
4556        let template_renders = !chosen_type.default_template.trim().is_empty()
4557            && state
4558                .tera
4559                .get_template_names()
4560                .any(|n| n == chosen_type.default_template);
4561        if kind.serves_json() && !kind.serves_html() {
4562            "json"
4563        } else if template_renders {
4564            "html"
4565        } else {
4566            "none"
4567        }
4568    };
4569    ctx.insert("preview_mode", preview_mode);
4570
4571    // Pull widgets via the rich-typed `widgets()` method, which by
4572    // default delegates to the legacy `extension_fields()` shape
4573    // for handlers that haven't migrated. Returns `Vec<Widget>`
4574    // directly so new handlers can use the full 26-kind catalog
4575    // (Date, Color, Radio, Checkboxes, MultiSelect, Custom, …).
4576    let raw_widgets: Vec<crate::widget::Widget> = match &resolved_handler {
4577        Some(h) => h.widgets(tenant.pool(), id).await.unwrap_or_default(),
4578        None => Vec::new(),
4579    };
4580
4581    // #416 — content metrics (word count / reading time / readability)
4582    // from the content-bearing widget values, so the editor shows them
4583    // without opening the preview. Computed before the widgets are
4584    // mutated for rendering (chooser options etc.).
4585    let content_metrics =
4586        crate::metrics::analyze(&crate::metrics::collect_widget_text(&raw_widgets));
4587    ctx.insert("content_metrics", &content_metrics);
4588
4589    // #i18n — per-leaf StreamField translation rows. In translation mode,
4590    // walk each Stream widget's canonical JSON, enumerate every
4591    // translatable text leaf (recursively, incl. nested blocks), group by
4592    // block instance, and prefill each from the existing per-locale
4593    // overrides. `raw_widgets` still holds canonical values here (it is
4594    // mutated for chooser-option rendering further below).
4595    if translation_mode {
4596        let mut stream_translations: Vec<serde_json::Value> = Vec::new();
4597        let mut leaf_paths: std::collections::HashSet<String> = std::collections::HashSet::new();
4598        for w in &raw_widgets {
4599            if !matches!(w.kind, crate::widget::WidgetKind::Stream) {
4600                continue;
4601            }
4602            let base: serde_json::Value = serde_json::from_str(&w.value)
4603                .unwrap_or_else(|_| serde_json::Value::Array(Vec::new()));
4604            let leaves = crate::block::translate::collect_translatable_leaves(&w.name, &base);
4605            if leaves.is_empty() {
4606                continue;
4607            }
4608            let mut groups: Vec<serde_json::Value> = Vec::new();
4609            let mut cur_id = String::new();
4610            for leaf in &leaves {
4611                leaf_paths.insert(leaf.path.clone());
4612                let row = serde_json::json!({
4613                    "path": leaf.path,
4614                    "widget_kind": leaf.widget_kind.as_tag(),
4615                    "field_label": leaf.field_label,
4616                    "canonical": leaf.canonical_text,
4617                    "canonical_html": translation_canonical_html(leaf.widget_kind.as_tag(), &leaf.canonical_text),
4618                    "value": existing_translations.get(&leaf.path).cloned().unwrap_or_default(),
4619                });
4620                if leaf.block_id != cur_id {
4621                    cur_id.clone_from(&leaf.block_id);
4622                    groups.push(serde_json::json!({
4623                        "block_type": leaf.block_type,
4624                        "block_label": leaf.block_label,
4625                        "block_id": leaf.block_id,
4626                        "depth": leaf.depth,
4627                        "leaves": [row],
4628                    }));
4629                } else if let Some(arr) = groups
4630                    .last_mut()
4631                    .and_then(|g| g.get_mut("leaves"))
4632                    .and_then(|v| v.as_array_mut())
4633                {
4634                    arr.push(row);
4635                }
4636            }
4637            stream_translations.push(serde_json::json!({ "field": w.name, "label": w.label, "groups": groups }));
4638        }
4639        // A code-made type's own text fields (a home page's heading, …).
4640        // Flat keys — the field's name — which the renderer overlays onto
4641        // `extension.<name>` (`translation::overlay_translations`). They
4642        // were translatable but never listed, so the form could not reach
4643        // them.
4644        let field_rows: Vec<serde_json::Value> = raw_widgets
4645            .iter()
4646            .filter(|w| {
4647                use crate::widget::WidgetKind as K;
4648                matches!(w.kind, K::Text | K::Textarea | K::Markdown | K::RichText)
4649                    && !w.name.starts_with(crate::page_builder::compile::FIELD_PREFIX)
4650            })
4651            .map(|w| {
4652                leaf_paths.insert(w.name.clone());
4653                serde_json::json!({
4654                    "path": w.name,
4655                    "widget_kind": w.kind.as_tag(),
4656                    "field_label": w.label,
4657                    "canonical": w.value,
4658                    "canonical_html": translation_canonical_html(w.kind.as_tag(), &w.value),
4659                    "value": existing_translations.get(&w.name).cloned().unwrap_or_default(),
4660                })
4661            })
4662            .collect();
4663        if !field_rows.is_empty() {
4664            stream_translations.insert(
4665                0,
4666                serde_json::json!({
4667                    "field": "fields",
4668                    "label": super::i18n::tr(&headers, "Fields", &[]),
4669                    "groups": [{
4670                        "block_type": "fields",
4671                        "block_label": "",
4672                        "block_id": "fields",
4673                        "depth": 0,
4674                        "leaves": field_rows,
4675                    }],
4676                }),
4677            );
4678        }
4679        // #567 — page-builder body leaves (fixed fields, group members,
4680        // repeater/flex zone blocks). Listed as one more translatable
4681        // "field" alongside the StreamField leaves, keyed `builder.<…>`.
4682        let (builder_groups, builder_paths) =
4683            builder_translation_groups(&tenant, id, page.page_type_id, &existing_translations)
4684                .await;
4685        if !builder_groups.is_empty() {
4686            leaf_paths.extend(builder_paths);
4687            stream_translations
4688                .push(serde_json::json!({
4689                    "field": "builder",
4690                    "label": super::i18n::tr(&headers, "Fields", &[]),
4691                    "groups": builder_groups,
4692                }));
4693        }
4694        // Don't also list dotted leaf paths under the raw "custom keys"
4695        // section (orphaned paths whose block was deleted still appear
4696        // there so editors can clear them).
4697        extra_translations.retain(|(k, _)| !leaf_paths.contains(k));
4698        ctx.insert("stream_translations", &stream_translations);
4699        ctx.insert("extra_translations", &extra_translations);
4700    }
4701
4702    // Computed display chips for the "At a glance" panel above the
4703    // form. See `PageTypeHandler::display_fields` — handlers can
4704    // surface word counts / derived metadata / linked-snippet
4705    // previews without subclassing a panel.
4706    let display_fields: Vec<crate::page_type::DisplayField> = match &resolved_handler {
4707        Some(h) => h
4708            .display_fields(tenant.pool(), id)
4709            .await
4710            .unwrap_or_default(),
4711        None => Vec::new(),
4712    };
4713    ctx.insert("display_fields", &display_fields);
4714
4715    // Handler-contributed tabs — appended to the built-in tab strip
4716    // (Content / Promote / Theme / Revisions). See
4717    // `PageTypeHandler::extra_tabs`.
4718    let mut raw_extra_tabs: Vec<crate::page_type::TabSpec> = match &resolved_handler {
4719        Some(h) => h.extra_tabs(tenant.pool(), id).await.unwrap_or_default(),
4720        None => Vec::new(),
4721    };
4722
4723    // Role list — shared by the Permissions-tab grid below and the
4724    // Privacy tab's "allowed roles" picker further down. Fetched once:
4725    // both used to run the same full-table query independently.
4726    let all_roles: Vec<rustango::tenancy::permissions::Role> =
4727        rustango::tenancy::permissions::Role::objects()
4728            .order_by(&[("name", false)])
4729            .fetch(tenant.pool())
4730            .await
4731            .unwrap_or_default();
4732
4733    // (#18) Permissions tab — every page gets one, regardless of
4734    // page type. Inject a TabSpec::template entry at the front of
4735    // the list so it sits right after Theme.
4736    {
4737        let grants: Vec<crate::permissions::PagePermission> =
4738            crate::permissions::PagePermission::objects()
4739                .where_(crate::permissions::PagePermission::page_id.eq(id))
4740                .fetch(tenant.pool())
4741                .await
4742                .unwrap_or_default();
4743        // (role_id, action) → granted?
4744        let granted: std::collections::HashSet<(i64, String)> = grants
4745            .iter()
4746            .map(|g| (g.role_id, g.permission.clone()))
4747            .collect();
4748        let actions: Vec<&str> = crate::permissions::Action::all()
4749            .iter()
4750            .map(|a| a.as_str())
4751            .collect();
4752        let perm_grid: Vec<serde_json::Value> = all_roles
4753            .iter()
4754            .map(|r| {
4755                let rid = r.id.get().copied().unwrap_or_default();
4756                let row_cells: Vec<serde_json::Value> = actions
4757                    .iter()
4758                    .map(|a| {
4759                        serde_json::json!({
4760                            "action": a,
4761                            "granted": granted.contains(&(rid, (*a).to_owned())),
4762                        })
4763                    })
4764                    .collect();
4765                serde_json::json!({
4766                    "role_id": rid,
4767                    "role_name": r.name,
4768                    "role_description": r.description,
4769                    "cells": row_cells,
4770                })
4771            })
4772            .collect();
4773        let perm_tab = crate::page_type::TabSpec::template(
4774            "permissions",
4775            "Permissions",
4776            "rcms_admin/_permissions_tab.html",
4777        )
4778        .with_icon("admin_panel_settings")
4779        .with_context_value(
4780            "perm_actions",
4781            serde_json::to_value(&actions).unwrap_or_default(),
4782        )
4783        .with_context_value(
4784            "perm_grid",
4785            serde_json::to_value(&perm_grid).unwrap_or_default(),
4786        )
4787        .with_context_value("perm_page_id", serde_json::Value::Number(id.into()));
4788        raw_extra_tabs.insert(0, perm_tab);
4789    }
4790    // (#20) Resolve each `TabSpec` into the flat `{name, label,
4791    // icon, badge, html}` shape the page_form.html template
4792    // expects. `Html` variants pass through; `Template` variants
4793    // render the named Tera template with the standard chrome
4794    // context + the spec's own context map merged in; `Widgets`
4795    // variants route through `_widget_group.html` so widget visuals
4796    // match the Content tab's main stack exactly.
4797    let extra_tabs: Vec<serde_json::Value> =
4798        render_extra_tabs(raw_extra_tabs, &state.tera, &ctx, &headers);
4799    ctx.insert("extra_tabs", &extra_tabs);
4800
4801    // A change held for review shows in place of the live values.
4802    let pending_form = pending.as_ref().filter(|_| !translation_mode).map(crate::pending_change::PendingChange::form_map);
4803    insert_type_fields(
4804        &mut ctx,
4805        &state.tera,
4806        tenant.pool(),
4807        resolved_handler.as_deref(),
4808        raw_widgets,
4809        id,
4810        page.page_type_id,
4811        pending_form.as_ref(),
4812    )
4813    .await;
4814
4815    // Picker options — every registered block surfaces as an option in
4816    // the block-picker dialog inside each stream editor. The dialog
4817    // filters client-side by `data-allowed` at open time.
4818    ctx.insert(
4819        "picker_options",
4820        &crate::block::admin::picker_options(&state.tera),
4821    );
4822
4823    // #72 — editor lock. Best-effort claim on form open: if the page
4824    // is unlocked or already owned by us, we hold the lock and the
4825    // form renders normally. If someone else holds an unexpired
4826    // lock, render the banner with their username + force-unlock
4827    // affordance; the form itself stays editable (we'll reject the
4828    // POST unless the user force-unlocks first).
4829    let mut lock_banner: Option<serde_json::Value> = None;
4830    let mut lock_owned_by_me = false;
4831    let reviewing_elsewhere = match session_user.as_ref() {
4832        Some(u) => read_only_under_review(tenant.pool(), id, u).await?,
4833        None => false,
4834    };
4835    if let Some(viewer_id) = session_user
4836        .as_ref()
4837        .and_then(|u| u.id.get().copied())
4838        .filter(|_| !reviewing_elsewhere)
4839    {
4840        match crate::lock::acquire(tenant.pool(), id, viewer_id, false).await {
4841            Ok(crate::lock::AcquireOutcome::Acquired(_)) => {
4842                lock_owned_by_me = true;
4843            }
4844            Ok(crate::lock::AcquireOutcome::Held(other)) => {
4845                let holder_name = rustango::tenancy::auth::User::objects()
4846                    .where_(rustango::tenancy::auth::User::id.eq(other.user_id))
4847                    .fetch(tenant.pool())
4848                    .await
4849                    .ok()
4850                    .and_then(|v| v.into_iter().next())
4851                    .map(|u| u.username)
4852                    .unwrap_or_else(|| format!("user#{}", other.user_id));
4853                lock_banner = Some(serde_json::json!({
4854                    "holder_username": holder_name,
4855                    "holder_id": other.user_id,
4856                    "acquired_at": other.acquired_at.get().copied(),
4857                    "expires_at": other.expires_at,
4858                }));
4859            }
4860            Err(e) => {
4861                tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "lock acquire failed");
4862            }
4863        }
4864    }
4865    ctx.insert("lock_banner", &lock_banner);
4866    ctx.insert("lock_owned_by_me", &lock_owned_by_me);
4867    ctx.insert("lock_heartbeat_secs", &crate::lock::HEARTBEAT_INTERVAL_SECS);
4868
4869    // #73 PR 2 — workflow context for the action bar + side panel.
4870    // Surface:
4871    //   * `workflow_slug` — the slug the page-type opted into (None if direct-publish)
4872    //   * `workflow` — the resolved Workflow row, if found + active
4873    //   * `workflow_state` — the active WorkflowState row, if one exists
4874    //   * `workflow_current_task` — task currently waiting for a decision (when in_progress)
4875    //   * `workflow_history` — [{task_name, status, decided_by_username, decided_at, comment}, …]
4876    //   * `workflow_viewer_can_decide` — true when viewer is in the current task's role (or superuser)
4877    let workflow_slug: Option<String> = chosen_type.workflow_name();
4878    let mut workflow_ctx: Option<serde_json::Value> = None;
4879    let mut workflow_state_ctx: Option<serde_json::Value> = None;
4880    let mut workflow_current_task_ctx: Option<serde_json::Value> = None;
4881    let mut workflow_history_ctx: Vec<serde_json::Value> = Vec::new();
4882    let mut workflow_viewer_can_decide = false;
4883    if let Some(slug) = workflow_slug.as_deref() {
4884        let workflow = crate::workflow::find_by_name(tenant.pool(), slug)
4885            .await
4886            .unwrap_or(None);
4887        if let Some(wf) = workflow {
4888            let wf_id = wf.id.get().copied().unwrap_or_default();
4889            let tasks = crate::workflow::tasks_for(tenant.pool(), wf_id)
4890                .await
4891                .unwrap_or_default();
4892            workflow_ctx = Some(serde_json::json!({
4893                "id": wf_id,
4894                "name": wf.name,
4895                "description": wf.description,
4896                "task_count": tasks.len(),
4897            }));
4898            // The latest round, whatever its outcome: an approved page says
4899            // so (and can go through review again), not what an earlier
4900            // round ended with.
4901            if let Some(state_row) = crate::workflow::latest_state_for_page(tenant.pool(), id)
4902                .await
4903                .unwrap_or(None)
4904            {
4905                let state_id = state_row.id.get().copied().unwrap_or_default();
4906                // Current task (when in_progress).
4907                if let Some(current) = state_row
4908                    .current_task_id
4909                    .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
4910                {
4911                    workflow_current_task_ctx = Some(serde_json::json!({
4912                        "id": current.id.get().copied(),
4913                        "name": current.name,
4914                        "role_id": current.role_id,
4915                    }));
4916                    if let Some(viewer) = session_user.as_ref() {
4917                        let viewer_id = viewer.id.get().copied().unwrap_or_default();
4918                        workflow_viewer_can_decide = viewer.is_superuser
4919                            || user_is_in_role(tenant.pool(), viewer_id, current.role_id)
4920                                .await
4921                                .unwrap_or(false);
4922                    }
4923                }
4924                workflow_state_ctx = Some(serde_json::json!({
4925                    "id": state_id,
4926                    "status": state_row.status,
4927                    "requested_by": state_row.requested_by,
4928                    "requested_at": state_row.requested_at.get().copied(),
4929                    "finished_at": state_row.finished_at,
4930                }));
4931                // Decision history — flatten task name + reviewer username.
4932                if let Ok(history) = crate::workflow::history_for_page(tenant.pool(), id).await {
4933                    // Pre-resolve user ids to usernames in one batch.
4934                    let reviewer_ids: Vec<i64> =
4935                        history.iter().filter_map(|h| h.decided_by).collect();
4936                    let reviewers: std::collections::HashMap<i64, String> =
4937                        if reviewer_ids.is_empty() {
4938                            std::collections::HashMap::new()
4939                        } else {
4940                            rustango::tenancy::auth::User::objects()
4941                                .where_(rustango::tenancy::auth::User::id.is_in(reviewer_ids))
4942                                .fetch(tenant.pool())
4943                                .await
4944                                .unwrap_or_default()
4945                                .into_iter()
4946                                .filter_map(|u| u.id.get().copied().map(|uid| (uid, u.username)))
4947                                .collect()
4948                        };
4949                    let task_name_by_id: std::collections::HashMap<i64, String> = tasks
4950                        .iter()
4951                        .filter_map(|t| t.id.get().copied().map(|tid| (tid, t.name.clone())))
4952                        .collect();
4953                    workflow_history_ctx = history
4954                        .iter()
4955                        .map(|h| {
4956                            serde_json::json!({
4957                                "task_name": task_name_by_id
4958                                    .get(&h.task_id)
4959                                    .cloned()
4960                                    .unwrap_or_else(|| format!("task #{}", h.task_id)),
4961                                "status": h.status,
4962                                "comment": h.comment,
4963                                "decided_by_username": h
4964                                    .decided_by
4965                                    .and_then(|uid| reviewers.get(&uid).cloned()),
4966                                "decided_at": h.decided_at,
4967                            })
4968                        })
4969                        .collect();
4970                }
4971            }
4972        }
4973    }
4974    // #73 PR 3 — workflow-driven lock. When the page is in_progress
4975    // AND the viewer is not authorized for the current task (and not
4976    // a superuser), the form is read-only — the page belongs to
4977    // whoever is reviewing it right now. Submitter waits for the
4978    // verdict; non-reviewers can't sneak edits in mid-review.
4979    let workflow_locked = workflow_state_ctx
4980        .as_ref()
4981        .and_then(|s| s.get("status"))
4982        .and_then(|v| v.as_str())
4983        .map(|s| s == crate::workflow::WorkflowStatus::InProgress.as_str())
4984        .unwrap_or(false)
4985        && !workflow_viewer_can_decide;
4986    ctx.insert("workflow_slug", &workflow_slug);
4987    ctx.insert("workflow", &workflow_ctx);
4988    ctx.insert("workflow_state", &workflow_state_ctx);
4989    ctx.insert("workflow_current_task", &workflow_current_task_ctx);
4990    ctx.insert("workflow_history", &workflow_history_ctx);
4991    ctx.insert("workflow_viewer_can_decide", &workflow_viewer_can_decide);
4992    ctx.insert("workflow_locked", &workflow_locked);
4993    let review_required = !session_user.as_ref().is_some_and(|u| u.is_superuser)
4994        && crate::workflow::review_workflow_for_type(tenant.pool(), page.page_type_id).await?.is_some();
4995    ctx.insert("review_required", &review_required);
4996    if let (Some(held), Some(form)) = (pending.as_ref(), pending_form.as_ref()) {
4997        ctx.insert("page", &overlay_pending_page(&page, form));
4998        let by = match held.created_by {
4999            Some(uid) => rustango::tenancy::auth::User::objects()
5000                .where_(rustango::tenancy::auth::User::id.eq(uid))
5001                .first(tenant.pool())
5002                .await?
5003                .map(|u| u.username),
5004            None => None,
5005        };
5006        ctx.insert(
5007            "pending_change",
5008            &serde_json::json!({ "by": by, "updated_at": held.updated_at.get().copied() }),
5009        );
5010    }
5011
5012    // #76 — view-restriction context for the Privacy widget.
5013    let view_restriction = crate::view_restriction::direct_for_page(tenant.pool(), id)
5014        .await
5015        .unwrap_or(None);
5016    let restriction_kind = view_restriction
5017        .as_ref()
5018        .map(|r| r.kind.clone())
5019        .unwrap_or_else(|| "none".to_owned());
5020    let restriction_groups = view_restriction
5021        .as_ref()
5022        .map(|r| r.parsed_groups())
5023        .unwrap_or_default();
5024    let restriction_groups_str = restriction_groups
5025        .iter()
5026        .map(i64::to_string)
5027        .collect::<Vec<_>>()
5028        .join(",");
5029    // For the role picker dropdown — reuses the `all_roles` list already
5030    // fetched once above for the Permissions tab.
5031    let role_choices: Vec<serde_json::Value> = all_roles
5032        .iter()
5033        .map(|r| {
5034            serde_json::json!({
5035                "id": r.id.get().copied(),
5036                "name": r.name,
5037                "checked": r.id.get().copied().is_some_and(|rid| restriction_groups.contains(&rid)),
5038            })
5039        })
5040        .collect();
5041    // #members — permission-codename picker (the permission-engine gate).
5042    let restriction_codenames = view_restriction
5043        .as_ref()
5044        .map(|r| r.parsed_codenames())
5045        .unwrap_or_default();
5046    let restriction_codenames_str = restriction_codenames.join(",");
5047    let codename_choices: Vec<serde_json::Value> = super::resources::membership_codenames()
5048        .into_iter()
5049        .map(|(codename, label)| {
5050            serde_json::json!({
5051                "codename": codename,
5052                "label": label,
5053                "checked": restriction_codenames.contains(&codename),
5054            })
5055        })
5056        .collect();
5057    ctx.insert("restriction_kind", &restriction_kind);
5058    ctx.insert("restriction_groups_str", &restriction_groups_str);
5059    ctx.insert("restriction_role_choices", &role_choices);
5060    ctx.insert("restriction_codenames_str", &restriction_codenames_str);
5061    ctx.insert("restriction_codename_choices", &codename_choices);
5062    ctx.insert(
5063        "restriction_has_password",
5064        &view_restriction
5065            .as_ref()
5066            .map(|r| !r.password_hash.is_empty())
5067            .unwrap_or(false),
5068    );
5069
5070    // #81 PR 1 — comments side panel. Fetch every thread on this
5071    // page + every reply in one batched query, group per thread,
5072    // resolve author usernames, and surface as JSON for the panel
5073    // template. Threads with `resolved_at` set render in a
5074    // collapsed "Resolved" bucket client-side.
5075    let threads = crate::comment::threads_for_page(tenant.pool(), id)
5076        .await
5077        .unwrap_or_default();
5078    let thread_ids: Vec<i64> = threads.iter().filter_map(|c| c.id.get().copied()).collect();
5079    let replies_by_thread = crate::comment::replies_for_threads(tenant.pool(), &thread_ids)
5080        .await
5081        .unwrap_or_default();
5082    let mut comment_user_ids: std::collections::BTreeSet<i64> =
5083        threads.iter().map(|c| c.author_id).collect();
5084    for replies in replies_by_thread.values() {
5085        for r in replies {
5086            comment_user_ids.insert(r.author_id);
5087        }
5088    }
5089    let comment_users: std::collections::HashMap<i64, String> = if comment_user_ids.is_empty() {
5090        std::collections::HashMap::new()
5091    } else {
5092        rustango::tenancy::auth::User::objects()
5093            .where_(rustango::tenancy::auth::User::id.is_in(comment_user_ids.iter().copied()))
5094            .fetch(tenant.pool())
5095            .await
5096            .unwrap_or_default()
5097            .into_iter()
5098            .filter_map(|u| u.id.get().copied().map(|uid| (uid, u.username)))
5099            .collect()
5100    };
5101    let comment_threads: Vec<serde_json::Value> = threads
5102        .iter()
5103        .map(|c| {
5104            let tid = c.id.get().copied().unwrap_or_default();
5105            let replies = replies_by_thread.get(&tid).cloned().unwrap_or_default();
5106            let rendered_replies: Vec<serde_json::Value> = replies
5107                .iter()
5108                .map(|r| {
5109                    serde_json::json!({
5110                        "id": r.id.get().copied(),
5111                        "author_username": comment_users.get(&r.author_id).cloned(),
5112                        "body": r.body,
5113                        "created_at": r.created_at.get().copied(),
5114                    })
5115                })
5116                .collect();
5117            serde_json::json!({
5118                "id": tid,
5119                "field_path": c.field_path,
5120                "author_username": comment_users.get(&c.author_id).cloned(),
5121                "body": c.body,
5122                "created_at": c.created_at.get().copied(),
5123                "resolved_at": c.resolved_at,
5124                "replies": rendered_replies,
5125                "reply_count": replies.len(),
5126            })
5127        })
5128        .collect();
5129    ctx.insert("comment_threads", &comment_threads);
5130    ctx.insert(
5131        "comment_open_count",
5132        &comment_threads
5133            .iter()
5134            .filter(|t| t.get("resolved_at").map(|v| v.is_null()).unwrap_or(true))
5135            .count(),
5136    );
5137    ctx.insert(
5138        "comment_resolved_count",
5139        &comment_threads
5140            .iter()
5141            .filter(|t| t.get("resolved_at").map(|v| !v.is_null()).unwrap_or(false))
5142            .count(),
5143    );
5144    // For the field-picker dropdown when adding a new comment.
5145    ctx.insert(
5146        "comment_field_choices",
5147        &serde_json::json!([
5148            {"value": "title", "label": "Title"},
5149            {"value": "slug", "label": "Slug"},
5150            {"value": "seo_title", "label": "SEO title"},
5151            {"value": "seo_description", "label": "SEO description"},
5152            {"value": "body", "label": "Body / stream content"},
5153            {"value": "general", "label": "General — whole page"},
5154        ]),
5155    );
5156
5157    render_with_csrf(&state, &headers, "rcms_admin/page_form.html", &mut ctx)
5158}
5159
5160/// POST /cms-admin/pages/{id}/edit — apply edits.
5161/// POST /cms-admin/pages/{id}/autosave — silent revision capture.
5162/// Takes the same form payload as
5163/// `page_edit_submit` but:
5164///   - Skips status-promotion logic (draft → published doesn't fire).
5165///   - Captures a revision row tagged `autosave: true` so the
5166///     timeline distinguishes autosaves from manual saves.
5167///   - Does NOT cascade slug / url_path recomputation, redirects,
5168///     workflow events, cache invalidation, or page_subscription
5169///     notifications — autosaves are scratch state, not publish
5170///     events.
5171///   - Returns 204 No Content so the editor JS treats success as a
5172///     quiet acknowledgement (no flash banner).
5173pub async fn page_autosave_submit(
5174    State(_state): State<super::AdminState>,
5175    tenant: Tenant,
5176    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
5177    Path(id): Path<i64>,
5178    Form(form_map): Form<std::collections::HashMap<String, String>>,
5179) -> Result<Response, AdminError> {
5180    use rustango::sql::FetcherPool as _;
5181    let mut page = Page::objects()
5182        .where_(Page::id.eq(id))
5183        .first(tenant.pool())
5184        .await?
5185        .ok_or(AdminError::NotFound(id))?;
5186    // Lock-respect — same as the regular save path. Refuse the
5187    // autosave when someone else holds the lock; the editor JS
5188    // surfaces this by suspending future autosaves until the user
5189    // reloads.
5190    if let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) {
5191        if let Ok(Some(lock)) = crate::lock::current(tenant.pool(), id).await {
5192            if lock.user_id != viewer_id {
5193                return Ok((axum::http::StatusCode::CONFLICT, "locked").into_response());
5194            }
5195        }
5196    }
5197    // Autosave writes the page row itself, so it only touches drafts:
5198    // on a live (or scheduled) page it would publish half-typed edits,
5199    // skipping the publish right and any review. The real Save handles
5200    // those pages; here nothing is written.
5201    if page.status != crate::page::PageStatus::Draft.as_str() {
5202        return Ok((axum::http::StatusCode::NO_CONTENT, "").into_response());
5203    }
5204    if let Some(u) = session_user.as_ref() {
5205        if read_only_under_review(tenant.pool(), id, u).await? {
5206            return Ok((axum::http::StatusCode::CONFLICT, "under review").into_response());
5207        }
5208    }
5209    // Overlay mutable fields. Tree placement (parent / path /
5210    // url_path / depth / sort_order) intentionally left alone —
5211    // autosaves never move the page. That includes the slug: writing it
5212    // here without url_path made the next real save see "no slug change",
5213    // so the rename never cascaded to url_path, children or a 301 (#679).
5214    // The edited slug stays in the form and the real save applies it.
5215    if let Some(v) = form_map.get("title") {
5216        page.title = v.clone();
5217    }
5218    if let Some(v) = form_map.get("seo_title") {
5219        page.seo_title = v.clone();
5220    }
5221    if let Some(v) = form_map.get("seo_description") {
5222        page.seo_description = v.clone();
5223    }
5224    // Skip status promotion. If the editor changed status, we
5225    // record it for the diff but don't fire any publish-side
5226    // effects.
5227    let posted_status = form_map.get("status").cloned();
5228    page.save_pool(tenant.pool()).await?;
5229    // Persist extension fields via handler (idempotent upserts).
5230    let pts: Vec<PageType> = PageType::objects()
5231        .where_(PageType::id.eq(page.page_type_id))
5232        .fetch(tenant.pool())
5233        .await?;
5234    if let Some(pt) = pts.into_iter().next() {
5235        if let Some(handler) = find_handler(&pt.type_name) {
5236            let ext_form =
5237                sanitized_extension_form(handler.as_ref(), tenant.pool(), id, &form_map).await;
5238            handler.save_extension(tenant.pool(), id, &ext_form).await?;
5239        }
5240    }
5241    // #564 — page-builder body values (additive to any code handler).
5242    save_page_builder_values(tenant.pool(), page.page_type_id, id, &form_map).await?;
5243    // Capture an autosave-flagged revision. Failure here is
5244    // best-effort.
5245    let by = session_user.as_ref().and_then(|u| u.id.get().copied());
5246    if let Ok(mut rev) = crate::revision::capture(tenant.pool(), &page, by).await {
5247        // Inject the autosave marker into the snapshot before
5248        // re-saving the row. The snapshot column is a plain
5249        // serde_json::Value so we can mutate + re-persist.
5250        if let serde_json::Value::Object(ref mut map) = rev.snapshot {
5251            map.insert("__autosave".to_owned(), serde_json::Value::Bool(true));
5252            if let Some(status) = posted_status {
5253                map.insert(
5254                    "__autosave_posted_status".to_owned(),
5255                    serde_json::Value::String(status),
5256                );
5257            }
5258            rev.save_pool(tenant.pool()).await.log_warn("autosave revision not stored");
5259        }
5260    }
5261    Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
5262}
5263
5264/// Allow-list of POST keys that `page_edit_submit` re-feeds into
5265/// [`PageForm`]. The submit handler filters the incoming form map
5266/// through this list to drop extension-field entries the page type
5267/// handler owns. Every field [`PageForm`] consumes — and every field
5268/// the body of `page_edit_submit` reads off the parsed form — MUST
5269/// be listed here, or the value is silently dropped on save.
5270///
5271/// `page_type_id` is intentionally absent: type is assigned at
5272/// create-time and is permanent (see comment in the handler).
5273/// Page fields the editor shows as text, overlaid from a held change.
5274const PENDING_TEXT_KEYS: &[&str] = &[
5275    "title",
5276    "slug",
5277    "seo_title",
5278    "seo_description",
5279    "og_title",
5280    "og_description",
5281    "preview_path",
5282];
5283
5284/// `page` as the editor shows it with a held change on top: its text
5285/// fields take the proposed values.
5286fn overlay_pending_page(
5287    page: &Page,
5288    form: &std::collections::HashMap<String, String>,
5289) -> serde_json::Value {
5290    let mut value = serde_json::to_value(page).unwrap_or_default();
5291    if let Some(obj) = value.as_object_mut() {
5292        for key in PENDING_TEXT_KEYS {
5293            if let Some(v) = form.get(*key) {
5294                obj.insert((*key).to_owned(), serde_json::Value::String(v.clone()));
5295            }
5296        }
5297    }
5298    value
5299}
5300
5301/// Give each widget its value from a held change. An unticked checkbox
5302/// isn't posted, so a Boolean the form lacks is off.
5303fn overlay_pending_widgets(
5304    widgets: &mut [crate::widget::Widget],
5305    form: &std::collections::HashMap<String, String>,
5306) {
5307    for w in widgets {
5308        match form.get(&w.name) {
5309            Some(v) => w.value.clone_from(v),
5310            None if matches!(w.kind, crate::widget::WidgetKind::Boolean) => w.value.clear(),
5311            None => {}
5312        }
5313    }
5314}
5315
5316const PAGE_FORM_CANONICAL_KEYS: &[&str] = &[
5317    "title",
5318    "slug",
5319    "status",
5320    "seo_title",
5321    "seo_description",
5322    "robots_index",
5323    "sitemap_priority",
5324    "parent_id",
5325    "theme_id",
5326    // #207 — schedule + auto-archive.
5327    "go_live_at",
5328    "expire_at",
5329    // #22 — surface in navigation editor.
5330    "show_in_menus",
5331    // Headless preview — per-page frontend route override.
5332    "preview_path",
5333    // Per-page template, overriding the page type's.
5334    "template_override",
5335    // #183 — social sharing.
5336    "og_title",
5337    "og_description",
5338    "og_image_media_id",
5339    "twitter_card",
5340    // #189 — page tags (comma-separated).
5341    "tags",
5342];
5343
5344/// The acting user for [`apply_page_edit`] — carries exactly what the
5345/// lock / workflow / attribution logic needs, decoupled from the HTTP
5346/// session type so the MCP tools can act as a key's owner.
5347pub(crate) struct PageEditActor {
5348    pub id: i64,
5349    pub username: String,
5350    pub is_superuser: bool,
5351}
5352
5353/// A save refused for a *policy* reason (not an error): the caller
5354/// renders it in its own shape — the HTTP handler as a flash+redirect,
5355/// an MCP tool as a structured tool error.
5356pub(crate) enum PageEditRefusal {
5357    /// Page is mid-review on a workflow step the actor can't edit.
5358    WorkflowReview { task_name: String },
5359    /// Another editor holds the edit lock.
5360    LockedBy { holder: String },
5361    /// Archived pages can't be unpublished in place.
5362    ArchivedUnpublish,
5363    /// The save would put the page live and the actor lacks the publish
5364    /// right.
5365    PublishDenied,
5366    /// The save would put the page live, but pages of its type go live
5367    /// through the named review workflow.
5368    ReviewRequired { workflow: String },
5369}
5370
5371/// What a successful [`apply_page_edit`] produced, for caller messaging.
5372pub(crate) struct PageEditOutcome {
5373    pub page: Page,
5374    pub redirects_created: usize,
5375    pub reapproval_kicked: bool,
5376    /// The save was kept for review; the live page is unchanged.
5377    pub held_for_review: bool,
5378}
5379
5380/// Apply one page edit end-to-end from a canonical+extension form map —
5381/// the single write path behind both `page_edit_submit` (HTTP) and the
5382/// MCP `update_page`/`publish_page` tools. Covers: workflow + editor
5383/// lock policy, the canonical-key overlay (`PAGE_FORM_CANONICAL_KEYS`),
5384/// scheduled-status derivation + publish timestamps, the atomic tree
5385/// save with url-path cascade + on-commit cache purges, tags, revision
5386/// capture (attributed to `actor`), reference reindex, search sync,
5387/// publish hooks + page log, extension + inline-panel + page-builder
5388/// value persistence, auto-301s on slug moves, redirect auto-disable on
5389/// unpublish, and reapproval-on-edit. `notify = false` skips the
5390/// publish subscription mail (MCP v1). Flash/redirect rendering stays
5391/// with the HTTP handler.
5392#[allow(clippy::too_many_arguments)]
5393pub(crate) async fn apply_page_edit(
5394    pool: &rustango::sql::Pool,
5395    org_slug: &str,
5396    invalidator: &std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator>,
5397    mailer: Option<&dyn rustango::email::Mailer>,
5398    mailer_from: &str,
5399    notify: bool,
5400    id: i64,
5401    form_map: &std::collections::HashMap<String, String>,
5402    actor: Option<&PageEditActor>,
5403) -> Result<Result<PageEditOutcome, PageEditRefusal>, AdminError> {
5404    // #73 PR 3 — workflow lock. While the page is in_progress on a
5405    // workflow, only members of the current task's role (and
5406    // superusers) can save edits. Submitter waits for the verdict;
5407    // non-reviewers can't sneak fixes in mid-review. Checked BEFORE
5408    // the editor lock — workflow restrictions outrank concurrency.
5409    if let Some(actor) = actor {
5410        if let Some(active) = crate::workflow::active_state_for_page(pool, id).await? {
5411            if active.status == crate::workflow::WorkflowStatus::InProgress.as_str()
5412                && !actor.is_superuser
5413            {
5414                let tasks = crate::workflow::tasks_for(pool, active.workflow_id).await?;
5415                if let Some(current_task) = active
5416                    .current_task_id
5417                    .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
5418                {
5419                    if !user_is_in_role(pool, actor.id, current_task.role_id).await? {
5420                        return Ok(Err(PageEditRefusal::WorkflowReview {
5421                            task_name: current_task.name.clone(),
5422                        }));
5423                    }
5424                }
5425            }
5426        }
5427    }
5428
5429    // #72 — refuse the write if the page is locked by someone else.
5430    // The GET path acquires the lock for the viewer; if they got
5431    // through, this is a no-op. If a second editor saves anyway
5432    // (race or curl), they hit a 409-flavored redirect with a flash
5433    // explaining who holds the lock. Force-unlock is a separate
5434    // POST so accidental clobbers stay impossible.
5435    if let Some(actor) = actor {
5436        match crate::lock::current(pool, id).await {
5437            Ok(Some(lock)) if lock.user_id != actor.id => {
5438                let holder = rustango::tenancy::auth::User::objects()
5439                    .where_(rustango::tenancy::auth::User::id.eq(lock.user_id))
5440                    .fetch(pool)
5441                    .await
5442                    .ok()
5443                    .and_then(|v| v.into_iter().next())
5444                    .map(|u| u.username)
5445                    .unwrap_or_else(|| format!("user#{}", lock.user_id));
5446                return Ok(Err(PageEditRefusal::LockedBy { holder }));
5447            }
5448            _ => {}
5449        }
5450    }
5451
5452    // Re-deserialize as PageForm using only the canonical keys. The
5453    // form map also carries extension-field entries (typed body /
5454    // hero / etc.) the type's handler is interested in; we hand that
5455    // raw HashMap to `save_extension` after the canonical save.
5456    //
5457    // `page_type_id` is *not* in this list — page type is assigned at
5458    // create-time and is permanent. Any value posted is ignored. The
5459    // template hides the selector and the handler defensively drops
5460    // the key here. Caller scenarios that *must* change a page's
5461    // type can delete + recreate (preserves slug history via
5462    // `cms_redirect`).
5463    let canonical_keys = PAGE_FORM_CANONICAL_KEYS;
5464    let mut canonical_only: std::collections::HashMap<&str, String> = form_map
5465        .iter()
5466        .filter(|(k, _)| canonical_keys.contains(&k.as_str()))
5467        .map(|(k, v)| (k.as_str(), v.clone()))
5468        .collect();
5469
5470    let mut page = Page::objects()
5471        .where_(Page::id.eq(id))
5472        .first(pool)
5473        .await?
5474        .ok_or(AdminError::NotFound(id))?;
5475
5476    // Re-inject the immutable `page_type_id` from the persisted row
5477    // so `PageForm`'s deserializer is satisfied without trusting
5478    // anything the client posted.
5479    let frozen_type_id = page.page_type_id.to_string();
5480    canonical_only.insert("page_type_id", frozen_type_id);
5481    let canonical_view: std::collections::HashMap<&str, &str> = canonical_only
5482        .iter()
5483        .map(|(k, v)| (*k, v.as_str()))
5484        .collect();
5485    let form: PageForm = serde_urlencoded::from_str(
5486        &serde_urlencoded::to_string(&canonical_view).unwrap_or_default(),
5487    )
5488    .map_err(|e| AdminError::Validation(format!("canonical form: {e}")))?;
5489
5490    // A live page of a type whose review workflow asks for re-approval
5491    // on edit: a non-superuser's save waits for that review instead of
5492    // changing what visitors see. The final approval applies it (a save
5493    // with no actor, so it isn't held again).
5494    if let Some(actor) = actor.filter(|a| !a.is_superuser) {
5495        if page.status == crate::page::PageStatus::Published.as_str() {
5496            if let Some(wf) = crate::workflow::review_workflow_for_type(pool, page.page_type_id)
5497                .await?
5498                .filter(|wf| wf.require_reapproval_on_edit)
5499            {
5500                crate::pending_change::hold(pool, id, form_map, Some(actor.id)).await?;
5501                let mut started = false;
5502                if crate::workflow::active_state_for_page(pool, id).await?.is_none() {
5503                    let tasks =
5504                        crate::workflow::tasks_for(pool, wf.id.get().copied().unwrap_or_default())
5505                            .await?;
5506                    crate::workflow::submit_for_review(pool, id, &wf, &tasks, actor.id).await?;
5507                    started = true;
5508                }
5509                return Ok(Ok(PageEditOutcome {
5510                    page,
5511                    redirects_created: 0,
5512                    reapproval_kicked: started,
5513                    held_for_review: true,
5514                }));
5515            }
5516        }
5517    }
5518
5519    page.title = form.title.clone();
5520    // #703 — the same normalisation a new page gets, and no two siblings
5521    // on one slug: they would share a URL and serve whichever row the
5522    // driver returned. The pattern attribute alone is bypassed by any
5523    // direct POST (and by MCP update_page, which lands here).
5524    let new_slug = if form.slug.trim().is_empty() {
5525        String::new()
5526    } else {
5527        slugify(&form.slug)
5528    };
5529    let slug_changed = page.slug != new_slug;
5530    if slug_changed && !new_slug.is_empty() {
5531        let sibling = Page::objects()
5532            .where_(Page::slug.eq(new_slug.clone()))
5533            .where_(Page::id.ne(id));
5534        let sibling = match page.parent_id {
5535            Some(pid) => sibling.where_(Page::parent_id.eq(pid)),
5536            None => sibling.where_(Page::parent_id.is_null()),
5537        };
5538        if sibling.first(pool).await?.is_some() {
5539            return Err(AdminError::Validation(format!(
5540                "another page under the same parent already uses the slug “{new_slug}”"
5541            )));
5542        }
5543    }
5544    // Capture the OLD url_path BEFORE the recomputation block below
5545    // overwrites it. Used after commit to evict the now-stale cache
5546    // entry under the page's previous URL.
5547    let old_url_path = page.url_path.clone();
5548    page.slug = new_slug;
5549    // #553 — remember whether this save takes the page out of
5550    // Published, so linked redirect rules can be auto-disabled below.
5551    let was_published = page.status == crate::page::PageStatus::Published.as_str();
5552    // #556 — remember whether it was archived, to block an unpublish
5553    // (archived → draft) below. Archived → published is the unarchive
5554    // path and stays allowed.
5555    let was_archived = page.status == crate::page::PageStatus::Archived.as_str();
5556    let old_status = page.status.clone();
5557    // page.page_type_id stays as-is — see comment on `canonical_keys`.
5558    page.status = form.parsed_status().as_str().to_owned();
5559    page.seo_title = form.seo_title.clone();
5560    page.seo_description = form.seo_description.clone();
5561    page.robots_index = form.parsed_robots_index();
5562    page.sitemap_priority = form.parsed_sitemap_priority();
5563    // The editor has no theme input: keep the stored theme unless the
5564    // request carries the field (#902).
5565    if let Some(theme_id) = form.theme_id {
5566        page.theme_id = theme_id;
5567    }
5568    // #207 — clear the pre-publish reminder flag when go_live_at
5569    // moves so a fresh schedule horizon gets a fresh reminder.
5570    let new_go_live = form.parsed_go_live_at();
5571    if page.go_live_at != new_go_live {
5572        page.notification_pre_published_sent = false;
5573    }
5574    page.go_live_at = new_go_live;
5575    page.expire_at = form.parsed_expire_at();
5576    // #264 — derive scheduled state from go_live_at AFTER the form's
5577    // chosen status has been applied above, so picking "Draft" +
5578    // setting a future go-live still parks the row in the sweep's
5579    // pickup queue.
5580    page.status = derive_scheduled_status(&page.status, page.go_live_at);
5581    page.show_in_menus = form.parsed_show_in_menus();
5582    page.preview_path = form.preview_path.trim().to_owned();
5583    page.template_override = form.template_override.trim().to_owned();
5584    // #251 — first/last publish timestamps. `published_at` is set
5585    // once on the first published transition (still the
5586    // chronological-ordering anchor). `last_published_at` bumps on
5587    // every save while status=published — sitemap / cache use it
5588    // for freshness.
5589    if page.status == crate::page::PageStatus::Published.as_str() {
5590        let now = chrono::Utc::now();
5591        if page.published_at.is_none() {
5592            page.published_at = Some(now);
5593        }
5594        page.last_published_at = Some(now);
5595    }
5596    // #556 — an archived page can't be unpublished to Draft in place;
5597    // it must be revived (→ Published) or explicitly unarchived first.
5598    // This runs before any DB mutation below.
5599    if was_archived && page.status == crate::page::PageStatus::Draft.as_str() {
5600        return Ok(Err(PageEditRefusal::ArchivedUnpublish));
5601    }
5602    // #761 — judged on the status this save actually lands on, after
5603    // `derive_scheduled_status`, so neither `archived` nor Draft plus a
5604    // go-live date gets a draft public without the publish right. Here so
5605    // the admin form and MCP share one rule. A save with no actor is the
5606    // CMS's own.
5607    if let Some(actor) = actor {
5608        if crate::page::PageStatus::str_goes_live(&old_status, &page.status) {
5609            // A workflow on the page type is only a promise if nobody can
5610            // publish around it: only its approval (or a superuser) puts
5611            // such a page live. Asked first — "submit it for review" is
5612            // the useful answer whatever the actor's rights.
5613            if !actor.is_superuser {
5614                if let Some(wf) = crate::workflow::review_workflow_for_type(pool, page.page_type_id).await? {
5615                    return Ok(Err(PageEditRefusal::ReviewRequired { workflow: wf.name }));
5616                }
5617            }
5618            let req = super::route_perms::Requirement {
5619                codename: "cms_page.publish".to_owned(),
5620                page: Some((id, crate::permissions::Action::Publish)),
5621            };
5622            if !super::route_perms::allows_id(pool, actor.id, actor.is_superuser, &req).await {
5623                return Ok(Err(PageEditRefusal::PublishDenied));
5624            }
5625        }
5626    }
5627    // #183 — social sharing fields.
5628    page.og_title = form.og_title.clone();
5629    page.og_description = form.og_description.clone();
5630    page.og_image_media_id = form.og_image_media_id;
5631    if let Some(tc) = form.twitter_card.as_deref() {
5632        if matches!(tc, "summary" | "summary_large_image") {
5633            page.twitter_card = tc.to_owned();
5634        }
5635    }
5636
5637    // Recompute the materialized `url_path` when the
5638    // slug changes, and cascade the recomputation to
5639    // every descendant so deep trees stay correct after an ancestor
5640    // rename.
5641    if slug_changed {
5642        let parent_url_path = match page.parent_id {
5643            None => None,
5644            Some(pid) => Page::objects()
5645                .where_(Page::id.eq(pid))
5646                .first(pool)
5647                .await?
5648                .map(|p| p.url_path),
5649        };
5650        page.url_path = crate::tree_ops::compute_url_path(parent_url_path.as_deref(), &page.slug);
5651    }
5652    let new_url_path = page.url_path.clone();
5653
5654    // Wrap self-save + cascade in one atomic_tree block so the tree
5655    // never observes a mixed state (own page updated but children
5656    // stale). The #78 purge of the affected URLs — this page's new
5657    // URL, plus (on a slug change) its old URL and every descendant —
5658    // is registered via on_commit, so it fires only once the save
5659    // commits (never on rollback) and runs detached. #317.
5660    let invalidator = invalidator.clone();
5661    let tenant_slug = org_slug.to_owned();
5662    let purge_new = new_url_path.clone();
5663    let purge_old = old_url_path.clone();
5664    let (page, descendant_urls) = crate::tree_ops::atomic_tree(pool, move |tx| {
5665        Box::pin(async move {
5666            page.save_tx(tx).await?;
5667            let descendants: Vec<Page> = if slug_changed {
5668                crate::tree_ops::cascade_url_path_to_descendants(tx, &page).await?;
5669                Page::objects()
5670                    .where_(Page::path.like(crate::tree::descendants_like(&page.path)))
5671                    .where_(Page::path.ne(page.path.clone()))
5672                    .fetch_tx(tx)
5673                    .await?
5674            } else {
5675                Vec::new()
5676            };
5677            // A rename moves this page and everything under it: keep the
5678            // old addresses of the public ones working (redirects that
5679            // follow the page).
5680            if slug_changed {
5681                let public = |p: &Page| matches!(p.status.as_str(), "published" | "archived");
5682                let mut moves = Vec::with_capacity(1 + descendants.len());
5683                if public(&page) {
5684                    moves.push((page.id.get().copied().unwrap_or_default(), purge_old.clone(), purge_new.clone()));
5685                }
5686                for d in descendants.iter().filter(|d| public(d)) {
5687                    if let Some(old) = crate::redirect::rebase_path(&d.url_path, &purge_new, &purge_old) {
5688                        moves.push((d.id.get().copied().unwrap_or_default(), old, d.url_path.clone()));
5689                    }
5690                }
5691                crate::redirect::record_renames_tx(tx, &moves).await?;
5692            }
5693            let descendant_urls: Vec<String> = descendants.into_iter().map(|d| d.url_path).collect();
5694            let mut urls = Vec::with_capacity(2 + descendant_urls.len());
5695            urls.push(purge_new.clone());
5696            if slug_changed && purge_old != purge_new && !purge_old.is_empty() {
5697                urls.push(purge_old);
5698            }
5699            urls.extend(descendant_urls.iter().cloned());
5700            crate::cache_invalidate::invalidate_urls_on_commit(invalidator, tenant_slug, urls);
5701            Ok((page, descendant_urls))
5702        })
5703    })
5704    .await?;
5705    // #705 — the page's content goes in straight after the core row, and
5706    // before anything announces the save: the revision, the reference
5707    // index, search, publish hooks, subscriber mail and the page log all
5708    // describe this content. A failed write is returned to the caller,
5709    // not logged and swallowed behind a "Saved" flash. (The writes can't
5710    // join the core row's transaction yet — the handler hooks take a
5711    // pool — so the core row stays committed; resubmitting is safe, the
5712    // upserts are idempotent.)
5713    //
5714    // #189 — tags from the comma-separated `tags` field. Missing → left
5715    // alone; posted empty → cleared.
5716    if let Some(tags_raw) = form_map.get("tags") {
5717        let names: Vec<String> = if tags_raw.is_empty() {
5718            Vec::new()
5719        } else {
5720            tags_raw.split(',').map(|s| s.to_owned()).collect()
5721        };
5722        crate::page_tag::replace_tags(pool, id, &names).await?;
5723    }
5724    // #842 — categories, same missing/empty rule as tags.
5725    crate::category::assign::save_from_form(
5726        pool,
5727        id,
5728        form_map.get(crate::category::assign::FORM_KEY).map(String::as_str),
5729    )
5730    .await?;
5731    let pt_opt: Option<PageType> = PageType::objects()
5732        .where_(PageType::id.eq(page.page_type_id))
5733        .first(pool)
5734        .await?;
5735    save_type_content(pool, pt_opt.as_ref(), page.page_type_id, id, form_map).await?;
5736
5737    // Capture revision after commit so the committed
5738    // page row is visible to the sequence SELECT inside capture.
5739    crate::revision::capture(pool, &page, actor.map(|a| a.id))
5740        .await
5741        .log_warn("revision not captured; the history has a gap");
5742
5743    reindex_from_form(pool, org_slug, id, form_map).await;
5744
5745    // #408 — keep an external search index (Elasticsearch) in sync:
5746    // published → indexed, otherwise removed. No-op when no backend is
5747    // installed (the Postgres FTS path needs no maintained index).
5748    crate::task_queue::sync_page_search(org_slug, &page).await;
5749
5750    // #107 — fan out to plugin `after_publish_page` hooks.
5751    let actor_id = actor.map(|a| a.id);
5752    if page.status == crate::page::PageStatus::Published.as_str() {
5753        crate::hooks::fire_after_publish_page(&page);
5754        // #115 — notify-on-publish subscribers.
5755        if notify {
5756            let actor_name = actor.map(|a| a.username.as_str());
5757            crate::page_subscription::notify_publish(
5758                mailer,
5759                mailer_from,
5760                pool,
5761                org_slug,
5762                page.id.get().copied().unwrap_or_default(),
5763                &page.title,
5764                &page.url_path,
5765                actor_name,
5766            )
5767            .await;
5768        }
5769        // #192 — record the publish in the audit log.
5770        crate::page_log::record_or_warn(
5771            pool,
5772            id,
5773            crate::page_log::ACTION_PUBLISH,
5774            actor_id,
5775            format!("Published “{}”.", page.title),
5776            None,
5777        )
5778        .await;
5779    } else {
5780        // #192 — log the edit even when the new status isn't Published.
5781        crate::page_log::record_or_warn(
5782            pool,
5783            id,
5784            crate::page_log::ACTION_EDIT,
5785            actor_id,
5786            format!("Edited “{}”.", page.title),
5787            Some(serde_json::json!({ "status": page.status })),
5788        )
5789        .await;
5790    }
5791
5792
5793    // #64 — auto-create 301 redirects from old paths to new ones
5794    // when a slug change cascades through the URL tree. Editors
5795    // rename pages all the time; keeping the old URL alive prevents
5796    // external links + SEO rank from going dead.
5797    let mut redirects_created = 0usize;
5798    if slug_changed && old_url_path != new_url_path && !old_url_path.is_empty() {
5799        // Capture the descendant before/after pairs alongside the
5800        // page itself. The cascade already updated every descendant's
5801        // url_path in the same transaction; rebuild the OLD → NEW
5802        // map from the path prefix relationship: a descendant whose
5803        // new url_path begins with `new_url_path` had its OLD url at
5804        // `old_url_path + suffix`.
5805        let new_prefix = if new_url_path == "/" {
5806            String::new()
5807        } else {
5808            new_url_path.clone()
5809        };
5810        let old_prefix = if old_url_path == "/" {
5811            String::new()
5812        } else {
5813            old_url_path.clone()
5814        };
5815        let mut pairs: Vec<(String, String)> = vec![(old_url_path.clone(), new_url_path.clone())];
5816        for new_d in &descendant_urls {
5817            if let Some(suffix) = new_d.strip_prefix(new_prefix.as_str()) {
5818                let old_d = format!("{old_prefix}{suffix}");
5819                if old_d != *new_d {
5820                    pairs.push((old_d, new_d.clone()));
5821                }
5822            }
5823        }
5824        // Upsert each pair. If an existing redirect already targets the
5825        // old path (e.g. from a previous rename), update its `to_path`
5826        // so the chain compresses to one hop instead of `foo → bar →
5827        // baz`. New rows land with is_permanent=true (301) + a stamped
5828        // note for auditability.
5829        let now = chrono::Utc::now().to_rfc3339();
5830        for (old_path, new_path) in pairs {
5831            // Look up any existing row keyed on the old URL.
5832            let existing: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
5833                .where_(crate::redirect::Redirect::from_path.eq(old_path.clone()))
5834                .fetch(pool)
5835                .await
5836                .unwrap_or_default();
5837            if let Some(mut r) = existing.into_iter().next() {
5838                // Compress chain: rewrite the existing row's target
5839                // unless it already points at the new URL.
5840                if r.to_path != new_path {
5841                    r.to_path = new_path.clone();
5842                    r.is_permanent = true;
5843                    r.note = format!("auto-updated on page rename at {now}");
5844                    // #553 — link the source page so the rule
5845                    // auto-disables if the page is later removed.
5846                    if r.from_page_id.is_none() {
5847                        r.from_page_id = Some(id);
5848                    }
5849                    r.save_pool(pool).await.log_warn("redirect not linked to its source page");
5850                }
5851                continue;
5852            }
5853            // Compress incoming chain: if an OLD existing row was
5854            // pointing TO old_path, redirect it straight to new_path
5855            // instead so the chain stays one hop.
5856            let stale_chain: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
5857                .where_(crate::redirect::Redirect::to_path.eq(old_path.clone()))
5858                .fetch(pool)
5859                .await
5860                .unwrap_or_default();
5861            for mut r in stale_chain {
5862                // #708 — renaming back (A → B, then B → A) would chain
5863                // A → B into A → A. The page lives at A again, so the
5864                // rule has nothing left to do.
5865                if r.from_path == new_path {
5866                    r.delete_pool(pool)
5867                        .await
5868                        .log_warn("self-redirect left after a rename back not deleted");
5869                    continue;
5870                }
5871                r.to_path = new_path.clone();
5872                r.note = format!("auto-chained on page rename at {now}");
5873                r.save_pool(pool).await.log_warn("redirect chain not updated after a rename");
5874            }
5875            // Insert the fresh old → new row.
5876            let mut row = crate::redirect::Redirect {
5877                id: rustango::sql::Auto::Unset,
5878                from_path: old_path,
5879                to_path: new_path,
5880                is_permanent: true,
5881                note: format!("auto-created on page rename at {now}"),
5882                hit_count: 0,
5883                overrides_live: false,
5884                // Link the renamed page so the rule auto-disables if the
5885                // page is later deleted/unpublished (#553).
5886                from_page_id: Some(id),
5887                to_page_id: None,
5888                is_active: true,
5889                disabled_reason: String::new(),
5890                last_hit_at: None,
5891                created_at: rustango::sql::Auto::Unset,
5892                updated_at: rustango::sql::Auto::Unset,
5893            };
5894            if row.insert_pool(pool).await.is_ok() {
5895                redirects_created += 1;
5896            }
5897        }
5898    }
5899
5900    // #78 cache invalidation for the affected URLs is registered via
5901    // `on_commit` inside the save block above (#317), so it fires only
5902    // once the save commits and doesn't block this response.
5903
5904    // #73 PR 3 — reapproval-on-edit. When the page type is bound to
5905    // a workflow whose `require_reapproval_on_edit` flag is set, and
5906    // the page has previously been through review (any approved
5907    // WorkflowState in its history), restart the workflow on this
5908    // save. The page stays at its current status; a fresh
5909    // WorkflowState pinned to task #1 kicks off a new approval
5910    // cycle. No-op when no active workflow exists for the type, or
5911    // when the page hasn't been approved yet (first-time submitters
5912    // explicitly submit via the action bar).
5913    let mut reapproval_kicked = false;
5914    if let (Some(viewer_id), Some(pt)) = (actor.map(|a| a.id), pt_opt.as_ref()) {
5915        if let Some(slug) = pt.workflow_name() {
5916            if let Some(workflow) = crate::workflow::find_by_name(pool, &slug).await? {
5917                if workflow.require_reapproval_on_edit
5918                    && crate::workflow::active_state_for_page(pool, id)
5919                        .await?
5920                        .is_none()
5921                    && crate::workflow::has_prior_approval(pool, id).await?
5922                {
5923                    let tasks = crate::workflow::tasks_for(
5924                        pool,
5925                        workflow.id.get().copied().unwrap_or_default(),
5926                    )
5927                    .await?;
5928                    if !tasks.is_empty() {
5929                        crate::workflow::submit_for_review(
5930                            pool, id, &workflow, &tasks, viewer_id,
5931                        )
5932                        .await?;
5933                        reapproval_kicked = true;
5934                    }
5935                }
5936            }
5937        }
5938    }
5939
5940    // Public render cache (rustango::cache_page::CachePageLayer)
5941    // is TTL-based; the new/old/descendant URLs propagate after the
5942    // configured TTL elapses.
5943    let _ = (&new_url_path, slug_changed, &old_url_path, &descendant_urls);
5944    // #553 — this save took the page out of Published: redirect rules
5945    // linked to it must not keep serving (a dead source URL, or a
5946    // destination that now 404s). Best-effort; the save itself stands.
5947    if was_published && page.status != crate::page::PageStatus::Published.as_str() {
5948        match crate::redirect::disable_for_page(
5949            pool,
5950            id,
5951            &format!("Linked page “{}” was unpublished", page.title),
5952        )
5953        .await
5954        {
5955            Ok(0) => {}
5956            Ok(n) => {
5957                tracing::info!(
5958                    page_id = id,
5959                    disabled = n,
5960                    "disabled redirects for unpublished page"
5961                );
5962            }
5963            Err(e) => {
5964                tracing::warn!(page_id = id, error = %e, "failed to disable redirects for unpublished page");
5965            }
5966        }
5967    }
5968
5969    // A save that went through directly (a superuser's) supersedes a
5970    // change held for review; the editor showed it pre-filled.
5971    if actor.is_some() {
5972        crate::pending_change::discard(pool, id).await?;
5973    }
5974
5975    Ok(Ok(PageEditOutcome {
5976        page,
5977        redirects_created,
5978        reapproval_kicked,
5979        held_for_review: false,
5980    }))
5981}
5982
5983pub async fn page_edit_submit(
5984    State(_state): State<super::AdminState>,
5985    tenant: Tenant,
5986    headers: HeaderMap,
5987    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
5988    Path(id): Path<i64>,
5989    Form(form_map): Form<std::collections::HashMap<String, String>>,
5990) -> Result<Response, AdminError> {
5991    let actor = session_user.as_ref().map(|u| PageEditActor {
5992        id: u.id.get().copied().unwrap_or_default(),
5993        username: u.username.clone(),
5994        is_superuser: u.is_superuser,
5995    });
5996    let outcome = apply_page_edit(
5997        tenant.pool(),
5998        &tenant.org.slug,
5999        &_state.cache_invalidator,
6000        _state.mailer.as_deref(),
6001        &_state.mailer_from,
6002        true,
6003        id,
6004        &form_map,
6005        actor.as_ref(),
6006    )
6007    .await?;
6008    let PageEditOutcome {
6009        page,
6010        redirects_created,
6011        reapproval_kicked,
6012        held_for_review,
6013    } = match outcome {
6014        Ok(o) => o,
6015        Err(PageEditRefusal::WorkflowReview { task_name }) => {
6016            return redirect_named_with_params_and_message_args(
6017                "rcms-admin:pages:edit",
6018                &[("id", id.to_string())],
6019                MsgLevel::Error,
6020                "Couldn't save — page is under review on “{name}”. Only reviewers of that step can edit during review.",
6021                &[("name", task_name.as_str())],
6022                &headers,
6023            );
6024        }
6025        Err(PageEditRefusal::LockedBy { holder }) => {
6026            return redirect_named_with_params_and_message_args(
6027                "rcms-admin:pages:edit",
6028                &[("id", id.to_string())],
6029                MsgLevel::Error,
6030                "Couldn't save — “{holder}” is editing this page right now. Force-unlock to take over.",
6031                &[("holder", holder.as_str())],
6032                &headers,
6033            );
6034        }
6035        Err(PageEditRefusal::ArchivedUnpublish) => {
6036            return redirect_named_with_params_and_message_args(
6037                "rcms-admin:pages:edit",
6038                &[("id", id.to_string())],
6039                MsgLevel::Error,
6040                "Can't unpublish an archived page. Set it back to Published to unarchive, or delete it after unarchiving.",
6041                &[],
6042                &headers,
6043            );
6044        }
6045        Err(PageEditRefusal::PublishDenied) => {
6046            return redirect_named_with_params_and_message(
6047                "rcms-admin:pages:edit",
6048                &[("id", id.to_string())],
6049                MsgLevel::Error,
6050                "You don't have permission to publish this page — save it as a draft or submit it for review.",
6051                &headers,
6052            );
6053        }
6054        Err(PageEditRefusal::ReviewRequired { workflow }) => {
6055            return redirect_named_with_params_and_message_args(
6056                "rcms-admin:pages:edit",
6057                &[("id", id.to_string())],
6058                MsgLevel::Error,
6059                "Pages of this type go live after review (“{workflow}”). Save it as a draft and click Submit for review.",
6060                &[("workflow", workflow.as_str())],
6061                &headers,
6062            );
6063        }
6064    };
6065    if held_for_review {
6066        return redirect_after_page_save(
6067            form_map.get("_action").map_or("save", String::as_str),
6068            id,
6069            page.parent_id,
6070            &super::i18n::tr(
6071                &headers,
6072                "Your changes to “{title}” wait for review. Visitors see the live page until they are approved.",
6073                &[("title", page.title.as_str())],
6074            ),
6075            &headers,
6076        );
6077    }
6078    let mut message = if redirects_created > 0 {
6079        let count = redirects_created.to_string();
6080        super::i18n::tr_plural(
6081            &headers,
6082            "Saved “{title}”. Auto-created {count} redirect(s) from the old URL(s).",
6083            redirects_created as i64,
6084            &[("title", page.title.as_str()), ("count", count.as_str())],
6085        )
6086    } else {
6087        super::i18n::tr(
6088            &headers,
6089            "Saved “{title}”.",
6090            &[("title", page.title.as_str())],
6091        )
6092    };
6093    if reapproval_kicked {
6094        message.push(' ');
6095        message.push_str(&super::i18n::tr(
6096            &headers,
6097            "Workflow restarted — page enters review again.",
6098            &[],
6099        ));
6100    }
6101    redirect_after_page_save(
6102        form_map.get("_action").map_or("save", String::as_str),
6103        id,
6104        page.parent_id,
6105        &message,
6106        &headers,
6107    )
6108}
6109
6110/// POST /cms-admin/pages/{id}/translate?locale=<code> — upsert
6111/// `cms_translation` rows for the given locale. Empty values delete
6112/// the matching row so the canonical content shows through.
6113///
6114/// Accepts arbitrary field paths (the three core ones — `title`,
6115/// `seo_title`, `seo_description` — plus any custom `field_path`
6116/// referenced by the page's template, e.g. `intro`, `body`,
6117/// `nav_about`). The form sends them as `tr__<path>` keys; the
6118/// "add new key" row uses `new_field_path` + `new_field_value`.
6119/// Apply one batch of translation overrides for `(page_id, locale_id)`:
6120/// an empty value deletes the override row, a non-empty one upserts it.
6121/// Wrapped in `atomic!` so a mid-loop failure rolls back the whole batch —
6122/// callers never leave half-applied translations behind. Callers are
6123/// responsible for locale validation (in particular: never the default
6124/// locale — canonical content lives on `cms_page`).
6125pub(crate) async fn upsert_page_translations(
6126    pool: &rustango::sql::Pool,
6127    page_id: i64,
6128    locale_id: i64,
6129    updates: Vec<(String, String)>,
6130) -> Result<(), rustango::sql::ExecError> {
6131    rustango::atomic!(pool, |tx| {
6132        let mut guard = tx.lock().await?;
6133        let tx = &mut *guard;
6134        for (path, value) in updates {
6135            if value.is_empty() {
6136                let rows: Vec<crate::translation::Translation> =
6137                    crate::translation::Translation::objects()
6138                        .where_(crate::translation::Translation::page_id.eq(page_id))
6139                        .where_(crate::translation::Translation::locale_id.eq(locale_id))
6140                        .where_(crate::translation::Translation::field_path.eq(path.clone()))
6141                        .fetch_tx(tx)
6142                        .await?;
6143                for row in rows {
6144                    row.delete_tx(tx).await?;
6145                }
6146            } else {
6147                let existing: Vec<crate::translation::Translation> =
6148                    crate::translation::Translation::objects()
6149                        .where_(crate::translation::Translation::page_id.eq(page_id))
6150                        .where_(crate::translation::Translation::locale_id.eq(locale_id))
6151                        .where_(crate::translation::Translation::field_path.eq(path.clone()))
6152                        .fetch_tx(tx)
6153                        .await?;
6154                if let Some(mut row) = existing.into_iter().next() {
6155                    row.value = value;
6156                    row.save_tx(tx).await?;
6157                } else {
6158                    let mut row = crate::translation::Translation {
6159                        id: rustango::sql::Auto::Unset,
6160                        page_id,
6161                        locale_id,
6162                        field_path: path,
6163                        value,
6164                        updated_at: rustango::sql::Auto::Unset,
6165                    };
6166                    row.save_tx(tx).await?;
6167                }
6168            }
6169        }
6170        Ok::<_, rustango::sql::ExecError>(())
6171    })
6172    .await
6173}
6174
6175pub async fn page_translate_submit(
6176    State(_state): State<super::AdminState>,
6177    tenant: Tenant,
6178    Path(id): Path<i64>,
6179    Query(q): Query<EditQuery>,
6180    Form(form): Form<std::collections::HashMap<String, String>>,
6181) -> Result<Response, AdminError> {
6182    let code = q
6183        .locale
6184        .as_deref()
6185        .filter(|c| !c.is_empty())
6186        .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
6187    let locale = Locale::objects()
6188        .where_(Locale::code.eq(code.to_owned()))
6189        .where_(Locale::active.eq(true))
6190        .first(tenant.pool())
6191        .await?
6192        .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
6193    if locale.is_default {
6194        return Ok((
6195            axum::http::StatusCode::BAD_REQUEST,
6196            "cannot translate INTO the default locale; canonical content lives on cms_page",
6197        )
6198            .into_response());
6199    }
6200    let locale_id = locale
6201        .id
6202        .get()
6203        .copied()
6204        .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
6205    // Verify the page exists; cheap one-row select.
6206    let _page = Page::objects()
6207        .where_(Page::id.eq(id))
6208        .first(tenant.pool())
6209        .await?
6210        .ok_or(AdminError::NotFound(id))?;
6211
6212    // Collect updates from the form. Keys starting with `tr__` are
6213    // existing-row edits; `new_field_path` + `new_field_value` is the
6214    // single "add new key" row at the bottom of the editor.
6215    let mut updates: Vec<(String, String)> = Vec::new();
6216    for (k, v) in &form {
6217        if let Some(path) = k.strip_prefix("tr__") {
6218            if path.is_empty() {
6219                continue;
6220            }
6221            updates.push((path.to_owned(), v.clone()));
6222        }
6223    }
6224    let new_path = form
6225        .get("new_field_path")
6226        .map(|s| s.trim().to_owned())
6227        .unwrap_or_default();
6228    if !new_path.is_empty() {
6229        let new_value = form.get("new_field_value").cloned().unwrap_or_default();
6230        // Validate shape via the shared guard (≤255, alphanumeric + `_`
6231        // `.` `-`) — allows dotted block-UUID paths into StreamFields.
6232        if let Ok(path) = crate::translation::validate_field_path(&new_path) {
6233            updates.push((path, new_value));
6234        }
6235    }
6236
6237    upsert_page_translations(tenant.pool(), id, locale_id, updates).await?;
6238
6239    // Invalidate cache for both the canonical and `?lang=` keys so
6240    // the next public hit re-renders with the updated translations.
6241    let page = Page::objects()
6242        .where_(Page::id.eq(id))
6243        .first(tenant.pool())
6244        .await?
6245        .ok_or(AdminError::NotFound(id))?;
6246    // Public render cache (rustango::cache_page::CachePageLayer)
6247    // expires on TTL; translation edits propagate after the
6248    // configured timeout.
6249    let _ = (page, &code);
6250
6251    Ok(Redirect::to(&format!("/cms-admin/pages/{id}/edit?locale={code}")).into_response())
6252}
6253
6254/// POST /cms-admin/pages/{id}/delete — refuse if page has children,
6255/// otherwise delete the row. Cascade-delete-with-children deferred.
6256pub async fn page_delete_submit(
6257    State(_state): State<super::AdminState>,
6258    tenant: Tenant,
6259    headers: HeaderMap,
6260    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6261    Path(id): Path<i64>,
6262) -> Result<Response, AdminError> {
6263    let page = Page::objects()
6264        .where_(Page::id.eq(id))
6265        .first(tenant.pool())
6266        .await?
6267        .ok_or(AdminError::NotFound(id))?;
6268
6269    // #556 — archived pages are frozen against deletion (archive is a
6270    // preservation lock, not a step toward removal). The editor must
6271    // unarchive first.
6272    if page.status == crate::page::PageStatus::Archived.as_str() {
6273        return redirect_named_with_message_args(
6274            "rcms-admin:pages:list",
6275            MsgLevel::Error,
6276            "Can't delete “{title}” while archived — unarchive it first.",
6277            &[("title", page.title.as_str())],
6278            &headers,
6279        );
6280    }
6281
6282    let child_count: Vec<Page> = Page::objects()
6283        .where_(Page::parent_id.eq(id))
6284        .fetch(tenant.pool())
6285        .await?;
6286    if !child_count.is_empty() {
6287        let count = child_count.len().to_string();
6288        return redirect_named_with_message_plural(
6289            "rcms-admin:pages:list",
6290            MsgLevel::Error,
6291            "Can't delete “{title}” — it has {count} child page(s). Delete or move them first.",
6292            child_count.len() as i64,
6293            &[("title", page.title.as_str()), ("count", count.as_str())],
6294            &headers,
6295        );
6296    }
6297
6298    // A hostname pointing at this root has a foreign key to it, so the
6299    // delete would fail with an opaque FK error. Refuse with the names
6300    // instead — and refuse rather than dropping the mapping, because a
6301    // live domain quietly falling back to a different site is a change
6302    // only visitors would notice.
6303    let serving_hosts = crate::site::hosts_for_root(tenant.pool(), id).await?;
6304    if !serving_hosts.is_empty() {
6305        let hosts = serving_hosts.join(", ");
6306        return redirect_named_with_message_args(
6307            "rcms-admin:pages:list",
6308            MsgLevel::Error,
6309            "Can't delete “{title}” — it is the root served by {hosts}. Change that on the Sites screen first.",
6310            &[("title", page.title.as_str()), ("hosts", hosts.as_str())],
6311            &headers,
6312        );
6313    }
6314
6315    // #75 — promote any aliases of this page to standalone pages
6316    // before deleting the source. Each alias inherits a snapshot of
6317    // the source's content (title / SEO / status / theme) so its
6318    // public URL keeps rendering coherent content after the source
6319    // is gone. Without this step the FK guard would refuse the
6320    // delete, or worse — aliases would point at a dead row.
6321    let aliases: Vec<Page> = Page::objects()
6322        .where_(Page::alias_of.eq(id))
6323        .fetch(tenant.pool())
6324        .await?;
6325    let alias_count = aliases.len();
6326    let title = page.title.clone();
6327    let url_path = page.url_path.clone();
6328
6329    // #317 — alias promotion + the delete run in one `atomic!` block,
6330    // so a failure can't leave aliases promoted against a still-present
6331    // source. The #78 cache purge is registered via `on_commit`, so it
6332    // fires only once the delete commits — a rollback never evicts a
6333    // still-valid public render. The purge runs detached, so the next
6334    // visitor sees a 404, not a stale 200, without blocking this
6335    // response on the cache round-trip.
6336    let invalidator = _state.cache_invalidator.clone();
6337    let tenant_slug = tenant.org.slug.clone();
6338    let purge_url = url_path.clone();
6339    rustango::atomic!(tenant.pool(), |tx| {
6340        let mut guard = tx.lock().await?;
6341        let tx = &mut *guard;
6342        for mut alias in aliases {
6343            alias.alias_of = None;
6344            alias.title = page.title.clone();
6345            alias.seo_title = page.seo_title.clone();
6346            alias.seo_description = page.seo_description.clone();
6347            alias.status = page.status.clone();
6348            alias.published_at = page.published_at;
6349            alias.last_published_at = page.last_published_at;
6350            alias.theme_id = page.theme_id;
6351            alias.show_in_menus = page.show_in_menus;
6352            alias.save_tx(tx).await?;
6353        }
6354        // Revisions, tags, logs… point at the page with no ON DELETE
6355        // action; clear them first or the delete fails.
6356        crate::page_delete::clear_page_references_tx(tx, id).await?;
6357        page.delete_tx(tx).await?;
6358        crate::cache_invalidate::invalidate_urls_on_commit(
6359            invalidator,
6360            tenant_slug,
6361            vec![purge_url],
6362        );
6363        Ok(())
6364    })
6365    .await?;
6366    // #408 — drop the deleted page from the external search index
6367    // (no-op when no backend is installed).
6368    crate::task_queue::remove_page_search(&tenant.org.slug, id).await;
6369    // #553 — redirect rules linked to this page must not keep serving.
6370    // Best-effort; the delete already committed.
6371    if let Err(e) = crate::redirect::disable_for_page(
6372        tenant.pool(),
6373        id,
6374        &format!("Linked page “{title}” was deleted"),
6375    )
6376    .await
6377    {
6378        tracing::warn!(page_id = id, error = %e, "failed to disable redirects for deleted page");
6379    }
6380    if alias_count > 0 {
6381        redirect_named_with_message_plural(
6382            "rcms-admin:pages:list",
6383            MsgLevel::Success,
6384            "Deleted “{title}”. Promoted {count} alias(es) to standalone page(s) with the source's last content.",
6385            alias_count as i64,
6386            &[("title", title.as_str()), ("count", &alias_count.to_string())],
6387            &headers,
6388        )
6389    } else {
6390        redirect_named_with_message_args(
6391            "rcms-admin:pages:list",
6392            MsgLevel::Success,
6393            "Deleted “{title}”.",
6394            &[("title", title.as_str())],
6395            &headers,
6396        )
6397    }
6398}
6399
6400// =====================================================================
6401// Slice 6 — drag-reorder + locale variants
6402// =====================================================================
6403
6404/// Form payload for `POST /cms-admin/pages/{id}/move` — emitted by
6405/// the tree view's drag-and-drop JS.
6406#[derive(Debug, Deserialize)]
6407pub struct MoveForm {
6408    /// The drop target's page id. The moved page becomes a child of
6409    /// this row (appended at the bottom of its existing children).
6410    /// Negative or zero values mean "move to root".
6411    pub new_parent: i64,
6412}
6413
6414/// POST /cms-admin/pages/{id}/move — change a page's parent +
6415/// sort_order via the existing `Page::move_to`. Wraps the cascade so
6416/// every descendant's `url_path` is re-materialized.
6417pub async fn page_move_submit(
6418    State(_state): State<super::AdminState>,
6419    tenant: Tenant,
6420    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6421    Path(id): Path<i64>,
6422    Form(form): Form<MoveForm>,
6423) -> Result<Response, AdminError> {
6424    let mut page = Page::objects()
6425        .where_(Page::id.eq(id))
6426        .first(tenant.pool())
6427        .await?
6428        .ok_or(AdminError::NotFound(id))?;
6429    let new_parent: Option<Page> = if form.new_parent > 0 {
6430        Page::objects()
6431            .where_(Page::id.eq(form.new_parent))
6432            .first(tenant.pool())
6433            .await?
6434    } else {
6435        None
6436    };
6437    let old_url_path = page.url_path.clone();
6438    let old_descendant_urls: Vec<String> =
6439        page.descendants(tenant.pool()).await?.into_iter().map(|d| d.url_path).collect();
6440    // One transaction moves the tree and its URLs together (#706).
6441    page.move_to(&tenant, new_parent.as_ref()).await?;
6442    let new_url_path = page.url_path.clone();
6443
6444    // #78 — purge the old and new URL of the page and every descendant,
6445    // now that the move has committed; detached so the response isn't
6446    // blocked on the cache round-trips.
6447    let mut urls = old_descendant_urls;
6448    urls.push(old_url_path.clone());
6449    urls.push(new_url_path.clone());
6450    urls.extend(page.descendants(tenant.pool()).await?.into_iter().map(|d| d.url_path));
6451    let invalidator = _state.cache_invalidator.clone();
6452    let tenant_slug = tenant.org.slug.clone();
6453    rustango::__private_runtime::tokio::spawn(async move {
6454        crate::task_queue::purge_urls(invalidator, tenant_slug, urls).await;
6455    });
6456
6457    // #192 — audit-log the move.
6458    let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6459    crate::page_log::record_or_warn(
6460        tenant.pool(),
6461        id,
6462        crate::page_log::ACTION_MOVE,
6463        actor_id,
6464        format!(
6465            "Moved “{}” from {old_url_path} to {new_url_path}.",
6466            page.title
6467        ),
6468        Some(serde_json::json!({
6469            "old_url_path": old_url_path,
6470            "new_url_path": new_url_path,
6471            "new_parent_id": form.new_parent,
6472        })),
6473    )
6474    .await;
6475
6476    Ok((axum::http::StatusCode::OK, "ok").into_response())
6477}
6478
6479/// POST /cms-admin/pages/{id}/clone — duplicate the source page as a
6480/// draft sibling. The copy carries everything the page stores —
6481/// core fields (SEO, OG/Twitter, theme, template override), tags, the
6482/// extension row, inline panels and the page-builder body — because it
6483/// is saved through the same pipeline as an edit, from the source's
6484/// [`crate::page_form::prefill`]. The new row:
6485///
6486/// - Lives under the same parent as the source.
6487/// - Title gets a " (copy)" suffix.
6488/// - Slug gets a "-copy" suffix; on conflict with an existing
6489///   sibling slug, we suffix `-copy-2`, `-copy-3`, … until unique.
6490/// - Status forces back to Draft, with no schedule, so editors review
6491///   before publishing.
6492/// - Locale-variant pointer cleared (variants stay independent of
6493///   any single source).
6494///
6495/// Subtree clone (source + all descendants) is not supported yet.
6496pub async fn page_clone_submit(
6497    State(state): State<super::AdminState>,
6498    tenant: Tenant,
6499    headers: HeaderMap,
6500    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6501    Path(id): Path<i64>,
6502) -> Result<Response, AdminError> {
6503    let source = Page::objects()
6504        .where_(Page::id.eq(id))
6505        .first(tenant.pool())
6506        .await?
6507        .ok_or(AdminError::NotFound(id))?;
6508
6509    let title = format!("{} (copy)", source.title);
6510    let base_slug = source.slug.trim_matches('-').to_owned();
6511    let slug = unique_sibling_slug(
6512        tenant.pool(),
6513        source.parent_id,
6514        &format!("{base_slug}-copy"),
6515    )
6516    .await?;
6517
6518    let new = crate::tree_ops::NewPage::new(source.page_type_id, title, slug)
6519        .with_status(crate::page::PageStatus::Draft)
6520        .with_seo(source.seo_title.clone(), source.seo_description.clone());
6521
6522    let clone = match source.parent_id {
6523        Some(pid) => {
6524            let parent = Page::objects()
6525                .where_(Page::id.eq(pid))
6526                .first(tenant.pool())
6527                .await?
6528                .ok_or(AdminError::NotFound(pid))?;
6529            Page::create_child(&tenant, &parent, new).await?
6530        }
6531        None => Page::create_root(&tenant, new).await?,
6532    };
6533    let new_id = clone.id.get().copied().unwrap_or_default();
6534
6535    // Copy the content by saving the source's full form onto the new
6536    // row: the edit pipeline writes the core fields, tags, extension,
6537    // inline panels and builder body, and captures the first revision
6538    // with all of it.
6539    let mut form = crate::page_form::prefill(tenant.pool(), &source).await;
6540    form.insert("title".into(), clone.title.clone());
6541    form.insert("slug".into(), clone.slug.clone());
6542    form.insert(
6543        "status".into(),
6544        crate::page::PageStatus::Draft.as_str().to_owned(),
6545    );
6546    form.remove("go_live_at");
6547    form.remove("expire_at");
6548    let actor = session_user.as_ref().map(|u| PageEditActor {
6549        id: u.id.get().copied().unwrap_or_default(),
6550        username: u.username.clone(),
6551        is_superuser: u.is_superuser,
6552    });
6553    let saved = apply_page_edit(
6554        tenant.pool(),
6555        &tenant.org.slug,
6556        &state.cache_invalidator,
6557        None,
6558        "",
6559        false,
6560        new_id,
6561        &form,
6562        actor.as_ref(),
6563    )
6564    .await?;
6565    if saved.is_err() {
6566        // A page created a moment ago has no workflow or editor lock.
6567        return Err(AdminError::Validation(
6568            "the copy was created but its content could not be saved".to_owned(),
6569        ));
6570    }
6571    // #192 — audit-log the clone on BOTH the new row (so the new
6572    // page's history shows where it came from) and the source (so
6573    // the source's history records its descendants).
6574    let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6575    crate::page_log::record_or_warn(
6576        tenant.pool(),
6577        new_id,
6578        crate::page_log::ACTION_COPY,
6579        actor_id,
6580        format!("Cloned from “{}” (page #{id}).", source.title),
6581        Some(serde_json::json!({ "source_page_id": id })),
6582    )
6583    .await;
6584    crate::page_log::record_or_warn(
6585        tenant.pool(),
6586        id,
6587        crate::page_log::ACTION_COPY,
6588        actor_id,
6589        format!("Cloned to new draft page #{new_id}."),
6590        Some(serde_json::json!({ "clone_page_id": new_id })),
6591    )
6592    .await;
6593    redirect_named_with_params_and_message_args(
6594        "rcms-admin:pages:edit",
6595        &[("id", new_id.to_string())],
6596        MsgLevel::Success,
6597        "Cloned “{title}” as a draft. Review before publishing.",
6598        &[("title", source.title.as_str())],
6599        &headers,
6600    )
6601}
6602
6603/// Form payload for `POST /cms-admin/pages/{id}/privacy`.
6604/// `kind` is one of `"none"`, `"login"`, `"groups"`, `"password"`.
6605/// `password` is the cleartext entered when `kind=password` (hashed
6606/// + discarded server-side). `group_ids` is the comma-separated list
6607/// for `kind=groups`.
6608#[derive(Deserialize)]
6609pub struct PrivacyForm {
6610    pub kind: String,
6611    #[serde(default)]
6612    pub password: String,
6613    #[serde(default)]
6614    pub group_ids: String,
6615    /// Comma-separated permission codenames — used when `kind =
6616    /// permission` (the permission-engine gate). Empty otherwise.
6617    #[serde(default)]
6618    pub codenames: String,
6619}
6620
6621pub async fn page_privacy_submit(
6622    State(_state): State<super::AdminState>,
6623    tenant: Tenant,
6624    headers: HeaderMap,
6625    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6626    Path(id): Path<i64>,
6627    Form(form): Form<PrivacyForm>,
6628) -> Result<Response, AdminError> {
6629    use rustango::sql::Auto;
6630    let existing = crate::view_restriction::direct_for_page(tenant.pool(), id).await?;
6631    if form.kind == "none" {
6632        if let Some(row) = existing {
6633            row.delete_pool(tenant.pool()).await?;
6634            return redirect_named_with_params_and_message(
6635                "rcms-admin:pages:edit",
6636                &[("id", id.to_string())],
6637                MsgLevel::Success,
6638                "Removed view restriction — page is now public.",
6639                &headers,
6640            );
6641        }
6642        return redirect_named_with_params_and_message(
6643            "rcms-admin:pages:edit",
6644            &[("id", id.to_string())],
6645            MsgLevel::Info,
6646            "No restriction to remove.",
6647            &headers,
6648        );
6649    }
6650    let Some(kind) = crate::view_restriction::RestrictionKind::parse(&form.kind) else {
6651        return Err(AdminError::Validation(format!(
6652            "unknown restriction kind `{}`",
6653            form.kind
6654        )));
6655    };
6656    let password_hash = match kind {
6657        crate::view_restriction::RestrictionKind::Password => {
6658            // Reuse the existing hash when the editor left the
6659            // field blank on a page that's already password-
6660            // protected — lets them flip groups/login back to
6661            // password without remembering the original.
6662            if form.password.is_empty() {
6663                if let Some(row) = &existing {
6664                    if row.kind == kind.as_str() {
6665                        row.password_hash.clone()
6666                    } else {
6667                        return redirect_named_with_params_and_message(
6668                            "rcms-admin:pages:edit",
6669                            &[("id", id.to_string())],
6670                            MsgLevel::Error,
6671                            "Password is required when switching the restriction kind to password.",
6672                            &headers,
6673                        );
6674                    }
6675                } else {
6676                    return redirect_named_with_params_and_message(
6677                        "rcms-admin:pages:edit",
6678                        &[("id", id.to_string())],
6679                        MsgLevel::Error,
6680                        "Password is required for password-protected pages.",
6681                        &headers,
6682                    );
6683                }
6684            } else {
6685                crate::passwords::hash(&form.password).await
6686                    .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?
6687            }
6688        }
6689        _ => String::new(),
6690    };
6691    let group_ids: Vec<i64> = if matches!(kind, crate::view_restriction::RestrictionKind::Groups) {
6692        form.group_ids
6693            .split(',')
6694            .filter_map(|s| s.trim().parse::<i64>().ok())
6695            .collect()
6696    } else {
6697        Vec::new()
6698    };
6699    let group_json = serde_json::json!(group_ids);
6700    let codenames: Vec<String> =
6701        if matches!(kind, crate::view_restriction::RestrictionKind::Permission) {
6702            form.codenames
6703                .split(',')
6704                .map(str::trim)
6705                .filter(|s| !s.is_empty())
6706                .map(str::to_owned)
6707                .collect()
6708        } else {
6709            Vec::new()
6710        };
6711    let codenames_json = serde_json::json!(codenames);
6712    match existing {
6713        Some(mut row) => {
6714            row.kind = kind.as_str().to_owned();
6715            row.password_hash = password_hash;
6716            row.group_ids = group_json;
6717            row.codenames = codenames_json;
6718            row.save_pool(tenant.pool()).await?;
6719        }
6720        None => {
6721            let mut row = crate::view_restriction::PageViewRestriction {
6722                id: Auto::Unset,
6723                page_id: id,
6724                kind: kind.as_str().to_owned(),
6725                password_hash,
6726                group_ids: group_json,
6727                codenames: codenames_json,
6728                created_at: Auto::Unset,
6729                updated_at: Auto::Unset,
6730            };
6731            row.insert_pool(tenant.pool()).await?;
6732        }
6733    }
6734    redirect_named_with_params_and_message_args(
6735        "rcms-admin:pages:edit",
6736        &[("id", id.to_string())],
6737        MsgLevel::Success,
6738        match kind {
6739            crate::view_restriction::RestrictionKind::Login => "Only signed-in people can see this page now.",
6740            crate::view_restriction::RestrictionKind::Groups => "Only the chosen roles can see this page now.",
6741            crate::view_restriction::RestrictionKind::Permission => "Only people with the chosen permissions can see this page now.",
6742            crate::view_restriction::RestrictionKind::Password => "This page asks for a password now.",
6743        },
6744        &[],
6745        &headers,
6746    )
6747}
6748
6749// =====================================================================
6750// Inline comments (#81 PR 1)
6751// =====================================================================
6752
6753#[derive(Debug, Deserialize)]
6754pub struct CommentNewForm {
6755    pub field_path: String,
6756    pub body: String,
6757}
6758
6759pub async fn comment_new_submit(
6760    State(_state): State<super::AdminState>,
6761    tenant: Tenant,
6762    headers: HeaderMap,
6763    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6764    Path(id): Path<i64>,
6765    Form(form): Form<CommentNewForm>,
6766) -> Result<Response, AdminError> {
6767    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6768        return Ok(unauthorized_no_session());
6769    };
6770    let body = form.body.trim();
6771    let field_path = form.field_path.trim();
6772    if body.is_empty() || field_path.is_empty() {
6773        return redirect_named_with_params_and_message(
6774            "rcms-admin:pages:edit",
6775            &[("id", id.to_string())],
6776            MsgLevel::Warning,
6777            "Comment body and field are both required.",
6778            &headers,
6779        );
6780    }
6781    let mut row = crate::comment::Comment {
6782        id: rustango::sql::Auto::Unset,
6783        page_id: id,
6784        field_path: field_path.to_owned(),
6785        author_id: viewer_id,
6786        body: body.to_owned(),
6787        resolved_at: None,
6788        resolved_by: None,
6789        created_at: rustango::sql::Auto::Unset,
6790    };
6791    row.insert_pool(tenant.pool()).await?;
6792    redirect_named_with_params_and_message(
6793        "rcms-admin:pages:edit",
6794        &[("id", id.to_string())],
6795        MsgLevel::Success,
6796        "Comment posted.",
6797        &headers,
6798    )
6799}
6800
6801#[derive(Debug, Deserialize)]
6802pub struct CommentReplyForm {
6803    pub body: String,
6804}
6805
6806pub async fn comment_reply_submit(
6807    State(_state): State<super::AdminState>,
6808    tenant: Tenant,
6809    headers: HeaderMap,
6810    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6811    Path((id, comment_id)): Path<(i64, i64)>,
6812    Form(form): Form<CommentReplyForm>,
6813) -> Result<Response, AdminError> {
6814    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6815        return Ok(unauthorized_no_session());
6816    };
6817    let body = form.body.trim();
6818    if body.is_empty() {
6819        return redirect_named_with_params_and_message(
6820            "rcms-admin:pages:edit",
6821            &[("id", id.to_string())],
6822            MsgLevel::Warning,
6823            "Reply body is required.",
6824            &headers,
6825        );
6826    }
6827    let mut row = crate::comment::CommentReply {
6828        id: rustango::sql::Auto::Unset,
6829        comment_id,
6830        author_id: viewer_id,
6831        body: body.to_owned(),
6832        created_at: rustango::sql::Auto::Unset,
6833    };
6834    row.insert_pool(tenant.pool()).await?;
6835    redirect_named_with_params_and_message(
6836        "rcms-admin:pages:edit",
6837        &[("id", id.to_string())],
6838        MsgLevel::Success,
6839        "Reply posted.",
6840        &headers,
6841    )
6842}
6843
6844pub async fn comment_resolve_submit(
6845    State(_state): State<super::AdminState>,
6846    tenant: Tenant,
6847    headers: HeaderMap,
6848    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6849    Path((id, comment_id)): Path<(i64, i64)>,
6850) -> Result<Response, AdminError> {
6851    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6852        return Ok(unauthorized_no_session());
6853    };
6854    let mut row = crate::comment::Comment::objects()
6855        .where_(crate::comment::Comment::id.eq(comment_id))
6856        .where_(crate::comment::Comment::page_id.eq(id))
6857        .first(tenant.pool())
6858        .await?
6859        .ok_or(AdminError::NotFound(comment_id))?;
6860    row.resolved_at = Some(chrono::Utc::now());
6861    row.resolved_by = Some(viewer_id);
6862    row.save_pool(tenant.pool()).await?;
6863    redirect_named_with_params_and_message(
6864        "rcms-admin:pages:edit",
6865        &[("id", id.to_string())],
6866        MsgLevel::Success,
6867        "Comment resolved.",
6868        &headers,
6869    )
6870}
6871
6872pub async fn comment_reopen_submit(
6873    State(_state): State<super::AdminState>,
6874    tenant: Tenant,
6875    headers: HeaderMap,
6876    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6877    Path((id, comment_id)): Path<(i64, i64)>,
6878) -> Result<Response, AdminError> {
6879    let mut row = crate::comment::Comment::objects()
6880        .where_(crate::comment::Comment::id.eq(comment_id))
6881        .where_(crate::comment::Comment::page_id.eq(id))
6882        .first(tenant.pool())
6883        .await?
6884        .ok_or(AdminError::NotFound(comment_id))?;
6885    row.resolved_at = None;
6886    row.resolved_by = None;
6887    row.save_pool(tenant.pool()).await?;
6888    redirect_named_with_params_and_message(
6889        "rcms-admin:pages:edit",
6890        &[("id", id.to_string())],
6891        MsgLevel::Info,
6892        "Comment reopened.",
6893        &headers,
6894    )
6895}
6896
6897/// POST /cms-admin/pages/{id}/alias — create a live alias of this
6898/// page as a sibling. The alias is a real tree row at a
6899/// distinct URL but its content fields proxy to the source. Edits
6900/// to the source propagate instantly; edits to the alias redirect
6901/// the editor to the source.
6902///
6903/// Differentiation from sibling actions:
6904///   * Clone (`/clone`)         — deep copy, divergent content
6905///   * Alias (this)             — one source, multiple URLs
6906///
6907/// Localization uses the `cms_translation` per-field override table
6908/// (see [`crate::translation`]); the legacy structural-variant flow
6909/// was removed.
6910pub async fn page_alias_submit(
6911    State(state): State<super::AdminState>,
6912    tenant: Tenant,
6913    headers: HeaderMap,
6914    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6915    Path(id): Path<i64>,
6916) -> Result<Response, AdminError> {
6917    let source = Page::objects()
6918        .where_(Page::id.eq(id))
6919        .first(tenant.pool())
6920        .await?
6921        .ok_or(AdminError::NotFound(id))?;
6922
6923    // Refuse to alias an alias — the chain would be impossible to
6924    // resolve without cycle detection, and there's no editorial use
6925    // case for it. Authors should alias the underlying source.
6926    if let Some(src_id) = source.alias_of {
6927        let src_id_str = src_id.to_string();
6928        return redirect_named_with_params_and_message_args(
6929            "rcms-admin:pages:edit",
6930            &[("id", id.to_string())],
6931            MsgLevel::Error,
6932            "Can't alias an alias — point your new alias at the underlying source page (#{source_id}) instead.",
6933            &[("source_id", src_id_str.as_str())],
6934            &headers,
6935        );
6936    }
6937
6938    let base_slug = source.slug.trim_matches('-').to_owned();
6939    let slug = unique_sibling_slug(
6940        tenant.pool(),
6941        source.parent_id,
6942        &if base_slug.is_empty() {
6943            "alias".to_owned()
6944        } else {
6945            format!("{base_slug}-alias")
6946        },
6947    )
6948    .await?;
6949
6950    // tree_ops::NewPage carries title/slug/page_type but the title
6951    // gets shadowed by the source on render. Use the source's title
6952    // verbatim so the admin lists still show something meaningful.
6953    let new = crate::tree_ops::NewPage::new(source.page_type_id, source.title.clone(), slug)
6954        .with_status(crate::page::PageStatus::Draft)
6955        .with_seo(source.seo_title.clone(), source.seo_description.clone());
6956
6957    let mut alias = match source.parent_id {
6958        Some(pid) => {
6959            let parent = Page::objects()
6960                .where_(Page::id.eq(pid))
6961                .first(tenant.pool())
6962                .await?
6963                .ok_or(AdminError::NotFound(pid))?;
6964            Page::create_child(&tenant, &parent, new).await?
6965        }
6966        None => Page::create_root(&tenant, new).await?,
6967    };
6968    alias.alias_of = Some(id);
6969    // Aliases inherit publish status from the source on render —
6970    // the underlying status column on the alias row is irrelevant
6971    // for live viewing, but setting it here keeps the admin list
6972    // visually accurate.
6973    alias.status = source.status.clone();
6974    alias.published_at = source.published_at;
6975    alias.last_published_at = source.last_published_at;
6976    alias.theme_id = source.theme_id;
6977    alias.show_in_menus = source.show_in_menus;
6978    alias.save_pool(tenant.pool()).await?;
6979
6980    crate::revision::capture(tenant.pool(), &alias, None)
6981        .await
6982        .log_warn("revision not captured; the history has a gap");
6983    let new_id = alias.id.get().copied().unwrap_or_default();
6984    let _ = state;
6985    // #192 — audit log on both source + alias.
6986    let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6987    crate::page_log::record_or_warn(
6988        tenant.pool(),
6989        new_id,
6990        crate::page_log::ACTION_ALIAS_CREATE,
6991        actor_id,
6992        format!("Alias of “{}” (page #{id}).", source.title),
6993        Some(serde_json::json!({ "alias_of": id })),
6994    )
6995    .await;
6996    crate::page_log::record_or_warn(
6997        tenant.pool(),
6998        id,
6999        crate::page_log::ACTION_ALIAS_CREATE,
7000        actor_id,
7001        format!("New alias #{new_id} pointing here."),
7002        Some(serde_json::json!({ "alias_page_id": new_id })),
7003    )
7004    .await;
7005    redirect_named_with_params_and_message_args(
7006        "rcms-admin:pages:list",
7007        // Land on the page list (alias's edit form proxies to the
7008        // source, so /edit just bounces; the list is the right
7009        // landing). Include the alias's parent if available so the
7010        // editor sees the new alias in context.
7011        &[],
7012        MsgLevel::Success,
7013        "Created alias of “{title}”. Edits to the source will propagate to every alias's URL.",
7014        &[("title", source.title.as_str())],
7015        &headers,
7016    )
7017}
7018
7019/// Canonical fields seeded into `cms_translation` by the
7020/// copy-to-locale bulk action: the page's `title`, `seo_title`, and
7021/// `seo_description`, skipping empties. The source text gives
7022/// translators a starting point.
7023fn copy_fields_for(p: &Page) -> Vec<(&'static str, String)> {
7024    copy_translatable_fields(&p.title, &p.seo_title, &p.seo_description)
7025}
7026
7027/// Pure core of [`copy_fields_for`] — selects the non-empty canonical
7028/// fields. Split out so the selection is unit-testable without a full
7029/// `Page`.
7030fn copy_translatable_fields(
7031    title: &str,
7032    seo_title: &str,
7033    seo_description: &str,
7034) -> Vec<(&'static str, String)> {
7035    [
7036        ("title", title),
7037        ("seo_title", seo_title),
7038        ("seo_description", seo_description),
7039    ]
7040    .into_iter()
7041    .filter(|(_, v)| !v.trim().is_empty())
7042    .map(|(k, v)| (k, v.to_owned()))
7043    .collect()
7044}
7045
7046/// POST /cms-admin/pages/bulk — multi-select dispatcher for the
7047/// page list. Body shape (urlencoded):
7048/// `action=<verb>&ids=<id>&ids=<id>[&new_parent=<id>]`.
7049///
7050/// Verbs:
7051///   - `publish`     → flips every selected page's `status` to
7052///                     Published (no-op for already-published rows).
7053///   - `unpublish`   → flips to Draft (no-op for already-draft rows).
7054///   - `delete`      → bulk delete. Rejects atomically if ANY selected
7055///                     page has children — matches the per-row guard.
7056///   - `move`        → reparent every selected page under `new_parent`
7057///                     (or to root when `new_parent=0`); cascades
7058///                     `url_path` to descendants. Filters out rows
7059///                     that would form a self-loop (you can't move a
7060///                     page under itself or one of its descendants).
7061///
7062/// All four are wrapped in a single transaction so a partial failure
7063/// rolls back the entire batch. The response is a redirect back to
7064/// the page list with a flash message summarizing how many rows were
7065/// touched + which were skipped (with reason).
7066pub async fn page_bulk_submit(
7067    State(_state): State<super::AdminState>,
7068    tenant: Tenant,
7069    headers: HeaderMap,
7070    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7071    Form(form): Form<Vec<(String, String)>>,
7072) -> Result<Response, AdminError> {
7073    let action = form
7074        .iter()
7075        .find(|(k, _)| k == "action")
7076        .map(|(_, v)| v.clone())
7077        .unwrap_or_default();
7078    let ids: Vec<i64> = form
7079        .iter()
7080        .filter(|(k, _)| k == "ids" || k == "id")
7081        .filter_map(|(_, v)| v.parse::<i64>().ok())
7082        .collect();
7083    let new_parent_raw = form
7084        .iter()
7085        .find(|(k, _)| k == "new_parent")
7086        .and_then(|(_, v)| v.parse::<i64>().ok());
7087    // #556 — archive cascade: mark every descendant's own row, not just
7088    // rely on inheritance. Accepts the checkbox/select truthy forms.
7089    let archive_cascade = form.iter().any(|(k, v)| {
7090        k == "archive_cascade" && matches!(v.as_str(), "1" | "on" | "subtree" | "true")
7091    });
7092
7093    if action.is_empty() || ids.is_empty() {
7094        return redirect_named_with_message(
7095            "rcms-admin:pages:list",
7096            MsgLevel::Warning,
7097            "Pick at least one row + an action before submitting.",
7098            &headers,
7099        );
7100    }
7101
7102    // Load the selected rows in one shot so per-id validation can run
7103    // before any mutation. The IN-list is small (page list pagination
7104    // caps the visible set; even an unbounded multi-select is dwarfed
7105    // by site-wide page counts).
7106    let pool = tenant.pool();
7107    let pages: Vec<Page> = {
7108        let mut out = Vec::with_capacity(ids.len());
7109        for id in &ids {
7110            if let Some(p) = Page::objects().where_(Page::id.eq(*id)).first(pool).await? {
7111                out.push(p);
7112            }
7113        }
7114        out
7115    };
7116    if pages.is_empty() {
7117        return redirect_named_with_message(
7118            "rcms-admin:pages:list",
7119            MsgLevel::Warning,
7120            "None of the selected ids matched a live page.",
7121            &headers,
7122        );
7123    }
7124
7125    // #672 — the route gate only knows this is a page edit; the action
7126    // posted decides what it really needs, on every selected page.
7127    let needs = match action.as_str() {
7128        "publish" | "unpublish" => crate::permissions::Action::Publish,
7129        "delete" => crate::permissions::Action::Delete,
7130        _ => crate::permissions::Action::Edit,
7131    };
7132    if let Some(user) = session_user.as_ref() {
7133        for p in &pages {
7134            let req = super::route_perms::Requirement {
7135                codename: format!("cms_page.{}", needs.as_str()),
7136                page: p.id.get().copied().map(|id| (id, needs)),
7137            };
7138            if !super::route_perms::allows(pool, user, &req).await {
7139                return redirect_named_with_message_args(
7140                    "rcms-admin:pages:list",
7141                    MsgLevel::Error,
7142                    "You don't have permission to {action} “{title}”.",
7143                    &[("action", action.as_str()), ("title", p.title.as_str())],
7144                    &headers,
7145                );
7146            }
7147        }
7148    }
7149
7150    match action.as_str() {
7151        "publish" | "unpublish" => {
7152            let target = if action == "publish" {
7153                crate::page::PageStatus::Published
7154            } else {
7155                crate::page::PageStatus::Draft
7156            };
7157            let invalidator = _state.cache_invalidator.clone();
7158            let tenant_slug = tenant.org.slug.clone();
7159            let purge_urls: Vec<String> = pages.iter().map(|p| p.url_path.clone()).collect();
7160            let pages_for_tx = pages.clone();
7161            // #317 — flip the batch's status in one atomic! block and
7162            // register the #78 per-URL purge via on_commit, so it fires
7163            // only once the batch commits (detached; dropped on rollback).
7164            let touched = rustango::atomic!(pool, |tx| {
7165                let mut guard = tx.lock().await?;
7166                let tx = &mut *guard;
7167                let mut touched = 0usize;
7168                for mut p in pages_for_tx {
7169                    // #556 — archived pages are frozen against unpublish;
7170                    // they must be explicitly unarchived. Skip them in a
7171                    // bulk unpublish (bulk publish still revives them).
7172                    if matches!(target, crate::page::PageStatus::Draft)
7173                        && p.status == crate::page::PageStatus::Archived.as_str()
7174                    {
7175                        continue;
7176                    }
7177                    if p.status != target.as_str() {
7178                        p.status = target.as_str().to_owned();
7179                        if matches!(target, crate::page::PageStatus::Published) {
7180                            let now = chrono::Utc::now();
7181                            if p.published_at.is_none() {
7182                                p.published_at = Some(now);
7183                            }
7184                            // #251 — bulk publish also bumps last-publish.
7185                            p.last_published_at = Some(now);
7186                        }
7187                        p.save_tx(tx).await?;
7188                        touched += 1;
7189                    }
7190                }
7191                crate::cache_invalidate::invalidate_urls_on_commit(
7192                    invalidator,
7193                    tenant_slug,
7194                    purge_urls,
7195                );
7196                Ok::<usize, rustango::sql::ExecError>(touched)
7197            })
7198            .await?;
7199            // Capture revisions outside the transaction; failure here
7200            // only affects history bookkeeping.
7201            for p in &pages {
7202                crate::revision::capture(pool, p, None)
7203                    .await
7204                    .log_warn("revision not captured; the history has a gap");
7205            }
7206            // #553 — bulk unpublish: rules linked to pages leaving
7207            // Published must not keep serving. `pages` holds the
7208            // pre-flip rows, so filter on the OLD status.
7209            if !matches!(target, crate::page::PageStatus::Published) {
7210                for p in &pages {
7211                    if p.status != crate::page::PageStatus::Published.as_str() {
7212                        continue;
7213                    }
7214                    let pid = p.id.get().copied().unwrap_or_default();
7215                    if let Err(e) = crate::redirect::disable_for_page(
7216                        pool,
7217                        pid,
7218                        &format!("Linked page “{}” was unpublished", p.title),
7219                    )
7220                    .await
7221                    {
7222                        tracing::warn!(page_id = pid, error = %e, "failed to disable redirects for unpublished page");
7223                    }
7224                }
7225            }
7226            // #107 — plugin after_publish_page on bulk publish only.
7227            if matches!(target, crate::page::PageStatus::Published) {
7228                for p in &pages {
7229                    crate::hooks::fire_after_publish_page(p);
7230                }
7231                // #115 — notify-on-publish subscribers (per page).
7232                let actor = session_user.as_ref().map(|u| u.username.as_str());
7233                for p in &pages {
7234                    crate::page_subscription::notify_publish(
7235                        _state.mailer.as_deref(),
7236                        &_state.mailer_from,
7237                        pool,
7238                        &tenant.org.slug,
7239                        p.id.get().copied().unwrap_or_default(),
7240                        &p.title,
7241                        &p.url_path,
7242                        actor,
7243                    )
7244                    .await;
7245                }
7246            }
7247            let already = (pages.len() - touched).to_string();
7248            let key = if action == "publish" {
7249                "Published {count} page(s) ({already} already in the target state)."
7250            } else {
7251                "Unpublished {count} page(s) ({already} already in the target state)."
7252            };
7253            redirect_named_with_message_plural(
7254                "rcms-admin:pages:list",
7255                MsgLevel::Success,
7256                key,
7257                touched as i64,
7258                &[("count", &touched.to_string()), ("already", already.as_str())],
7259                &headers,
7260            )
7261        }
7262        "delete" => {
7263            // #556 — archived pages are a preservation lock: they can't
7264            // be deleted until explicitly unarchived. Reject the whole
7265            // batch if any selected page is archived (mirrors the child
7266            // guard's all-or-nothing rule).
7267            let archived_names: Vec<String> = pages
7268                .iter()
7269                .filter(|p| p.status == crate::page::PageStatus::Archived.as_str())
7270                .map(|p| format!("“{}”", p.title))
7271                .collect();
7272            if !archived_names.is_empty() {
7273                let list = archived_names.join(", ");
7274                return redirect_named_with_message_args(
7275                    "rcms-admin:pages:list",
7276                    MsgLevel::Error,
7277                    "Can't delete archived page(s) {names} — unarchive them first.",
7278                    &[("names", list.as_str())],
7279                    &headers,
7280                );
7281            }
7282            // Atomic guard: if ANY selected page has children, the
7283            // whole batch fails. Matches the per-row delete rule and
7284            // the acceptance criterion on the issue.
7285            let id_set: std::collections::HashSet<i64> =
7286                pages.iter().filter_map(|p| p.id.get().copied()).collect();
7287            let mut offenders: Vec<String> = Vec::new();
7288            for p in &pages {
7289                let pid = p.id.get().copied().unwrap_or_default();
7290                let children: Vec<Page> = Page::objects()
7291                    .where_(Page::parent_id.eq(pid))
7292                    .fetch(pool)
7293                    .await?;
7294                // Children that are themselves part of this batch
7295                // don't count as blockers — they'll be deleted in
7296                // the same transaction.
7297                let external_children = children
7298                    .iter()
7299                    .filter(|c| !id_set.contains(&c.id.get().copied().unwrap_or_default()))
7300                    .count();
7301                if external_children > 0 {
7302                    offenders.push(format!("#{pid} “{}” ({external_children})", p.title));
7303                }
7304            }
7305            if !offenders.is_empty() {
7306                let offenders_list = offenders.join(", ");
7307                return redirect_named_with_message_args(
7308                    "rcms-admin:pages:list",
7309                    MsgLevel::Error,
7310                    "Bulk delete blocked — these page(s) still have external children: {offenders}.",
7311                    &[("offenders", offenders_list.as_str())],
7312                    &headers,
7313                );
7314            }
7315            // Delete deepest-first so child rows go before parents
7316            // and FK guards stay green. Every row that points at a page
7317            // (revisions, tags, logs, host extension rows…) is cleared
7318            // first: those FKs have no ON DELETE action.
7319            let mut ordered = pages.clone();
7320            ordered.sort_by(|a, b| b.depth.cmp(&a.depth));
7321            let invalidator = _state.cache_invalidator.clone();
7322            let tenant_slug = tenant.org.slug.clone();
7323            // #78 — purge every deleted URL so the next visitor sees a
7324            // 404, not a stale 200. #317 — registered via on_commit so
7325            // it fires only once the whole batch delete commits.
7326            let purge_urls: Vec<String> = pages.iter().map(|p| p.url_path.clone()).collect();
7327            rustango::atomic!(pool, |tx| {
7328                let mut guard = tx.lock().await?;
7329                let tx = &mut *guard;
7330                for p in &ordered {
7331                    let pid = p.id.get().copied().unwrap_or_default();
7332                    crate::page_delete::clear_page_references_tx(tx, pid).await?;
7333                }
7334                for p in ordered {
7335                    p.delete_tx(tx).await?;
7336                }
7337                crate::cache_invalidate::invalidate_urls_on_commit(
7338                    invalidator,
7339                    tenant_slug,
7340                    purge_urls,
7341                );
7342                Ok::<(), rustango::sql::ExecError>(())
7343            })
7344            .await?;
7345            // #553 — disable redirect rules linked to any deleted page.
7346            for p in &pages {
7347                let pid = p.id.get().copied().unwrap_or_default();
7348                if let Err(e) = crate::redirect::disable_for_page(
7349                    pool,
7350                    pid,
7351                    &format!("Linked page “{}” was deleted", p.title),
7352                )
7353                .await
7354                {
7355                    tracing::warn!(page_id = pid, error = %e, "failed to disable redirects for deleted page");
7356                }
7357            }
7358            redirect_named_with_message_plural(
7359                "rcms-admin:pages:list",
7360                MsgLevel::Success,
7361                "Deleted {count} page(s).",
7362                pages.len() as i64,
7363                &[("count", &pages.len().to_string())],
7364                &headers,
7365            )
7366        }
7367        "move" => {
7368            let Some(new_parent_id) = new_parent_raw else {
7369                return redirect_named_with_message(
7370                    "rcms-admin:pages:list",
7371                    MsgLevel::Warning,
7372                    "Bulk move requires a destination — pick a parent page.",
7373                    &headers,
7374                );
7375            };
7376            let new_parent: Option<Page> = if new_parent_id > 0 {
7377                Page::objects()
7378                    .where_(Page::id.eq(new_parent_id))
7379                    .first(pool).await?
7380            } else {
7381                None
7382            };
7383            // Self-loop guard: can't move a page under itself or any
7384            // of its descendants. Path-prefix check is cheap.
7385            if let Some(np) = &new_parent {
7386                for p in &pages {
7387                    if np.path.starts_with(&p.path) {
7388                        return redirect_named_with_message_args(
7389                            "rcms-admin:pages:list",
7390                            MsgLevel::Error,
7391                            "Can't move “{title}” under “{parent}” — destination is itself or a descendant.",
7392                            &[("title", p.title.as_str()), ("parent", np.title.as_str())],
7393                            &headers,
7394                        );
7395                    }
7396                }
7397            }
7398
7399            // Pre-validate page-type placement for every selected row
7400            // before mutating anything. If a single page rejects the
7401            // destination, the whole batch fails — matches the issue's
7402            // atomicity requirement so editors never end up with a
7403            // partial reparent.
7404            if let Some(np) = &new_parent {
7405                for p in &pages {
7406                    if let Err(e) =
7407                        crate::tree_ops::validate_child_placement(pool, np.page_type_id, p.page_type_id)
7408                            .await
7409                    {
7410                        let err = e.to_string();
7411                        return redirect_named_with_message_args(
7412                            "rcms-admin:pages:list",
7413                            MsgLevel::Error,
7414                            "Move blocked — “{title}” can't live under “{parent}”: {error}",
7415                            &[("title", p.title.as_str()), ("parent", np.title.as_str()), ("error", err.as_str())],
7416                            &headers,
7417                        );
7418                    }
7419                }
7420            }
7421
7422            // F2 / #317 — reparent the whole batch in ONE atomic_tree so a
7423            // mid-batch failure rolls back every move (no partial reparent;
7424            // placement was already pre-validated above). Each page's
7425            // subtree is pre-read on the pool *before* the transaction, so
7426            // nothing inside the tx reads the pool (which would deadlock a
7427            // single-connection SQLite pool); `move_to_in_tx` then reparents
7428            // each page within the shared tx. The #78 purge of every page's
7429            // old + new URL + descendant URLs (captured pre-cascade) is
7430            // registered via on_commit, firing only once the batch commits.
7431            let mut to_move: Vec<(Page, Vec<Page>)> = Vec::with_capacity(pages.len());
7432            for p in pages.iter().cloned() {
7433                let subtree = p.descendants(pool).await?;
7434                to_move.push((p, subtree));
7435            }
7436            let moved = to_move.len();
7437            let invalidator = _state.cache_invalidator.clone();
7438            let tenant_slug = tenant.org.slug.clone();
7439            let np_for_tx = new_parent.clone();
7440            crate::tree_ops::atomic_tree(pool, move |tx| {
7441                Box::pin(async move {
7442                    let mut purge: Vec<String> = Vec::new();
7443                    for (mut p, subtree) in to_move {
7444                        let old_url = p.url_path.clone();
7445                        let descendant_old_urls: Vec<String> =
7446                            subtree.iter().map(|d| d.url_path.clone()).collect();
7447                        // Moves the URLs with the tree (#706).
7448                        p.move_to_in_tx(np_for_tx.as_ref(), subtree, tx).await?;
7449                        purge.push(old_url);
7450                        purge.push(p.url_path.clone());
7451                        purge.extend(descendant_old_urls);
7452                    }
7453                    crate::cache_invalidate::invalidate_urls_on_commit(
7454                        invalidator,
7455                        tenant_slug,
7456                        purge,
7457                    );
7458                    Ok(())
7459                })
7460            })
7461            .await?;
7462            redirect_named_with_message_plural(
7463                "rcms-admin:pages:list",
7464                MsgLevel::Success,
7465                "Moved {count} page(s) under “{parent}”.",
7466                moved as i64,
7467                &[
7468                    ("count", &moved.to_string()),
7469                    (
7470                        "parent",
7471                        &new_parent.map(|p| p.title).unwrap_or_else(|| "Root".to_owned()),
7472                    ),
7473                ],
7474                &headers,
7475            )
7476        }
7477        "copy-to-locale" => {
7478            // #438 — simple-translation bulk: seed `cms_translation`
7479            // rows for each selected page from its canonical text, so
7480            // translators start from the source rather than a blank
7481            // form. Existing translations are left untouched.
7482            let code = form
7483                .iter()
7484                .find(|(k, _)| k == "locale")
7485                .map(|(_, v)| v.as_str())
7486                .unwrap_or("");
7487            let locale = Locale::objects()
7488                .where_(Locale::code.eq(code.to_owned()))
7489                .where_(Locale::active.eq(true))
7490                .first(pool)
7491                .await?;
7492            let Some(locale) = locale.filter(|l| !l.is_default) else {
7493                return redirect_named_with_message(
7494                    "rcms-admin:pages:list",
7495                    MsgLevel::Warning,
7496                    "Copy to locale needs a target locale (and not the default — canonical content already lives there).",
7497                    &headers,
7498                );
7499            };
7500            let locale_id = locale.id.get().copied().unwrap_or_default();
7501            let pages_for_tx = pages.clone();
7502            let (seeded_pages, seeded_fields) = rustango::atomic!(pool, |tx| {
7503                let mut guard = tx.lock().await?;
7504                let tx = &mut *guard;
7505                let mut sp = 0usize;
7506                let mut sf = 0usize;
7507                for p in &pages_for_tx {
7508                    let Some(pid) = p.id.get().copied() else {
7509                        continue;
7510                    };
7511                    // Field paths already translated for this locale —
7512                    // never overwrite a translator's work.
7513                    let existing: Vec<crate::translation::Translation> =
7514                        crate::translation::Translation::objects()
7515                            .where_(crate::translation::Translation::page_id.eq(pid))
7516                            .where_(crate::translation::Translation::locale_id.eq(locale_id))
7517                            .fetch_tx(tx)
7518                            .await?;
7519                    let have: std::collections::HashSet<String> =
7520                        existing.into_iter().map(|t| t.field_path).collect();
7521                    let mut touched = false;
7522                    for (path, value) in copy_fields_for(p) {
7523                        if have.contains(path) {
7524                            continue;
7525                        }
7526                        let mut row = crate::translation::Translation {
7527                            id: rustango::sql::Auto::Unset,
7528                            page_id: pid,
7529                            locale_id,
7530                            field_path: path.to_owned(),
7531                            value,
7532                            updated_at: rustango::sql::Auto::Unset,
7533                        };
7534                        row.save_tx(tx).await?;
7535                        sf += 1;
7536                        touched = true;
7537                    }
7538                    if touched {
7539                        sp += 1;
7540                    }
7541                }
7542                Ok::<_, rustango::sql::ExecError>((sp, sf))
7543            })
7544            .await?;
7545            // Two independent counts → compose localized noun-phrases into a
7546            // localized sentence template (#528/#1102).
7547            let fields = super::i18n::tr_plural(
7548                &headers,
7549                "{count} field(s)",
7550                seeded_fields as i64,
7551                &[("count", &seeded_fields.to_string())],
7552            );
7553            let pages_ph = super::i18n::tr_plural(
7554                &headers,
7555                "{count} page(s)",
7556                seeded_pages as i64,
7557                &[("count", &seeded_pages.to_string())],
7558            );
7559            redirect_named_with_message_args(
7560                "rcms-admin:pages:list",
7561                MsgLevel::Success,
7562                "Seeded {fields} across {pages} into “{locale}”. Existing translations were left untouched.",
7563                &[
7564                    ("fields", fields.as_str()),
7565                    ("pages", pages_ph.as_str()),
7566                    ("locale", locale.name.as_str()),
7567                ],
7568                &headers,
7569            )
7570        }
7571        "archive" | "unarchive" => {
7572            // #556 — archive: preserve superseded content (serve 200,
7573            // stay searchable, frozen against delete/unpublish).
7574            // Unarchive: revive to published. Descendants inherit the
7575            // treatment at render time, so the whole public subtree is
7576            // purged; with `archive_cascade` their own rows flip too.
7577            let archive = action == "archive";
7578            let plan =
7579                crate::page::plan_archive(pool, &pages, archive, archive_cascade).await?;
7580            let invalidator = _state.cache_invalidator.clone();
7581            let tenant_slug = tenant.org.slug.clone();
7582            let purge = plan.changed_urls.clone();
7583            let flips = plan.to_flip.clone();
7584            let touched = rustango::atomic!(pool, |tx| {
7585                let mut guard = tx.lock().await?;
7586                let tx = &mut *guard;
7587                let mut n = 0usize;
7588                for mut p in flips {
7589                    p.save_tx(tx).await?;
7590                    n += 1;
7591                }
7592                crate::cache_invalidate::invalidate_urls_on_commit(
7593                    invalidator,
7594                    tenant_slug,
7595                    purge,
7596                );
7597                Ok::<usize, rustango::sql::ExecError>(n)
7598            })
7599            .await?;
7600            // Bookkeeping outside the tx (best-effort): a revision per
7601            // flipped row + search-index sync (archived stays indexed;
7602            // the FTS path is query-time so this is a no-op there).
7603            for p in &plan.to_flip {
7604                crate::revision::capture(pool, p, None)
7605                    .await
7606                    .log_warn("revision not captured; the history has a gap");
7607                crate::task_queue::sync_page_search(&tenant.org.slug, p).await;
7608            }
7609            let key = if archive {
7610                "Archived {count} page(s)."
7611            } else {
7612                "Unarchived {count} page(s)."
7613            };
7614            redirect_named_with_message_plural(
7615                "rcms-admin:pages:list",
7616                MsgLevel::Success,
7617                key,
7618                touched as i64,
7619                &[("count", &touched.to_string())],
7620                &headers,
7621            )
7622        }
7623        other => Err(AdminError::Validation(format!(
7624            "unknown bulk action `{other}` (expected publish / unpublish / archive / unarchive / delete / move / copy-to-locale)"
7625        ))),
7626    }
7627}
7628
7629/// POST /cms-admin/pages/{id}/unlock — force-release the editor lock.
7630/// Anyone with Edit permission on this page can call it. The
7631/// row is deleted and an audit-log entry is written so the action is
7632/// reversible to inspect.
7633/// POST /cms-admin/pages/{id}/lock-release — the editor was left: give
7634/// up our own lock right away, not 30 minutes later, so a colleague who
7635/// opens the page next can save. Only ever releases the caller's lock.
7636pub async fn page_lock_release(
7637    tenant: Tenant,
7638    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7639    Path(id): Path<i64>,
7640) -> Result<Response, AdminError> {
7641    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7642        return Ok(unauthorized_no_session());
7643    };
7644    crate::lock::release(tenant.pool(), id, viewer_id).await?;
7645    Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
7646}
7647
7648pub async fn page_unlock_submit(
7649    State(_state): State<super::AdminState>,
7650    tenant: Tenant,
7651    headers: HeaderMap,
7652    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7653    Path(id): Path<i64>,
7654) -> Result<Response, AdminError> {
7655    let released = crate::lock::force_release(tenant.pool(), id).await?;
7656    let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
7657    let message = if let Some(row) = released {
7658        let holder = rustango::tenancy::auth::User::objects()
7659            .where_(rustango::tenancy::auth::User::id.eq(row.user_id))
7660            .fetch(tenant.pool())
7661            .await
7662            .ok()
7663            .and_then(|v| v.into_iter().next())
7664            .map(|u| u.username)
7665            .unwrap_or_else(|| format!("user#{}", row.user_id));
7666        // #192 — audit log the forced unlock.
7667        crate::page_log::record_or_warn(
7668            tenant.pool(),
7669            id,
7670            crate::page_log::ACTION_FORCE_UNLOCK,
7671            actor_id,
7672            format!("Force-unlocked — “{holder}” no longer holds the editor lock."),
7673            Some(serde_json::json!({ "previous_holder_user_id": row.user_id })),
7674        )
7675        .await;
7676        format!("Lock released — “{holder}” no longer holds the editor lock on this page.")
7677    } else {
7678        "Lock was already released.".to_owned()
7679    };
7680    redirect_named_with_params_and_message(
7681        "rcms-admin:pages:edit",
7682        &[("id", id.to_string())],
7683        MsgLevel::Success,
7684        &message,
7685        &headers,
7686    )
7687}
7688
7689/// POST /cms-admin/pages/{id}/subscribe — opt the current user in
7690/// to publish notifications for this page.
7691/// Idempotent — re-subscribing returns success without inserting a
7692/// duplicate row.
7693pub async fn page_subscribe_submit(
7694    State(_state): State<super::AdminState>,
7695    tenant: Tenant,
7696    headers: HeaderMap,
7697    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7698    Path(id): Path<i64>,
7699) -> Result<Response, AdminError> {
7700    let Some(viewer) = session_user.as_ref() else {
7701        return Ok(unauthorized_no_session());
7702    };
7703    let viewer_id = viewer.id.get().copied().unwrap_or_default();
7704    crate::page_subscription::subscribe(tenant.pool(), id, viewer_id).await?;
7705    redirect_named_with_params_and_message(
7706        "rcms-admin:pages:edit",
7707        &[("id", id.to_string())],
7708        MsgLevel::Success,
7709        "Subscribed — you'll get an email when this page publishes.",
7710        &headers,
7711    )
7712}
7713
7714/// POST /cms-admin/pages/{id}/unsubscribe — opt the current user out
7715/// of publish notifications. No-op when not subscribed.
7716pub async fn page_unsubscribe_submit(
7717    State(_state): State<super::AdminState>,
7718    tenant: Tenant,
7719    headers: HeaderMap,
7720    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7721    Path(id): Path<i64>,
7722) -> Result<Response, AdminError> {
7723    let Some(viewer) = session_user.as_ref() else {
7724        return Ok(unauthorized_no_session());
7725    };
7726    let viewer_id = viewer.id.get().copied().unwrap_or_default();
7727    crate::page_subscription::unsubscribe(tenant.pool(), id, viewer_id).await?;
7728    redirect_named_with_params_and_message(
7729        "rcms-admin:pages:edit",
7730        &[("id", id.to_string())],
7731        MsgLevel::Success,
7732        "Unsubscribed — you won't get future publish notifications for this page.",
7733        &headers,
7734    )
7735}
7736
7737/// True while the page is mid-review and `user` may not decide the
7738/// current step: the editor is read-only for them, so they must not
7739/// take (or keep) the edit lock — a submitter who reopens the page
7740/// would otherwise lock the reviewer out.
7741async fn read_only_under_review(
7742    pool: &rustango::sql::Pool,
7743    page_id: i64,
7744    user: &rustango::tenancy::auth::User,
7745) -> Result<bool, AdminError> {
7746    if user.is_superuser {
7747        return Ok(false);
7748    }
7749    let Some(state) = crate::workflow::active_state_for_page(pool, page_id).await? else {
7750        return Ok(false);
7751    };
7752    if state.status != crate::workflow::WorkflowStatus::InProgress.as_str() {
7753        return Ok(false);
7754    }
7755    let tasks = crate::workflow::tasks_for(pool, state.workflow_id).await?;
7756    let Some(task) = state
7757        .current_task_id
7758        .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
7759    else {
7760        return Ok(false);
7761    };
7762    let uid = user.id.get().copied().unwrap_or_default();
7763    Ok(!user_is_in_role(pool, uid, task.role_id).await?)
7764}
7765
7766/// POST /cms-admin/pages/{id}/lock-heartbeat — refresh the TTL on
7767/// the caller's lock. Called every
7768/// `lock::HEARTBEAT_INTERVAL_SECS` from the page-editor JS while the
7769/// tab stays open. Returns:
7770///   * 204 — heartbeat accepted (lock refreshed, or first claim).
7771///   * 409 — someone else owns the lock; the editor JS should
7772///           reload to surface the banner.
7773/// Heartbeat query: editors send `?is_editing=1` once they've
7774/// touched the form so the presence banner can show "editing" vs
7775/// "viewing" for other viewers.
7776#[derive(Debug, Deserialize)]
7777pub struct HeartbeatQuery {
7778    #[serde(default)]
7779    pub is_editing: Option<String>,
7780}
7781
7782pub async fn page_lock_heartbeat(
7783    State(_state): State<super::AdminState>,
7784    tenant: Tenant,
7785    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7786    Path(id): Path<i64>,
7787    Query(q): Query<HeartbeatQuery>,
7788) -> Result<Response, AdminError> {
7789    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7790        return Ok(unauthorized_no_session());
7791    };
7792
7793    // #106 — touch the editing-session row on every ping. Stale
7794    // rows GC lazily here so we don't need a cron.
7795    let is_editing = q.is_editing.as_deref() == Some("1");
7796    if let Err(e) = crate::editing_session::touch(tenant.pool(), id, viewer_id, is_editing).await {
7797        tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "editing-session touch failed (continuing)");
7798    }
7799    // GC every ~50 heartbeats to keep the table bounded without
7800    // doing the SELECT on every call. Probabilistic — fine for v1.
7801    if rand::random::<u8>() < 5 {
7802        crate::editing_session::gc_stale(tenant.pool())
7803            .await
7804            .log_warn("stale editing sessions not collected");
7805    }
7806
7807    // Read-only during someone else's review step: no lock to keep.
7808    if let Some(u) = session_user.as_ref() {
7809        if read_only_under_review(tenant.pool(), id, u).await? {
7810            return Ok((axum::http::StatusCode::NO_CONTENT, "").into_response());
7811        }
7812    }
7813    match crate::lock::acquire(tenant.pool(), id, viewer_id, false).await {
7814        Ok(crate::lock::AcquireOutcome::Acquired(_)) => {
7815            Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
7816        }
7817        Ok(crate::lock::AcquireOutcome::Held(_)) => Ok((
7818            axum::http::StatusCode::CONFLICT,
7819            "lock held by another editor",
7820        )
7821            .into_response()),
7822        Err(e) => {
7823            tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "lock heartbeat failed");
7824            Err(e.into())
7825        }
7826    }
7827}
7828
7829/// GET /cms-admin/pages/{id}/sessions — JSON list of OTHER active
7830/// editors / viewers on this page. Returns
7831/// `[{user_id, username, last_seen_at, is_editing}, ...]`.
7832pub async fn page_sessions_json(
7833    State(_state): State<super::AdminState>,
7834    tenant: Tenant,
7835    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7836    Path(id): Path<i64>,
7837) -> Result<Response, AdminError> {
7838    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7839        return Ok(unauthorized_no_session());
7840    };
7841    let others = crate::editing_session::others_on_page(tenant.pool(), id, viewer_id)
7842        .await
7843        .unwrap_or_default();
7844    if others.is_empty() {
7845        return Ok(([(header::CONTENT_TYPE, "application/json")], "[]").into_response());
7846    }
7847    // Resolve usernames in one batched lookup.
7848    let user_ids: Vec<i64> = others.iter().map(|s| s.user_id).collect();
7849    let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
7850        .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
7851        .fetch(tenant.pool())
7852        .await
7853        .unwrap_or_default();
7854    let username_by_id: std::collections::HashMap<i64, String> = users
7855        .into_iter()
7856        .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
7857        .collect();
7858    let payload: Vec<serde_json::Value> = others
7859        .iter()
7860        .map(|s| {
7861            serde_json::json!({
7862                "user_id": s.user_id,
7863                "username": username_by_id.get(&s.user_id).cloned(),
7864                "last_seen_at": s.last_seen_at,
7865                "is_editing": s.is_editing,
7866            })
7867        })
7868        .collect();
7869    let body = serde_json::to_string(&payload).unwrap_or_else(|_| "[]".to_owned());
7870    Ok(([(header::CONTENT_TYPE, "application/json")], body).into_response())
7871}
7872
7873/// Pick a slug not already used by any sibling under `parent_id`.
7874/// Tries `desired`, then `desired-2`, `desired-3`, … up to 100
7875/// attempts. Returns the first available one.
7876async fn unique_sibling_slug(
7877    pool: &rustango::sql::Pool,
7878    parent_id: Option<i64>,
7879    desired: &str,
7880) -> Result<String, AdminError> {
7881    use rustango::core::Column as _;
7882    let qs = Page::objects().order_by(&[("slug", false)]);
7883    let siblings: Vec<Page> = match parent_id {
7884        Some(pid) => qs.where_(Page::parent_id.eq(pid)).fetch(pool).await?,
7885        None => qs.where_(Page::parent_id.is_null()).fetch(pool).await?,
7886    };
7887    let taken: std::collections::HashSet<String> = siblings.into_iter().map(|p| p.slug).collect();
7888    if !taken.contains(desired) {
7889        return Ok(desired.to_owned());
7890    }
7891    for n in 2..=100 {
7892        let candidate = format!("{desired}-{n}");
7893        if !taken.contains(&candidate) {
7894            return Ok(candidate);
7895        }
7896    }
7897    Err(AdminError::Validation(
7898        "Could not allocate a unique slug for the clone — over 100 siblings share the same base."
7899            .to_owned(),
7900    ))
7901}
7902
7903/// POST /cms-admin/pages/{id}/revert/{rev_id} — replace the page's
7904/// mutable fields with those from the given revision, then capture a
7905/// NEW revision recording the revert. URL-shaped fields (slug, path,
7906/// depth, parent_id, sort_order) are NOT reverted — moving the page
7907/// is a tree-ops concern, not a content concern.
7908///
7909/// Returns to the edit form afterward so the editor can verify the
7910/// state and continue editing.
7911pub async fn page_revert_submit(
7912    State(_state): State<super::AdminState>,
7913    tenant: Tenant,
7914    headers: HeaderMap,
7915    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7916    Path((id, rev_id)): Path<(i64, i64)>,
7917) -> Result<Response, AdminError> {
7918    let mut page = Page::objects()
7919        .where_(Page::id.eq(id))
7920        .first(tenant.pool())
7921        .await?
7922        .ok_or(AdminError::NotFound(id))?;
7923    let rev = crate::revision::Revision::objects()
7924        .where_(crate::revision::Revision::id.eq(rev_id))
7925        .where_(crate::revision::Revision::page_id.eq(id))
7926        .first(tenant.pool())
7927        .await?
7928        .ok_or(AdminError::NotFound(rev_id))?;
7929
7930    // Decode the snapshot into a Page shell. Tree-shape fields
7931    // (parent_id, path, depth, sort_order, slug, url_path) are
7932    // preserved from the LIVE row — a revert restores content +
7933    // status, not tree placement.
7934    let snapshot: Page = match serde_json::from_value(rev.snapshot.clone()) {
7935        Ok(p) => p,
7936        Err(e) => {
7937            return Ok((
7938                axum::http::StatusCode::BAD_REQUEST,
7939                format!("revision snapshot could not be decoded: {e}"),
7940            )
7941                .into_response());
7942        }
7943    };
7944
7945    let old_url_path = page.url_path.clone();
7946    page.title = snapshot.title;
7947    page.page_type_id = snapshot.page_type_id;
7948    page.status = snapshot.status;
7949    page.published_at = snapshot.published_at;
7950    page.go_live_at = snapshot.go_live_at;
7951    page.expire_at = snapshot.expire_at;
7952    page.seo_title = snapshot.seo_title;
7953    page.seo_description = snapshot.seo_description;
7954    page.robots_index = snapshot.robots_index;
7955    page.sitemap_priority = snapshot.sitemap_priority;
7956
7957    let mut tx = transaction_pool(tenant.pool()).await?;
7958    page.save_tx(&mut tx).await?;
7959    tx.commit().await?;
7960    crate::revision::capture(tenant.pool(), &page, None)
7961        .await
7962        .log_warn("revision not captured; the history has a gap");
7963
7964    let _ = old_url_path; // TTL-based cache propagation per rustango::cache_page
7965                          // #192 — audit log the restore.
7966    let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
7967    crate::page_log::record_or_warn(
7968        tenant.pool(),
7969        id,
7970        crate::page_log::ACTION_RESTORE,
7971        actor_id,
7972        format!("Reverted to revision #{}.", rev.sequence),
7973        Some(serde_json::json!({ "revision_id": rev_id, "sequence": rev.sequence })),
7974    )
7975    .await;
7976    let sequence_str = rev.sequence.to_string();
7977    redirect_named_with_params_and_message_args(
7978        "rcms-admin:pages:edit",
7979        &[("id", id.to_string())],
7980        MsgLevel::Success,
7981        "Reverted to revision #{sequence}.",
7982        &[("sequence", sequence_str.as_str())],
7983        &headers,
7984    )
7985}
7986
7987// =====================================================================
7988// Live preview
7989// =====================================================================
7990
7991/// Stamp the response with anti-cache headers so the editor's preview
7992/// iframe always renders the latest content. Browsers cache HTML
7993/// aggressively by default; the editor's "Refresh" button and the
7994/// initial load both need to hit fresh markup.
7995fn stamp_no_cache(mut response: Response) -> Response {
7996    let h = response.headers_mut();
7997    h.insert(
7998        header::CACHE_CONTROL,
7999        HeaderValue::from_static("no-store, no-cache, must-revalidate, max-age=0"),
8000    );
8001    h.insert(header::PRAGMA, HeaderValue::from_static("no-cache"));
8002    h.insert(header::EXPIRES, HeaderValue::from_static("0"));
8003    // Tell upstream caches the response varies per-request even
8004    // for the same URL (preview pulls live data on every load).
8005    h.insert(header::VARY, HeaderValue::from_static("*"));
8006    // Block embedding outside our own admin so other origins can't
8007    // frame the preview for clickjacking.
8008    h.insert(
8009        header::X_FRAME_OPTIONS,
8010        HeaderValue::from_static("SAMEORIGIN"),
8011    );
8012    response
8013}
8014
8015/// Inject the axe-core preview-glue script into the
8016/// rendered preview HTML so the editor can surface client-side
8017/// accessibility findings alongside the server-side heuristics.
8018/// Reads the response body, locates the closing `</body>`
8019/// tag (case-insensitive), and splices two `<script src="…">`
8020/// tags before it: axe-core itself, then the small glue script
8021/// that calls `axe.run()` + `postMessage`s the results back to
8022/// the editor's parent window.
8023///
8024/// Non-HTML responses pass through unchanged; pages without a
8025/// `</body>` tag (malformed templates, plain-text responses) also
8026/// pass through so the injection is best-effort + non-breaking.
8027async fn inject_axe_into_preview(response: Response) -> Response {
8028    // Only touch text/html responses.
8029    let is_html = response
8030        .headers()
8031        .get(header::CONTENT_TYPE)
8032        .and_then(|v| v.to_str().ok())
8033        .is_some_and(|ct| ct.to_ascii_lowercase().contains("text/html"));
8034    if !is_html {
8035        return response;
8036    }
8037    let (parts, body) = response.into_parts();
8038    // 4 MiB cap matches the rendition route's preview-safe upper
8039    // bound; admin preview HTML should never approach this.
8040    let bytes = match axum::body::to_bytes(body, 4 * 1024 * 1024).await {
8041        Ok(b) => b,
8042        Err(_) => {
8043            // Body read failed — return a minimal 500 since we
8044            // already consumed the original.
8045            return (
8046                axum::http::StatusCode::INTERNAL_SERVER_ERROR,
8047                "preview body read failed",
8048            )
8049                .into_response();
8050        }
8051    };
8052    let body_str = match std::str::from_utf8(&bytes) {
8053        Ok(s) => s,
8054        Err(_) => {
8055            // Non-UTF-8 HTML — rebuild without injection.
8056            return axum::http::Response::from_parts(parts, axum::body::Body::from(bytes));
8057        }
8058    };
8059    let new_body = inject_axe_into_body_str(body_str);
8060    // Rebuild the response with the patched body + a refreshed
8061    // Content-Length so axum doesn't emit the stale value.
8062    let mut resp = axum::http::Response::from_parts(parts, axum::body::Body::from(new_body));
8063    resp.headers_mut().remove(header::CONTENT_LENGTH);
8064    resp
8065}
8066
8067/// Pure string helper for [`inject_axe_into_preview`] — splice the
8068/// axe-core + glue `<script>` tags before the closing `</body>`
8069/// (case-insensitive `rfind`). Pages with no closing body tag get
8070/// the scripts appended at the end (browsers tolerate trailing
8071/// `<script>` after `</html>`). Extracted so the injection logic
8072/// is unit-testable without spinning up an axum Response stack.
8073fn inject_axe_into_body_str(body: &str) -> String {
8074    // Fingerprinted like every other admin asset (`?v=`): these are served
8075    // `immutable`, so an unversioned URL would let a year-old cached copy
8076    // mask an update.
8077    let v = super::cms_asset_version();
8078    let scripts = format!(
8079        "<script src=\"/cms-admin/static/vendor/axe-core.min.js?v={v}\" defer></script>\n\
8080         <script src=\"/cms-admin/static/cms-preview-guard.js?v={v}\" defer></script>\n\
8081         <script src=\"/cms-admin/static/cms-axe-preview.js?v={v}\" defer></script>\n"
8082    );
8083    let lower = body.to_ascii_lowercase();
8084    if let Some(idx) = lower.rfind("</body>") {
8085        let mut out = String::with_capacity(body.len() + scripts.len());
8086        out.push_str(&body[..idx]);
8087        out.push_str(&scripts);
8088        out.push_str(&body[idx..]);
8089        out
8090    } else {
8091        let mut out = String::with_capacity(body.len() + scripts.len());
8092        out.push_str(body);
8093        out.push_str(&scripts);
8094        out
8095    }
8096}
8097
8098#[cfg(test)]
8099mod axe_injection_tests {
8100    use super::inject_axe_into_body_str;
8101
8102    #[test]
8103    fn splices_before_lowercase_body_close() {
8104        let html = "<html><body><h1>hi</h1></body></html>";
8105        let out = inject_axe_into_body_str(html);
8106        assert!(out.contains("axe-core.min.js"), "axe script missing: {out}");
8107        assert!(
8108            out.contains("cms-axe-preview.js"),
8109            "glue script missing: {out}"
8110        );
8111        assert!(
8112            out.contains("cms-preview-guard.js"),
8113            "preview-guard script missing: {out}"
8114        );
8115        // Both scripts land BEFORE the body close.
8116        let close = out.find("</body>").expect("body close kept");
8117        assert!(
8118            out[..close].contains("axe-core.min.js"),
8119            "axe script should be before </body>: {out}"
8120        );
8121        assert!(
8122            out[..close].contains("cms-axe-preview.js"),
8123            "glue script should be before </body>: {out}"
8124        );
8125    }
8126
8127    #[test]
8128    fn splices_before_uppercase_body_close() {
8129        let html = "<HTML><BODY><h1>hi</h1></BODY></HTML>";
8130        let out = inject_axe_into_body_str(html);
8131        // The original close tag stays uppercase; injection is still
8132        // positioned in front of it.
8133        let close = out.find("</BODY>").expect("uppercase body close kept");
8134        assert!(out[..close].contains("axe-core.min.js"));
8135    }
8136
8137    #[test]
8138    fn appends_when_no_body_close() {
8139        let html = "<html><h1>hi</h1>";
8140        let out = inject_axe_into_body_str(html);
8141        // URLs carry a `?v=<fingerprint>` cache-bust token, so assert on the
8142        // script identity + trailing position rather than an exact URL.
8143        assert!(out.contains("cms-axe-preview.js?v="));
8144        assert!(out.trim_end().ends_with("defer></script>"));
8145        assert!(out.contains("axe-core.min.js"));
8146        // Original content preserved.
8147        assert!(out.starts_with("<html><h1>hi</h1>"));
8148    }
8149
8150    #[test]
8151    fn uses_rfind_for_nested_body_close_text() {
8152        // A template that mentions "</body>" inside a comment / text
8153        // string and ALSO has a real closing tag — we want to splice
8154        // before the LAST one, not the first.
8155        let html = "<html><body><pre>literal: &lt;/body&gt;</pre></body></html>";
8156        let out = inject_axe_into_body_str(html);
8157        let close = out.rfind("</body>").unwrap();
8158        assert!(out[..close].contains("axe-core.min.js"));
8159        // Make sure the literal in the <pre> survived.
8160        assert!(out.contains("literal: &lt;/body&gt;"));
8161    }
8162
8163    #[test]
8164    fn empty_body_renders_clean() {
8165        let out = inject_axe_into_body_str("");
8166        // Nothing to splice before; just the scripts.
8167        assert!(out.contains("axe-core.min.js"));
8168        assert!(out.contains("cms-axe-preview.js"));
8169    }
8170}
8171
8172/// Query string for the preview endpoints — carries the editing locale
8173/// when the editor is in translation mode (`?locale=fr`) so the preview
8174/// renders that locale's translation instead of the canonical content.
8175#[derive(serde::Deserialize, Default)]
8176pub struct PreviewLocaleQuery {
8177    #[serde(default)]
8178    locale: Option<String>,
8179    /// `?format=json` — show the page's API representation instead of
8180    /// its rendered HTML. This is the editor's preview switch, and it
8181    /// works for **any** page type, not just ones whose `view_mode`
8182    /// opts into a public JSON view: an authenticated editor asking to
8183    /// inspect the API shape is a different act from an anonymous
8184    /// client negotiating for it.
8185    #[serde(default)]
8186    format: Option<String>,
8187}
8188
8189/// The Tera a preview must render through: the tenant's, not the global set.
8190///
8191/// The public renderer resolves templates per tenant (`router.rs` →
8192/// [`crate::tenant_templates::TenantTemplates::for_tenant`]), so a
8193/// preview built from `state.tera` shows a page the visitor will never
8194/// get. Three ways it goes wrong, all silent: a tenant's override of a
8195/// shared template is ignored; a `Page::template_override` naming a
8196/// template that exists only as an override fails `pick_template`'s
8197/// existence check and falls back to the page type's default; and a
8198/// block whose template is a tenant override renders its
8199/// "missing template" fallback.
8200///
8201/// Falls back to the global set when no overlay is installed, which is
8202/// every single-template-set deployment.
8203fn preview_tera(state: &super::AdminState, tenant: &Tenant) -> std::sync::Arc<tera::Tera> {
8204    crate::tenant_templates::installed()
8205        .map(|tt| tt.for_tenant(&tenant.org.slug))
8206        .unwrap_or_else(|| state.tera.clone())
8207}
8208
8209/// GET /cms-admin/pages/{id}/preview — renders the saved page through
8210/// the public render pipeline (no admin chrome) so the editor's
8211/// iframe shows exactly what a visitor would see. Anti-cache headers
8212/// ensure the iframe always pulls fresh markup. `?locale=` (translation
8213/// mode) renders that locale's saved translation.
8214pub async fn page_preview(
8215    State(state): State<super::AdminState>,
8216    tenant: Tenant,
8217    Path(id): Path<i64>,
8218    axum::extract::Query(q): axum::extract::Query<PreviewLocaleQuery>,
8219) -> Result<Response, AdminError> {
8220    let page = Page::objects()
8221        .where_(Page::id.eq(id))
8222        .first(tenant.pool())
8223        .await?
8224        .ok_or(AdminError::NotFound(id))?;
8225    let response = crate::render::render(
8226        &tenant,
8227        &preview_tera(&state, &tenant),
8228        &page,
8229        "",
8230        // No site prefix: this path renders the tenant-absolute
8231        // tree, so links must stay absolute.
8232        "",
8233        q.locale.as_deref(),
8234        None,
8235        None,
8236    )
8237    .await;
8238    // #208 — splice axe-core + the iframe-glue script before the
8239    // closing </body> so the editor's accessibility panel can
8240    // surface client-side findings alongside the server-side ones.
8241    Ok(stamp_no_cache(inject_axe_into_preview(response).await))
8242}
8243
8244/// GET /cms-admin/pages/{id}/preview-token — mint a short-lived
8245/// signed preview token so a decoupled / headless frontend can fetch
8246/// this page's DRAFT via `/api/v2/pages/{id}/?preview_token=…`. Returns
8247/// JSON `{token, expires_at, api_path}`. Auth is enforced by the admin
8248/// router's login guard.
8249pub async fn page_preview_token(
8250    tenant: Tenant,
8251    Path(id): Path<i64>,
8252) -> Result<Response, AdminError> {
8253    let exists = Page::objects()
8254        .where_(Page::id.eq(id))
8255        .first(tenant.pool())
8256        .await?
8257        .is_some();
8258    if !exists {
8259        return Err(AdminError::NotFound(id));
8260    }
8261    // 1-hour token: long enough to click through + iterate, short
8262    // enough to bound exposure of an unpublished page.
8263    let expires = chrono::Utc::now().timestamp() + PREVIEW_TOKEN_TTL_SECS;
8264    let token = crate::preview_token::mint(&tenant.org.slug, id, expires);
8265    Ok(Json(serde_json::json!({
8266        "token": token,
8267        "expires_at": expires,
8268        "api_path": format!("/api/v2/pages/{id}/?preview_token={token}"),
8269    }))
8270    .into_response())
8271}
8272
8273/// POST /cms-admin/pages/{id}/preview — same as the GET variant, but
8274/// renders a *virtual* page assembled from the posted form values so
8275/// the editor can preview unsaved changes. Nothing is persisted. Anti-cache
8276/// headers + same-origin frame policy mirror the GET handler.
8277pub async fn page_preview_draft(
8278    State(state): State<super::AdminState>,
8279    tenant: Tenant,
8280    Path(id): Path<i64>,
8281    axum::extract::Query(q): axum::extract::Query<PreviewLocaleQuery>,
8282    headers: HeaderMap,
8283    Form(form_map): Form<std::collections::HashMap<String, String>>,
8284) -> Result<Response, AdminError> {
8285    let mut page = Page::objects()
8286        .where_(Page::id.eq(id))
8287        .first(tenant.pool())
8288        .await?
8289        .ok_or(AdminError::NotFound(id))?;
8290
8291    // Overlay the canonical form fields onto the virtual page. The
8292    // tree placement (parent / path / url_path) stays as-saved so
8293    // breadcrumb + ancestor lookups still work.
8294    if let Some(v) = form_map.get("title") {
8295        page.title = v.clone();
8296    }
8297    if let Some(v) = form_map.get("slug") {
8298        page.slug = v.clone();
8299    }
8300    if let Some(v) = form_map
8301        .get("page_type_id")
8302        .and_then(|s| s.parse::<i64>().ok())
8303    {
8304        page.page_type_id = v;
8305    }
8306    if let Some(v) = form_map.get("status") {
8307        page.status = v.clone();
8308    }
8309    if let Some(v) = form_map.get("seo_title") {
8310        page.seo_title = v.clone();
8311    }
8312    if let Some(v) = form_map.get("seo_description") {
8313        page.seo_description = v.clone();
8314    }
8315    // Checkboxes submit `on` when checked, absent when unchecked.
8316    page.robots_index = form_map
8317        .get("robots_index")
8318        .map(|v| matches!(v.as_str(), "on" | "true" | "1"))
8319        .unwrap_or(page.robots_index);
8320    if let Some(v) = form_map
8321        .get("sitemap_priority")
8322        .and_then(|s| s.parse::<f32>().ok())
8323    {
8324        page.sitemap_priority = v;
8325    }
8326    if let Some(raw) = form_map.get("theme_id") {
8327        page.theme_id = if raw.is_empty() || raw == "0" {
8328            None
8329        } else {
8330            raw.parse::<i64>().ok()
8331        };
8332    }
8333
8334    // The editor's JSON pane sends `Accept: application/json`, so the
8335    // same renderer that answers the public URL answers the preview —
8336    // which is what makes the pane show the real response body rather
8337    // than an admin-side reconstruction of it.
8338    let accept = crate::page_view::parse_accept(
8339        headers
8340            .get(axum::http::header::ACCEPT)
8341            .and_then(|v| v.to_str().ok()),
8342    );
8343    let force_json = q.format.as_deref() == Some("json");
8344    let response = crate::render::render_preview(
8345        &tenant,
8346        &preview_tera(&state, &tenant),
8347        &page,
8348        "",
8349        // Preview renders tenant-absolute paths — see the GET twin.
8350        "",
8351        q.locale.as_deref(),
8352        &form_map,
8353        accept,
8354        force_json,
8355    )
8356    .await;
8357    // #208 — same axe splice as the GET preview handler above. It gates
8358    // on `text/html`, so a JSON preview passes through untouched and
8359    // never pulls axe-core into the pane.
8360    Ok(stamp_no_cache(inject_axe_into_preview(response).await))
8361}
8362
8363// =====================================================================
8364// Library tab
8365// =====================================================================
8366
8367/// GET /cms-admin/library — placeholder until a real
8368/// `register_library_type!` macro lands. Shows the registered
8369/// PageTypeHandlers as a stand-in so the chrome demos cleanly.
8370/// Query for the paginated, filtered, folder-scoped snippet list.
8371#[derive(Debug, Deserialize, Default)]
8372pub struct LibraryListQuery {
8373    /// When set, focuses the list to one library type. When absent,
8374    /// the overview (one card per registered type with counts) shows.
8375    #[serde(default)]
8376    pub r#type: Option<String>,
8377    /// Folder prefix to scope the list to. Empty / unset = root.
8378    #[serde(default)]
8379    pub folder: Option<String>,
8380    /// Free-text query — matched against the type handler's
8381    /// `search_fields()`.
8382    #[serde(default)]
8383    pub q: Option<String>,
8384    /// 1-based page number.
8385    #[serde(default)]
8386    pub page: Option<u32>,
8387    /// Rows per page. Named so it is consumed here rather than falling
8388    /// into `raw_filters` and being read as a filter chip.
8389    #[serde(default)]
8390    pub per_page: Option<usize>,
8391    /// Catch-all bucket for `filter_<key>=<value>` filter chips. Any
8392    /// query parameter starting with `filter_` lands here.
8393    #[serde(flatten)]
8394    pub raw_filters: std::collections::HashMap<String, String>,
8395}
8396
8397pub async fn library_list(
8398    State(state): State<super::AdminState>,
8399    tenant: Tenant,
8400    headers: HeaderMap,
8401    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8402    Query(q): Query<LibraryListQuery>,
8403    axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
8404) -> Result<Response, AdminError> {
8405    // Sidebar / overview data — all types + total counts. Forms are excluded:
8406    // they have their own dedicated area (`/cms-admin/forms`, sidebar "Forms")
8407    // with per-form submission counts, so listing them here would be a second,
8408    // weaker path to the same thing. Direct `?type=form` URLs still work.
8409    let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8410        .order_by(&[("type_name", false)])
8411        .fetch(tenant.pool())
8412        .await?
8413        .into_iter()
8414        .filter(|t| t.type_name != "form")
8415        .collect();
8416    let all_snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
8417        .fetch(tenant.pool())
8418        .await?;
8419    let mut counts_by_type: std::collections::HashMap<String, i64> =
8420        std::collections::HashMap::new();
8421    for s in &all_snippets {
8422        *counts_by_type.entry(s.type_name.clone()).or_default() += 1;
8423    }
8424
8425    let mut ctx = Context::new();
8426    add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8427    add_admin_theme(&mut ctx, tenant.pool()).await;
8428    // #316 — raw query string for the `| querystring(page=…)` filter in
8429    // the pagination links (preserves type/folder/q/filter_* + sets page).
8430    ctx.insert("query_string", &raw_query.unwrap_or_default());
8431    ctx.insert("types", &types);
8432    ctx.insert("counts_by_type", &counts_by_type);
8433
8434    // Overview mode — no `?type=`, show one card per registered type.
8435    let Some(type_name) = q.r#type.as_deref().filter(|s| !s.is_empty()) else {
8436        ctx.insert("mode", "overview");
8437        return render_with_csrf(&state, &headers, "rcms_admin/library_list.html", &mut ctx);
8438    };
8439
8440    // Resolve the handler so we can call list_display / search_fields
8441    // / list_filter / render_cell.
8442    let handler = crate::library::find_handler(type_name);
8443    let list_display = handler
8444        .as_ref()
8445        .map(|h| h.list_display())
8446        .unwrap_or_else(|| {
8447            vec![
8448                crate::library::ListColumn::Field {
8449                    column: "title",
8450                    label: "Title",
8451                },
8452                crate::library::ListColumn::Field {
8453                    column: "slug",
8454                    label: "Slug",
8455                },
8456                crate::library::ListColumn::Field {
8457                    column: "updated_at",
8458                    label: "Updated",
8459                },
8460            ]
8461        });
8462    let search_fields = handler
8463        .as_ref()
8464        .map(|h| h.search_fields())
8465        .unwrap_or_else(|| vec!["title", "slug"]);
8466    let filter_keys = handler
8467        .as_ref()
8468        .map(|h| h.list_filter())
8469        .unwrap_or_default();
8470
8471    // Folder scoping. Snippets with `folder_path = <current>` are
8472    // direct contents; we also surface the immediate sub-folder
8473    // names so the user can drill in.
8474    let folder = crate::snippet::normalize_folder(q.folder.as_deref().unwrap_or(""));
8475    let child_folders = crate::snippet::child_folders(tenant.pool(), &folder)
8476        .await
8477        .unwrap_or_default();
8478
8479    // Apply filters — type, folder, then per-data.<key> chips +
8480    // per-row `can_view` (#21 phase 1) so handler-supplied hooks
8481    // suppress rows from the list.
8482    let mut filtered: Vec<crate::snippet::Snippet> = all_snippets
8483        .iter()
8484        .filter(|s| s.type_name == type_name && s.folder_path == folder)
8485        .filter(|s| handler.as_ref().map(|h| h.can_view(s)).unwrap_or(true))
8486        .cloned()
8487        .collect();
8488
8489    // Search — ILIKE pattern on each search_field, ANY match wins.
8490    let search_q = q.q.as_deref().map(|s| s.trim()).filter(|s| !s.is_empty());
8491    if let Some(needle) = search_q {
8492        let needle_lower = needle.to_lowercase();
8493        filtered.retain(|s| {
8494            search_fields.iter().any(|field| {
8495                let hay = match *field {
8496                    "title" => s.title.to_lowercase(),
8497                    "slug" => s.slug.to_lowercase(),
8498                    "body_markdown" => s.body_markdown.to_lowercase(),
8499                    other => s
8500                        .data
8501                        .get(other)
8502                        .and_then(serde_json::Value::as_str)
8503                        .map(str::to_lowercase)
8504                        .unwrap_or_default(),
8505                };
8506                hay.contains(&needle_lower)
8507            })
8508        });
8509    }
8510
8511    // `filter_<key>=<value>` chips — flatten raw_filters into a
8512    // typed map first so we don't carry useless keys into context.
8513    let mut active_filters: std::collections::HashMap<String, String> =
8514        std::collections::HashMap::new();
8515    for (k, v) in &q.raw_filters {
8516        if let Some(stripped) = k.strip_prefix("filter_") {
8517            if !v.is_empty() {
8518                active_filters.insert(stripped.to_owned(), v.clone());
8519            }
8520        }
8521    }
8522    if !active_filters.is_empty() {
8523        filtered.retain(|s| {
8524            active_filters.iter().all(|(key, want)| {
8525                let got = s
8526                    .data
8527                    .get(key)
8528                    .map(|v| match v {
8529                        serde_json::Value::String(s) => s.clone(),
8530                        other => other.to_string(),
8531                    })
8532                    .unwrap_or_default();
8533                got == *want
8534            })
8535        });
8536    }
8537
8538    // Filter chip options (distinct values per filterable key).
8539    let filter_options: std::collections::HashMap<String, Vec<String>> = filter_keys
8540        .iter()
8541        .map(|k| {
8542            let mut opts: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
8543            for s in &all_snippets {
8544                if s.type_name != type_name {
8545                    continue;
8546                }
8547                if let Some(v) = s.data.get(*k) {
8548                    let s = match v {
8549                        serde_json::Value::String(s) => s.clone(),
8550                        other => other.to_string(),
8551                    };
8552                    if !s.is_empty() {
8553                        opts.insert(s);
8554                    }
8555                }
8556            }
8557            ((*k).to_owned(), opts.into_iter().collect())
8558        })
8559        .collect();
8560
8561    // Pagination — driven by `rustango::pagination::Paginator`.
8562    // `get_page()` never errors; out-of-range numbers clamp to the
8563    // last page (or 1 when empty). The slice indices come from
8564    // `start_index() - 1 .. end_index()` (the paginator returns
8565    // 1-based inclusive indices for "Showing X–Y" UI lines).
8566    let total = filtered.len();
8567    let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
8568    let paginator = rustango::pagination::Paginator::new(total, page_size);
8569    let requested_page = q.page.unwrap_or(1).max(1) as i64;
8570    let page_obj = paginator.get_page(requested_page);
8571    let page = page_obj.number;
8572    let total_pages = paginator.num_pages().max(1);
8573    let page_rows: Vec<crate::snippet::Snippet> = if total == 0 {
8574        Vec::new()
8575    } else {
8576        let start = page_obj.start_index().saturating_sub(1);
8577        let end = page_obj.end_index();
8578        filtered[start..end].to_vec()
8579    };
8580
8581    // Pre-render each row's cells so the template doesn't need to
8582    // know about ListColumn variants. Each row → Vec<String> of
8583    // pre-escaped HTML strings (cells), aligned with `column_headers`.
8584    let column_headers: Vec<serde_json::Value> = list_display
8585        .iter()
8586        .map(|c| {
8587            serde_json::json!({
8588                "key": c.key(),
8589                "label": c.label(),
8590            })
8591        })
8592        .collect();
8593    let rows_html: Vec<serde_json::Value> = page_rows
8594        .iter()
8595        .map(|row| {
8596            let cells: Vec<String> = list_display
8597                .iter()
8598                .map(|c| render_list_cell(c, row, handler.as_deref()))
8599                .collect();
8600            serde_json::json!({
8601                "id": row.id.get().copied().unwrap_or_default(),
8602                "slug": row.slug,
8603                "cells": cells,
8604            })
8605        })
8606        .collect();
8607
8608    let active_filters_json: Vec<serde_json::Value> = active_filters
8609        .iter()
8610        .map(|(k, v)| serde_json::json!({ "key": k, "value": v }))
8611        .collect();
8612
8613    // Handler-declared bulk + row actions (#21 phase 2). Serialize
8614    // the structs into the JSON shape the template iterates.
8615    let bulk_actions: Vec<serde_json::Value> = handler
8616        .as_ref()
8617        .map(|h| h.bulk_actions())
8618        .unwrap_or_default()
8619        .iter()
8620        .map(serialize_bulk_action)
8621        .collect();
8622    let row_actions: Vec<serde_json::Value> = handler
8623        .as_ref()
8624        .map(|h| h.row_actions())
8625        .unwrap_or_default()
8626        .iter()
8627        .map(serialize_bulk_action)
8628        .collect();
8629
8630    // #134 — plugin-contributed bulk actions targeting `cms_snippet`.
8631    let plugin_bulk_actions: Vec<serde_json::Value> = crate::hooks::bulk_actions_for("cms_snippet")
8632        .into_iter()
8633        .map(|a| {
8634            serde_json::json!({
8635                "key": a.key,
8636                "label": a.label,
8637                "icon": a.icon,
8638                "danger": a.danger,
8639                "confirm_message": a.confirm_message,
8640                "action_url": a.action_url,
8641            })
8642        })
8643        .collect();
8644
8645    // #196 — full folder tree for the left rail. Flat list of every
8646    // folder_path (including derived intermediates), sorted; the
8647    // template renders each row with depth-based indentation based
8648    // on the slash count.
8649    let folder_tree_paths = crate::snippet::folder_tree_for_type(tenant.pool(), type_name)
8650        .await
8651        .unwrap_or_default();
8652    let folder_tree: Vec<serde_json::Value> = folder_tree_paths
8653        .iter()
8654        .map(|p| {
8655            let depth = p.matches('/').count(); // root="" → 0; "a/" → 1; "a/b/" → 2
8656            let display = if p.is_empty() {
8657                "Root".to_owned()
8658            } else {
8659                // Last non-empty segment is the displayed name.
8660                p.trim_end_matches('/')
8661                    .rsplit('/')
8662                    .next()
8663                    .unwrap_or("")
8664                    .to_owned()
8665            };
8666            serde_json::json!({
8667                "path": p,
8668                "name": display,
8669                "depth": depth,
8670                "active": *p == folder,
8671            })
8672        })
8673        .collect();
8674
8675    ctx.insert("mode", "type");
8676    ctx.insert("active_type", type_name);
8677    ctx.insert("folder", &folder);
8678    ctx.insert("child_folders", &child_folders);
8679    ctx.insert("folder_tree", &folder_tree);
8680    ctx.insert("column_headers", &column_headers);
8681    ctx.insert("rows", &rows_html);
8682    ctx.insert("plugin_bulk_actions", &plugin_bulk_actions);
8683    ctx.insert("page", &page);
8684    ctx.insert("total_pages", &total_pages);
8685    // Shared control row (`rcms_admin/_pagination.html`); the bespoke
8686    // vars above stay for the rest of the template.
8687    ctx.insert(
8688        "pagination",
8689        &crate::admin::pagination::context(page as i64, page_size, total),
8690    );
8691    ctx.insert("total", &total);
8692    ctx.insert("page_size", &page_size);
8693    ctx.insert("search_q", &search_q.unwrap_or(""));
8694    ctx.insert("filter_keys", &filter_keys);
8695    ctx.insert("filter_options", &filter_options);
8696    ctx.insert("active_filters", &active_filters_json);
8697    ctx.insert("bulk_actions", &bulk_actions);
8698    ctx.insert("row_actions", &row_actions);
8699    render_with_csrf(&state, &headers, "rcms_admin/library_list.html", &mut ctx)
8700}
8701
8702/// Bulk-action button shape the library_list template iterates.
8703fn serialize_bulk_action(a: &crate::library::BulkAction) -> serde_json::Value {
8704    use crate::library::BulkActionStyle;
8705    let style_class = match a.style {
8706        BulkActionStyle::Primary => "btn",
8707        BulkActionStyle::Outlined => "btn btn-outlined",
8708        BulkActionStyle::Danger => "btn btn-danger",
8709    };
8710    serde_json::json!({
8711        "name": a.name,
8712        "label": a.label,
8713        "icon": a.icon,
8714        "confirm_message": a.confirm_message,
8715        "style_class": style_class,
8716    })
8717}
8718
8719/// POST /cms-admin/library/{type}/bulk — dispatch a bulk action
8720/// to the registered LibraryTypeHandler. Body shape:
8721/// `action=<name>&ids=<id>&ids=<id>...`. Returns the editor back
8722/// to the type's list view with a flash message reporting how many
8723/// rows the handler processed.
8724pub async fn library_bulk_submit(
8725    State(_state): State<super::AdminState>,
8726    tenant: Tenant,
8727    headers: HeaderMap,
8728    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
8729    Path(type_name): Path<String>,
8730    Form(form): Form<Vec<(String, String)>>,
8731) -> Result<Response, AdminError> {
8732    let action = form
8733        .iter()
8734        .find(|(k, _)| k == "action")
8735        .map(|(_, v)| v.clone())
8736        .unwrap_or_default();
8737    let ids: Vec<i64> = form
8738        .iter()
8739        .filter(|(k, _)| k == "ids" || k == "id")
8740        .filter_map(|(_, v)| v.parse::<i64>().ok())
8741        .collect();
8742    if action.is_empty() || ids.is_empty() {
8743        return redirect_named_with_message(
8744            "rcms-admin:library:list",
8745            MsgLevel::Warning,
8746            "Pick at least one row + a bulk action before submitting.",
8747            &headers,
8748        );
8749    }
8750    let Some(handler) = crate::library::find_handler(&type_name) else {
8751        return Err(AdminError::Validation(format!(
8752            "unknown library type `{type_name}`"
8753        )));
8754    };
8755    // Validate that the named action is in the handler's declared
8756    // set — guards against forged form posts.
8757    let declared: std::collections::HashSet<&'static str> = handler
8758        .bulk_actions()
8759        .iter()
8760        .chain(handler.row_actions().iter())
8761        .map(|a| a.name)
8762        .collect();
8763    if !declared.contains(action.as_str()) {
8764        return Err(AdminError::Validation(format!(
8765            "library type `{type_name}` doesn't declare bulk action `{action}`"
8766        )));
8767    }
8768    let touched = handler
8769        .handle_bulk_action(tenant.pool(), &action, &ids)
8770        .await?;
8771    let count = touched.to_string();
8772    redirect_named_with_message_plural(
8773        "rcms-admin:library:list",
8774        MsgLevel::Success,
8775        "{action}: touched {count} row(s) in `{type_name}`.",
8776        touched as i64,
8777        &[
8778            ("action", action.as_str()),
8779            ("count", count.as_str()),
8780            ("type_name", type_name.as_str()),
8781        ],
8782        &headers,
8783    )
8784}
8785
8786/// Render one cell for a [`ListColumn`] / row pair into pre-escaped
8787/// HTML. Handles type-aware formatting: booleans → ✓/✗, datetimes →
8788/// 10-char prefix, FK-ish text → escape, JSON lookups → kind-driven
8789/// formatting, method fields → handler-supplied HTML (trusted —
8790/// caller is responsible for escaping).
8791fn render_list_cell(
8792    col: &crate::library::ListColumn,
8793    row: &crate::snippet::Snippet,
8794    handler: Option<&dyn crate::library::LibraryTypeHandler>,
8795) -> String {
8796    use crate::library::{ListColumn, ListColumnKind};
8797    match col {
8798        ListColumn::Field { column, .. } => match *column {
8799            "id" => row.id.get().copied().unwrap_or_default().to_string(),
8800            "type_name" => html_escape(&row.type_name),
8801            "slug" => format!("<code>{}</code>", html_escape(&row.slug)),
8802            "folder_path" => html_escape(&row.folder_path),
8803            "title" => format!("<strong>{}</strong>", html_escape(&row.title)),
8804            "body_markdown" => {
8805                let preview: String = row.body_markdown.chars().take(80).collect();
8806                format!("<span>{}</span>", html_escape(&preview))
8807            }
8808            "created_at" => row
8809                .created_at
8810                .get()
8811                .map(|d| d.format("%Y-%m-%d").to_string())
8812                .unwrap_or_default(),
8813            "updated_at" => row
8814                .updated_at
8815                .get()
8816                .map(|d| d.format("%Y-%m-%d").to_string())
8817                .unwrap_or_default(),
8818            other => format!("<em>(unknown field: {})</em>", html_escape(other)),
8819        },
8820        ListColumn::JsonField { key, kind, .. } => {
8821            let val = row.data.get(*key);
8822            match (kind, val) {
8823                (ListColumnKind::Bool, Some(serde_json::Value::Bool(b))) => bool_checkbox_html(*b),
8824                (_, Some(serde_json::Value::Bool(b))) => bool_checkbox_html(*b),
8825                (ListColumnKind::Integer, Some(serde_json::Value::Number(n)))
8826                | (ListColumnKind::Float, Some(serde_json::Value::Number(n))) => {
8827                    html_escape(&n.to_string())
8828                }
8829                (_, Some(serde_json::Value::String(s))) => html_escape(s),
8830                (_, Some(other)) => html_escape(&other.to_string()),
8831                (_, None) => String::new(),
8832            }
8833        }
8834        ListColumn::Method { name, .. } | ListColumn::Computed { name, .. } => handler
8835            .map(|h| h.render_cell(name, row))
8836            .unwrap_or_default(),
8837    }
8838}
8839
8840fn html_escape(s: &str) -> String {
8841    s.replace('&', "&amp;")
8842        .replace('<', "&lt;")
8843        .replace('>', "&gt;")
8844        .replace('"', "&quot;")
8845}
8846
8847fn bool_checkbox_html(b: bool) -> String {
8848    if b {
8849        r#"<span class="material-symbols-rounded sm filled" style="color: var(--accent);" aria-label="true">check_box</span>"#.to_owned()
8850    } else {
8851        r#"<span class="material-symbols-rounded sm" style="color: var(--muted-2);" aria-label="false">check_box_outline_blank</span>"#.to_owned()
8852    }
8853}
8854
8855/// GET /cms-admin/library/new?type=<type_name> — render the create
8856/// form for a new snippet. The type pre-selects from the query string
8857/// so the "+ New <Type>" CTA on the list page lands here.
8858#[derive(Debug, Deserialize)]
8859pub struct SnippetNewQuery {
8860    #[serde(default)]
8861    pub r#type: Option<String>,
8862    #[serde(default)]
8863    pub folder: Option<String>,
8864}
8865
8866pub async fn snippet_new_form(
8867    State(state): State<super::AdminState>,
8868    tenant: Tenant,
8869    headers: HeaderMap,
8870    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8871    Query(q): Query<SnippetNewQuery>,
8872) -> Result<Response, AdminError> {
8873    let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8874        .order_by(&[("type_name", false)])
8875        .fetch(tenant.pool())
8876        .await?;
8877    let mut ctx = Context::new();
8878    add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8879    add_admin_theme(&mut ctx, tenant.pool()).await;
8880    ctx.insert("mode", "new");
8881    ctx.insert("types", &types);
8882    ctx.insert("preselect_type", &q.r#type.unwrap_or_default());
8883    let folder = q.folder.unwrap_or_default();
8884    ctx.insert(
8885        "snippet",
8886        &serde_json::json!({
8887            "type_name": "",
8888            "slug": "",
8889            "title": "",
8890            "body_markdown": "",
8891            "folder_path": folder,
8892        }),
8893    );
8894    render_with_csrf(&state, &headers, "rcms_admin/snippet_form.html", &mut ctx)
8895}
8896
8897pub async fn snippet_edit_form(
8898    State(state): State<super::AdminState>,
8899    tenant: Tenant,
8900    headers: HeaderMap,
8901    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8902    Path(id): Path<i64>,
8903    Query(q): Query<EditQuery>,
8904) -> Result<Response, AdminError> {
8905    let snippet = crate::snippet::Snippet::objects()
8906        .where_(crate::snippet::Snippet::id.eq(id))
8907        .first(tenant.pool())
8908        .await?
8909        .ok_or(AdminError::NotFound(id))?;
8910    // FB-04 (#537) — forms are edited in the dedicated visual builder, not
8911    // the generic snippet form. The list's Edit link lands here; bounce to
8912    // the builder so the entry point "just works".
8913    if snippet.type_name == "form" {
8914        let url = rustango::urls::reverse_owned(
8915            "rcms-admin:forms:build",
8916            &std::collections::HashMap::from([("id".to_owned(), id.to_string())]),
8917        )
8918        .map_err(|e| AdminError::Validation(format!("url reversal failed: {e}")))?;
8919        return Ok(axum::response::Redirect::to(&url).into_response());
8920    }
8921    // Permission gate (#21 phase 3) — `can_view = false` denies
8922    // the edit page entirely (404 rather than 403 to avoid leaking
8923    // existence). `can_edit = false` lets the page render read-only
8924    // — we surface it via a `read_only` context var.
8925    let handler = crate::library::find_handler(&snippet.type_name);
8926    if let Some(h) = handler.as_ref() {
8927        if !h.can_view(&snippet) {
8928            return Err(AdminError::NotFound(id));
8929        }
8930    }
8931    let read_only = handler
8932        .as_ref()
8933        .map(|h| !h.can_edit(&snippet))
8934        .unwrap_or(false);
8935    let can_delete = handler
8936        .as_ref()
8937        .map(|h| h.can_delete(&snippet))
8938        .unwrap_or(true);
8939    // Optional custom edit template — falls back to the default
8940    // `snippet_form.html` when not overridden.
8941    let template_path = handler
8942        .as_ref()
8943        .and_then(|h| h.edit_template())
8944        .unwrap_or("rcms_admin/snippet_form.html");
8945
8946    let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8947        .order_by(&[("type_name", false)])
8948        .fetch(tenant.pool())
8949        .await?;
8950    let mut ctx = Context::new();
8951    add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8952    add_admin_theme(&mut ctx, tenant.pool()).await;
8953    ctx.insert("mode", "edit");
8954    ctx.insert("types", &types);
8955    ctx.insert("snippet", &snippet);
8956    ctx.insert("read_only", &read_only);
8957    ctx.insert("can_delete", &can_delete);
8958    // Types that let each element name its own template get the field;
8959    // for every other type the concept doesn't exist and the form
8960    // shouldn't imply it does.
8961    ctx.insert(
8962        "allows_element_template",
8963        &handler
8964            .as_ref()
8965            .map(|h| h.allows_element_template())
8966            .unwrap_or(false),
8967    );
8968    // #123 — surface revision history + preview opt-in flags so the
8969    // edit template can render a History card + Preview link only
8970    // for types that opted in.
8971    let revisions_enabled = handler.as_ref().is_some_and(|h| h.revisions_enabled());
8972    let preview_enabled = handler.as_ref().is_some_and(|h| h.preview_enabled());
8973    let revisions: Vec<crate::snippet::SnippetRevision> = if revisions_enabled {
8974        crate::snippet::revisions_for(tenant.pool(), id)
8975            .await
8976            .unwrap_or_default()
8977    } else {
8978        Vec::new()
8979    };
8980    ctx.insert("revisions_enabled", &revisions_enabled);
8981    ctx.insert("preview_enabled", &preview_enabled);
8982    ctx.insert("snippet_revisions", &revisions);
8983    // #409 — snippet translation mode. `?locale=<code>` (a non-default
8984    // active locale) shows a per-field translation editor beside the
8985    // canonical content, mirroring the page translate flow.
8986    let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
8987        .where_(crate::locale::Locale::active.eq(true))
8988        .order_by(&[("sort_order", false), ("code", false)])
8989        .fetch(tenant.pool())
8990        .await?;
8991    let editing_locale = q
8992        .locale
8993        .as_deref()
8994        .filter(|c| !c.is_empty())
8995        .and_then(|code| locales.iter().find(|l| l.code == code).cloned());
8996    let translation_mode = editing_locale.as_ref().is_some_and(|l| !l.is_default);
8997    let mut core_translations: std::collections::HashMap<String, String> =
8998        std::collections::HashMap::new();
8999    let mut extra_translations: Vec<(String, String)> = Vec::new();
9000    if translation_mode {
9001        let lid = editing_locale
9002            .as_ref()
9003            .and_then(|l| l.id.get().copied())
9004            .unwrap_or_default();
9005        let existing = crate::snippet_translation::fetch_for(tenant.pool(), id, lid)
9006            .await
9007            .unwrap_or_default();
9008        let core_keys = ["title", "body_markdown"];
9009        core_translations = core_keys
9010            .iter()
9011            .map(|k| {
9012                (
9013                    (*k).to_owned(),
9014                    existing.get(*k).cloned().unwrap_or_default(),
9015                )
9016            })
9017            .collect();
9018        extra_translations = existing
9019            .iter()
9020            .filter(|(k, _)| !core_keys.contains(&k.as_str()))
9021            .map(|(k, v)| (k.clone(), v.clone()))
9022            .collect();
9023    }
9024    ctx.insert("locales", &locales);
9025    ctx.insert("editing_locale", &editing_locale);
9026    ctx.insert("translation_mode", &translation_mode);
9027    ctx.insert("core_translations", &core_translations);
9028    ctx.insert("extra_translations", &extra_translations);
9029    render_with_csrf(&state, &headers, template_path, &mut ctx)
9030}
9031
9032/// POST `/cms-admin/library/{id}/translate?locale=<code>` —
9033/// upsert per-field snippet translations for a non-default locale.
9034/// Mirrors [`page_translate_submit`]: `tr__<field>` keys edit existing
9035/// fields, `new_field_path` + `new_field_value` adds one; an empty
9036/// value deletes the row (canonical shows through). Atomic batch.
9037pub async fn snippet_translate_submit(
9038    State(_state): State<super::AdminState>,
9039    tenant: Tenant,
9040    Path(id): Path<i64>,
9041    Query(q): Query<EditQuery>,
9042    Form(form): Form<std::collections::HashMap<String, String>>,
9043) -> Result<Response, AdminError> {
9044    use crate::snippet_translation::SnippetTranslation;
9045    let code = q
9046        .locale
9047        .as_deref()
9048        .filter(|c| !c.is_empty())
9049        .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
9050    let locale = crate::locale::Locale::objects()
9051        .where_(crate::locale::Locale::code.eq(code.to_owned()))
9052        .where_(crate::locale::Locale::active.eq(true))
9053        .first(tenant.pool())
9054        .await?
9055        .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
9056    if locale.is_default {
9057        return Ok((
9058            axum::http::StatusCode::BAD_REQUEST,
9059            "cannot translate INTO the default locale; canonical content lives on cms_snippet",
9060        )
9061            .into_response());
9062    }
9063    let locale_id = locale
9064        .id
9065        .get()
9066        .copied()
9067        .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
9068    // Verify the snippet exists.
9069    let snippet = crate::snippet::Snippet::objects()
9070        .where_(crate::snippet::Snippet::id.eq(id))
9071        .first(tenant.pool())
9072        .await?
9073        .ok_or(AdminError::NotFound(id))?;
9074
9075    // Collect `tr__<field>` edits + an optional new-field row.
9076    let mut updates: Vec<(String, String)> = Vec::new();
9077    for (k, v) in &form {
9078        if let Some(path) = k.strip_prefix("tr__") {
9079            if !path.is_empty() {
9080                updates.push((path.to_owned(), v.clone()));
9081            }
9082        }
9083    }
9084    let new_path_raw = form.get("new_field_path").map(String::as_str).unwrap_or("");
9085    if !new_path_raw.trim().is_empty() {
9086        // Reuse the model's validator; silently skip a malformed path
9087        // rather than 400 the whole batch.
9088        if let Ok(path) = crate::snippet_translation::validate_field_path(new_path_raw) {
9089            let value = form.get("new_field_value").cloned().unwrap_or_default();
9090            updates.push((path, value));
9091        }
9092    }
9093
9094    // Empty value → delete; non-empty → upsert. Atomic batch.
9095    rustango::atomic!(tenant.pool(), |tx| {
9096        let mut guard = tx.lock().await?;
9097        let tx = &mut *guard;
9098        for (path, value) in updates {
9099            let existing: Vec<SnippetTranslation> = SnippetTranslation::objects()
9100                .where_(SnippetTranslation::snippet_id.eq(id))
9101                .where_(SnippetTranslation::locale_id.eq(locale_id))
9102                .where_(SnippetTranslation::field_path.eq(path.clone()))
9103                .fetch_tx(tx)
9104                .await?;
9105            if value.is_empty() {
9106                for row in existing {
9107                    row.delete_tx(tx).await?;
9108                }
9109            } else if let Some(mut row) = existing.into_iter().next() {
9110                row.value = value;
9111                row.save_tx(tx).await?;
9112            } else {
9113                let mut row = SnippetTranslation {
9114                    id: rustango::sql::Auto::Unset,
9115                    snippet_id: id,
9116                    locale_id,
9117                    field_path: path,
9118                    value,
9119                    updated_at: rustango::sql::Auto::Unset,
9120                };
9121                row.save_tx(tx).await?;
9122            }
9123        }
9124        Ok::<_, rustango::sql::ExecError>(())
9125    })
9126    .await?;
9127
9128    // A form is translated on its own screen; its library edit page
9129    // forwards to the builder and would drop the language.
9130    let back = if snippet.type_name == "form" {
9131        format!("/cms-admin/forms/{id}/build?locale={code}")
9132    } else {
9133        format!("/cms-admin/library/{id}/edit?locale={code}")
9134    };
9135    Ok(Redirect::to(&back).into_response())
9136}
9137
9138/// POST /cms-admin/library/snippets/{id}/revert/{seq} — restore a
9139/// snippet to the snapshot stored in the named revision. Captures a
9140/// fresh revision after the revert so the timeline stays linear.
9141pub async fn snippet_revert_submit(
9142    State(_state): State<super::AdminState>,
9143    tenant: Tenant,
9144    headers: HeaderMap,
9145    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9146    Path((id, sequence)): Path<(i64, i32)>,
9147) -> Result<Response, AdminError> {
9148    let Some(rev) = crate::snippet::revision_by_sequence(tenant.pool(), id, sequence).await? else {
9149        return Err(AdminError::NotFound(id));
9150    };
9151    let mut snippet = crate::snippet::Snippet::objects()
9152        .where_(crate::snippet::Snippet::id.eq(id))
9153        .first(tenant.pool())
9154        .await?
9155        .ok_or(AdminError::NotFound(id))?;
9156    // Re-hydrate from the snapshot — title / body / slug / data /
9157    // folder_path / type_name. Skip primary key + audit timestamps.
9158    let snap = &rev.snapshot;
9159    if let Some(v) = snap.get("title").and_then(|v| v.as_str()) {
9160        snippet.title = v.to_owned();
9161    }
9162    if let Some(v) = snap.get("slug").and_then(|v| v.as_str()) {
9163        snippet.slug = v.to_owned();
9164    }
9165    if let Some(v) = snap.get("body_markdown").and_then(|v| v.as_str()) {
9166        snippet.body_markdown = v.to_owned();
9167    }
9168    if let Some(v) = snap.get("folder_path").and_then(|v| v.as_str()) {
9169        snippet.folder_path = v.to_owned();
9170    }
9171    if let Some(v) = snap.get("type_name").and_then(|v| v.as_str()) {
9172        snippet.type_name = v.to_owned();
9173    }
9174    if let Some(v) = snap.get("data") {
9175        snippet.data = v.clone();
9176    }
9177    snippet.save_pool(tenant.pool()).await?;
9178    // Capture the revert itself so the timeline shows it.
9179    if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9180        if handler.revisions_enabled() {
9181            let captured_by = session_user.as_ref().and_then(|u| u.id.get().copied());
9182            crate::snippet::capture_revision(tenant.pool(), &snippet, captured_by)
9183                .await
9184                .log_warn("revision not captured; the history has a gap");
9185        }
9186    }
9187    let sequence_str = sequence.to_string();
9188    redirect_named_with_params_and_message_args(
9189        "rcms-admin:library:edit",
9190        &[("id", id.to_string())],
9191        MsgLevel::Success,
9192        "Reverted to revision #{sequence}.",
9193        &[("sequence", sequence_str.as_str())],
9194        &headers,
9195    )
9196}
9197
9198pub async fn snippet_create_submit(
9199    State(_state): State<super::AdminState>,
9200    tenant: Tenant,
9201    headers: HeaderMap,
9202    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9203    Form(form): Form<std::collections::HashMap<String, String>>,
9204) -> Result<Response, AdminError> {
9205    let type_name = form.get("type_name").cloned().unwrap_or_default();
9206    let slug = form.get("slug").cloned().unwrap_or_default();
9207    let title = form.get("title").cloned().unwrap_or_default();
9208    let body = form.get("body_markdown").cloned().unwrap_or_default();
9209    let folder_path = form
9210        .get("folder_path")
9211        .map(|s| crate::snippet::normalize_folder(s))
9212        .unwrap_or_default();
9213    if type_name.is_empty() || slug.is_empty() || title.is_empty() {
9214        return Err(AdminError::Validation(
9215            "type, slug, and title are all required".to_owned(),
9216        ));
9217    }
9218    let mut row = crate::snippet::Snippet {
9219        id: rustango::sql::Auto::Unset,
9220        type_name,
9221        slug,
9222        folder_path,
9223        title,
9224        body_markdown: body,
9225        data: serde_json::Value::Object(serde_json::Map::new()),
9226        created_at: rustango::sql::Auto::Unset,
9227        updated_at: rustango::sql::Auto::Unset,
9228    };
9229    row.save_pool(tenant.pool()).await?;
9230    // A new form is empty until its fields are built — go straight to the
9231    // Form Builder rather than back to the Library list.
9232    if row.type_name == "form" {
9233        let id = row.id.get().copied().unwrap_or_default();
9234        return redirect_named_with_params_and_message(
9235            "rcms-admin:forms:build",
9236            &[("id", id.to_string())],
9237            MsgLevel::Success,
9238            &super::i18n::tr(
9239                &headers,
9240                "Created snippet “{title}”.",
9241                &[("title", row.title.as_str())],
9242            ),
9243            &headers,
9244        );
9245    }
9246    redirect_named_with_message_args(
9247        "rcms-admin:library:list",
9248        MsgLevel::Success,
9249        "Created snippet “{title}”.",
9250        &[("title", row.title.as_str())],
9251        &headers,
9252    )
9253}
9254
9255pub async fn snippet_edit_submit(
9256    State(_state): State<super::AdminState>,
9257    tenant: Tenant,
9258    headers: HeaderMap,
9259    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9260    Path(id): Path<i64>,
9261    Form(form): Form<std::collections::HashMap<String, String>>,
9262) -> Result<Response, AdminError> {
9263    let mut snippet = crate::snippet::Snippet::objects()
9264        .where_(crate::snippet::Snippet::id.eq(id))
9265        .first(tenant.pool())
9266        .await?
9267        .ok_or(AdminError::NotFound(id))?;
9268    // Permission gate (#21 phase 3) — handler-declared can_edit
9269    // hook short-circuits the save. V1 default is `true`; hosts
9270    // override to wire role-aware logic.
9271    if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9272        if !handler.can_edit(&snippet) {
9273            return Err(AdminError::Validation(format!(
9274                "Library type `{}` denies edit on this row.",
9275                snippet.type_name
9276            )));
9277        }
9278        // Cross-field validation hook — surfaces field-scoped error
9279        // strings before any mutation lands.
9280        if let Err(errors) = handler.validate(&form) {
9281            let summary: Vec<String> = errors
9282                .into_iter()
9283                .map(|(field, msg)| format!("{field}: {msg}"))
9284                .collect();
9285            return Err(AdminError::Validation(summary.join("; ")));
9286        }
9287    }
9288    if let Some(v) = form.get("type_name") {
9289        if !v.is_empty() {
9290            snippet.type_name = v.clone();
9291        }
9292    }
9293    if let Some(v) = form.get("slug") {
9294        if !v.is_empty() {
9295            snippet.slug = v.clone();
9296        }
9297    }
9298    if let Some(v) = form.get("title") {
9299        snippet.title = v.clone();
9300    }
9301    if let Some(v) = form.get("body_markdown") {
9302        snippet.body_markdown = v.clone();
9303    }
9304    if let Some(v) = form.get("folder_path") {
9305        snippet.folder_path = crate::snippet::normalize_folder(v);
9306    }
9307    // Per-element template name, for types that opted in via
9308    // `allows_element_template()`. Only that one `data` key is read
9309    // here: the generic form deliberately does not own `data` (typed
9310    // extras belong to a type's own `edit_template`), so a type that
9311    // never opted in cannot have its render repointed from this form.
9312    if crate::library::find_handler(&snippet.type_name)
9313        .is_some_and(|h| h.allows_element_template())
9314    {
9315        if let Some(v) = form.get("data__template") {
9316            crate::snippet::set_element_template(&mut snippet.data, v.trim());
9317        }
9318    }
9319    snippet.save_pool(tenant.pool()).await?;
9320    // #123 — capture a versioned snapshot when the handler opts in
9321    // via `revisions_enabled()`. Best-effort: capture failure logs
9322    // + does NOT abort the save.
9323    if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9324        if handler.revisions_enabled() {
9325            let captured_by = session_user.as_ref().and_then(|u| u.id.get().copied());
9326            if let Err(e) =
9327                crate::snippet::capture_revision(tenant.pool(), &snippet, captured_by).await
9328            {
9329                tracing::warn!(
9330                    target: "rustango_cms::admin",
9331                    snippet_id = id,
9332                    type_name = %snippet.type_name,
9333                    error = %e,
9334                    "snippet revision capture failed",
9335                );
9336            }
9337        }
9338    }
9339    // #146 — reindex references from the saved snippet form.
9340    {
9341        let mut refs: Vec<crate::reference_index::Reference> = Vec::new();
9342        for (key, value) in &form {
9343            let mut found = crate::reference_index::scan(value, key);
9344            refs.append(&mut found);
9345        }
9346        if let Err(e) = crate::reference_index::reindex_source(
9347            tenant.pool(),
9348            crate::reference_index::KIND_SNIPPET,
9349            id,
9350            refs,
9351        )
9352        .await
9353        {
9354            tracing::warn!(
9355                target: "rustango_cms::reference_index",
9356                snippet_id = id, error = %e,
9357                "snippet reindex failed (best-effort)"
9358            );
9359        }
9360    }
9361    redirect_named_with_message_args(
9362        "rcms-admin:library:list",
9363        MsgLevel::Success,
9364        "Saved snippet “{title}”.",
9365        &[("title", snippet.title.as_str())],
9366        &headers,
9367    )
9368}
9369
9370pub async fn snippet_delete_submit(
9371    State(_state): State<super::AdminState>,
9372    tenant: Tenant,
9373    headers: HeaderMap,
9374    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9375    Path(id): Path<i64>,
9376) -> Result<Response, AdminError> {
9377    let snippet = crate::snippet::Snippet::objects()
9378        .where_(crate::snippet::Snippet::id.eq(id))
9379        .first(tenant.pool())
9380        .await?
9381        .ok_or(AdminError::NotFound(id))?;
9382    // Permission gate (#21 phase 3) — handler can deny delete.
9383    if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9384        if !handler.can_delete(&snippet) {
9385            return Err(AdminError::Validation(format!(
9386                "Library type `{}` denies delete on this row.",
9387                snippet.type_name
9388            )));
9389        }
9390    }
9391    let title = snippet.title.clone();
9392    let is_form = snippet.type_name == "form";
9393    snippet.delete_pool(tenant.pool()).await?;
9394    // Forms are deleted from the Forms screen — go back there.
9395    if is_form {
9396        let body = super::i18n::tr(&headers, "Deleted snippet “{title}”.", &[("title", title.as_str())]);
9397        return Ok(rustango::messages::redirect_with_message(
9398            messages_secret(),
9399            &headers,
9400            MsgLevel::Success,
9401            &body,
9402            "/cms-admin/forms",
9403        ));
9404    }
9405    redirect_named_with_message_args(
9406        "rcms-admin:library:list",
9407        MsgLevel::Success,
9408        "Deleted snippet “{title}”.",
9409        &[("title", title.as_str())],
9410        &headers,
9411    )
9412}
9413
9414// =====================================================================
9415// Media + Documents tabs
9416// =====================================================================
9417
9418/// Parse a `YYYY-MM-DD` filter into the UTC instant at start-of-day.
9419/// Empty / unparseable → None.
9420fn parse_date_floor(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
9421    let raw = raw?.trim();
9422    if raw.is_empty() {
9423        return None;
9424    }
9425    chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d")
9426        .ok()
9427        .map(|d| {
9428            chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
9429                d.and_hms_opt(0, 0, 0).unwrap_or_default(),
9430                chrono::Utc,
9431            )
9432        })
9433}
9434
9435/// Parse a `YYYY-MM-DD` filter into the UTC instant at end-of-day
9436/// (23:59:59) so the inclusive ceiling matches editor intent.
9437fn parse_date_ceil(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
9438    let raw = raw?.trim();
9439    if raw.is_empty() {
9440        return None;
9441    }
9442    chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d")
9443        .ok()
9444        .map(|d| {
9445            chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
9446                d.and_hms_opt(23, 59, 59).unwrap_or_default(),
9447                chrono::Utc,
9448            )
9449        })
9450}
9451
9452/// Query string for the media + documents list views. All filters
9453/// optional; URL state persists so editors can bookmark filtered
9454/// views.
9455#[derive(Debug, Deserialize)]
9456pub struct MediaListQuery {
9457    /// 1-based page number. Out-of-range values clamp to the last page.
9458    #[serde(default)]
9459    pub page: Option<i64>,
9460    /// Rows per page; clamped to `admin::pagination::MAX_PER_PAGE`.
9461    #[serde(default)]
9462    pub per_page: Option<usize>,
9463    /// Filter to a specific collection. Omitted = all collections.
9464    #[serde(default)]
9465    pub collection: Option<i64>,
9466    /// Case-insensitive substring search across title, filename,
9467    /// alt_text.
9468    #[serde(default)]
9469    pub q: Option<String>,
9470    /// Date range floor — `YYYY-MM-DD`. Matches `uploaded_at >= from`.
9471    #[serde(default)]
9472    pub from: Option<String>,
9473    /// Date range ceiling — `YYYY-MM-DD`. Matches `uploaded_at <= to`
9474    /// (end of day in UTC).
9475    #[serde(default)]
9476    pub to: Option<String>,
9477}
9478
9479// =====================================================================
9480// Image hard crop (#24) — apply / clone-and-crop
9481// =====================================================================
9482
9483/// Form payload for both crop handlers. Coords are in source-image
9484/// pixel space; `mode` distinguishes apply vs clone-and-crop.
9485#[derive(Debug, Deserialize)]
9486pub struct CropForm {
9487    pub crop_x: u32,
9488    pub crop_y: u32,
9489    pub crop_w: u32,
9490    pub crop_h: u32,
9491    /// Either "apply" (destructive — overwrites source) or "clone"
9492    /// (creates a new media row from the cropped bytes).
9493    pub mode: String,
9494}
9495
9496/// POST /cms-admin/media/{id}/crop — apply the crop rect to the
9497/// source bytes. Two modes:
9498/// - `mode=apply` — replaces the row's bytes in-place, bumps
9499///   content_hash, recomputes width/height, purges every rendition
9500///   for the old hash. Destructive — the original bytes are gone.
9501/// - `mode=clone` — creates a new media row whose bytes are the
9502///   cropped output. Original row is untouched. New row inherits
9503///   title (" — crop" suffix) + alt_text + collection_id; focal
9504///   point clears so the editor re-marks on the crop.
9505pub async fn media_crop_submit(
9506    State(_state): State<super::AdminState>,
9507    tenant: Tenant,
9508    headers: HeaderMap,
9509    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9510    Path(id): Path<i64>,
9511    Form(form): Form<CropForm>,
9512) -> Result<Response, AdminError> {
9513    use rustango::sql::Auto;
9514    let mut media = Media::objects()
9515        .where_(Media::id.eq(id))
9516        .first(tenant.pool())
9517        .await?
9518        .ok_or(AdminError::NotFound(id))?;
9519    if media.kind != "image" {
9520        return Err(AdminError::Validation(
9521            "Crop applies to images only.".to_owned(),
9522        ));
9523    }
9524
9525    let bytes = crate::media_storage::disk_for(&tenant.org.slug)
9526        .load(&crate::media_storage::key(
9527            &tenant.org.slug,
9528            &media.storage_key,
9529        ))
9530        .await
9531        .map_err(|e| AdminError::Validation(format!("read source: {e}")))?;
9532    let (cropped_bytes, out_mime) = crate::rendition::crop_image_off_runtime(
9533        bytes,
9534        media.mime.clone(),
9535        (form.crop_x, form.crop_y, form.crop_w, form.crop_h),
9536    )
9537    .await
9538    .map_err(AdminError::Validation)?;
9539
9540    let new_hash = {
9541        use sha2::Digest;
9542        let mut hasher = sha2::Sha256::new();
9543        hasher.update(&cropped_bytes);
9544        let digest = hasher.finalize();
9545        let mut hex = String::with_capacity(digest.len() * 2);
9546        for b in digest.iter() {
9547            hex.push_str(&format!("{b:02x}"));
9548        }
9549        hex
9550    };
9551
9552    match form.mode.as_str() {
9553        "apply" => {
9554            // In-place: overwrite the same storage_key. The backend
9555            // writes the object wholesale (atomic PUT on S3), which
9556            // replaces the old tmp-file + rename dance.
9557            crate::media_storage::disk_for(&tenant.org.slug)
9558                .save(
9559                    &crate::media_storage::key(&tenant.org.slug, &media.storage_key),
9560                    &cropped_bytes,
9561                )
9562                .await
9563                .map_err(|e| AdminError::Validation(format!("write crop: {e}")))?;
9564            let old_hash = media.content_hash.clone();
9565            media.content_hash = new_hash;
9566            media.size = cropped_bytes.len() as i64;
9567            media.mime = out_mime;
9568            media.width = Some(form.crop_w as i32);
9569            media.height = Some(form.crop_h as i32);
9570            // Focal point in original coords no longer maps; clear.
9571            media.focal_point_x = None;
9572            media.focal_point_y = None;
9573            media.save_pool(tenant.pool()).await?;
9574
9575            // Purge renditions for the OLD content_hash (the route
9576            // looks them up by hash + filter spec; bytes on disk
9577            // also need cleaning).
9578            for r in crate::rendition::MediaRendition::objects()
9579                .where_(crate::rendition::MediaRendition::content_hash.eq(old_hash))
9580                .fetch(tenant.pool())
9581                .await?
9582            {
9583                crate::media_storage::disk_for(&tenant.org.slug)
9584                    .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
9585                    .await
9586                    .log_warn("stored file not deleted; the blob is orphaned");
9587                r.delete_pool(tenant.pool()).await?;
9588            }
9589            let crop_w = form.crop_w.to_string();
9590            let crop_h = form.crop_h.to_string();
9591            redirect_named_with_params_and_message_args(
9592                "rcms-admin:media:edit",
9593                &[("id", id.to_string())],
9594                MsgLevel::Success,
9595                "Crop applied. New dimensions {width}×{height}; renditions purged.",
9596                &[("width", crop_w.as_str()), ("height", crop_h.as_str())],
9597                &headers,
9598            )
9599        }
9600        "clone" => {
9601            // Save as new. Fresh storage_key under the source's
9602            // content-hash prefix so the on-disk bytes are
9603            // discoverable. Suffix the title with " — crop" so the
9604            // new row reads distinctly in lists.
9605            let ext = match out_mime.as_str() {
9606                "image/jpeg" => "jpg",
9607                "image/webp" => "webp",
9608                _ => "png",
9609            };
9610            let new_key = format!("{}-crop-{}.{ext}", &new_hash[..16.min(new_hash.len())], id);
9611            crate::media_storage::disk_for(&tenant.org.slug)
9612                .save(
9613                    &crate::media_storage::key(&tenant.org.slug, &new_key),
9614                    &cropped_bytes,
9615                )
9616                .await
9617                .map_err(|e| AdminError::Validation(format!("write clone: {e}")))?;
9618
9619            let clone_title = if media.title.contains(" — crop") {
9620                media.title.clone()
9621            } else {
9622                format!("{} — crop", media.title)
9623            };
9624            let mut clone = Media {
9625                id: Auto::Unset,
9626                filename: format!(
9627                    "{}.crop.{ext}",
9628                    std::path::Path::new(&media.filename)
9629                        .file_stem()
9630                        .map(|s| s.to_string_lossy().to_string())
9631                        .unwrap_or_else(|| "crop".to_owned())
9632                ),
9633                content_hash: new_hash,
9634                mime: out_mime,
9635                size: cropped_bytes.len() as i64,
9636                kind: "image".to_owned(),
9637                width: Some(form.crop_w as i32),
9638                height: Some(form.crop_h as i32),
9639                storage_key: new_key,
9640                title: clone_title,
9641                alt_text: media.alt_text.clone(),
9642                description: media.description.clone(),
9643                uploaded_by: media.uploaded_by,
9644                collection_id: media.collection_id,
9645                focal_point_x: None,
9646                focal_point_y: None,
9647                uploaded_at: Auto::Unset,
9648            };
9649            clone.insert_pool(tenant.pool()).await?;
9650            let new_id = clone.id.get().copied().unwrap_or_default();
9651            let new_id_str = new_id.to_string();
9652            let crop_w = form.crop_w.to_string();
9653            let crop_h = form.crop_h.to_string();
9654            redirect_named_with_params_and_message_args(
9655                "rcms-admin:media:edit",
9656                &[("id", new_id.to_string())],
9657                MsgLevel::Success,
9658                "Saved cropped clone as new media #{id} ({width}×{height}).",
9659                &[
9660                    ("id", new_id_str.as_str()),
9661                    ("width", crop_w.as_str()),
9662                    ("height", crop_h.as_str()),
9663                ],
9664                &headers,
9665            )
9666        }
9667        other => Err(AdminError::Validation(format!(
9668            "Unknown crop mode `{other}` — expected `apply` or `clone`."
9669        ))),
9670    }
9671}
9672
9673// =====================================================================
9674// Image replace (#190)
9675// =====================================================================
9676
9677/// POST /cms-admin/media/{id}/replace — re-upload bytes for an existing
9678/// media row. Keeps the row id (so every page that references it stays
9679/// linked) and the editorial metadata (title, alt_text). Updates the
9680/// physical fields: storage_key, content_hash, mime, size, width,
9681/// height, filename. Focal point survives unless the new dimensions
9682/// require it to be clamped — it's stored as a 0..1 fraction so it
9683/// already scales across resizes.
9684///
9685/// Old on-disk bytes are best-effort deleted; every cached rendition
9686/// for the old content_hash is purged so subsequent requests
9687/// regenerate from the replacement.
9688pub async fn media_replace_submit(
9689    State(_state): State<super::AdminState>,
9690    tenant: Tenant,
9691    headers: HeaderMap,
9692    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9693    Path(id): Path<i64>,
9694    mut multipart: axum::extract::Multipart,
9695) -> Result<Response, AdminError> {
9696    use sha2::{Digest, Sha256};
9697
9698    let mut media = Media::objects()
9699        .where_(Media::id.eq(id))
9700        .first(tenant.pool())
9701        .await?
9702        .ok_or(AdminError::NotFound(id))?;
9703
9704    let mut filename = String::new();
9705    let mut bytes: Vec<u8> = Vec::new();
9706    while let Some(field) = multipart
9707        .next_field()
9708        .await
9709        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
9710    {
9711        if field.name().unwrap_or("") == "file" {
9712            if let Some(fname) = field.file_name() {
9713                filename = sanitize_filename(fname);
9714            }
9715            bytes = field
9716                .bytes()
9717                .await
9718                .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
9719                .to_vec();
9720        } else {
9721            let _ = field.bytes().await;
9722        }
9723    }
9724    if filename.is_empty() || bytes.is_empty() {
9725        return Err(AdminError::Upload("no file submitted".into()));
9726    }
9727
9728    let new_mime = mime_guess::from_path(&filename)
9729        .first_or_octet_stream()
9730        .essence_str()
9731        .to_owned();
9732    refuse_active_upload(&new_mime)?;
9733    // Replacing an image with a non-image (or vice versa) would
9734    // silently break every consumer that branches on `kind`.
9735    let new_kind = Media::classify_mime(&new_mime).to_owned();
9736    if new_kind != media.kind {
9737        return Err(AdminError::Validation(format!(
9738            "Replacement kind `{new_kind}` does not match existing `{}` — replace must keep the media type.",
9739            media.kind
9740        )));
9741    }
9742
9743    // EXIF strip + decode for dimensions, same as the upload path.
9744    let (stored, decoded_dims) =
9745        crate::rendition::strip_exif_off_runtime(bytes, new_mime.clone()).await;
9746    bytes = stored;
9747
9748    let mut hasher = Sha256::new();
9749    hasher.update(&bytes);
9750    let digest = hasher.finalize();
9751    let new_hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
9752        use std::fmt::Write as _;
9753        let _ = write!(acc, "{b:02x}");
9754        acc
9755    });
9756
9757    let new_storage_key = format!("{}-{}", &new_hash[..16.min(new_hash.len())], filename);
9758    crate::media_storage::disk_for(&tenant.org.slug)
9759        .save(
9760            &crate::media_storage::key(&tenant.org.slug, &new_storage_key),
9761            &bytes,
9762        )
9763        .await
9764        .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
9765
9766    let old_storage_key = media.storage_key.clone();
9767    let old_hash = media.content_hash.clone();
9768
9769    let (new_w, new_h): (Option<i32>, Option<i32>) = decoded_dims
9770        .map(|(w, h)| (Some(w as i32), Some(h as i32)))
9771        .unwrap_or((None, None));
9772
9773    media.filename = filename;
9774    media.storage_key = new_storage_key;
9775    media.content_hash = new_hash;
9776    media.mime = new_mime;
9777    media.size = bytes.len() as i64;
9778    media.width = new_w;
9779    media.height = new_h;
9780    media.save_pool(tenant.pool()).await?;
9781
9782    // Best-effort cleanup of the old file on disk. Only remove when
9783    // the storage_key actually changed — content-addressed naming
9784    // means an identical replacement reuses the same path.
9785    if old_storage_key != media.storage_key {
9786        crate::media_storage::disk_for(&tenant.org.slug)
9787            .delete(&crate::media_storage::key(
9788                &tenant.org.slug,
9789                &old_storage_key,
9790            ))
9791            .await
9792            .log_warn("stored file not deleted; the blob is orphaned");
9793    }
9794
9795    // Purge renditions for the old content_hash so the next request
9796    // regenerates from the replacement bytes.
9797    if old_hash != media.content_hash {
9798        for r in crate::rendition::MediaRendition::objects()
9799            .where_(crate::rendition::MediaRendition::content_hash.eq(old_hash))
9800            .fetch(tenant.pool())
9801            .await?
9802        {
9803            crate::media_storage::disk_for(&tenant.org.slug)
9804                .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
9805                .await
9806                .log_warn("stored file not deleted; the blob is orphaned");
9807            r.delete_pool(tenant.pool()).await?;
9808        }
9809    }
9810
9811    redirect_named_with_params_and_message(
9812        "rcms-admin:media:edit",
9813        &[("id", id.to_string())],
9814        MsgLevel::Success,
9815        "Replaced. Old renditions purged; every page referencing this image now serves the new bytes.",
9816        &headers,
9817    )
9818}
9819
9820// =====================================================================
9821// Image focal point (#4)
9822// =====================================================================
9823
9824/// GET /cms-admin/media/{id}/edit — image detail page with the
9825/// focal-point picker. Image-only; other kinds return 404.
9826/// Locate every page that references `media_id`. Returns
9827/// `(page_id, page_title, url_path, status)` rows. Scan reuses the
9828/// `harvest_media_ids` helper that powers `media_unused_report`,
9829/// inverted so we collect per-page hits instead of building a
9830/// tenant-wide used-set.
9831async fn pages_referencing_media(
9832    pool: &rustango::sql::Pool,
9833    media_id: i64,
9834) -> Result<Vec<(i64, String, String, String)>, rustango::sql::ExecError> {
9835    let pages: Vec<Page> = Page::objects().fetch(pool).await?;
9836    let mut hits: Vec<(i64, String, String, String)> = Vec::new();
9837    for p in &pages {
9838        let page_id = p.id.get().copied().unwrap_or_default();
9839        if page_id == 0 {
9840            continue;
9841        }
9842        let mut ids = std::collections::BTreeSet::new();
9843        // Walk the canonical page JSON first (defensive).
9844        if let Ok(v) = serde_json::to_value(p) {
9845            harvest_media_ids(&v, &mut ids);
9846        }
9847        // Walk the page-type extension JSON (hero_media_id +
9848        // stream-block image refs).
9849        if let Ok(pts) = PageType::objects()
9850            .where_(PageType::id.eq(p.page_type_id))
9851            .fetch(pool)
9852            .await
9853        {
9854            if let Some(pt_row) = pts.into_iter().next() {
9855                if let Some(handler) = crate::page_type::find_handler(&pt_row.type_name) {
9856                    if let Ok(ext) = handler.load_extension(pool, page_id).await {
9857                        harvest_media_ids(&ext, &mut ids);
9858                    }
9859                }
9860            }
9861        }
9862        if ids.contains(&media_id) {
9863            hits.push((
9864                page_id,
9865                p.title.clone(),
9866                p.url_path.clone(),
9867                p.status.clone(),
9868            ));
9869        }
9870    }
9871    Ok(hits)
9872}
9873
9874pub async fn media_edit_form(
9875    State(state): State<super::AdminState>,
9876    tenant: Tenant,
9877    headers: HeaderMap,
9878    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9879    Path(id): Path<i64>,
9880) -> Result<Response, AdminError> {
9881    let media = Media::objects()
9882        .where_(Media::id.eq(id))
9883        .first(tenant.pool())
9884        .await?
9885        .ok_or(AdminError::NotFound(id))?;
9886    if media.kind != "image" {
9887        return Err(AdminError::NotFound(id));
9888    }
9889    // #100 — per-image usage report.
9890    let usages = pages_referencing_media(tenant.pool(), id)
9891        .await
9892        .unwrap_or_default();
9893    let usage_rows: Vec<serde_json::Value> = usages
9894        .iter()
9895        .map(|(pid, title, url_path, status)| {
9896            serde_json::json!({
9897                "id": pid,
9898                "title": title,
9899                "url_path": url_path,
9900                "status": status,
9901            })
9902        })
9903        .collect();
9904    let mut ctx = Context::new();
9905    add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
9906    add_admin_theme(&mut ctx, tenant.pool()).await;
9907    ctx.insert(
9908        "media",
9909        &serde_json::json!({
9910            "id": media.id.get().copied(),
9911            "title": media.title,
9912            "filename": media.filename,
9913            "alt_text": media.alt_text,
9914            "description": media.description,
9915            "mime": media.mime,
9916            "size": media.size,
9917            "width": media.width,
9918            "height": media.height,
9919            "focal_point_x": media.focal_point_x,
9920            "focal_point_y": media.focal_point_y,
9921            "uploaded_at": media.uploaded_at.get().copied(),
9922            // Cache-buster for the `rcms_image_url(..., v=media.content_hash)`
9923            // call in the template — without this the focal-point
9924            // preview never picks up an in-place re-crop.
9925            "content_hash": media.content_hash,
9926        }),
9927    );
9928    ctx.insert("usages", &usage_rows);
9929    ctx.insert("usage_count", &(usage_rows.len() as i64));
9930    render_with_csrf(&state, &headers, "rcms_admin/media_edit.html", &mut ctx)
9931}
9932
9933/// Form payload for the focal-point editor. All four fields
9934/// arrive as strings from the HTML form; we parse + validate
9935/// server-side. A submission with empty x/y clears the focal point.
9936#[derive(Debug, Deserialize)]
9937pub struct MediaEditForm {
9938    pub title: String,
9939    pub alt_text: String,
9940    #[serde(default)]
9941    pub description: String,
9942    #[serde(default)]
9943    pub focal_point_x: Option<String>,
9944    #[serde(default)]
9945    pub focal_point_y: Option<String>,
9946}
9947
9948/// POST /cms-admin/media/{id}/edit — save title / alt + focal point.
9949/// When the focal point changes, every cached rendition for this
9950/// media row is purged so subsequent requests regenerate around the
9951/// new center.
9952pub async fn media_edit_submit(
9953    State(_state): State<super::AdminState>,
9954    tenant: Tenant,
9955    headers: HeaderMap,
9956    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9957    Path(id): Path<i64>,
9958    Form(form): Form<MediaEditForm>,
9959) -> Result<Response, AdminError> {
9960    let mut media = Media::objects()
9961        .where_(Media::id.eq(id))
9962        .first(tenant.pool())
9963        .await?
9964        .ok_or(AdminError::NotFound(id))?;
9965    if media.kind != "image" {
9966        return Err(AdminError::NotFound(id));
9967    }
9968    media.title = form.title.trim().to_owned();
9969    media.alt_text = form.alt_text.trim().to_owned();
9970    media.description = form.description.trim().to_owned();
9971
9972    let parse_fraction = |raw: Option<&str>| -> Option<f32> {
9973        raw.map(str::trim)
9974            .filter(|s| !s.is_empty())
9975            .and_then(|s| s.parse::<f32>().ok())
9976            .map(|f| f.clamp(0.0, 1.0))
9977    };
9978    let new_x = parse_fraction(form.focal_point_x.as_deref());
9979    let new_y = parse_fraction(form.focal_point_y.as_deref());
9980    let focal_changed = media.focal_point_x != new_x || media.focal_point_y != new_y;
9981    media.focal_point_x = new_x;
9982    media.focal_point_y = new_y;
9983    media.save_pool(tenant.pool()).await?;
9984
9985    // Invalidate rendition cache rows + delete their on-disk bytes
9986    // so subsequent requests regenerate with the new focal point.
9987    if focal_changed {
9988        let renditions: Vec<crate::rendition::MediaRendition> =
9989            crate::rendition::MediaRendition::objects()
9990                .where_(
9991                    crate::rendition::MediaRendition::content_hash.eq(media.content_hash.clone()),
9992                )
9993                .fetch(tenant.pool())
9994                .await?;
9995        for r in renditions {
9996            // Best-effort delete of the on-disk bytes; the DB row
9997            // delete is what counts (next render miss regenerates).
9998            crate::media_storage::disk_for(&tenant.org.slug)
9999                .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
10000                .await
10001                .log_warn("stored file not deleted; the blob is orphaned");
10002            r.delete_pool(tenant.pool()).await?;
10003        }
10004    }
10005    redirect_named_with_params_and_message(
10006        "rcms-admin:media:edit",
10007        &[("id", id.to_string())],
10008        MsgLevel::Success,
10009        if focal_changed {
10010            "Saved. Renditions purged — next request regenerates with the new focal point."
10011        } else {
10012            "Saved."
10013        },
10014        &headers,
10015    )
10016}
10017
10018/// Recursively scan a JSON value for any string that contains
10019/// `needle` (already lowercased). Used by admin search to
10020/// broaden recall into page-type extension fields without listing
10021/// every key on the handler trait.
10022fn json_contains_needle(value: &serde_json::Value, needle: &str) -> bool {
10023    match value {
10024        serde_json::Value::String(s) => {
10025            if s.to_lowercase().contains(needle) {
10026                return true;
10027            }
10028            // Stream-block extension columns sometimes hold a JSON
10029            // array as a string — peek through if it looks like one.
10030            let trimmed = s.trim_start();
10031            if trimmed.starts_with('[') || trimmed.starts_with('{') {
10032                if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(s) {
10033                    return json_contains_needle(&parsed, needle);
10034                }
10035            }
10036            false
10037        }
10038        serde_json::Value::Array(arr) => arr.iter().any(|v| json_contains_needle(v, needle)),
10039        serde_json::Value::Object(map) => map.values().any(|v| json_contains_needle(v, needle)),
10040        _ => false,
10041    }
10042}
10043
10044/// Recursively walk `value` (the JSON shape of a page's extension
10045/// row, plus any nested stream-block JSON we find as string values)
10046/// and collect every `media_id` reference. Catches:
10047///
10048/// - Direct `media_id` / `hero_media_id` / `*_media_id` fields on
10049///   the extension table (any object key matching `media_id` or
10050///   ending in `_media_id`).
10051/// - Stream-block image references: extension rows store the
10052///   `body_stream` column as a JSON string; we detect string values
10053///   that look like JSON and recurse into the parsed array.
10054/// - IDs stored as numbers OR strings — HTML forms submit text, so
10055///   stream-block `media_id` values land as strings in the JSON.
10056fn harvest_media_ids(value: &serde_json::Value, out: &mut std::collections::BTreeSet<i64>) {
10057    use serde_json::Value;
10058    match value {
10059        Value::Object(map) => {
10060            for (key, child) in map {
10061                let is_media_key = key == "media_id" || key.ends_with("_media_id");
10062                if is_media_key {
10063                    match child {
10064                        Value::Number(n) => {
10065                            if let Some(id) = n.as_i64() {
10066                                if id > 0 {
10067                                    out.insert(id);
10068                                }
10069                            }
10070                        }
10071                        Value::String(s) => {
10072                            if let Ok(id) = s.parse::<i64>() {
10073                                if id > 0 {
10074                                    out.insert(id);
10075                                }
10076                            }
10077                        }
10078                        _ => harvest_media_ids(child, out),
10079                    }
10080                } else {
10081                    harvest_media_ids(child, out);
10082                }
10083            }
10084        }
10085        Value::Array(arr) => {
10086            for item in arr {
10087                harvest_media_ids(item, out);
10088            }
10089        }
10090        Value::String(s) => {
10091            let trimmed = s.trim_start();
10092            if trimmed.starts_with('[') || trimmed.starts_with('{') {
10093                if let Ok(parsed) = serde_json::from_str::<Value>(s) {
10094                    harvest_media_ids(&parsed, out);
10095                }
10096            }
10097        }
10098        _ => {}
10099    }
10100}
10101
10102/// GET /cms-admin/media/unused — list `cms_media` rows that no page
10103/// references. Builds a reverse index by walking every page's
10104/// extension JSON for `media_id` keys, then diffs against the full
10105/// media table. Used by editors to garbage-collect stale uploads.
10106pub async fn media_unused_report(
10107    State(state): State<super::AdminState>,
10108    tenant: Tenant,
10109    headers: HeaderMap,
10110    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10111) -> Result<Response, AdminError> {
10112    let all_media: Vec<Media> = Media::objects()
10113        .order_by(&[("uploaded_at", true)])
10114        .fetch(tenant.pool())
10115        .await?;
10116    let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
10117
10118    let mut used: std::collections::BTreeSet<i64> = std::collections::BTreeSet::new();
10119
10120    // 1) Page rows themselves carry no media_id columns today, but
10121    //    we walk the JSON-serialized page anyway for defense-in-depth
10122    //    — a future column would auto-surface.
10123    for p in &pages {
10124        if let Ok(v) = serde_json::to_value(p) {
10125            harvest_media_ids(&v, &mut used);
10126        }
10127    }
10128
10129    // 2) Extension rows: every PageType handler loads its own
10130    //    extension row. The default impl returns Value::Null for
10131    //    unit-struct types; ours returns the row as JSON (including
10132    //    body_stream as a string we recurse into).
10133    for p in &pages {
10134        let page_id = p.id.get().copied().unwrap_or_default();
10135        // Resolve the PageType row → type_name → handler.
10136        // page_type lookup is cheap; tenants have a handful of types.
10137        let pt: Vec<crate::page_type_model::PageType> = crate::page_type_model::PageType::objects()
10138            .where_(crate::page_type_model::PageType::id.eq(p.page_type_id))
10139            .fetch(tenant.pool())
10140            .await?;
10141        let Some(pt_row) = pt.into_iter().next() else {
10142            continue;
10143        };
10144        let Some(handler) = crate::page_type::find_handler(&pt_row.type_name) else {
10145            continue;
10146        };
10147        if let Ok(ext_value) = handler.load_extension(tenant.pool(), page_id).await {
10148            harvest_media_ids(&ext_value, &mut used);
10149        }
10150    }
10151
10152    // 3) Diff: media rows whose ID isn't in the used set are unused.
10153    let unused: Vec<&Media> = all_media
10154        .iter()
10155        .filter(|m| m.id.get().copied().is_some_and(|id| !used.contains(&id)))
10156        .collect();
10157
10158    let unused_view: Vec<serde_json::Value> = unused
10159        .iter()
10160        .map(|m| {
10161            serde_json::json!({
10162                "id": m.id.get().copied(),
10163                "title": m.title,
10164                "filename": m.filename,
10165                "kind": m.kind,
10166                "mime": m.mime,
10167                "size": m.size,
10168                "uploaded_at": m.uploaded_at.get().copied(),
10169                "uploaded_by": m.uploaded_by,
10170            })
10171        })
10172        .collect();
10173
10174    let mut ctx = Context::new();
10175    add_chrome(&mut ctx, &tenant, "media-unused", session_user.as_ref()).await;
10176    add_admin_theme(&mut ctx, tenant.pool()).await;
10177    ctx.insert("unused", &unused_view);
10178    ctx.insert("total_media", &all_media.len());
10179    ctx.insert("used_count", &used.len());
10180    render_with_csrf(&state, &headers, "rcms_admin/media_unused.html", &mut ctx)
10181}
10182
10183/// POST /cms-admin/media/unused/delete — bulk-delete the chosen
10184/// media rows. Receives a list of `id=N` form fields and deletes
10185/// each in sequence. The handler does NOT re-verify "unused" status
10186/// — that's the editor's job — but it stays well-behaved because
10187/// the form template only renders rows that ARE currently unused.
10188pub async fn media_unused_bulk_delete(
10189    State(_state): State<super::AdminState>,
10190    tenant: Tenant,
10191    headers: HeaderMap,
10192    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
10193    Form(form): Form<Vec<(String, String)>>,
10194) -> Result<Response, AdminError> {
10195    use rustango::sql::Auto;
10196    let ids: Vec<i64> = form
10197        .iter()
10198        .filter(|(k, _)| k == "id" || k == "ids")
10199        .filter_map(|(_, v)| v.parse::<i64>().ok())
10200        .collect();
10201    let mut deleted = 0usize;
10202    for id in ids {
10203        let row = Media::objects()
10204            .where_(Media::id.eq(id))
10205            .first(tenant.pool())
10206            .await?;
10207        if let Some(m) = row {
10208            // Use Model::delete_pool via the row instance.
10209            // The framework's Auto wrapper holds the id; deletion
10210            // through the row resolves it cleanly.
10211            let _ = Auto::Unset::<i64>; // silence unused-import lint
10212            m.delete_pool(tenant.pool()).await?;
10213            deleted += 1;
10214        }
10215    }
10216    redirect_named_with_message_plural(
10217        "rcms-admin:media:unused",
10218        MsgLevel::Success,
10219        "Deleted {count} unused media item(s).",
10220        deleted as i64,
10221        &[("count", &deleted.to_string())],
10222        &headers,
10223    )
10224}
10225
10226/// GET /cms-admin/media — list `cms_media` rows where `kind = 'image'`.
10227pub async fn media_list(
10228    State(state): State<super::AdminState>,
10229    tenant: Tenant,
10230    headers: HeaderMap,
10231    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10232    Query(q): Query<MediaListQuery>,
10233    axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
10234) -> Result<Response, AdminError> {
10235    // #142 — opportunistic scratch-upload sweep. Roughly 2% of
10236    // media-list visits trigger a stale-row GC so dead scratch uploads
10237    // don't accumulate. Best-effort: file unlink errors log + continue.
10238    if rand::random::<u8>() < 5 {
10239        if let Ok(unlinked) = crate::uploaded_file::gc_stale(tenant.pool()).await {
10240            for key in unlinked {
10241                crate::media_storage::disk_for(&tenant.org.slug)
10242                    .delete(&crate::media_storage::key(&tenant.org.slug, &key))
10243                    .await
10244                    .log_warn("stored file not deleted; the blob is orphaned");
10245            }
10246        }
10247    }
10248    render_media_list(
10249        &state,
10250        &tenant,
10251        &headers,
10252        session_user.as_ref(),
10253        "image",
10254        q,
10255        raw_query,
10256    )
10257    .await
10258}
10259
10260/// GET /cms-admin/documents — same view filtered to non-image kinds.
10261pub async fn documents_list(
10262    State(state): State<super::AdminState>,
10263    tenant: Tenant,
10264    headers: HeaderMap,
10265    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10266    Query(q): Query<MediaListQuery>,
10267    axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
10268) -> Result<Response, AdminError> {
10269    render_media_list(
10270        &state,
10271        &tenant,
10272        &headers,
10273        session_user.as_ref(),
10274        "document",
10275        q,
10276        raw_query,
10277    )
10278    .await
10279}
10280
10281/// Shared list renderer for the image / document views. `kind` is
10282/// the discriminator on `cms_media.kind` ("image" / "document").
10283async fn render_media_list(
10284    state: &super::AdminState,
10285    tenant: &Tenant,
10286    headers: &HeaderMap,
10287    session_user: Option<&rustango::tenancy::auth::User>,
10288    kind: &str,
10289    filters: MediaListQuery,
10290    raw_query: Option<String>,
10291) -> Result<Response, AdminError> {
10292    let collection_filter = filters.collection;
10293    let search = filters
10294        .q
10295        .as_deref()
10296        .map(str::trim)
10297        .filter(|s| !s.is_empty())
10298        .map(str::to_lowercase);
10299    let from_filter = parse_date_floor(filters.from.as_deref());
10300    let to_filter = parse_date_ceil(filters.to.as_deref());
10301    // Fetch every media row + every collection once. Collection
10302    // count is small (a handful per tenant); media count is bounded
10303    // by what fits comfortably in the admin list. Walk in Rust.
10304    let all: Vec<Media> = Media::objects()
10305        .order_by(&[("uploaded_at", true)])
10306        .fetch(tenant.pool())
10307        .await?;
10308    let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
10309        .order_by(&[("sort_order", false), ("name", false)])
10310        .fetch(tenant.pool())
10311        .await?;
10312
10313    let items: Vec<&Media> = all
10314        .iter()
10315        .filter(|m| {
10316            let kind_match = if kind == "image" {
10317                m.kind == "image"
10318            } else {
10319                m.kind != "image"
10320            };
10321            let collection_match = match collection_filter {
10322                None => true,
10323                Some(cid) => m.collection_id == Some(cid),
10324            };
10325            let search_match = match &search {
10326                None => true,
10327                Some(needle) => {
10328                    m.title.to_lowercase().contains(needle)
10329                        || m.filename.to_lowercase().contains(needle)
10330                        || m.alt_text.to_lowercase().contains(needle)
10331                }
10332            };
10333            let date_match = m.uploaded_at.get().is_none_or(|when| {
10334                let after_from = from_filter.is_none_or(|floor| *when >= floor);
10335                let before_to = to_filter.is_none_or(|ceil| *when <= ceil);
10336                after_from && before_to
10337            });
10338            kind_match && collection_match && search_match && date_match
10339        })
10340        .collect();
10341
10342    // Paginate the filtered set, so a large library renders one page of
10343    // cards and thumbnails. The fetch above is still unbounded: filtering
10344    // happens in Rust so the case-insensitive search behaves the same on
10345    // SQLite, Postgres and MySQL (bare LIKE does not) — see #632.
10346    let per_page = crate::admin::pagination::clamp_per_page(filters.per_page);
10347    let requested_page = filters.page.unwrap_or(1);
10348    let total_items = items.len();
10349    let pagination = crate::admin::pagination::context(requested_page, per_page, total_items);
10350    let current_page = pagination["page"].as_i64().unwrap_or(1);
10351    let skip = crate::admin::pagination::offset(current_page, per_page) as usize;
10352    let items: Vec<&Media> = items.into_iter().skip(skip).take(per_page).collect();
10353
10354    // Count per collection so the sidebar shows "(N)" beside each
10355    // name. We count for the CURRENT kind only so the badges line
10356    // up with the filtered view the editor is looking at.
10357    let mut counts: std::collections::HashMap<Option<i64>, i64> = std::collections::HashMap::new();
10358    for m in &all {
10359        let in_kind = if kind == "image" {
10360            m.kind == "image"
10361        } else {
10362            m.kind != "image"
10363        };
10364        if in_kind {
10365            *counts.entry(m.collection_id).or_insert(0) += 1;
10366        }
10367    }
10368
10369    let collections_view: Vec<serde_json::Value> = collections
10370        .iter()
10371        .map(|c| {
10372            let id = c.id.get().copied();
10373            serde_json::json!({
10374                "id": id,
10375                "name": c.name,
10376                "parent_id": c.parent_id,
10377                "count": id.and_then(|i| counts.get(&Some(i)).copied()).unwrap_or(0),
10378            })
10379        })
10380        .collect();
10381    let uncategorized_count = counts.get(&None).copied().unwrap_or(0);
10382
10383    let mut ctx = Context::new();
10384    let active_tab = if kind == "image" {
10385        "media"
10386    } else {
10387        "documents"
10388    };
10389    add_chrome(&mut ctx, tenant, active_tab, session_user).await;
10390    add_admin_theme(&mut ctx, tenant.pool()).await;
10391    ctx.insert("items", &items);
10392    ctx.insert("collections", &collections_view);
10393    ctx.insert("collection_filter", &collection_filter);
10394    ctx.insert("uncategorized_count", &uncategorized_count);
10395    ctx.insert("search_q", &filters.q);
10396    ctx.insert("date_from", &filters.from);
10397    ctx.insert("date_to", &filters.to);
10398    ctx.insert(
10399        "is_filtered",
10400        &(collection_filter.is_some()
10401            || search.is_some()
10402            || from_filter.is_some()
10403            || to_filter.is_some()),
10404    );
10405    // The full match count, not the size of the visible page.
10406    ctx.insert("filtered_count", &total_items);
10407    ctx.insert("pagination", &pagination);
10408    ctx.insert(
10409        "kind_label",
10410        if kind == "image" {
10411            "Media (images)"
10412        } else {
10413            "Documents"
10414        },
10415    );
10416    ctx.insert(
10417        "upload_kind",
10418        if kind == "image" { "image" } else { "document" },
10419    );
10420    ctx.insert(
10421        "self_url",
10422        if kind == "image" {
10423            "/cms-admin/media"
10424        } else {
10425            "/cms-admin/documents"
10426        },
10427    );
10428    // #316 — raw query string for the `| querystring(collection=…)` rail
10429    // links: they preserve the q / from / to filters and just set or
10430    // clear `collection` (media has no page param). `qs_none` is a null
10431    // sentinel — Tera has no `null` literal, so `querystring(k=qs_none)`
10432    // is how the template drops a key.
10433    ctx.insert("query_string", &raw_query.unwrap_or_default());
10434    ctx.insert("qs_none", &serde_json::Value::Null);
10435    render_with_csrf(state, headers, "rcms_admin/media_list.html", &mut ctx)
10436}
10437
10438/// GET /cms-admin/media/upload — upload form.
10439pub async fn media_upload_form(
10440    State(state): State<super::AdminState>,
10441    tenant: Tenant,
10442    headers: HeaderMap,
10443    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10444    Query(q): Query<UploadFormQuery>,
10445) -> Result<Response, AdminError> {
10446    let kind_label = if q.kind.as_deref() == Some("document") {
10447        "Documents"
10448    } else {
10449        "Media (images)"
10450    };
10451    let mut ctx = Context::new();
10452    add_chrome(
10453        &mut ctx,
10454        &tenant,
10455        if q.kind.as_deref() == Some("document") {
10456            "documents"
10457        } else {
10458            "media"
10459        },
10460        session_user.as_ref(),
10461    )
10462    .await;
10463    // Collections picker (#188) — pass into ctx so each queue row
10464    // can render a per-file dropdown without a follow-up fetch.
10465    let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
10466        .order_by(&[("sort_order", false), ("name", false)])
10467        .fetch(tenant.pool())
10468        .await?;
10469    let collections_view: Vec<serde_json::Value> = collections
10470        .iter()
10471        .map(|c| {
10472            serde_json::json!({
10473                "id": c.id.get().copied(),
10474                "name": c.name,
10475            })
10476        })
10477        .collect();
10478    ctx.insert("collections", &collections_view);
10479    ctx.insert("kind_label", kind_label);
10480    ctx.insert("upload_kind", &q.kind.as_deref().unwrap_or("image"));
10481    render_with_csrf(&state, &headers, "rcms_admin/media_upload.html", &mut ctx)
10482}
10483
10484#[derive(Debug, Deserialize)]
10485pub struct UploadFormQuery {
10486    #[serde(default)]
10487    pub kind: Option<String>,
10488}
10489
10490/// POST /cms-admin/media/upload — accept a multipart upload, hash
10491/// the bytes, drop them through the tenant `Storage` backend, and
10492/// stamp a `cms_media` row.
10493/// POST /cms-admin/media/upload-staged — write bytes to scratch
10494/// storage + return JSON `{id, filename, mime, size}`.
10495/// Returned `id` is the [`crate::uploaded_file::UploadedFile`]
10496/// row to commit / cancel later.
10497///
10498/// Coexists with the existing single-step `media_upload_submit` — that
10499/// path keeps working unchanged. Use this endpoint for future
10500/// drag-drop / multi-file UIs where bytes need to land before
10501/// metadata is collected.
10502pub async fn media_upload_staged(
10503    State(_state): State<super::AdminState>,
10504    tenant: Tenant,
10505    headers: HeaderMap,
10506    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10507    mut multipart: axum::extract::Multipart,
10508) -> Result<Response, AdminError> {
10509    use sha2::{Digest, Sha256};
10510    let Some(viewer) = session_user.as_ref() else {
10511        // #285 — XHR/fetch clients (the multi-file upload UI) used to
10512        // get the raw HTML page injected into a toast on session
10513        // expiry. Pass the request headers so the responder returns
10514        // JSON when the client sent `Accept: application/json` or
10515        // `X-Requested-With: XMLHttpRequest`.
10516        return Ok(unauthorized_no_session_for(Some(&headers)));
10517    };
10518    let viewer_id = viewer.id.get().copied().unwrap_or_default();
10519    let mut filename = String::new();
10520    let mut bytes: Vec<u8> = Vec::new();
10521    while let Some(field) = multipart
10522        .next_field()
10523        .await
10524        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
10525    {
10526        if field.name().unwrap_or("") == "file" {
10527            if let Some(fname) = field.file_name() {
10528                filename = sanitize_filename(fname);
10529            }
10530            bytes = field
10531                .bytes()
10532                .await
10533                .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
10534                .to_vec();
10535        } else {
10536            let _ = field.bytes().await;
10537        }
10538    }
10539    if filename.is_empty() || bytes.is_empty() {
10540        return Err(AdminError::Upload("no file submitted".into()));
10541    }
10542    let mut hasher = Sha256::new();
10543    hasher.update(&bytes);
10544    let digest = hasher.finalize();
10545    let hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
10546        use std::fmt::Write as _;
10547        let _ = write!(acc, "{b:02x}");
10548        acc
10549    });
10550    let mime = mime_guess::from_path(&filename)
10551        .first_or_octet_stream()
10552        .essence_str()
10553        .to_owned();
10554    refuse_active_upload(&mime)?;
10555    // #284 — dedup by content hash. If this tenant already has a
10556    // cms_media row whose `content_hash` matches the bytes the
10557    // editor just uploaded, skip writing to scratch + creating a
10558    // new UploadedFile row. The client treats the response as a
10559    // "skipped" outcome and surfaces it as a toast linking back to
10560    // the existing media row. Per-tenant query — the
10561    // `tenant.pool()` is the tenant-scoped pool, so a hash that
10562    // collides across tenants doesn't dedup across the boundary.
10563    {
10564        use rustango::core::Column as _;
10565        use rustango::sql::FetcherPool as _;
10566        let existing: Vec<crate::media::Media> = crate::media::Media::objects()
10567            .where_(crate::media::Media::content_hash.eq(hash.clone()))
10568            .fetch(tenant.pool())
10569            .await
10570            .unwrap_or_default();
10571        if let Some(existing_media) = existing.into_iter().next() {
10572            let existing_id = existing_media.id.get().copied().unwrap_or_default();
10573            let payload = serde_json::json!({
10574                "id": null,
10575                "duplicate_of": existing_id,
10576                "duplicate_title": existing_media.title,
10577                "duplicate_filename": existing_media.filename,
10578                "filename": filename,
10579                "mime": existing_media.mime,
10580                "size": existing_media.size,
10581            });
10582            return Ok((
10583                [(axum::http::header::CONTENT_TYPE, "application/json")],
10584                serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
10585            )
10586                .into_response());
10587        }
10588    }
10589    let storage_key = format!("scratch/{}-{filename}", &hash[..16]);
10590    crate::media_storage::disk_for(&tenant.org.slug)
10591        .save(
10592            &crate::media_storage::key(&tenant.org.slug, &storage_key),
10593            &bytes,
10594        )
10595        .await
10596        .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
10597    let size = bytes.len() as i64;
10598    let row = crate::uploaded_file::create(
10599        tenant.pool(),
10600        viewer_id,
10601        storage_key,
10602        filename,
10603        mime,
10604        size,
10605        hash,
10606    )
10607    .await?;
10608    let payload = serde_json::json!({
10609        "id": row.id.get().copied().unwrap_or_default(),
10610        "filename": row.original_filename,
10611        "mime": row.mime,
10612        "size": row.size,
10613    });
10614    Ok((
10615        [(axum::http::header::CONTENT_TYPE, "application/json")],
10616        serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
10617    )
10618        .into_response())
10619}
10620
10621/// One entry in the [`StagedCommitPayload`] commit grid.
10622#[derive(Debug, Deserialize)]
10623pub struct StagedCommitItem {
10624    pub uploaded_file_id: i64,
10625    #[serde(default)]
10626    pub title: String,
10627    #[serde(default)]
10628    pub alt_text: String,
10629    #[serde(default)]
10630    pub collection_id: Option<i64>,
10631}
10632
10633/// Body of `POST /cms-admin/media/upload-staged/commit`. The
10634/// editor uploaded N files into scratch storage; now this payload
10635/// names each scratch row + its editorial metadata in one
10636/// transaction-equivalent call.
10637#[derive(Debug, Deserialize)]
10638pub struct StagedCommitPayload {
10639    pub items: Vec<StagedCommitItem>,
10640}
10641
10642/// POST /cms-admin/media/upload-staged/commit — promote staged rows
10643/// to `cms_media` with per-file metadata. Each item:
10644///
10645/// 1. Loads the scratch row.
10646/// 2. Re-reads bytes from the scratch path; EXIF-strips images.
10647/// 3. Moves the file out of `scratch/` to the canonical
10648///    `<hash>-<filename>` storage_key.
10649/// 4. Inserts a `cms_media` row.
10650/// 5. Deletes the scratch DB row + (best-effort) the scratch file.
10651///
10652/// On a per-item failure, that scratch row is left in place so the
10653/// editor can retry; successful items still commit. The response is
10654/// JSON `{ committed: [media_id...], failed: [{id, error}...] }`.
10655pub async fn media_upload_staged_commit(
10656    State(_state): State<super::AdminState>,
10657    tenant: Tenant,
10658    headers: HeaderMap,
10659    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10660    Json(payload): Json<StagedCommitPayload>,
10661) -> Result<Response, AdminError> {
10662    use rustango::sql::Auto;
10663    let Some(viewer) = session_user.as_ref() else {
10664        // #285 — JSON-aware 401 for fetch clients.
10665        return Ok(unauthorized_no_session_for(Some(&headers)));
10666    };
10667    let viewer_id = viewer.id.get().copied().unwrap_or_default();
10668    let media_slug = tenant.org.slug.clone();
10669
10670    let mut committed: Vec<i64> = Vec::new();
10671    let mut failed: Vec<serde_json::Value> = Vec::new();
10672
10673    for item in payload.items {
10674        let result: Result<i64, String> = async {
10675            let row = crate::uploaded_file::get(tenant.pool(), item.uploaded_file_id)
10676                .await
10677                .map_err(|e| format!("lookup: {e}"))?
10678                .ok_or_else(|| "scratch row missing".to_owned())?;
10679            if row.user_id != viewer_id && !viewer.is_superuser {
10680                return Err("not your upload".to_owned());
10681            }
10682
10683            let scratch_key = crate::media_storage::key(&media_slug, &row.storage_key);
10684            let mut bytes = crate::media_storage::disk_for(&media_slug)
10685                .load(&scratch_key)
10686                .await
10687                .map_err(|e| format!("read scratch: {e}"))?;
10688
10689            // EXIF-strip + decode for pixel dims. Mirrors upload path.
10690            let (stored, decoded_dims) =
10691                crate::rendition::strip_exif_off_runtime(bytes, row.mime.clone()).await;
10692            bytes = stored;
10693
10694            // Canonical storage_key under the tenant's media dir —
10695            // content-addressed prefix so renditions can find bytes
10696            // by hash without hitting the DB.
10697            let final_key = format!(
10698                "{}-{}",
10699                &row.content_hash[..16.min(row.content_hash.len())],
10700                row.original_filename
10701            );
10702            crate::media_storage::disk_for(&media_slug)
10703                .save(&crate::media_storage::key(&media_slug, &final_key), &bytes)
10704                .await
10705                .map_err(|e| format!("write final: {e}"))?;
10706
10707            let kind = Media::classify_mime(&row.mime).to_owned();
10708            let (width, height): (Option<i32>, Option<i32>) = decoded_dims
10709                .map(|(w, h)| (Some(w as i32), Some(h as i32)))
10710                .unwrap_or((None, None));
10711
10712            let title = if item.title.trim().is_empty() {
10713                row.original_filename
10714                    .rsplit_once('.')
10715                    .map(|(stem, _)| stem.to_owned())
10716                    .unwrap_or_else(|| row.original_filename.clone())
10717            } else {
10718                item.title.trim().to_owned()
10719            };
10720
10721            let mut media_row = Media {
10722                id: Auto::Unset,
10723                filename: row.original_filename.clone(),
10724                content_hash: row.content_hash.clone(),
10725                mime: row.mime.clone(),
10726                size: bytes.len() as i64,
10727                kind,
10728                width,
10729                height,
10730                storage_key: final_key,
10731                title,
10732                alt_text: item.alt_text.trim().to_owned(),
10733                description: String::new(),
10734                uploaded_by: Some(viewer_id),
10735                collection_id: item.collection_id,
10736                focal_point_x: None,
10737                focal_point_y: None,
10738                uploaded_at: Auto::Unset,
10739            };
10740            media_row
10741                .insert_pool(tenant.pool())
10742                .await
10743                .map_err(|e| format!("insert media: {e}"))?;
10744            let new_id = media_row.id.get().copied().unwrap_or_default();
10745
10746            // Best-effort scratch cleanup. Scratch file is a separate
10747            // path from the final storage_key (final lives outside
10748            // `scratch/`), so removing it is safe even when the bytes
10749            // are byte-identical.
10750            crate::media_storage::disk_for(&media_slug)
10751                .delete(&scratch_key)
10752                .await
10753                .log_warn("stored file not deleted; the blob is orphaned");
10754            crate::uploaded_file::delete(tenant.pool(), item.uploaded_file_id)
10755                .await
10756                .map_err(|e| format!("delete scratch: {e}"))?;
10757            Ok(new_id)
10758        }
10759        .await;
10760
10761        match result {
10762            Ok(id) => committed.push(id),
10763            Err(e) => {
10764                failed.push(serde_json::json!({
10765                    "uploaded_file_id": item.uploaded_file_id,
10766                    "error": e,
10767                }));
10768            }
10769        }
10770    }
10771
10772    let body = serde_json::json!({
10773        "committed": committed,
10774        "failed": failed,
10775    });
10776    Ok((
10777        [(axum::http::header::CONTENT_TYPE, "application/json")],
10778        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
10779    )
10780        .into_response())
10781}
10782
10783/// POST /cms-admin/media/upload-staged/{id}/cancel — drop scratch row
10784/// + unlink the file. Returns 204.
10785pub async fn media_upload_staged_cancel(
10786    State(_state): State<super::AdminState>,
10787    tenant: Tenant,
10788    headers: HeaderMap,
10789    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10790    Path(id): Path<i64>,
10791) -> Result<Response, AdminError> {
10792    let Some(viewer) = session_user.as_ref() else {
10793        // #285 — JSON-aware 401 for fetch clients.
10794        return Ok(unauthorized_no_session_for(Some(&headers)));
10795    };
10796    let viewer_id = viewer.id.get().copied().unwrap_or_default();
10797    let Some(row) = crate::uploaded_file::get(tenant.pool(), id).await? else {
10798        return Ok((axum::http::StatusCode::NOT_FOUND, "not found").into_response());
10799    };
10800    if row.user_id != viewer_id && !viewer.is_superuser {
10801        return Ok((axum::http::StatusCode::FORBIDDEN, "not your upload").into_response());
10802    }
10803    crate::media_storage::disk_for(&tenant.org.slug)
10804        .delete(&crate::media_storage::key(
10805            &tenant.org.slug,
10806            &row.storage_key,
10807        ))
10808        .await
10809        .log_warn("stored file not deleted; the blob is orphaned");
10810    crate::uploaded_file::delete(tenant.pool(), id).await?;
10811    Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
10812}
10813
10814/// Refuse a file a browser would run as a page: HTML, XHTML,
10815/// JavaScript and XML (which can carry script through XSLT or an XHTML
10816/// namespace). Serving neutralises every type already; this keeps such
10817/// files out of the library in the first place. SVG stays allowed — it is
10818/// served under a no-script CSP.
10819fn refuse_active_upload(mime: &str) -> Result<(), AdminError> {
10820    let active = matches!(
10821        mime,
10822        "text/html"
10823            | "application/xhtml+xml"
10824            | "text/javascript"
10825            | "application/javascript"
10826            | "application/ecmascript"
10827            | "text/xml"
10828            | "application/xml"
10829            | "text/xsl"
10830            | "application/xslt+xml"
10831    );
10832    if active {
10833        return Err(AdminError::Upload(format!(
10834            "files of type {mime} can't be uploaded: a browser would run them as a page"
10835        )));
10836    }
10837    Ok(())
10838}
10839
10840/// Store one media file: sanitize the name, detect + classify the mime,
10841/// strip EXIF from images, hash, write
10842/// storage key `<org_slug>/<hash16>-<name>`, and insert the `cms_media`
10843/// row. The single canonical write path — the browser upload handlers and
10844/// the MCP `upload_media` tool all funnel through here.
10845///
10846/// `dedupe = true` short-circuits on an existing row with the same
10847/// content hash (returns it instead of storing a byte-identical copy) —
10848/// the same behavior the staged-upload flow gives the browser.
10849#[allow(clippy::too_many_arguments)]
10850pub(crate) async fn store_media(
10851    pool: &rustango::sql::Pool,
10852    org_slug: &str,
10853    mut bytes: Vec<u8>,
10854    raw_filename: &str,
10855    title: Option<&str>,
10856    alt_text: &str,
10857    collection_id: Option<i64>,
10858    uploaded_by: Option<i64>,
10859    dedupe: bool,
10860) -> Result<Media, AdminError> {
10861    use rustango::sql::Auto;
10862    use sha2::{Digest, Sha256};
10863
10864    let filename = sanitize_filename(raw_filename);
10865    if filename.is_empty() || bytes.is_empty() {
10866        return Err(AdminError::Upload("no file submitted".into()));
10867    }
10868
10869    let mime = mime_guess::from_path(&filename)
10870        .first_or_octet_stream()
10871        .essence_str()
10872        .to_owned();
10873    refuse_active_upload(&mime)?;
10874    let kind = Media::classify_mime(&mime).to_owned();
10875
10876    // #184 — strip EXIF on image upload, BEFORE hashing so the hash
10877    // reflects the stored bytes. See `media_upload_submit` for the why.
10878    let (stored, decoded_dims) = crate::rendition::strip_exif_off_runtime(bytes, mime.clone()).await;
10879    bytes = stored;
10880
10881    let mut hasher = Sha256::new();
10882    hasher.update(&bytes);
10883    let digest = hasher.finalize();
10884    let hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
10885        use std::fmt::Write as _;
10886        let _ = write!(acc, "{b:02x}");
10887        acc
10888    });
10889
10890    if dedupe {
10891        if let Some(existing) = Media::objects()
10892            .where_(Media::content_hash.eq(hash.clone()))
10893            .first(pool)
10894            .await?
10895        {
10896            return Ok(existing);
10897        }
10898    }
10899
10900    // Routed through the pluggable storage backend (Slice 8.x).
10901    let storage_key = format!("{}-{}", &hash[..16], filename);
10902    crate::media_storage::disk_for(&org_slug)
10903        .save(&crate::media_storage::key(org_slug, &storage_key), &bytes)
10904        .await
10905        .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
10906
10907    let title = match title {
10908        Some(t) if !t.is_empty() => t.to_owned(),
10909        _ => filename
10910            .rsplit_once('.')
10911            .map(|(stem, _)| stem.to_owned())
10912            .unwrap_or_else(|| filename.clone()),
10913    };
10914
10915    // Pixel dimensions fall out of the EXIF-strip decode; non-images /
10916    // broken decodes get `None`.
10917    let (width, height): (Option<i32>, Option<i32>) = decoded_dims
10918        .map(|(w, h)| (Some(w as i32), Some(h as i32)))
10919        .unwrap_or((None, None));
10920
10921    let mut row = Media {
10922        id: Auto::Unset,
10923        filename,
10924        content_hash: hash,
10925        mime,
10926        size: bytes.len() as i64,
10927        kind,
10928        width,
10929        height,
10930        storage_key,
10931        title,
10932        alt_text: alt_text.to_owned(),
10933        description: String::new(),
10934        uploaded_by,
10935        collection_id,
10936        focal_point_x: None,
10937        focal_point_y: None,
10938        uploaded_at: Auto::Unset,
10939    };
10940    row.insert_pool(pool).await?;
10941    Ok(row)
10942}
10943
10944pub async fn media_upload_submit(
10945    State(_state): State<super::AdminState>,
10946    tenant: Tenant,
10947    mut multipart: axum::extract::Multipart,
10948) -> Result<Response, AdminError> {
10949    let mut filename = String::new();
10950    let mut bytes: Vec<u8> = Vec::new();
10951    let mut title = String::new();
10952    let mut alt_text = String::new();
10953    // #24 V2 — upload-time crop. When the client submits all four
10954    // crop coords (source-image pixel space), we decode + crop the
10955    // bytes before storing so the on-disk canonical file matches the
10956    // editor's intent. Absence of any of the four = no crop.
10957    let mut crop_x: Option<u32> = None;
10958    let mut crop_y: Option<u32> = None;
10959    let mut crop_w: Option<u32> = None;
10960    let mut crop_h: Option<u32> = None;
10961
10962    while let Some(field) = multipart
10963        .next_field()
10964        .await
10965        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
10966    {
10967        let name = field.name().unwrap_or("").to_owned();
10968        match name.as_str() {
10969            "file" => {
10970                if let Some(fname) = field.file_name() {
10971                    filename = sanitize_filename(fname);
10972                }
10973                bytes = field
10974                    .bytes()
10975                    .await
10976                    .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
10977                    .to_vec();
10978            }
10979            "title" => {
10980                title = field
10981                    .text()
10982                    .await
10983                    .map_err(|e| AdminError::Upload(format!("read title: {e}")))?;
10984            }
10985            "alt_text" => {
10986                alt_text = field
10987                    .text()
10988                    .await
10989                    .map_err(|e| AdminError::Upload(format!("read alt_text: {e}")))?;
10990            }
10991            "crop_x" | "crop_y" | "crop_w" | "crop_h" => {
10992                let value = field
10993                    .text()
10994                    .await
10995                    .map_err(|e| AdminError::Upload(format!("read {name}: {e}")))?;
10996                let parsed: Option<u32> = value.trim().parse().ok();
10997                match name.as_str() {
10998                    "crop_x" => crop_x = parsed,
10999                    "crop_y" => crop_y = parsed,
11000                    "crop_w" => crop_w = parsed,
11001                    "crop_h" => crop_h = parsed,
11002                    _ => {}
11003                }
11004            }
11005            _ => {
11006                let _ = field.bytes().await;
11007            }
11008        }
11009    }
11010
11011    if filename.is_empty() || bytes.is_empty() {
11012        return Err(AdminError::Upload("no file submitted".into()));
11013    }
11014
11015    // Apply crop if all four coords arrived. Image-only — vector
11016    // sources can't be raster-cropped (mirrors the edit-time rule
11017    // in the V1 crop handler).
11018    if let (Some(x), Some(y), Some(w), Some(h)) = (crop_x, crop_y, crop_w, crop_h) {
11019        if w > 0 && h > 0 {
11020            let detected_mime = mime_guess::from_path(&filename)
11021                .first_or_octet_stream()
11022                .essence_str()
11023                .to_owned();
11024            refuse_active_upload(&detected_mime)?;
11025            if detected_mime == "image/svg+xml" {
11026                return Err(AdminError::Validation(
11027                    "Cropping SVG sources isn't supported; upload uncropped, then edit the markup."
11028                        .to_owned(),
11029                ));
11030            }
11031            if detected_mime.starts_with("image/") {
11032                let (cropped, _out_mime) = crate::rendition::crop_image_off_runtime(
11033                    bytes,
11034                    detected_mime.clone(),
11035                    (x, y, w, h),
11036                )
11037                .await
11038                .map_err(AdminError::Validation)?;
11039                bytes = cropped;
11040            }
11041        }
11042    }
11043
11044    // This legacy single-file path ignores any collection choice (the
11045    // per-file picker lives on the staged upload flow): rows land in
11046    // "uncategorized" (NULL) under the root collection.
11047    let row = store_media(
11048        tenant.pool(),
11049        &tenant.org.slug,
11050        bytes,
11051        &filename,
11052        (!title.is_empty()).then_some(title.as_str()),
11053        &alt_text,
11054        None,
11055        None,
11056        false,
11057    )
11058    .await?;
11059
11060    let redirect = if row.kind == "image" {
11061        "/cms-admin/media"
11062    } else {
11063        "/cms-admin/documents"
11064    };
11065    Ok(Redirect::to(redirect).into_response())
11066}
11067
11068/// POST /cms-admin/media/{id}/delete — drop a media row.
11069pub async fn media_delete_submit(
11070    State(_state): State<super::AdminState>,
11071    tenant: Tenant,
11072    Path(id): Path<i64>,
11073) -> Result<Response, AdminError> {
11074    let row = Media::objects()
11075        .where_(Media::id.eq(id))
11076        .first(tenant.pool())
11077        .await?
11078        .ok_or(AdminError::NotFound(id))?;
11079    // Best-effort storage cleanup — a missing object is not fatal.
11080    crate::media_storage::disk_for(&tenant.org.slug)
11081        .delete(&crate::media_storage::key(
11082            &tenant.org.slug,
11083            &row.storage_key,
11084        ))
11085        .await
11086        .log_warn("stored file not deleted; the blob is orphaned");
11087    let redirect = if row.kind == "image" {
11088        "/cms-admin/media"
11089    } else {
11090        "/cms-admin/documents"
11091    };
11092    row.delete_pool(tenant.pool()).await?;
11093    Ok(Redirect::to(redirect).into_response())
11094}
11095
11096fn sanitize_filename(raw: &str) -> String {
11097    raw.chars()
11098        .map(|c| {
11099            if c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_') {
11100                c
11101            } else {
11102                '_'
11103            }
11104        })
11105        .collect()
11106}
11107
11108// =====================================================================
11109// Locales tab
11110// =====================================================================
11111
11112/// GET /cms-admin/locales — list every locale.
11113/// GET /cms-admin/model/{slug} — generic read-only index for a
11114/// model registered via `register_model_admin!`: columns come from the
11115/// model's `admin(list_display = …)`, rows from its type-erased
11116/// list-rows thunk, all inside the CMS admin chrome. 404s an unknown
11117/// slug.
11118pub async fn model_admin_list(
11119    State(state): State<super::AdminState>,
11120    tenant: Tenant,
11121    headers: HeaderMap,
11122    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11123    Path(slug): Path<String>,
11124) -> Result<Response, AdminError> {
11125    let Some(ma) = super::model_admin::find(&slug) else {
11126        return Ok((axum::http::StatusCode::NOT_FOUND, "unknown model admin").into_response());
11127    };
11128    let rows_json = (ma.list_rows)(tenant.pool().clone()).await;
11129    let columns = super::model_admin::list_columns(ma.schema);
11130    let header_labels: Vec<&str> = columns.iter().map(|(_, l)| l.as_str()).collect();
11131    let body_rows: Vec<Vec<String>> = rows_json
11132        .iter()
11133        .map(|r| {
11134            columns
11135                .iter()
11136                .map(|(name, _)| super::model_admin::row_cell(r, name))
11137                .collect()
11138        })
11139        .collect();
11140    let mut ctx = Context::new();
11141    add_chrome(&mut ctx, &tenant, "model-admin", session_user.as_ref()).await;
11142    add_admin_theme(&mut ctx, tenant.pool()).await;
11143    ctx.insert("model_label", ma.label);
11144    ctx.insert("model_slug", &slug);
11145    ctx.insert("columns", &header_labels);
11146    ctx.insert("rows", &body_rows);
11147    ctx.insert("total", &body_rows.len());
11148    render_with_csrf(
11149        &state,
11150        &headers,
11151        "rcms_admin/model_admin_list.html",
11152        &mut ctx,
11153    )
11154}
11155
11156/// `?format=csv` selector for [`report_view`].
11157#[derive(serde::Deserialize, Default)]
11158pub struct ReportQuery {
11159    pub format: Option<String>,
11160}
11161
11162/// Render any registered report through the shared chrome'd
11163/// table, or export it as CSV with `?format=csv`. `active_tab` is
11164/// `report:<slug>` so `_base.html` highlights the matching sidebar link.
11165pub async fn report_view(
11166    State(state): State<super::AdminState>,
11167    tenant: Tenant,
11168    headers: HeaderMap,
11169    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11170    Path(slug): Path<String>,
11171    Query(q): Query<ReportQuery>,
11172) -> Result<Response, AdminError> {
11173    let Some(report) = super::report::find_report(&slug) else {
11174        return Ok((axum::http::StatusCode::NOT_FOUND, "unknown report").into_response());
11175    };
11176    let user_id = session_user.as_ref().and_then(|u| u.id.get().copied());
11177    let columns = report.columns();
11178    let rows = report.rows(tenant.pool(), user_id).await;
11179
11180    // CSV export — same rows, flattened to column order.
11181    if q.format.as_deref() == Some("csv") {
11182        let mut out = String::with_capacity(128 + rows.len() * 64);
11183        let header: Vec<String> = columns.iter().map(|c| csv_escape(c.label)).collect();
11184        out.push_str(&header.join(","));
11185        out.push('\n');
11186        for row in &rows {
11187            let line: Vec<String> = columns
11188                .iter()
11189                .map(|c| csv_escape(&report_cell_string(row.get(c.key))))
11190                .collect();
11191            out.push_str(&line.join(","));
11192            out.push('\n');
11193        }
11194        return Ok(csv_response(&slug, &out));
11195    }
11196
11197    let header_labels: Vec<&str> = columns.iter().map(|c| c.label).collect();
11198    let view_rows: Vec<serde_json::Value> = rows
11199        .iter()
11200        .map(|row| {
11201            let cells: Vec<serde_json::Value> = columns
11202                .iter()
11203                .map(|c| {
11204                    serde_json::json!({
11205                        "kind": c.kind.as_str(),
11206                        "value": report_cell_string(row.get(c.key)),
11207                    })
11208                })
11209                .collect();
11210            serde_json::json!({
11211                "edit_url": row.get("edit_url").and_then(|v| v.as_str()),
11212                "cells": cells,
11213            })
11214        })
11215        .collect();
11216
11217    let mut ctx = Context::new();
11218    add_chrome(
11219        &mut ctx,
11220        &tenant,
11221        &format!("report:{slug}"),
11222        session_user.as_ref(),
11223    )
11224    .await;
11225    add_admin_theme(&mut ctx, tenant.pool()).await;
11226    ctx.insert("report_title", report.title());
11227    ctx.insert("report_slug", &slug);
11228    ctx.insert("report_description", &report.description());
11229    ctx.insert("columns", &header_labels);
11230    ctx.insert("rows", &view_rows);
11231    ctx.insert("total", &view_rows.len());
11232    render_with_csrf(&state, &headers, "rcms_admin/report.html", &mut ctx)
11233}
11234
11235// ===================================================================== Form builder (#533)
11236
11237/// GET `/cms-admin/forms` — dedicated Forms list: every form snippet with its
11238/// per-form submission count and last-submission time, linking straight into
11239/// the builder and the submission history. This exists because the generic
11240/// library table can't surface submissions (`LibraryTypeHandler::render_cell`
11241/// is sync and pool-less), which left "Forms" dead-ending on a Library view
11242/// with no way to see what a form collected.
11243pub async fn forms_list(
11244    State(state): State<super::AdminState>,
11245    tenant: Tenant,
11246    headers: HeaderMap,
11247    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11248) -> Result<Response, AdminError> {
11249    let pool = tenant.pool();
11250    let rows = forms_list_rows(pool).await?;
11251
11252    let mut ctx = Context::new();
11253    add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11254    add_admin_theme(&mut ctx, pool).await;
11255    ctx.insert("rows", &rows);
11256    ctx.insert("total", &rows.len());
11257    render_with_csrf(&state, &headers, "rcms_admin/forms_list.html", &mut ctx)
11258}
11259
11260/// Core of [`forms_list`] — the row model (per-form field count, submission
11261/// count, latest submission, action URLs), split out so unit tests can drive
11262/// it with an in-memory pool.
11263pub(crate) async fn forms_list_rows(
11264    pool: &rustango::sql::Pool,
11265) -> Result<Vec<serde_json::Value>, AdminError> {
11266    let mut forms: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
11267        .where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
11268        .fetch(pool)
11269        .await?;
11270    // Newest-edited first.
11271    forms.sort_by(|a, b| {
11272        b.updated_at
11273            .get()
11274            .cloned()
11275            .cmp(&a.updated_at.get().cloned())
11276    });
11277
11278    // Per-form submission count + latest submission, grouped in Rust — the
11279    // tri-dialect pattern used by `counts_by_type` / the pages `child_counts`
11280    // (no SQL GROUP BY helper in the codebase).
11281    let entries: Vec<crate::forms::submit::FormEntry> = crate::forms::submit::FormEntry::objects()
11282        .fetch(pool)
11283        .await?;
11284    let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
11285    let mut last_at: std::collections::HashMap<i64, String> = std::collections::HashMap::new();
11286    for e in &entries {
11287        *counts.entry(e.form_snippet_id).or_default() += 1;
11288        if let Some(at) = e.submitted_at.get() {
11289            let s = at.format("%Y-%m-%d %H:%M").to_string();
11290            let slot = last_at.entry(e.form_snippet_id).or_default();
11291            if s > *slot {
11292                *slot = s;
11293            }
11294        }
11295    }
11296
11297    let rows: Vec<serde_json::Value> = forms
11298        .iter()
11299        .map(|s| {
11300            let id = s.id.get().copied().unwrap_or_default();
11301            let parsed = crate::forms::schema::parse(&s.data).unwrap_or_default();
11302            serde_json::json!({
11303                "id": id,
11304                "title": s.title,
11305                "slug": s.slug,
11306                "fields": parsed.field_count(),
11307                "submissions": counts.get(&id).copied().unwrap_or(0),
11308                "last_submission": last_at.get(&id).cloned().unwrap_or_default(),
11309                "updated_at": s.updated_at.get().map(|d| d.format("%Y-%m-%d").to_string()).unwrap_or_default(),
11310                "build_url": format!("/cms-admin/forms/{id}/build"),
11311                "submissions_url": format!("/cms-admin/forms/{id}/submissions"),
11312                "delete_url": format!("/cms-admin/library/{id}/delete"),
11313            })
11314        })
11315        .collect();
11316    Ok(rows)
11317}
11318
11319/// GET `/cms-admin/forms/{id}/build` — the visual form builder editor.
11320/// Loads the form snippet's schema JSON into the page; the
11321/// `form_builder.js` engine renders the editor from it.
11322pub async fn form_build_form(
11323    State(state): State<super::AdminState>,
11324    tenant: Tenant,
11325    headers: HeaderMap,
11326    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11327    Path(id): Path<i64>,
11328    Query(q): Query<EditQuery>,
11329) -> Result<Response, AdminError> {
11330    let snippet = crate::snippet::Snippet::objects()
11331        .where_(crate::snippet::Snippet::id.eq(id))
11332        .first(tenant.pool())
11333        .await?
11334        .ok_or(AdminError::NotFound(id))?;
11335    if snippet.type_name != "form" {
11336        return Err(AdminError::NotFound(id));
11337    }
11338    let mut ctx = Context::new();
11339    add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11340    add_admin_theme(&mut ctx, tenant.pool()).await;
11341    ctx.insert("title", &snippet.title);
11342    ctx.insert("form_id", &id);
11343    ctx.insert("build_url", &format!("/cms-admin/forms/{id}/build"));
11344
11345    // #550 FB-17 — active non-default locales for the Translate picker.
11346    let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
11347        .where_(crate::locale::Locale::active.eq(true))
11348        .where_(crate::locale::Locale::is_default.eq(false))
11349        .fetch(tenant.pool())
11350        .await
11351        .unwrap_or_default();
11352    ctx.insert(
11353        "locales",
11354        &locales
11355            .iter()
11356            .map(|l| serde_json::json!({"code": l.code, "name": l.name}))
11357            .collect::<Vec<_>>(),
11358    );
11359
11360    // Translate mode: ?locale=<code> renders a focused per-leaf editor that
11361    // posts to the existing snippet-translate endpoint.
11362    if let Some(code) = q.locale.as_deref().filter(|c| !c.is_empty()) {
11363        if let Some(loc) = locales.iter().find(|l| l.code == code) {
11364            let lid = loc.id.get().copied().unwrap_or(0);
11365            let form = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11366            let leaves = crate::forms::schema::translatable_leaves(&form);
11367            let existing = crate::snippet_translation::fetch_for(tenant.pool(), id, lid)
11368                .await
11369                .unwrap_or_default();
11370            // Consecutive leaves of one field form a group, like the
11371            // block groups of the page editor.
11372            let mut groups: Vec<serde_json::Value> = Vec::new();
11373            for l in &leaves {
11374                let row = serde_json::json!({
11375                    "path": l.path,
11376                    "part": l.part,
11377                    "n": l.n.to_string(),
11378                    "canonical": l.text,
11379                    "value": existing.get(&l.path).cloned().unwrap_or_default(),
11380                });
11381                let same = groups
11382                    .last()
11383                    .is_some_and(|g| g["name"].as_str() == Some(l.group.as_str()));
11384                if same {
11385                    if let Some(arr) = groups
11386                        .last_mut()
11387                        .and_then(|g| g.get_mut("leaves"))
11388                        .and_then(|v| v.as_array_mut())
11389                    {
11390                        arr.push(row);
11391                    }
11392                } else {
11393                    groups.push(serde_json::json!({ "name": l.group, "leaves": [row] }));
11394                }
11395            }
11396            ctx.insert("editing_locale", &loc.name);
11397            ctx.insert("editing_code", &code);
11398            ctx.insert("trans_groups", &groups);
11399            ctx.insert(
11400                "translate_url",
11401                &format!("/cms-admin/library/{id}/translate"),
11402            );
11403            return render_with_csrf(&state, &headers, "rcms_admin/form_translate.html", &mut ctx);
11404        }
11405    }
11406
11407    // The builder's back button says "Forms", so it has to land on the
11408    // Forms list. Pointing it at the generic Library view dropped editors
11409    // onto a different listing of the same rows — its own search, its own
11410    // column picker, no Submissions column — which read as a second,
11411    // older Forms screen. Every other builder points at its own list.
11412    ctx.insert("list_url", "/cms-admin/forms");
11413    // FB-15 — the builder edits the DRAFT; Publish promotes it to live.
11414    ctx.insert("publish_url", &format!("/cms-admin/forms/{id}/publish"));
11415    ctx.insert(
11416        "has_unpublished",
11417        &crate::forms::schema::has_unpublished_changes(&snippet.data),
11418    );
11419    let mut draft = crate::forms::schema::parse_draft(&snippet.data);
11420    draft.sanitize_rich_text();
11421    let schema_json = serde_json::to_string(&crate::forms::schema::to_value(&draft))
11422        .unwrap_or_else(|_| "{}".to_owned());
11423    ctx.insert("schema_json", &schema_json);
11424    render_with_csrf(&state, &headers, "rcms_admin/form_builder.html", &mut ctx)
11425}
11426
11427#[derive(Debug, Deserialize)]
11428pub struct FormBuildSubmit {
11429    pub schema: String,
11430}
11431
11432/// Create-a-page-type submit. `type_name` is slugified server-side.
11433#[derive(Debug, Deserialize)]
11434pub struct FormPageTypeCreate {
11435    #[serde(default)]
11436    pub verbose_name: String,
11437    #[serde(default)]
11438    pub type_name: String,
11439    #[serde(default)]
11440    pub allowed_parents: String,
11441    #[serde(default)]
11442    pub allowed_children: String,
11443    /// `"auto" | "html" | "api"` — see [`crate::page_view::PageViewMode`].
11444    /// Offered only for UI types: a code type's mode is re-seeded from
11445    /// its handler on every boot, so an admin edit would silently revert.
11446    #[serde(default)]
11447    pub view_mode: String,
11448    /// Workflow name, or empty to publish directly.
11449    #[serde(default)]
11450    pub workflow: String,
11451}
11452
11453/// Component builder submit: builder `schema` (a `{nodes:[…]}` blob)
11454/// plus the component metadata fields.
11455#[derive(Debug, Deserialize)]
11456pub struct FormComponentSubmit {
11457    #[serde(default)]
11458    pub slug: String,
11459    #[serde(default)]
11460    pub label: String,
11461    #[serde(default)]
11462    pub icon: String,
11463    #[serde(default)]
11464    pub description: String,
11465    #[serde(default)]
11466    pub schema: String,
11467}
11468
11469/// POST `/cms-admin/forms/{id}/build` — persist the builder's schema into
11470/// GET|POST /cms-admin/forms/{id}/preview — render this form the way a
11471/// visitor sees it, for the editor's sidebar preview.
11472///
11473/// GET renders the saved draft; POST renders the schema in the request
11474/// body, which is how the builder shows unsaved edits — the same
11475/// saved-vs-unsaved split the page preview uses.
11476///
11477/// Crucially this calls [`crate::forms::render::render_form_html`] — the
11478/// one the public site calls. The builder used to draw its own preview in
11479/// JavaScript, rebuilding the layout a second time in a second language;
11480/// the two could only agree by coincidence, and every renderer change had
11481/// to be made twice or the preview quietly started lying.
11482pub async fn form_preview(
11483    tenant: Tenant,
11484    Path(id): Path<i64>,
11485    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11486) -> Result<Response, AdminError> {
11487    let snippet = load_form_snippet(&tenant, id).await?;
11488    let form = crate::forms::schema::parse_draft(&snippet.data);
11489    Ok(render_form_preview(id, &form))
11490}
11491
11492/// POST /cms-admin/forms/{id}/preview — render the schema in the body, so
11493/// the builder previews edits that have not been saved. Mirrors
11494/// `page_preview_draft`.
11495pub async fn form_preview_draft(
11496    tenant: Tenant,
11497    Path(id): Path<i64>,
11498    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11499    Form(body): Form<FormBuildSubmit>,
11500) -> Result<Response, AdminError> {
11501    let snippet = load_form_snippet(&tenant, id).await?;
11502    // A schema that does not parse is the normal state mid-edit, not an
11503    // error worth blanking the pane for: fall back to the saved draft and
11504    // let the editor keep typing.
11505    let form = crate::forms::schema::parse_str(&body.schema)
11506        .unwrap_or_else(|_| crate::forms::schema::parse_draft(&snippet.data));
11507    Ok(render_form_preview(id, &form))
11508}
11509
11510/// The snippet behind a form id, refusing anything that is not a form.
11511async fn load_form_snippet(
11512    tenant: &Tenant,
11513    id: i64,
11514) -> Result<crate::snippet::Snippet, AdminError> {
11515    let snippet = crate::snippet::Snippet::objects()
11516        .where_(crate::snippet::Snippet::id.eq(id))
11517        .first(tenant.pool())
11518        .await?
11519        .ok_or(AdminError::NotFound(id))?;
11520    if snippet.type_name != "form" {
11521        return Err(AdminError::NotFound(id));
11522    }
11523    Ok(snippet)
11524}
11525
11526fn render_form_preview(id: i64, form: &crate::forms::schema::Form) -> Response {
11527    // `embed_id` is empty: this is the standalone render, with no page
11528    // embedding it and so no per-embed override to resolve.
11529    let inner = crate::forms::render::render_form_html(form, id, "");
11530    let html = format!(
11531        "<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\">\
11532         <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\
11533         <title>Form preview</title>\
11534         <style>body{{margin:0;padding:24px;font:14px/1.5 system-ui,sans-serif;}}</style>\
11535         </head><body>{inner}</body></html>"
11536    );
11537    stamp_no_cache(
11538        (
11539            [(
11540                axum::http::header::CONTENT_TYPE,
11541                axum::http::HeaderValue::from_static("text/html; charset=utf-8"),
11542            )],
11543            html,
11544        )
11545            .into_response(),
11546    )
11547}
11548
11549/// the snippet's `data` column + capture a revision.
11550pub async fn form_build_submit(
11551    State(_state): State<super::AdminState>,
11552    tenant: Tenant,
11553    headers: HeaderMap,
11554    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11555    Path(id): Path<i64>,
11556    Form(form): Form<FormBuildSubmit>,
11557) -> Result<Response, AdminError> {
11558    let mut snippet = crate::snippet::Snippet::objects()
11559        .where_(crate::snippet::Snippet::id.eq(id))
11560        .first(tenant.pool())
11561        .await?
11562        .ok_or(AdminError::NotFound(id))?;
11563    if snippet.type_name != "form" {
11564        return Err(AdminError::NotFound(id));
11565    }
11566    let mut parsed = crate::forms::schema::parse_str(&form.schema)
11567        .map_err(|e| AdminError::Validation(format!("invalid form schema: {e}")))?;
11568    parsed.sanitize_rich_text();
11569    let mut warnings = crate::forms::schema::validate(&parsed);
11570    // FB-15 — saving stores a DRAFT; the published (public) form is untouched
11571    // until Publish.
11572    snippet.data = crate::forms::schema::save_draft_value(&snippet.data, &parsed);
11573    snippet.save_pool(tenant.pool()).await?;
11574    // Keep the notification target in step with the recipients typed into
11575    // form settings, so the two cannot disagree about who gets told.
11576    if let Err(e) = crate::notify::targets::sync_form_email(
11577        tenant.pool(),
11578        id,
11579        &snippet.title,
11580        &parsed.settings.notify_emails,
11581    )
11582    .await
11583    {
11584        tracing::warn!(
11585            target: "rustango_cms::notify",
11586            error = %e, form_id = id,
11587            "could not sync the form's email notification target"
11588        );
11589        warnings.push(format!("Email notifications are off: {e}."));
11590    }
11591    let (level, msg) = if warnings.is_empty() {
11592        (MsgLevel::Success, "Draft saved.".to_owned())
11593    } else {
11594        (
11595            MsgLevel::Warning,
11596            format!("Draft saved with warnings: {}", warnings.join(" ")),
11597        )
11598    };
11599    redirect_named_with_params_and_message(
11600        "rcms-admin:forms:build",
11601        &[("id", id.to_string())],
11602        level,
11603        &msg,
11604        &headers,
11605    )
11606}
11607
11608/// POST `/cms-admin/forms/{id}/publish` — publish the submitted schema: it
11609/// becomes the live (public) form + the draft, and a revision is captured.
11610pub async fn form_publish_submit(
11611    State(_state): State<super::AdminState>,
11612    tenant: Tenant,
11613    headers: HeaderMap,
11614    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11615    Path(id): Path<i64>,
11616    Form(form): Form<FormBuildSubmit>,
11617) -> Result<Response, AdminError> {
11618    let mut snippet = crate::snippet::Snippet::objects()
11619        .where_(crate::snippet::Snippet::id.eq(id))
11620        .first(tenant.pool())
11621        .await?
11622        .ok_or(AdminError::NotFound(id))?;
11623    if snippet.type_name != "form" {
11624        return Err(AdminError::NotFound(id));
11625    }
11626    let mut parsed = crate::forms::schema::parse_str(&form.schema)
11627        .map_err(|e| AdminError::Validation(format!("invalid form schema: {e}")))?;
11628    parsed.sanitize_rich_text();
11629    snippet.data = crate::forms::schema::publish_value(&parsed);
11630    snippet.save_pool(tenant.pool()).await?;
11631    if let Some(h) = crate::library::find_handler(&snippet.type_name) {
11632        if h.revisions_enabled() {
11633            let uid = session_user.as_ref().and_then(|u| u.id.get().copied());
11634            crate::snippet::capture_revision(tenant.pool(), &snippet, uid)
11635                .await
11636                .log_warn("revision not captured; the history has a gap");
11637        }
11638    }
11639    redirect_named_with_params_and_message(
11640        "rcms-admin:forms:build",
11641        &[("id", id.to_string())],
11642        MsgLevel::Success,
11643        "Form published — the live form is now up to date.",
11644        &headers,
11645    )
11646}
11647
11648/// Shared loader for the submissions views: the form
11649/// snippet, its parsed schema's value-columns, the entries, and a
11650/// source-page-id → url_path map for provenance links.
11651async fn load_form_submissions(
11652    pool: &rustango::sql::Pool,
11653    form_id: i64,
11654) -> Result<
11655    (
11656        crate::snippet::Snippet,
11657        Vec<(String, String)>,
11658        Vec<crate::forms::submit::FormEntry>,
11659        std::collections::HashMap<i64, String>,
11660    ),
11661    AdminError,
11662> {
11663    let snippet = crate::snippet::Snippet::objects()
11664        .where_(crate::snippet::Snippet::id.eq(form_id))
11665        .where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
11666        .first(pool)
11667        .await?
11668        .ok_or(AdminError::NotFound(form_id))?;
11669    let form = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11670    let columns: Vec<(String, String)> = form
11671        .fields()
11672        .filter(|f| f.field_type.collects_value() && !f.key.is_empty())
11673        .map(|f| {
11674            (
11675                f.key.clone(),
11676                if f.label.is_empty() {
11677                    f.key.clone()
11678                } else {
11679                    f.label.clone()
11680                },
11681            )
11682        })
11683        .collect();
11684    let entries: Vec<crate::forms::submit::FormEntry> = crate::forms::submit::FormEntry::objects()
11685        .where_(crate::forms::submit::FormEntry::form_snippet_id.eq(form_id))
11686        .order_by(&[("submitted_at", true)])
11687        .fetch(pool)
11688        .await?;
11689    // Resolve source pages for provenance links.
11690    let mut page_urls = std::collections::HashMap::new();
11691    let ids: Vec<i64> = entries
11692        .iter()
11693        .map(|e| e.source_page_id)
11694        .filter(|i| *i != 0)
11695        .collect();
11696    if !ids.is_empty() {
11697        if let Ok(pages) = crate::page::Page::objects().fetch(pool).await {
11698            for p in pages {
11699                if let Some(pid) = p.id.get().copied() {
11700                    if ids.contains(&pid) {
11701                        page_urls.insert(pid, p.url_path.clone());
11702                    }
11703                }
11704            }
11705        }
11706    }
11707    Ok((snippet, columns, entries, page_urls))
11708}
11709
11710/// Render one submission answer cell from the `data_json` value.
11711fn submission_cell(data: &serde_json::Value, key: &str) -> String {
11712    match data.get(key) {
11713        Some(serde_json::Value::Array(items)) => items
11714            .iter()
11715            .filter_map(|v| v.as_str().map(str::to_owned))
11716            .collect::<Vec<_>>()
11717            .join("; "),
11718        Some(serde_json::Value::String(s)) => s.clone(),
11719        Some(other) => other.to_string(),
11720        None => String::new(),
11721    }
11722}
11723
11724/// GET `/cms-admin/forms/{id}/submissions` — the per-form submission
11725/// history with a Source-page column.
11726pub async fn form_submissions_list(
11727    State(state): State<super::AdminState>,
11728    tenant: Tenant,
11729    headers: HeaderMap,
11730    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11731    Path(id): Path<i64>,
11732) -> Result<Response, AdminError> {
11733    let (snippet, columns, entries, page_urls) = load_form_submissions(tenant.pool(), id).await?;
11734    // Which columns are file uploads → render those cells as download links.
11735    let parsed = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11736    let file_keys: std::collections::HashSet<String> = parsed
11737        .fields()
11738        .filter(|f| matches!(f.field_type, crate::forms::schema::FieldType::File))
11739        .map(|f| f.key.clone())
11740        .collect();
11741    let rows: Vec<serde_json::Value> = entries
11742        .iter()
11743        .map(|e| {
11744            let cells: Vec<serde_json::Value> = columns
11745                .iter()
11746                .map(|(k, _)| {
11747                    let v = submission_cell(&e.data_json, k);
11748                    if file_keys.contains(k) && !v.is_empty() {
11749                        // value is the storage key; display the filename part.
11750                        let name = v.splitn(2, '-').nth(1).unwrap_or(&v).to_owned();
11751                        serde_json::json!({
11752                            "value": name,
11753                            "url": format!("/cms-admin/forms/{id}/submissions/file/{v}"),
11754                        })
11755                    } else {
11756                        serde_json::json!({ "value": v })
11757                    }
11758                })
11759                .collect();
11760            serde_json::json!({
11761                // RFC 3339, for the admin's `<time data-utc>` localizer; the
11762                // minute-precision text is what shows without JavaScript.
11763                "submitted_at": e
11764                    .submitted_at
11765                    .get()
11766                    .map(|t| t.to_rfc3339_opts(chrono::SecondsFormat::Secs, true))
11767                    .unwrap_or_default(),
11768                "submitted_at_text": e
11769                    .submitted_at
11770                    .get()
11771                    .map(|t| t.format("%Y-%m-%d %H:%M UTC").to_string())
11772                    .unwrap_or_default(),
11773                "ip": e.ip,
11774                "source_page": if e.source_page_id == 0 {
11775                    serde_json::Value::Null
11776                } else {
11777                    serde_json::json!({
11778                        "id": e.source_page_id,
11779                        "url": page_urls.get(&e.source_page_id).cloned().unwrap_or_default(),
11780                    })
11781                },
11782                "cells": cells,
11783            })
11784        })
11785        .collect();
11786    let mut ctx = Context::new();
11787    add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11788    add_admin_theme(&mut ctx, tenant.pool()).await;
11789    ctx.insert("form_title", &snippet.title);
11790    ctx.insert("form_id", &id);
11791    ctx.insert("build_url", &format!("/cms-admin/forms/{id}/build"));
11792    ctx.insert(
11793        "csv_url",
11794        &format!("/cms-admin/forms/{id}/submissions/export.csv"),
11795    );
11796    ctx.insert(
11797        "columns",
11798        &columns.iter().map(|(_, l)| l).collect::<Vec<_>>(),
11799    );
11800    ctx.insert("rows", &rows);
11801    ctx.insert("total", &entries.len());
11802    render_with_csrf(
11803        &state,
11804        &headers,
11805        "rcms_admin/form_submissions.html",
11806        &mut ctx,
11807    )
11808}
11809
11810/// GET `/cms-admin/forms/{id}/submissions/export.csv`.
11811pub async fn form_submissions_csv(
11812    State(_state): State<super::AdminState>,
11813    tenant: Tenant,
11814    Path(id): Path<i64>,
11815) -> Result<Response, AdminError> {
11816    let (snippet, columns, entries, page_urls) = load_form_submissions(tenant.pool(), id).await?;
11817    let mut out = String::new();
11818    out.push_str("submitted_at,source_page,ip");
11819    for (_, label) in &columns {
11820        out.push(',');
11821        out.push_str(&csv_escape(label));
11822    }
11823    out.push('\n');
11824    for e in &entries {
11825        let when = e
11826            .submitted_at
11827            .get()
11828            .map(ToString::to_string)
11829            .unwrap_or_default();
11830        let src = if e.source_page_id == 0 {
11831            String::new()
11832        } else {
11833            page_urls
11834                .get(&e.source_page_id)
11835                .cloned()
11836                .unwrap_or_default()
11837        };
11838        out.push_str(&csv_escape(&when));
11839        out.push(',');
11840        out.push_str(&csv_escape(&src));
11841        out.push(',');
11842        out.push_str(&csv_escape(&e.ip));
11843        for (k, _) in &columns {
11844            out.push(',');
11845            out.push_str(&csv_escape(&submission_cell(&e.data_json, k)));
11846        }
11847        out.push('\n');
11848    }
11849    let filename = format!("submissions-{}.csv", snippet.slug);
11850    Ok(csv_response(&filename, &out))
11851}
11852
11853/// GET `/cms-admin/forms/{id}/submissions/file/{key}` — download a file
11854/// uploaded through a form submission (admin-gated). Streams from
11855/// `./var/form-uploads/<tenant>/<key>`; rejects path traversal.
11856pub async fn form_submission_file(
11857    State(_state): State<super::AdminState>,
11858    tenant: Tenant,
11859    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11860    Path((_id, key)): Path<(i64, String)>,
11861) -> Result<Response, AdminError> {
11862    if key.contains('/') || key.contains('\\') || key.contains("..") || key.is_empty() {
11863        return Err(AdminError::NotFound(0));
11864    }
11865    let path = std::path::PathBuf::from("./var/form-uploads")
11866        .join(&tenant.org.slug)
11867        .join(&key);
11868    let bytes = std::fs::read(&path).map_err(|_| AdminError::NotFound(0))?;
11869    let mime = mime_guess::from_path(&key)
11870        .first_or_octet_stream()
11871        .essence_str()
11872        .to_owned();
11873    let download = key.splitn(2, '-').nth(1).unwrap_or(&key).to_owned();
11874    Ok((
11875        [
11876            (header::CONTENT_TYPE, mime),
11877            (
11878                header::CONTENT_DISPOSITION,
11879                format!("attachment; filename=\"{download}\""),
11880            ),
11881        ],
11882        bytes,
11883    )
11884        .into_response())
11885}
11886
11887#[derive(Debug, Deserialize)]
11888pub struct SetLangQuery {
11889    pub lang: String,
11890}
11891
11892/// POST `/cms-admin/set-language` (`lang=<code>`) — persist the sticky
11893/// admin-UI language cookie and the user's durable preference, then
11894/// redirect back to the Referer. POST so a cross-site link can't
11895/// rewrite a signed-in user's preference: it goes through the CSRF check
11896/// like every other admin write.
11897pub async fn admin_set_language(
11898    tenant: Tenant,
11899    headers: HeaderMap,
11900    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11901    Form(q): Form<SetLangQuery>,
11902) -> Response {
11903    let lang = if super::i18n::is_ui_locale(&q.lang) {
11904        q.lang
11905    } else {
11906        "en".to_owned()
11907    };
11908    // #526 — persist to the user's durable pref too, so the switcher choice
11909    // follows them across devices (not just this browser's cookie). Best-effort:
11910    // a save failure still sets the cookie below.
11911    if let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) {
11912        persist_user_admin_lang(tenant.pool(), uid, &lang)
11913            .await
11914            .log_warn("admin language preference not saved");
11915    }
11916    // The Referer's path, if it is a local one, else the admin root. The
11917    // path of `https://evil.test//evil.test/x` is `//evil.test/x`, so it
11918    // goes through safe_next like any other redirect target (#728).
11919    let back = headers
11920        .get(header::REFERER)
11921        .and_then(|v| v.to_str().ok())
11922        .and_then(|r| match r.split_once("://") {
11923            Some((_, rest)) => rest.find('/').map(|i| &rest[i..]),
11924            None => Some(r),
11925        })
11926        .and_then(rustango::auth_decorators::safe_next)
11927        .unwrap_or_else(|| "/cms-admin/".to_owned());
11928    let cookie = format!(
11929        "{}={lang}; Path=/; SameSite=Lax; Max-Age=31536000",
11930        super::i18n::ADMIN_LANG_COOKIE
11931    );
11932    let mut resp = axum::response::Redirect::to(&back).into_response();
11933    if let Ok(v) = HeaderValue::from_str(&cookie) {
11934        resp.headers_mut().append(header::SET_COOKIE, v);
11935    }
11936    resp
11937}
11938
11939/// RFC-4180 CSV field escaping: quote when the value contains a comma,
11940/// quote, or newline, doubling any embedded quotes. Shared by every
11941/// admin CSV export (reports, audit log, pages, redirects, …).
11942fn csv_escape(s: &str) -> String {
11943    if s.contains(',') || s.contains('"') || s.contains('\n') || s.contains('\r') {
11944        let mut out = String::with_capacity(s.len() + 2);
11945        out.push('"');
11946        for c in s.chars() {
11947            if c == '"' {
11948                out.push('"');
11949            }
11950            out.push(c);
11951        }
11952        out.push('"');
11953        out
11954    } else {
11955        s.to_owned()
11956    }
11957}
11958
11959/// Stringify a report cell value for display / CSV: strings pass
11960/// through; null / missing → empty; numbers + bools → their literal.
11961fn report_cell_string(v: Option<&serde_json::Value>) -> String {
11962    match v {
11963        Some(serde_json::Value::String(s)) => s.clone(),
11964        None | Some(serde_json::Value::Null) => String::new(),
11965        Some(other) => other.to_string(),
11966    }
11967}
11968
11969pub async fn locale_list(
11970    State(state): State<super::AdminState>,
11971    tenant: Tenant,
11972    headers: HeaderMap,
11973    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11974) -> Result<Response, AdminError> {
11975    let items: Vec<Locale> = Locale::objects()
11976        .order_by(&[("sort_order", false), ("code", false)])
11977        .fetch(tenant.pool())
11978        .await?;
11979    // Enrich each row with core's static support level so the list can warn
11980    // where a content locale outruns the framework (no admin-UI catalog, no
11981    // language-specific plural rule, unknown to core). Serialize the row then
11982    // attach `support` — keeps every existing template field working.
11983    let rows: Vec<serde_json::Value> = items
11984        .iter()
11985        .map(|l| {
11986            let info = rustango::i18n::locale_info(&l.code);
11987            let ui = super::i18n::is_ui_locale(&l.code);
11988            let mut v = serde_json::to_value(l).unwrap_or_default();
11989            v["support"] = serde_json::json!({
11990                "ui_translated": ui,
11991                "known": info.known,
11992                "display_name": info.display_name,
11993                "has_plural_rules": info.has_plural_rules,
11994                "is_rtl": info.is_rtl,
11995                "content_only": !ui,
11996            });
11997            v
11998        })
11999        .collect();
12000    let mut ctx = Context::new();
12001    add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
12002    add_admin_theme(&mut ctx, tenant.pool()).await;
12003    ctx.insert("items", &rows);
12004    render_with_csrf(&state, &headers, "rcms_admin/locale_list.html", &mut ctx)
12005}
12006
12007/// Inject core's known-locale roster into a locale-form context: a
12008/// `known_locales` list (`code`, `name`) for the code datalist, and a
12009/// `known_locales_meta` map (`code → {ui, is_rtl, has_plural_rules}`) the
12010/// form JS reads to show a live support hint. Free-text codes stay valid;
12011/// this is guidance, not a whitelist.
12012fn insert_known_locales(ctx: &mut Context) {
12013    let known: Vec<serde_json::Value> = rustango::i18n::known_locales()
12014        .map(|(code, name)| serde_json::json!({ "code": code, "name": name }))
12015        .collect();
12016    let meta: serde_json::Map<String, serde_json::Value> = rustango::i18n::known_locales()
12017        .map(|(code, _)| {
12018            let info = rustango::i18n::locale_info(code);
12019            (
12020                code.to_owned(),
12021                serde_json::json!({
12022                    "ui": super::i18n::is_ui_locale(code),
12023                    "is_rtl": info.is_rtl,
12024                    "has_plural_rules": info.has_plural_rules,
12025                }),
12026            )
12027        })
12028        .collect();
12029    ctx.insert("known_locales", &known);
12030    ctx.insert("known_locales_meta", &serde_json::Value::Object(meta));
12031}
12032
12033pub async fn locale_new_form(
12034    State(state): State<super::AdminState>,
12035    tenant: Tenant,
12036    headers: HeaderMap,
12037    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12038) -> Result<Response, AdminError> {
12039    let mut ctx = Context::new();
12040    add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
12041    add_admin_theme(&mut ctx, tenant.pool()).await;
12042    insert_known_locales(&mut ctx);
12043    ctx.insert("mode", "new");
12044    ctx.insert(
12045        "locale",
12046        &serde_json::json!({
12047            "code": "",
12048            "name": "",
12049            "is_default": false,
12050            "active": true,
12051            "sort_order": 100,
12052        }),
12053    );
12054    render_with_csrf(&state, &headers, "rcms_admin/locale_form.html", &mut ctx)
12055}
12056
12057#[derive(Debug, Deserialize)]
12058pub struct LocaleForm {
12059    pub code: String,
12060    pub name: String,
12061    #[serde(default)]
12062    pub is_default: Option<String>,
12063    #[serde(default)]
12064    pub active: Option<String>,
12065    #[serde(default)]
12066    pub sort_order: Option<i32>,
12067}
12068
12069impl LocaleForm {
12070    fn parsed_default(&self) -> bool {
12071        self.is_default.is_some()
12072    }
12073    fn parsed_active(&self) -> bool {
12074        self.active.is_some()
12075    }
12076    fn parsed_sort_order(&self) -> i32 {
12077        self.sort_order.unwrap_or(100)
12078    }
12079}
12080
12081pub async fn locale_new_submit(
12082    State(_state): State<super::AdminState>,
12083    tenant: Tenant,
12084    headers: HeaderMap,
12085    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12086    Form(form): Form<LocaleForm>,
12087) -> Result<Response, AdminError> {
12088    use rustango::sql::Auto;
12089    let name = form.name.trim().to_owned();
12090    if name.is_empty() {
12091        return Err(AdminError::Validation(
12092            "Display name is required.".to_owned(),
12093        ));
12094    }
12095    let mut row = Locale {
12096        id: Auto::Unset,
12097        code: crate::locale::validate_code(&form.code).map_err(AdminError::Validation)?,
12098        name,
12099        is_default: form.parsed_default(),
12100        active: form.parsed_active(),
12101        sort_order: form.parsed_sort_order(),
12102        created_at: Auto::Unset,
12103    };
12104    if row.is_default {
12105        clear_default_flag(&tenant, None).await?;
12106    }
12107    row.insert_pool(tenant.pool()).await?;
12108    redirect_named_with_message_args(
12109        "rcms-admin:locales:list",
12110        MsgLevel::Success,
12111        "Added locale {name} ({code}).",
12112        &[("name", row.name.as_str()), ("code", row.code.as_str())],
12113        &headers,
12114    )
12115}
12116
12117pub async fn locale_edit_form(
12118    State(state): State<super::AdminState>,
12119    tenant: Tenant,
12120    headers: HeaderMap,
12121    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12122    Path(id): Path<i64>,
12123) -> Result<Response, AdminError> {
12124    let row = Locale::objects()
12125        .where_(Locale::id.eq(id))
12126        .first(tenant.pool())
12127        .await?
12128        .ok_or(AdminError::NotFound(id))?;
12129    let mut ctx = Context::new();
12130    add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
12131    add_admin_theme(&mut ctx, tenant.pool()).await;
12132    insert_known_locales(&mut ctx);
12133    ctx.insert("mode", "edit");
12134    ctx.insert("locale", &row);
12135    render_with_csrf(&state, &headers, "rcms_admin/locale_form.html", &mut ctx)
12136}
12137
12138pub async fn locale_edit_submit(
12139    State(_state): State<super::AdminState>,
12140    tenant: Tenant,
12141    headers: HeaderMap,
12142    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12143    Path(id): Path<i64>,
12144    Form(form): Form<LocaleForm>,
12145) -> Result<Response, AdminError> {
12146    let mut row = Locale::objects()
12147        .where_(Locale::id.eq(id))
12148        .first(tenant.pool())
12149        .await?
12150        .ok_or(AdminError::NotFound(id))?;
12151    let name = form.name.trim().to_owned();
12152    if name.is_empty() {
12153        return Err(AdminError::Validation(
12154            "Display name is required.".to_owned(),
12155        ));
12156    }
12157    row.code = crate::locale::validate_code(&form.code).map_err(AdminError::Validation)?;
12158    row.name = name;
12159    row.is_default = form.parsed_default();
12160    row.active = form.parsed_active();
12161    row.sort_order = form.parsed_sort_order();
12162    if row.is_default {
12163        clear_default_flag(&tenant, Some(id)).await?;
12164    }
12165    row.save_pool(tenant.pool()).await?;
12166    redirect_named_with_message_args(
12167        "rcms-admin:locales:list",
12168        MsgLevel::Success,
12169        "Saved locale {name} ({code}).",
12170        &[("name", row.name.as_str()), ("code", row.code.as_str())],
12171        &headers,
12172    )
12173}
12174
12175pub async fn locale_delete_submit(
12176    State(_state): State<super::AdminState>,
12177    tenant: Tenant,
12178    headers: HeaderMap,
12179    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12180    Path(id): Path<i64>,
12181) -> Result<Response, AdminError> {
12182    let row = Locale::objects()
12183        .where_(Locale::id.eq(id))
12184        .first(tenant.pool())
12185        .await?
12186        .ok_or(AdminError::NotFound(id))?;
12187    if row.is_default {
12188        return redirect_named_with_message(
12189            "rcms-admin:locales:list",
12190            MsgLevel::Error,
12191            "Cannot delete the default locale — promote another locale to default first.",
12192            &headers,
12193        );
12194    }
12195    let label = format!("{} ({})", row.name, row.code);
12196    // Translations reference the locale; they go with it, in one step,
12197    // or the foreign keys refuse the delete.
12198    let pages = crate::translation::Translation::objects()
12199        .where_(crate::translation::Translation::locale_id.eq(id))
12200        .compile_delete()
12201        .map_err(rustango::sql::ExecError::from)?;
12202    let snippets = crate::snippet_translation::SnippetTranslation::objects()
12203        .where_(crate::snippet_translation::SnippetTranslation::locale_id.eq(id))
12204        .compile_delete()
12205        .map_err(rustango::sql::ExecError::from)?;
12206    let menus = crate::menu_item_translation::MenuItemTranslation::objects()
12207        .where_(crate::menu_item_translation::MenuItemTranslation::locale_id.eq(id))
12208        .compile_delete()
12209        .map_err(rustango::sql::ExecError::from)?;
12210    let categories = crate::category_translation::CategoryTranslation::objects()
12211        .where_(crate::category_translation::CategoryTranslation::locale_id.eq(id))
12212        .compile_delete()
12213        .map_err(rustango::sql::ExecError::from)?;
12214    rustango::atomic!(tenant.pool(), |tx| {
12215        let mut guard = tx.lock().await?;
12216        let tx = &mut *guard;
12217        for q in [&pages, &snippets, &menus, &categories] {
12218            rustango::sql::delete_tx(tx, q).await?;
12219        }
12220        row.delete_tx(tx).await?;
12221        Ok::<_, rustango::sql::ExecError>(())
12222    })
12223    .await?;
12224    redirect_named_with_message_args(
12225        "rcms-admin:locales:list",
12226        MsgLevel::Success,
12227        "Deleted locale {label}.",
12228        &[("label", label.as_str())],
12229        &headers,
12230    )
12231}
12232
12233// ============================================================ SSO Providers
12234//
12235// Admin-managed, DB-backed multi-provider SSO (the framework's
12236// `rustango::admin::SsoProvider`, one row per configurable OIDC/social
12237// provider). Each enabled row becomes a "Sign in with …" button on the
12238// login page (`/login/sso/{slug}`). This is the UI that replaces hand-
12239// editing `rustango_sso_providers` — mirrors the Locales CRUD.
12240
12241/// Built-in provider presets offered in the `kind` dropdown, plus generic
12242/// `oidc` (needs an issuer URL). Free-text isn't allowed — the framework
12243/// only knows these preset keys + `oidc`.
12244const SSO_KINDS: &[(&str, &str)] = &[
12245    ("google", "Google"),
12246    ("microsoft", "Microsoft"),
12247    ("github", "GitHub"),
12248    ("gitlab", "GitLab"),
12249    ("discord", "Discord"),
12250    ("oidc", "Generic OpenID Connect"),
12251];
12252
12253/// Serialize a `SsoProvider` row to JSON for the templates. The framework
12254/// model isn't `Serialize`, so map the fields by hand.
12255fn sso_provider_json(p: &rustango::admin::SsoProvider) -> serde_json::Value {
12256    serde_json::json!({
12257        "id": p.id.get().copied().unwrap_or_default(),
12258        "slug": p.slug,
12259        "label": p.label,
12260        "kind": p.kind,
12261        "issuer_url": p.issuer_url,
12262        "client_id": p.client_id,
12263        // Never surface the secret itself — just whether one is set (for the
12264        // edit form's "leave blank to keep" hint).
12265        "has_secret": !p.client_secret.is_empty(),
12266        "enabled": p.enabled,
12267        "sort_order": p.sort_order,
12268        "scopes": p.scopes,
12269    })
12270}
12271
12272pub async fn sso_provider_list(
12273    State(state): State<super::AdminState>,
12274    tenant: Tenant,
12275    headers: HeaderMap,
12276    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12277) -> Result<Response, AdminError> {
12278    // Identity administration is superuser-only (#672).
12279    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12280        return Ok(redirect);
12281    }
12282    use rustango::sql::FetcherPool as _;
12283    let mut items: Vec<rustango::admin::SsoProvider> = rustango::admin::SsoProvider::objects()
12284        .fetch(tenant.pool())
12285        .await
12286        .unwrap_or_default();
12287    items.sort_by(|a, b| a.sort_order.cmp(&b.sort_order).then(a.slug.cmp(&b.slug)));
12288    let rows: Vec<serde_json::Value> = items.iter().map(sso_provider_json).collect();
12289    let mut ctx = Context::new();
12290    add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12291    add_admin_theme(&mut ctx, tenant.pool()).await;
12292    ctx.insert("items", &rows);
12293    render_with_csrf(
12294        &state,
12295        &headers,
12296        "rcms_admin/sso_provider_list.html",
12297        &mut ctx,
12298    )
12299}
12300
12301#[derive(Deserialize)]
12302pub struct SsoProviderForm {
12303    pub slug: String,
12304    pub label: String,
12305    pub kind: String,
12306    #[serde(default)]
12307    pub issuer_url: String,
12308    pub client_id: String,
12309    /// The raw OAuth client secret. On edit, blank means "keep the current one"
12310    /// (the field is never pre-filled — it's write-only).
12311    #[serde(default)]
12312    pub client_secret: String,
12313    #[serde(default)]
12314    pub scopes: String,
12315    #[serde(default)]
12316    pub enabled: Option<String>,
12317    #[serde(default)]
12318    pub sort_order: Option<i32>,
12319}
12320
12321impl SsoProviderForm {
12322    /// Validate + normalize the form into field values, or an error message.
12323    fn validated(&self) -> Result<ValidatedProvider, String> {
12324        let slug = self.slug.trim().to_lowercase();
12325        if slug.is_empty()
12326            || !slug
12327                .chars()
12328                .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
12329        {
12330            return Err(
12331                "Slug is required and may only contain letters, numbers, - and _.".to_owned(),
12332            );
12333        }
12334        let label = self.label.trim().to_owned();
12335        if label.is_empty() {
12336            return Err("Button label is required.".to_owned());
12337        }
12338        let kind = self.kind.trim().to_lowercase();
12339        if !SSO_KINDS.iter().any(|(k, _)| *k == kind) {
12340            return Err("Pick a provider type.".to_owned());
12341        }
12342        let client_id = self.client_id.trim().to_owned();
12343        if client_id.is_empty() {
12344            return Err("Client ID is required.".to_owned());
12345        }
12346        let issuer = self.issuer_url.trim().to_owned();
12347        if kind == "oidc" && issuer.is_empty() {
12348            return Err("A generic OpenID Connect provider needs an issuer URL.".to_owned());
12349        }
12350        let scopes = self.scopes.trim().to_owned();
12351        Ok(ValidatedProvider {
12352            slug,
12353            label,
12354            kind,
12355            issuer_url: (!issuer.is_empty()).then_some(issuer),
12356            client_id,
12357            scopes: (!scopes.is_empty()).then_some(scopes),
12358            enabled: self.enabled.is_some(),
12359            sort_order: self.sort_order.unwrap_or(0),
12360        })
12361    }
12362}
12363
12364struct ValidatedProvider {
12365    slug: String,
12366    label: String,
12367    kind: String,
12368    issuer_url: Option<String>,
12369    client_id: String,
12370    scopes: Option<String>,
12371    enabled: bool,
12372    sort_order: i32,
12373}
12374
12375fn render_sso_provider_form(ctx: &mut Context, mode: &str, provider: serde_json::Value) {
12376    let kinds: Vec<serde_json::Value> = SSO_KINDS
12377        .iter()
12378        .map(|(k, name)| serde_json::json!({ "key": k, "name": name }))
12379        .collect();
12380    ctx.insert("mode", mode);
12381    ctx.insert("kinds", &kinds);
12382    ctx.insert("provider", &provider);
12383}
12384
12385pub async fn sso_provider_new_form(
12386    State(state): State<super::AdminState>,
12387    tenant: Tenant,
12388    headers: HeaderMap,
12389    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12390) -> Result<Response, AdminError> {
12391    // Identity administration is superuser-only (#672).
12392    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12393        return Ok(redirect);
12394    }
12395    let mut ctx = Context::new();
12396    add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12397    add_admin_theme(&mut ctx, tenant.pool()).await;
12398    render_sso_provider_form(
12399        &mut ctx,
12400        "new",
12401        serde_json::json!({
12402            "slug": "", "label": "", "kind": "google", "issuer_url": null,
12403            "client_id": "", "has_secret": false, "scopes": null,
12404            "enabled": true, "sort_order": 0,
12405        }),
12406    );
12407    render_with_csrf(
12408        &state,
12409        &headers,
12410        "rcms_admin/sso_provider_form.html",
12411        &mut ctx,
12412    )
12413}
12414
12415async fn find_sso_provider(
12416    tenant: &Tenant,
12417    id: i64,
12418) -> Result<rustango::admin::SsoProvider, AdminError> {
12419    use rustango::sql::FetcherPool as _;
12420    rustango::admin::SsoProvider::objects()
12421        .filter("id", id)
12422        .fetch(tenant.pool())
12423        .await
12424        .map_err(|e| AdminError::Validation(format!("db: {e}")))?
12425        .into_iter()
12426        .next()
12427        .ok_or(AdminError::NotFound(id))
12428}
12429
12430pub async fn sso_provider_edit_form(
12431    State(state): State<super::AdminState>,
12432    tenant: Tenant,
12433    headers: HeaderMap,
12434    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12435    Path(id): Path<i64>,
12436) -> Result<Response, AdminError> {
12437    // Identity administration is superuser-only (#672).
12438    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12439        return Ok(redirect);
12440    }
12441    let row = find_sso_provider(&tenant, id).await?;
12442    let mut ctx = Context::new();
12443    add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12444    add_admin_theme(&mut ctx, tenant.pool()).await;
12445    render_sso_provider_form(&mut ctx, "edit", sso_provider_json(&row));
12446    render_with_csrf(
12447        &state,
12448        &headers,
12449        "rcms_admin/sso_provider_form.html",
12450        &mut ctx,
12451    )
12452}
12453
12454pub async fn sso_provider_new_submit(
12455    State(_state): State<super::AdminState>,
12456    tenant: Tenant,
12457    headers: HeaderMap,
12458    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12459    Form(form): Form<SsoProviderForm>,
12460) -> Result<Response, AdminError> {
12461    // Identity administration is superuser-only (#672).
12462    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12463        return Ok(redirect);
12464    }
12465    let v = form.validated().map_err(AdminError::Validation)?;
12466    let secret = form.client_secret.trim().to_owned();
12467    if secret.is_empty() {
12468        return Err(AdminError::Validation(
12469            "Client secret is required.".to_owned(),
12470        ));
12471    }
12472    let mut row = rustango::admin::SsoProvider {
12473        id: rustango::sql::Auto::Unset,
12474        slug: v.slug,
12475        label: v.label,
12476        kind: v.kind,
12477        issuer_url: v.issuer_url,
12478        client_id: v.client_id,
12479        client_secret: rustango::casts::Cast::new(secret),
12480        enabled: v.enabled,
12481        sort_order: v.sort_order,
12482        scopes: v.scopes,
12483        allow_email_link: false,
12484        created_at: rustango::sql::Auto::Unset,
12485        updated_at: rustango::sql::Auto::Unset,
12486    };
12487    row.insert_pool(tenant.pool()).await?;
12488    redirect_named_with_message_args(
12489        "rcms-admin:sso-providers:list",
12490        MsgLevel::Success,
12491        "Added SSO provider {label}.",
12492        &[("label", row.label.as_str())],
12493        &headers,
12494    )
12495}
12496
12497pub async fn sso_provider_edit_submit(
12498    State(_state): State<super::AdminState>,
12499    tenant: Tenant,
12500    headers: HeaderMap,
12501    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12502    Path(id): Path<i64>,
12503    Form(form): Form<SsoProviderForm>,
12504) -> Result<Response, AdminError> {
12505    // Identity administration is superuser-only (#672).
12506    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12507        return Ok(redirect);
12508    }
12509    let mut row = find_sso_provider(&tenant, id).await?;
12510    let v = form.validated().map_err(AdminError::Validation)?;
12511    row.slug = v.slug;
12512    row.label = v.label;
12513    row.kind = v.kind;
12514    row.issuer_url = v.issuer_url;
12515    row.client_id = v.client_id;
12516    // Write-only secret: only replace it when a new one was typed; a blank
12517    // field keeps the stored (encrypted) value.
12518    let new_secret = form.client_secret.trim();
12519    if !new_secret.is_empty() {
12520        row.client_secret = rustango::casts::Cast::new(new_secret.to_owned());
12521    }
12522    row.enabled = v.enabled;
12523    row.sort_order = v.sort_order;
12524    row.scopes = v.scopes;
12525    row.save_pool(tenant.pool()).await?;
12526    redirect_named_with_message_args(
12527        "rcms-admin:sso-providers:list",
12528        MsgLevel::Success,
12529        "Saved SSO provider {label}.",
12530        &[("label", row.label.as_str())],
12531        &headers,
12532    )
12533}
12534
12535pub async fn sso_provider_delete_submit(
12536    State(_state): State<super::AdminState>,
12537    tenant: Tenant,
12538    headers: HeaderMap,
12539    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12540    Path(id): Path<i64>,
12541) -> Result<Response, AdminError> {
12542    // Identity administration is superuser-only (#672).
12543    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12544        return Ok(redirect);
12545    }
12546    let row = find_sso_provider(&tenant, id).await?;
12547    let label = row.label.clone();
12548    row.delete_pool(tenant.pool()).await?;
12549    redirect_named_with_message_args(
12550        "rcms-admin:sso-providers:list",
12551        MsgLevel::Success,
12552        "Deleted SSO provider {label}.",
12553        &[("label", label.as_str())],
12554        &headers,
12555    )
12556}
12557
12558/// Clear `is_default = true` on every other row so the new default
12559/// row owns the flag uniquely. Optionally exclude an id when
12560/// editing the same row.
12561async fn clear_default_flag(tenant: &Tenant, except: Option<i64>) -> Result<(), AdminError> {
12562    let rows: Vec<Locale> = Locale::objects()
12563        .where_(Locale::is_default.eq(true))
12564        .fetch(tenant.pool())
12565        .await?;
12566    for mut r in rows {
12567        if let (Some(skip), Some(id)) = (except, r.id.get().copied()) {
12568            if skip == id {
12569                continue;
12570            }
12571        }
12572        r.is_default = false;
12573        r.save_pool(tenant.pool()).await?;
12574    }
12575    Ok(())
12576}
12577
12578// =====================================================================
12579// Workflows — multi-step approval CRUD (#73 PR 1)
12580// =====================================================================
12581
12582pub async fn workflows_list(
12583    State(state): State<super::AdminState>,
12584    tenant: Tenant,
12585    headers: HeaderMap,
12586    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12587) -> Result<Response, AdminError> {
12588    let items: Vec<crate::workflow::Workflow> = crate::workflow::Workflow::objects()
12589        .order_by(&[("name", false)])
12590        .fetch(tenant.pool())
12591        .await?;
12592    // Task counts per workflow — surfaced in the list as a quick
12593    // indicator. One query for all tasks; bucket client-side.
12594    let all_tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12595        .fetch(tenant.pool())
12596        .await?;
12597    let mut task_counts: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
12598    for t in &all_tasks {
12599        *task_counts.entry(t.workflow_id).or_insert(0) += 1;
12600    }
12601    let rows: Vec<serde_json::Value> = items
12602        .iter()
12603        .map(|w| {
12604            let id = w.id.get().copied().unwrap_or_default();
12605            serde_json::json!({
12606                "id": id,
12607                "name": w.name,
12608                "description": w.description,
12609                "active": w.active,
12610                "require_reapproval_on_edit": w.require_reapproval_on_edit,
12611                "task_count": task_counts.get(&id).copied().unwrap_or(0),
12612                "created_at": w.created_at.get().copied(),
12613            })
12614        })
12615        .collect();
12616    let mut ctx = Context::new();
12617    add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12618    add_admin_theme(&mut ctx, tenant.pool()).await;
12619    ctx.insert("items", &rows);
12620    render_with_csrf(&state, &headers, "rcms_admin/workflow_list.html", &mut ctx)
12621}
12622
12623pub async fn workflow_new_form(
12624    State(state): State<super::AdminState>,
12625    tenant: Tenant,
12626    headers: HeaderMap,
12627    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12628) -> Result<Response, AdminError> {
12629    let mut ctx = Context::new();
12630    add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12631    add_admin_theme(&mut ctx, tenant.pool()).await;
12632    ctx.insert("mode", "new");
12633    ctx.insert(
12634        "workflow",
12635        &serde_json::json!({
12636            "name": "",
12637            "description": "",
12638            "active": true,
12639            "require_reapproval_on_edit": false,
12640        }),
12641    );
12642    ctx.insert("tasks", &Vec::<serde_json::Value>::new());
12643    ctx.insert("roles", &Vec::<serde_json::Value>::new());
12644    render_with_csrf(&state, &headers, "rcms_admin/workflow_form.html", &mut ctx)
12645}
12646
12647#[derive(Debug, Deserialize)]
12648pub struct WorkflowForm {
12649    pub name: String,
12650    #[serde(default)]
12651    pub description: String,
12652    #[serde(default)]
12653    pub active: Option<String>,
12654    #[serde(default)]
12655    pub require_reapproval_on_edit: Option<String>,
12656}
12657
12658impl WorkflowForm {
12659    fn parsed_active(&self) -> bool {
12660        self.active.is_some()
12661    }
12662    fn parsed_reapproval(&self) -> bool {
12663        self.require_reapproval_on_edit.is_some()
12664    }
12665}
12666
12667pub async fn workflow_new_submit(
12668    State(_state): State<super::AdminState>,
12669    tenant: Tenant,
12670    headers: HeaderMap,
12671    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12672    Form(form): Form<WorkflowForm>,
12673) -> Result<Response, AdminError> {
12674    use rustango::sql::Auto;
12675    let name = form.name.trim().to_owned();
12676    if name.is_empty() {
12677        return redirect_named_with_message(
12678            "rcms-admin:workflows:list",
12679            MsgLevel::Error,
12680            "Workflow name is required.",
12681            &headers,
12682        );
12683    }
12684    let mut row = crate::workflow::Workflow {
12685        id: Auto::Unset,
12686        name: name.clone(),
12687        description: form.description.trim().to_owned(),
12688        active: form.parsed_active(),
12689        require_reapproval_on_edit: form.parsed_reapproval(),
12690        created_at: Auto::Unset,
12691        updated_at: Auto::Unset,
12692    };
12693    row.insert_pool(tenant.pool()).await?;
12694    let id = row.id.get().copied().unwrap_or_default();
12695    redirect_named_with_params_and_message_args(
12696        "rcms-admin:workflows:edit",
12697        &[("id", id.to_string())],
12698        MsgLevel::Success,
12699        "Created workflow “{name}”. Add review steps below.",
12700        &[("name", name.as_str())],
12701        &headers,
12702    )
12703}
12704
12705pub async fn workflow_edit_form(
12706    State(state): State<super::AdminState>,
12707    tenant: Tenant,
12708    headers: HeaderMap,
12709    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12710    Path(id): Path<i64>,
12711) -> Result<Response, AdminError> {
12712    let row = crate::workflow::Workflow::objects()
12713        .where_(crate::workflow::Workflow::id.eq(id))
12714        .first(tenant.pool())
12715        .await?
12716        .ok_or(AdminError::NotFound(id))?;
12717    let tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12718        .where_(crate::workflow::WorkflowTask::workflow_id.eq(id))
12719        .order_by(&[("sort_order", false), ("id", false)])
12720        .fetch(tenant.pool())
12721        .await?;
12722    // Role picker — every tenant role is a valid assignee for a
12723    // task. Sort alphabetically for predictable ordering.
12724    let roles: Vec<rustango::tenancy::permissions::Role> =
12725        rustango::tenancy::permissions::Role::objects()
12726            .order_by(&[("name", false)])
12727            .fetch(tenant.pool())
12728            .await?;
12729    let role_rows: Vec<serde_json::Value> = roles
12730        .iter()
12731        .map(|r| {
12732            serde_json::json!({
12733                "id": r.id.get().copied(),
12734                "name": r.name,
12735            })
12736        })
12737        .collect();
12738    let role_by_id: std::collections::HashMap<i64, String> = roles
12739        .iter()
12740        .filter_map(|r| r.id.get().copied().map(|id| (id, r.name.clone())))
12741        .collect();
12742    let task_rows: Vec<serde_json::Value> = tasks
12743        .iter()
12744        .map(|t| {
12745            serde_json::json!({
12746                "id": t.id.get().copied(),
12747                "name": t.name,
12748                "role_id": t.role_id,
12749                "role_name": role_by_id.get(&t.role_id).cloned().unwrap_or_default(),
12750                "sort_order": t.sort_order,
12751                "kind": t.kind,
12752                "webhook_url": t.webhook_url,
12753            })
12754        })
12755        .collect();
12756    // #191 — every registered task kind, surfaced to the template
12757    // so the Add-step form can offer the kind picker.
12758    // A person's approval first: it's what a review step normally is,
12759    // and the pre-selected kind.
12760    let mut task_kinds: Vec<serde_json::Value> = crate::task_kind::registered_kinds()
12761        .iter()
12762        .map(|k| {
12763            serde_json::json!({
12764                "name": k.kind_name(),
12765                "verbose_name": k.verbose_name(),
12766            })
12767        })
12768        .collect();
12769    task_kinds.sort_by_key(|k| k["name"] != "group_approval");
12770    let kind_label = |name: &str| {
12771        crate::task_kind::registered_kinds()
12772            .iter()
12773            .find(|k| k.kind_name() == name)
12774            .map_or_else(|| name.to_owned(), |k| k.verbose_name().to_owned())
12775    };
12776    let task_rows: Vec<serde_json::Value> = task_rows
12777        .into_iter()
12778        .map(|mut t| {
12779            let label = kind_label(t["kind"].as_str().unwrap_or_default());
12780            t["kind_label"] = serde_json::Value::String(label);
12781            t
12782        })
12783        .collect();
12784    let mut ctx = Context::new();
12785    add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12786    add_admin_theme(&mut ctx, tenant.pool()).await;
12787    ctx.insert("mode", "edit");
12788    ctx.insert("workflow", &row);
12789    ctx.insert("tasks", &task_rows);
12790    ctx.insert("roles", &role_rows);
12791    ctx.insert("task_kinds", &task_kinds);
12792    render_with_csrf(&state, &headers, "rcms_admin/workflow_form.html", &mut ctx)
12793}
12794
12795pub async fn workflow_edit_submit(
12796    State(_state): State<super::AdminState>,
12797    tenant: Tenant,
12798    headers: HeaderMap,
12799    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12800    Path(id): Path<i64>,
12801    Form(form): Form<WorkflowForm>,
12802) -> Result<Response, AdminError> {
12803    let mut row = crate::workflow::Workflow::objects()
12804        .where_(crate::workflow::Workflow::id.eq(id))
12805        .first(tenant.pool())
12806        .await?
12807        .ok_or(AdminError::NotFound(id))?;
12808    let old_name = row.name.clone();
12809    row.name = form.name.trim().to_owned();
12810    row.description = form.description.trim().to_owned();
12811    row.active = form.parsed_active();
12812    row.require_reapproval_on_edit = form.parsed_reapproval();
12813    row.save_pool(tenant.pool()).await?;
12814    // Page types name their workflow; a rename must move them along, or
12815    // their pages would silently publish without review.
12816    if old_name != row.name {
12817        crate::workflow::rebind_page_types(tenant.pool(), &old_name, &row.name).await?;
12818    }
12819    redirect_named_with_params_and_message_args(
12820        "rcms-admin:workflows:edit",
12821        &[("id", id.to_string())],
12822        MsgLevel::Success,
12823        "Saved workflow “{name}”.",
12824        &[("name", row.name.as_str())],
12825        &headers,
12826    )
12827}
12828
12829pub async fn workflow_delete_submit(
12830    State(_state): State<super::AdminState>,
12831    tenant: Tenant,
12832    headers: HeaderMap,
12833    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12834    Path(id): Path<i64>,
12835) -> Result<Response, AdminError> {
12836    let row = crate::workflow::Workflow::objects()
12837        .where_(crate::workflow::Workflow::id.eq(id))
12838        .first(tenant.pool())
12839        .await?
12840        .ok_or(AdminError::NotFound(id))?;
12841    // Page types that use it would quietly stop requiring review.
12842    let users: Vec<String> = crate::workflow::page_types_using(tenant.pool(), &row.name)
12843        .await?
12844        .into_iter()
12845        .map(|pt| pt.verbose_name)
12846        .collect();
12847    if !users.is_empty() {
12848        let types = users.join(", ");
12849        return redirect_named_with_message_args(
12850            "rcms-admin:workflows:list",
12851            MsgLevel::Error,
12852            "Can't delete “{title}” — the page types {types} use it. Choose another workflow for them first.",
12853            &[("title", row.name.as_str()), ("types", types.as_str())],
12854            &headers,
12855        );
12856    }
12857    // Reject when any WorkflowState references this workflow — the
12858    // audit trail would otherwise lose its parent FK. Editors should
12859    // toggle `active = false` instead.
12860    let in_use: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
12861        .where_(crate::workflow::WorkflowState::workflow_id.eq(id))
12862        .fetch(tenant.pool())
12863        .await?;
12864    if !in_use.is_empty() {
12865        let count = in_use.len().to_string();
12866        return redirect_named_with_message_plural(
12867            "rcms-admin:workflows:list",
12868            MsgLevel::Error,
12869            "Can't delete “{title}” — {count} page(s) have history under it. Toggle Active off instead.",
12870            in_use.len() as i64,
12871            &[("title", row.name.as_str()), ("count", count.as_str())],
12872            &headers,
12873        );
12874    }
12875    // Cascade the task rows by hand (FK isn't ON DELETE CASCADE).
12876    let tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12877        .where_(crate::workflow::WorkflowTask::workflow_id.eq(id))
12878        .fetch(tenant.pool())
12879        .await?;
12880    for t in tasks {
12881        t.delete_pool(tenant.pool()).await?;
12882    }
12883    let name = row.name.clone();
12884    row.delete_pool(tenant.pool()).await?;
12885    redirect_named_with_message_args(
12886        "rcms-admin:workflows:list",
12887        MsgLevel::Success,
12888        "Deleted workflow “{name}”.",
12889        &[("name", name.as_str())],
12890        &headers,
12891    )
12892}
12893
12894#[derive(Debug, Deserialize)]
12895pub struct WorkflowTaskForm {
12896    pub name: String,
12897    pub role_id: i64,
12898    /// Task kind discriminator. Defaults to `group_approval`
12899    /// when the form input is missing or empty so the existing
12900    /// human-approval flow stays the default behavior.
12901    #[serde(default)]
12902    pub kind: Option<String>,
12903    #[serde(default)]
12904    pub webhook_url: Option<String>,
12905}
12906
12907pub async fn workflow_task_add(
12908    State(_state): State<super::AdminState>,
12909    tenant: Tenant,
12910    headers: HeaderMap,
12911    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12912    Path(workflow_id): Path<i64>,
12913    Form(form): Form<WorkflowTaskForm>,
12914) -> Result<Response, AdminError> {
12915    use rustango::sql::Auto;
12916    let name = form.name.trim().to_owned();
12917    if name.is_empty() {
12918        return redirect_named_with_params_and_message(
12919            "rcms-admin:workflows:edit",
12920            &[("id", workflow_id.to_string())],
12921            MsgLevel::Error,
12922            "Step name is required.",
12923            &headers,
12924        );
12925    }
12926    let existing: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12927        .where_(crate::workflow::WorkflowTask::workflow_id.eq(workflow_id))
12928        .order_by(&[("sort_order", true)]) // desc
12929        .fetch(tenant.pool())
12930        .await?;
12931    let next_order = existing.first().map_or(10, |t| t.sort_order + 10);
12932    let kind = form
12933        .kind
12934        .as_deref()
12935        .map(str::trim)
12936        .filter(|s| !s.is_empty())
12937        .filter(|s| crate::task_kind::find(s).is_some())
12938        .unwrap_or("group_approval")
12939        .to_owned();
12940    let webhook_url = form
12941        .webhook_url
12942        .as_deref()
12943        .map(str::trim)
12944        .unwrap_or("")
12945        .to_owned();
12946    let mut row = crate::workflow::WorkflowTask {
12947        id: Auto::Unset,
12948        workflow_id,
12949        name: name.clone(),
12950        role_id: form.role_id,
12951        sort_order: next_order,
12952        kind,
12953        webhook_url,
12954    };
12955    row.insert_pool(tenant.pool()).await?;
12956    redirect_named_with_params_and_message_args(
12957        "rcms-admin:workflows:edit",
12958        &[("id", workflow_id.to_string())],
12959        MsgLevel::Success,
12960        "Added step “{name}”.",
12961        &[("name", name.as_str())],
12962        &headers,
12963    )
12964}
12965
12966pub async fn workflow_task_delete(
12967    State(_state): State<super::AdminState>,
12968    tenant: Tenant,
12969    headers: HeaderMap,
12970    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12971    Path((workflow_id, task_id)): Path<(i64, i64)>,
12972) -> Result<Response, AdminError> {
12973    let row = crate::workflow::WorkflowTask::objects()
12974        .where_(crate::workflow::WorkflowTask::id.eq(task_id))
12975        .where_(crate::workflow::WorkflowTask::workflow_id.eq(workflow_id))
12976        .first(tenant.pool())
12977        .await?
12978        .ok_or(AdminError::NotFound(task_id))?;
12979    let name = row.name.clone();
12980    row.delete_pool(tenant.pool()).await?;
12981    redirect_named_with_params_and_message_args(
12982        "rcms-admin:workflows:edit",
12983        &[("id", workflow_id.to_string())],
12984        MsgLevel::Success,
12985        "Removed step “{name}”.",
12986        &[("name", name.as_str())],
12987        &headers,
12988    )
12989}
12990
12991// ---------------------------------------------------------------
12992// Per-page workflow actions (#73 PR 2): submit / approve / reject /
12993// cancel. Permission rules:
12994//   - submit: any logged-in user (page-Edit perm already gated the
12995//     editor URL).
12996//   - approve / reject: viewer must be a member of the role bound
12997//     to the current task. Tenant superusers bypass.
12998//   - cancel: any logged-in user (audit captures who).
12999// ---------------------------------------------------------------
13000
13001#[derive(Debug, Deserialize)]
13002pub struct WorkflowDecisionForm {
13003    #[serde(default)]
13004    pub comment: String,
13005    /// The step the reviewer was looking at. A decision posted
13006    /// for a step that is no longer current is refused, not applied to
13007    /// whichever step is current now.
13008    #[serde(default)]
13009    pub task_id: Option<i64>,
13010}
13011
13012/// The decision the reviewer posted is for a step that is no
13013/// longer the current one, or another request decided it first.
13014fn step_already_decided(page_id: i64, headers: &HeaderMap) -> Result<Response, AdminError> {
13015    redirect_named_with_params_and_message(
13016        "rcms-admin:pages:edit",
13017        &[("id", page_id.to_string())],
13018        MsgLevel::Error,
13019        "That review step was already decided — check the page's current step before deciding again.",
13020        headers,
13021    )
13022}
13023
13024async fn user_is_in_role(
13025    pool: &rustango::sql::Pool,
13026    user_id: i64,
13027    role_id: i64,
13028) -> Result<bool, rustango::sql::ExecError> {
13029    use rustango::core::Column as _;
13030    use rustango::sql::FetcherPool as _;
13031    let rows: Vec<rustango::tenancy::permissions::UserRole> =
13032        rustango::tenancy::permissions::UserRole::objects()
13033            .where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
13034            .where_(rustango::tenancy::permissions::UserRole::role_id.eq(role_id))
13035            .fetch(pool)
13036            .await?;
13037    Ok(!rows.is_empty())
13038}
13039
13040pub async fn page_workflow_submit(
13041    State(_state): State<super::AdminState>,
13042    tenant: Tenant,
13043    headers: HeaderMap,
13044    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13045    Path(id): Path<i64>,
13046) -> Result<Response, AdminError> {
13047    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
13048        return Ok(unauthorized_no_session());
13049    };
13050    let page = Page::objects()
13051        .where_(Page::id.eq(id))
13052        .first(tenant.pool())
13053        .await?
13054        .ok_or(AdminError::NotFound(id))?;
13055    // Resolve the page-type → workflow slug.
13056    let pts: Vec<PageType> = PageType::objects()
13057        .where_(PageType::id.eq(page.page_type_id))
13058        .fetch(tenant.pool())
13059        .await?;
13060    let Some(pt) = pts.into_iter().next() else {
13061        return redirect_named_with_params_and_message(
13062            "rcms-admin:pages:edit",
13063            &[("id", id.to_string())],
13064            MsgLevel::Error,
13065            "Page type row not found.",
13066            &headers,
13067        );
13068    };
13069    let Some(slug) = pt.workflow_name() else {
13070        return redirect_named_with_params_and_message(
13071            "rcms-admin:pages:edit",
13072            &[("id", id.to_string())],
13073            MsgLevel::Error,
13074            "This page type isn't bound to a workflow — nothing to submit.",
13075            &headers,
13076        );
13077    };
13078    let Some(workflow) = crate::workflow::find_by_name(tenant.pool(), &slug).await? else {
13079        return redirect_named_with_params_and_message_args(
13080            "rcms-admin:pages:edit",
13081            &[("id", id.to_string())],
13082            MsgLevel::Error,
13083            "Workflow `{slug}` not found or inactive — ask an admin to enable it.",
13084            &[("slug", slug.as_str())],
13085            &headers,
13086        );
13087    };
13088    let tasks = crate::workflow::tasks_for(
13089        tenant.pool(),
13090        workflow.id.get().copied().unwrap_or_default(),
13091    )
13092    .await?;
13093    if tasks.is_empty() {
13094        return redirect_named_with_params_and_message(
13095            "rcms-admin:pages:edit",
13096            &[("id", id.to_string())],
13097            MsgLevel::Error,
13098            "Workflow has no review steps yet — ask an admin to add at least one step.",
13099            &headers,
13100        );
13101    }
13102    // Only block when an in-progress review already exists. A
13103    // `needs_changes` row means the prior cycle was rejected; the
13104    // author is allowed to resubmit, which leaves the rejected row
13105    // as audit history and starts a fresh cycle.
13106    if let Some(active) = crate::workflow::active_state_for_page(tenant.pool(), id).await? {
13107        if active.status == crate::workflow::WorkflowStatus::InProgress.as_str() {
13108            return redirect_named_with_params_and_message(
13109                "rcms-admin:pages:edit",
13110                &[("id", id.to_string())],
13111                MsgLevel::Warning,
13112                "This page is already under review.",
13113                &headers,
13114            );
13115        }
13116    }
13117    crate::workflow::submit_for_review(tenant.pool(), id, &workflow, &tasks, viewer_id).await?;
13118    // The submitter waits for the verdict now; their edit lock would
13119    // only stop the reviewer from editing.
13120    crate::lock::release(tenant.pool(), id, viewer_id)
13121        .await
13122        .log_warn("editor lock not released on submit");
13123
13124    // #192 — audit log the workflow submission.
13125    crate::page_log::record_or_warn(
13126        tenant.pool(),
13127        id,
13128        crate::page_log::ACTION_WORKFLOW_SUBMIT,
13129        Some(viewer_id),
13130        format!(
13131            "Submitted for review — workflow “{}”, first step “{}”.",
13132            workflow.name, tasks[0].name
13133        ),
13134        Some(serde_json::json!({
13135            "workflow_id": workflow.id.get().copied(),
13136            "workflow_name": workflow.name,
13137            "first_task": tasks[0].name,
13138        })),
13139    )
13140    .await;
13141
13142    // #85 — notify the first task's reviewers that a review is
13143    // waiting. No-op when no mailer is wired into AdminState.
13144    notify_workflow(
13145        _state.mailer.as_deref(),
13146        &_state.mailer_from,
13147        tenant.pool(),
13148        &tenant.org.slug,
13149        "submit",
13150        &workflow.name,
13151        &page.title,
13152        id,
13153        Some(&tasks[0].name),
13154        session_user.as_ref().map(|u| u.username.as_str()),
13155        None,
13156        WorkflowRecipients::Role(tasks[0].role_id),
13157    )
13158    .await;
13159
13160    redirect_named_with_params_and_message_args(
13161        "rcms-admin:pages:edit",
13162        &[("id", id.to_string())],
13163        MsgLevel::Success,
13164        "Submitted for review — first step: “{name}”.",
13165        &[("name", tasks[0].name.as_str())],
13166        &headers,
13167    )
13168}
13169
13170/// Recipient selector for [`notify_workflow`].
13171enum WorkflowRecipients {
13172    /// Members of a single role (reviewers on the active task).
13173    Role(i64),
13174    /// A single user — used to notify the original submitter on
13175    /// approve-finish / reject / cancel.
13176    User(i64),
13177}
13178
13179/// Helper invoked by the workflow handlers to dispatch the right
13180/// notification per event. Resolves recipients, composes subject +
13181/// body, and hands off to the framework's `Mailer`. No-op if the
13182/// AdminState has no mailer attached.
13183#[allow(clippy::too_many_arguments)]
13184async fn notify_workflow(
13185    mailer: Option<&dyn rustango::email::Mailer>,
13186    from: &str,
13187    pool: &rustango::sql::Pool,
13188    tenant_slug: &str,
13189    event: &str,
13190    workflow_name: &str,
13191    page_title: &str,
13192    page_id: i64,
13193    task_name: Option<&str>,
13194    actor_username: Option<&str>,
13195    comment: Option<&str>,
13196    recipients: WorkflowRecipients,
13197) {
13198    let Some(mailer) = mailer else {
13199        return;
13200    };
13201    // #197 — resolve recipients to user_ids first so we can filter
13202    // out users who have muted this event class before composing
13203    // email bodies.
13204    let kind = crate::notification_pref::pref_kind_for_workflow_event(event);
13205    let candidate_user_ids: Vec<i64> = match recipients {
13206        WorkflowRecipients::Role(role_id) => {
13207            crate::workflow_mail::role_member_user_ids(pool, role_id)
13208                .await
13209                .unwrap_or_default()
13210        }
13211        WorkflowRecipients::User(user_id) => vec![user_id],
13212    };
13213    let allowed_ids = crate::notification_pref::filter_enabled(pool, &candidate_user_ids, kind)
13214        .await
13215        .unwrap_or(candidate_user_ids);
13216    let mut pairs: Vec<(String, String)> = Vec::with_capacity(allowed_ids.len());
13217    for uid in allowed_ids {
13218        if let Ok(Some(pair)) = crate::workflow_mail::user_email(pool, uid, tenant_slug).await {
13219            pairs.push(pair);
13220        }
13221    }
13222    if pairs.is_empty() {
13223        return;
13224    }
13225    let (subject, body) = crate::workflow_mail::render_notification(
13226        event,
13227        workflow_name,
13228        page_title,
13229        page_id,
13230        task_name,
13231        actor_username,
13232        comment,
13233    );
13234    crate::workflow_mail::notify_many(mailer, from, &pairs, &subject, &body).await;
13235}
13236
13237pub async fn page_workflow_approve(
13238    State(_state): State<super::AdminState>,
13239    tenant: Tenant,
13240    headers: HeaderMap,
13241    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13242    Path(id): Path<i64>,
13243    Form(form): Form<WorkflowDecisionForm>,
13244) -> Result<Response, AdminError> {
13245    let Some(viewer) = session_user.as_ref() else {
13246        return Ok(unauthorized_no_session());
13247    };
13248    let viewer_id = viewer.id.get().copied().unwrap_or_default();
13249    let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13250        return redirect_named_with_params_and_message(
13251            "rcms-admin:pages:edit",
13252            &[("id", id.to_string())],
13253            MsgLevel::Error,
13254            "No active workflow on this page.",
13255            &headers,
13256        );
13257    };
13258    let tasks = crate::workflow::tasks_for(tenant.pool(), state.workflow_id).await?;
13259    let Some(current_task) = state
13260        .current_task_id
13261        .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
13262    else {
13263        return redirect_named_with_params_and_message(
13264            "rcms-admin:pages:edit",
13265            &[("id", id.to_string())],
13266            MsgLevel::Error,
13267            "Workflow has no current task — refresh the page.",
13268            &headers,
13269        );
13270    };
13271    if !viewer.is_superuser
13272        && !user_is_in_role(tenant.pool(), viewer_id, current_task.role_id).await?
13273    {
13274        return redirect_named_with_params_and_message_args(
13275            "rcms-admin:pages:edit",
13276            &[("id", id.to_string())],
13277            MsgLevel::Error,
13278            "Only members of the task's role can approve “{name}”.",
13279            &[("name", current_task.name.as_str())],
13280            &headers,
13281        );
13282    }
13283    if form.task_id.is_some_and(|t| current_task.id.get().copied() != Some(t)) {
13284        return step_already_decided(id, &headers);
13285    }
13286    // Capture submitter_id + page title BEFORE the transition so we
13287    // can route the notification on Finished.
13288    let submitter_id = state.requested_by;
13289    let page_title: String = Page::objects()
13290        .where_(Page::id.eq(id))
13291        .fetch(tenant.pool())
13292        .await
13293        .ok()
13294        .and_then(|v| v.into_iter().next())
13295        .map(|p| p.title)
13296        .unwrap_or_else(|| format!("page #{id}"));
13297    let workflow_name: String = crate::workflow::Workflow::objects()
13298        .where_(crate::workflow::Workflow::id.eq(state.workflow_id))
13299        .fetch(tenant.pool())
13300        .await
13301        .ok()
13302        .and_then(|v| v.into_iter().next())
13303        .map(|w| w.name)
13304        .unwrap_or_else(|| "Workflow".to_owned());
13305    let outcome = crate::workflow::approve_current(
13306        tenant.pool(),
13307        &mut state,
13308        &tasks,
13309        viewer_id,
13310        &form.comment,
13311    )
13312    .await?;
13313    let msg = match outcome {
13314        crate::workflow::ApproveOutcome::AlreadyDecided => {
13315            return step_already_decided(id, &headers);
13316        }
13317        crate::workflow::ApproveOutcome::Advanced { next_task_id } => {
13318            let next = tasks
13319                .iter()
13320                .find(|t| t.id.get().copied() == Some(next_task_id));
13321            let next_name = next.map(|t| t.name.as_str()).unwrap_or("next step");
13322            // #85 — notify reviewers of the new current step.
13323            if let Some(nt) = next {
13324                notify_workflow(
13325                    _state.mailer.as_deref(),
13326                    &_state.mailer_from,
13327                    tenant.pool(),
13328                    &tenant.org.slug,
13329                    "approve_advance",
13330                    &workflow_name,
13331                    &page_title,
13332                    id,
13333                    Some(&nt.name),
13334                    Some(&viewer.username),
13335                    Some(&form.comment),
13336                    WorkflowRecipients::Role(nt.role_id),
13337                )
13338                .await;
13339            }
13340            // #192 — audit log the approve-advance.
13341            crate::page_log::record_or_warn(
13342                tenant.pool(),
13343                id,
13344                crate::page_log::ACTION_WORKFLOW_APPROVE,
13345                Some(viewer_id),
13346                format!(
13347                    "Approved “{}” — advanced to “{next_name}”.",
13348                    current_task.name
13349                ),
13350                Some(serde_json::json!({
13351                    "outcome": "advanced",
13352                    "task_name": current_task.name,
13353                    "next_task_name": next_name,
13354                    "comment": form.comment,
13355                })),
13356            )
13357            .await;
13358            format!("Approved “{}” — moved to “{next_name}”.", current_task.name)
13359        }
13360        crate::workflow::ApproveOutcome::Finished => {
13361            // Changes to the live page held for this review go live now,
13362            // through the normal save path.
13363            if let Some(pending) = crate::pending_change::for_page(tenant.pool(), id).await? {
13364                match apply_page_edit(
13365                    tenant.pool(),
13366                    &tenant.org.slug,
13367                    &_state.cache_invalidator,
13368                    _state.mailer.as_deref(),
13369                    &_state.mailer_from,
13370                    false,
13371                    id,
13372                    &pending.form_map(),
13373                    None,
13374                )
13375                .await
13376                {
13377                    Ok(Ok(_)) => crate::pending_change::discard(tenant.pool(), id).await?,
13378                    Ok(Err(_)) | Err(_) => {
13379                        tracing::warn!(page_id = id, "held change could not be applied on approval");
13380                    }
13381                }
13382            }
13383            // Auto-publish on workflow completion.
13384            if let Some(mut page) = Page::objects()
13385                .where_(Page::id.eq(id))
13386                .first(tenant.pool())
13387                .await?
13388            {
13389                page.status = crate::page::PageStatus::Published.as_str().to_owned();
13390                let now = chrono::Utc::now();
13391                if page.published_at.is_none() {
13392                    page.published_at = Some(now);
13393                }
13394                // #251 — workflow-finish publish bumps last-publish.
13395                page.last_published_at = Some(now);
13396                page.save_pool(tenant.pool()).await?;
13397                // #692 — the same go-live effects as any other publish
13398                // (search index + after_publish_page hooks), and the page's
13399                // cached URL goes too: it used to keep serving the old copy.
13400                crate::page::went_live_effects(&tenant.org.slug, &page).await;
13401                crate::task_queue::purge_urls(
13402                    _state.cache_invalidator.clone(),
13403                    tenant.org.slug.clone(),
13404                    vec![page.url_path.clone()],
13405                )
13406                .await;
13407                // #115 — notify-on-publish subscribers.
13408                crate::page_subscription::notify_publish(
13409                    _state.mailer.as_deref(),
13410                    &_state.mailer_from,
13411                    tenant.pool(),
13412                    &tenant.org.slug,
13413                    id,
13414                    &page.title,
13415                    &page.url_path,
13416                    Some(&viewer.username),
13417                )
13418                .await;
13419            }
13420            // #85 — notify the submitter that their submission shipped.
13421            notify_workflow(
13422                _state.mailer.as_deref(),
13423                &_state.mailer_from,
13424                tenant.pool(),
13425                &tenant.org.slug,
13426                "approve_finish",
13427                &workflow_name,
13428                &page_title,
13429                id,
13430                Some(&current_task.name),
13431                Some(&viewer.username),
13432                Some(&form.comment),
13433                WorkflowRecipients::User(submitter_id),
13434            )
13435            .await;
13436            // #192 — audit log the workflow-finish approval + the
13437            // auto-publish it triggered.
13438            crate::page_log::record_or_warn(
13439                tenant.pool(),
13440                id,
13441                crate::page_log::ACTION_WORKFLOW_APPROVE,
13442                Some(viewer_id),
13443                format!(
13444                    "Approved “{}” — workflow complete; page auto-published.",
13445                    current_task.name
13446                ),
13447                Some(serde_json::json!({
13448                    "outcome": "finished",
13449                    "task_name": current_task.name,
13450                    "comment": form.comment,
13451                })),
13452            )
13453            .await;
13454            crate::page_log::record_or_warn(
13455                tenant.pool(),
13456                id,
13457                crate::page_log::ACTION_PUBLISH,
13458                Some(viewer_id),
13459                "Published via workflow approval.",
13460                Some(serde_json::json!({ "via": "workflow" })),
13461            )
13462            .await;
13463            format!(
13464                "Approved “{}” — workflow complete, page published.",
13465                current_task.name
13466            )
13467        }
13468    };
13469    redirect_named_with_params_and_message(
13470        "rcms-admin:pages:edit",
13471        &[("id", id.to_string())],
13472        MsgLevel::Success,
13473        &msg,
13474        &headers,
13475    )
13476}
13477
13478pub async fn page_workflow_reject(
13479    State(_state): State<super::AdminState>,
13480    tenant: Tenant,
13481    headers: HeaderMap,
13482    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13483    Path(id): Path<i64>,
13484    Form(form): Form<WorkflowDecisionForm>,
13485) -> Result<Response, AdminError> {
13486    let Some(viewer) = session_user.as_ref() else {
13487        return Ok(unauthorized_no_session());
13488    };
13489    let viewer_id = viewer.id.get().copied().unwrap_or_default();
13490    let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13491        return redirect_named_with_params_and_message(
13492            "rcms-admin:pages:edit",
13493            &[("id", id.to_string())],
13494            MsgLevel::Error,
13495            "No active workflow on this page.",
13496            &headers,
13497        );
13498    };
13499    let tasks = crate::workflow::tasks_for(tenant.pool(), state.workflow_id).await?;
13500    let Some(current_task) = state
13501        .current_task_id
13502        .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
13503    else {
13504        return redirect_named_with_params_and_message(
13505            "rcms-admin:pages:edit",
13506            &[("id", id.to_string())],
13507            MsgLevel::Error,
13508            "Workflow has no current task — refresh the page.",
13509            &headers,
13510        );
13511    };
13512    if !viewer.is_superuser
13513        && !user_is_in_role(tenant.pool(), viewer_id, current_task.role_id).await?
13514    {
13515        return redirect_named_with_params_and_message_args(
13516            "rcms-admin:pages:edit",
13517            &[("id", id.to_string())],
13518            MsgLevel::Error,
13519            "Only members of the task's role can reject “{name}”.",
13520            &[("name", current_task.name.as_str())],
13521            &headers,
13522        );
13523    }
13524    if form.task_id.is_some_and(|t| current_task.id.get().copied() != Some(t)) {
13525        return step_already_decided(id, &headers);
13526    }
13527    if form.comment.trim().is_empty() {
13528        return redirect_named_with_params_and_message(
13529            "rcms-admin:pages:edit",
13530            &[("id", id.to_string())],
13531            MsgLevel::Error,
13532            "Say what should change — the author sees it in the review history.",
13533            &headers,
13534        );
13535    }
13536    let submitter_id = state.requested_by;
13537    let workflow_id = state.workflow_id;
13538    if !crate::workflow::reject_current(tenant.pool(), &mut state, viewer_id, &form.comment).await? {
13539        return step_already_decided(id, &headers);
13540    }
13541    // #192 — audit log the rejection.
13542    crate::page_log::record_or_warn(
13543        tenant.pool(),
13544        id,
13545        crate::page_log::ACTION_WORKFLOW_REJECT,
13546        Some(viewer_id),
13547        format!("Rejected “{}” — changes requested.", current_task.name),
13548        Some(serde_json::json!({
13549            "task_name": current_task.name,
13550            "comment": form.comment,
13551        })),
13552    )
13553    .await;
13554    // #85 — notify the submitter that changes are requested.
13555    let workflow_name: String = crate::workflow::Workflow::objects()
13556        .where_(crate::workflow::Workflow::id.eq(workflow_id))
13557        .fetch(tenant.pool())
13558        .await
13559        .ok()
13560        .and_then(|v| v.into_iter().next())
13561        .map(|w| w.name)
13562        .unwrap_or_else(|| "Workflow".to_owned());
13563    let page_title: String = Page::objects()
13564        .where_(Page::id.eq(id))
13565        .fetch(tenant.pool())
13566        .await
13567        .ok()
13568        .and_then(|v| v.into_iter().next())
13569        .map(|p| p.title)
13570        .unwrap_or_else(|| format!("page #{id}"));
13571    notify_workflow(
13572        _state.mailer.as_deref(),
13573        &_state.mailer_from,
13574        tenant.pool(),
13575        &tenant.org.slug,
13576        "reject",
13577        &workflow_name,
13578        &page_title,
13579        id,
13580        Some(&current_task.name),
13581        Some(&viewer.username),
13582        Some(&form.comment),
13583        WorkflowRecipients::User(submitter_id),
13584    )
13585    .await;
13586    redirect_named_with_params_and_message_args(
13587        "rcms-admin:pages:edit",
13588        &[("id", id.to_string())],
13589        MsgLevel::Success,
13590        "Rejected “{name}” — page returned to author for changes.",
13591        &[("name", current_task.name.as_str())],
13592        &headers,
13593    )
13594}
13595
13596pub async fn page_workflow_cancel(
13597    State(_state): State<super::AdminState>,
13598    tenant: Tenant,
13599    headers: HeaderMap,
13600    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13601    Path(id): Path<i64>,
13602) -> Result<Response, AdminError> {
13603    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
13604        return Ok(unauthorized_no_session());
13605    };
13606    let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13607        return redirect_named_with_params_and_message(
13608            "rcms-admin:pages:edit",
13609            &[("id", id.to_string())],
13610            MsgLevel::Warning,
13611            "This page isn't currently under review.",
13612            &headers,
13613        );
13614    };
13615    let submitter_id = state.requested_by;
13616    let workflow_id = state.workflow_id;
13617    crate::workflow::cancel(tenant.pool(), &mut state, viewer_id).await?;
13618    // #192 — audit log the cancellation.
13619    crate::page_log::record_or_warn(
13620        tenant.pool(),
13621        id,
13622        crate::page_log::ACTION_WORKFLOW_CANCEL,
13623        Some(viewer_id),
13624        "Workflow cancelled.",
13625        Some(serde_json::json!({ "workflow_id": workflow_id })),
13626    )
13627    .await;
13628    // #85 — notify the submitter the review was cancelled. No-op
13629    // when the submitter is the canceller themselves (the mailer
13630    // still sends but the user's inbox is the audit trail).
13631    let workflow_name: String = crate::workflow::Workflow::objects()
13632        .where_(crate::workflow::Workflow::id.eq(workflow_id))
13633        .fetch(tenant.pool())
13634        .await
13635        .ok()
13636        .and_then(|v| v.into_iter().next())
13637        .map(|w| w.name)
13638        .unwrap_or_else(|| "Workflow".to_owned());
13639    let page_title: String = Page::objects()
13640        .where_(Page::id.eq(id))
13641        .fetch(tenant.pool())
13642        .await
13643        .ok()
13644        .and_then(|v| v.into_iter().next())
13645        .map(|p| p.title)
13646        .unwrap_or_else(|| format!("page #{id}"));
13647    let actor_username = session_user.as_ref().map(|u| u.username.as_str());
13648    notify_workflow(
13649        _state.mailer.as_deref(),
13650        &_state.mailer_from,
13651        tenant.pool(),
13652        &tenant.org.slug,
13653        "cancel",
13654        &workflow_name,
13655        &page_title,
13656        id,
13657        None,
13658        actor_username,
13659        None,
13660        WorkflowRecipients::User(submitter_id),
13661    )
13662    .await;
13663    redirect_named_with_params_and_message(
13664        "rcms-admin:pages:edit",
13665        &[("id", id.to_string())],
13666        MsgLevel::Success,
13667        "Workflow cancelled.",
13668        &headers,
13669    )
13670}
13671
13672// =====================================================================
13673// Per-page audit log CSV export (#192)
13674// =====================================================================
13675
13676/// GET /cms-admin/pages/{id}/log.csv — every audit-log entry for the
13677/// page, newest first, as CSV. Columns: timestamp, action, actor_id,
13678/// actor_username, message, data_json. The full log (no row cap)
13679/// emits — the editor explicitly clicked Download.
13680pub async fn page_log_csv(
13681    State(_state): State<super::AdminState>,
13682    tenant: Tenant,
13683    Path(id): Path<i64>,
13684) -> Result<Response, AdminError> {
13685    let entries = crate::page_log::for_page(tenant.pool(), id, None).await?;
13686    let user_ids: std::collections::BTreeSet<i64> =
13687        entries.iter().filter_map(|e| e.actor_id).collect();
13688    let users: std::collections::HashMap<i64, String> = if user_ids.is_empty() {
13689        std::collections::HashMap::new()
13690    } else {
13691        rustango::tenancy::auth::User::objects()
13692            .where_(
13693                rustango::tenancy::auth::User::id.is_in(user_ids.into_iter().collect::<Vec<_>>()),
13694            )
13695            .fetch(tenant.pool())
13696            .await?
13697            .into_iter()
13698            .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
13699            .collect()
13700    };
13701
13702    let mut out = String::with_capacity(4096);
13703    out.push_str("timestamp,action,actor_id,actor_username,message,data_json\n");
13704    for e in entries {
13705        let ts = e
13706            .created_at
13707            .get()
13708            .map(|t| t.to_rfc3339())
13709            .unwrap_or_default();
13710        let actor_id = e.actor_id.map(|i| i.to_string()).unwrap_or_default();
13711        let actor_username = e
13712            .actor_id
13713            .and_then(|uid| users.get(&uid).cloned())
13714            .unwrap_or_default();
13715        out.push_str(&csv_escape(&ts));
13716        out.push(',');
13717        out.push_str(&csv_escape(&e.action));
13718        out.push(',');
13719        out.push_str(&csv_escape(&actor_id));
13720        out.push(',');
13721        out.push_str(&csv_escape(&actor_username));
13722        out.push(',');
13723        out.push_str(&csv_escape(&e.message));
13724        out.push(',');
13725        out.push_str(&csv_escape(&e.data_json));
13726        out.push('\n');
13727    }
13728
13729    let filename = format!("page-{id}-audit-log.csv");
13730    Ok((
13731        [
13732            (
13733                axum::http::header::CONTENT_TYPE,
13734                "text/csv; charset=utf-8".to_owned(),
13735            ),
13736            (
13737                axum::http::header::CONTENT_DISPOSITION,
13738                format!("attachment; filename=\"{filename}\""),
13739            ),
13740        ],
13741        out,
13742    )
13743        .into_response())
13744}
13745
13746// =====================================================================
13747// History — tenant-wide revision audit log (#17)
13748// =====================================================================
13749
13750/// Query string for the history view. All filters optional; pagination
13751/// via `page` (1-indexed, defaults to 1 — `limit` is fixed at 50 to
13752/// keep the URL state simple).
13753#[derive(Debug, Deserialize)]
13754pub struct HistoryQuery {
13755    #[serde(default)]
13756    pub page_id: Option<i64>,
13757    #[serde(default)]
13758    pub user_id: Option<i64>,
13759    #[serde(default)]
13760    pub page: Option<u32>,
13761    /// Rows per page.
13762    #[serde(default)]
13763    pub per_page: Option<usize>,
13764}
13765
13766/// GET /cms-admin/history — tenant-wide cross-page audit log built
13767/// from `cms_revision`. Each row joins to the page (for title +
13768/// current URL) and the editor (for username). One Rust-side stitch
13769/// pass instead of a SQL JOIN since the ORM doesn't expose joins
13770/// fluently yet.
13771pub async fn history_page(
13772    State(state): State<super::AdminState>,
13773    tenant: Tenant,
13774    headers: HeaderMap,
13775    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13776    Query(q): Query<HistoryQuery>,
13777    axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
13778) -> Result<Response, AdminError> {
13779    let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
13780
13781    // Build the base query with optional filters. The ORM's
13782    // `.where_()` is additive (AND); we apply each filter only when
13783    // present so the SQL stays minimal.
13784    let mut revisions_query =
13785        crate::revision::Revision::objects().order_by(&[("created_at", true)]); // desc — newest first
13786    if let Some(pid) = q.page_id {
13787        revisions_query = revisions_query.where_(crate::revision::Revision::page_id.eq(pid));
13788    }
13789    if let Some(uid) = q.user_id {
13790        revisions_query =
13791            revisions_query.where_(crate::revision::Revision::created_by.eq(Some(uid)));
13792    }
13793
13794    // The ORM builder has no server-side limit/offset yet, so we fetch
13795    // all matching rows then page in memory via
13796    // `rustango::pagination::Paginator` (matches the snippet list).
13797    // `get_page()` clamps out-of-range numbers to the last page, so the
13798    // prev/next links never dangle. Acceptable on the 50-row scale.
13799    let all: Vec<crate::revision::Revision> = revisions_query.fetch(tenant.pool()).await?;
13800    let total = all.len();
13801    let paginator = rustango::pagination::Paginator::new(total, page_size);
13802    let page_obj = paginator.get_page(q.page.unwrap_or(1).max(1) as i64);
13803    let current_page = page_obj.number as u32;
13804    let has_next = page_obj.has_next();
13805    let has_prev = page_obj.has_previous();
13806    let revisions: Vec<crate::revision::Revision> = if total == 0 {
13807        Vec::new()
13808    } else {
13809        all[page_obj.start_index().saturating_sub(1)..page_obj.end_index()].to_vec()
13810    };
13811
13812    // Batch-fetch every distinct page + user referenced by this slice.
13813    let page_ids: std::collections::BTreeSet<i64> = revisions.iter().map(|r| r.page_id).collect();
13814    let user_ids: std::collections::BTreeSet<i64> =
13815        revisions.iter().filter_map(|r| r.created_by).collect();
13816
13817    let pages: Vec<Page> = if page_ids.is_empty() {
13818        Vec::new()
13819    } else {
13820        Page::objects()
13821            .where_(Page::id.is_in(page_ids.iter().copied()))
13822            .fetch(tenant.pool())
13823            .await?
13824    };
13825    let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
13826        Vec::new()
13827    } else {
13828        rustango::tenancy::auth::User::objects()
13829            .where_(rustango::tenancy::auth::User::id.is_in(user_ids.iter().copied()))
13830            .fetch(tenant.pool())
13831            .await?
13832    };
13833
13834    let pages_by_id: std::collections::HashMap<i64, &Page> = pages
13835        .iter()
13836        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
13837        .collect();
13838    let users_by_id: std::collections::HashMap<i64, &rustango::tenancy::auth::User> = users
13839        .iter()
13840        .filter_map(|u| u.id.get().copied().map(|id| (id, u)))
13841        .collect();
13842
13843    // Build a list of view-model dicts for the template — each row
13844    // carries everything Tera needs (no further lookups inside the
13845    // template loop). `is_latest` flags the most-recent revision for
13846    // each page so the UI can disable revert on the current state.
13847    let mut latest_seq_by_page: std::collections::HashMap<i64, i32> =
13848        std::collections::HashMap::new();
13849    for r in &all {
13850        let cur = latest_seq_by_page.entry(r.page_id).or_insert(r.sequence);
13851        if r.sequence > *cur {
13852            *cur = r.sequence;
13853        }
13854    }
13855    // #74 — surface the prior revision's id + sequence per row so
13856    // the history list's Compare button can deep-link to the diff
13857    // view. "Prior" = next-lower sequence on the same page. Built
13858    // from `all` (not the page slice) so a row at the slice boundary
13859    // still knows its predecessor.
13860    let mut by_page: std::collections::HashMap<i64, Vec<&crate::revision::Revision>> =
13861        std::collections::HashMap::new();
13862    for r in &all {
13863        by_page.entry(r.page_id).or_default().push(r);
13864    }
13865    let mut prev_by_id: std::collections::HashMap<i64, (i64, i32)> =
13866        std::collections::HashMap::new();
13867    for (_pid, mut list) in by_page {
13868        list.sort_by_key(|r| r.sequence);
13869        for window in list.windows(2) {
13870            let earlier = window[0];
13871            let later = window[1];
13872            if let (Some(later_id), Some(earlier_id)) =
13873                (later.id.get().copied(), earlier.id.get().copied())
13874            {
13875                prev_by_id.insert(later_id, (earlier_id, earlier.sequence));
13876            }
13877        }
13878    }
13879
13880    let rows: Vec<serde_json::Value> = revisions
13881        .iter()
13882        .map(|r| {
13883            let page = pages_by_id.get(&r.page_id);
13884            let user = r.created_by.and_then(|uid| users_by_id.get(&uid));
13885            let created_at = r.created_at.get().copied();
13886            let (prev_id, prev_sequence) =
13887                r.id.get()
13888                    .copied()
13889                    .and_then(|id| prev_by_id.get(&id).copied())
13890                    .map(|(a, b)| (Some(a), Some(b)))
13891                    .unwrap_or((None, None));
13892            let is_latest = latest_seq_by_page
13893                .get(&r.page_id)
13894                .is_some_and(|s| *s == r.sequence);
13895            serde_json::json!({
13896                "id": r.id.get().copied(),
13897                "page_id": r.page_id,
13898                "sequence": r.sequence,
13899                "created_at": created_at,
13900                "page_title": page.map(|p| p.title.clone()),
13901                "page_url_path": page.map(|p| p.url_path.clone()),
13902                "page_status": page.map(|p| p.status.as_str()),
13903                "username": user.map(|u| u.username.clone()),
13904                "system_user": r.created_by.is_none(),
13905                "is_latest": is_latest,
13906                "prev_id": prev_id,
13907                "prev_sequence": prev_sequence,
13908            })
13909        })
13910        .collect();
13911
13912    let mut ctx = Context::new();
13913    add_chrome(&mut ctx, &tenant, "history", session_user.as_ref()).await;
13914    add_admin_theme(&mut ctx, tenant.pool()).await;
13915    ctx.insert("rows", &rows);
13916    ctx.insert("filter_page_id", &q.page_id);
13917    ctx.insert("filter_user_id", &q.user_id);
13918    // #316 — raw query string for the `| querystring(page=…)` pagination
13919    // links (preserves the page_id / user_id filters + sets page).
13920    ctx.insert("query_string", &raw_query.unwrap_or_default());
13921    ctx.insert("current_page", &current_page);
13922    ctx.insert("has_next", &has_next);
13923    ctx.insert("has_prev", &has_prev);
13924    ctx.insert("total", &total);
13925    ctx.insert("page_size", &page_size);
13926    ctx.insert(
13927        "pagination",
13928        &crate::admin::pagination::context(current_page as i64, page_size, total),
13929    );
13930    render_with_csrf(&state, &headers, "rcms_admin/history.html", &mut ctx)
13931}
13932
13933/// Query string for the diff view: required `a` + `b` revision ids.
13934/// `only_changes` (default true) hides unchanged fields when the
13935/// template renders.
13936#[derive(Debug, Deserialize)]
13937pub struct HistoryDiffQuery {
13938    pub a: i64,
13939    pub b: i64,
13940    #[serde(default)]
13941    pub all: Option<String>,
13942}
13943
13944/// GET /cms-admin/pages/{id}/history/diff?a=<rev_id>&b=<rev_id>.
13945/// Side-by-side comparison of two revisions on the same
13946/// page. v1 surfaces a flat field-level diff; rich-text +
13947/// StreamField-aware diff is a follow-up.
13948pub async fn history_diff(
13949    State(state): State<super::AdminState>,
13950    tenant: Tenant,
13951    headers: HeaderMap,
13952    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13953    Path(page_id): Path<i64>,
13954    Query(q): Query<HistoryDiffQuery>,
13955) -> Result<Response, AdminError> {
13956    let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
13957        .where_(crate::revision::Revision::page_id.eq(page_id))
13958        .where_(crate::revision::Revision::id.is_in([q.a, q.b]))
13959        .fetch(tenant.pool())
13960        .await?;
13961    let a_row = revisions
13962        .iter()
13963        .find(|r| r.id.get().copied() == Some(q.a))
13964        .cloned()
13965        .ok_or(AdminError::NotFound(q.a))?;
13966    let b_row = revisions
13967        .iter()
13968        .find(|r| r.id.get().copied() == Some(q.b))
13969        .cloned()
13970        .ok_or(AdminError::NotFound(q.b))?;
13971
13972    let page = Page::objects()
13973        .where_(Page::id.eq(page_id))
13974        .first(tenant.pool())
13975        .await?
13976        .ok_or(AdminError::NotFound(page_id))?;
13977
13978    // Reviewer name lookup for the header.
13979    let user_ids: Vec<i64> = [a_row.created_by, b_row.created_by]
13980        .into_iter()
13981        .flatten()
13982        .collect();
13983    let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
13984        Vec::new()
13985    } else {
13986        rustango::tenancy::auth::User::objects()
13987            .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
13988            .fetch(tenant.pool())
13989            .await?
13990    };
13991    let username_for = |uid: Option<i64>| -> Option<String> {
13992        uid.and_then(|id| {
13993            users
13994                .iter()
13995                .find(|u| u.id.get().copied() == Some(id))
13996                .map(|u| u.username.clone())
13997        })
13998    };
13999
14000    let diffs = crate::revision::diff_snapshots(&a_row.snapshot, &b_row.snapshot);
14001    let changed_count = diffs.iter().filter(|d| d.is_change()).count();
14002    let only_changes = q.all.is_none();
14003
14004    let mut ctx = Context::new();
14005    add_chrome(&mut ctx, &tenant, "history", session_user.as_ref()).await;
14006    add_admin_theme(&mut ctx, tenant.pool()).await;
14007    ctx.insert("page", &page);
14008    ctx.insert(
14009        "rev_a",
14010        &serde_json::json!({
14011            "id": a_row.id.get().copied(),
14012            "sequence": a_row.sequence,
14013            "created_at": a_row.created_at.get().copied(),
14014            "username": username_for(a_row.created_by),
14015        }),
14016    );
14017    ctx.insert(
14018        "rev_b",
14019        &serde_json::json!({
14020            "id": b_row.id.get().copied(),
14021            "sequence": b_row.sequence,
14022            "created_at": b_row.created_at.get().copied(),
14023            "username": username_for(b_row.created_by),
14024        }),
14025    );
14026    ctx.insert("diffs", &diffs);
14027    ctx.insert("changed_count", &changed_count);
14028    ctx.insert("only_changes", &only_changes);
14029    render_with_csrf(&state, &headers, "rcms_admin/history_diff.html", &mut ctx)
14030}
14031
14032// =====================================================================
14033// Aging-pages report (#101)
14034// =====================================================================
14035
14036#[derive(Debug, Deserialize)]
14037pub struct AnalyticsQuery {
14038    /// Window in days back from now — defaults to 30, clamped 1..=365.
14039    #[serde(default)]
14040    pub days: Option<i64>,
14041}
14042
14043/// GET /cms-admin/analytics — the default first-party analytics
14044/// dashboard: unique visitors, pageviews, bounce, avg time, top pages /
14045/// referrers / countries / devices, a per-day series, and "active now".
14046pub async fn analytics_dashboard(
14047    State(state): State<super::AdminState>,
14048    tenant: Tenant,
14049    headers: HeaderMap,
14050    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14051    Query(q): Query<AnalyticsQuery>,
14052) -> Result<Response, AdminError> {
14053    let days = q.days.unwrap_or(30).clamp(1, 365);
14054    let to = chrono::Utc::now();
14055    let from = to - chrono::Duration::days(days);
14056    let metrics = crate::analytics::query::compute(tenant.pool(), from, to).await?;
14057    let host = headers
14058        .get(header::HOST)
14059        .and_then(|v| v.to_str().ok())
14060        .unwrap_or("");
14061    let active_now = crate::analytics::presence_count(host);
14062    // Max pageviews across the series → the 100%-height reference for the
14063    // bar chart (min 1 to avoid divide-by-zero).
14064    let series_max = metrics
14065        .series
14066        .iter()
14067        .map(|p| p.pageviews)
14068        .max()
14069        .unwrap_or(0)
14070        .max(1);
14071
14072    let mut ctx = Context::new();
14073    add_chrome(&mut ctx, &tenant, "analytics", session_user.as_ref()).await;
14074    add_admin_theme(&mut ctx, tenant.pool()).await;
14075    ctx.insert("metrics", &metrics);
14076    ctx.insert("active_now", &active_now);
14077    ctx.insert("series_max", &series_max);
14078    ctx.insert("days", &days);
14079    render_with_csrf(&state, &headers, "rcms_admin/analytics.html", &mut ctx)
14080}
14081
14082#[derive(Debug, Deserialize)]
14083pub struct AgingQuery {
14084    /// Minimum days stale — defaults to 90.
14085    #[serde(default)]
14086    pub min_days: Option<i64>,
14087    /// Status filter — defaults to "published". Pass `all` to skip.
14088    #[serde(default)]
14089    pub status: Option<String>,
14090    /// 1-indexed page number.
14091    #[serde(default)]
14092    pub page: Option<u32>,
14093    /// Rows per page.
14094    #[serde(default)]
14095    pub per_page: Option<usize>,
14096}
14097
14098/// GET /cms-admin/reports/aging — table of pages sorted by
14099/// `updated_at` ascending (oldest first). Editors use this to spot
14100/// pages that have gone stale.
14101pub async fn aging_pages_report(
14102    State(state): State<super::AdminState>,
14103    tenant: Tenant,
14104    headers: HeaderMap,
14105    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14106    Query(q): Query<AgingQuery>,
14107    axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
14108) -> Result<Response, AdminError> {
14109    let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
14110    let min_days = q.min_days.unwrap_or(90).max(0);
14111    let status_filter = q
14112        .status
14113        .as_deref()
14114        .map(str::trim)
14115        .filter(|s| !s.is_empty() && *s != "all")
14116        .map(str::to_owned)
14117        .unwrap_or_else(|| "published".to_owned());
14118
14119    let now = chrono::Utc::now();
14120    let mut q_pages = Page::objects().order_by(&[("updated_at", false)]); // asc
14121    if status_filter != "all" {
14122        q_pages = q_pages.where_(Page::status.eq(status_filter.clone()));
14123    }
14124    let all: Vec<Page> = q_pages.fetch(tenant.pool()).await?;
14125
14126    // Filter by min-days-stale.
14127    let stale: Vec<&Page> = all
14128        .iter()
14129        .filter(|p| match p.updated_at.get().copied() {
14130            Some(ts) => {
14131                let delta = now.signed_duration_since(ts).num_days();
14132                delta >= min_days
14133            }
14134            None => false,
14135        })
14136        .collect();
14137    let total = stale.len();
14138    // Page in memory via `rustango::pagination::Paginator` (matches the
14139    // snippet list); `get_page()` clamps out-of-range numbers to the
14140    // last page so prev/next links never dangle.
14141    let paginator = rustango::pagination::Paginator::new(total, page_size);
14142    let page_obj = paginator.get_page(q.page.unwrap_or(1).max(1) as i64);
14143    let current_page = page_obj.number as u32;
14144    let has_next = page_obj.has_next();
14145    let has_prev = page_obj.has_previous();
14146    let slice: Vec<&&Page> = if total == 0 {
14147        Vec::new()
14148    } else {
14149        stale[page_obj.start_index().saturating_sub(1)..page_obj.end_index()]
14150            .iter()
14151            .collect()
14152    };
14153
14154    // Per-row last editor — pulled from the latest revision per
14155    // page in one batched query.
14156    let page_ids: Vec<i64> = slice.iter().filter_map(|p| p.id.get().copied()).collect();
14157    let revisions: Vec<crate::revision::Revision> = if page_ids.is_empty() {
14158        Vec::new()
14159    } else {
14160        crate::revision::Revision::objects()
14161            .where_(crate::revision::Revision::page_id.is_in(page_ids.iter().copied()))
14162            .order_by(&[("sequence", true)]) // desc, so newest sequence per page first
14163            .fetch(tenant.pool())
14164            .await
14165            .unwrap_or_default()
14166    };
14167    let mut last_editor_by_page: std::collections::HashMap<i64, Option<i64>> =
14168        std::collections::HashMap::new();
14169    for r in &revisions {
14170        // First insertion wins for each page_id since we ordered
14171        // desc by sequence — that's the most-recent revision.
14172        last_editor_by_page.entry(r.page_id).or_insert(r.created_by);
14173    }
14174    let user_ids: Vec<i64> = last_editor_by_page
14175        .values()
14176        .filter_map(|opt| *opt)
14177        .collect();
14178    let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
14179        Vec::new()
14180    } else {
14181        rustango::tenancy::auth::User::objects()
14182            .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
14183            .fetch(tenant.pool())
14184            .await
14185            .unwrap_or_default()
14186    };
14187    let username_by_id: std::collections::HashMap<i64, String> = users
14188        .into_iter()
14189        .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
14190        .collect();
14191
14192    let rows: Vec<serde_json::Value> = slice
14193        .iter()
14194        .map(|p| {
14195            let pid = p.id.get().copied().unwrap_or_default();
14196            let updated = p.updated_at.get().copied();
14197            let days_stale = updated.map(|ts| now.signed_duration_since(ts).num_days());
14198            let editor = last_editor_by_page
14199                .get(&pid)
14200                .and_then(|v| *v)
14201                .and_then(|uid| username_by_id.get(&uid).cloned());
14202            serde_json::json!({
14203                "id": pid,
14204                "title": p.title,
14205                "url_path": p.url_path,
14206                "status": p.status,
14207                "updated_at": updated,
14208                "days_stale": days_stale,
14209                "last_editor": editor,
14210            })
14211        })
14212        .collect();
14213
14214    let mut ctx = Context::new();
14215    add_chrome(&mut ctx, &tenant, "reports", session_user.as_ref()).await;
14216    add_admin_theme(&mut ctx, tenant.pool()).await;
14217    ctx.insert("rows", &rows);
14218    ctx.insert("min_days", &min_days);
14219    ctx.insert("status_filter", &status_filter);
14220    // #316 — raw query string for the `| querystring(page=…)` pagination
14221    // links (preserves min_days / status + sets page).
14222    ctx.insert("query_string", &raw_query.unwrap_or_default());
14223    ctx.insert("current_page", &current_page);
14224    ctx.insert("has_next", &has_next);
14225    ctx.insert("has_prev", &has_prev);
14226    ctx.insert("total", &total);
14227    ctx.insert("page_size", &page_size);
14228    ctx.insert(
14229        "pagination",
14230        &crate::admin::pagination::context(current_page as i64, page_size, total),
14231    );
14232    render_with_csrf(&state, &headers, "rcms_admin/aging_pages.html", &mut ctx)
14233}
14234
14235/// GET /cms-admin/reports/aging.csv — same data as the HTML view
14236/// but streamed as RFC 4180 CSV. Honors the same `min_days` +
14237/// `status` filters.
14238pub async fn aging_pages_csv(
14239    State(_state): State<super::AdminState>,
14240    tenant: Tenant,
14241    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14242    Query(q): Query<AgingQuery>,
14243) -> Result<Response, AdminError> {
14244    let min_days = q.min_days.unwrap_or(90).max(0);
14245    let status_filter = q
14246        .status
14247        .as_deref()
14248        .map(str::trim)
14249        .filter(|s| !s.is_empty() && *s != "all")
14250        .map(str::to_owned)
14251        .unwrap_or_else(|| "published".to_owned());
14252    let now = chrono::Utc::now();
14253    let mut q_pages = Page::objects().order_by(&[("updated_at", false)]);
14254    if status_filter != "all" {
14255        q_pages = q_pages.where_(Page::status.eq(status_filter.clone()));
14256    }
14257    let all: Vec<Page> = q_pages.fetch(tenant.pool()).await?;
14258    let stale: Vec<&Page> = all
14259        .iter()
14260        .filter(|p| match p.updated_at.get().copied() {
14261            Some(ts) => now.signed_duration_since(ts).num_days() >= min_days,
14262            None => false,
14263        })
14264        .collect();
14265
14266    let mut out = String::with_capacity(256 + stale.len() * 96);
14267    out.push_str("page_id,title,url_path,status,updated_at,days_stale\n");
14268    for p in stale {
14269        let pid = p.id.get().copied().unwrap_or_default();
14270        let updated = p.updated_at.get().copied();
14271        let days = updated
14272            .map(|ts| now.signed_duration_since(ts).num_days())
14273            .unwrap_or_default();
14274        let when = updated.map(|t| t.to_rfc3339()).unwrap_or_default();
14275        out.push_str(&format!(
14276            "{},{},{},{},{},{}\n",
14277            pid,
14278            csv_escape(&p.title),
14279            csv_escape(&p.url_path),
14280            csv_escape(&p.status),
14281            csv_escape(&when),
14282            days
14283        ));
14284    }
14285    Ok(csv_response("aging-pages", &out))
14286}
14287
14288/// Helper — attach CSV content-type + a date-stamped Content-Disposition.
14289fn csv_response(name: &str, body: &str) -> Response {
14290    let filename = format!("{name}-{}.csv", chrono::Utc::now().format("%Y%m%d"));
14291    let mut response = (
14292        [(header::CONTENT_TYPE, "text/csv; charset=utf-8")],
14293        body.to_owned(),
14294    )
14295        .into_response();
14296    if let Ok(v) = HeaderValue::from_str(&format!("attachment; filename=\"{filename}\"")) {
14297        response
14298            .headers_mut()
14299            .insert(header::CONTENT_DISPOSITION, v);
14300    }
14301    response
14302}
14303
14304// =====================================================================
14305// Site settings (#108)
14306// =====================================================================
14307
14308pub async fn site_settings_list(
14309    State(state): State<super::AdminState>,
14310    tenant: Tenant,
14311    headers: HeaderMap,
14312    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14313) -> Result<Response, AdminError> {
14314    let rows = crate::site_setting::list_all(tenant.pool())
14315        .await
14316        .unwrap_or_default();
14317    let by_scope: std::collections::HashMap<&str, &crate::site_setting::SiteSetting> =
14318        rows.iter().map(|r| (r.scope.as_str(), r)).collect();
14319    // #406 — registered typed schemas come first and are always listed
14320    // (configured or not); then any
14321    // ad-hoc free-form JSON scopes that aren't backed by a schema.
14322    let mut view: Vec<serde_json::Value> = Vec::new();
14323    for schema in crate::site_setting::registered_schemas() {
14324        let row = by_scope.get(schema.scope).copied();
14325        view.push(serde_json::json!({
14326            "scope": schema.scope,
14327            "label": schema.label,
14328            "typed": true,
14329            "configured": row.is_some(),
14330            "preview": row
14331                .map(|r| serde_json::to_string(&r.value_json).unwrap_or_default())
14332                .unwrap_or_default(),
14333            "updated_at": row.and_then(|r| r.updated_at.get().copied()),
14334        }));
14335    }
14336    for s in &rows {
14337        if crate::site_setting::schema_for(&s.scope).is_some() {
14338            continue;
14339        }
14340        view.push(serde_json::json!({
14341            "scope": s.scope,
14342            "label": s.scope,
14343            "typed": false,
14344            "configured": true,
14345            "preview": serde_json::to_string(&s.value_json).unwrap_or_default(),
14346            "updated_at": s.updated_at.get().copied(),
14347        }));
14348    }
14349    let mut ctx = Context::new();
14350    add_chrome(&mut ctx, &tenant, "site-settings", session_user.as_ref()).await;
14351    add_admin_theme(&mut ctx, tenant.pool()).await;
14352    ctx.insert("rows", &view);
14353    render_with_csrf(
14354        &state,
14355        &headers,
14356        "rcms_admin/site_settings_list.html",
14357        &mut ctx,
14358    )
14359}
14360
14361pub async fn site_setting_edit_form(
14362    State(state): State<super::AdminState>,
14363    tenant: Tenant,
14364    headers: HeaderMap,
14365    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14366    Path(scope): Path<String>,
14367    Query(q): Query<EditQuery>,
14368) -> Result<Response, AdminError> {
14369    let row = crate::site_setting::get(tenant.pool(), &scope)
14370        .await
14371        .unwrap_or(None);
14372    let stored = row
14373        .as_ref()
14374        .map(|s| s.value_json.clone())
14375        .unwrap_or_else(|| serde_json::json!({}));
14376    let mut ctx = Context::new();
14377    add_chrome(&mut ctx, &tenant, "site-settings", session_user.as_ref()).await;
14378    add_admin_theme(&mut ctx, tenant.pool()).await;
14379    ctx.insert("scope", &scope);
14380    ctx.insert("is_new", &row.is_none());
14381    // #406 — a registered schema renders a typed form; otherwise the
14382    // free-form JSON textarea covers ad-hoc scopes.
14383    if let Some(schema) = crate::site_setting::schema_for(&scope) {
14384        let widgets = crate::site_setting::prefill_widgets((schema.fields)(), &stored);
14385        ctx.insert("typed", &true);
14386        ctx.insert("schema_label", schema.label);
14387        // Other languages: the text fields, translated side by side.
14388        let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
14389            .where_(crate::locale::Locale::active.eq(true))
14390            .order_by(&[("sort_order", false), ("code", false)])
14391            .fetch(tenant.pool())
14392            .await?;
14393        let editing = q
14394            .locale
14395            .as_deref()
14396            .and_then(|c| locales.iter().find(|l| l.code == c && !l.is_default).cloned());
14397        if let (Some(loc), false) = (&editing, row.is_none()) {
14398            let tr = crate::site_setting::translations(&stored, &loc.code);
14399            let rows: Vec<serde_json::Value> = widgets
14400                .iter()
14401                .filter(|w| site_setting_translatable(w))
14402                .map(|w| {
14403                    serde_json::json!({
14404                        "name": w.name,
14405                        "label": w.label,
14406                        "canonical": w.value,
14407                        "multiline": !matches!(w.kind, crate::widget::WidgetKind::Text),
14408                        "value": tr.get(&w.name).and_then(|v| v.as_str()).unwrap_or(""),
14409                    })
14410                })
14411                .collect();
14412            ctx.insert("translation_mode", &true);
14413            ctx.insert("editing_locale", loc);
14414            ctx.insert("tr_rows", &rows);
14415        }
14416        ctx.insert("locales", &locales);
14417        ctx.insert("widgets", &widgets);
14418    } else {
14419        ctx.insert("typed", &false);
14420        let body = serde_json::to_string_pretty(&stored).unwrap_or_else(|_| "{}".to_owned());
14421        ctx.insert("value_pretty", &body);
14422    }
14423    render_with_csrf(
14424        &state,
14425        &headers,
14426        "rcms_admin/site_setting_form.html",
14427        &mut ctx,
14428    )
14429}
14430
14431pub async fn site_setting_edit_submit(
14432    State(_state): State<super::AdminState>,
14433    tenant: Tenant,
14434    headers: HeaderMap,
14435    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14436    Path(scope): Path<String>,
14437    Form(form): Form<std::collections::HashMap<String, String>>,
14438) -> Result<Response, AdminError> {
14439    // #406 — typed scopes coerce each declared field by widget kind;
14440    // unregistered scopes keep the raw-JSON textarea contract.
14441    let parsed: serde_json::Value = if let Some(schema) = crate::site_setting::schema_for(&scope) {
14442        let fields = (schema.fields)();
14443        let missing = crate::site_setting::missing_required(&fields, &form);
14444        if !missing.is_empty() {
14445            return Err(AdminError::Validation(format!(
14446                "These required fields are empty: {}.",
14447                missing.join(", ")
14448            )));
14449        }
14450        let mut value = crate::site_setting::value_json_from_form(&fields, &form);
14451        if let Ok(Some(old)) = crate::site_setting::get(tenant.pool(), &scope).await {
14452            crate::site_setting::keep_translations(&old.value_json, &mut value);
14453        }
14454        value
14455    } else {
14456        let raw = form.get("value_json").map_or("", |s| s.trim());
14457        if raw.is_empty() {
14458            serde_json::json!({})
14459        } else {
14460            serde_json::from_str(raw)
14461                .map_err(|e| AdminError::Validation(format!("value_json isn't valid JSON: {e}")))?
14462        }
14463    };
14464    crate::site_setting::upsert(tenant.pool(), &scope, parsed).await?;
14465    redirect_named_with_message_args(
14466        "rcms-admin:site-settings:list",
14467        MsgLevel::Success,
14468        "Saved site setting “{scope}”.",
14469        &[("scope", scope.as_str())],
14470        &headers,
14471    )
14472}
14473
14474/// A typed setting field worth translating: free text.
14475fn site_setting_translatable(w: &crate::widget::Widget) -> bool {
14476    use crate::widget::WidgetKind as K;
14477    matches!(w.kind, K::Text | K::Textarea | K::Markdown | K::RichText)
14478}
14479
14480/// POST /cms-admin/site-settings/{scope}/translate?locale=<code> — store
14481/// the text fields' translations in the setting's `_i18n` bag.
14482pub async fn site_setting_translate_submit(
14483    State(_state): State<super::AdminState>,
14484    tenant: Tenant,
14485    headers: HeaderMap,
14486    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14487    Path(scope): Path<String>,
14488    Query(q): Query<EditQuery>,
14489    Form(form): Form<std::collections::HashMap<String, String>>,
14490) -> Result<Response, AdminError> {
14491    let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
14492    let schema = crate::site_setting::schema_for(&scope)
14493        .ok_or_else(|| AdminError::Validation(format!("`{scope}` has no typed fields to translate")))?;
14494    let row = crate::site_setting::get(tenant.pool(), &scope)
14495        .await?
14496        .ok_or_else(|| AdminError::Validation(format!("save `{scope}` before translating it")))?;
14497    let fields: serde_json::Map<String, serde_json::Value> = (schema.fields)()
14498        .iter()
14499        .filter(|w| site_setting_translatable(w))
14500        .filter_map(|w| {
14501            form.get(&format!("tr__{}", w.name))
14502                .map(|v| (w.name.clone(), serde_json::Value::String(v.trim().to_owned())))
14503        })
14504        .collect();
14505    let mut value = row.value_json;
14506    crate::site_setting::set_translations(&mut value, &locale.code, fields);
14507    crate::site_setting::upsert(tenant.pool(), &scope, value).await?;
14508    Ok(rustango::messages::redirect_with_message(
14509        messages_secret(),
14510        &headers,
14511        MsgLevel::Success,
14512        &super::i18n::tr(&headers, "Translations saved.", &[]),
14513        &format!("/cms-admin/site-settings/{scope}/edit?locale={}", locale.code),
14514    ))
14515}
14516
14517pub async fn site_setting_delete_submit(
14518    State(_state): State<super::AdminState>,
14519    tenant: Tenant,
14520    headers: HeaderMap,
14521    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14522    Path(scope): Path<String>,
14523) -> Result<Response, AdminError> {
14524    if let Some(row) = crate::site_setting::get(tenant.pool(), &scope)
14525        .await
14526        .unwrap_or(None)
14527    {
14528        row.delete_pool(tenant.pool()).await?;
14529    }
14530    redirect_named_with_message_args(
14531        "rcms-admin:site-settings:list",
14532        MsgLevel::Success,
14533        "Deleted site setting “{scope}”.",
14534        &[("scope", scope.as_str())],
14535        &headers,
14536    )
14537}
14538
14539// =====================================================================
14540// Locked-pages report (#109)
14541// =====================================================================
14542
14543// ----- #143 — search promotions report ---------
14544
14545/// GET /cms-admin/reports/search — top queries by hit count with
14546/// counts of pinned promotions per query.
14547pub async fn search_promotions_report(
14548    State(state): State<super::AdminState>,
14549    tenant: Tenant,
14550    headers: HeaderMap,
14551    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14552) -> Result<Response, AdminError> {
14553    let top = crate::search_promotion::top_queries(tenant.pool(), 100)
14554        .await
14555        .unwrap_or_default();
14556    // Annotate each query with its promotion count.
14557    let mut rows: Vec<serde_json::Value> = Vec::with_capacity(top.len());
14558    for q in top {
14559        let qid = q.id.get().copied().unwrap_or_default();
14560        let promos = crate::search_promotion::promotions_for_query(tenant.pool(), qid)
14561            .await
14562            .unwrap_or_default();
14563        rows.push(serde_json::json!({
14564            "id": qid,
14565            "raw": q.raw,
14566            "normalized": q.normalized,
14567            "hits": q.hits,
14568            "last_seen_at": q.last_seen_at.get().copied(),
14569            "promotion_count": promos.len(),
14570        }));
14571    }
14572    let mut ctx = Context::new();
14573    add_chrome(&mut ctx, &tenant, "reports-search", session_user.as_ref()).await;
14574    add_admin_theme(&mut ctx, tenant.pool()).await;
14575    ctx.insert("rows", &rows);
14576    render_with_csrf(
14577        &state,
14578        &headers,
14579        "rcms_admin/search_promotions_report.html",
14580        &mut ctx,
14581    )
14582}
14583
14584/// GET /cms-admin/reports/search/{id}/edit — edit pinned pages for
14585/// one query.
14586pub async fn search_promotion_edit_form(
14587    State(state): State<super::AdminState>,
14588    tenant: Tenant,
14589    headers: HeaderMap,
14590    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14591    Path(query_id): Path<i64>,
14592) -> Result<Response, AdminError> {
14593    use rustango::core::Column as _;
14594    use rustango::sql::FetcherPool as _;
14595    let queries: Vec<crate::search_promotion::SearchQuery> =
14596        crate::search_promotion::SearchQuery::objects()
14597            .where_(crate::search_promotion::SearchQuery::id.eq(query_id))
14598            .fetch(tenant.pool())
14599            .await?;
14600    let Some(query) = queries.into_iter().next() else {
14601        return Err(AdminError::NotFound(query_id));
14602    };
14603    let promotions = crate::search_promotion::promotions_for_query(tenant.pool(), query_id)
14604        .await
14605        .unwrap_or_default();
14606    let pages: Vec<Page> = Page::objects()
14607        .where_(Page::status.eq("published".to_owned()))
14608        .order_by(&[("title", false)])
14609        .fetch(tenant.pool())
14610        .await
14611        .unwrap_or_default();
14612    let mut ctx = Context::new();
14613    add_chrome(&mut ctx, &tenant, "reports-search", session_user.as_ref()).await;
14614    add_admin_theme(&mut ctx, tenant.pool()).await;
14615    ctx.insert("query", &query);
14616    ctx.insert("promotions", &promotions);
14617    ctx.insert("pages", &pages);
14618    render_with_csrf(
14619        &state,
14620        &headers,
14621        "rcms_admin/search_promotion_edit.html",
14622        &mut ctx,
14623    )
14624}
14625
14626#[derive(Debug, Deserialize)]
14627pub struct SearchPromotionForm {
14628    /// Comma-separated page ids in pin order.
14629    #[serde(default)]
14630    pub page_ids: String,
14631    #[serde(default)]
14632    pub descriptions: String,
14633}
14634
14635/// POST /cms-admin/reports/search/{id}/edit — replace the pinned
14636/// list with the posted ordered page ids.
14637pub async fn search_promotion_edit_submit(
14638    State(_state): State<super::AdminState>,
14639    tenant: Tenant,
14640    headers: HeaderMap,
14641    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14642    Path(query_id): Path<i64>,
14643    Form(form): Form<SearchPromotionForm>,
14644) -> Result<Response, AdminError> {
14645    use rustango::core::Column as _;
14646    use rustango::sql::Auto;
14647    use rustango::sql::FetcherPool as _;
14648    // Drop existing promotions then re-insert fresh — simpler than
14649    // diffing.
14650    let existing: Vec<crate::search_promotion::SearchPromotion> =
14651        crate::search_promotion::SearchPromotion::objects()
14652            .where_(crate::search_promotion::SearchPromotion::query_id.eq(query_id))
14653            .fetch(tenant.pool())
14654            .await?;
14655    for row in existing {
14656        row.delete_pool(tenant.pool()).await.log_warn("old search promotion not deleted");
14657    }
14658    let ids: Vec<i64> = form
14659        .page_ids
14660        .split(',')
14661        .map(str::trim)
14662        .filter(|s| !s.is_empty())
14663        .filter_map(|s| s.parse::<i64>().ok())
14664        .collect();
14665    let descriptions: Vec<String> = form
14666        .descriptions
14667        .split('\n')
14668        .map(|s| s.trim().to_owned())
14669        .collect();
14670    for (idx, page_id) in ids.iter().enumerate() {
14671        let mut row = crate::search_promotion::SearchPromotion {
14672            id: Auto::Unset,
14673            query_id,
14674            page_id: *page_id,
14675            sort_order: idx as i32,
14676            description: descriptions.get(idx).cloned().unwrap_or_default(),
14677            created_at: Auto::Unset,
14678        };
14679        row.insert_pool(tenant.pool()).await.log_warn("search promotion not saved");
14680    }
14681    redirect_named_with_message_plural(
14682        "rcms-admin:reports:search",
14683        MsgLevel::Success,
14684        "Saved {count} pinned result(s).",
14685        ids.len() as i64,
14686        &[("count", &ids.len().to_string())],
14687        &headers,
14688    )
14689}
14690
14691// ----- #141 — scheduled-publish report ---------
14692
14693/// Derive the effective lifecycle state from `go_live_at`.
14694/// Any row carrying a future
14695/// `go_live_at` is treated as `scheduled` regardless of the editor's
14696/// literal status pick (draft / published) so the sweep job +
14697/// scheduled-report query pick it up. Clearing `go_live_at` on a
14698/// previously-scheduled row falls back to `draft` so the row stops
14699/// claiming a schedule it no longer has.
14700///
14701/// `archived` is preserved either way — archive is an explicit
14702/// lifecycle terminus and an editor un-archives via a different
14703/// path. A scheduled row whose `go_live_at` has already passed is
14704/// left alone too; the sweep is the one that flips it to `published`,
14705/// and stepping in here would steal that transition.
14706pub(crate) fn derive_scheduled_status(
14707    current: &str,
14708    go_live_at: Option<chrono::DateTime<chrono::Utc>>,
14709) -> String {
14710    let archived = crate::page::PageStatus::Archived.as_str();
14711    if current == archived {
14712        return current.to_owned();
14713    }
14714    let now = chrono::Utc::now();
14715    let future = go_live_at.is_some_and(|t| t > now);
14716    let scheduled = crate::page::PageStatus::Scheduled.as_str();
14717    let draft = crate::page::PageStatus::Draft.as_str();
14718    match (current, future, go_live_at) {
14719        (_, true, _) => scheduled.to_owned(),
14720        (s, false, None) if s == scheduled => draft.to_owned(),
14721        _ => current.to_owned(),
14722    }
14723}
14724
14725#[cfg(test)]
14726mod scheduled_status_tests {
14727    use super::derive_scheduled_status;
14728    use chrono::{Duration, Utc};
14729
14730    #[test]
14731    fn future_go_live_promotes_draft_to_scheduled() {
14732        let go = Utc::now() + Duration::hours(1);
14733        assert_eq!(derive_scheduled_status("draft", Some(go)), "scheduled");
14734    }
14735
14736    #[test]
14737    fn future_go_live_also_promotes_published() {
14738        // Editor picked "published" + a future go-live. The row
14739        // defers to the sweep — surface as scheduled.
14740        let go = Utc::now() + Duration::hours(2);
14741        assert_eq!(derive_scheduled_status("published", Some(go)), "scheduled");
14742    }
14743
14744    #[test]
14745    fn cleared_go_live_demotes_scheduled_to_draft() {
14746        assert_eq!(derive_scheduled_status("scheduled", None), "draft");
14747    }
14748
14749    #[test]
14750    fn past_go_live_on_scheduled_left_alone_for_sweep() {
14751        let past = Utc::now() - Duration::hours(1);
14752        assert_eq!(
14753            derive_scheduled_status("scheduled", Some(past)),
14754            "scheduled",
14755        );
14756    }
14757
14758    #[test]
14759    fn archived_preserved_regardless_of_go_live() {
14760        let go = Utc::now() + Duration::hours(1);
14761        assert_eq!(derive_scheduled_status("archived", Some(go)), "archived");
14762        assert_eq!(derive_scheduled_status("archived", None), "archived");
14763    }
14764
14765    #[test]
14766    fn draft_with_no_go_live_unchanged() {
14767        assert_eq!(derive_scheduled_status("draft", None), "draft");
14768    }
14769
14770    #[test]
14771    fn published_with_no_go_live_unchanged() {
14772        assert_eq!(derive_scheduled_status("published", None), "published");
14773    }
14774}
14775
14776/// Build the dataset for the scheduled-publish report: every page
14777/// with a future `go_live_at` plus every published page with a
14778/// future `expire_at`. Rows sorted by go_live_at ascending (soonest
14779/// first), with expirations interleaved by their expire_at.
14780async fn scheduled_pages_rows(
14781    pool: &rustango::sql::Pool,
14782) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
14783    use rustango::sql::FetcherPool as _;
14784    let pages: Vec<Page> = Page::objects().fetch(pool).await?;
14785    let now = chrono::Utc::now();
14786    let mut rows: Vec<serde_json::Value> = Vec::new();
14787    for p in &pages {
14788        let pid = p.id.get().copied().unwrap_or_default();
14789        if let Some(go) = p.go_live_at {
14790            // #264 — surface any page with a future `go_live_at`,
14791            // even if its status hasn't been coerced to "scheduled"
14792            // yet (the save handler now does the coercion, but legacy
14793            // rows or out-of-band edits may have `go_live_at` set on
14794            // a draft/published row — the editor still wants to see
14795            // the upcoming flip). Archived / expired rows are excluded
14796            // because both are explicit lifecycle termini.
14797            if go > now
14798                && p.status != crate::page::PageStatus::Archived.as_str()
14799                && p.status != crate::page::PageStatus::Expired.as_str()
14800            {
14801                let countdown = (go - now).num_seconds();
14802                rows.push(serde_json::json!({
14803                    "kind": "publish",
14804                    "when": go,
14805                    "countdown_secs": countdown,
14806                    "page_id": pid,
14807                    "title": p.title,
14808                    "url_path": p.url_path,
14809                    "status": p.status,
14810                }));
14811            }
14812        }
14813        if let Some(exp) = p.expire_at {
14814            // A scheduled page with both dates comes down too: list it.
14815            if exp > now
14816                && (p.status == crate::page::PageStatus::Published.as_str()
14817                    || p.status == crate::page::PageStatus::Scheduled.as_str())
14818            {
14819                let countdown = (exp - now).num_seconds();
14820                rows.push(serde_json::json!({
14821                    "kind": "expire",
14822                    "when": exp,
14823                    "countdown_secs": countdown,
14824                    "page_id": pid,
14825                    "title": p.title,
14826                    "url_path": p.url_path,
14827                    "status": p.status,
14828                }));
14829            }
14830        }
14831    }
14832    rows.sort_by_key(|r| {
14833        r.get("countdown_secs")
14834            .and_then(|v| v.as_i64())
14835            .unwrap_or(i64::MAX)
14836    });
14837    Ok(rows)
14838}
14839
14840pub async fn scheduled_report(
14841    State(state): State<super::AdminState>,
14842    tenant: Tenant,
14843    headers: HeaderMap,
14844    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14845) -> Result<Response, AdminError> {
14846    let rows = scheduled_pages_rows(tenant.pool())
14847        .await
14848        .unwrap_or_default();
14849    let mut ctx = Context::new();
14850    add_chrome(
14851        &mut ctx,
14852        &tenant,
14853        "reports-scheduled",
14854        session_user.as_ref(),
14855    )
14856    .await;
14857    add_admin_theme(&mut ctx, tenant.pool()).await;
14858    ctx.insert("rows", &rows);
14859    render_with_csrf(
14860        &state,
14861        &headers,
14862        "rcms_admin/scheduled_report.html",
14863        &mut ctx,
14864    )
14865}
14866
14867pub async fn scheduled_report_csv(
14868    State(_state): State<super::AdminState>,
14869    tenant: Tenant,
14870    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14871) -> Result<Response, AdminError> {
14872    let rows = scheduled_pages_rows(tenant.pool())
14873        .await
14874        .unwrap_or_default();
14875    let mut out = String::with_capacity(256 + rows.len() * 160);
14876    out.push_str("kind,page_id,title,url_path,status,when,countdown_secs\n");
14877    for r in &rows {
14878        out.push_str(&format!(
14879            "{},{},{},{},{},{},{}\n",
14880            csv_escape(r.get("kind").and_then(|v| v.as_str()).unwrap_or_default()),
14881            r.get("page_id")
14882                .and_then(|v| v.as_i64())
14883                .unwrap_or_default(),
14884            csv_escape(r.get("title").and_then(|v| v.as_str()).unwrap_or_default()),
14885            csv_escape(
14886                r.get("url_path")
14887                    .and_then(|v| v.as_str())
14888                    .unwrap_or_default()
14889            ),
14890            csv_escape(r.get("status").and_then(|v| v.as_str()).unwrap_or_default()),
14891            csv_escape(&r.get("when").map(ToString::to_string).unwrap_or_default()),
14892            r.get("countdown_secs")
14893                .and_then(|v| v.as_i64())
14894                .unwrap_or_default(),
14895        ));
14896    }
14897    Ok(csv_response("scheduled-pages", &out))
14898}
14899
14900/// Build the locked-pages dataset: every live PageLock joined with
14901/// its page + holder username. Returns rows sorted by acquired_at
14902/// desc (newest holds first). Excludes stale locks past their TTL.
14903async fn locked_pages_rows(
14904    pool: &rustango::sql::Pool,
14905) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
14906    use rustango::sql::FetcherPool as _;
14907    let locks: Vec<crate::lock::PageLock> = crate::lock::PageLock::objects()
14908        .order_by(&[("acquired_at", true)]) // desc
14909        .fetch(pool)
14910        .await?;
14911    let now = chrono::Utc::now();
14912    let live: Vec<&crate::lock::PageLock> = locks.iter().filter(|l| !l.is_stale(now)).collect();
14913    if live.is_empty() {
14914        return Ok(Vec::new());
14915    }
14916    let page_ids: Vec<i64> = live.iter().map(|l| l.page_id).collect();
14917    let user_ids: Vec<i64> = live.iter().map(|l| l.user_id).collect();
14918    let pages: Vec<Page> = Page::objects()
14919        .where_(Page::id.is_in(page_ids))
14920        .fetch(pool)
14921        .await
14922        .unwrap_or_default();
14923    let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
14924        .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
14925        .fetch(pool)
14926        .await
14927        .unwrap_or_default();
14928    let page_by_id: std::collections::HashMap<i64, &Page> = pages
14929        .iter()
14930        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
14931        .collect();
14932    let user_by_id: std::collections::HashMap<i64, String> = users
14933        .into_iter()
14934        .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
14935        .collect();
14936    Ok(live
14937        .into_iter()
14938        .map(|l| {
14939            let title = page_by_id
14940                .get(&l.page_id)
14941                .map(|p| p.title.clone())
14942                .unwrap_or_else(|| format!("page #{}", l.page_id));
14943            let url_path = page_by_id
14944                .get(&l.page_id)
14945                .map(|p| p.url_path.clone())
14946                .unwrap_or_default();
14947            let username = user_by_id
14948                .get(&l.user_id)
14949                .cloned()
14950                .unwrap_or_else(|| format!("user#{}", l.user_id));
14951            let ttl_remaining = (l.expires_at - now).num_seconds();
14952            serde_json::json!({
14953                "page_id": l.page_id,
14954                "title": title,
14955                "url_path": url_path,
14956                "user_id": l.user_id,
14957                "username": username,
14958                "acquired_at": l.acquired_at.get().copied(),
14959                "expires_at": l.expires_at,
14960                "ttl_remaining_secs": ttl_remaining,
14961            })
14962        })
14963        .collect())
14964}
14965
14966pub async fn locked_pages_report(
14967    State(state): State<super::AdminState>,
14968    tenant: Tenant,
14969    headers: HeaderMap,
14970    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14971) -> Result<Response, AdminError> {
14972    let rows = locked_pages_rows(tenant.pool()).await.unwrap_or_default();
14973    let mut ctx = Context::new();
14974    add_chrome(&mut ctx, &tenant, "reports-locked", session_user.as_ref()).await;
14975    add_admin_theme(&mut ctx, tenant.pool()).await;
14976    ctx.insert("rows", &rows);
14977    render_with_csrf(&state, &headers, "rcms_admin/locked_pages.html", &mut ctx)
14978}
14979
14980pub async fn locked_pages_csv(
14981    State(_state): State<super::AdminState>,
14982    tenant: Tenant,
14983    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14984) -> Result<Response, AdminError> {
14985    let rows = locked_pages_rows(tenant.pool()).await.unwrap_or_default();
14986    let mut out = String::with_capacity(256 + rows.len() * 128);
14987    out.push_str("page_id,title,url_path,username,acquired_at,expires_at\n");
14988    for r in &rows {
14989        out.push_str(&format!(
14990            "{},{},{},{},{},{}\n",
14991            r.get("page_id")
14992                .and_then(|v| v.as_i64())
14993                .unwrap_or_default(),
14994            csv_escape(r.get("title").and_then(|v| v.as_str()).unwrap_or_default()),
14995            csv_escape(
14996                r.get("url_path")
14997                    .and_then(|v| v.as_str())
14998                    .unwrap_or_default()
14999            ),
15000            csv_escape(
15001                r.get("username")
15002                    .and_then(|v| v.as_str())
15003                    .unwrap_or_default()
15004            ),
15005            csv_escape(
15006                r.get("acquired_at")
15007                    .and_then(|v| v.as_str())
15008                    .unwrap_or_default()
15009            ),
15010            csv_escape(
15011                r.get("expires_at")
15012                    .and_then(|v| v.as_str())
15013                    .unwrap_or_default()
15014            ),
15015        ));
15016    }
15017    Ok(csv_response("locked-pages", &out))
15018}
15019
15020// =====================================================================
15021// Workflows report (#109)
15022// =====================================================================
15023
15024async fn workflows_report_rows(
15025    pool: &rustango::sql::Pool,
15026) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
15027    use rustango::sql::FetcherPool as _;
15028    let states: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
15029        .order_by(&[("requested_at", true)]) // desc
15030        .fetch(pool)
15031        .await?;
15032    if states.is_empty() {
15033        return Ok(Vec::new());
15034    }
15035    let workflow_ids: Vec<i64> = states.iter().map(|s| s.workflow_id).collect();
15036    let page_ids: Vec<i64> = states.iter().map(|s| s.page_id).collect();
15037    let user_ids: Vec<i64> = states.iter().map(|s| s.requested_by).collect();
15038    let workflows: Vec<crate::workflow::Workflow> = crate::workflow::Workflow::objects()
15039        .where_(crate::workflow::Workflow::id.is_in(workflow_ids))
15040        .fetch(pool)
15041        .await
15042        .unwrap_or_default();
15043    let pages: Vec<Page> = Page::objects()
15044        .where_(Page::id.is_in(page_ids))
15045        .fetch(pool)
15046        .await
15047        .unwrap_or_default();
15048    let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
15049        .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
15050        .fetch(pool)
15051        .await
15052        .unwrap_or_default();
15053    let task_ids: Vec<i64> = states.iter().filter_map(|s| s.current_task_id).collect();
15054    let tasks: Vec<crate::workflow::WorkflowTask> = if task_ids.is_empty() {
15055        Vec::new()
15056    } else {
15057        crate::workflow::WorkflowTask::objects()
15058            .where_(crate::workflow::WorkflowTask::id.is_in(task_ids))
15059            .fetch(pool)
15060            .await
15061            .unwrap_or_default()
15062    };
15063    let workflow_by_id: std::collections::HashMap<i64, String> = workflows
15064        .into_iter()
15065        .filter_map(|w| w.id.get().copied().map(|id| (id, w.name)))
15066        .collect();
15067    let page_by_id: std::collections::HashMap<i64, &Page> = pages
15068        .iter()
15069        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
15070        .collect();
15071    let user_by_id: std::collections::HashMap<i64, String> = users
15072        .into_iter()
15073        .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
15074        .collect();
15075    let task_by_id: std::collections::HashMap<i64, String> = tasks
15076        .into_iter()
15077        .filter_map(|t| t.id.get().copied().map(|id| (id, t.name)))
15078        .collect();
15079    Ok(states
15080        .iter()
15081        .map(|s| {
15082            serde_json::json!({
15083                "id": s.id.get().copied(),
15084                "workflow_name": workflow_by_id.get(&s.workflow_id).cloned().unwrap_or_else(|| format!("workflow #{}", s.workflow_id)),
15085                "page_id": s.page_id,
15086                "page_title": page_by_id.get(&s.page_id).map(|p| p.title.clone()).unwrap_or_else(|| format!("page #{}", s.page_id)),
15087                "page_url_path": page_by_id.get(&s.page_id).map(|p| p.url_path.clone()).unwrap_or_default(),
15088                "status": s.status,
15089                "current_task_name": s.current_task_id.and_then(|tid| task_by_id.get(&tid).cloned()),
15090                "requested_by_username": user_by_id.get(&s.requested_by).cloned(),
15091                "requested_at": s.requested_at.get().copied(),
15092                "finished_at": s.finished_at,
15093            })
15094        })
15095        .collect())
15096}
15097
15098pub async fn workflows_report(
15099    State(state): State<super::AdminState>,
15100    tenant: Tenant,
15101    headers: HeaderMap,
15102    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15103) -> Result<Response, AdminError> {
15104    let rows = workflows_report_rows(tenant.pool())
15105        .await
15106        .unwrap_or_default();
15107    let mut ctx = Context::new();
15108    add_chrome(
15109        &mut ctx,
15110        &tenant,
15111        "reports-workflows",
15112        session_user.as_ref(),
15113    )
15114    .await;
15115    add_admin_theme(&mut ctx, tenant.pool()).await;
15116    ctx.insert("rows", &rows);
15117    render_with_csrf(
15118        &state,
15119        &headers,
15120        "rcms_admin/workflow_report.html",
15121        &mut ctx,
15122    )
15123}
15124
15125// =====================================================================
15126// #122 — revision storage report + manual prune.
15127// =====================================================================
15128
15129/// GET /cms-admin/reports/revisions — list pages ordered by revision
15130/// count so editors can see which ones accumulate history fastest.
15131/// Surface a "Prune now" form scoped to the whole tenant.
15132pub async fn revisions_report(
15133    State(state): State<super::AdminState>,
15134    tenant: Tenant,
15135    headers: HeaderMap,
15136    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15137) -> Result<Response, AdminError> {
15138    use rustango::sql::FetcherPool as _;
15139    let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
15140    let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
15141        .fetch(tenant.pool())
15142        .await
15143        .unwrap_or_default();
15144    let mut count_by_page: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
15145    for r in &revisions {
15146        *count_by_page.entry(r.page_id).or_default() += 1;
15147    }
15148    let mut rows: Vec<serde_json::Value> = pages
15149        .into_iter()
15150        .filter_map(|p| {
15151            let pid = p.id.get().copied()?;
15152            let count = count_by_page.get(&pid).copied().unwrap_or(0);
15153            if count == 0 {
15154                return None;
15155            }
15156            Some(serde_json::json!({
15157                "page_id": pid,
15158                "title": p.title,
15159                "url_path": p.url_path,
15160                "status": p.status,
15161                "revision_count": count,
15162            }))
15163        })
15164        .collect();
15165    rows.sort_by(|a, b| {
15166        let ac = a
15167            .get("revision_count")
15168            .and_then(|v| v.as_u64())
15169            .unwrap_or(0);
15170        let bc = b
15171            .get("revision_count")
15172            .and_then(|v| v.as_u64())
15173            .unwrap_or(0);
15174        bc.cmp(&ac)
15175    });
15176    let total_revisions = revisions.len();
15177    let mut ctx = Context::new();
15178    add_chrome(
15179        &mut ctx,
15180        &tenant,
15181        "reports-revisions",
15182        session_user.as_ref(),
15183    )
15184    .await;
15185    add_admin_theme(&mut ctx, tenant.pool()).await;
15186    ctx.insert("rows", &rows);
15187    ctx.insert("total_revisions", &total_revisions);
15188    ctx.insert("default_keep_latest", &crate::revision::DEFAULT_KEEP_LATEST);
15189    render_with_csrf(
15190        &state,
15191        &headers,
15192        "rcms_admin/revisions_report.html",
15193        &mut ctx,
15194    )
15195}
15196
15197/// Form posted from the revisions report's "Prune now" button.
15198#[derive(Debug, Deserialize)]
15199pub struct RevisionsPruneForm {
15200    #[serde(default)]
15201    pub keep_latest: Option<usize>,
15202    #[serde(default)]
15203    pub include_published: Option<String>,
15204}
15205
15206/// POST /cms-admin/reports/revisions/prune — manual prune. Honours
15207/// the same `(keep_latest, keep_published)` knobs as the library
15208/// helper. Redirects back to the report with a count flash.
15209pub async fn revisions_report_prune(
15210    State(_state): State<super::AdminState>,
15211    tenant: Tenant,
15212    headers: HeaderMap,
15213    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
15214    Form(form): Form<RevisionsPruneForm>,
15215) -> Result<Response, AdminError> {
15216    let keep_latest = form
15217        .keep_latest
15218        .unwrap_or(crate::revision::DEFAULT_KEEP_LATEST)
15219        .max(1);
15220    // The form check sends "1" when the box is ticked → keep
15221    // published-status revisions. Unchecked = include them in the
15222    // sweep (more aggressive).
15223    let keep_published = form.include_published.as_deref() != Some("1");
15224    let (pages_scanned, rows_deleted) =
15225        crate::revision::prune_all_pages(tenant.pool(), keep_latest, keep_published)
15226            .await
15227            .unwrap_or((0, 0));
15228    let revisions = super::i18n::tr_plural(
15229        &headers,
15230        "{count} revision(s)",
15231        rows_deleted as i64,
15232        &[("count", &rows_deleted.to_string())],
15233    );
15234    let pages_ph = super::i18n::tr_plural(
15235        &headers,
15236        "{count} page(s)",
15237        pages_scanned as i64,
15238        &[("count", &pages_scanned.to_string())],
15239    );
15240    let kl = keep_latest.to_string();
15241    let kp = keep_published.to_string();
15242    redirect_named_with_message_args(
15243        "rcms-admin:reports:revisions",
15244        MsgLevel::Success,
15245        "Pruned {revisions} across {pages} (keep_latest={keep_latest}, keep_published={keep_published}).",
15246        &[
15247            ("revisions", revisions.as_str()),
15248            ("pages", pages_ph.as_str()),
15249            ("keep_latest", kl.as_str()),
15250            ("keep_published", kp.as_str()),
15251        ],
15252        &headers,
15253    )
15254}
15255
15256pub async fn workflows_report_csv(
15257    State(_state): State<super::AdminState>,
15258    tenant: Tenant,
15259    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
15260) -> Result<Response, AdminError> {
15261    let rows = workflows_report_rows(tenant.pool())
15262        .await
15263        .unwrap_or_default();
15264    let mut out = String::with_capacity(256 + rows.len() * 192);
15265    out.push_str("workflow,page_id,page_title,page_url,status,current_task,requested_by,requested_at,finished_at\n");
15266    for r in &rows {
15267        out.push_str(&format!(
15268            "{},{},{},{},{},{},{},{},{}\n",
15269            csv_escape(
15270                r.get("workflow_name")
15271                    .and_then(|v| v.as_str())
15272                    .unwrap_or_default()
15273            ),
15274            r.get("page_id")
15275                .and_then(|v| v.as_i64())
15276                .unwrap_or_default(),
15277            csv_escape(
15278                r.get("page_title")
15279                    .and_then(|v| v.as_str())
15280                    .unwrap_or_default()
15281            ),
15282            csv_escape(
15283                r.get("page_url_path")
15284                    .and_then(|v| v.as_str())
15285                    .unwrap_or_default()
15286            ),
15287            csv_escape(r.get("status").and_then(|v| v.as_str()).unwrap_or_default()),
15288            csv_escape(
15289                r.get("current_task_name")
15290                    .and_then(|v| v.as_str())
15291                    .unwrap_or_default()
15292            ),
15293            csv_escape(
15294                r.get("requested_by_username")
15295                    .and_then(|v| v.as_str())
15296                    .unwrap_or_default()
15297            ),
15298            csv_escape(
15299                r.get("requested_at")
15300                    .and_then(|v| v.as_str())
15301                    .unwrap_or_default()
15302            ),
15303            csv_escape(
15304                r.get("finished_at")
15305                    .and_then(|v| v.as_str())
15306                    .unwrap_or_default()
15307            ),
15308        ));
15309    }
15310    Ok(csv_response("workflow-report", &out))
15311}
15312
15313// =====================================================================
15314// Global admin search (#77 — stage 0)
15315// =====================================================================
15316
15317/// Query for the global search. `q` is the search needle; when
15318/// `autocomplete=1` is set the handler returns a JSON shape suited
15319/// to the topbar dropdown (no surrounding chrome).
15320#[derive(Debug, Deserialize)]
15321pub struct AdminSearchQuery {
15322    #[serde(default)]
15323    pub q: Option<String>,
15324    #[serde(default)]
15325    pub autocomplete: Option<String>,
15326}
15327
15328/// Query string for `GET /cms-admin/__page-chooser`.
15329#[derive(Debug, Deserialize)]
15330pub struct PageChooserQuery {
15331    #[serde(default)]
15332    pub q: Option<String>,
15333}
15334
15335/// Query string for the generic `GET /cms-admin/__chooser/{slug}`.
15336#[derive(Debug, Default, Deserialize)]
15337pub struct ChooserSearchQuery {
15338    #[serde(default)]
15339    pub q: Option<String>,
15340}
15341
15342/// GET `/cms-admin/__chooser/{slug}?q=<needle>` — JSON endpoint
15343/// backing any `register_chooser!`ed model, generalising the three
15344/// bespoke choosers. Returns `{ "items": [ { id, title, sub, … } ] }`,
15345/// the shape the shared overlay (`cms-ux.js`) renders. Unknown slug → 404.
15346pub async fn chooser_search_json(
15347    State(_state): State<super::AdminState>,
15348    tenant: Tenant,
15349    Path(slug): Path<String>,
15350    Query(q): Query<ChooserSearchQuery>,
15351) -> Result<Response, AdminError> {
15352    let Some(cvs) = super::chooser::find(&slug) else {
15353        return Ok((axum::http::StatusCode::NOT_FOUND, "unknown chooser").into_response());
15354    };
15355    let items = (cvs.search_rows)(tenant.pool().clone(), q.q.unwrap_or_default()).await;
15356    let body = serde_json::json!({ "items": items });
15357    Ok((
15358        [(header::CONTENT_TYPE, "application/json")],
15359        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15360    )
15361        .into_response())
15362}
15363
15364/// Query string for `GET /cms-admin/__media-picker`.
15365#[derive(Debug, Default, Deserialize)]
15366pub struct MediaPickerQuery {
15367    #[serde(default)]
15368    pub q: Option<String>,
15369    /// Collection filter: omitted = all collections, `0` = uncategorized
15370    /// (NULL collection_id), any other value = that exact collection.
15371    #[serde(default)]
15372    pub collection: Option<i64>,
15373    /// `"image"` (default) | `"document"` | `"other"` | `"any"`.
15374    #[serde(default)]
15375    pub kind: Option<String>,
15376    /// Comma-separated media ids — resolve exactly these rows (any kind
15377    /// unless `kind` is set explicitly). Used by the widget-label
15378    /// hydration pass to turn a server-rendered `#42` into the title.
15379    #[serde(default)]
15380    pub ids: Option<String>,
15381    #[serde(default)]
15382    pub limit: Option<usize>,
15383    #[serde(default)]
15384    pub offset: Option<usize>,
15385}
15386
15387/// GET `/cms-admin/__media-picker` — the media picker's data endpoint.
15388///
15389/// Richer than the generic `/cms-admin/__chooser/media` (which stays for
15390/// back-compat): collection + kind filters, offset pagination, and
15391/// server-computed `thumb_url`/`preview_url` rendition URLs. The URLs are
15392/// built here (not in JS) because renditions can be signature-gated
15393/// and only the server can sign a spec.
15394///
15395/// Filtering is in-Rust over a full fetch — the crate's tri-dialect
15396/// convention (see `render_media_list`); no SQL LIKE.
15397pub async fn media_picker_json(
15398    State(_state): State<super::AdminState>,
15399    tenant: Tenant,
15400    Query(q): Query<MediaPickerQuery>,
15401) -> Result<Response, AdminError> {
15402    let body = media_picker_payload(tenant.pool(), &q).await?;
15403    Ok((
15404        [(header::CONTENT_TYPE, "application/json")],
15405        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15406    )
15407        .into_response())
15408}
15409
15410/// Core of [`media_picker_json`], split out so unit tests can drive it with
15411/// an in-memory pool (the handler's `Tenant`/`State` extractors need a full
15412/// admin app).
15413pub(crate) async fn media_picker_payload(
15414    pool: &rustango::sql::Pool,
15415    q: &MediaPickerQuery,
15416) -> Result<serde_json::Value, AdminError> {
15417    let mut rows: Vec<Media> = Media::objects()
15418        .order_by(&[("uploaded_at", true)])
15419        .fetch(pool)
15420        .await?;
15421
15422    // Explicit-id lookup (label hydration): keep exactly those rows, and
15423    // default the kind filter OFF — a video/document id must resolve too.
15424    let id_set: Option<std::collections::HashSet<i64>> = q.ids.as_deref().map(|s| {
15425        s.split(',')
15426            .filter_map(|t| t.trim().parse::<i64>().ok())
15427            .collect()
15428    });
15429    if let Some(ids) = &id_set {
15430        rows.retain(|m| m.id.get().copied().is_some_and(|id| ids.contains(&id)));
15431    }
15432    // Kind filter — the picker is image-first ("Choose an image…");
15433    // documents have their own chooser kind. `any` opts out.
15434    let kind = q
15435        .kind
15436        .as_deref()
15437        .unwrap_or(if id_set.is_some() { "any" } else { "image" });
15438    if kind != "any" {
15439        rows.retain(|m| m.kind == kind);
15440    }
15441    // Per-collection counts for the dropdown, computed over the kind-filtered
15442    // set (before collection/search narrow it) so the numbers answer
15443    // "how many would this filter show?".
15444    let mut collection_counts: std::collections::HashMap<i64, i64> =
15445        std::collections::HashMap::new();
15446    let mut uncategorized_count: i64 = 0;
15447    for m in &rows {
15448        match m.collection_id {
15449            Some(cid) => *collection_counts.entry(cid).or_default() += 1,
15450            None => uncategorized_count += 1,
15451        }
15452    }
15453    match q.collection {
15454        Some(0) => rows.retain(|m| m.collection_id.is_none()),
15455        Some(cid) => rows.retain(|m| m.collection_id == Some(cid)),
15456        None => {}
15457    }
15458    if let Some(needle) = q.q.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
15459        let needle = needle.to_lowercase();
15460        rows.retain(|m| {
15461            m.title.to_lowercase().contains(&needle)
15462                || m.filename.to_lowercase().contains(&needle)
15463                || m.alt_text.to_lowercase().contains(&needle)
15464                || m.description.to_lowercase().contains(&needle)
15465        });
15466    }
15467
15468    let total = rows.len();
15469    let limit = q.limit.unwrap_or(60).min(200);
15470    let offset = q.offset.unwrap_or(0).min(total);
15471    let has_more = offset + limit < total;
15472    let page: Vec<serde_json::Value> = rows[offset..(offset + limit).min(total)]
15473        .iter()
15474        .map(|m| {
15475            let id = m.id.get().copied().unwrap_or_default();
15476            let is_image = m.kind == "image";
15477            let thumb_url = is_image
15478                .then(|| {
15479                    crate::rendition::rendition_url_for(
15480                        id,
15481                        "fill-320x320|format-webp|quality-70",
15482                        Some(m.content_hash.as_str()),
15483                    )
15484                })
15485                .flatten();
15486            let preview_url = is_image
15487                .then(|| {
15488                    crate::rendition::rendition_url_for(
15489                        id,
15490                        "max-640x480|format-webp|quality-80",
15491                        Some(m.content_hash.as_str()),
15492                    )
15493                })
15494                .flatten();
15495            serde_json::json!({
15496                "id": id,
15497                "title": if m.title.is_empty() { m.filename.clone() } else { m.title.clone() },
15498                "filename": m.filename,
15499                "kind": m.kind,
15500                "mime": m.mime,
15501                "size": m.size,
15502                "width": m.width,
15503                "height": m.height,
15504                "collection_id": m.collection_id,
15505                "alt_text": m.alt_text,
15506                "uploaded_at": m.uploaded_at,
15507                "thumb_url": thumb_url,
15508                "preview_url": preview_url,
15509            })
15510        })
15511        .collect();
15512
15513    // Collections in DFS order so the dropdown nests visually
15514    // ("— Child" under its parent). A visited set guards against
15515    // accidental parent cycles.
15516    let cols: Vec<crate::media::MediaCollection> =
15517        crate::media::MediaCollection::objects().fetch(pool).await?;
15518    let mut children: std::collections::HashMap<Option<i64>, Vec<&crate::media::MediaCollection>> =
15519        std::collections::HashMap::new();
15520    for c in &cols {
15521        children.entry(c.parent_id).or_default().push(c);
15522    }
15523    for v in children.values_mut() {
15524        v.sort_by(|a, b| a.sort_order.cmp(&b.sort_order).then(a.name.cmp(&b.name)));
15525    }
15526    let mut ordered: Vec<serde_json::Value> = Vec::with_capacity(cols.len());
15527    let mut visited: std::collections::HashSet<i64> = std::collections::HashSet::new();
15528    let mut stack: Vec<(i64, usize)> = children
15529        .get(&None)
15530        .map(|roots| {
15531            roots
15532                .iter()
15533                .rev()
15534                .filter_map(|c| c.id.get().copied())
15535                .map(|id| (id, 0))
15536                .collect()
15537        })
15538        .unwrap_or_default();
15539    let by_id: std::collections::HashMap<i64, &crate::media::MediaCollection> = cols
15540        .iter()
15541        .filter_map(|c| c.id.get().copied().map(|id| (id, c)))
15542        .collect();
15543    while let Some((id, depth)) = stack.pop() {
15544        if !visited.insert(id) {
15545            continue;
15546        }
15547        if let Some(c) = by_id.get(&id) {
15548            ordered.push(serde_json::json!({
15549                "id": id,
15550                "name": c.name,
15551                "depth": depth,
15552                "count": collection_counts.get(&id).copied().unwrap_or(0),
15553            }));
15554            if let Some(kids) = children.get(&Some(id)) {
15555                for k in kids.iter().rev() {
15556                    if let Some(kid) = k.id.get().copied() {
15557                        stack.push((kid, depth + 1));
15558                    }
15559                }
15560            }
15561        }
15562    }
15563
15564    Ok(serde_json::json!({
15565        "items": page,
15566        "collections": ordered,
15567        "uncategorized_count": uncategorized_count,
15568        "total": total,
15569        "has_more": has_more,
15570    }))
15571}
15572
15573/// GET /cms-admin/__page-chooser?q=<needle> — JSON endpoint backing
15574/// the PageChooser widget. Returns the top-N matching
15575/// pages by title / slug / url_path (LIKE, lowercased), bounded at 50.
15576/// Empty `q` returns the most recently updated pages so the chooser
15577/// has something useful to show on first open.
15578pub async fn page_chooser_json(
15579    State(_state): State<super::AdminState>,
15580    tenant: Tenant,
15581    Query(q): Query<PageChooserQuery>,
15582) -> Result<Response, AdminError> {
15583    let needle =
15584        q.q.as_deref()
15585            .map(str::trim)
15586            .filter(|s| !s.is_empty())
15587            .map(str::to_lowercase);
15588
15589    let mut pages: Vec<Page> = Page::objects()
15590        .order_by(&[("updated_at", true)])
15591        .fetch(tenant.pool())
15592        .await
15593        .unwrap_or_default();
15594
15595    if let Some(n) = needle.as_ref() {
15596        pages.retain(|p| {
15597            p.title.to_lowercase().contains(n)
15598                || p.slug.to_lowercase().contains(n)
15599                || p.url_path.to_lowercase().contains(n)
15600        });
15601    }
15602
15603    let items: Vec<serde_json::Value> = pages
15604        .iter()
15605        .take(50)
15606        .map(|p| {
15607            serde_json::json!({
15608                "id": p.id.get().copied(),
15609                "title": p.title,
15610                "slug": p.slug,
15611                "url_path": p.url_path,
15612                "depth": p.depth,
15613                "parent_id": p.parent_id,
15614                "status": p.status,
15615            })
15616        })
15617        .collect();
15618
15619    let body = serde_json::json!({ "items": items });
15620    Ok((
15621        [(header::CONTENT_TYPE, "application/json")],
15622        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15623    )
15624        .into_response())
15625}
15626
15627/// Query string for `GET /cms-admin/__snippet-chooser`. Optional
15628/// `type_name` narrows to one snippet kind — the `data-chooser-filter`
15629/// attribute on the widget threads through.
15630#[derive(Debug, Deserialize)]
15631pub struct SnippetChooserQuery {
15632    #[serde(default)]
15633    pub q: Option<String>,
15634    #[serde(default)]
15635    pub type_name: Option<String>,
15636    /// Comma-separated snippet ids — resolve exactly these rows. Used by
15637    /// the widget-label hydration pass (a server-rendered value only has
15638    /// the raw id).
15639    #[serde(default)]
15640    pub ids: Option<String>,
15641}
15642
15643/// GET /cms-admin/__snippet-chooser?q=…&type_name=… — JSON endpoint
15644/// backing the SnippetChooser widget. Returns the
15645/// top-50 matching snippets by title / slug; optionally filtered
15646/// to a single `type_name`.
15647pub async fn snippet_chooser_json(
15648    State(_state): State<super::AdminState>,
15649    tenant: Tenant,
15650    Query(q): Query<SnippetChooserQuery>,
15651) -> Result<Response, AdminError> {
15652    let needle =
15653        q.q.as_deref()
15654            .map(str::trim)
15655            .filter(|s| !s.is_empty())
15656            .map(str::to_lowercase);
15657    let type_filter = q
15658        .type_name
15659        .as_deref()
15660        .map(str::trim)
15661        .filter(|s| !s.is_empty())
15662        .map(str::to_owned);
15663
15664    let mut snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
15665        .order_by(&[("updated_at", true)])
15666        .fetch(tenant.pool())
15667        .await
15668        .unwrap_or_default();
15669
15670    if let Some(ids) = q.ids.as_deref() {
15671        let id_set: std::collections::HashSet<i64> = ids
15672            .split(',')
15673            .filter_map(|t| t.trim().parse::<i64>().ok())
15674            .collect();
15675        snippets.retain(|s| s.id.get().copied().is_some_and(|id| id_set.contains(&id)));
15676    }
15677    if let Some(tn) = type_filter.as_ref() {
15678        snippets.retain(|s| &s.type_name == tn);
15679    }
15680    if let Some(n) = needle.as_ref() {
15681        snippets
15682            .retain(|s| s.title.to_lowercase().contains(n) || s.slug.to_lowercase().contains(n));
15683    }
15684
15685    let items: Vec<serde_json::Value> = snippets
15686        .iter()
15687        .take(50)
15688        .map(|s| {
15689            serde_json::json!({
15690                "id": s.id.get().copied(),
15691                "title": s.title,
15692                "slug": s.slug,
15693                "type_name": s.type_name,
15694            })
15695        })
15696        .collect();
15697
15698    let body = serde_json::json!({ "items": items });
15699    Ok((
15700        [(header::CONTENT_TYPE, "application/json")],
15701        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15702    )
15703        .into_response())
15704}
15705
15706/// Query string for `GET /cms-admin/__document-chooser`.
15707#[derive(Debug, Deserialize)]
15708pub struct DocumentChooserQuery {
15709    #[serde(default)]
15710    pub q: Option<String>,
15711}
15712
15713/// GET /cms-admin/__document-chooser?q=… — JSON endpoint backing
15714/// the DocumentChooser widget. Returns top-50 media
15715/// rows where `kind = "document"` (i.e. non-images), filtered by
15716/// title / filename.
15717pub async fn document_chooser_json(
15718    State(_state): State<super::AdminState>,
15719    tenant: Tenant,
15720    Query(q): Query<DocumentChooserQuery>,
15721) -> Result<Response, AdminError> {
15722    let needle =
15723        q.q.as_deref()
15724            .map(str::trim)
15725            .filter(|s| !s.is_empty())
15726            .map(str::to_lowercase);
15727
15728    let mut rows: Vec<Media> = Media::objects()
15729        .where_(Media::kind.eq("document".to_owned()))
15730        .order_by(&[("uploaded_at", true)])
15731        .fetch(tenant.pool())
15732        .await
15733        .unwrap_or_default();
15734
15735    if let Some(n) = needle.as_ref() {
15736        rows.retain(|m| {
15737            m.title.to_lowercase().contains(n) || m.filename.to_lowercase().contains(n)
15738        });
15739    }
15740
15741    let items: Vec<serde_json::Value> = rows
15742        .iter()
15743        .take(50)
15744        .map(|m| {
15745            serde_json::json!({
15746                "id": m.id.get().copied(),
15747                "title": m.title,
15748                "filename": m.filename,
15749                "kind": m.kind,
15750                "mime": m.mime,
15751            })
15752        })
15753        .collect();
15754
15755    let body = serde_json::json!({ "items": items });
15756    Ok((
15757        [(header::CONTENT_TYPE, "application/json")],
15758        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15759    )
15760        .into_response())
15761}
15762
15763/// GET /cms-admin/search?q=<needle>[&autocomplete=1] — unified search
15764/// across pages, snippets, and media. In-memory case-insensitive
15765/// substring match only; the ranked `crate::search` backend is not
15766/// wired into this handler.
15767pub async fn admin_search(
15768    State(state): State<super::AdminState>,
15769    tenant: Tenant,
15770    headers: HeaderMap,
15771    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15772    Query(q): Query<AdminSearchQuery>,
15773) -> Result<Response, AdminError> {
15774    let needle =
15775        q.q.as_deref()
15776            .map(str::trim)
15777            .filter(|s| !s.is_empty())
15778            .map(str::to_lowercase);
15779    let autocomplete = q.autocomplete.as_deref() == Some("1");
15780
15781    // #143 — log every non-empty query. Best-effort; never blocks
15782    // the response. Skip autocomplete pings so the analytics surface
15783    // tracks user-intent queries, not keystroke-level ones.
15784    if !autocomplete {
15785        if let Some(raw) = q.q.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
15786            if let Err(e) = crate::search_promotion::log_query(tenant.pool(), raw).await {
15787                tracing::debug!(
15788                    target: "rustango_cms::search",
15789                    error = %e,
15790                    "search query log failed (best-effort)",
15791                );
15792            }
15793        }
15794    }
15795
15796    let mut pages_out: Vec<serde_json::Value> = Vec::new();
15797    let mut snippets_out: Vec<serde_json::Value> = Vec::new();
15798    let mut media_out: Vec<serde_json::Value> = Vec::new();
15799
15800    if let Some(needle) = needle.as_ref() {
15801        // Pages. #204 — recall extends from title/slug/url to also
15802        // include seo_title, seo_description, og_title, og_description
15803        // and (best-effort) the page-type extension's `load_extension`
15804        // JSON. Title hits float to the top — they're more relevant
15805        // than a stray match in a body paragraph.
15806        let all_pages: Vec<Page> = Page::objects()
15807            .order_by(&[("updated_at", true)])
15808            .fetch(tenant.pool())
15809            .await
15810            .unwrap_or_default();
15811        let page_types: Vec<PageType> = PageType::objects()
15812            .fetch(tenant.pool())
15813            .await
15814            .unwrap_or_default();
15815        let page_type_by_id: std::collections::HashMap<i64, String> = page_types
15816            .into_iter()
15817            .filter_map(|pt| pt.id.get().copied().map(|id| (id, pt.type_name)))
15818            .collect();
15819        let mut title_hits: Vec<serde_json::Value> = Vec::new();
15820        let mut body_hits: Vec<serde_json::Value> = Vec::new();
15821        for p in all_pages {
15822            if title_hits.len() + body_hits.len() >= 20 {
15823                break;
15824            }
15825            let title = p.title.to_lowercase();
15826            let slug = p.slug.to_lowercase();
15827            let url_path = p.url_path.to_lowercase();
15828            let primary_hit =
15829                title.contains(needle) || slug.contains(needle) || url_path.contains(needle);
15830
15831            // Wider body search — SEO/OG fields + extension JSON.
15832            let mut body_match = false;
15833            if !primary_hit {
15834                if p.seo_title.to_lowercase().contains(needle)
15835                    || p.seo_description.to_lowercase().contains(needle)
15836                    || p.og_title.to_lowercase().contains(needle)
15837                    || p.og_description.to_lowercase().contains(needle)
15838                {
15839                    body_match = true;
15840                }
15841                if !body_match {
15842                    if let Some(type_name) = page_type_by_id.get(&p.page_type_id) {
15843                        if let Some(handler) = crate::page_type::find_handler(type_name) {
15844                            let page_id = p.id.get().copied().unwrap_or_default();
15845                            if let Ok(ext) = handler.load_extension(tenant.pool(), page_id).await {
15846                                body_match = json_contains_needle(&ext, needle);
15847                            }
15848                        }
15849                    }
15850                }
15851            }
15852
15853            if primary_hit || body_match {
15854                let row = serde_json::json!({
15855                    "id": p.id.get().copied(),
15856                    "title": p.title,
15857                    "slug": p.slug,
15858                    "url_path": p.url_path,
15859                    "status": p.status,
15860                });
15861                if primary_hit {
15862                    title_hits.push(row);
15863                } else {
15864                    body_hits.push(row);
15865                }
15866            }
15867        }
15868        // Title-first ordering — primary hits float above body hits.
15869        pages_out.extend(title_hits);
15870        pages_out.extend(body_hits);
15871        if pages_out.len() > 20 {
15872            pages_out.truncate(20);
15873        }
15874
15875        // Snippets.
15876        let all_snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
15877            .order_by(&[("updated_at", true)])
15878            .fetch(tenant.pool())
15879            .await
15880            .unwrap_or_default();
15881        for s in all_snippets {
15882            if snippets_out.len() >= 20 {
15883                break;
15884            }
15885            let title = s.title.to_lowercase();
15886            let slug = s.slug.to_lowercase();
15887            if title.contains(needle) || slug.contains(needle) {
15888                snippets_out.push(serde_json::json!({
15889                    "id": s.id.get().copied(),
15890                    "title": s.title,
15891                    "slug": s.slug,
15892                    "type_name": s.type_name,
15893                }));
15894            }
15895        }
15896
15897        // Media.
15898        let all_media: Vec<crate::media::Media> = crate::media::Media::objects()
15899            .order_by(&[("created_at", true)])
15900            .fetch(tenant.pool())
15901            .await
15902            .unwrap_or_default();
15903        for m in all_media {
15904            if media_out.len() >= 20 {
15905                break;
15906            }
15907            let title = m.title.to_lowercase();
15908            let filename = m.filename.to_lowercase();
15909            let alt = m.alt_text.to_lowercase();
15910            if title.contains(needle) || filename.contains(needle) || alt.contains(needle) {
15911                media_out.push(serde_json::json!({
15912                    "id": m.id.get().copied(),
15913                    "title": m.title,
15914                    "filename": m.filename,
15915                    "alt_text": m.alt_text,
15916                    "kind": m.kind,
15917                }));
15918            }
15919        }
15920    }
15921
15922    // #107 — plugin-contributed search sources
15923    // (`register_admin_search_area!`). Each area returns its own
15924    // hit list keyed by area label. Empty when no query.
15925    let plugin_areas: Vec<serde_json::Value> = if let Some(query) = q.q.as_deref() {
15926        let trimmed = query.trim();
15927        if trimmed.is_empty() {
15928            Vec::new()
15929        } else {
15930            crate::hooks::run_admin_search_areas(trimmed)
15931                .into_iter()
15932                .map(|(label, hits)| {
15933                    serde_json::json!({
15934                        "label": label,
15935                        "hits": hits,
15936                    })
15937                })
15938                .collect()
15939        }
15940    } else {
15941        Vec::new()
15942    };
15943
15944    if autocomplete {
15945        // Compact JSON shape for the topbar dropdown.
15946        let payload = serde_json::json!({
15947            "q": q.q,
15948            "pages": pages_out.iter().take(5).collect::<Vec<_>>(),
15949            "snippets": snippets_out.iter().take(5).collect::<Vec<_>>(),
15950            "media": media_out.iter().take(5).collect::<Vec<_>>(),
15951            "plugin_areas": plugin_areas,
15952        });
15953        return Ok((
15954            [(header::CONTENT_TYPE, "application/json")],
15955            serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
15956        )
15957            .into_response());
15958    }
15959
15960    let mut ctx = Context::new();
15961    add_chrome(&mut ctx, &tenant, "search", session_user.as_ref()).await;
15962    add_admin_theme(&mut ctx, tenant.pool()).await;
15963    ctx.insert("query", &q.q.unwrap_or_default());
15964    ctx.insert("pages", &pages_out);
15965    ctx.insert("snippets", &snippets_out);
15966    ctx.insert("media", &media_out);
15967    let plugin_hit_count: usize = plugin_areas
15968        .iter()
15969        .filter_map(|a| a.get("hits").and_then(|h| h.as_array()).map(Vec::len))
15970        .sum();
15971    ctx.insert("plugin_search_areas", &plugin_areas);
15972    ctx.insert(
15973        "total_hits",
15974        &(pages_out.len() + snippets_out.len() + media_out.len() + plugin_hit_count),
15975    );
15976    render_with_csrf(&state, &headers, "rcms_admin/admin_search.html", &mut ctx)
15977}
15978
15979// =====================================================================
15980// Navigation menus (#22)
15981// =====================================================================
15982
15983/// GET /cms-admin/navigation — list every menu.
15984pub async fn navigation_list(
15985    State(state): State<super::AdminState>,
15986    tenant: Tenant,
15987    headers: HeaderMap,
15988    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15989) -> Result<Response, AdminError> {
15990    let menus: Vec<crate::navigation::Menu> = crate::navigation::Menu::objects()
15991        .order_by(&[("name", false)])
15992        .fetch(tenant.pool())
15993        .await?;
15994    // Per-menu item count so the list view shows "(N items)".
15995    let all_items: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
15996        .fetch(tenant.pool())
15997        .await?;
15998    let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
15999    for it in &all_items {
16000        *counts.entry(it.menu_id).or_insert(0) += 1;
16001    }
16002    let rows: Vec<serde_json::Value> = menus
16003        .iter()
16004        .map(|m| {
16005            let id = m.id.get().copied().unwrap_or_default();
16006            serde_json::json!({
16007                "id": id,
16008                "slug": m.slug,
16009                "name": m.name,
16010                "item_count": counts.get(&id).copied().unwrap_or(0),
16011                "created_at": m.created_at.get().copied(),
16012            })
16013        })
16014        .collect();
16015
16016    let mut ctx = Context::new();
16017    add_chrome(&mut ctx, &tenant, "navigation", session_user.as_ref()).await;
16018    add_admin_theme(&mut ctx, tenant.pool()).await;
16019    ctx.insert("menus", &rows);
16020    render_with_csrf(
16021        &state,
16022        &headers,
16023        "rcms_admin/navigation_list.html",
16024        &mut ctx,
16025    )
16026}
16027
16028/// Form payload for create / rename of a menu.
16029#[derive(Debug, Deserialize)]
16030pub struct MenuForm {
16031    pub slug: String,
16032    pub name: String,
16033}
16034
16035/// POST /cms-admin/navigation/new — create a new menu.
16036pub async fn navigation_create_submit(
16037    State(_state): State<super::AdminState>,
16038    tenant: Tenant,
16039    headers: HeaderMap,
16040    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16041    Form(form): Form<MenuForm>,
16042) -> Result<Response, AdminError> {
16043    let slug = form.slug.trim().to_lowercase();
16044    let name = form.name.trim().to_owned();
16045    if slug.is_empty() || name.is_empty() {
16046        return redirect_named_with_message(
16047            "rcms-admin:navigation:list",
16048            MsgLevel::Warning,
16049            "Menu slug + name are both required.",
16050            &headers,
16051        );
16052    }
16053    let mut row = crate::navigation::Menu {
16054        id: rustango::sql::Auto::Unset,
16055        slug: slug.clone(),
16056        name,
16057        created_at: rustango::sql::Auto::Unset,
16058    };
16059    row.insert_pool(tenant.pool()).await?;
16060    redirect_named_with_message_args(
16061        "rcms-admin:navigation:list",
16062        MsgLevel::Success,
16063        "Menu “{slug}” created.",
16064        &[("slug", slug.as_str())],
16065        &headers,
16066    )
16067}
16068
16069/// POST /cms-admin/navigation/{id}/delete — delete a menu (cascade
16070/// deletes its items via the schema FK).
16071pub async fn navigation_delete_submit(
16072    State(_state): State<super::AdminState>,
16073    tenant: Tenant,
16074    headers: HeaderMap,
16075    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16076    Path(id): Path<i64>,
16077) -> Result<Response, AdminError> {
16078    let menu = crate::navigation::Menu::objects()
16079        .where_(crate::navigation::Menu::id.eq(id))
16080        .first(tenant.pool())
16081        .await?
16082        .ok_or(AdminError::NotFound(id))?;
16083    // Items, their translations, then the menu — all in one transaction.
16084    // This used to delete items in fetch order with pool-level writes, so
16085    // a nested menu tripped the self-FK partway through and left the menu
16086    // half-deleted, and a translated item made it fail every time.
16087    let items: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16088        .where_(crate::navigation::MenuItem::menu_id.eq(id))
16089        .fetch(tenant.pool())
16090        .await?;
16091    rustango::atomic!(tenant.pool(), |tx| {
16092        let mut guard = tx.lock().await?;
16093        let tx = &mut *guard;
16094        delete_menu_items_tx(tx, items).await?;
16095        menu.delete_tx(tx).await?;
16096        Ok::<_, rustango::sql::ExecError>(())
16097    })
16098    .await?;
16099    redirect_named_with_message(
16100        "rcms-admin:navigation:list",
16101        MsgLevel::Success,
16102        "Menu deleted.",
16103        &headers,
16104    )
16105}
16106
16107/// POST /cms-admin/navigation/{id}/clone — duplicate a menu + all
16108/// its items. The new menu inherits the same item tree
16109/// (parent_id pointers remapped to the new MenuItem ids); page links
16110/// stay pointed at the same pages (no page duplication). Slug gets a
16111/// "-copy" suffix, then "-copy-2" / "-copy-3" / … to dodge the
16112/// unique constraint on `Menu.slug`. Name gets " (copy)" appended.
16113pub async fn navigation_clone_submit(
16114    State(_state): State<super::AdminState>,
16115    tenant: Tenant,
16116    headers: HeaderMap,
16117    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16118    Path(id): Path<i64>,
16119) -> Result<Response, AdminError> {
16120    let source = crate::navigation::Menu::objects()
16121        .where_(crate::navigation::Menu::id.eq(id))
16122        .first(tenant.pool())
16123        .await?
16124        .ok_or(AdminError::NotFound(id))?;
16125
16126    // Pick a unique slug. Menu.slug is unique across the tenant.
16127    let base = source.slug.trim_matches('-').to_owned();
16128    let desired = format!("{base}-copy");
16129    let existing_slugs: std::collections::HashSet<String> = crate::navigation::Menu::objects()
16130        .fetch(tenant.pool())
16131        .await?
16132        .into_iter()
16133        .map(|m| m.slug)
16134        .collect();
16135    let slug = if !existing_slugs.contains(&desired) {
16136        desired
16137    } else {
16138        let mut chosen = None;
16139        for n in 2..=100 {
16140            let candidate = format!("{desired}-{n}");
16141            if !existing_slugs.contains(&candidate) {
16142                chosen = Some(candidate);
16143                break;
16144            }
16145        }
16146        chosen.ok_or_else(|| {
16147            AdminError::Validation(
16148                "Could not allocate a unique slug for the cloned menu.".to_owned(),
16149            )
16150        })?
16151    };
16152
16153    let mut clone_menu = crate::navigation::Menu {
16154        id: rustango::sql::Auto::Unset,
16155        slug,
16156        name: format!("{} (copy)", source.name),
16157        created_at: rustango::sql::Auto::Unset,
16158    };
16159    // Clone items. `parent_id` needs remapping from source ids to the
16160    // freshly-inserted clone ids, so a parent must be inserted before its
16161    // children. `(parent_id.is_some(), sort_order, id)` is NOT that
16162    // order: it puts every non-root in one bucket sorted by `sort_order`,
16163    // which says nothing about depth. `seed_from_pages` numbers
16164    // `sort_order` per sibling bucket, so a grandchild routinely sorts
16165    // ahead of its parent — cloning a three-level menu then failed
16166    // partway and, with no transaction, left a junk `*-copy` behind.
16167    // Pre-order is the guarantee we actually need.
16168    let items = crate::navigation::order_pre_order(
16169        crate::navigation::MenuItem::objects()
16170            .where_(crate::navigation::MenuItem::menu_id.eq(id))
16171            .order_by(&[("sort_order", false), ("id", false)])
16172            .fetch(tenant.pool())
16173            .await?,
16174    );
16175    let count = items.len().to_string();
16176
16177    // Menu row and items together: a failure halfway through used to
16178    // leave the tenant with an empty, half-built `*-copy` menu.
16179    let new_menu_id = rustango::atomic!(tenant.pool(), |tx| {
16180        let mut guard = tx.lock().await?;
16181        let tx = &mut *guard;
16182        clone_menu.save_tx(tx).await?;
16183        let new_menu_id = clone_menu.id.get().copied().unwrap_or_default();
16184
16185        let mut id_map: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
16186        for item in &items {
16187            let old_id = item.id.get().copied().unwrap_or_default();
16188            // Pre-order guarantees the parent is mapped. An unreachable
16189            // item (orphan or cycle) is appended by `order_pre_order`
16190            // and re-parents to the root rather than aborting the clone
16191            // — losing the nesting of already-broken data beats refusing
16192            // to copy the menu at all.
16193            let new_parent = item.parent_id.and_then(|p| id_map.get(&p).copied());
16194            let mut clone_item = crate::navigation::MenuItem {
16195                id: rustango::sql::Auto::Unset,
16196                menu_id: new_menu_id,
16197                parent_id: new_parent,
16198                sort_order: item.sort_order,
16199                label: item.label.clone(),
16200                page_id: item.page_id,
16201                external_url: item.external_url.clone(),
16202                open_in_new_tab: item.open_in_new_tab,
16203            };
16204            clone_item.save_tx(tx).await?;
16205            id_map.insert(old_id, clone_item.id.get().copied().unwrap_or_default());
16206        }
16207        Ok::<_, rustango::sql::ExecError>(new_menu_id)
16208    })
16209    .await?;
16210
16211    redirect_named_with_params_and_message_args(
16212        "rcms-admin:navigation:edit",
16213        &[("id", new_menu_id.to_string())],
16214        MsgLevel::Success,
16215        "Cloned “{name}” with {count} items.",
16216        &[("name", source.name.as_str()), ("count", count.as_str())],
16217        &headers,
16218    )
16219}
16220
16221/// POST /cms-admin/navigation/{id}/seed-from-pages — Option B.
16222/// Replaces this menu's items with a tree
16223/// seeded from every published page that has `show_in_menus = true`.
16224/// The page tree's structure is preserved: a child MenuItem points
16225/// at its parent MenuItem when both pages are in the menu set; if a
16226/// page's parent is NOT in the menu set, the menu item lands at
16227/// the top level.
16228///
16229/// Idempotent — running it twice rebuilds the same tree (page ids
16230/// stay constant, so the second pass produces identical items).
16231/// Drops the existing menu items first; failure rolls back via
16232/// the per-row delete loop (matches the save-tree handler's
16233/// drop-and-rebuild approach).
16234pub async fn navigation_seed_from_pages_submit(
16235    State(_state): State<super::AdminState>,
16236    tenant: Tenant,
16237    headers: HeaderMap,
16238    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16239    Path(id): Path<i64>,
16240) -> Result<Response, AdminError> {
16241    use rustango::core::Column as _;
16242    use rustango::sql::FetcherPool as _;
16243
16244    let menu = crate::navigation::Menu::objects()
16245        .where_(crate::navigation::Menu::id.eq(id))
16246        .first(tenant.pool())
16247        .await?
16248        .ok_or(AdminError::NotFound(id))?;
16249
16250    // Step 1: collect what is there now. Deleted inside the transaction
16251    // below, not here — this used to delete row by row on the pool, in
16252    // fetch order, so re-seeding a nested menu tripped the self-FK
16253    // partway through and left the menu wiped with nothing re-inserted.
16254    // A second click on an "idempotent" button was straight data loss.
16255    let existing: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16256        .where_(crate::navigation::MenuItem::menu_id.eq(id))
16257        .fetch(tenant.pool())
16258        .await?;
16259
16260    // Step 2: fetch every menu-eligible page in materialized-path
16261    // order (tree-pre-order: a parent always appears before its
16262    // children, so the parent's new MenuItem id is mapped by the
16263    // time the child's row is processed).
16264    let mut pages: Vec<crate::page::Page> = crate::page::Page::objects()
16265        .where_(crate::page::Page::show_in_menus.eq(true))
16266        .where_(crate::page::Page::status.eq("published".to_owned()))
16267        .order_by(&[("path", false), ("id", false)])
16268        .fetch(tenant.pool())
16269        .await?;
16270    // Error pages are routing furniture, not navigation — excluded here
16271    // as `auto_menu`, `sitemap` and the tree endpoint all exclude them.
16272    // A 404 handler marked "Show in menus" used to land in the navbar.
16273    let error_tid = crate::error_pages::error_page_type_id(tenant.pool()).await;
16274    pages.retain(|p| error_tid.is_none_or(|tid| p.page_type_id != tid));
16275
16276    // Step 3: insert one MenuItem per page, mapping page.parent_id →
16277    // the freshly-inserted MenuItem id of that parent (if the parent
16278    // is also in the menu set). sort_order mirrors the sibling-
16279    // relative order in the page tree.
16280    let mut page_to_item: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
16281    let mut sibling_counter: std::collections::HashMap<Option<i64>, i32> =
16282        std::collections::HashMap::new();
16283    // One item per eligible page, so the count is known before the write
16284    // — and reading a counter mutated inside the transaction closure
16285    // would always have returned 0 anyway.
16286    let inserted = pages.len();
16287    rustango::atomic!(tenant.pool(), |tx| {
16288        let mut guard = tx.lock().await?;
16289        let tx = &mut *guard;
16290    delete_menu_items_tx(tx, existing).await?;
16291    for page in &pages {
16292        let page_id = page.id.get().copied().unwrap_or_default();
16293        let parent_menu_item_id: Option<i64> = page
16294            .parent_id
16295            .and_then(|pid| page_to_item.get(&pid).copied());
16296        // Sort order: monotonically increasing within each
16297        // parent-bucket so the menu builder shows pages in the same
16298        // sibling order the page tree has.
16299        let bucket = parent_menu_item_id;
16300        let sort_order = *sibling_counter
16301            .entry(bucket)
16302            .and_modify(|n| *n += 1)
16303            .or_insert(0);
16304        let mut item = crate::navigation::MenuItem {
16305            id: rustango::sql::Auto::Unset,
16306            menu_id: id,
16307            parent_id: parent_menu_item_id,
16308            sort_order,
16309            label: page.title.clone(),
16310            page_id: Some(page_id),
16311            external_url: None,
16312            open_in_new_tab: false,
16313        };
16314        item.save_tx(tx).await?;
16315        let new_item_id = item.id.get().copied().unwrap_or_default();
16316        page_to_item.insert(page_id, new_item_id);
16317    }
16318    Ok::<_, rustango::sql::ExecError>(())
16319    })
16320    .await?;
16321
16322    redirect_named_with_params_and_message_plural(
16323        "rcms-admin:navigation:edit",
16324        &[("id", id.to_string())],
16325        MsgLevel::Success,
16326        "Seeded “{name}” with {count} item(s) from pages marked Show in menus.",
16327        inserted as i64,
16328        &[
16329            ("name", menu.name.as_str()),
16330            ("count", &inserted.to_string()),
16331        ],
16332        &headers,
16333    )
16334}
16335
16336/// Delete menu items and their translations inside a transaction.
16337///
16338/// `cms_menu_item_translation.item_id` and `cms_menu_item.parent_id` are
16339/// both FKs with no `ON DELETE`, so the order is forced: translations
16340/// first, then items deepest-first. Three handlers got this wrong in
16341/// three different ways before it lived in one place — the menu delete
16342/// ignored translations entirely, the re-seed deleted in fetch order, and
16343/// save-tree sorted on `parent_id.is_none()`, which ties every non-root.
16344async fn delete_menu_items_tx(
16345    tx: &mut rustango::sql::PoolTx<'_>,
16346    items: Vec<crate::navigation::MenuItem>,
16347) -> Result<(), rustango::sql::ExecError> {
16348    use crate::menu_item_translation::MenuItemTranslation;
16349    if items.is_empty() {
16350        return Ok(());
16351    }
16352    let ids: Vec<i64> = items.iter().filter_map(|it| it.id.get().copied()).collect();
16353    if !ids.is_empty() {
16354        let orphans: Vec<MenuItemTranslation> = MenuItemTranslation::objects()
16355            .where_(MenuItemTranslation::item_id.is_in(ids))
16356            .fetch_tx(tx)
16357            .await?;
16358        for row in orphans {
16359            row.delete_tx(tx).await?;
16360        }
16361    }
16362    for it in crate::navigation::order_deepest_first(items) {
16363        it.delete_tx(tx).await?;
16364    }
16365    Ok(())
16366}
16367
16368/// POST /cms-admin/navigation/{id}/save-tree — WP-style menu builder
16369/// save. Accepts a JSON array of items in display order; each
16370/// entry's `local_id` is its position in the array (0-indexed) and
16371/// `parent_local_id` references the array index of the parent (null
16372/// for top-level). The handler:
16373///
16374///   1. Validates that the tree is acyclic + every parent_local_id
16375///      < the child's local_id (insert-order invariant).
16376///   2. Updates rows the payload still carries an `id` for, **in
16377///      place**, and inserts the rest.
16378///   3. Deletes the rows the payload dropped, children before parents.
16379///
16380/// It used to delete every row and re-insert, which meant a menu item's
16381/// id changed on every save. That was survivable while nothing
16382/// referenced those ids — and stopped being survivable the moment
16383/// `cms_menu_item_translation` keyed translations on `item_id`, since a
16384/// reorder would silently discard every translated label. Ids are now
16385/// stable across a save.
16386///
16387/// Failure rolls back; no half-saved state.
16388#[derive(Debug, Deserialize)]
16389pub struct SaveTreeItem {
16390    /// Existing `cms_menu_item.id`. `None` for items added in this
16391    /// session, in which case the handler inserts a new row. An id that
16392    /// doesn't belong to this menu is treated the same way, so a stale
16393    /// or forged id can't reassign another menu's item.
16394    #[serde(default)]
16395    pub id: Option<i64>,
16396    /// 0-indexed position in the submitted array.
16397    pub local_id: i32,
16398    /// Array index of the parent, or `None` for top-level.
16399    #[serde(default)]
16400    pub parent_local_id: Option<i32>,
16401    pub label: String,
16402    #[serde(default)]
16403    pub page_id: Option<i64>,
16404    #[serde(default)]
16405    pub external_url: Option<String>,
16406    #[serde(default)]
16407    pub open_in_new_tab: bool,
16408}
16409
16410#[derive(Debug, Deserialize)]
16411pub struct SaveTreePayload {
16412    pub items: Vec<SaveTreeItem>,
16413}
16414
16415pub async fn navigation_save_tree_submit(
16416    State(_state): State<super::AdminState>,
16417    tenant: Tenant,
16418    Path(id): Path<i64>,
16419    axum::Json(payload): axum::Json<SaveTreePayload>,
16420) -> Result<Response, AdminError> {
16421    // Validate tree shape: every parent_local_id must reference an
16422    // earlier index (so we can insert in order without two passes).
16423    for (i, item) in payload.items.iter().enumerate() {
16424        if item.local_id as usize != i {
16425            return Err(AdminError::Validation(format!(
16426                "items[{i}].local_id must equal its array index"
16427            )));
16428        }
16429        if let Some(p) = item.parent_local_id {
16430            if (p as usize) >= i {
16431                return Err(AdminError::Validation(format!(
16432                    "items[{i}].parent_local_id {p} must reference an earlier item"
16433                )));
16434            }
16435        }
16436    }
16437
16438    // Exactly one link target, and lengths the columns can hold. The
16439    // form handler enforced this and `save-tree` did not, so the builder
16440    // could store an item with both (`page_id` silently wins, and
16441    // unpublishing that page drops an item carrying a perfectly good
16442    // external fallback) or with neither (rendered as a link to `/`,
16443    // indistinguishable from a grouping header). An over-long label
16444    // reached the driver as a raw error and surfaced as a 500.
16445    for (i, item) in payload.items.iter().enumerate() {
16446        let external = item
16447            .external_url
16448            .as_deref()
16449            .map(str::trim)
16450            .filter(|s| !s.is_empty());
16451        match (item.page_id, external) {
16452            (Some(_), Some(_)) => {
16453                return Err(AdminError::Validation(format!(
16454                    "items[{i}] sets both a page and an external URL — pick one"
16455                )))
16456            }
16457            (None, None) => {
16458                return Err(AdminError::Validation(format!(
16459                    "items[{i}] has no link target — set a page or an external URL"
16460                )))
16461            }
16462            _ => {}
16463        }
16464        if item.label.chars().count() > 200 {
16465            return Err(AdminError::Validation(format!(
16466                "items[{i}].label is too long (max 200 characters)"
16467            )));
16468        }
16469        if external.is_some_and(|u| u.chars().count() > 500) {
16470            return Err(AdminError::Validation(format!(
16471                "items[{i}].external_url is too long (max 500 characters)"
16472            )));
16473        }
16474    }
16475
16476    // An id may appear at most once. The upsert below claims each kept row
16477    // out of `existing_by_id`, so a repeat would find the row already
16478    // taken — previously an `.expect` that panicked mid-transaction.
16479    let mut seen: std::collections::HashSet<i64> = std::collections::HashSet::new();
16480    for (i, item) in payload.items.iter().enumerate() {
16481        if let Some(iid) = item.id {
16482            if !seen.insert(iid) {
16483                return Err(AdminError::Validation(format!(
16484                    "items[{i}].id {iid} appears more than once"
16485                )));
16486            }
16487        }
16488    }
16489
16490    // Every sibling handler verifies the menu first; this one went
16491    // straight to inserting rows with `menu_id: id`, so a stale or
16492    // mistyped id surfaced as a raw FK violation (a 500) instead of a
16493    // 404.
16494    if crate::navigation::Menu::objects()
16495        .where_(crate::navigation::Menu::id.eq(id))
16496        .first(tenant.pool())
16497        .await?
16498        .is_none()
16499    {
16500        return Err(AdminError::NotFound(id));
16501    }
16502
16503    let existing: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16504        .where_(crate::navigation::MenuItem::menu_id.eq(id))
16505        .fetch(tenant.pool())
16506        .await?;
16507    let mut existing_by_id: std::collections::HashMap<i64, crate::navigation::MenuItem> = existing
16508        .into_iter()
16509        .filter_map(|it| it.id.get().copied().map(|iid| (iid, it)))
16510        .collect();
16511
16512    // Claim each payload entry's existing row up front, so the write loop
16513    // below has no fallible lookup left to make. `Some(row)` updates in
16514    // place (keeping the id, and with it the item's translations);
16515    // `None` inserts. An id from another menu, or one that isn't in this
16516    // menu at all, resolves to `None` rather than stealing that row.
16517    let plan: Vec<Option<crate::navigation::MenuItem>> = payload
16518        .items
16519        .iter()
16520        .map(|it| it.id.and_then(|iid| existing_by_id.remove(&iid)))
16521        .collect();
16522
16523    let items_saved = payload.items.len();
16524    rustango::atomic!(tenant.pool(), |tx| {
16525        let mut guard = tx.lock().await?;
16526        let tx = &mut *guard;
16527        // Upsert in array order, resolving each item's parent from the
16528        // slot its `local_id` indexes. The validation above pins
16529        // `local_id` to the array index and requires
16530        // `parent_local_id < local_id`, so a parent's slot is always
16531        // filled before a child reads it — no fallible lookup here, and
16532        // no way to express one.
16533        let mut resolved: Vec<i64> = Vec::with_capacity(payload.items.len());
16534        for ((i, item), claimed) in payload.items.iter().enumerate().zip(plan) {
16535            let parent_id = item.parent_local_id.map(|p| resolved[p as usize]);
16536            let external_url = item
16537                .external_url
16538                .as_ref()
16539                .filter(|s| !s.trim().is_empty())
16540                .cloned();
16541            let sort_order = (i as i32) * 10;
16542
16543            let new_id = match claimed {
16544                Some(mut row) => {
16545                    // Update in place — this is what keeps the id, and
16546                    // therefore the item's translations, alive.
16547                    let iid = row.id.get().copied().unwrap_or_default();
16548                    row.parent_id = parent_id;
16549                    row.sort_order = sort_order;
16550                    row.label = item.label.clone();
16551                    row.page_id = item.page_id;
16552                    row.external_url = external_url;
16553                    row.open_in_new_tab = item.open_in_new_tab;
16554                    row.save_tx(tx).await?;
16555                    iid
16556                }
16557                None => {
16558                    let mut row = crate::navigation::MenuItem {
16559                        id: rustango::sql::Auto::Unset,
16560                        menu_id: id,
16561                        parent_id,
16562                        sort_order,
16563                        label: item.label.clone(),
16564                        page_id: item.page_id,
16565                        external_url,
16566                        open_in_new_tab: item.open_in_new_tab,
16567                    };
16568                    row.save_tx(tx).await?;
16569                    row.id.get().copied().unwrap_or_default()
16570                }
16571            };
16572            resolved.push(new_id);
16573        }
16574
16575        // Whatever the payload dropped. Every surviving row has already
16576        // been repointed above, so nothing still references these — but
16577        // they may reference each other, and `MenuItem.parent_id` is an
16578        // FK to `cms_menu_item.id` with no `ON DELETE`, so a parent can
16579        // only go once its children are gone.
16580        delete_menu_items_tx(tx, existing_by_id.into_values().collect()).await?;
16581        Ok::<_, rustango::sql::ExecError>(())
16582    })
16583    .await?;
16584
16585    Ok(axum::Json(serde_json::json!({
16586        "ok": true,
16587        "items_saved": items_saved,
16588    }))
16589    .into_response())
16590}
16591
16592/// GET /cms-admin/navigation/{id}/edit — item editor for one menu.
16593pub async fn navigation_edit_form(
16594    State(state): State<super::AdminState>,
16595    tenant: Tenant,
16596    headers: HeaderMap,
16597    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
16598    Path(id): Path<i64>,
16599    Query(q): Query<EditQuery>,
16600) -> Result<Response, AdminError> {
16601    let menu = crate::navigation::Menu::objects()
16602        .where_(crate::navigation::Menu::id.eq(id))
16603        .first(tenant.pool())
16604        .await?
16605        .ok_or(AdminError::NotFound(id))?;
16606    // Pre-order, not `ORDER BY parent_id`. The builder derives each
16607    // item's parent from DOM adjacency on save, so the DOM has to start
16608    // in pre-order or merely opening a menu and pressing Save rewrites
16609    // its nesting — see `navigation::order_pre_order`.
16610    let items = crate::navigation::order_pre_order(
16611        crate::navigation::MenuItem::objects()
16612            .where_(crate::navigation::MenuItem::menu_id.eq(id))
16613            .order_by(&[("sort_order", false), ("id", false)])
16614            .fetch(tenant.pool())
16615            .await?,
16616    );
16617    // Pages flagged `show_in_menus = true` are the suggested-picker
16618    // entries; fall back to "every page" if no editor has opted any
16619    // pages in yet.
16620    let suggested: Vec<Page> = Page::objects()
16621        .where_(Page::show_in_menus.eq(true))
16622        .order_by(&[("title", false)])
16623        .fetch(tenant.pool())
16624        .await?;
16625    // WP-style builder (#44): the picker always shows every page so
16626    // editors can drop any of them in. The legacy curated flag stays
16627    // available for downstream theme rendering but no longer hides
16628    // pages from the admin picker.
16629    let all_pages: Vec<Page> = Page::objects()
16630        .order_by(&[("title", false)])
16631        .fetch(tenant.pool())
16632        .await?;
16633
16634    // Resolve item rows into a render-friendly shape (label, url,
16635    // page title for the dropdown when set).
16636    let by_page_id: std::collections::HashMap<i64, &Page> = all_pages
16637        .iter()
16638        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
16639        .collect();
16640    // ?locale=<non-default> switches the editor into translation mode:
16641    // the tree builder still edits canonical structure, and a second
16642    // panel edits this locale's label overrides. Same shape as the page
16643    // and snippet editors, so the locale switcher behaves identically
16644    // wherever an editor meets one.
16645    let locales: Vec<Locale> = Locale::objects()
16646        .where_(Locale::active.eq(true))
16647        .order_by(&[("is_default", true), ("code", false)])
16648        .fetch(tenant.pool())
16649        .await?;
16650    let editing_locale: Option<Locale> = match q.locale.as_deref().filter(|c| !c.is_empty()) {
16651        Some(code) => locales.iter().find(|l| l.code == code).cloned(),
16652        None => None,
16653    };
16654    let translation_mode = editing_locale.as_ref().is_some_and(|l| !l.is_default);
16655    let item_translations = match editing_locale.as_ref().filter(|l| !l.is_default) {
16656        Some(loc) => {
16657            let lid = loc.id.get().copied().unwrap_or_default();
16658            let ids: Vec<i64> = items.iter().filter_map(|it| it.id.get().copied()).collect();
16659            crate::menu_item_translation::fetch_for_items(tenant.pool(), &ids, lid).await?
16660        }
16661        None => std::collections::HashMap::new(),
16662    };
16663
16664    let item_rows: Vec<serde_json::Value> = items
16665        .iter()
16666        .map(|it| {
16667            let resolved_label = if it.label.trim().is_empty() {
16668                it.page_id
16669                    .and_then(|pid| by_page_id.get(&pid).map(|p| p.title.clone()))
16670                    .unwrap_or_default()
16671            } else {
16672                it.label.clone()
16673            };
16674            let resolved_url = match (it.page_id, it.external_url.clone()) {
16675                (Some(pid), _) => by_page_id
16676                    .get(&pid)
16677                    .map(|p| p.url_path.clone())
16678                    .unwrap_or_else(|| "—".to_owned()),
16679                (None, Some(url)) => url,
16680                _ => "—".to_owned(),
16681            };
16682            let tr = it
16683                .id
16684                .get()
16685                .and_then(|iid| item_translations.get(iid));
16686            serde_json::json!({
16687                "id": it.id.get().copied(),
16688                "label": it.label,
16689                "resolved_label": resolved_label,
16690                "page_id": it.page_id,
16691                "external_url": it.external_url,
16692                "parent_id": it.parent_id,
16693                "sort_order": it.sort_order,
16694                "open_in_new_tab": it.open_in_new_tab,
16695                "resolved_url": resolved_url,
16696                "tr_label": tr.and_then(|m| m.get("label")).cloned().unwrap_or_default(),
16697                "tr_external_url": tr
16698                    .and_then(|m| m.get("external_url"))
16699                    .cloned()
16700                    .unwrap_or_default(),
16701            })
16702        })
16703        .collect();
16704
16705    // Error pages are served for a status code; a menu never links one.
16706    let error_tid = crate::error_pages::error_page_type_id(tenant.pool()).await;
16707    let linkable = |p: &&Page| error_tid.map_or(true, |tid| p.page_type_id != tid);
16708    let picker_pages: Vec<serde_json::Value> = all_pages
16709        .iter()
16710        .filter(linkable)
16711        .map(|p| {
16712            serde_json::json!({
16713                "id": p.id.get().copied(),
16714                "title": p.title,
16715                "url_path": p.url_path,
16716            })
16717        })
16718        .collect();
16719
16720    // #49c — recent-pages tab. 20 most-recently-updated pages so
16721    // editors who just published something can drop it into the menu
16722    // without scrolling the full picker. Fetched via a separate
16723    // updated_at-desc query so the existing alphabetical picker
16724    // stays unchanged.
16725    let recent_pages_raw: Vec<Page> = Page::objects()
16726        .order_by(&[("updated_at", true)])
16727        .fetch(tenant.pool())
16728        .await?;
16729    let picker_recent: Vec<serde_json::Value> = recent_pages_raw
16730        .iter()
16731        .filter(linkable)
16732        .take(20)
16733        .map(|p| {
16734            serde_json::json!({
16735                "id": p.id.get().copied(),
16736                "title": p.title,
16737                "url_path": p.url_path,
16738                "updated_at": p.updated_at,
16739            })
16740        })
16741        .collect();
16742
16743    // #49d — Library tab. Each registered `LibraryTypeHandler` opts
16744    // in via `menu_picker_entries(pool)`; we flatten the result
16745    // across every handler and tag each entry with the contributing
16746    // type's verbose_name so editors can tell where an entry came
16747    // from. Failure in any handler short-circuits the response so
16748    // bugs surface loudly instead of silently hiding entries.
16749    let mut picker_library: Vec<serde_json::Value> = Vec::new();
16750    for handler in crate::library::registered_handlers() {
16751        let entries = handler
16752            .menu_picker_entries(tenant.pool())
16753            .await
16754            .map_err(|e| {
16755                AdminError::Validation(format!(
16756                    "library `{}::menu_picker_entries` failed: {e}",
16757                    handler.type_name()
16758                ))
16759            })?;
16760        for entry in entries {
16761            picker_library.push(serde_json::json!({
16762                "label": entry.label,
16763                "url": entry.url,
16764                "kind_hint": entry.kind_hint,
16765                "library_type": handler.verbose_name(),
16766            }));
16767        }
16768    }
16769
16770    let mut ctx = Context::new();
16771    add_chrome(&mut ctx, &tenant, "navigation", session_user.as_ref()).await;
16772    add_admin_theme(&mut ctx, tenant.pool()).await;
16773    ctx.insert("menu_id", &menu.id.get().copied());
16774    ctx.insert("menu_slug", &menu.slug);
16775    ctx.insert("menu_name", &menu.name);
16776    ctx.insert("items", &item_rows);
16777    ctx.insert("picker_pages", &picker_pages);
16778    ctx.insert("picker_recent", &picker_recent);
16779    ctx.insert("picker_library", &picker_library);
16780    ctx.insert("has_library_picker", &!picker_library.is_empty());
16781    ctx.insert("has_curated_picker", &!suggested.is_empty());
16782    ctx.insert("locales", &locales);
16783    ctx.insert("editing_locale", &editing_locale);
16784    ctx.insert("translation_mode", &translation_mode);
16785    render_with_csrf(
16786        &state,
16787        &headers,
16788        "rcms_admin/navigation_edit.html",
16789        &mut ctx,
16790    )
16791}
16792
16793/// POST /cms-admin/navigation/{id}/translate?locale=<code> — save this
16794/// locale's label overrides for a menu's items.
16795///
16796/// Separate from the tree save on purpose. The builder posts JSON and
16797/// owns *structure*; this posts a form and owns *text*, so an editor
16798/// translating labels cannot accidentally reshape the menu, and a
16799/// reorder cannot drop a translation.
16800///
16801/// Field names are `tr__<item id>__<field>`. An empty value deletes the
16802/// override rather than storing a blank, which is what makes the
16803/// canonical label show through again.
16804pub async fn navigation_translate_submit(
16805    State(_state): State<super::AdminState>,
16806    tenant: Tenant,
16807    Path(id): Path<i64>,
16808    Query(q): Query<EditQuery>,
16809    Form(form): Form<std::collections::HashMap<String, String>>,
16810) -> Result<Response, AdminError> {
16811    use crate::menu_item_translation::MenuItemTranslation;
16812
16813    let code = q
16814        .locale
16815        .as_deref()
16816        .filter(|c| !c.is_empty())
16817        .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
16818    let locale = Locale::objects()
16819        .where_(Locale::code.eq(code.to_owned()))
16820        .where_(Locale::active.eq(true))
16821        .first(tenant.pool())
16822        .await?
16823        .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
16824    if locale.is_default {
16825        return Ok((
16826            axum::http::StatusCode::BAD_REQUEST,
16827            "cannot translate INTO the default locale; canonical labels live on cms_menu_item",
16828        )
16829            .into_response());
16830    }
16831    let locale_id = locale
16832        .id
16833        .get()
16834        .copied()
16835        .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
16836
16837    // Only this menu's items are editable here — the field names carry
16838    // item ids, and without this check a crafted post could write
16839    // translations for another menu's items.
16840    let own_items: std::collections::HashSet<i64> = crate::navigation::MenuItem::objects()
16841        .where_(crate::navigation::MenuItem::menu_id.eq(id))
16842        .fetch(tenant.pool())
16843        .await?
16844        .iter()
16845        .filter_map(|it| it.id.get().copied())
16846        .collect();
16847
16848    let mut updates: Vec<(i64, String, String)> = Vec::new();
16849    for (k, v) in &form {
16850        let Some(rest) = k.strip_prefix("tr__") else {
16851            continue;
16852        };
16853        let Some((raw_id, raw_field)) = rest.split_once("__") else {
16854            continue;
16855        };
16856        let Ok(item_id) = raw_id.parse::<i64>() else {
16857            continue;
16858        };
16859        if !own_items.contains(&item_id) {
16860            continue;
16861        }
16862        // A malformed field is skipped rather than 400-ing the batch, so
16863        // one bad input doesn't discard an editor's other edits.
16864        if let Ok(field) = crate::menu_item_translation::validate_field_path(raw_field) {
16865            updates.push((item_id, field, v.trim().to_owned()));
16866        }
16867    }
16868
16869    rustango::atomic!(tenant.pool(), |tx| {
16870        let mut guard = tx.lock().await?;
16871        let tx = &mut *guard;
16872        for (item_id, field, value) in updates {
16873            let existing: Vec<MenuItemTranslation> = MenuItemTranslation::objects()
16874                .where_(MenuItemTranslation::item_id.eq(item_id))
16875                .where_(MenuItemTranslation::locale_id.eq(locale_id))
16876                .where_(MenuItemTranslation::field_path.eq(field.clone()))
16877                .fetch_tx(tx)
16878                .await?;
16879            if value.is_empty() {
16880                for row in existing {
16881                    row.delete_tx(tx).await?;
16882                }
16883            } else if let Some(mut row) = existing.into_iter().next() {
16884                row.value = value;
16885                row.save_tx(tx).await?;
16886            } else {
16887                let mut row = MenuItemTranslation {
16888                    id: rustango::sql::Auto::Unset,
16889                    item_id,
16890                    locale_id,
16891                    field_path: field,
16892                    value,
16893                    updated_at: rustango::sql::Auto::Unset,
16894                };
16895                row.save_tx(tx).await?;
16896            }
16897        }
16898        Ok::<_, rustango::sql::ExecError>(())
16899    })
16900    .await?;
16901
16902    Ok(Redirect::to(&format!(
16903        "/cms-admin/navigation/{id}/edit?locale={code}"
16904    ))
16905    .into_response())
16906}
16907
16908/// Form payload for adding / updating a menu item. Empty strings on
16909/// `page_id` and `external_url` map to None; the validator enforces
16910/// "exactly one of the two".
16911#[derive(Debug, Deserialize)]
16912pub struct MenuItemForm {
16913    pub label: String,
16914    #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
16915    pub page_id: Option<i64>,
16916    #[serde(default)]
16917    pub external_url: Option<String>,
16918    #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
16919    pub parent_id: Option<i64>,
16920    #[serde(default)]
16921    pub sort_order: Option<i32>,
16922    #[serde(default)]
16923    pub open_in_new_tab: Option<String>,
16924}
16925
16926/// Reject a `parent_id` that does not belong to `menu_id`.
16927///
16928/// The form took the value straight from the request, so an item could be
16929/// parented into another menu — leaving it invisible in *both* (each
16930/// resolver buckets by its own `menu_id`, so the child is unreachable in
16931/// one and filtered out of the other) and making the other menu
16932/// permanently undeletable, because its item is now referenced by a row
16933/// the delete never sees.
16934async fn validate_menu_parent(
16935    tenant: &Tenant,
16936    menu_id: i64,
16937    parent_id: Option<i64>,
16938) -> Result<(), AdminError> {
16939    let Some(pid) = parent_id else {
16940        return Ok(());
16941    };
16942    let parent = crate::navigation::MenuItem::objects()
16943        .where_(crate::navigation::MenuItem::id.eq(pid))
16944        .first(tenant.pool())
16945        .await?;
16946    match parent {
16947        Some(p) if p.menu_id == menu_id => Ok(()),
16948        Some(_) => Err(AdminError::Validation(
16949            "That parent item belongs to a different menu.".to_owned(),
16950        )),
16951        None => Err(AdminError::Validation(
16952            "That parent item no longer exists.".to_owned(),
16953        )),
16954    }
16955}
16956
16957impl MenuItemForm {
16958    fn parsed_external_url(&self) -> Option<String> {
16959        self.external_url
16960            .as_deref()
16961            .map(str::trim)
16962            .filter(|s| !s.is_empty())
16963            .map(str::to_owned)
16964    }
16965}
16966
16967/// POST /cms-admin/navigation/{id}/items — create a new menu item.
16968pub async fn navigation_item_create(
16969    State(_state): State<super::AdminState>,
16970    tenant: Tenant,
16971    headers: HeaderMap,
16972    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16973    Path(menu_id): Path<i64>,
16974    Form(form): Form<MenuItemForm>,
16975) -> Result<Response, AdminError> {
16976    let external = form.parsed_external_url();
16977    // "Exactly one of page_id / external_url" — fail soft to the
16978    // edit page with a warning message.
16979    if form.page_id.is_some() == external.is_some() {
16980        return redirect_named_with_params_and_message(
16981            "rcms-admin:navigation:edit",
16982            &[("id", menu_id.to_string())],
16983            MsgLevel::Warning,
16984            "Pick exactly one of: a page link, or a custom URL.",
16985            &headers,
16986        );
16987    }
16988    // The parent must live in this menu — see `validate_menu_parent`.
16989    validate_menu_parent(&tenant, menu_id, form.parent_id).await?;
16990    let mut row = crate::navigation::MenuItem {
16991        id: rustango::sql::Auto::Unset,
16992        menu_id,
16993        parent_id: form.parent_id,
16994        sort_order: form.sort_order.unwrap_or(100),
16995        label: form.label.trim().to_owned(),
16996        page_id: form.page_id,
16997        external_url: external,
16998        open_in_new_tab: form.open_in_new_tab.is_some(),
16999    };
17000    row.insert_pool(tenant.pool()).await?;
17001    redirect_named_with_params_and_message(
17002        "rcms-admin:navigation:edit",
17003        &[("id", menu_id.to_string())],
17004        MsgLevel::Success,
17005        "Item added.",
17006        &headers,
17007    )
17008}
17009
17010/// POST /cms-admin/navigation/{menu_id}/items/{id}/delete.
17011pub async fn navigation_item_delete(
17012    State(_state): State<super::AdminState>,
17013    tenant: Tenant,
17014    headers: HeaderMap,
17015    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
17016    Path((menu_id, id)): Path<(i64, i64)>,
17017) -> Result<Response, AdminError> {
17018    let row = crate::navigation::MenuItem::objects()
17019        .where_(crate::navigation::MenuItem::id.eq(id))
17020        .where_(crate::navigation::MenuItem::menu_id.eq(menu_id))
17021        .first(tenant.pool())
17022        .await?
17023        .ok_or(AdminError::NotFound(id))?;
17024    // Re-parent any children to the deleted item's parent so the
17025    // tree doesn't orphan a whole subtree.
17026    let children: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
17027        .where_(crate::navigation::MenuItem::parent_id.eq(Some(id)))
17028        .fetch(tenant.pool())
17029        .await?;
17030    for mut c in children {
17031        c.parent_id = row.parent_id;
17032        c.save_pool(tenant.pool()).await?;
17033    }
17034    row.delete_pool(tenant.pool()).await?;
17035    redirect_named_with_params_and_message(
17036        "rcms-admin:navigation:edit",
17037        &[("id", menu_id.to_string())],
17038        MsgLevel::Success,
17039        "Item deleted.",
17040        &headers,
17041    )
17042}
17043
17044// =====================================================================
17045// Page types — usage dashboard (#16)
17046// =====================================================================
17047
17048/// GET /cms-admin/page-types — registry of every page type the host
17049/// has compiled in, with how many pages of each currently exist + the
17050/// most-recent one. Useful before deprecating a type or refactoring
17051/// its declared fields.
17052pub async fn page_types_dashboard(
17053    State(state): State<super::AdminState>,
17054    tenant: Tenant,
17055    headers: HeaderMap,
17056    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17057) -> Result<Response, AdminError> {
17058    // Pull every Page row once and bucket by `page_type_id` in Rust;
17059    // sites have N pages but only a handful of types, so one fetch +
17060    // a HashMap aggregate beats a per-type COUNT round-trip.
17061    let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
17062    let page_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
17063
17064    let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17065    let mut latest: std::collections::HashMap<i64, chrono::DateTime<chrono::Utc>> =
17066        std::collections::HashMap::new();
17067    for p in &pages {
17068        *counts.entry(p.page_type_id).or_insert(0) += 1;
17069        if let Some(when) = p.published_at.or_else(|| p.created_at.get().copied()) {
17070            latest
17071                .entry(p.page_type_id)
17072                .and_modify(|cur| {
17073                    if when > *cur {
17074                        *cur = when;
17075                    }
17076                })
17077                .or_insert(when);
17078        }
17079    }
17080
17081    let type_id_by_name: std::collections::HashMap<&str, i64> = page_types
17082        .iter()
17083        .filter_map(|t| t.id.get().copied().map(|id| (t.type_name.as_str(), id)))
17084        .collect();
17085
17086    // Cross-reference the in-process handler registry with the DB
17087    // `cms_page_type` rows so unregistered + un-seeded types both
17088    // surface (handler-only = "compiled in but never used"; row-only
17089    // = "DB drift from an old build").
17090    let mut handler_names = std::collections::BTreeSet::new();
17091    let mut rows: Vec<serde_json::Value> = Vec::new();
17092    for handler in crate::page_type::registered_handlers() {
17093        let name = handler.type_name().to_owned();
17094        handler_names.insert(name.clone());
17095        let row_id = type_id_by_name.get(name.as_str()).copied();
17096        let count = row_id.and_then(|id| counts.get(&id).copied()).unwrap_or(0);
17097        let last = row_id.and_then(|id| latest.get(&id).copied());
17098        rows.push(serde_json::json!({
17099            "type_name": name,
17100            "verbose_name": handler.verbose_name(),
17101            "app_label": handler.app_label(),
17102            "icon": handler.icon(),
17103            "description": handler.description(),
17104            "default_template": handler.default_template(),
17105            "feed_kind": handler.feed_kind(),
17106            "allowed_parents": handler.allowed_parent_types(),
17107            "allowed_children": handler.allowed_child_types(),
17108            "is_creatable": handler.is_creatable(),
17109            "count": count,
17110            "latest": last,
17111            "registered": true,
17112            "row_id": row_id,
17113        }));
17114    }
17115
17116    // DB-only types — appear in `cms_page_type` but no handler is
17117    // compiled in. Two flavours: UI-created types (#566,
17118    // `app_label = "cms_ui"`, first-class — creatable + deletable) and
17119    // build drift (a stale row from an old binary — surfaced so editors
17120    // notice). Only UI types get a delete affordance, and only while no
17121    // pages use them; code types are never deletable from the UI.
17122    for t in &page_types {
17123        if !handler_names.contains(&t.type_name) {
17124            let id = t.id.get().copied().unwrap_or_default();
17125            let count = counts.get(&id).copied().unwrap_or(0);
17126            let ui_type = t.app_label == "cms_ui";
17127            rows.push(serde_json::json!({
17128                "type_name": t.type_name,
17129                "verbose_name": t.verbose_name,
17130                "app_label": t.app_label,
17131                "icon": if ui_type { serde_json::Value::String("dashboard_customize".to_owned()) } else { serde_json::Value::Null },
17132                "description": serde_json::Value::Null,
17133                "default_template": t.default_template,
17134                "feed_kind": serde_json::Value::Null,
17135                "allowed_parents": t.allowed_parent_types.clone(),
17136                "allowed_children": t.allowed_child_types.clone(),
17137                "is_creatable": ui_type && t.is_creatable,
17138                "count": count,
17139                "latest": latest.get(&id).copied(),
17140                "registered": false,
17141                "row_id": id,
17142                "ui_type": ui_type,
17143                "deletable": ui_type && count == 0,
17144            }));
17145        }
17146    }
17147    // Sort: most-used first; ties break by verbose_name.
17148    rows.sort_by(|a, b| {
17149        let ac = a.get("count").and_then(|v| v.as_i64()).unwrap_or(0);
17150        let bc = b.get("count").and_then(|v| v.as_i64()).unwrap_or(0);
17151        bc.cmp(&ac).then_with(|| {
17152            a.get("verbose_name")
17153                .and_then(|v| v.as_str())
17154                .unwrap_or("")
17155                .cmp(b.get("verbose_name").and_then(|v| v.as_str()).unwrap_or(""))
17156        })
17157    });
17158
17159    let mut ctx = Context::new();
17160    add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
17161    add_admin_theme(&mut ctx, tenant.pool()).await;
17162    ctx.insert("rows", &rows);
17163    ctx.insert("total_pages", &pages.len());
17164    ctx.insert("total_types", &rows.len());
17165    // #566 — the New-page-type affordance is Developer-gated (same
17166    // codename as the field builder). The template also checks the flag.
17167    let can_build = session_user.as_ref().is_some_and(|u| u.is_superuser)
17168        || crate::permissions::user_codenames(
17169            tenant.pool(),
17170            session_user
17171                .as_ref()
17172                .and_then(|u| u.id.get().copied())
17173                .unwrap_or_default(),
17174        )
17175        .await
17176        .unwrap_or_default()
17177        .contains("cms_page_type.build");
17178    ctx.insert("can_build_types", &can_build);
17179    ctx.insert("new_type_url", "/cms-admin/page-types/new");
17180    render_with_csrf(&state, &headers, "rcms_admin/page_types.html", &mut ctx)
17181}
17182
17183// =====================================================================
17184// Users / Roles — native CMS surface (#9). Replaces the prior
17185// `Redirect::to("/admin/rustango_users")` stub.
17186// =====================================================================
17187
17188/// User management is a **superuser-only** operation.
17189///
17190/// The create/edit handlers set `is_superuser`, `active`, and role
17191/// memberships straight from the submitted form, and the handlers
17192/// themselves previously performed no authorization at all — so any user
17193/// whose request reached the admin router could mint a superuser or
17194/// assign themselves a privileged role. Because *every* one of those
17195/// fields is a privilege the caller might not hold, the safe invariant
17196/// is to restrict the whole user-management surface to superusers rather
17197/// than try to police individual field grants. (Delegated, codename-
17198/// scoped user management that forbids privilege escalation can be added
17199/// later as a deliberate feature.)
17200///
17201/// The same gate covers roles and SSO providers, which decide who
17202/// a user *is* as much as the user rows do: a role editor could grant its
17203/// own role every codename, and an SSO-provider editor could point an
17204/// issuer at an IdP it controls and sign in as any user by email.
17205///
17206/// Returns `Some(redirect)` when denied — anonymous → login, an
17207/// authenticated non-superuser → the no-access page — and `None` when
17208/// the caller is a superuser and may proceed.
17209fn require_superuser_for_user_admin(
17210    user: Option<&rustango::tenancy::auth::User>,
17211) -> Option<Response> {
17212    use axum::response::{IntoResponse, Redirect};
17213    user_admin_denial_target(user.map(|u| u.is_superuser))
17214        .map(|path| Redirect::to(path).into_response())
17215}
17216
17217/// The redirect target for a user-management request, or `None` when the
17218/// caller (identified only by their superuser status: `None` = anonymous,
17219/// `Some(false)` = signed-in non-superuser, `Some(true)` = superuser) may
17220/// proceed. Split out from [`require_superuser_for_user_admin`] so the
17221/// deny/allow decision is unit-testable without constructing a framework
17222/// `User` (which has no `Default`).
17223fn user_admin_denial_target(is_superuser: Option<bool>) -> Option<&'static str> {
17224    match is_superuser {
17225        Some(true) => None,
17226        Some(false) => Some("/cms-admin/no-access"),
17227        None => Some("/login"),
17228    }
17229}
17230
17231/// GET /cms-admin/users — every tenant user with their assigned
17232/// roles + a delta-since indicator on the last password rotation.
17233pub async fn users_list(
17234    State(state): State<super::AdminState>,
17235    tenant: Tenant,
17236    headers: HeaderMap,
17237    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17238) -> Result<Response, AdminError> {
17239    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17240        return Ok(redirect);
17241    }
17242    let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
17243        .order_by(&[("username", false)])
17244        .fetch(tenant.pool())
17245        .await?;
17246    let roles: Vec<rustango::tenancy::permissions::Role> =
17247        rustango::tenancy::permissions::Role::objects()
17248            .fetch(tenant.pool())
17249            .await?;
17250    let user_roles: Vec<rustango::tenancy::permissions::UserRole> =
17251        rustango::tenancy::permissions::UserRole::objects()
17252            .fetch(tenant.pool())
17253            .await?;
17254
17255    let roles_by_id: std::collections::HashMap<i64, &rustango::tenancy::permissions::Role> = roles
17256        .iter()
17257        .filter_map(|r| r.id.get().copied().map(|id| (id, r)))
17258        .collect();
17259    let mut roles_by_user: std::collections::HashMap<i64, Vec<String>> =
17260        std::collections::HashMap::new();
17261    for ur in &user_roles {
17262        if let Some(role) = roles_by_id.get(&ur.role_id) {
17263            roles_by_user
17264                .entry(ur.user_id)
17265                .or_default()
17266                .push(role.name.clone());
17267        }
17268    }
17269
17270    let rows: Vec<serde_json::Value> = users
17271        .iter()
17272        .map(|u| {
17273            let id = u.id.get().copied();
17274            serde_json::json!({
17275                "id": id,
17276                "username": u.username,
17277                "email": user_email(u),
17278                "is_superuser": u.is_superuser,
17279                "active": u.active,
17280                "created_at": u.created_at,
17281                "password_changed_at": u.password_changed_at,
17282                "roles": id.and_then(|i| roles_by_user.get(&i).cloned()).unwrap_or_default(),
17283            })
17284        })
17285        .collect();
17286
17287    let mut ctx = Context::new();
17288    add_chrome(&mut ctx, &tenant, "users", session_user.as_ref()).await;
17289    add_admin_theme(&mut ctx, tenant.pool()).await;
17290    ctx.insert("users", &rows);
17291    ctx.insert("total_users", &users.len());
17292    ctx.insert("active_users", &users.iter().filter(|u| u.active).count());
17293    render_with_csrf(&state, &headers, "rcms_admin/users_list.html", &mut ctx)
17294}
17295
17296/// Query string for the security log: filters plus pagination. Not a
17297/// flattened [`crate::security_log::Filter`]: serde's `flatten` reads
17298/// every query value as a string, which breaks the numeric fields.
17299#[derive(Debug, Deserialize)]
17300pub struct SecurityLogQuery {
17301    #[serde(default)]
17302    pub event: String,
17303    #[serde(default)]
17304    pub username: String,
17305    #[serde(default)]
17306    pub page: Option<i64>,
17307    #[serde(default)]
17308    pub per_page: Option<usize>,
17309}
17310
17311/// The tag colour a security event shows in.
17312fn security_event_tone(event: &str) -> &'static str {
17313    use crate::security_log as log;
17314    match event {
17315        log::EVENT_LOGIN => "published",
17316        log::EVENT_LOGIN_FAILED => "scheduled",
17317        log::EVENT_LOCKOUT => "expired",
17318        log::EVENT_PERMISSIONS_CHANGED => "archived",
17319        _ => "draft",
17320    }
17321}
17322
17323/// GET /cms-admin/security-log — sign-ins, lockouts, sign-outs, password
17324/// resets and permission changes, newest first (#433). Superuser-only,
17325/// like the user and role screens it audits.
17326pub async fn security_log_page(
17327    State(state): State<super::AdminState>,
17328    tenant: Tenant,
17329    headers: HeaderMap,
17330    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17331    Query(q): Query<SecurityLogQuery>,
17332) -> Result<Response, AdminError> {
17333    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17334        return Ok(redirect);
17335    }
17336    let per_page = crate::admin::pagination::clamp_per_page(q.per_page);
17337    let filter = crate::security_log::Filter {
17338        event: q.event.trim().to_owned(),
17339        username: q.username.trim().to_owned(),
17340    };
17341    let total = crate::security_log::count(tenant.pool(), &filter).await?;
17342    let pagination = crate::admin::pagination::context(
17343        q.page.unwrap_or(1),
17344        per_page,
17345        usize::try_from(total).unwrap_or(0),
17346    );
17347    // Clamped into range, so a page past the end shows the last one.
17348    let page = pagination["page"].as_i64().unwrap_or(1);
17349    let events = crate::security_log::list(
17350        tenant.pool(),
17351        &filter,
17352        per_page as i64,
17353        crate::admin::pagination::offset(page, per_page),
17354    )
17355    .await?;
17356    let rows: Vec<serde_json::Value> = events
17357        .iter()
17358        .map(|e| {
17359            serde_json::json!({
17360                "event": e.event,
17361                "tone": security_event_tone(&e.event),
17362                "source": e.source,
17363                "user_id": e.user_id,
17364                "username": e.username,
17365                "reason": e.reason,
17366                "actor": e.actor,
17367                "detail": e.detail,
17368                "ip_address": e.ip_address,
17369                "user_agent": e.user_agent,
17370                "created_at": e.created_at.get().copied(),
17371            })
17372        })
17373        .collect();
17374
17375    let mut ctx = Context::new();
17376    add_chrome(&mut ctx, &tenant, "security-log", session_user.as_ref()).await;
17377    add_admin_theme(&mut ctx, tenant.pool()).await;
17378    ctx.insert("rows", &rows);
17379    ctx.insert("total", &total);
17380    ctx.insert("events", crate::security_log::EVENTS);
17381    ctx.insert("filter_event", &filter.event);
17382    ctx.insert("filter_username", &filter.username);
17383    ctx.insert("pagination", &pagination);
17384    render_with_csrf(&state, &headers, "rcms_admin/security_log.html", &mut ctx)
17385}
17386
17387/// GET /cms-admin/roles — list every role with its permission count
17388/// and member count.
17389pub async fn roles_list(
17390    State(state): State<super::AdminState>,
17391    tenant: Tenant,
17392    headers: HeaderMap,
17393    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17394) -> Result<Response, AdminError> {
17395    // Identity administration is superuser-only (#672).
17396    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17397        return Ok(redirect);
17398    }
17399    let roles: Vec<rustango::tenancy::permissions::Role> =
17400        rustango::tenancy::permissions::Role::objects()
17401            .order_by(&[("name", false)])
17402            .fetch(tenant.pool())
17403            .await?;
17404    let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17405        rustango::tenancy::permissions::RolePermission::objects()
17406            .fetch(tenant.pool())
17407            .await?;
17408    let user_roles: Vec<rustango::tenancy::permissions::UserRole> =
17409        rustango::tenancy::permissions::UserRole::objects()
17410            .fetch(tenant.pool())
17411            .await?;
17412
17413    let mut perm_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17414    for p in &perms {
17415        *perm_counts.entry(p.role_id).or_insert(0) += 1;
17416    }
17417    let mut member_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17418    for ur in &user_roles {
17419        *member_counts.entry(ur.role_id).or_insert(0) += 1;
17420    }
17421
17422    let rows: Vec<serde_json::Value> = roles
17423        .iter()
17424        .map(|r| {
17425            let id = r.id.get().copied().unwrap_or_default();
17426            serde_json::json!({
17427                "id": id,
17428                "name": r.name,
17429                "description": r.description,
17430                "perm_count": perm_counts.get(&id).copied().unwrap_or(0),
17431                "member_count": member_counts.get(&id).copied().unwrap_or(0),
17432            })
17433        })
17434        .collect();
17435    let mut ctx = Context::new();
17436    add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17437    add_admin_theme(&mut ctx, tenant.pool()).await;
17438    ctx.insert("roles", &rows);
17439    render_with_csrf(&state, &headers, "rcms_admin/roles_list.html", &mut ctx)
17440}
17441
17442/// GET `/cms-admin/permissions` — tenant-wide permission
17443/// overview matrix. The role editor matrix shows one role at a time;
17444/// this is the read-only birds-eye: every resource (grouped by section)
17445/// × every role, each cell listing the granted actions. Answers "who
17446/// can publish pages?" / "what can this role touch?" at a glance.
17447pub async fn permissions_overview(
17448    State(state): State<super::AdminState>,
17449    tenant: Tenant,
17450    headers: HeaderMap,
17451    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17452) -> Result<Response, AdminError> {
17453    let roles: Vec<rustango::tenancy::permissions::Role> =
17454        rustango::tenancy::permissions::Role::objects()
17455            .order_by(&[("name", false)])
17456            .fetch(tenant.pool())
17457            .await?;
17458    let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17459        rustango::tenancy::permissions::RolePermission::objects()
17460            .fetch(tenant.pool())
17461            .await?;
17462    let granted: std::collections::HashSet<(i64, String)> = perms
17463        .iter()
17464        .map(|p| (p.role_id, p.codename.clone()))
17465        .collect();
17466
17467    let role_headers: Vec<serde_json::Value> = roles
17468        .iter()
17469        .map(|r| {
17470            serde_json::json!({
17471                "id": r.id.get().copied().unwrap_or_default(),
17472                "name": r.name,
17473            })
17474        })
17475        .collect();
17476
17477    // sections → resource rows → one cell per role (granted action codes).
17478    let sections: Vec<serde_json::Value> = super::resources::grouped()
17479        .into_iter()
17480        .map(|(section, resources)| {
17481            let rows: Vec<serde_json::Value> = resources
17482                .iter()
17483                .map(|res| {
17484                    let cells: Vec<serde_json::Value> = roles
17485                        .iter()
17486                        .map(|r| {
17487                            let rid = r.id.get().copied().unwrap_or_default();
17488                            let actions = super::resources::granted_actions(res, rid, &granted);
17489                            serde_json::json!({
17490                                "actions": actions,
17491                                "any": !actions.is_empty(),
17492                            })
17493                        })
17494                        .collect();
17495                    serde_json::json!({
17496                        "label": res.label,
17497                        "key": res.key,
17498                        "cells": cells,
17499                    })
17500                })
17501                .collect();
17502            serde_json::json!({
17503                "label": section.label(),
17504                "rows": rows,
17505            })
17506        })
17507        .collect();
17508
17509    let mut ctx = Context::new();
17510    add_chrome(&mut ctx, &tenant, "permissions", session_user.as_ref()).await;
17511    add_admin_theme(&mut ctx, tenant.pool()).await;
17512    ctx.insert("roles", &role_headers);
17513    ctx.insert("sections", &sections);
17514    ctx.insert("role_count", &role_headers.len());
17515    render_with_csrf(
17516        &state,
17517        &headers,
17518        "rcms_admin/permissions_overview.html",
17519        &mut ctx,
17520    )
17521}
17522
17523/// GET /cms-admin/roles/new — create form.
17524pub async fn roles_new_form(
17525    State(state): State<super::AdminState>,
17526    tenant: Tenant,
17527    headers: HeaderMap,
17528    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17529) -> Result<Response, AdminError> {
17530    // Identity administration is superuser-only (#672).
17531    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17532        return Ok(redirect);
17533    }
17534    let mut ctx = Context::new();
17535    add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17536    add_admin_theme(&mut ctx, tenant.pool()).await;
17537    ctx.insert("mode", "new");
17538    ctx.insert(
17539        "role",
17540        &serde_json::json!({ "id": serde_json::Value::Null, "name": "", "description": "", "permissions": [] }),
17541    );
17542    ctx.insert("matrix", &build_permission_matrix(&[]));
17543    ctx.insert("legacy_codenames", &Vec::<String>::new());
17544    render_with_csrf(&state, &headers, "rcms_admin/role_form.html", &mut ctx)
17545}
17546
17547/// GET /cms-admin/roles/{id}/edit — edit form with permission
17548/// codenames pre-populated.
17549pub async fn roles_edit_form(
17550    State(state): State<super::AdminState>,
17551    tenant: Tenant,
17552    headers: HeaderMap,
17553    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17554    Path(id): Path<i64>,
17555) -> Result<Response, AdminError> {
17556    // Identity administration is superuser-only (#672).
17557    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17558        return Ok(redirect);
17559    }
17560    let role = rustango::tenancy::permissions::Role::objects()
17561        .where_(rustango::tenancy::permissions::Role::id.eq(id))
17562        .first(tenant.pool())
17563        .await?
17564        .ok_or(AdminError::NotFound(id))?;
17565    let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17566        rustango::tenancy::permissions::RolePermission::objects()
17567            .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17568            .order_by(&[("codename", false)])
17569            .fetch(tenant.pool())
17570            .await?;
17571    let codenames: Vec<String> = perms.iter().map(|p| p.codename.clone()).collect();
17572    let (_matched, legacy) = split_matrix_codenames(&codenames);
17573    let mut ctx = Context::new();
17574    add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17575    add_admin_theme(&mut ctx, tenant.pool()).await;
17576    ctx.insert("mode", "edit");
17577    ctx.insert(
17578        "role",
17579        &serde_json::json!({
17580            "id": role.id.get().copied(),
17581            "name": role.name,
17582            "description": role.description,
17583            "permissions": codenames,
17584        }),
17585    );
17586    ctx.insert("matrix", &build_permission_matrix(&codenames));
17587    ctx.insert("legacy_codenames", &legacy);
17588    render_with_csrf(&state, &headers, "rcms_admin/role_form.html", &mut ctx)
17589}
17590
17591/// Build the matrix structure consumed by `role_form.html`.
17592/// Returns one JSON object per [`super::resources::ResourceSection`]
17593/// with its rows pre-populated against the granted codename set so
17594/// the template can render checkboxes pre-checked.
17595///
17596/// The matrix is keyed by *resource key* (e.g. `pages`,
17597/// `library_item:author`) rather than codename so the same template
17598/// works regardless of which library types / custom admin pages a
17599/// downstream crate registers.
17600fn build_permission_matrix(granted: &[String]) -> serde_json::Value {
17601    use super::resources::{codename, grouped};
17602    use crate::permissions::Action;
17603
17604    let granted_set: std::collections::HashSet<&str> = granted.iter().map(String::as_str).collect();
17605
17606    let mut sections = Vec::new();
17607    for (section, rows) in grouped() {
17608        let rows_json: Vec<serde_json::Value> = rows
17609            .iter()
17610            .map(|r| {
17611                let applicable: Vec<&str> = r.actions.iter().map(|a| a.as_str()).collect();
17612                let granted_actions: Vec<&str> = [
17613                    Action::Access,
17614                    Action::AccessAdmin,
17615                    Action::View,
17616                    Action::Add,
17617                    Action::Edit,
17618                    Action::Publish,
17619                    Action::Delete,
17620                ]
17621                .iter()
17622                .copied()
17623                .filter(|action| {
17624                    r.actions.contains(action)
17625                        && granted_set.contains(codename(r, *action).as_str())
17626                })
17627                .map(|a| a.as_str())
17628                .collect();
17629                serde_json::json!({
17630                    "key": r.key,
17631                    "label": r.label,
17632                    "applicable": applicable,
17633                    "granted": granted_actions,
17634                })
17635            })
17636            .collect();
17637        sections.push(serde_json::json!({
17638            "section_label": section.label(),
17639            "rows": rows_json,
17640        }));
17641    }
17642    serde_json::Value::Array(sections)
17643}
17644
17645/// Split the supplied codename list into:
17646/// 1. The codenames represented in the matrix (`matched`) — these
17647///    get fully re-computed from the form submission.
17648/// 2. Everything else (`legacy`) — preserved across saves so
17649///    out-of-matrix grants (third-party codenames, ad-hoc strings
17650///    from before the matrix existed) survive a role edit.
17651fn split_matrix_codenames(granted: &[String]) -> (Vec<String>, Vec<String>) {
17652    use super::resources::{all_resources, codename};
17653    use crate::permissions::Action;
17654
17655    let known: std::collections::HashSet<String> = all_resources()
17656        .iter()
17657        .flat_map(|r| {
17658            r.actions
17659                .iter()
17660                .copied()
17661                .filter(|a| {
17662                    // Mirror the matrix — only actions in `r.actions`
17663                    // can be toggled, so only those codenames are
17664                    // "matrix-owned".
17665                    matches!(
17666                        a,
17667                        Action::View
17668                            | Action::Add
17669                            | Action::Edit
17670                            | Action::Publish
17671                            | Action::Delete
17672                            | Action::Access
17673                            | Action::AccessAdmin
17674                    )
17675                })
17676                .map(|a| codename(r, a))
17677                .collect::<Vec<_>>()
17678        })
17679        .collect();
17680    let (matched, legacy): (Vec<String>, Vec<String>) =
17681        granted.iter().cloned().partition(|c| known.contains(c));
17682    (matched, legacy)
17683}
17684
17685/// Parse the matrix POST shape (`perm[<key>][<action>]=1`) into a
17686/// codename list. Unknown keys / actions are silently dropped — the
17687/// matrix is authoritative for the resources it represents.
17688fn parse_matrix_form(form: &std::collections::HashMap<String, String>) -> Vec<String> {
17689    use super::resources::{all_resources, codename};
17690    use crate::permissions::Action;
17691
17692    let resources = all_resources();
17693    let resource_by_key: std::collections::HashMap<&str, &super::resources::AdminResource> =
17694        resources.iter().map(|r| (r.key.as_str(), r)).collect();
17695
17696    let mut out = Vec::new();
17697    for (raw_key, value) in form {
17698        // Form serializes `name="perm[<key>][<action>]"`. The bracket
17699        // shape stays intact in `serde_urlencoded` because it doesn't
17700        // try to descend nested keys — we parse manually.
17701        let Some(rest) = raw_key.strip_prefix("perm[") else {
17702            continue;
17703        };
17704        let Some((key, rest)) = rest.split_once("][") else {
17705            continue;
17706        };
17707        let Some(action_str) = rest.strip_suffix(']') else {
17708            continue;
17709        };
17710        // Checkbox semantics: present-and-truthy means granted;
17711        // absent means not granted. Browsers always send `1` for
17712        // checked boxes here.
17713        if value.is_empty() || value == "0" || value.eq_ignore_ascii_case("off") {
17714            continue;
17715        }
17716        let Some(resource) = resource_by_key.get(key) else {
17717            continue;
17718        };
17719        let action = match action_str {
17720            "view" => Action::View,
17721            "add" => Action::Add,
17722            "edit" => Action::Edit,
17723            "publish" => Action::Publish,
17724            "delete" => Action::Delete,
17725            "access" => Action::Access,
17726            "access_admin" => Action::AccessAdmin,
17727            _ => continue,
17728        };
17729        if !resource.actions.contains(&action) {
17730            continue;
17731        }
17732        out.push(codename(resource, action));
17733    }
17734    out.sort();
17735    out.dedup();
17736    out
17737}
17738
17739/// Shared helper: replace the codename set for a role with the
17740/// supplied list. Idempotent — added/removed deltas only.
17741async fn sync_role_codenames(
17742    pool: &rustango::sql::Pool,
17743    role_id: i64,
17744    new_codenames: &[String],
17745) -> Result<(), AdminError> {
17746    let existing: Vec<rustango::tenancy::permissions::RolePermission> =
17747        rustango::tenancy::permissions::RolePermission::objects()
17748            .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(role_id))
17749            .fetch(pool)
17750            .await?;
17751    let want: std::collections::BTreeSet<&str> = new_codenames.iter().map(String::as_str).collect();
17752    let have: std::collections::BTreeSet<&str> =
17753        existing.iter().map(|p| p.codename.as_str()).collect();
17754    // Drop the codenames that are no longer wanted.
17755    for p in &existing {
17756        if !want.contains(p.codename.as_str()) {
17757            p.clone().delete_pool(pool).await?;
17758        }
17759    }
17760    // Insert the codenames that aren't already there.
17761    for codename in new_codenames {
17762        if !have.contains(codename.as_str()) {
17763            let mut row = rustango::tenancy::permissions::RolePermission {
17764                id: rustango::sql::Auto::Unset,
17765                role_id,
17766                codename: codename.clone(),
17767            };
17768            row.insert_pool(pool).await?;
17769        }
17770    }
17771    Ok(())
17772}
17773
17774/// POST /cms-admin/roles/new — create a role + sync its codenames.
17775/// Body shape (matrix): `name=`, `description=`, plus one
17776/// `perm[<resource>][<action>]=1` per granted cell.
17777pub async fn roles_create_submit(
17778    State(_state): State<super::AdminState>,
17779    tenant: Tenant,
17780    headers: HeaderMap,
17781    request: crate::security_log::LoginRequest,
17782    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17783    Form(form): Form<std::collections::HashMap<String, String>>,
17784) -> Result<Response, AdminError> {
17785    // Identity administration is superuser-only (#672).
17786    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17787        return Ok(redirect);
17788    }
17789    let name = form.get("name").map(|s| s.trim()).unwrap_or("").to_owned();
17790    if name.is_empty() {
17791        return Err(AdminError::Validation("Role name is required.".to_owned()));
17792    }
17793    let description = form
17794        .get("description")
17795        .map(|s| s.trim())
17796        .unwrap_or("")
17797        .to_owned();
17798    let mut row = rustango::tenancy::permissions::Role {
17799        id: rustango::sql::Auto::Unset,
17800        name: name.clone(),
17801        description,
17802        data: serde_json::Value::Object(serde_json::Map::new()),
17803    };
17804    row.insert_pool(tenant.pool()).await?;
17805    let role_id = row.id.get().copied().unwrap_or_default();
17806    let codenames = parse_matrix_form(&form);
17807    sync_role_codenames(tenant.pool(), role_id, &codenames).await?;
17808    let detail = crate::security_log::describe_role_change(&name, &[], &codenames)
17809        .unwrap_or_else(|| format!("role “{name}”: no permissions"));
17810    record_access_change(&tenant, session_user.as_ref(), &request, None, format!("created {detail}"))
17811        .await;
17812    redirect_named_with_message_args(
17813        "rcms-admin:roles",
17814        MsgLevel::Success,
17815        "Role “{name}” created.",
17816        &[("name", name.as_str())],
17817        &headers,
17818    )
17819}
17820
17821/// POST /cms-admin/roles/{id}/edit — update name/description +
17822/// sync the codename set. Out-of-matrix legacy codenames are
17823/// preserved across saves.
17824pub async fn roles_edit_submit(
17825    State(_state): State<super::AdminState>,
17826    tenant: Tenant,
17827    headers: HeaderMap,
17828    request: crate::security_log::LoginRequest,
17829    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17830    Path(id): Path<i64>,
17831    Form(form): Form<std::collections::HashMap<String, String>>,
17832) -> Result<Response, AdminError> {
17833    // Identity administration is superuser-only (#672).
17834    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17835        return Ok(redirect);
17836    }
17837    let mut role = rustango::tenancy::permissions::Role::objects()
17838        .where_(rustango::tenancy::permissions::Role::id.eq(id))
17839        .first(tenant.pool())
17840        .await?
17841        .ok_or(AdminError::NotFound(id))?;
17842    let name = form.get("name").map(|s| s.trim()).unwrap_or("").to_owned();
17843    if name.is_empty() {
17844        return Err(AdminError::Validation("Role name is required.".to_owned()));
17845    }
17846    let description = form
17847        .get("description")
17848        .map(|s| s.trim())
17849        .unwrap_or("")
17850        .to_owned();
17851    role.name = name.clone();
17852    role.description = description;
17853    role.save_pool(tenant.pool()).await?;
17854    // Carry over codenames that live outside the matrix surface so
17855    // legacy / third-party codenames aren't silently dropped when
17856    // an admin saves the matrix-only form.
17857    let existing: Vec<rustango::tenancy::permissions::RolePermission> =
17858        rustango::tenancy::permissions::RolePermission::objects()
17859            .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17860            .fetch(tenant.pool())
17861            .await?;
17862    let existing_codenames: Vec<String> = existing.into_iter().map(|p| p.codename).collect();
17863    let (_old_matrix, legacy) = split_matrix_codenames(&existing_codenames);
17864    let mut codenames = parse_matrix_form(&form);
17865    codenames.extend(legacy);
17866    codenames.sort();
17867    codenames.dedup();
17868    sync_role_codenames(tenant.pool(), id, &codenames).await?;
17869    if let Some(detail) =
17870        crate::security_log::describe_role_change(&name, &existing_codenames, &codenames)
17871    {
17872        record_access_change(&tenant, session_user.as_ref(), &request, None, detail).await;
17873    }
17874    redirect_named_with_message_args(
17875        "rcms-admin:roles",
17876        MsgLevel::Success,
17877        "Role “{name}” saved.",
17878        &[("name", name.as_str())],
17879        &headers,
17880    )
17881}
17882
17883/// POST /cms-admin/roles/{id}/delete — delete the role + its
17884/// codenames + every UserRole row referencing it.
17885pub async fn roles_delete_submit(
17886    State(_state): State<super::AdminState>,
17887    tenant: Tenant,
17888    headers: HeaderMap,
17889    request: crate::security_log::LoginRequest,
17890    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17891    Path(id): Path<i64>,
17892) -> Result<Response, AdminError> {
17893    // Identity administration is superuser-only (#672).
17894    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17895        return Ok(redirect);
17896    }
17897    let role = rustango::tenancy::permissions::Role::objects()
17898        .where_(rustango::tenancy::permissions::Role::id.eq(id))
17899        .first(tenant.pool())
17900        .await?
17901        .ok_or(AdminError::NotFound(id))?;
17902    let name = role.name.clone();
17903    // Delete dependent rows manually — the schema FK isn't ON DELETE CASCADE.
17904    for p in rustango::tenancy::permissions::RolePermission::objects()
17905        .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17906        .fetch(tenant.pool())
17907        .await?
17908    {
17909        p.delete_pool(tenant.pool()).await?;
17910    }
17911    for ur in rustango::tenancy::permissions::UserRole::objects()
17912        .where_(rustango::tenancy::permissions::UserRole::role_id.eq(id))
17913        .fetch(tenant.pool())
17914        .await?
17915    {
17916        ur.delete_pool(tenant.pool()).await?;
17917    }
17918    role.delete_pool(tenant.pool()).await?;
17919    record_access_change(
17920        &tenant,
17921        session_user.as_ref(),
17922        &request,
17923        None,
17924        format!("deleted role “{name}”"),
17925    )
17926    .await;
17927    redirect_named_with_message_args(
17928        "rcms-admin:roles",
17929        MsgLevel::Success,
17930        "Role “{name}” deleted.",
17931        &[("name", name.as_str())],
17932        &headers,
17933    )
17934}
17935
17936/// GET /cms-admin/users/new — create form.
17937pub async fn users_new_form(
17938    State(state): State<super::AdminState>,
17939    tenant: Tenant,
17940    headers: HeaderMap,
17941    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17942) -> Result<Response, AdminError> {
17943    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17944        return Ok(redirect);
17945    }
17946    let mut ctx = Context::new();
17947    add_chrome(&mut ctx, &tenant, "users", session_user.as_ref()).await;
17948    add_admin_theme(&mut ctx, tenant.pool()).await;
17949    ctx.insert("mode", "new");
17950    ctx.insert(
17951        "user",
17952        &serde_json::json!({
17953            "id": serde_json::Value::Null,
17954            "username": "",
17955            "is_superuser": false,
17956            "active": true,
17957        }),
17958    );
17959    // Roles can be given right away, not only after a second visit.
17960    let role_choices: Vec<serde_json::Value> = rustango::tenancy::permissions::Role::objects()
17961        .order_by(&[("name", false)])
17962        .fetch(tenant.pool())
17963        .await?
17964        .iter()
17965        .map(|r| {
17966            serde_json::json!({
17967                "id": r.id.get().copied().unwrap_or_default(),
17968                "name": r.name,
17969                "description": r.description,
17970                "assigned": false,
17971            })
17972        })
17973        .collect();
17974    ctx.insert("role_choices", &role_choices);
17975    render_with_csrf(&state, &headers, "rcms_admin/user_form.html", &mut ctx)
17976}
17977
17978/// GET /cms-admin/users/{id}/edit — edit form. Password field stays
17979/// empty by default; leave blank to keep the existing password.
17980/// Includes a role-checkbox group so editors can grant / revoke
17981/// role memberships inline.
17982pub async fn users_edit_form(
17983    State(state): State<super::AdminState>,
17984    tenant: Tenant,
17985    headers: HeaderMap,
17986    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17987    Path(id): Path<i64>,
17988) -> Result<Response, AdminError> {
17989    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17990        return Ok(redirect);
17991    }
17992    render_user_edit_page(&state, &tenant, &headers, session_user.as_ref(), id, None).await
17993}
17994
17995async fn render_user_edit_page(
17996    state: &super::AdminState,
17997    tenant: &Tenant,
17998    headers: &HeaderMap,
17999    session_user: Option<&rustango::tenancy::auth::User>,
18000    id: i64,
18001    mcp_one_time: Option<serde_json::Value>,
18002) -> Result<Response, AdminError> {
18003    let user = rustango::tenancy::auth::User::objects()
18004        .where_(rustango::tenancy::auth::User::id.eq(id))
18005        .first(tenant.pool())
18006        .await?
18007        .ok_or(AdminError::NotFound(id))?;
18008    let roles: Vec<rustango::tenancy::permissions::Role> =
18009        rustango::tenancy::permissions::Role::objects()
18010            .order_by(&[("name", false)])
18011            .fetch(tenant.pool())
18012            .await?;
18013    let memberships: Vec<rustango::tenancy::permissions::UserRole> =
18014        rustango::tenancy::permissions::UserRole::objects()
18015            .where_(rustango::tenancy::permissions::UserRole::user_id.eq(id))
18016            .fetch(tenant.pool())
18017            .await?;
18018    let assigned: std::collections::BTreeSet<i64> = memberships.iter().map(|m| m.role_id).collect();
18019
18020    let role_choices: Vec<serde_json::Value> = roles
18021        .iter()
18022        .map(|r| {
18023            let rid = r.id.get().copied().unwrap_or_default();
18024            serde_json::json!({
18025                "id": rid,
18026                "name": r.name,
18027                "description": r.description,
18028                "assigned": assigned.contains(&rid),
18029            })
18030        })
18031        .collect();
18032
18033    // #13 V2 — per-user timezone stored in `User.data.timezone`.
18034    // No framework column change required; the existing JSON bag
18035    // holds the IANA name. Empty / missing = browser-detected
18036    // fallback (the no-flash JS already handles that case).
18037    let user_timezone = user
18038        .data
18039        .get("timezone")
18040        .and_then(serde_json::Value::as_str)
18041        .unwrap_or("")
18042        .to_owned();
18043    let user_email = user_email(&user);
18044
18045    let mut ctx = Context::new();
18046    add_chrome(&mut ctx, tenant, "users", session_user).await;
18047    add_admin_theme(&mut ctx, tenant.pool()).await;
18048    ctx.insert("mode", "edit");
18049    ctx.insert(
18050        "user",
18051        &serde_json::json!({
18052            "id": user.id.get().copied(),
18053            "username": user.username,
18054            "email": user_email,
18055            "is_superuser": user.is_superuser,
18056            "active": user.active,
18057            "timezone": user_timezone,
18058            "password_changed_at": user.password_changed_at,
18059            "created_at": user.created_at,
18060        }),
18061    );
18062    ctx.insert("role_choices", &role_choices);
18063    // #587 — the target user's MCP keys, for admin-managed minting
18064    // (the "register an agent user, give it a key" flow).
18065    let (keys, skills) = mcp_keys_ctx(tenant.pool(), id).await;
18066    ctx.insert("mcp_keys", &keys);
18067    ctx.insert("mcp_skills", &skills);
18068    if let Some(one_time) = &mcp_one_time {
18069        ctx.insert("mcp_one_time", one_time);
18070    }
18071    render_with_csrf(state, headers, "rcms_admin/user_form.html", &mut ctx)
18072}
18073
18074// ------------------------------------------------------------- MCP keys (#587)
18075
18076/// Parse a keys-create form: `label` (optional) + repeated `skill`
18077/// entries (optional scope — empty = the owner's full entitlement).
18078fn parse_mcp_key_form(pairs: &[(String, String)]) -> (String, Vec<String>) {
18079    let label = pairs
18080        .iter()
18081        .find(|(k, _)| k == "label")
18082        .map(|(_, v)| v.trim())
18083        .filter(|v| !v.is_empty())
18084        .unwrap_or("MCP key")
18085        .to_owned();
18086    let skills: Vec<String> = pairs
18087        .iter()
18088        .filter(|(k, v)| k == "skill" && !v.trim().is_empty())
18089        .map(|(_, v)| v.trim().to_owned())
18090        .collect();
18091    (label, skills)
18092}
18093
18094/// Best-effort audit trail for key lifecycle events — explicit source
18095/// because the CMS admin doesn't install `audit::with_source`.
18096async fn audit_mcp_key(
18097    pool: &rustango::sql::Pool,
18098    actor_id: i64,
18099    what: &str,
18100    detail: serde_json::Value,
18101) {
18102    let entry = rustango::audit::PendingEntry {
18103        entity_table: "rustango_agents",
18104        entity_pk: detail
18105            .get("key_id")
18106            .and_then(serde_json::Value::as_i64)
18107            .map(|i| i.to_string())
18108            .unwrap_or_default(),
18109        operation: rustango::audit::AuditOp::Action,
18110        source: rustango::audit::AuditSource::User {
18111            id: actor_id.to_string(),
18112        },
18113        changes: serde_json::json!({ "event": what, "detail": detail }),
18114    };
18115    if let Err(e) = rustango::audit::emit_one_pool(pool, &entry).await {
18116        tracing::warn!(error = %e, "mcp key audit emit failed");
18117    }
18118}
18119
18120/// Mint a user key for `owner_id`, mapping scope-validation failures to a
18121/// user-facing message. Returns the show-once payload for the dialog.
18122async fn mint_mcp_key(
18123    pool: &rustango::sql::Pool,
18124    actor_id: i64,
18125    owner_id: i64,
18126    label: &str,
18127    skills: &[String],
18128) -> Result<serde_json::Value, String> {
18129    match rustango::tenancy::create_user_key_pool(pool, owner_id, label, skills).await {
18130        Ok(issued) => {
18131            let key_id = issued.agent.id.get().copied().unwrap_or_default();
18132            audit_mcp_key(
18133                pool,
18134                actor_id,
18135                "created",
18136                serde_json::json!({ "key_id": key_id, "owner_id": owner_id, "label": label, "scope": skills }),
18137            )
18138            .await;
18139            Ok(serde_json::json!({ "token": issued.token, "label": label }))
18140        }
18141        Err(e) => Err(e.to_string()),
18142    }
18143}
18144
18145/// POST /cms-admin/me/mcp-keys — mint a key for the signed-in user.
18146/// Renders the account page directly with the show-once token (no PRG —
18147/// the token must never ride a redirect or a flash cookie).
18148pub async fn account_mcp_key_create(
18149    State(state): State<super::AdminState>,
18150    tenant: Tenant,
18151    headers: HeaderMap,
18152    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18153    Form(pairs): Form<Vec<(String, String)>>,
18154) -> Result<Response, AdminError> {
18155    let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18156        return Ok(unauthorized_no_session());
18157    };
18158    let (label, skills) = parse_mcp_key_form(&pairs);
18159    match mint_mcp_key(tenant.pool(), uid, uid, &label, &skills).await {
18160        Ok(one_time) => {
18161            render_account_page(
18162                &state,
18163                &tenant,
18164                &headers,
18165                session_user.as_ref(),
18166                Some(one_time),
18167            )
18168            .await
18169        }
18170        Err(msg) => redirect_named_with_message_args(
18171            "rcms-admin:account",
18172            MsgLevel::Error,
18173            "Couldn't create the key: {error}",
18174            &[("error", msg.as_str())],
18175            &headers,
18176        ),
18177    }
18178}
18179
18180/// POST /cms-admin/me/mcp-keys/{id}/revoke — revoke one of the signed-in
18181/// user's keys (ownership-verified in the framework call).
18182pub async fn account_mcp_key_revoke(
18183    State(_state): State<super::AdminState>,
18184    tenant: Tenant,
18185    headers: HeaderMap,
18186    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18187    Path(key_id): Path<i64>,
18188) -> Result<Response, AdminError> {
18189    let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18190        return Ok(unauthorized_no_session());
18191    };
18192    match rustango::tenancy::revoke_user_key_pool(tenant.pool(), uid, key_id).await {
18193        Ok(()) => {
18194            audit_mcp_key(
18195                tenant.pool(),
18196                uid,
18197                "revoked",
18198                serde_json::json!({ "key_id": key_id, "owner_id": uid }),
18199            )
18200            .await;
18201            redirect_named_with_message_args(
18202                "rcms-admin:account",
18203                MsgLevel::Success,
18204                "MCP key revoked.",
18205                &[],
18206                &headers,
18207            )
18208        }
18209        Err(e) => {
18210            let msg = e.to_string();
18211            redirect_named_with_message_args(
18212                "rcms-admin:account",
18213                MsgLevel::Error,
18214                "Couldn't revoke the key: {error}",
18215                &[("error", msg.as_str())],
18216                &headers,
18217            )
18218        }
18219    }
18220}
18221
18222/// POST /cms-admin/users/{id}/mcp-keys — an admin mints a key for another
18223/// user (the "register an agent user, give it a key" flow). Safe by
18224/// construction: the key's capabilities are bounded by the TARGET user's
18225/// entitlement at every token resolution, so this can't escalate beyond
18226/// what that user could already do.
18227pub async fn users_mcp_key_create(
18228    State(state): State<super::AdminState>,
18229    tenant: Tenant,
18230    headers: HeaderMap,
18231    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18232    Path(user_id): Path<i64>,
18233    Form(pairs): Form<Vec<(String, String)>>,
18234) -> Result<Response, AdminError> {
18235    // #646 — user-management is superuser-only. Without this the two
18236    // mcp-key handlers gated on "a session exists" only, so a non-superuser
18237    // staff account could mint a key bounded by ANY target user's (e.g. a
18238    // superuser's) entitlement — a privilege escalation the other seven
18239    // user-admin handlers already block. Mirror them.
18240    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18241        return Ok(redirect);
18242    }
18243    let Some(actor_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18244        return Ok(unauthorized_no_session());
18245    };
18246    let (label, skills) = parse_mcp_key_form(&pairs);
18247    match mint_mcp_key(tenant.pool(), actor_id, user_id, &label, &skills).await {
18248        Ok(one_time) => {
18249            render_user_edit_page(
18250                &state,
18251                &tenant,
18252                &headers,
18253                session_user.as_ref(),
18254                user_id,
18255                Some(one_time),
18256            )
18257            .await
18258        }
18259        Err(msg) => redirect_named_with_params_and_message_args(
18260            "rcms-admin:users:edit",
18261            &[("id", user_id.to_string())],
18262            MsgLevel::Error,
18263            "Couldn't create the key: {error}",
18264            &[("error", msg.as_str())],
18265            &headers,
18266        ),
18267    }
18268}
18269
18270/// POST /cms-admin/users/{id}/mcp-keys/{key_id}/revoke — admin revoke of
18271/// another user's key (ownership pinned to the target user).
18272pub async fn users_mcp_key_revoke(
18273    State(_state): State<super::AdminState>,
18274    tenant: Tenant,
18275    headers: HeaderMap,
18276    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18277    Path((user_id, key_id)): Path<(i64, i64)>,
18278) -> Result<Response, AdminError> {
18279    // #646 — user-management is superuser-only. Without this the two
18280    // mcp-key handlers gated on "a session exists" only, so a non-superuser
18281    // staff account could mint a key bounded by ANY target user's (e.g. a
18282    // superuser's) entitlement — a privilege escalation the other seven
18283    // user-admin handlers already block. Mirror them.
18284    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18285        return Ok(redirect);
18286    }
18287    let Some(actor_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18288        return Ok(unauthorized_no_session());
18289    };
18290    match rustango::tenancy::revoke_user_key_pool(tenant.pool(), user_id, key_id).await {
18291        Ok(()) => {
18292            audit_mcp_key(
18293                tenant.pool(),
18294                actor_id,
18295                "revoked",
18296                serde_json::json!({ "key_id": key_id, "owner_id": user_id }),
18297            )
18298            .await;
18299            redirect_named_with_params_and_message_args(
18300                "rcms-admin:users:edit",
18301                &[("id", user_id.to_string())],
18302                MsgLevel::Success,
18303                "MCP key revoked.",
18304                &[],
18305                &headers,
18306            )
18307        }
18308        Err(e) => {
18309            let msg = e.to_string();
18310            redirect_named_with_params_and_message_args(
18311                "rcms-admin:users:edit",
18312                &[("id", user_id.to_string())],
18313                MsgLevel::Error,
18314                "Couldn't revoke the key: {error}",
18315                &[("error", msg.as_str())],
18316                &headers,
18317            )
18318        }
18319    }
18320}
18321
18322/// Form payload for create + edit. Password is optional on edit
18323/// (empty = "don't change"); required on create (rejected with a
18324/// 400 if missing).
18325#[derive(Deserialize)]
18326pub struct UserForm {
18327    pub username: String,
18328    #[serde(default)]
18329    pub email: Option<String>,
18330    #[serde(default)]
18331    pub password: Option<String>,
18332    #[serde(default)]
18333    pub is_superuser: Option<String>,
18334    #[serde(default)]
18335    pub active: Option<String>,
18336}
18337
18338/// Light email validation (presence of a single `@` with text
18339/// on both sides). Empty is allowed (email is optional). Returns the
18340/// trimmed value to store, or an error message.
18341fn validate_optional_email(raw: Option<&str>) -> Result<String, String> {
18342    let e = raw.map(str::trim).unwrap_or("");
18343    if e.is_empty() {
18344        return Ok(String::new());
18345    }
18346    let ok = e.split('@').count() == 2
18347        && e.split('@').all(|p| !p.is_empty())
18348        && !e.contains(char::is_whitespace);
18349    if ok {
18350        Ok(e.to_owned())
18351    } else {
18352        Err(format!("“{e}” is not a valid email address."))
18353    }
18354}
18355
18356/// POST /cms-admin/users/new — create a new user. Password is
18357/// required; we hash via the framework's argon2id helper.
18358pub async fn users_create_submit(
18359    State(_state): State<super::AdminState>,
18360    tenant: Tenant,
18361    headers: HeaderMap,
18362    request: crate::security_log::LoginRequest,
18363    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18364    Form(pairs): Form<Vec<(String, String)>>,
18365) -> Result<Response, AdminError> {
18366    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18367        return Ok(redirect);
18368    }
18369    use rustango::sql::Auto;
18370    // Pairs, not the typed struct: the roles are a multi-value field
18371    // (see `users_edit_submit`), granted at creation too.
18372    let single = |k: &str| pairs.iter().find(|(n, _)| n == k).map(|(_, v)| v.clone());
18373    let form = UserForm {
18374        username: single("username").unwrap_or_default(),
18375        email: single("email"),
18376        password: single("password"),
18377        is_superuser: single("is_superuser"),
18378        active: single("active"),
18379    };
18380    let role_ids: Vec<i64> = pairs
18381        .iter()
18382        .filter(|(k, _)| k == "role_id")
18383        .filter_map(|(_, v)| v.parse::<i64>().ok())
18384        .collect();
18385    let username = form.username.trim().to_owned();
18386    let password = form
18387        .password
18388        .as_deref()
18389        .map(str::trim)
18390        .filter(|s| !s.is_empty())
18391        .map(str::to_owned);
18392    if username.is_empty() || password.is_none() {
18393        return Err(AdminError::Validation(
18394            "Username and initial password are both required.".to_owned(),
18395        ));
18396    }
18397    let hash = crate::passwords::hash(password.as_deref().unwrap_or_default()).await
18398        .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
18399    let email = validate_optional_email(form.email.as_deref()).map_err(AdminError::Validation)?;
18400    // The framework's first-class `email` column is the SSO link target (the
18401    // admin-sso login matches the IdP's verified email against it). Set it here;
18402    // NULL when no email was given (that account simply can't sign in via SSO).
18403    let email_col = (!email.is_empty()).then(|| email.clone());
18404
18405    // #435 — also mirror into the User.data bag (legacy readers: users list +
18406    // edit form still read `data.email`).
18407    let mut data = serde_json::Map::new();
18408    if !email.is_empty() {
18409        data.insert("email".to_owned(), serde_json::Value::String(email));
18410    }
18411    let mut row = rustango::tenancy::auth::User {
18412        id: Auto::Unset,
18413        username: username.clone(),
18414        password_hash: hash,
18415        email: email_col,
18416        is_superuser: form.is_superuser.is_some(),
18417        active: form.active.is_some(),
18418        created_at: chrono::Utc::now(),
18419        data: serde_json::Value::Object(data),
18420        password_changed_at: Some(chrono::Utc::now()),
18421        sessions_revoked_at: None,
18422    };
18423    row.insert_pool(tenant.pool()).await?;
18424    if let Some(new_id) = row.id.get().copied() {
18425        sync_user_roles(tenant.pool(), new_id, &role_ids).await?;
18426    }
18427    let access = user_access(tenant.pool(), &row).await?;
18428    record_access_change(
18429        &tenant,
18430        session_user.as_ref(),
18431        &request,
18432        Some(&row),
18433        crate::security_log::describe_new_user(&access),
18434    )
18435    .await;
18436    redirect_named_with_message_args(
18437        "rcms-admin:users",
18438        MsgLevel::Success,
18439        "User “{username}” created.",
18440        &[("username", username.as_str())],
18441        &headers,
18442    )
18443}
18444
18445/// POST /cms-admin/users/{id}/edit — update flags + optionally
18446/// rotate the password (empty password field = no rotation) +
18447/// sync role memberships. Body parsed as `Vec<(String, String)>`
18448/// instead of the typed struct because role_id is a multi-value
18449/// form field — checkbox groups in HTML submit one entry per
18450/// checked box, and serde_urlencoded folds duplicates onto the
18451/// last write.
18452pub async fn users_edit_submit(
18453    State(_state): State<super::AdminState>,
18454    tenant: Tenant,
18455    headers: HeaderMap,
18456    request: crate::security_log::LoginRequest,
18457    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18458    Path(id): Path<i64>,
18459    Form(form): Form<Vec<(String, String)>>,
18460) -> Result<Response, AdminError> {
18461    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18462        return Ok(redirect);
18463    }
18464    // Pull each field out of the multi-pair vec. `find` honors the
18465    // first occurrence — fine for single-value fields.
18466    let single = |key: &str| -> Option<String> {
18467        form.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
18468    };
18469    let username_raw = single("username").unwrap_or_default();
18470    let username = username_raw.trim().to_owned();
18471    if username.is_empty() {
18472        return Err(AdminError::Validation(
18473            "Username cannot be empty.".to_owned(),
18474        ));
18475    }
18476    let password = single("password");
18477    let is_superuser = form.iter().any(|(k, _)| k == "is_superuser");
18478    let active = form.iter().any(|(k, _)| k == "active");
18479    let timezone_raw = single("timezone").unwrap_or_default();
18480    let timezone = timezone_raw.trim().to_owned();
18481    // #435 — optional email, validated + stored in User.data.
18482    let email =
18483        validate_optional_email(single("email").as_deref()).map_err(AdminError::Validation)?;
18484    let role_ids: Vec<i64> = form
18485        .iter()
18486        .filter(|(k, _)| k == "role_id")
18487        .filter_map(|(_, v)| v.parse::<i64>().ok())
18488        .collect();
18489
18490    let mut user = rustango::tenancy::auth::User::objects()
18491        .where_(rustango::tenancy::auth::User::id.eq(id))
18492        .first(tenant.pool())
18493        .await?
18494        .ok_or(AdminError::NotFound(id))?;
18495    let before = user_access(tenant.pool(), &user).await?;
18496    user.username = username.clone();
18497    user.is_superuser = is_superuser;
18498    user.active = active;
18499    // #13 V2 — persist the chosen IANA timezone (or unset key
18500    // entirely when blank) on the User.data JSON bag.
18501    {
18502        let map = user.data.as_object_mut().ok_or_else(|| {
18503            AdminError::Validation(
18504                "User.data is not a JSON object — refusing to overwrite.".to_owned(),
18505            )
18506        })?;
18507        if timezone.is_empty() {
18508            map.remove("timezone");
18509        } else {
18510            map.insert(
18511                "timezone".to_owned(),
18512                serde_json::Value::String(timezone.clone()),
18513            );
18514        }
18515        if email.is_empty() {
18516            map.remove("email");
18517        } else {
18518            map.insert("email".to_owned(), serde_json::Value::String(email.clone()));
18519        }
18520    }
18521    // Keep the first-class `email` column (the admin-sso link target) in sync
18522    // with the edited address — NULL clears the SSO link for this user.
18523    user.email = (!email.is_empty()).then(|| email.clone());
18524
18525    let rotated = password.as_deref().map(str::trim).filter(|s| !s.is_empty());
18526    if let Some(new_pw) = rotated {
18527        let hash = crate::passwords::hash(new_pw).await
18528            .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
18529        user.password_hash = hash;
18530        user.password_changed_at = Some(chrono::Utc::now());
18531    }
18532    user.save_pool(tenant.pool()).await?;
18533    sync_user_roles(tenant.pool(), id, &role_ids).await?;
18534    let after = user_access(tenant.pool(), &user).await?;
18535    if let Some(detail) = crate::security_log::describe_user_change(&before, &after) {
18536        record_access_change(&tenant, session_user.as_ref(), &request, Some(&user), detail).await;
18537    }
18538    if rotated.is_some() {
18539        redirect_named_with_message_args(
18540            "rcms-admin:users",
18541            MsgLevel::Success,
18542            "User “{username}” saved (password rotated).",
18543            &[("username", username.as_str())],
18544            &headers,
18545        )
18546    } else {
18547        redirect_named_with_message_args(
18548            "rcms-admin:users",
18549            MsgLevel::Success,
18550            "User “{username}” saved.",
18551            &[("username", username.as_str())],
18552            &headers,
18553        )
18554    }
18555}
18556
18557/// Shared helper — replace a user's role-membership set with the
18558/// supplied list. Idempotent; computes adds + drops via set diff.
18559async fn sync_user_roles(
18560    pool: &rustango::sql::Pool,
18561    user_id: i64,
18562    new_role_ids: &[i64],
18563) -> Result<(), AdminError> {
18564    let existing: Vec<rustango::tenancy::permissions::UserRole> =
18565        rustango::tenancy::permissions::UserRole::objects()
18566            .where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
18567            .fetch(pool)
18568            .await?;
18569    let want: std::collections::BTreeSet<i64> = new_role_ids.iter().copied().collect();
18570    let have: std::collections::BTreeSet<i64> = existing.iter().map(|m| m.role_id).collect();
18571    for m in &existing {
18572        if !want.contains(&m.role_id) {
18573            m.clone().delete_pool(pool).await?;
18574        }
18575    }
18576    for role_id in new_role_ids {
18577        if !have.contains(role_id) {
18578            let mut row = rustango::tenancy::permissions::UserRole {
18579                id: rustango::sql::Auto::Unset,
18580                user_id,
18581                role_id: *role_id,
18582            };
18583            row.insert_pool(pool).await?;
18584        }
18585    }
18586    Ok(())
18587}
18588
18589/// `user`'s flags and role names, as the security log compares them.
18590async fn user_access(
18591    pool: &rustango::sql::Pool,
18592    user: &rustango::tenancy::auth::User,
18593) -> Result<crate::security_log::Access, AdminError> {
18594    use rustango::tenancy::permissions::{Role, UserRole};
18595    let role_ids: Vec<i64> = match user.id.get().copied() {
18596        Some(uid) => UserRole::objects()
18597            .where_(UserRole::user_id.eq(uid))
18598            .fetch(pool)
18599            .await?
18600            .into_iter()
18601            .map(|m| m.role_id)
18602            .collect(),
18603        None => Vec::new(),
18604    };
18605    let roles = if role_ids.is_empty() {
18606        Vec::new()
18607    } else {
18608        Role::objects()
18609            .where_(Role::id.is_in(role_ids))
18610            .fetch(pool)
18611            .await?
18612            .into_iter()
18613            .map(|r| r.name)
18614            .collect()
18615    };
18616    Ok(crate::security_log::Access {
18617        superuser: user.is_superuser,
18618        active: user.active,
18619        roles,
18620    })
18621}
18622
18623/// Log a change to who may do what, made by `actor` to `target` (a
18624/// user, or `None` for a role).
18625async fn record_access_change(
18626    tenant: &Tenant,
18627    actor: Option<&rustango::tenancy::auth::User>,
18628    request: &crate::security_log::LoginRequest,
18629    target: Option<&rustango::tenancy::auth::User>,
18630    detail: String,
18631) {
18632    let mut entry = SecurityEntry::new(
18633        crate::security_log::EVENT_PERMISSIONS_CHANGED,
18634        "admin",
18635        &request.meta,
18636    )
18637    .change(actor.map_or("", |u| u.username.as_str()), detail);
18638    if let Some(user) = target {
18639        entry = entry.user(user.id.get().copied(), &user.username);
18640    }
18641    crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
18642}
18643
18644/// POST /cms-admin/users/{id}/deactivate — flip the `active` bit
18645/// off. Idempotent. Reversed via the edit form's checkbox.
18646pub async fn users_deactivate_submit(
18647    State(_state): State<super::AdminState>,
18648    tenant: Tenant,
18649    headers: HeaderMap,
18650    request: crate::security_log::LoginRequest,
18651    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18652    Path(id): Path<i64>,
18653) -> Result<Response, AdminError> {
18654    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18655        return Ok(redirect);
18656    }
18657    let mut user = rustango::tenancy::auth::User::objects()
18658        .where_(rustango::tenancy::auth::User::id.eq(id))
18659        .first(tenant.pool())
18660        .await?
18661        .ok_or(AdminError::NotFound(id))?;
18662    let was_active = user.active;
18663    user.active = false;
18664    user.save_pool(tenant.pool()).await?;
18665    if was_active {
18666        record_access_change(
18667            &tenant,
18668            session_user.as_ref(),
18669            &request,
18670            Some(&user),
18671            "active: on → off".to_owned(),
18672        )
18673        .await;
18674    }
18675    redirect_named_with_message_args(
18676        "rcms-admin:users",
18677        MsgLevel::Success,
18678        "User “{username}” deactivated.",
18679        &[("username", user.username.as_str())],
18680        &headers,
18681    )
18682}
18683
18684/// POST /cms-admin/users/bulk — enable or disable the selected users
18685/// (bulk actions). `user_id` repeats once per checked row;
18686/// `action` is the clicked button (`enable` | `disable`). Disabling
18687/// your own account is skipped so an admin can't lock themselves out.
18688pub async fn users_bulk_submit(
18689    State(_state): State<super::AdminState>,
18690    tenant: Tenant,
18691    headers: HeaderMap,
18692    request: crate::security_log::LoginRequest,
18693    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18694    Form(pairs): Form<Vec<(String, String)>>,
18695) -> Result<Response, AdminError> {
18696    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18697        return Ok(redirect);
18698    }
18699    let mut ids: Vec<i64> = Vec::new();
18700    let mut action = String::new();
18701    for (k, v) in &pairs {
18702        match k.as_str() {
18703            "user_id" => {
18704                if let Ok(id) = v.parse::<i64>() {
18705                    ids.push(id);
18706                }
18707            }
18708            "action" => action = v.clone(),
18709            _ => {}
18710        }
18711    }
18712    let target_active = match action.as_str() {
18713        "enable" => true,
18714        "disable" => false,
18715        _ => {
18716            return redirect_named_with_message(
18717                "rcms-admin:users",
18718                MsgLevel::Error,
18719                "Unknown bulk action.",
18720                &headers,
18721            );
18722        }
18723    };
18724    if ids.is_empty() {
18725        return redirect_named_with_message(
18726            "rcms-admin:users",
18727            MsgLevel::Info,
18728            "No users selected.",
18729            &headers,
18730        );
18731    }
18732    let me = session_user.as_ref().and_then(|u| u.id.get().copied());
18733    let mut changed = 0usize;
18734    let mut skipped_self = false;
18735    for id in ids {
18736        // Never disable the acting admin — that's a self-lockout.
18737        if !target_active && Some(id) == me {
18738            skipped_self = true;
18739            continue;
18740        }
18741        if let Some(mut user) = rustango::tenancy::auth::User::objects()
18742            .where_(rustango::tenancy::auth::User::id.eq(id))
18743            .first(tenant.pool())
18744            .await?
18745        {
18746            if user.active != target_active {
18747                user.active = target_active;
18748                user.save_pool(tenant.pool()).await?;
18749                changed += 1;
18750                let detail = if target_active { "active: off → on" } else { "active: on → off" };
18751                record_access_change(
18752                    &tenant,
18753                    session_user.as_ref(),
18754                    &request,
18755                    Some(&user),
18756                    detail.to_owned(),
18757                )
18758                .await;
18759            }
18760        }
18761    }
18762    let verb = if target_active { "Enabled" } else { "Disabled" };
18763    let mut msg = format!("{verb} {changed} user(s).");
18764    if skipped_self {
18765        msg.push_str(" (Skipped your own account.)");
18766    }
18767    redirect_named_with_message("rcms-admin:users", MsgLevel::Success, &msg, &headers)
18768}
18769
18770// =====================================================================
18771// Settings tab
18772// =====================================================================
18773
18774pub async fn settings_page(
18775    State(state): State<super::AdminState>,
18776    tenant: Tenant,
18777    headers: HeaderMap,
18778    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18779) -> Result<Response, AdminError> {
18780    let locales: Vec<Locale> = Locale::objects()
18781        .order_by(&[("sort_order", false), ("code", false)])
18782        .fetch(tenant.pool())
18783        .await?;
18784    let media_count: Vec<Media> = Media::objects().fetch(tenant.pool()).await?;
18785    // #58 — themes available to the picker. We surface every row in
18786    // `cms_theme` plus its 4 marquee colors for a swatch preview.
18787    let themes: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
18788        .order_by(&[("name", false)])
18789        .fetch(tenant.pool())
18790        .await?;
18791    let theme_rows: Vec<serde_json::Value> = themes
18792        .iter()
18793        .map(|t| {
18794            serde_json::json!({
18795                "id": t.id.get().copied(),
18796                "name": t.name,
18797                "slug": t.slug,
18798                "is_admin_default": t.is_admin_default,
18799                "is_default": t.is_default,
18800                "color_bg": t.color_bg,
18801                "color_surface": t.color_surface,
18802                "color_text_primary": t.color_text_primary,
18803                "color_link": t.color_link,
18804            })
18805        })
18806        .collect();
18807    let mut ctx = Context::new();
18808    add_chrome(&mut ctx, &tenant, "settings", session_user.as_ref()).await;
18809    add_admin_theme(&mut ctx, tenant.pool()).await;
18810    ctx.insert("locales", &locales);
18811    ctx.insert("media_count", &media_count.len());
18812    ctx.insert("org_slug", &tenant.org.slug);
18813    ctx.insert("org_display_name", &tenant.org.display_name);
18814    ctx.insert("themes", &theme_rows);
18815
18816    // #199 — surface the current branding asset filenames + URLs
18817    // so the Branding form can render "Current logo: <filename>"
18818    // hints next to the upload inputs.
18819    if let Ok(Some(row)) = crate::site_setting::get(tenant.pool(), "branding").await {
18820        let logo_key = row
18821            .value_json
18822            .get("logo_storage_key")
18823            .and_then(|v| v.as_str())
18824            .unwrap_or("")
18825            .to_owned();
18826        let favicon_key = row
18827            .value_json
18828            .get("favicon_storage_key")
18829            .and_then(|v| v.as_str())
18830            .unwrap_or("")
18831            .to_owned();
18832        ctx.insert("branding_logo_filename", &logo_key);
18833        ctx.insert("branding_favicon_filename", &favicon_key);
18834        ctx.insert(
18835            "branding_site_name",
18836            row.value_json.get("site_name").and_then(|v| v.as_str()).unwrap_or(""),
18837        );
18838    }
18839
18840    render_with_csrf(&state, &headers, "rcms_admin/settings.html", &mut ctx)
18841}
18842
18843/// POST /cms-admin/settings/branding — multipart upload of logo
18844/// and/or favicon. Files land in
18845/// storage key `<tenant>/branding/<name>` and the storage keys are
18846/// recorded in `cms_site_setting` under scope `branding`.
18847pub async fn settings_branding_submit(
18848    State(_state): State<super::AdminState>,
18849    tenant: Tenant,
18850    headers: HeaderMap,
18851    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
18852    mut multipart: axum::extract::Multipart,
18853) -> Result<Response, AdminError> {
18854    let mut logo_filename: Option<String> = None;
18855    let mut favicon_filename: Option<String> = None;
18856    let mut site_name: Option<String> = None;
18857
18858    while let Some(field) = multipart
18859        .next_field()
18860        .await
18861        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
18862    {
18863        let field_name = field.name().unwrap_or("").to_owned();
18864        let original = field.file_name().map(|s| s.to_owned());
18865        let bytes = field
18866            .bytes()
18867            .await
18868            .map_err(|e| AdminError::Upload(format!("read field {field_name}: {e}")))?;
18869        // A text field; empty clears it (back to the tenant's name).
18870        if field_name == "site_name" {
18871            site_name = Some(String::from_utf8_lossy(&bytes).trim().chars().take(120).collect());
18872            continue;
18873        }
18874        if bytes.is_empty() {
18875            continue;
18876        }
18877        let (slot, default_ext) = match field_name.as_str() {
18878            "logo" => (&mut logo_filename, "png"),
18879            "favicon" => (&mut favicon_filename, "ico"),
18880            _ => continue,
18881        };
18882        let safe_ext = original
18883            .as_deref()
18884            .and_then(|n| n.rsplit_once('.'))
18885            .map(|(_, ext)| ext)
18886            .filter(|ext| ext.len() <= 8 && ext.chars().all(|c| c.is_ascii_alphanumeric()))
18887            .map(str::to_ascii_lowercase)
18888            .unwrap_or_else(|| default_ext.to_owned());
18889        let storage_name = format!("{field_name}.{safe_ext}");
18890        crate::media_storage::disk_for(&tenant.org.slug)
18891            .save(
18892                &crate::media_storage::key(&tenant.org.slug, &format!("branding/{storage_name}")),
18893                &bytes,
18894            )
18895            .await
18896            .map_err(|e| AdminError::Upload(format!("write {field_name}: {e}")))?;
18897        *slot = Some(storage_name);
18898    }
18899
18900    // Merge into the existing row so an upload of just the favicon
18901    // doesn't clobber a previously-uploaded logo.
18902    let existing = crate::site_setting::get(tenant.pool(), "branding")
18903        .await
18904        .unwrap_or_default()
18905        .map(|r| r.value_json)
18906        .unwrap_or_else(|| serde_json::json!({}));
18907    let mut value = existing.as_object().cloned().unwrap_or_default();
18908    if let Some(name) = logo_filename {
18909        value.insert("logo_storage_key".to_owned(), serde_json::json!(name));
18910    }
18911    if let Some(name) = favicon_filename {
18912        value.insert("favicon_storage_key".to_owned(), serde_json::json!(name));
18913    }
18914    match site_name {
18915        Some(n) if n.is_empty() => {
18916            value.remove("site_name");
18917        }
18918        Some(n) => {
18919            value.insert("site_name".to_owned(), serde_json::json!(n));
18920        }
18921        None => {}
18922    }
18923    let _ =
18924        crate::site_setting::upsert(tenant.pool(), "branding", serde_json::Value::Object(value))
18925            .await?;
18926
18927    redirect_named_with_message(
18928        "rcms-admin:settings",
18929        MsgLevel::Success,
18930        "Branding saved. Reload to see the new logo / favicon.",
18931        &headers,
18932    )
18933}
18934
18935/// GET /__cms-branding/logo — streams the per-tenant logo bytes.
18936/// Anonymous-OK: this is admin chrome but the favicon especially
18937/// needs to be reachable before login.
18938pub async fn settings_branding_serve_logo(headers: HeaderMap, tenant: Tenant) -> Response {
18939    serve_branding_asset(&headers, &tenant, "logo_storage_key").await
18940}
18941
18942/// GET /__cms-branding/favicon — streams the per-tenant favicon.
18943pub async fn settings_branding_serve_favicon(headers: HeaderMap, tenant: Tenant) -> Response {
18944    serve_branding_asset(&headers, &tenant, "favicon_storage_key").await
18945}
18946
18947async fn serve_branding_asset(headers: &HeaderMap, tenant: &Tenant, slot: &str) -> Response {
18948    let setting = match crate::site_setting::get(tenant.pool(), "branding").await {
18949        Ok(Some(s)) => s,
18950        _ => {
18951            return (axum::http::StatusCode::NOT_FOUND, "no branding set").into_response();
18952        }
18953    };
18954    let storage_name = match setting.value_json.get(slot).and_then(|v| v.as_str()) {
18955        Some(s) if !s.is_empty() => s.to_owned(),
18956        _ => {
18957            return (axum::http::StatusCode::NOT_FOUND, "asset not set").into_response();
18958        }
18959    };
18960    // Reject path traversal — storage_name comes from a setting we
18961    // wrote ourselves, but never trust round-tripped JSON.
18962    if storage_name.contains('/') || storage_name.contains("..") {
18963        return (axum::http::StatusCode::BAD_REQUEST, "invalid storage name").into_response();
18964    }
18965    let bytes = match crate::media_storage::disk_for(&tenant.org.slug)
18966        .load(&crate::media_storage::key(
18967            &tenant.org.slug,
18968            &format!("branding/{storage_name}"),
18969        ))
18970        .await
18971    {
18972        Ok(b) => b,
18973        Err(_) => {
18974            return (axum::http::StatusCode::NOT_FOUND, "branding bytes missing").into_response();
18975        }
18976    };
18977    let mime = mime_guess::from_path(&storage_name)
18978        .first_or_octet_stream()
18979        .essence_str()
18980        .to_owned();
18981    // #199 fix — the URL is stable (`/__cms-branding/logo|favicon`) and
18982    // the storage key can stay the same across a re-upload, so the old
18983    // `public, max-age=3600` (no validator) left browsers showing the
18984    // OLD logo/favicon for up to an hour after a change (the reported
18985    // "upload didn't work"). Revalidate via a content ETag instead.
18986    revalidated_asset(headers, mime, bytes)
18987}
18988
18989/// Response for a small, mutable asset served from a STABLE URL
18990/// (branding logo/favicon, user avatar): a content-hash ETag plus
18991/// `Cache-Control: no-cache` (cache, but always revalidate) so a
18992/// re-upload is picked up immediately — no stale-for-an-hour window —
18993/// while unchanged bytes still `304` cheaply (`If-None-Match` honored).
18994fn revalidated_asset(headers: &HeaderMap, mime: String, bytes: Vec<u8>) -> Response {
18995    use sha2::{Digest, Sha256};
18996    let digest = Sha256::digest(&bytes);
18997    let mut etag = String::with_capacity(34);
18998    etag.push('"');
18999    for b in digest.iter().take(16) {
19000        use std::fmt::Write as _;
19001        let _ = write!(etag, "{b:02x}");
19002    }
19003    etag.push('"');
19004    let matches_etag = headers
19005        .get(axum::http::header::IF_NONE_MATCH)
19006        .and_then(|v| v.to_str().ok())
19007        .is_some_and(|inm| inm.split(',').any(|t| t.trim() == etag));
19008    if matches_etag {
19009        return (
19010            axum::http::StatusCode::NOT_MODIFIED,
19011            [
19012                (axum::http::header::ETAG, etag),
19013                (axum::http::header::CACHE_CONTROL, "no-cache".to_owned()),
19014            ],
19015        )
19016            .into_response();
19017    }
19018    (
19019        [
19020            (axum::http::header::CONTENT_TYPE, mime),
19021            (axum::http::header::CACHE_CONTROL, "no-cache".to_owned()),
19022            (axum::http::header::ETAG, etag),
19023        ],
19024        bytes,
19025    )
19026        .into_response()
19027}
19028
19029/// POST /cms-admin/settings/theme — flip either `is_admin_default`
19030/// or `is_default` to a new theme. Form fields:
19031///
19032/// - `surface`: either `admin` or `public` — picks which flag to toggle.
19033/// - `theme_id`: the row to set the flag on.
19034///
19035/// The flag is exclusive per surface (one row at a time carries it),
19036/// so we explicitly clear it from every other row in the same pass.
19037#[derive(Debug, Deserialize)]
19038pub struct ThemeSwitchForm {
19039    pub surface: String,
19040    pub theme_id: i64,
19041}
19042
19043pub async fn settings_theme_switch(
19044    State(_state): State<super::AdminState>,
19045    tenant: Tenant,
19046    headers: HeaderMap,
19047    Form(form): Form<ThemeSwitchForm>,
19048) -> Result<Response, AdminError> {
19049    // #174 — only `surface=admin` is reachable through the UI now.
19050    // The `public` value is still accepted at the API level so host
19051    // crates that drive public-page theming externally keep working,
19052    // but no editor surface posts it anymore.
19053    if form.surface != "admin" && form.surface != "public" {
19054        return Err(AdminError::Validation(format!(
19055            "Unknown surface `{}` — expected `admin` or `public`.",
19056            form.surface
19057        )));
19058    }
19059    let target = crate::theme::Theme::objects()
19060        .where_(crate::theme::Theme::id.eq(form.theme_id))
19061        .first(tenant.pool())
19062        .await?
19063        .ok_or(AdminError::NotFound(form.theme_id))?;
19064
19065    // Clear the exclusive flag everywhere else, then set it on the
19066    // picked row. Sequential ORM writes — atomicity isn't critical
19067    // here (worst case a transient request sees zero rows flagged
19068    // and falls through to the static default).
19069    let all_themes: Vec<crate::theme::Theme> =
19070        crate::theme::Theme::objects().fetch(tenant.pool()).await?;
19071    for mut t in all_themes {
19072        let target_id = target.id.get().copied().unwrap_or_default();
19073        let this_id = t.id.get().copied().unwrap_or_default();
19074        if form.surface == "admin" {
19075            t.is_admin_default = this_id == target_id;
19076        } else {
19077            t.is_default = this_id == target_id;
19078        }
19079        t.save_pool(tenant.pool()).await?;
19080    }
19081    // #274 — when the picker submits via fetch() (XHR), return JSON with
19082    // the freshly-rendered CSS + identifying bits so the client can swap
19083    // the `<style data-rcms-theme>` block in place. Detection: either an
19084    // explicit `Accept: application/json` (preferred — modern), or the
19085    // legacy `X-Requested-With: XMLHttpRequest` (kept so older host
19086    // crates that wrap the picker can still light it up). Plain form
19087    // submissions keep the redirect-with-flash behavior so the picker
19088    // degrades gracefully with JS off.
19089    if wants_json_response(&headers) && form.surface == "admin" {
19090        let target_id = target.id.get().copied().unwrap_or_default();
19091        let brand_colors: Vec<crate::theme::BrandColor> = crate::theme::BrandColor::objects()
19092            .where_(crate::theme::BrandColor::theme_id.eq(target_id))
19093            .order_by(&[("sort_order", false)])
19094            .fetch(tenant.pool())
19095            .await
19096            .unwrap_or_default();
19097        let css = crate::theme::emit_css(&target, &brand_colors);
19098        return Ok(Json(serde_json::json!({
19099            "ok": true,
19100            "id": target_id,
19101            "slug": target.slug,
19102            "name": target.name,
19103            "default_mode": target.default_mode,
19104            "css": css,
19105            "message": format!("Admin theme switched to “{}”.", target.name),
19106        }))
19107        .into_response());
19108    }
19109    // #174 — admin picker redirects back to Preferences (its new
19110    // home); the legacy `public` surface still redirects to Settings
19111    // so host integrations that POST manually keep their UX.
19112    let redirect_target = if form.surface == "admin" {
19113        "rcms-admin:account"
19114    } else {
19115        "rcms-admin:settings"
19116    };
19117    let theme_flash = if form.surface == "admin" {
19118        "Admin theme switched to “{name}”."
19119    } else {
19120        "Public theme switched to “{name}”."
19121    };
19122    redirect_named_with_message_args(
19123        redirect_target,
19124        MsgLevel::Success,
19125        theme_flash,
19126        &[("name", target.name.as_str())],
19127        &headers,
19128    )
19129}
19130
19131/// True when the request prefers a JSON response — either set
19132/// `Accept: application/json` (modern fetch with `Accept` header) or
19133/// the legacy `X-Requested-With: XMLHttpRequest` marker. Used by the
19134/// theme picker so it can opt into a live-swap JSON payload
19135/// without losing the no-JS redirect fallback.
19136fn wants_json_response(headers: &HeaderMap) -> bool {
19137    let accept = headers
19138        .get(header::ACCEPT)
19139        .and_then(|v| v.to_str().ok())
19140        .unwrap_or("");
19141    if accept.contains("application/json") {
19142        return true;
19143    }
19144    headers
19145        .get("x-requested-with")
19146        .and_then(|v| v.to_str().ok())
19147        .is_some_and(|v| v.eq_ignore_ascii_case("XMLHttpRequest"))
19148}
19149
19150// =====================================================================
19151// Redirects tab — editor-managed 301/302 maps. Backed by
19152// crate::redirect::Redirect; the public router consults this table
19153// when a slug lookup returns None (see crate::router).
19154// =====================================================================
19155
19156#[derive(Debug, Deserialize)]
19157pub struct RedirectForm {
19158    pub from_path: String,
19159    pub to_path: String,
19160    /// Checkbox — present when ticked, absent when not. `Some(_)` →
19161    /// 301 Moved Permanently. Default checked in the form template.
19162    #[serde(default)]
19163    pub is_permanent: Option<String>,
19164    #[serde(default)]
19165    pub note: Option<String>,
19166    /// Checkbox: serve even when a published page exists at
19167    /// `from_path`.
19168    #[serde(default)]
19169    pub overrides_live: Option<String>,
19170    /// Chooser hidden inputs; empty string when cleared.
19171    #[serde(default)]
19172    pub from_page_id: Option<String>,
19173    #[serde(default)]
19174    pub to_page_id: Option<String>,
19175}
19176
19177impl RedirectForm {
19178    fn parsed_permanent(&self) -> bool {
19179        self.is_permanent.is_some()
19180    }
19181    fn parsed_overrides_live(&self) -> bool {
19182        self.overrides_live.is_some()
19183    }
19184    fn parsed_page_id(raw: &Option<String>) -> Option<i64> {
19185        raw.as_deref()
19186            .and_then(|s| s.trim().parse::<i64>().ok())
19187            .filter(|id| *id > 0)
19188    }
19189    fn parsed_from_page_id(&self) -> Option<i64> {
19190        Self::parsed_page_id(&self.from_page_id)
19191    }
19192    fn parsed_to_page_id(&self) -> Option<i64> {
19193        Self::parsed_page_id(&self.to_page_id)
19194    }
19195}
19196
19197/// Resolve the effective from/to paths for a redirect form:
19198/// a picked source page snapshots its CURRENT `url_path` into
19199/// `from_path`; a picked destination page snapshots into `to_path`
19200/// (display/fallback — the serve path re-resolves it live). Returns
19201/// `(from_path, to_path)`; typed values pass through when no page is
19202/// picked.
19203async fn redirect_form_paths(
19204    pool: &rustango::sql::Pool,
19205    form: &RedirectForm,
19206) -> Result<(String, String), AdminError> {
19207    let mut from = form.from_path.trim().to_owned();
19208    let mut to = form.to_path.trim().to_owned();
19209    if let Some(pid) = form.parsed_from_page_id() {
19210        if let Some(p) = Page::objects().where_(Page::id.eq(pid)).first(pool).await? {
19211            from = p.url_path;
19212        }
19213    }
19214    if let Some(pid) = form.parsed_to_page_id() {
19215        if let Some(p) = Page::objects().where_(Page::id.eq(pid)).first(pool).await? {
19216            to = p.url_path;
19217        }
19218    }
19219    Ok((from, to))
19220}
19221
19222/// Save-time shadow check: a non-override rule whose
19223/// `from_path` matches a PUBLISHED page will never serve (live pages
19224/// win). Returns `true` when shadowed so the submit handlers can
19225/// flash a warning instead of a plain success.
19226async fn redirect_is_shadowed(tenant: &Tenant, from_path: &str, overrides_live: bool) -> bool {
19227    if overrides_live || crate::redirect::is_wildcard(from_path) {
19228        // Wildcards are meant to span subtrees (which may include live
19229        // pages); "shadow" only applies to exact non-override rules.
19230        return false;
19231    }
19232    matches!(
19233        crate::resolver::resolve_path(tenant, from_path).await,
19234        Ok(Some(_))
19235    )
19236}
19237
19238/// Reject a `from_path` with more than one `*`; a single glob
19239/// (typically `path/*` or `*/path`) is the supported shape. Also reject a
19240/// rule whose destination matches its own from-path.
19241fn redirect_pattern_error(from_path: &str, to_path: &str) -> Option<&'static str> {
19242    if from_path.matches('*').count() > 1 {
19243        Some("The from-path may contain at most one “*” wildcard (e.g. /old/* or */feed).")
19244    } else if crate::redirect::redirect_loops(from_path, to_path) {
19245        Some("That redirect points back at its own from-path, so visitors would loop.")
19246    } else {
19247        None
19248    }
19249}
19250
19251/// Query for the redirect list: free-text search, status filter chip,
19252/// sortable column + direction, and page number.
19253#[derive(Debug, Deserialize, Default)]
19254pub struct RedirectListQuery {
19255    #[serde(default)]
19256    pub q: Option<String>,
19257    /// `all` | `active` | `disabled` | `stale`.
19258    #[serde(default)]
19259    pub filter: Option<String>,
19260    /// `from` | `last_used` | `created` | `hits` | `staleness`.
19261    #[serde(default)]
19262    pub sort: Option<String>,
19263    /// `asc` | `desc`.
19264    #[serde(default)]
19265    pub dir: Option<String>,
19266    #[serde(default)]
19267    pub page: Option<i64>,
19268}
19269
19270const REDIRECTS_PER_PAGE: usize = 50;
19271
19272pub async fn redirect_list(
19273    State(state): State<super::AdminState>,
19274    tenant: Tenant,
19275    headers: HeaderMap,
19276    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19277    Query(q): Query<RedirectListQuery>,
19278) -> Result<Response, AdminError> {
19279    // The redirect table is small (editor-managed), so search / sort /
19280    // paginate happen in-memory over one fetch — same result as
19281    // SQL LIMIT/OFFSET without threading dialect-specific ordering.
19282    let mut all: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
19283        .fetch(tenant.pool())
19284        .await?;
19285    let now = chrono::Utc::now();
19286
19287    let needle = q.q.as_deref().unwrap_or("").trim().to_lowercase();
19288    if !needle.is_empty() {
19289        all.retain(|r| {
19290            r.from_path.to_lowercase().contains(&needle)
19291                || r.to_path.to_lowercase().contains(&needle)
19292                || r.note.to_lowercase().contains(&needle)
19293        });
19294    }
19295
19296    // Chip counts reflect the search-filtered set (before the status filter).
19297    let count_all = all.len();
19298    let count_active = all.iter().filter(|r| r.is_active).count();
19299    let count_disabled = all.iter().filter(|r| !r.is_active).count();
19300    let count_stale = all
19301        .iter()
19302        .filter(|r| matches!(crate::redirect::staleness(r, now), "stale" | "unused"))
19303        .count();
19304
19305    let filter = q.filter.as_deref().unwrap_or("all");
19306    all.retain(|r| match filter {
19307        "active" => r.is_active,
19308        "disabled" => !r.is_active,
19309        "stale" => matches!(crate::redirect::staleness(r, now), "stale" | "unused"),
19310        _ => true,
19311    });
19312
19313    let sort = q.sort.as_deref().unwrap_or("from");
19314    let desc = q.dir.as_deref() == Some("desc");
19315    all.sort_by(|a, b| {
19316        let o = match sort {
19317            "last_used" => a.last_hit_at.cmp(&b.last_hit_at),
19318            "created" => a.created_at.get().cmp(&b.created_at.get()),
19319            "hits" => a.hit_count.cmp(&b.hit_count),
19320            "staleness" => {
19321                let rank = |r: &crate::redirect::Redirect| match crate::redirect::staleness(r, now)
19322                {
19323                    "disabled" => 0u8,
19324                    "unused" => 1,
19325                    "stale" => 2,
19326                    _ => 3,
19327                };
19328                rank(a).cmp(&rank(b))
19329            }
19330            _ => a.from_path.cmp(&b.from_path),
19331        };
19332        if desc {
19333            o.reverse()
19334        } else {
19335            o
19336        }
19337    });
19338
19339    let total = all.len();
19340    let total_pages = total.div_ceil(REDIRECTS_PER_PAGE).max(1);
19341    let page = q.page.unwrap_or(1).clamp(1, total_pages as i64) as usize;
19342    let start = (page - 1) * REDIRECTS_PER_PAGE;
19343    let items: Vec<crate::redirect::Redirect> = all
19344        .into_iter()
19345        .skip(start)
19346        .take(REDIRECTS_PER_PAGE)
19347        .collect();
19348
19349    let mut ctx = Context::new();
19350    add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19351    add_admin_theme(&mut ctx, tenant.pool()).await;
19352    ctx.insert("items", &items);
19353    ctx.insert("q", &needle);
19354    ctx.insert("filter", filter);
19355    ctx.insert("sort", sort);
19356    ctx.insert("dir", if desc { "desc" } else { "asc" });
19357    ctx.insert("current_page", &page);
19358    ctx.insert("total_pages", &total_pages);
19359    ctx.insert("total", &total);
19360    ctx.insert("count_all", &count_all);
19361    ctx.insert("count_active", &count_active);
19362    ctx.insert("count_disabled", &count_disabled);
19363    ctx.insert("count_stale", &count_stale);
19364    render_with_csrf(&state, &headers, "rcms_admin/redirect_list.html", &mut ctx)
19365}
19366
19367pub async fn redirect_new_form(
19368    State(state): State<super::AdminState>,
19369    tenant: Tenant,
19370    headers: HeaderMap,
19371    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19372) -> Result<Response, AdminError> {
19373    let mut ctx = Context::new();
19374    add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19375    add_admin_theme(&mut ctx, tenant.pool()).await;
19376    ctx.insert("mode", "new");
19377    ctx.insert(
19378        "redirect",
19379        &serde_json::json!({
19380            "from_path": "",
19381            "to_path": "",
19382            "is_permanent": true,
19383            "note": "",
19384            "hit_count": 0,
19385            "overrides_live": false,
19386            "from_page_id": null,
19387            "to_page_id": null,
19388        }),
19389    );
19390    render_with_csrf(&state, &headers, "rcms_admin/redirect_form.html", &mut ctx)
19391}
19392
19393pub async fn redirect_new_submit(
19394    State(_state): State<super::AdminState>,
19395    tenant: Tenant,
19396    headers: HeaderMap,
19397    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19398    Form(form): Form<RedirectForm>,
19399) -> Result<Response, AdminError> {
19400    use rustango::sql::Auto;
19401    let (from, to) = redirect_form_paths(tenant.pool(), &form).await?;
19402    if from.is_empty() || to.is_empty() {
19403        return redirect_named_with_message(
19404            "rcms-admin:redirects:list",
19405            MsgLevel::Error,
19406            "From-path and to-path are both required.",
19407            &headers,
19408        );
19409    }
19410    if let Some(msg) = redirect_pattern_error(&from, &to) {
19411        return redirect_named_with_message(
19412            "rcms-admin:redirects:list",
19413            MsgLevel::Error,
19414            msg,
19415            &headers,
19416        );
19417    }
19418    let overrides_live = form.parsed_overrides_live();
19419    let is_permanent = form.parsed_permanent();
19420    let from_page_id = form.parsed_from_page_id();
19421    let to_page_id = form.parsed_to_page_id();
19422    let mut row = crate::redirect::Redirect {
19423        id: Auto::Unset,
19424        from_path: from,
19425        to_path: to,
19426        is_permanent,
19427        note: form.note.unwrap_or_default().trim().to_owned(),
19428        hit_count: 0,
19429        overrides_live,
19430        from_page_id,
19431        to_page_id,
19432        is_active: true,
19433        disabled_reason: String::new(),
19434        last_hit_at: None,
19435        created_at: Auto::Unset,
19436        updated_at: Auto::Unset,
19437    };
19438    row.insert_pool(tenant.pool()).await?;
19439    redirect_save_response(&tenant, &row, overrides_live, true, &headers).await
19440}
19441
19442/// Shared post-save flash for redirect create/edit: a strong warning
19443/// for a wildcard override (it can shadow many live pages), a warning
19444/// for an exact non-override rule shadowed by a live page, else
19445/// success. `is_new` picks the "Added…" vs "Saved…" wording so every
19446/// message stays a single fully-localizable sentence.
19447async fn redirect_save_response(
19448    tenant: &Tenant,
19449    row: &crate::redirect::Redirect,
19450    overrides_live: bool,
19451    is_new: bool,
19452    headers: &HeaderMap,
19453) -> Result<Response, AdminError> {
19454    let args = &[
19455        ("from", row.from_path.as_str()),
19456        ("to", row.to_path.as_str()),
19457    ];
19458    if overrides_live && crate::redirect::is_wildcard(&row.from_path) {
19459        let key = if is_new {
19460            "Added redirect {from} → {to} — heads up: a wildcard override can shadow many live pages under this pattern. Double-check the pattern."
19461        } else {
19462            "Saved redirect {from} → {to} — heads up: a wildcard override can shadow many live pages under this pattern. Double-check the pattern."
19463        };
19464        return redirect_named_with_message_args(
19465            "rcms-admin:redirects:list",
19466            MsgLevel::Warning,
19467            key,
19468            args,
19469            headers,
19470        );
19471    }
19472    if redirect_is_shadowed(tenant, &row.from_path, overrides_live).await {
19473        let key = if is_new {
19474            "Added redirect {from} → {to} — but a published page exists at {from}, so it won't serve until that page is unpublished (or tick “Apply even when a published page exists”)."
19475        } else {
19476            "Saved redirect {from} → {to} — but a published page exists at {from}, so it won't serve until that page is unpublished (or tick “Apply even when a published page exists”)."
19477        };
19478        return redirect_named_with_message_args(
19479            "rcms-admin:redirects:list",
19480            MsgLevel::Warning,
19481            key,
19482            args,
19483            headers,
19484        );
19485    }
19486    let key = if is_new {
19487        "Added redirect {from} → {to}."
19488    } else {
19489        "Saved redirect {from} → {to}."
19490    };
19491    redirect_named_with_message_args(
19492        "rcms-admin:redirects:list",
19493        MsgLevel::Success,
19494        key,
19495        args,
19496        headers,
19497    )
19498}
19499
19500// ----- #186 — snippet CSV import (bulk migration) ---
19501
19502/// One row from the snippet CSV / TSV. Mirrors the cms_snippet shape:
19503/// required slug + title, optional body_markdown + folder_path + a
19504/// flat `data` map (any extra column → data.<column_name>).
19505#[derive(Debug)]
19506struct SnippetImportRow {
19507    slug: String,
19508    title: String,
19509    body_markdown: String,
19510    folder_path: String,
19511    data: serde_json::Map<String, serde_json::Value>,
19512}
19513
19514fn parse_snippet_csv(text: &str) -> Vec<SnippetImportRow> {
19515    // Header is required (we need to know what column is what).
19516    // Auto-detect TSV when tabs are present.
19517    let delimiter = if text.contains('\t') { '\t' } else { ',' };
19518    let mut lines = text.lines();
19519    let header = match lines.next() {
19520        Some(h) => h,
19521        None => return Vec::new(),
19522    };
19523    let cols: Vec<String> = header
19524        .split(delimiter)
19525        .map(|s| s.trim().to_ascii_lowercase())
19526        .collect();
19527    // Need at least slug + title.
19528    let slug_idx = cols.iter().position(|c| c == "slug" || c == "key");
19529    let title_idx = cols.iter().position(|c| c == "title" || c == "name");
19530    let (Some(slug_idx), Some(title_idx)) = (slug_idx, title_idx) else {
19531        return Vec::new();
19532    };
19533    let body_idx = cols
19534        .iter()
19535        .position(|c| c == "body_markdown" || c == "body" || c == "content");
19536    let folder_idx = cols
19537        .iter()
19538        .position(|c| c == "folder_path" || c == "folder" || c == "path");
19539    let mut out = Vec::new();
19540    for raw in lines {
19541        let trimmed = raw.trim();
19542        if trimmed.is_empty() {
19543            continue;
19544        }
19545        let parts: Vec<&str> = trimmed.split(delimiter).map(str::trim).collect();
19546        let slug = parts.get(slug_idx).copied().unwrap_or("");
19547        let title = parts.get(title_idx).copied().unwrap_or("");
19548        if slug.is_empty() || title.is_empty() {
19549            continue;
19550        }
19551        let body_markdown = body_idx
19552            .and_then(|i| parts.get(i))
19553            .copied()
19554            .unwrap_or("")
19555            .to_owned();
19556        let folder_path = folder_idx
19557            .and_then(|i| parts.get(i))
19558            .copied()
19559            .unwrap_or("")
19560            .to_owned();
19561        // Every other column lands in `data`.
19562        let mut data = serde_json::Map::new();
19563        for (i, col) in cols.iter().enumerate() {
19564            if Some(i) == Some(slug_idx)
19565                || Some(i) == Some(title_idx)
19566                || Some(i) == body_idx
19567                || Some(i) == folder_idx
19568            {
19569                continue;
19570            }
19571            if col.is_empty() {
19572                continue;
19573            }
19574            let v = parts.get(i).copied().unwrap_or("");
19575            if !v.is_empty() {
19576                data.insert(col.clone(), serde_json::Value::String(v.to_owned()));
19577            }
19578        }
19579        out.push(SnippetImportRow {
19580            slug: slug.to_owned(),
19581            title: title.to_owned(),
19582            body_markdown,
19583            folder_path: crate::snippet::normalize_folder(&folder_path),
19584            data,
19585        });
19586    }
19587    out
19588}
19589
19590/// GET /cms-admin/library/{type_name}/import — show upload form.
19591pub async fn snippet_import_form(
19592    State(state): State<super::AdminState>,
19593    tenant: Tenant,
19594    headers: HeaderMap,
19595    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19596    Path(type_name): Path<String>,
19597) -> Result<Response, AdminError> {
19598    let mut ctx = Context::new();
19599    add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
19600    add_admin_theme(&mut ctx, tenant.pool()).await;
19601    ctx.insert("type_name", &type_name);
19602    render_with_csrf(&state, &headers, "rcms_admin/snippet_import.html", &mut ctx)
19603}
19604
19605/// POST /cms-admin/library/{type_name}/import — bulk import snippets
19606/// for one library type from CSV / TSV.
19607pub async fn snippet_import_submit(
19608    State(_state): State<super::AdminState>,
19609    tenant: Tenant,
19610    headers: HeaderMap,
19611    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19612    Path(type_name): Path<String>,
19613    mut multipart: axum::extract::Multipart,
19614) -> Result<Response, AdminError> {
19615    use rustango::sql::Auto;
19616    let mut bytes: Vec<u8> = Vec::new();
19617    let mut filename = String::new();
19618    while let Some(field) = multipart
19619        .next_field()
19620        .await
19621        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
19622    {
19623        if field.name().unwrap_or("") == "file" {
19624            if let Some(name) = field.file_name() {
19625                filename = name.to_owned();
19626            }
19627            bytes = field
19628                .bytes()
19629                .await
19630                .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
19631                .to_vec();
19632        } else {
19633            let _ = field.bytes().await;
19634        }
19635    }
19636    if bytes.is_empty() {
19637        return redirect_named_with_message(
19638            "rcms-admin:library:list",
19639            MsgLevel::Error,
19640            "No file uploaded.",
19641            &headers,
19642        );
19643    }
19644    let text = String::from_utf8_lossy(&bytes);
19645    let rows = parse_snippet_csv(&text);
19646    let total = rows.len();
19647    if total == 0 {
19648        return redirect_named_with_message(
19649            "rcms-admin:library:list",
19650            MsgLevel::Error,
19651            "Imported 0 snippets — CSV must have a header row with `slug` + `title` columns.",
19652            &headers,
19653        );
19654    }
19655    let mut inserted = 0usize;
19656    let mut skipped = 0usize;
19657    let _ = filename; // captured for the note below
19658    for row in rows {
19659        let mut snippet = crate::snippet::Snippet {
19660            id: Auto::Unset,
19661            type_name: type_name.clone(),
19662            folder_path: row.folder_path,
19663            slug: row.slug,
19664            title: row.title,
19665            body_markdown: row.body_markdown,
19666            data: serde_json::Value::Object(row.data),
19667            created_at: Auto::Unset,
19668            updated_at: Auto::Unset,
19669        };
19670        match snippet.insert_pool(tenant.pool()).await {
19671            Ok(_) => inserted += 1,
19672            Err(_) => skipped += 1,
19673        }
19674    }
19675    let inserted_str = inserted.to_string();
19676    let total_str = total.to_string();
19677    let skipped_str = skipped.to_string();
19678    redirect_named_with_message_args(
19679        "rcms-admin:library:list",
19680        MsgLevel::Success,
19681        "Imported {inserted}/{total} snippets ({skipped} skipped — likely duplicate slugs).",
19682        &[
19683            ("inserted", inserted_str.as_str()),
19684            ("total", total_str.as_str()),
19685            ("skipped", skipped_str.as_str()),
19686        ],
19687        &headers,
19688    )
19689}
19690
19691/// GET /cms-admin/redirects/import — show the upload form.
19692pub async fn redirect_import_form(
19693    State(state): State<super::AdminState>,
19694    tenant: Tenant,
19695    headers: HeaderMap,
19696    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19697) -> Result<Response, AdminError> {
19698    let mut ctx = Context::new();
19699    add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19700    add_admin_theme(&mut ctx, tenant.pool()).await;
19701    render_with_csrf(
19702        &state,
19703        &headers,
19704        "rcms_admin/redirect_import.html",
19705        &mut ctx,
19706    )
19707}
19708
19709/// Parsed shape of one row from the CSV / TSV upload. Either two
19710/// or three fields per row: `old_path`, `new_path`, optional
19711/// `is_permanent` (`true` / `false`, or `301` / `302`).
19712#[derive(Debug)]
19713struct RedirectImportRow {
19714    from_path: String,
19715    to_path: String,
19716    is_permanent: bool,
19717}
19718
19719fn parse_redirect_csv(text: &str) -> Vec<RedirectImportRow> {
19720    // Best-effort CSV / TSV. Doesn't handle quoted commas inside
19721    // values (RFC-4180 strict) — redirects are URL paths, no
19722    // commas in them. TSV detection: if any line contains a tab,
19723    // use tab as the delimiter; otherwise comma.
19724    let delimiter = if text.contains('\t') { '\t' } else { ',' };
19725    let mut out = Vec::new();
19726    for (lineno, raw) in text.lines().enumerate() {
19727        let trimmed = raw.trim();
19728        if trimmed.is_empty() {
19729            continue;
19730        }
19731        let parts: Vec<&str> = trimmed.split(delimiter).map(str::trim).collect();
19732        // Header row: if the first row's first two cells are exactly
19733        // `from_path` / `to_path` (case-insensitive), skip.
19734        if lineno == 0 {
19735            let h0 = parts.first().copied().unwrap_or("").to_ascii_lowercase();
19736            if h0 == "from_path" || h0 == "from" || h0 == "old" || h0 == "source" {
19737                continue;
19738            }
19739        }
19740        if parts.len() < 2 {
19741            continue;
19742        }
19743        let from = parts[0];
19744        let to = parts[1];
19745        if from.is_empty() || to.is_empty() {
19746            continue;
19747        }
19748        let is_permanent = parts
19749            .get(2)
19750            .map(|s| {
19751                let v = s.to_ascii_lowercase();
19752                !matches!(v.as_str(), "false" | "0" | "302" | "no")
19753            })
19754            .unwrap_or(true);
19755        out.push(RedirectImportRow {
19756            from_path: from.to_owned(),
19757            to_path: to.to_owned(),
19758            is_permanent,
19759        });
19760    }
19761    out
19762}
19763
19764/// Serialize redirects to CSV: a header row + `from_path,to_path,
19765/// is_permanent`, with `is_permanent` rendered as `301`/`302` so the
19766/// importer ([`parse_redirect_csv`]) round-trips an export.
19767fn redirects_csv(items: &[crate::redirect::Redirect]) -> String {
19768    let mut out = String::from("from_path,to_path,is_permanent\n");
19769    for r in items {
19770        out.push_str(&csv_escape(&r.from_path));
19771        out.push(',');
19772        out.push_str(&csv_escape(&r.to_path));
19773        out.push(',');
19774        out.push_str(if r.is_permanent { "301" } else { "302" });
19775        out.push('\n');
19776    }
19777    out
19778}
19779
19780/// GET /cms-admin/redirects/export.csv — download all redirects as a
19781/// CSV the importer can round-trip.
19782pub async fn redirect_export_csv(
19783    State(_state): State<super::AdminState>,
19784    tenant: Tenant,
19785    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19786) -> Result<Response, AdminError> {
19787    let items: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
19788        .order_by(&[("from_path", false)])
19789        .fetch(tenant.pool())
19790        .await?;
19791    let body = redirects_csv(&items);
19792    let filename = format!("redirects-{}.csv", chrono::Utc::now().format("%Y%m%d"));
19793    let mut response = ([(header::CONTENT_TYPE, "text/csv; charset=utf-8")], body).into_response();
19794    if let Ok(v) = HeaderValue::from_str(&format!("attachment; filename=\"{filename}\"")) {
19795        response
19796            .headers_mut()
19797            .insert(header::CONTENT_DISPOSITION, v);
19798    }
19799    Ok(response)
19800}
19801
19802#[cfg(test)]
19803mod user_email_column_tests {
19804    use super::user_email;
19805
19806    fn user(email: Option<&str>, data: serde_json::Value) -> rustango::tenancy::auth::User {
19807        rustango::tenancy::auth::User {
19808            id: rustango::sql::Auto::Set(1),
19809            username: "u".into(),
19810            password_hash: String::new(),
19811            email: email.map(ToOwned::to_owned),
19812            is_superuser: false,
19813            active: true,
19814            created_at: chrono::Utc::now(),
19815            data,
19816            password_changed_at: None,
19817            sessions_revoked_at: None,
19818        }
19819    }
19820
19821    #[test]
19822    fn column_first_then_legacy_data_bag() {
19823        // A member signed up on the site: the column only.
19824        assert_eq!(user_email(&user(Some("a@x.example"), serde_json::json!({}))), "a@x.example");
19825        // An admin-made user from before: the data bag only.
19826        assert_eq!(user_email(&user(None, serde_json::json!({"email": "b@x.example"}))), "b@x.example");
19827        assert_eq!(
19828            user_email(&user(Some("a@x.example"), serde_json::json!({"email": "old@x.example"}))),
19829            "a@x.example"
19830        );
19831        assert_eq!(user_email(&user(Some("  "), serde_json::json!({}))), "");
19832    }
19833}
19834
19835#[cfg(test)]
19836mod translation_canonical_html_tests {
19837    use super::translation_canonical_html;
19838
19839    #[test]
19840    fn rich_text_is_sanitized_html_other_kinds_empty() {
19841        let html = translation_canonical_html("richtext", "<p>A jar</p><script>x()</script>");
19842        assert_eq!(html, "<p>A jar</p>");
19843        assert_eq!(translation_canonical_html("richtext", "  "), "");
19844        assert_eq!(translation_canonical_html("textarea", "<p>A jar</p>"), "");
19845        assert_eq!(translation_canonical_html("text", "Moon jar"), "");
19846    }
19847}
19848
19849#[cfg(test)]
19850mod user_email_tests {
19851    use super::validate_optional_email;
19852
19853    #[test]
19854    fn accepts_valid_and_empty() {
19855        assert_eq!(validate_optional_email(Some("a@b.com")).unwrap(), "a@b.com");
19856        assert_eq!(
19857            validate_optional_email(Some("  a@b.com ")).unwrap(),
19858            "a@b.com"
19859        ); // trimmed
19860        assert_eq!(validate_optional_email(None).unwrap(), ""); // optional
19861        assert_eq!(validate_optional_email(Some("   ")).unwrap(), ""); // blank → empty
19862    }
19863
19864    #[test]
19865    fn rejects_malformed() {
19866        assert!(validate_optional_email(Some("nope")).is_err()); // no @
19867        assert!(validate_optional_email(Some("a@b@c")).is_err()); // two @
19868        assert!(validate_optional_email(Some("@b.com")).is_err()); // empty local
19869        assert!(validate_optional_email(Some("a@")).is_err()); // empty domain
19870        assert!(validate_optional_email(Some("a b@c.com")).is_err()); // whitespace
19871    }
19872}
19873
19874#[cfg(test)]
19875mod copy_to_locale_tests {
19876    use super::copy_translatable_fields;
19877
19878    #[test]
19879    fn selects_nonempty_canonical_fields() {
19880        let out = copy_translatable_fields("Home", "", "  Welcome  ");
19881        // `seo_title` empty → skipped; whitespace-only would be too.
19882        assert_eq!(
19883            out,
19884            vec![
19885                ("title", "Home".to_owned()),
19886                ("seo_description", "  Welcome  ".to_owned()),
19887            ]
19888        );
19889    }
19890
19891    #[test]
19892    fn all_empty_yields_nothing_to_seed() {
19893        assert!(copy_translatable_fields("", "   ", "").is_empty());
19894    }
19895}
19896
19897#[cfg(test)]
19898mod redirect_csv_tests {
19899    use super::*;
19900    use rustango::sql::Auto;
19901
19902    fn row(from: &str, to: &str, permanent: bool) -> crate::redirect::Redirect {
19903        crate::redirect::Redirect {
19904            id: Auto::Unset,
19905            from_path: from.to_owned(),
19906            to_path: to.to_owned(),
19907            is_permanent: permanent,
19908            note: String::new(),
19909            hit_count: 0,
19910            overrides_live: false,
19911            from_page_id: None,
19912            to_page_id: None,
19913            is_active: true,
19914            disabled_reason: String::new(),
19915            last_hit_at: None,
19916            created_at: Auto::Unset,
19917            updated_at: Auto::Unset,
19918        }
19919    }
19920
19921    #[test]
19922    fn redirects_csv_header_and_301_302_mapping() {
19923        let csv = redirects_csv(&[row("/old", "/new", true), row("/tmp", "/dst", false)]);
19924        let mut lines = csv.lines();
19925        assert_eq!(lines.next(), Some("from_path,to_path,is_permanent"));
19926        assert_eq!(lines.next(), Some("/old,/new,301"));
19927        assert_eq!(lines.next(), Some("/tmp,/dst,302"));
19928        assert_eq!(lines.next(), None);
19929    }
19930
19931    #[test]
19932    fn redirects_csv_empty_is_header_only() {
19933        assert_eq!(redirects_csv(&[]), "from_path,to_path,is_permanent\n");
19934    }
19935}
19936
19937/// POST /cms-admin/redirects/import — accepts a multipart upload of
19938/// CSV / TSV; bulk-inserts redirects.
19939pub async fn redirect_import_submit(
19940    State(_state): State<super::AdminState>,
19941    tenant: Tenant,
19942    headers: HeaderMap,
19943    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19944    mut multipart: axum::extract::Multipart,
19945) -> Result<Response, AdminError> {
19946    use rustango::sql::Auto;
19947    let mut bytes: Vec<u8> = Vec::new();
19948    let mut filename = String::new();
19949    while let Some(field) = multipart
19950        .next_field()
19951        .await
19952        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
19953    {
19954        if field.name().unwrap_or("") == "file" {
19955            if let Some(name) = field.file_name() {
19956                filename = name.to_owned();
19957            }
19958            bytes = field
19959                .bytes()
19960                .await
19961                .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
19962                .to_vec();
19963        } else {
19964            let _ = field.bytes().await;
19965        }
19966    }
19967    if bytes.is_empty() {
19968        return redirect_named_with_message(
19969            "rcms-admin:redirects:list",
19970            MsgLevel::Error,
19971            "No file uploaded.",
19972            &headers,
19973        );
19974    }
19975    let text = String::from_utf8_lossy(&bytes);
19976    let rows = parse_redirect_csv(&text);
19977    let total = rows.len();
19978    let mut inserted = 0usize;
19979    let mut skipped = 0usize;
19980    for row in rows {
19981        if redirect_pattern_error(&row.from_path, &row.to_path).is_some() {
19982            skipped += 1;
19983            continue;
19984        }
19985        let mut redirect = crate::redirect::Redirect {
19986            id: Auto::Unset,
19987            from_path: row.from_path,
19988            to_path: row.to_path,
19989            is_permanent: row.is_permanent,
19990            note: format!("Imported from {filename}"),
19991            hit_count: 0,
19992            overrides_live: false,
19993            from_page_id: None,
19994            to_page_id: None,
19995            is_active: true,
19996            disabled_reason: String::new(),
19997            last_hit_at: None,
19998            created_at: Auto::Unset,
19999            updated_at: Auto::Unset,
20000        };
20001        match redirect.insert_pool(tenant.pool()).await {
20002            Ok(_) => inserted += 1,
20003            Err(_) => skipped += 1,
20004        }
20005    }
20006    let inserted_str = inserted.to_string();
20007    let total_str = total.to_string();
20008    let skipped_str = skipped.to_string();
20009    redirect_named_with_message_args(
20010        "rcms-admin:redirects:list",
20011        MsgLevel::Success,
20012        "Imported {inserted}/{total} redirects ({skipped} skipped — likely duplicates).",
20013        &[
20014            ("inserted", inserted_str.as_str()),
20015            ("total", total_str.as_str()),
20016            ("skipped", skipped_str.as_str()),
20017        ],
20018        &headers,
20019    )
20020}
20021
20022pub async fn redirect_edit_form(
20023    State(state): State<super::AdminState>,
20024    tenant: Tenant,
20025    headers: HeaderMap,
20026    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20027    Path(id): Path<i64>,
20028) -> Result<Response, AdminError> {
20029    let row = crate::redirect::Redirect::objects()
20030        .where_(crate::redirect::Redirect::id.eq(id))
20031        .first(tenant.pool())
20032        .await?
20033        .ok_or(AdminError::NotFound(id))?;
20034    let mut ctx = Context::new();
20035    add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
20036    add_admin_theme(&mut ctx, tenant.pool()).await;
20037    ctx.insert("mode", "edit");
20038    ctx.insert("redirect", &row);
20039    render_with_csrf(&state, &headers, "rcms_admin/redirect_form.html", &mut ctx)
20040}
20041
20042pub async fn redirect_edit_submit(
20043    State(_state): State<super::AdminState>,
20044    tenant: Tenant,
20045    headers: HeaderMap,
20046    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
20047    Path(id): Path<i64>,
20048    Form(form): Form<RedirectForm>,
20049) -> Result<Response, AdminError> {
20050    let mut row = crate::redirect::Redirect::objects()
20051        .where_(crate::redirect::Redirect::id.eq(id))
20052        .first(tenant.pool())
20053        .await?
20054        .ok_or(AdminError::NotFound(id))?;
20055    let (from, to) = redirect_form_paths(tenant.pool(), &form).await?;
20056    if from.is_empty() || to.is_empty() {
20057        return redirect_named_with_message(
20058            "rcms-admin:redirects:list",
20059            MsgLevel::Error,
20060            "From-path and to-path are both required.",
20061            &headers,
20062        );
20063    }
20064    if let Some(msg) = redirect_pattern_error(&from, &to) {
20065        return redirect_named_with_message(
20066            "rcms-admin:redirects:list",
20067            MsgLevel::Error,
20068            msg,
20069            &headers,
20070        );
20071    }
20072    row.from_path = from;
20073    row.to_path = to;
20074    row.is_permanent = form.parsed_permanent();
20075    row.overrides_live = form.parsed_overrides_live();
20076    row.from_page_id = form.parsed_from_page_id();
20077    row.to_page_id = form.parsed_to_page_id();
20078    row.note = form.note.unwrap_or_default().trim().to_owned();
20079    row.save_pool(tenant.pool()).await?;
20080    let overrides_live = row.overrides_live;
20081    redirect_save_response(&tenant, &row, overrides_live, false, &headers).await
20082}
20083
20084/// POST /cms-admin/redirects/{id}/enable — re-enable a rule that was
20085/// auto-disabled when a linked page was deleted/unpublished.
20086pub async fn redirect_enable_submit(
20087    State(_state): State<super::AdminState>,
20088    tenant: Tenant,
20089    headers: HeaderMap,
20090    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
20091    Path(id): Path<i64>,
20092) -> Result<Response, AdminError> {
20093    let mut row = crate::redirect::Redirect::objects()
20094        .where_(crate::redirect::Redirect::id.eq(id))
20095        .first(tenant.pool())
20096        .await?
20097        .ok_or(AdminError::NotFound(id))?;
20098    row.is_active = true;
20099    row.disabled_reason = String::new();
20100    row.save_pool(tenant.pool()).await?;
20101    redirect_named_with_message_args(
20102        "rcms-admin:redirects:list",
20103        MsgLevel::Success,
20104        "Re-enabled redirect {from} → {to}.",
20105        &[
20106            ("from", row.from_path.as_str()),
20107            ("to", row.to_path.as_str()),
20108        ],
20109        &headers,
20110    )
20111}
20112
20113pub async fn redirect_delete_submit(
20114    State(_state): State<super::AdminState>,
20115    tenant: Tenant,
20116    headers: HeaderMap,
20117    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
20118    Path(id): Path<i64>,
20119) -> Result<Response, AdminError> {
20120    let row = crate::redirect::Redirect::objects()
20121        .where_(crate::redirect::Redirect::id.eq(id))
20122        .first(tenant.pool())
20123        .await?
20124        .ok_or(AdminError::NotFound(id))?;
20125    let label = format!("{} → {}", row.from_path, row.to_path);
20126    row.delete_pool(tenant.pool()).await?;
20127    redirect_named_with_message_args(
20128        "rcms-admin:redirects:list",
20129        MsgLevel::Success,
20130        "Deleted redirect {label}.",
20131        &[("label", label.as_str())],
20132        &headers,
20133    )
20134}
20135
20136// =====================================================================
20137// Helpers (existing)
20138// =====================================================================
20139
20140// ---------- helpers ----------
20141
20142/// `PageType` rows whose handler reports `is_creatable() = true`.
20143/// Falls back to the row's `is_creatable` column when no handler is
20144/// registered (stale row from a removed type).
20145pub(crate) fn creatable_types(all: &[PageType]) -> Vec<PageType> {
20146    all.iter()
20147        .filter(|t| {
20148            find_handler(&t.type_name)
20149                .map(|h| h.is_creatable())
20150                .unwrap_or(t.is_creatable)
20151        })
20152        .cloned()
20153        .collect()
20154}
20155
20156/// `PageType` rows allowed at the ROOT of the tree (no parent).
20157///
20158/// A type that names `allowed_parent_types` is declaring it may only live
20159/// under those parents, so it cannot be a root. Without this the root picker
20160/// offered every creatable type and the save path accepted it, letting you
20161/// create e.g. an `ArticlePage` (parent-restricted to `HomePage`) at the root
20162/// — a tree the type rules forbid. The child case has always been
20163/// gated by [`allowed_children_for`]; this is the missing mirror.
20164pub(crate) fn allowed_root_types(all: &[PageType]) -> Vec<PageType> {
20165    creatable_types(all)
20166        .into_iter()
20167        .filter(|t| t.allowed_parents().is_empty())
20168        .collect()
20169}
20170
20171/// `PageType` rows allowed as direct children of `parent`. Consults
20172/// the parent's handler's `allowed_child_types` AND each candidate's
20173/// `allowed_parent_types`. Skip the check if either whitelist is
20174/// empty.
20175pub(crate) fn allowed_children_for(parent: &Page, all: &[PageType]) -> Vec<PageType> {
20176    let parent_row = all
20177        .iter()
20178        .find(|t| t.id.get().copied() == Some(parent.page_type_id));
20179    let parent_type_name = parent_row.map(|t| t.type_name.clone()).unwrap_or_default();
20180    // Rules come from the rows, so admin-made types count too (#843).
20181    let parent_allowed_children = parent_row.map(PageType::allowed_children).unwrap_or_default();
20182
20183    creatable_types(all)
20184        .into_iter()
20185        .filter(|cand| {
20186            // Parent-side gate: empty list = no restriction.
20187            if !parent_allowed_children.is_empty()
20188                && !parent_allowed_children.iter().any(|t| t == &cand.type_name)
20189            {
20190                return false;
20191            }
20192            // Child-side gate.
20193            let allowed_parents = cand.allowed_parents();
20194            allowed_parents.is_empty() || allowed_parents.iter().any(|p| *p == parent_type_name)
20195        })
20196        .collect()
20197}
20198
20199/// Empty values for a fresh create form — Tera doesn't auto-default
20200/// missing keys, so we pre-populate the field map.
20201fn empty_page_form_values() -> serde_json::Value {
20202    serde_json::json!({
20203        "title": "",
20204        "slug": "",
20205        "page_type_id": 0,
20206        "status": "draft",
20207        "seo_title": "",
20208        "seo_description": "",
20209        "robots_index": true,
20210        "sitemap_priority": 0.5,
20211        "show_in_menus": true,
20212        "go_live_at": serde_json::Value::Null,
20213        "expire_at": serde_json::Value::Null,
20214        "og_title": "",
20215        "og_description": "",
20216        "og_image_media_id": serde_json::Value::Null,
20217        "twitter_card": "summary_large_image",
20218    })
20219}
20220
20221// =====================================================================
20222// Password reset
20223// =====================================================================
20224//
20225// The four screens — request form (GET), request submit (POST),
20226// confirm form (GET, signed-token URL), confirm submit (POST). Mounted
20227// by `admin::public_router` so anonymous visitors can reach them.
20228//
20229// Token model: signed-URL only (no DB table). The signing secret lives
20230// in `AdminState::signing_secret`, loaded once at boot. `PasswordReset`
20231// (rustango::auth_flows) handles issue + verify.
20232//
20233// Email model: `ConsoleMailer` for v1 — the reset URL prints to stdout
20234// + `tracing::info!`. Production deployments swap in `SmtpMailer` by
20235// editing `send_reset_email` below.
20236//
20237// Account-existence non-leak: every reset-request returns the same
20238// "if that account exists, check your email" page regardless of
20239// whether a user was found.
20240
20241/// POST `/cms-admin/logout` — clear every session cookie the host
20242/// might have minted (bare-admin `rustango_admin_session`, tenant
20243/// `rustango_tenant_session`, operator `rustango_op_session`),
20244/// redirect to `/login`. Self-contained so the button works
20245/// regardless of which framework auth flow signed the user in —
20246/// avoids depending on the right cookie name being known here.
20247pub async fn cms_logout_submit(
20248    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20249    tenant: Result<Tenant, rustango::extractors::TenantRejection>,
20250    request: crate::security_log::LoginRequest,
20251) -> Response {
20252    if let (Some(user), Ok(tenant)) = (session_user, tenant) {
20253        let entry = SecurityEntry::new(crate::security_log::EVENT_LOGOUT, "admin", &request.meta)
20254            .user(user.id.get().copied(), &user.username);
20255        crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
20256    }
20257    let mut resp = Redirect::to("/login").into_response();
20258    // Reset all three cookies (`Max-Age=0` clears, the empty value
20259    // is a fallback for browsers that only honor expiry-by-value).
20260    // SameSite=Lax + HttpOnly match the framework's mint shape.
20261    let cookies = [
20262        "rustango_admin_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20263        "rustango_tenant_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20264        "rustango_op_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20265    ];
20266    for c in cookies {
20267        if let Ok(v) = HeaderValue::from_str(c) {
20268            resp.headers_mut().append(header::SET_COOKIE, v);
20269        }
20270    }
20271    resp
20272}
20273
20274/// GET `/login` — render the CMS-branded login form. Shadows the
20275/// framework's default `/login` GET (which is wired to its own
20276/// embedded Tera + `login.html`). POST `/login` continues to be
20277/// handled by the framework's auth code — its handler validates
20278/// `username`+`password` against `rustango_users` and sets the
20279/// tenant session cookie.
20280/// GET `/cms-admin/no-access` — destination for the `cms_admin.access`
20281/// gate. Reachable while signed in; doesn't require any
20282/// permission. The middleware adds an exception for this path so
20283/// the redirect doesn't loop.
20284pub async fn no_access_page(
20285    State(state): State<super::AdminState>,
20286    headers: HeaderMap,
20287    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
20288) -> Result<Response, AdminError> {
20289    let mut ctx = Context::new();
20290    ctx.insert("admin_title", &"CMS Admin");
20291    render_with_csrf(&state, &headers, "rcms_admin/no_access.html", &mut ctx)
20292}
20293
20294/// GET `/cms-admin/me` — per-user appearance / text-size / accessibility
20295/// preferences. Replaces the sidebar-footer toggles. The
20296/// preferences themselves persist in `localStorage` via the existing
20297/// no-flash boot script + the toggle JS in `_base.html`; this view
20298/// is purely the surface that hosts the same toggle widgets in a
20299/// dedicated page.
20300/// POST /cms-admin/dismissibles/{key} — record dismissal of the
20301/// banner identified by `key` for the current user. Returns 204 No Content on success.
20302pub async fn dismissible_submit(
20303    State(_state): State<super::AdminState>,
20304    tenant: Tenant,
20305    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20306    Path(key): Path<String>,
20307) -> Result<Response, AdminError> {
20308    let Some(viewer) = session_user.as_ref() else {
20309        return Ok(unauthorized_no_session());
20310    };
20311    let viewer_id = viewer.id.get().copied().unwrap_or_default();
20312    crate::dismissible::dismiss(tenant.pool(), viewer_id, &key).await?;
20313    Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
20314}
20315
20316/// GET /cms-admin/dashboard — editor home / at-a-glance screen.
20317/// Surfaces count widgets, recent edits,
20318/// items locked by the current user, and pages scheduled to publish
20319/// next.
20320pub async fn dashboard(
20321    State(state): State<super::AdminState>,
20322    tenant: Tenant,
20323    headers: HeaderMap,
20324    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20325) -> Result<Response, AdminError> {
20326    let pool = tenant.pool();
20327    let viewer_id = session_user.as_ref().and_then(|u| u.id.get().copied());
20328
20329    // ---- counts ----
20330    let all_pages: Vec<Page> = Page::objects().fetch(pool).await.unwrap_or_default();
20331    let mut count_drafts = 0usize;
20332    let mut count_published = 0usize;
20333    let mut count_scheduled = 0usize;
20334    let mut count_archived = 0usize;
20335    for p in &all_pages {
20336        match p.status.as_str() {
20337            "draft" => count_drafts += 1,
20338            "published" => count_published += 1,
20339            "scheduled" => count_scheduled += 1,
20340            "archived" => count_archived += 1,
20341            _ => {}
20342        }
20343    }
20344    let snippet_count: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
20345        .fetch(pool)
20346        .await
20347        .unwrap_or_default();
20348    let media_rows: Vec<Media> = Media::objects().fetch(pool).await.unwrap_or_default();
20349    let media_images = media_rows.iter().filter(|m| m.kind == "image").count();
20350    let media_docs = media_rows.len() - media_images;
20351
20352    // ---- recent edits (last 10 revisions across all pages) ----
20353    let revs: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
20354        .order_by(&[("created_at", true)]) // desc
20355        .limit(10)
20356        .fetch(pool)
20357        .await
20358        .unwrap_or_default();
20359    // Who made them, by name (one query).
20360    let user_ids: std::collections::BTreeSet<i64> = revs.iter().filter_map(|r| r.created_by).collect();
20361    let usernames: std::collections::HashMap<i64, String> = if user_ids.is_empty() {
20362        std::collections::HashMap::new()
20363    } else {
20364        rustango::tenancy::auth::User::objects()
20365            .where_(rustango::tenancy::auth::User::id.is_in(user_ids.into_iter()))
20366            .fetch(pool)
20367            .await
20368            .unwrap_or_default()
20369            .into_iter()
20370            .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
20371            .collect()
20372    };
20373    let page_by_id: std::collections::HashMap<i64, &Page> = all_pages
20374        .iter()
20375        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
20376        .collect();
20377    let recent_edits: Vec<serde_json::Value> = revs
20378        .iter()
20379        .filter_map(|r| {
20380            let p = page_by_id.get(&r.page_id)?;
20381            Some(serde_json::json!({
20382                "page_id": r.page_id,
20383                "title": p.title,
20384                "url_path": p.url_path,
20385                "sequence": r.sequence,
20386                "created_at": r.created_at.get().copied(),
20387                "created_by": r.created_by.and_then(|id| usernames.get(&id).cloned()),
20388            }))
20389        })
20390        .collect();
20391
20392    // ---- locked by me ----
20393    let locks: Vec<crate::lock::PageLock> = crate::lock::PageLock::objects()
20394        .fetch(pool)
20395        .await
20396        .unwrap_or_default();
20397    let now = chrono::Utc::now();
20398    let mine_locked: Vec<serde_json::Value> = locks
20399        .iter()
20400        .filter(|l| !l.is_stale(now))
20401        .filter(|l| Some(l.user_id) == viewer_id)
20402        .filter_map(|l| {
20403            let p = page_by_id.get(&l.page_id)?;
20404            Some(serde_json::json!({
20405                "page_id": l.page_id,
20406                "title": p.title,
20407                "url_path": p.url_path,
20408                "acquired_at": l.acquired_at.get().copied(),
20409            }))
20410        })
20411        .collect();
20412
20413    // ---- waiting for your review ----
20414    // Pages mid-review whose current step belongs to one of the viewer's
20415    // roles (a superuser decides every step). Without this the reviewer
20416    // had no way to know someone was waiting.
20417    let mut review_rows: Vec<serde_json::Value> = Vec::new();
20418    if let Some(viewer) = session_user.as_ref() {
20419        let states: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
20420            .where_(crate::workflow::WorkflowState::status.eq(crate::workflow::WorkflowStatus::InProgress.as_str().to_owned()))
20421            .fetch(pool)
20422            .await
20423            .unwrap_or_default();
20424        if !states.is_empty() {
20425            let my_roles: std::collections::BTreeSet<i64> = rustango::tenancy::permissions::UserRole::objects()
20426                .where_(rustango::tenancy::permissions::UserRole::user_id.eq(viewer_id.unwrap_or_default()))
20427                .fetch(pool)
20428                .await
20429                .unwrap_or_default()
20430                .into_iter()
20431                .map(|m| m.role_id)
20432                .collect();
20433            let task_ids: Vec<i64> = states.iter().filter_map(|st| st.current_task_id).collect();
20434            let tasks: std::collections::HashMap<i64, crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
20435                .where_(crate::workflow::WorkflowTask::id.is_in(task_ids.into_iter()))
20436                .fetch(pool)
20437                .await
20438                .unwrap_or_default()
20439                .into_iter()
20440                .filter_map(|t| t.id.get().copied().map(|id| (id, t)))
20441                .collect();
20442            for st in &states {
20443                let Some(task) = st.current_task_id.and_then(|id| tasks.get(&id)) else { continue };
20444                if !viewer.is_superuser && !my_roles.contains(&task.role_id) {
20445                    continue;
20446                }
20447                let Some(p) = page_by_id.get(&st.page_id) else { continue };
20448                review_rows.push(serde_json::json!({
20449                    "page_id": st.page_id,
20450                    "title": p.title,
20451                    "url_path": p.url_path,
20452                    "step": task.name,
20453                    "requested_at": st.requested_at.get().copied(),
20454                }));
20455            }
20456        }
20457    }
20458
20459    // ---- scheduled next ----
20460    let mut scheduled: Vec<&Page> = all_pages
20461        .iter()
20462        .filter(|p| {
20463            p.status == "scheduled" && p.go_live_at.is_some() && p.go_live_at.unwrap() > now
20464        })
20465        .collect();
20466    scheduled.sort_by_key(|p| p.go_live_at);
20467    scheduled.truncate(5);
20468    let scheduled_rows: Vec<serde_json::Value> = scheduled
20469        .into_iter()
20470        .map(|p| {
20471            serde_json::json!({
20472                "page_id": p.id.get().copied().unwrap_or_default(),
20473                "title": p.title,
20474                "url_path": p.url_path,
20475                "go_live_at": p.go_live_at,
20476            })
20477        })
20478        .collect();
20479
20480    // ---- plugin widgets ----
20481    let plugin_widgets: Vec<serde_json::Value> = crate::hooks::dashboard_widgets()
20482        .into_iter()
20483        .map(|w| {
20484            serde_json::json!({
20485                "key": w.key,
20486                "label": w.label,
20487                "icon": w.icon,
20488                "html": w.html,
20489            })
20490        })
20491        .collect();
20492
20493    let mut ctx = Context::new();
20494    add_chrome(&mut ctx, &tenant, "dashboard", session_user.as_ref()).await;
20495    add_admin_theme(&mut ctx, tenant.pool()).await;
20496    ctx.insert("review_rows", &review_rows);
20497    ctx.insert("count_drafts", &count_drafts);
20498    ctx.insert("count_published", &count_published);
20499    ctx.insert("count_scheduled", &count_scheduled);
20500    ctx.insert("count_archived", &count_archived);
20501    ctx.insert("count_snippets", &snippet_count.len());
20502    ctx.insert("count_images", &media_images);
20503    ctx.insert("count_documents", &media_docs);
20504    ctx.insert("recent_edits", &recent_edits);
20505    ctx.insert("mine_locked", &mine_locked);
20506    ctx.insert("scheduled_rows", &scheduled_rows);
20507    ctx.insert("plugin_widgets", &plugin_widgets);
20508    render_with_csrf(&state, &headers, "rcms_admin/dashboard.html", &mut ctx)
20509}
20510
20511/// GET /cms-admin/styleguide — component gallery. Lists every registered block + every widget kind so
20512/// editors + reviewers can see the available palette at a glance.
20513pub async fn styleguide(
20514    State(state): State<super::AdminState>,
20515    tenant: Tenant,
20516    headers: HeaderMap,
20517    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20518) -> Result<Response, AdminError> {
20519    let mut ctx = Context::new();
20520    add_chrome(&mut ctx, &tenant, "styleguide", session_user.as_ref()).await;
20521    add_admin_theme(&mut ctx, tenant.pool()).await;
20522
20523    // Registered blocks — one row per registration. Author-curated
20524    // sample data lives in the template (the trait surface doesn't
20525    // require blocks to ship examples).
20526    let blocks: Vec<serde_json::Value> = crate::block::registered_blocks()
20527        .map(|b| {
20528            serde_json::json!({
20529                "type_name": b.type_name(),
20530                "verbose_name": b.verbose_name(),
20531                "icon": b.icon(),
20532                "group": b.group(),
20533                "field_count": b.fields().len(),
20534            })
20535        })
20536        .collect();
20537    ctx.insert("blocks", &blocks);
20538
20539    // Registered page types — second registry editors care about.
20540    let page_types: Vec<serde_json::Value> = crate::page_type::registered_handlers()
20541        .map(|h| {
20542            serde_json::json!({
20543                "type_name": h.type_name(),
20544                "verbose_name": h.verbose_name(),
20545                "icon": h.icon(),
20546                "description": h.description(),
20547            })
20548        })
20549        .collect();
20550    ctx.insert("page_types", &page_types);
20551
20552    // Library types.
20553    let library_types: Vec<serde_json::Value> = crate::library::registered_handlers()
20554        .map(|h| {
20555            serde_json::json!({
20556                "type_name": h.type_name(),
20557                "verbose_name": h.verbose_name(),
20558            })
20559        })
20560        .collect();
20561    ctx.insert("library_types", &library_types);
20562
20563    render_with_csrf(&state, &headers, "rcms_admin/styleguide.html", &mut ctx)
20564}
20565
20566pub async fn account_preferences(
20567    State(state): State<super::AdminState>,
20568    tenant: Tenant,
20569    headers: HeaderMap,
20570    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20571) -> Result<Response, AdminError> {
20572    render_account_page(&state, &tenant, &headers, session_user.as_ref(), None).await
20573}
20574
20575/// Serialize a user's MCP keys (+ per-key skill scope) and the tenant's
20576/// skill catalog for the key-management cards.
20577async fn mcp_keys_ctx(
20578    pool: &rustango::sql::Pool,
20579    owner_id: i64,
20580) -> (Vec<serde_json::Value>, Vec<serde_json::Value>) {
20581    use rustango::tenancy::{AgentGrant, AgentSkill};
20582
20583    let keys = rustango::tenancy::list_user_keys_pool(pool, owner_id)
20584        .await
20585        .unwrap_or_default();
20586    let skills: Vec<AgentSkill> = rustango::tenancy::list_skills_pool(pool)
20587        .await
20588        .unwrap_or_default();
20589    let skill_name = |sid: i64| -> Option<String> {
20590        skills
20591            .iter()
20592            .find(|s| s.id.get().copied() == Some(sid))
20593            .map(|s| s.codename.clone())
20594    };
20595    let mut rows = Vec::with_capacity(keys.len());
20596    for key in &keys {
20597        let key_id = key.id.get().copied().unwrap_or_default();
20598        let grants: Vec<AgentGrant> = AgentGrant::objects()
20599            .where_(AgentGrant::agent_id.eq(key_id))
20600            .fetch(pool)
20601            .await
20602            .unwrap_or_default();
20603        let scope: Vec<String> = grants
20604            .iter()
20605            .filter_map(|g| skill_name(g.skill_id))
20606            .collect();
20607        rows.push(serde_json::json!({
20608            "id": key_id,
20609            "label": key.data.get("label").and_then(|v| v.as_str()).unwrap_or(&key.name),
20610            "prefix": key.secret_prefix,
20611            "active": key.active,
20612            "created_at": key.created_at.get().map(|t| t.format("%Y-%m-%d %H:%M").to_string()),
20613            "scope": scope,
20614        }));
20615    }
20616    let skill_rows: Vec<serde_json::Value> = skills
20617        .iter()
20618        .map(|s| {
20619            serde_json::json!({
20620                "codename": s.codename,
20621                "name": s.name,
20622                "description": s.description,
20623            })
20624        })
20625        .collect();
20626    (rows, skill_rows)
20627}
20628
20629async fn render_account_page(
20630    state: &super::AdminState,
20631    tenant: &Tenant,
20632    headers: &HeaderMap,
20633    session_user: Option<&rustango::tenancy::auth::User>,
20634    mcp_one_time: Option<serde_json::Value>,
20635) -> Result<Response, AdminError> {
20636    // #202 — surface the current + pending email + mailer presence so
20637    // the Profile card can render the change-email form variant.
20638    let (current_email, pending_email, mailer_wired) = {
20639        let mailer = state.mailer.is_some();
20640        let user_data = session_user
20641            .map(|u| u.data.clone())
20642            .unwrap_or_else(|| serde_json::json!({}));
20643        let cur = session_user.map(user_email).unwrap_or_default();
20644        let pending = user_data
20645            .get("pending_email")
20646            .and_then(|v| v.as_str())
20647            .unwrap_or("")
20648            .to_owned();
20649        (cur, pending, mailer)
20650    };
20651    let mut ctx = Context::new();
20652    add_chrome(&mut ctx, tenant, "", session_user).await;
20653    add_admin_theme(&mut ctx, tenant.pool()).await;
20654    // #174 — admin theme picker lives in Preferences (was on
20655    // Settings). Surface every cms_theme row + its 4 marquee
20656    // colors for a swatch preview.
20657    let themes: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
20658        .order_by(&[("name", false)])
20659        .fetch(tenant.pool())
20660        .await
20661        .unwrap_or_default();
20662    let theme_rows: Vec<serde_json::Value> = themes
20663        .iter()
20664        .map(|t| {
20665            serde_json::json!({
20666                "id": t.id.get().copied(),
20667                "name": t.name,
20668                "slug": t.slug,
20669                "is_admin_default": t.is_admin_default,
20670                "color_bg": t.color_bg,
20671                "color_surface": t.color_surface,
20672                "color_text_primary": t.color_text_primary,
20673                "color_link": t.color_link,
20674            })
20675        })
20676        .collect();
20677    ctx.insert("themes", &theme_rows);
20678    // #128 — plugin-contributed Account settings panels. Each panel is a pre-rendered HTML fragment hosts
20679    // contribute via `register_account_settings_panel!`.
20680    let account_panels: Vec<serde_json::Value> = crate::hooks::account_settings_panels()
20681        .into_iter()
20682        .map(|p| {
20683            serde_json::json!({
20684                "key": p.key,
20685                "label": p.label,
20686                "icon": p.icon,
20687                "html": p.html,
20688            })
20689        })
20690        .collect();
20691    ctx.insert("account_panels", &account_panels);
20692
20693    // #197 — per-user notification preferences. We pass every kind
20694    // through with its current toggle state so the template renders
20695    // checked/unchecked without a second fetch. Missing rows default
20696    // to true (opt-out semantics).
20697    let pref_map = session_user
20698        .and_then(|u| u.id.get().copied())
20699        .map(|uid| crate::notification_pref::map_for_user(tenant.pool(), uid))
20700        .map(|fut| async move { fut.await.unwrap_or_default() });
20701    let pref_lookup: std::collections::HashMap<String, bool> = match pref_map {
20702        Some(f) => f.await,
20703        None => std::collections::HashMap::new(),
20704    };
20705    let notification_rows: Vec<serde_json::Value> = crate::notification_pref::ALL_KINDS
20706        .iter()
20707        .map(|(label, kind, hint)| {
20708            let enabled = pref_lookup.get(*kind).copied().unwrap_or(true);
20709            serde_json::json!({
20710                "label": label,
20711                "kind": kind,
20712                "hint": hint,
20713                "enabled": enabled,
20714            })
20715        })
20716        .collect();
20717    ctx.insert("notification_prefs", &notification_rows);
20718
20719    ctx.insert("account_email", &current_email);
20720    ctx.insert("account_pending_email", &pending_email);
20721    ctx.insert("account_mailer_wired", &mailer_wired);
20722
20723    // #587 — MCP keys card: the viewer's keys + the skill catalog for
20724    // the optional-scope picker; `mcp_one_time` carries a just-minted
20725    // token for the show-once dialog.
20726    if let Some(uid) = session_user.and_then(|u| u.id.get().copied()) {
20727        let (keys, skills) = mcp_keys_ctx(tenant.pool(), uid).await;
20728        ctx.insert("mcp_keys", &keys);
20729        ctx.insert("mcp_skills", &skills);
20730    }
20731    if let Some(one_time) = &mcp_one_time {
20732        ctx.insert("mcp_one_time", one_time);
20733    }
20734
20735    render_with_csrf(
20736        state,
20737        headers,
20738        "rcms_admin/account_preferences.html",
20739        &mut ctx,
20740    )
20741}
20742
20743/// POST /cms-admin/me/notifications — save the on/off toggles for
20744/// every notification kind. The form posts a checkbox per kind;
20745/// absent inputs mean "off". Iterates every known kind so the user
20746/// can disable categories from a single submit.
20747pub async fn account_notifications_submit(
20748    State(_state): State<super::AdminState>,
20749    tenant: Tenant,
20750    headers: HeaderMap,
20751    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20752    Form(form): Form<std::collections::HashMap<String, String>>,
20753) -> Result<Response, AdminError> {
20754    let Some(viewer) = session_user.as_ref() else {
20755        return Ok(unauthorized_no_session());
20756    };
20757    let Some(uid) = viewer.id.get().copied() else {
20758        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20759    };
20760    for (_label, kind, _hint) in crate::notification_pref::ALL_KINDS {
20761        let key = format!("kind_{kind}");
20762        let enabled = form
20763            .get(&key)
20764            .map(|v| matches!(v.as_str(), "on" | "true" | "1" | "yes"))
20765            .unwrap_or(false);
20766        crate::notification_pref::set_enabled(tenant.pool(), uid, kind, enabled).await?;
20767    }
20768    redirect_named_with_params_and_message(
20769        "rcms-admin:account",
20770        &[],
20771        MsgLevel::Success,
20772        "Notification preferences saved.",
20773        &headers,
20774    )
20775}
20776
20777/// POST /cms-admin/me/profile — display name + avatar upload.
20778/// Multipart submit; absence of either field leaves the existing
20779/// value untouched. Avatar bytes land at
20780/// `./var/avatars/<tenant-slug>/<user_id>.<ext>` (slug-namespaced so
20781/// per-tenant user ids don't collide) and the filename is recorded in
20782/// `rustango_users.data.avatar_path`.
20783pub async fn account_profile_submit(
20784    State(_state): State<super::AdminState>,
20785    tenant: Tenant,
20786    headers: HeaderMap,
20787    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20788    mut multipart: axum::extract::Multipart,
20789) -> Result<Response, AdminError> {
20790    let Some(viewer) = session_user.as_ref() else {
20791        return Ok(unauthorized_no_session());
20792    };
20793    let Some(uid) = viewer.id.get().copied() else {
20794        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20795    };
20796
20797    let mut new_display_name: Option<String> = None;
20798    let mut new_avatar_path: Option<String> = None;
20799    // Namespace avatars by tenant slug. Per-tenant DBs each start user
20800    // ids at 1, so a flat `./var/avatars/{uid}.{ext}` collided across
20801    // tenants (tenant B's user #1 overwriting / exposing tenant A's).
20802    let avatar_dir = std::path::PathBuf::from("./var/avatars").join(&tenant.org.slug);
20803
20804    while let Some(field) = multipart
20805        .next_field()
20806        .await
20807        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
20808    {
20809        let field_name = field.name().unwrap_or("").to_owned();
20810        match field_name.as_str() {
20811            "display_name" => {
20812                new_display_name = Some(
20813                    field
20814                        .text()
20815                        .await
20816                        .map_err(|e| AdminError::Upload(format!("read display_name: {e}")))?
20817                        .trim()
20818                        .to_owned(),
20819                );
20820            }
20821            "avatar" => {
20822                let original = field.file_name().map(|s| s.to_owned());
20823                let bytes = field
20824                    .bytes()
20825                    .await
20826                    .map_err(|e| AdminError::Upload(format!("read avatar: {e}")))?;
20827                if bytes.is_empty() {
20828                    continue;
20829                }
20830                let ext = original
20831                    .as_deref()
20832                    .and_then(|n| n.rsplit_once('.'))
20833                    .map(|(_, ext)| ext)
20834                    .filter(|ext| ext.len() <= 8 && ext.chars().all(|c| c.is_ascii_alphanumeric()))
20835                    .map(str::to_ascii_lowercase)
20836                    .unwrap_or_else(|| "png".to_owned());
20837                std::fs::create_dir_all(&avatar_dir)
20838                    .map_err(|e| AdminError::Upload(format!("create avatar dir: {e}")))?;
20839                let storage_name = format!("{uid}.{ext}");
20840                let path = avatar_dir.join(&storage_name);
20841                std::fs::write(&path, &bytes)
20842                    .map_err(|e| AdminError::Upload(format!("write avatar: {e}")))?;
20843                new_avatar_path = Some(storage_name);
20844            }
20845            _ => {
20846                let _ = field.bytes().await;
20847            }
20848        }
20849    }
20850
20851    // Reload the user row + merge changes into `.data`. Using the
20852    // pool fetch (rather than mutating the extracted `viewer`) keeps
20853    // the save isolated from any session-cache invariants.
20854    let mut user_rows: Vec<rustango::tenancy::auth::User> =
20855        rustango::tenancy::auth::User::objects()
20856            .where_(rustango::tenancy::auth::User::id.eq(uid))
20857            .fetch(tenant.pool())
20858            .await?;
20859    let Some(mut user) = user_rows.pop() else {
20860        return Ok((axum::http::StatusCode::NOT_FOUND, "user not found").into_response());
20861    };
20862
20863    let mut data = user.data.as_object().cloned().unwrap_or_default();
20864    if let Some(name) = new_display_name {
20865        if name.is_empty() {
20866            data.remove("display_name");
20867        } else {
20868            data.insert("display_name".to_owned(), serde_json::json!(name));
20869        }
20870    }
20871    if let Some(path) = new_avatar_path {
20872        data.insert("avatar_path".to_owned(), serde_json::json!(path));
20873    }
20874    user.data = serde_json::Value::Object(data);
20875    user.save_pool(tenant.pool()).await?;
20876
20877    redirect_named_with_message(
20878        "rcms-admin:account",
20879        MsgLevel::Success,
20880        "Profile saved.",
20881        &headers,
20882    )
20883}
20884
20885/// Persist an editor's preferred admin UI locale to
20886/// `rustango_users.data.admin_lang`. Shared by the account-prefs form and
20887/// the sidebar switcher so both keep the durable pref in sync with the cookie.
20888async fn persist_user_admin_lang(
20889    pool: &rustango::sql::Pool,
20890    uid: i64,
20891    lang: &str,
20892) -> Result<(), AdminError> {
20893    let mut rows: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
20894        .where_(rustango::tenancy::auth::User::id.eq(uid))
20895        .fetch(pool)
20896        .await?;
20897    if let Some(mut user) = rows.pop() {
20898        let mut data = user.data.as_object().cloned().unwrap_or_default();
20899        data.insert("admin_lang".to_owned(), serde_json::json!(lang));
20900        user.data = serde_json::Value::Object(data);
20901        user.save_pool(pool).await?;
20902    }
20903    Ok(())
20904}
20905
20906/// Form body for `POST /cms-admin/me/language`.
20907#[derive(Debug, Deserialize)]
20908pub struct AccountLanguageForm {
20909    pub lang: String,
20910}
20911
20912/// POST /cms-admin/me/language — set the editor's preferred admin UI locale.
20913/// Persists to `rustango_users.data.admin_lang` (durable + cross-device,
20914/// folded into negotiation by `add_user_chrome` → `render_with_csrf`) AND sets
20915/// the sticky `rcms_admin_lang` cookie so the change applies on the next render.
20916/// An unshipped code resets to English.
20917pub async fn account_language_submit(
20918    State(_state): State<super::AdminState>,
20919    tenant: Tenant,
20920    headers: HeaderMap,
20921    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20922    Form(form): Form<AccountLanguageForm>,
20923) -> Result<Response, AdminError> {
20924    let Some(viewer) = session_user.as_ref() else {
20925        return Ok(unauthorized_no_session());
20926    };
20927    let Some(uid) = viewer.id.get().copied() else {
20928        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20929    };
20930    let lang = if super::i18n::is_ui_locale(&form.lang) {
20931        form.lang.clone()
20932    } else {
20933        "en".to_owned()
20934    };
20935    persist_user_admin_lang(tenant.pool(), uid, &lang).await?;
20936
20937    let mut resp = redirect_named_with_message(
20938        "rcms-admin:account",
20939        MsgLevel::Success,
20940        "Language updated.",
20941        &headers,
20942    )?;
20943    let cookie = format!(
20944        "{}={lang}; Path=/; SameSite=Lax; Max-Age=31536000",
20945        super::i18n::ADMIN_LANG_COOKIE
20946    );
20947    if let Ok(v) = HeaderValue::from_str(&cookie) {
20948        resp.headers_mut().append(header::SET_COOKIE, v);
20949    }
20950    Ok(resp)
20951}
20952
20953/// Form body for `POST /cms-admin/me/email`.
20954#[derive(Debug, Deserialize)]
20955pub struct AccountEmailForm {
20956    pub new_email: String,
20957}
20958
20959/// POST /cms-admin/me/email — request an email change.
20960///
20961/// When a mailer is wired, the change goes through a confirmation
20962/// flow: a random 32-hex token is stashed on `user.data.pending_email_*`
20963/// and the new address receives a confirm link. Clicking the link
20964/// finalizes the change.
20965///
20966/// When no mailer is wired, the change applies immediately + a banner
20967/// explains no confirmation email was sent.
20968pub async fn account_email_submit(
20969    State(state): State<super::AdminState>,
20970    tenant: Tenant,
20971    headers: HeaderMap,
20972    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20973    Form(form): Form<AccountEmailForm>,
20974) -> Result<Response, AdminError> {
20975    let Some(viewer) = session_user.as_ref() else {
20976        return Ok(unauthorized_no_session());
20977    };
20978    let Some(uid) = viewer.id.get().copied() else {
20979        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20980    };
20981
20982    let new_email = form.new_email.trim().to_owned();
20983    if new_email.is_empty() || !new_email.contains('@') {
20984        return redirect_named_with_message(
20985            "rcms-admin:account",
20986            MsgLevel::Error,
20987            "Enter a valid email address.",
20988            &headers,
20989        );
20990    }
20991
20992    let mut user = rustango::tenancy::auth::User::objects()
20993        .where_(rustango::tenancy::auth::User::id.eq(uid))
20994        .first(tenant.pool())
20995        .await?
20996        .ok_or(AdminError::NotFound(uid))?;
20997    let mut data = user.data.as_object().cloned().unwrap_or_default();
20998
20999    if state.mailer.is_none() {
21000        // No mailer → write directly + banner.
21001        data.insert("email".to_owned(), serde_json::json!(new_email));
21002        user.email = Some(new_email.clone());
21003        // Clear any in-flight confirmation token from a previous attempt.
21004        data.remove("pending_email");
21005        user.data = serde_json::Value::Object(data);
21006        user.save_pool(tenant.pool()).await?;
21007        return redirect_named_with_message(
21008            "rcms-admin:account",
21009            MsgLevel::Warning,
21010            "Email updated. No confirmation email was sent — the host hasn't wired a mailer.",
21011            &headers,
21012        );
21013    }
21014
21015    // Stash the pending email so the editor sees a banner + the
21016    // confirm handler can replay-guard against a different change
21017    // having kicked off in the meantime. Drop legacy keys from the
21018    // previous hand-rolled token scheme so they don't shadow the
21019    // new flow.
21020    data.insert(
21021        "pending_email".to_owned(),
21022        serde_json::json!(new_email.clone()),
21023    );
21024    data.remove("pending_email_token");
21025    data.remove("pending_email_expires_at");
21026    user.data = serde_json::Value::Object(data);
21027    user.save_pool(tenant.pool()).await?;
21028
21029    // Send the confirmation. Best-effort. The signed URL carries
21030    // user_id + email + TTL — `EmailVerification::verify` on the
21031    // confirm endpoint replaces the hand-rolled (token, expires_at)
21032    // round-trip we used to stash in user.data.
21033    if let Some(mailer) = state.mailer.as_deref() {
21034        let link = rustango::auth_flows::EmailVerification::issue(
21035            &rustango::auth_flows::LinkScope::from(&tenant),
21036            "/cms-admin/me/email/confirm",
21037            uid,
21038            &new_email,
21039            state.signing_secret.as_slice(),
21040            std::time::Duration::from_secs(3600),
21041        );
21042        let subject = "Confirm your CMS email change";
21043        let body = format!(
21044            "Click the link below to confirm your CMS email change to {new_email}.\n\nLink: {link}\n\nThe link expires in one hour. If you didn't request this change, ignore this email.\n",
21045        );
21046        let email = rustango::email::Email::new()
21047            .from((*state.mailer_from).clone())
21048            .to(new_email.clone())
21049            .subject(subject.to_owned())
21050            .body(body);
21051        if let Err(e) = mailer.send(&email).await {
21052            tracing::warn!(
21053                target: "rustango_cms::admin::account",
21054                user_id = uid, error = %e,
21055                "email-change confirmation send failed (pending_email stashed; user can re-request)"
21056            );
21057        }
21058    }
21059
21060    redirect_named_with_message(
21061        "rcms-admin:account",
21062        MsgLevel::Success,
21063        "Confirmation link sent to the new email. Click it within an hour to finalize the change.",
21064        &headers,
21065    )
21066}
21067
21068/// GET /cms-admin/me/email/confirm — verify the signed URL from
21069/// [`account_email_submit`] (`EmailVerification::verify`) and apply
21070/// the pending email change. The URL itself carries user_id + new
21071/// email + TTL signature — we just check the click came from the
21072/// account that started the change and that the change is still
21073/// the one the user wants to apply.
21074pub async fn account_email_confirm(
21075    State(state): State<super::AdminState>,
21076    tenant: Tenant,
21077    headers: HeaderMap,
21078    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
21079    axum::extract::OriginalUri(uri): axum::extract::OriginalUri,
21080) -> Result<Response, AdminError> {
21081    let Some(viewer) = session_user.as_ref() else {
21082        return Ok(unauthorized_no_session());
21083    };
21084    let Some(uid) = viewer.id.get().copied() else {
21085        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
21086    };
21087
21088    let path_and_query = uri
21089        .path_and_query()
21090        .map(|p| p.as_str())
21091        .unwrap_or_default()
21092        .to_owned();
21093    let (token_uid, signed_email) = match rustango::auth_flows::EmailVerification::verify(
21094        &rustango::auth_flows::LinkScope::from(&tenant),
21095        &path_and_query,
21096        state.signing_secret.as_slice(),
21097    ) {
21098        Ok(pair) => pair,
21099        Err(_) => {
21100            return redirect_named_with_message(
21101                "rcms-admin:account",
21102                MsgLevel::Error,
21103                "Confirmation link is invalid or has expired. Request a new one.",
21104                &headers,
21105            );
21106        }
21107    };
21108    // Clicking your own confirm link from a different session is a
21109    // common case (verify from inbox on phone, signed in on
21110    // desktop). We require the session user to match the user_id
21111    // baked into the signed URL — anything else is a cross-account
21112    // hijack attempt.
21113    if token_uid != uid {
21114        return redirect_named_with_message(
21115            "rcms-admin:account",
21116            MsgLevel::Error,
21117            "Confirmation link belongs to a different account. Sign in as that account to confirm.",
21118            &headers,
21119        );
21120    }
21121
21122    let mut user = rustango::tenancy::auth::User::objects()
21123        .where_(rustango::tenancy::auth::User::id.eq(uid))
21124        .first(tenant.pool())
21125        .await?
21126        .ok_or(AdminError::NotFound(uid))?;
21127    let mut data = user.data.as_object().cloned().unwrap_or_default();
21128    // Stale-link guard: if the user kicked off a different change
21129    // since this link was minted (or none at all), reject — the
21130    // signed URL is still valid but no longer the one they want.
21131    let pending = data
21132        .get("pending_email")
21133        .and_then(|v| v.as_str())
21134        .unwrap_or("");
21135    if pending != signed_email {
21136        return redirect_named_with_message(
21137            "rcms-admin:account",
21138            MsgLevel::Error,
21139            "This link is for a different email change than the one currently pending. Request a fresh confirmation.",
21140            &headers,
21141        );
21142    }
21143
21144    data.insert("email".to_owned(), serde_json::json!(signed_email));
21145    user.email = Some(signed_email.clone());
21146    data.remove("pending_email");
21147    // Keys the earlier email-change flow stored — dropped on confirm so
21148    // old rows clean themselves up.
21149    data.remove("pending_email_token");
21150    data.remove("pending_email_expires_at");
21151    user.data = serde_json::Value::Object(data);
21152    user.save_pool(tenant.pool()).await?;
21153
21154    redirect_named_with_message(
21155        "rcms-admin:account",
21156        MsgLevel::Success,
21157        "Email confirmed. Notifications go to the new address from now on.",
21158        &headers,
21159    )
21160}
21161
21162/// Form body for `POST /cms-admin/me/password`.
21163#[derive(Deserialize)]
21164pub struct AccountPasswordForm {
21165    pub current_password: String,
21166    pub new_password: String,
21167    pub new_password_confirm: String,
21168}
21169
21170/// POST /cms-admin/me/password — verify current password, hash + write
21171/// the new one.
21172pub async fn account_password_submit(
21173    State(_state): State<super::AdminState>,
21174    tenant: Tenant,
21175    headers: HeaderMap,
21176    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
21177    Form(form): Form<AccountPasswordForm>,
21178) -> Result<Response, AdminError> {
21179    let Some(viewer) = session_user.as_ref() else {
21180        return Ok(unauthorized_no_session());
21181    };
21182    let Some(uid) = viewer.id.get().copied() else {
21183        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
21184    };
21185    if form.new_password.len() < 12 {
21186        return redirect_named_with_message(
21187            "rcms-admin:account",
21188            MsgLevel::Error,
21189            "New password must be at least 12 characters.",
21190            &headers,
21191        );
21192    }
21193    if form.new_password != form.new_password_confirm {
21194        return redirect_named_with_message(
21195            "rcms-admin:account",
21196            MsgLevel::Error,
21197            "New password and confirmation don't match.",
21198            &headers,
21199        );
21200    }
21201
21202    let mut user = rustango::tenancy::auth::User::objects()
21203        .where_(rustango::tenancy::auth::User::id.eq(uid))
21204        .first(tenant.pool())
21205        .await?
21206        .ok_or(AdminError::NotFound(uid))?;
21207
21208    let verified =
21209        crate::passwords::verify(&form.current_password, &user.password_hash).await.unwrap_or(false);
21210    if !verified {
21211        return redirect_named_with_message(
21212            "rcms-admin:account",
21213            MsgLevel::Error,
21214            "Current password is incorrect.",
21215            &headers,
21216        );
21217    }
21218    let hash = crate::passwords::hash(&form.new_password).await
21219        .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
21220    user.password_hash = hash;
21221    user.password_changed_at = Some(chrono::Utc::now());
21222    user.save_pool(tenant.pool()).await?;
21223
21224    redirect_named_with_message(
21225        "rcms-admin:account",
21226        MsgLevel::Success,
21227        "Password changed. Old sessions on other devices will be signed out on next request.",
21228        &headers,
21229    )
21230}
21231
21232/// GET /__cms-avatar/{user_id} — stream the user's avatar bytes.
21233/// Anonymous-OK so the sidebar avatar shows on the dashboard
21234/// pre-login. Image not found → 404.
21235pub async fn account_avatar_serve(
21236    headers: HeaderMap,
21237    tenant: Tenant,
21238    Path(user_id): Path<i64>,
21239) -> Response {
21240    let user_rows: Vec<rustango::tenancy::auth::User> =
21241        match rustango::tenancy::auth::User::objects()
21242            .where_(rustango::tenancy::auth::User::id.eq(user_id))
21243            .fetch(tenant.pool())
21244            .await
21245        {
21246            Ok(v) => v,
21247            Err(_) => {
21248                return (
21249                    axum::http::StatusCode::INTERNAL_SERVER_ERROR,
21250                    "user lookup failed",
21251                )
21252                    .into_response();
21253            }
21254        };
21255    let Some(user) = user_rows.into_iter().next() else {
21256        return (axum::http::StatusCode::NOT_FOUND, "user not found").into_response();
21257    };
21258    let storage_name = match user.data.get("avatar_path").and_then(|v| v.as_str()) {
21259        Some(s) if !s.is_empty() => s.to_owned(),
21260        _ => return (axum::http::StatusCode::NOT_FOUND, "no avatar").into_response(),
21261    };
21262    if storage_name.contains('/') || storage_name.contains("..") {
21263        return (axum::http::StatusCode::BAD_REQUEST, "invalid storage name").into_response();
21264    }
21265    // Tenant-scoped path (matches the upload) — never read another
21266    // tenant's avatar dir.
21267    let path = std::path::PathBuf::from("./var/avatars")
21268        .join(&tenant.org.slug)
21269        .join(&storage_name);
21270    let bytes = match std::fs::read(&path) {
21271        Ok(b) => b,
21272        Err(_) => {
21273            return (axum::http::StatusCode::NOT_FOUND, "avatar bytes missing").into_response()
21274        }
21275    };
21276    let mime = mime_guess::from_path(&storage_name)
21277        .first_or_octet_stream()
21278        .essence_str()
21279        .to_owned();
21280    // Same stable-URL staleness fix as branding: revalidate via a
21281    // content ETag so a changed avatar is picked up immediately.
21282    revalidated_asset(&headers, mime, bytes)
21283}
21284
21285pub async fn cms_login_form(
21286    State(state): State<super::AdminState>,
21287    headers: HeaderMap,
21288    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21289    tenant: Tenant,
21290    Query(q): Query<std::collections::HashMap<String, String>>,
21291) -> Result<Response, AdminError> {
21292    let mut ctx = Context::new();
21293    // The framework's POST handler expects to receive the form at
21294    // `/login`. Set the action to a relative URL so the same shape
21295    // works under reverse proxies.
21296    ctx.insert("action", &"/login");
21297    ctx.insert("admin_title", &"CMS Admin");
21298    // #279 — make sure the CMS-branded login form always carries a
21299    // `next` destination so the framework's POST handler doesn't
21300    // fall back to `/` (the public homepage). Precedence:
21301    //   1. Explicit `?next=` (passed in by `with_login_required`
21302    //      when an anonymous request hit an admin URL).
21303    //   2. Default `/cms-admin/` when the user navigated to /login
21304    //      manually — they almost certainly want the admin, not
21305    //      the public site root.
21306    // The framework's `sanitize_next` rejects open-redirect-shaped
21307    // values (anything not starting with a single `/`, scheme-bearing,
21308    // or pointing back at /login itself), so we don't need to filter
21309    // here; the worst case is the framework strips ours and uses `/`.
21310    let next = q
21311        .get("next")
21312        .map(String::as_str)
21313        .filter(|s| !s.is_empty())
21314        .unwrap_or("/cms-admin/");
21315    ctx.insert("next", next);
21316    // Friendly error from a redirect (e.g. `?error=invalid_credentials`).
21317    if let Some(err) = q.get("error") {
21318        ctx.insert("error", err);
21319    }
21320    // SSO (admin-sso) — one "Sign in with <provider>" button per enabled
21321    // `SsoProvider` row (the DB-backed, admin-managed, multi-provider model
21322    // that replaced the flat `Org.sso_*` columns). The framework serves
21323    // `/login/sso/{slug}` + `/login/sso/{slug}/callback` (mints the same
21324    // rustango_tenant_session cookie password login does), so no auth code
21325    // lives here — just the buttons. Mirrors the framework's own login context.
21326    let sso_providers = rustango::admin::sso_provider::list_enabled(tenant.pool(), "/login").await;
21327    ctx.insert("sso_enabled", &!sso_providers.is_empty());
21328    ctx.insert("sso_providers", &sso_providers);
21329    // Surface the callback's failure reason (it redirects with `?sso_error=...`).
21330    if let Some(err) = q.get("sso_error") {
21331        ctx.insert("sso_error", err);
21332    }
21333    // #199 — show the tenant's uploaded logo/favicon in the login brand badge
21334    // (falls back to the default icon when none is set). Same source as the
21335    // authenticated sidebar; the `/__cms-branding/*` routes are pre-auth.
21336    add_branding_urls(&mut ctx, &tenant).await;
21337    render_with_csrf(&state, &headers, "login.html", &mut ctx)
21338}
21339
21340/// GET `/cms-admin/password-reset` — show the username form.
21341pub async fn password_reset_request_form(
21342    State(state): State<super::AdminState>,
21343    headers: HeaderMap,
21344    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21345) -> Result<Response, AdminError> {
21346    let mut ctx = Context::new();
21347    render_with_csrf(
21348        &state,
21349        &headers,
21350        "rcms_admin/password_reset_request.html",
21351        &mut ctx,
21352    )
21353}
21354
21355/// POST `/cms-admin/password-reset` — issue a token, email the link,
21356/// render the "check your email" page either way (so the form never
21357/// confirms or denies account existence).
21358/// The key a password-reset link is signed with: the process secret
21359/// narrowed to one tenant and one password.
21360///
21361/// Tenants number their users from 1, so a link signed with the process
21362/// secret alone — which names only `user_id` — resets the same id on every
21363/// tenant. Binding the tenant slug makes a link verify only where it was
21364/// issued; binding the current password hash makes it die the moment the
21365/// password changes, so it is single-use without any cache.
21366/// The scope stamped on a reset link: the link only verifies on the tenant
21367/// it was issued for, alongside the tenant-bound key.
21368fn password_reset_scope(tenant_slug: &str) -> rustango::auth_flows::LinkScope {
21369    rustango::auth_flows::LinkScope::audience(&format!("rcms-reset:{tenant_slug}"))
21370}
21371
21372fn password_reset_key(secret: &[u8], tenant_slug: &str, password_hash: &str) -> Vec<u8> {
21373    let msg = format!("rcms-password-reset\0{tenant_slug}\0{password_hash}");
21374    crate::signing::hmac_sha256_hex(secret, msg.as_bytes()).into_bytes()
21375}
21376
21377/// The relative reset link (`/cms-admin/password-reset/confirm?…`) for
21378/// `user`, valid for an hour. Signed with a key bound to the tenant and
21379/// the user's current password hash, so it stops working once used.
21380fn password_reset_url(
21381    secret: &[u8],
21382    tenant_slug: &str,
21383    user: &rustango::tenancy::auth::User,
21384) -> String {
21385    let key = password_reset_key(secret, tenant_slug, &user.password_hash);
21386    rustango::auth_flows::PasswordReset::issue(
21387        &password_reset_scope(tenant_slug),
21388        "/cms-admin/password-reset/confirm",
21389        user.id.get().copied().unwrap_or(0),
21390        &key,
21391        std::time::Duration::from_secs(3600),
21392    )
21393}
21394
21395/// A one-hour password-reset link for the active user `username` in the
21396/// tenant `pool` belongs to, or `None` when there is no such user.
21397///
21398/// For operators: it works for an account with no email on file, which
21399/// the reset form cannot reach. The link is relative — prefix the site's
21400/// origin. It is valid on any admin router of this process, which signs
21401/// with the same [`crate::signing::secret`].
21402///
21403/// # Errors
21404/// Database errors from the user lookup.
21405pub async fn issue_password_reset_link(
21406    pool: &rustango::sql::Pool,
21407    tenant_slug: &str,
21408    username: &str,
21409) -> Result<Option<String>, rustango::sql::ExecError> {
21410    let user: Option<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
21411        .where_(rustango::tenancy::auth::User::username.eq(username.to_owned()))
21412        .where_(rustango::tenancy::auth::User::active.eq(true))
21413        .fetch(pool)
21414        .await?
21415        .into_iter()
21416        .next();
21417    let secret = crate::signing::derived_key(super::PASSWORD_RESET_KEY_PURPOSE);
21418    Ok(user.map(|u| password_reset_url(&secret, tenant_slug, &u)))
21419}
21420
21421/// The active user a reset link was issued for, in this request's tenant.
21422///
21423/// The `user_id` in the link is read before it is trusted only to find
21424/// whose key to verify against; the link is accepted solely when it
21425/// verifies under that user's tenant- and password-bound key.
21426async fn password_reset_user(
21427    tenant: &Tenant,
21428    secret: &[u8],
21429    signed_url: &str,
21430) -> Option<rustango::tenancy::auth::User> {
21431    let claimed: i64 = signed_url
21432        .split_once('?')?
21433        .1
21434        .split('&')
21435        .find_map(|kv| kv.strip_prefix("user_id="))?
21436        .parse()
21437        .ok()?;
21438    let user = rustango::tenancy::auth::User::objects()
21439        .where_(rustango::tenancy::auth::User::id.eq(claimed))
21440        .where_(rustango::tenancy::auth::User::active.eq(true))
21441        .first(tenant.pool())
21442        .await
21443        .ok()??;
21444    let key = password_reset_key(secret, &tenant.org.slug, &user.password_hash);
21445    match rustango::auth_flows::PasswordReset::verify(
21446        &password_reset_scope(&tenant.org.slug),
21447        signed_url,
21448        &key,
21449    ) {
21450        Ok(uid) if uid == claimed => Some(user),
21451        _ => None,
21452    }
21453}
21454
21455pub async fn password_reset_request_submit(
21456    State(state): State<super::AdminState>,
21457    tenant: Tenant,
21458    headers: HeaderMap,
21459    request: crate::security_log::LoginRequest,
21460    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21461    Form(form): Form<std::collections::HashMap<String, String>>,
21462) -> Result<Response, AdminError> {
21463    let username = form.get("username").cloned().unwrap_or_default();
21464    if !username.trim().is_empty() {
21465        // Look up the rustango_users row by username. Active users
21466        // only; soft-disabled accounts get the same silent treatment
21467        // as missing ones.
21468        let user: Option<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
21469            .where_(rustango::tenancy::auth::User::username.eq(username.clone()))
21470            .where_(rustango::tenancy::auth::User::active.eq(true))
21471            .fetch(tenant.pool())
21472            .await
21473            .unwrap_or_default()
21474            .into_iter()
21475            .next();
21476        if let Some(u) = user {
21477            let entry = SecurityEntry::new(
21478                crate::security_log::EVENT_PASSWORD_RESET_REQUESTED,
21479                "admin",
21480                &request.meta,
21481            )
21482            .user(u.id.get().copied(), &u.username);
21483            crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
21484            // The link goes to the user's real address. The response below
21485            // renders "sent" either way, so the form never confirms or
21486            // denies that an account exists.
21487            let token_url =
21488                password_reset_url(state.signing_secret.as_slice(), &tenant.org.slug, &u);
21489            let to_email = Some(user_email(&u)).filter(|e| !e.is_empty());
21490            match (to_email, state.mailer.is_some()) {
21491                (Some(to), _) => {
21492                    send_reset_email(
21493                        state.mailer.as_deref(),
21494                        &state.mailer_from,
21495                        &to,
21496                        &u.username,
21497                        &token_url,
21498                    )
21499                    .await;
21500                }
21501                // No mailer: emails already go to stdout, which the page
21502                // tells the reader to check — so print the link there for
21503                // the operator too, rather than nothing at all.
21504                (None, false) => {
21505                    println!(
21506                        "============= password reset =============\n\
21507                         {} has no email on file. Reset link, valid for an hour \
21508                         (prefix the site's address):\n{token_url}\n\
21509                         ==========================================",
21510                        u.username
21511                    );
21512                    tracing::warn!(
21513                        username = %u.username,
21514                        "password reset for an account with no email: link printed to stdout"
21515                    );
21516                }
21517                (None, true) => {
21518                    tracing::warn!(
21519                        username = %u.username,
21520                        "password reset requested but the account has no email on file; nothing \
21521                         sent. Add an email to the account, or issue a link with \
21522                         rustango_cms::admin::issue_password_reset_link"
21523                    );
21524                }
21525            }
21526        }
21527    }
21528    let mut ctx = Context::new();
21529    // The stdout hint is only true when no mailer is wired.
21530    ctx.insert("console_mail", &state.mailer.is_none());
21531    render_with_csrf(
21532        &state,
21533        &headers,
21534        "rcms_admin/password_reset_sent.html",
21535        &mut ctx,
21536    )
21537}
21538
21539/// GET `/cms-admin/password-reset/confirm` — verify the signed token
21540/// in the URL, render the new-password form when valid. Invalid /
21541/// expired links land on a friendly error inside the same template.
21542pub async fn password_reset_confirm_form(
21543    State(state): State<super::AdminState>,
21544    tenant: Tenant,
21545    headers: HeaderMap,
21546    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21547    axum::extract::OriginalUri(uri): axum::extract::OriginalUri,
21548) -> Result<Response, AdminError> {
21549    let path_and_query = uri
21550        .path_and_query()
21551        .map(|p| p.as_str())
21552        .unwrap_or_default()
21553        .to_owned();
21554    let mut ctx = Context::new();
21555    match password_reset_user(&tenant, state.signing_secret.as_slice(), &path_and_query).await {
21556        Some(_) => {
21557            // Pass the signed URL through so the POST handler can
21558            // re-verify before writing the new password.
21559            ctx.insert("signed_token", &path_and_query);
21560            render_with_csrf(
21561                &state,
21562                &headers,
21563                "rcms_admin/password_reset_confirm.html",
21564                &mut ctx,
21565            )
21566        }
21567        None => {
21568            ctx.insert(
21569                "error",
21570                &"This reset link is invalid or has expired. Request a fresh one.",
21571            );
21572            render_with_csrf(
21573                &state,
21574                &headers,
21575                "rcms_admin/password_reset_request.html",
21576                &mut ctx,
21577            )
21578        }
21579    }
21580}
21581
21582/// POST `/cms-admin/password-reset/confirm` — verify the token + new
21583/// password fields, hash the password, write to `rustango_users`,
21584/// render the "all set" page.
21585pub async fn password_reset_confirm_submit(
21586    State(state): State<super::AdminState>,
21587    tenant: Tenant,
21588    headers: HeaderMap,
21589    request: crate::security_log::LoginRequest,
21590    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21591    Form(form): Form<std::collections::HashMap<String, String>>,
21592) -> Result<Response, AdminError> {
21593    let token = form.get("token").cloned().unwrap_or_default();
21594    let password = form.get("password").cloned().unwrap_or_default();
21595    let password_confirm = form.get("password_confirm").cloned().unwrap_or_default();
21596
21597    let mut ctx = Context::new();
21598    let render_confirm_with_error = |state: &super::AdminState,
21599                                     headers: &HeaderMap,
21600                                     token: &str,
21601                                     msg: &str|
21602     -> Result<Response, AdminError> {
21603        let mut c = Context::new();
21604        c.insert("signed_token", &token);
21605        c.insert("error", &msg);
21606        render_with_csrf(
21607            state,
21608            headers,
21609            "rcms_admin/password_reset_confirm.html",
21610            &mut c,
21611        )
21612    };
21613
21614    if password.len() < 12 {
21615        return render_confirm_with_error(
21616            &state,
21617            &headers,
21618            &token,
21619            "Password must be at least 12 characters.",
21620        );
21621    }
21622    if password != password_confirm {
21623        return render_confirm_with_error(
21624            &state,
21625            &headers,
21626            &token,
21627            "Password confirmation didn't match.",
21628        );
21629    }
21630
21631    // Tenant- and password-bound (#673): a link from another tenant, or one
21632    // already used to change this password, does not verify.
21633    let Some(mut user) = password_reset_user(&tenant, state.signing_secret.as_slice(), &token).await
21634    else {
21635        ctx.insert(
21636            "error",
21637            &"This reset link is invalid or has expired. Request a fresh one.",
21638        );
21639        return render_with_csrf(
21640            &state,
21641            &headers,
21642            "rcms_admin/password_reset_request.html",
21643            &mut ctx,
21644        );
21645    };
21646    let new_hash = match crate::passwords::hash(&password).await {
21647        Ok(h) => h,
21648        Err(e) => {
21649            tracing::warn!(error = %e, "password hash failed");
21650            return render_confirm_with_error(
21651                &state,
21652                &headers,
21653                &token,
21654                "Could not save the new password. Try again.",
21655            );
21656        }
21657    };
21658    user.password_hash = new_hash;
21659    if user.save_pool(tenant.pool()).await.is_err() {
21660        return render_confirm_with_error(
21661            &state,
21662            &headers,
21663            &token,
21664            "Could not save the new password. Try again.",
21665        );
21666    }
21667    // Proving control of the account's mail lifts a lock a guesser set.
21668    crate::security_log::unlock(&tenant.org.slug, &user.username).await;
21669    let entry = SecurityEntry::new(crate::security_log::EVENT_PASSWORD_RESET, "admin", &request.meta)
21670        .user(user.id.get().copied(), &user.username);
21671    crate::security_log::record(tenant.pool(), &tenant.org.slug, entry).await;
21672
21673    render_with_csrf(
21674        &state,
21675        &headers,
21676        "rcms_admin/password_reset_done.html",
21677        &mut ctx,
21678    )
21679}
21680
21681/// Send the reset email via `ConsoleMailer`. Prints the URL to stdout
21682/// in dev; production deployments swap in `SmtpMailer` here.
21683///
21684/// The `rustango_users` table doesn't carry an email column, so the
21685/// "to" address is synthesized from the username for now. Replace
21686/// with `user.email` once the host extends the user model.
21687/// Deliver the reset link to the user's real address through
21688/// the host-configured mailer (`router_with_mailer`), falling back to
21689/// the console mailer in dev setups with no mailer wired.
21690async fn send_reset_email(
21691    mailer: Option<&dyn rustango::email::Mailer>,
21692    mailer_from: &str,
21693    to_email: &str,
21694    username: &str,
21695    reset_url: &str,
21696) {
21697    let from = if mailer_from.trim().is_empty() {
21698        "noreply@cms.local"
21699    } else {
21700        mailer_from
21701    };
21702    let email = rustango::email::Email::new()
21703        .to(to_email)
21704        .from(from)
21705        .subject("Reset your CMS password")
21706        .body(format!(
21707            "Hi {username},\n\n\
21708             We received a request to reset your CMS password.\n\
21709             Click the link below within the next hour to set a new one:\n\n\
21710             {reset_url}\n\n\
21711             If you didn't request this, you can safely ignore this email.\n"
21712        ));
21713    let result = match mailer {
21714        Some(m) => m.send(&email).await,
21715        None => {
21716            let console = rustango::email::ConsoleMailer;
21717            <rustango::email::ConsoleMailer as rustango::email::Mailer>::send(&console, &email)
21718                .await
21719        }
21720    };
21721    if let Err(e) = result {
21722        tracing::warn!(error = %e, username = %username, "password-reset mail send failed");
21723    }
21724    tracing::info!(username = %username, "issued password-reset link");
21725}
21726
21727#[cfg(test)]
21728mod tests {
21729    //! Role-permission matrix translation tests. Exercise the
21730    //! pure helpers — no DB, no Tera.
21731    use super::*;
21732
21733    fn reset_user(password_hash: &str) -> rustango::tenancy::auth::User {
21734        rustango::tenancy::auth::User {
21735            id: rustango::sql::Auto::Set(7),
21736            username: "admin".to_owned(),
21737            password_hash: password_hash.to_owned(),
21738            email: None,
21739            is_superuser: true,
21740            active: true,
21741            created_at: chrono::Utc::now(),
21742            data: serde_json::json!({}),
21743            password_changed_at: None,
21744            sessions_revoked_at: None,
21745        }
21746    }
21747
21748    /// The link an operator gets (or the console prints for an account
21749    /// with no email) is the one the confirm page accepts — and it dies
21750    /// once the password changes.
21751    #[test]
21752    fn a_reset_link_verifies_until_the_password_changes() {
21753        let secret = b"test-secret";
21754        let url = password_reset_url(secret, "blog", &reset_user("hash-1"));
21755        assert!(url.starts_with("/cms-admin/password-reset/confirm?user_id=7&"), "{url}");
21756        let key = password_reset_key(secret, "blog", "hash-1");
21757        let blog = password_reset_scope("blog");
21758        assert_eq!(rustango::auth_flows::PasswordReset::verify(&blog, &url, &key).ok(), Some(7));
21759        let after_change = password_reset_key(secret, "blog", "hash-2");
21760        assert!(rustango::auth_flows::PasswordReset::verify(&blog, &url, &after_change).is_err());
21761        let other_tenant = password_reset_key(secret, "shop", "hash-1");
21762        let shop = password_reset_scope("shop");
21763        assert!(rustango::auth_flows::PasswordReset::verify(&shop, &url, &other_tenant).is_err());
21764    }
21765
21766    #[test]
21767    fn parse_matrix_form_translates_brackets_to_codenames() {
21768        let mut form = std::collections::HashMap::new();
21769        form.insert("name".to_owned(), "Editor".to_owned());
21770        form.insert("perm[pages][view]".to_owned(), "1".to_owned());
21771        form.insert("perm[pages][add]".to_owned(), "1".to_owned());
21772        form.insert("perm[pages][edit]".to_owned(), "1".to_owned());
21773        // Unchecked → not present in the form. View-only.
21774        form.insert("perm[history][view]".to_owned(), "1".to_owned());
21775        // Inapplicable cell — `history` doesn't accept `edit`. Must be
21776        // dropped silently.
21777        form.insert("perm[history][edit]".to_owned(), "1".to_owned());
21778        // Off-state checkbox shouldn't produce a grant.
21779        form.insert("perm[redirects][delete]".to_owned(), "0".to_owned());
21780        // Unknown resource key — dropped.
21781        form.insert("perm[bogus][view]".to_owned(), "1".to_owned());
21782        // Malformed key — dropped.
21783        form.insert("perm[pages]".to_owned(), "1".to_owned());
21784
21785        let codenames = parse_matrix_form(&form);
21786        assert!(codenames.contains(&"cms_page.view".to_owned()));
21787        assert!(codenames.contains(&"cms_page.add".to_owned()));
21788        assert!(codenames.contains(&"cms_page.edit".to_owned()));
21789        assert!(codenames.contains(&"cms_history.view".to_owned()));
21790        assert!(!codenames.contains(&"cms_history.edit".to_owned()));
21791        assert!(!codenames.contains(&"cms_redirect.delete".to_owned()));
21792        // No bogus / malformed leakage.
21793        assert!(!codenames.iter().any(|c| c.contains("bogus")));
21794    }
21795
21796    #[test]
21797    fn split_matrix_codenames_isolates_legacy() {
21798        let granted = vec![
21799            "cms_page.view".to_owned(),
21800            "cms_page.edit".to_owned(),
21801            "rustango_roles.view".to_owned(),
21802            "acme_custom.do_thing".to_owned(),
21803            "free_form_string".to_owned(),
21804        ];
21805        let (matched, legacy) = split_matrix_codenames(&granted);
21806        assert!(matched.contains(&"cms_page.view".to_owned()));
21807        assert!(matched.contains(&"cms_page.edit".to_owned()));
21808        assert!(matched.contains(&"rustango_roles.view".to_owned()));
21809        assert!(legacy.contains(&"acme_custom.do_thing".to_owned()));
21810        assert!(legacy.contains(&"free_form_string".to_owned()));
21811    }
21812
21813    #[test]
21814    fn build_permission_matrix_marks_granted_cells() {
21815        let granted = vec![
21816            "cms_page.view".to_owned(),
21817            "cms_page.add".to_owned(),
21818            "cms_media.view".to_owned(),
21819        ];
21820        let matrix = build_permission_matrix(&granted);
21821        let arr = matrix.as_array().expect("matrix is an array of sections");
21822        // Find the Content section → Pages row → granted list.
21823        let pages_row = arr
21824            .iter()
21825            .flat_map(|s| s["rows"].as_array().unwrap().iter())
21826            .find(|r| r["key"] == "pages")
21827            .expect("pages row present");
21828        let granted_actions: Vec<&str> = pages_row["granted"]
21829            .as_array()
21830            .unwrap()
21831            .iter()
21832            .map(|v| v.as_str().unwrap())
21833            .collect();
21834        assert!(granted_actions.contains(&"view"));
21835        assert!(granted_actions.contains(&"add"));
21836        assert!(!granted_actions.contains(&"edit"));
21837        assert!(!granted_actions.contains(&"delete"));
21838    }
21839
21840    #[test]
21841    fn round_trip_form_to_codenames_to_matrix() {
21842        // Submit a matrix; reverse-render it; expect every checked cell
21843        // to come back as `granted`.
21844        let mut form = std::collections::HashMap::new();
21845        form.insert("perm[pages][view]".to_owned(), "1".to_owned());
21846        form.insert("perm[pages][publish]".to_owned(), "1".to_owned());
21847        form.insert("perm[media][view]".to_owned(), "1".to_owned());
21848        let codenames = parse_matrix_form(&form);
21849        let matrix = build_permission_matrix(&codenames);
21850
21851        let pages = matrix
21852            .as_array()
21853            .unwrap()
21854            .iter()
21855            .flat_map(|s| s["rows"].as_array().unwrap().iter())
21856            .find(|r| r["key"] == "pages")
21857            .unwrap();
21858        let granted: Vec<&str> = pages["granted"]
21859            .as_array()
21860            .unwrap()
21861            .iter()
21862            .map(|v| v.as_str().unwrap())
21863            .collect();
21864        assert_eq!(granted, vec!["view", "publish"]);
21865    }
21866
21867    // -------- #117 InlinePanel extractor --------
21868
21869    fn sample_spec() -> crate::page_type::InlinePanelSpec {
21870        crate::page_type::InlinePanelSpec::new(
21871            "team",
21872            "Team",
21873            vec![
21874                crate::page_type::ExtensionField {
21875                    name: "name".to_owned(),
21876                    label: "Name".to_owned(),
21877                    kind: crate::page_type::ExtensionFieldKind::Text,
21878                    value: String::new(),
21879                    help: String::new(),
21880                    max_length: None,
21881                },
21882                crate::page_type::ExtensionField {
21883                    name: "role".to_owned(),
21884                    label: "Role".to_owned(),
21885                    kind: crate::page_type::ExtensionFieldKind::Text,
21886                    value: String::new(),
21887                    help: String::new(),
21888                    max_length: None,
21889                },
21890            ],
21891        )
21892    }
21893
21894    #[test]
21895    fn inline_extractor_groups_by_row_index() {
21896        let spec = sample_spec();
21897        let mut form = std::collections::HashMap::new();
21898        form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21899        form.insert("inline__team__0__role".to_owned(), "Engineer".to_owned());
21900        form.insert("inline__team__1__name".to_owned(), "Bob".to_owned());
21901        form.insert("inline__team__1__role".to_owned(), "Designer".to_owned());
21902        let rows = extract_inline_panel_rows(&form, &spec);
21903        assert_eq!(rows.len(), 2);
21904        assert_eq!(rows[0]["name"], "Ada");
21905        assert_eq!(rows[1]["role"], "Designer");
21906    }
21907
21908    #[test]
21909    fn inline_extractor_drops_tombstoned_rows() {
21910        let spec = sample_spec();
21911        let mut form = std::collections::HashMap::new();
21912        form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21913        form.insert("inline__team__1__name".to_owned(), "Bob".to_owned());
21914        form.insert("inline__team__1____deleted".to_owned(), "1".to_owned());
21915        let rows = extract_inline_panel_rows(&form, &spec);
21916        assert_eq!(rows.len(), 1);
21917        assert_eq!(rows[0]["name"], "Ada");
21918    }
21919
21920    #[test]
21921    fn inline_extractor_ignores_unknown_field_names() {
21922        let spec = sample_spec();
21923        let mut form = std::collections::HashMap::new();
21924        form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21925        form.insert("inline__team__0__bogus".to_owned(), "x".to_owned());
21926        let rows = extract_inline_panel_rows(&form, &spec);
21927        assert_eq!(rows.len(), 1);
21928        assert!(!rows[0].contains_key("bogus"));
21929    }
21930
21931    #[test]
21932    fn inline_extractor_ignores_unrelated_form_keys() {
21933        let spec = sample_spec();
21934        let mut form = std::collections::HashMap::new();
21935        form.insert("title".to_owned(), "irrelevant".to_owned());
21936        form.insert("inline__other_panel__0__name".to_owned(), "x".to_owned());
21937        let rows = extract_inline_panel_rows(&form, &spec);
21938        assert!(rows.is_empty());
21939    }
21940
21941    /// The page-edit submit handler funnels the raw posted
21942    /// form through an allow-list before re-deserializing as
21943    /// `PageForm`. The bug guarded here was that schedule fields
21944    /// (`go_live_at`, `expire_at`) and `show_in_menus` were missing
21945    /// from that allow-list, so any datetime the editor set on the
21946    /// Promote tab was silently dropped on save — and never made it
21947    /// to the scheduled-pages report. Lock these in so a future
21948    /// trim of the array can't reintroduce the regression.
21949    #[test]
21950    fn page_form_canonical_keys_include_schedule_and_menu_fields() {
21951        assert!(
21952            PAGE_FORM_CANONICAL_KEYS.contains(&"go_live_at"),
21953            "go_live_at must be in canonical keys — see #268"
21954        );
21955        assert!(
21956            PAGE_FORM_CANONICAL_KEYS.contains(&"expire_at"),
21957            "expire_at must be in canonical keys — see #268"
21958        );
21959        assert!(
21960            PAGE_FORM_CANONICAL_KEYS.contains(&"show_in_menus"),
21961            "show_in_menus must be in canonical keys — see #268"
21962        );
21963    }
21964}
21965
21966#[cfg(all(test, feature = "sqlite"))]
21967mod media_picker_tests {
21968    //! `media_picker_payload` filtering / pagination / collection-tree
21969    //! tests over an in-memory sqlite pool (mirrors redirect.rs's
21970    //! `mem_pool` pattern).
21971    use super::{media_picker_payload, MediaPickerQuery};
21972    use crate::media::{Media, MediaCollection};
21973    use rustango::core::Model as _;
21974    use rustango::sql::{Auto, FetcherPool as _, Pool};
21975
21976    async fn mem_pool() -> Pool {
21977        let pool = Pool::connect("sqlite::memory:")
21978            .await
21979            .expect("in-memory sqlite");
21980        for schema in [&Media::SCHEMA, &MediaCollection::SCHEMA] {
21981            let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
21982                pool.dialect(),
21983                schema,
21984            );
21985            for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
21986                rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
21987                    .await
21988                    .expect("ddl");
21989            }
21990        }
21991        pool
21992    }
21993
21994    async fn mk_collection(pool: &Pool, name: &str, parent_id: Option<i64>, sort: i32) -> i64 {
21995        MediaCollection {
21996            id: Auto::Unset,
21997            name: name.to_owned(),
21998            parent_id,
21999            sort_order: sort,
22000            created_at: Auto::Unset,
22001        }
22002        .insert_pool(pool)
22003        .await
22004        .expect("collection insert");
22005        MediaCollection::objects()
22006            .fetch(pool)
22007            .await
22008            .expect("fetch")
22009            .into_iter()
22010            .find(|c| c.name == name)
22011            .and_then(|c| c.id.get().copied())
22012            .expect("collection id")
22013    }
22014
22015    async fn mk_media(
22016        pool: &Pool,
22017        title: &str,
22018        filename: &str,
22019        kind: &str,
22020        collection_id: Option<i64>,
22021        alt: &str,
22022    ) {
22023        Media {
22024            id: Auto::Unset,
22025            filename: filename.to_owned(),
22026            content_hash: format!("{:0>64}", title.len()),
22027            mime: if kind == "image" {
22028                "image/png"
22029            } else {
22030                "application/pdf"
22031            }
22032            .to_owned(),
22033            size: 123,
22034            kind: kind.to_owned(),
22035            width: (kind == "image").then_some(100),
22036            height: (kind == "image").then_some(80),
22037            storage_key: format!("k-{filename}"),
22038            title: title.to_owned(),
22039            alt_text: alt.to_owned(),
22040            description: String::new(),
22041            uploaded_by: None,
22042            collection_id,
22043            focal_point_x: None,
22044            focal_point_y: None,
22045            uploaded_at: Auto::Unset,
22046        }
22047        .insert_pool(pool)
22048        .await
22049        .expect("media insert");
22050    }
22051
22052    #[tokio::test]
22053    async fn default_kind_excludes_documents() {
22054        let pool = mem_pool().await;
22055        mk_media(&pool, "Photo", "p.png", "image", None, "").await;
22056        mk_media(&pool, "Spec", "s.pdf", "document", None, "").await;
22057        let body = media_picker_payload(&pool, &MediaPickerQuery::default())
22058            .await
22059            .expect("payload");
22060        let items = body["items"].as_array().expect("items");
22061        assert_eq!(items.len(), 1);
22062        assert_eq!(items[0]["kind"], "image");
22063        // kind=any opts back in.
22064        let q = MediaPickerQuery {
22065            kind: Some("any".to_owned()),
22066            ..Default::default()
22067        };
22068        let body = media_picker_payload(&pool, &q).await.expect("payload");
22069        assert_eq!(body["items"].as_array().expect("items").len(), 2);
22070    }
22071
22072    #[tokio::test]
22073    async fn collection_zero_means_uncategorized_only() {
22074        let pool = mem_pool().await;
22075        let cid = mk_collection(&pool, "Root", None, 0).await;
22076        mk_media(&pool, "In", "in.png", "image", Some(cid), "").await;
22077        mk_media(&pool, "Loose", "loose.png", "image", None, "").await;
22078        let q = MediaPickerQuery {
22079            collection: Some(0),
22080            ..Default::default()
22081        };
22082        let body = media_picker_payload(&pool, &q).await.expect("payload");
22083        let items = body["items"].as_array().expect("items");
22084        assert_eq!(items.len(), 1);
22085        assert_eq!(items[0]["title"], "Loose");
22086        assert_eq!(body["uncategorized_count"], 1);
22087        // Exact collection id narrows to its members.
22088        let q = MediaPickerQuery {
22089            collection: Some(cid),
22090            ..Default::default()
22091        };
22092        let body = media_picker_payload(&pool, &q).await.expect("payload");
22093        assert_eq!(body["items"].as_array().expect("items").len(), 1);
22094        assert_eq!(body["items"][0]["title"], "In");
22095    }
22096
22097    #[tokio::test]
22098    async fn search_matches_alt_text() {
22099        let pool = mem_pool().await;
22100        mk_media(
22101            &pool,
22102            "IMG_0001",
22103            "a.png",
22104            "image",
22105            None,
22106            "sunset glow over harbour",
22107        )
22108        .await;
22109        mk_media(&pool, "IMG_0002", "b.png", "image", None, "office desk").await;
22110        let q = MediaPickerQuery {
22111            q: Some("Sunset".to_owned()),
22112            ..Default::default()
22113        };
22114        let body = media_picker_payload(&pool, &q).await.expect("payload");
22115        let items = body["items"].as_array().expect("items");
22116        assert_eq!(items.len(), 1);
22117        assert_eq!(items[0]["title"], "IMG_0001");
22118    }
22119
22120    #[tokio::test]
22121    async fn pagination_math_and_has_more() {
22122        let pool = mem_pool().await;
22123        for i in 0..5 {
22124            mk_media(
22125                &pool,
22126                &format!("M{i}"),
22127                &format!("m{i}.png"),
22128                "image",
22129                None,
22130                "",
22131            )
22132            .await;
22133        }
22134        let q = MediaPickerQuery {
22135            limit: Some(2),
22136            offset: Some(0),
22137            ..Default::default()
22138        };
22139        let body = media_picker_payload(&pool, &q).await.expect("payload");
22140        assert_eq!(body["items"].as_array().expect("items").len(), 2);
22141        assert_eq!(body["total"], 5);
22142        assert_eq!(body["has_more"], true);
22143        let q = MediaPickerQuery {
22144            limit: Some(2),
22145            offset: Some(4),
22146            ..Default::default()
22147        };
22148        let body = media_picker_payload(&pool, &q).await.expect("payload");
22149        assert_eq!(body["items"].as_array().expect("items").len(), 1);
22150        assert_eq!(body["has_more"], false);
22151        // Offset past the end is clamped, not a panic.
22152        let q = MediaPickerQuery {
22153            limit: Some(2),
22154            offset: Some(99),
22155            ..Default::default()
22156        };
22157        let body = media_picker_payload(&pool, &q).await.expect("payload");
22158        assert_eq!(body["items"].as_array().expect("items").len(), 0);
22159    }
22160
22161    #[tokio::test]
22162    async fn collections_come_back_in_dfs_order_with_depth() {
22163        let pool = mem_pool().await;
22164        let root_a = mk_collection(&pool, "Alpha", None, 0).await;
22165        let _sub = mk_collection(&pool, "Alpha Child", Some(root_a), 0).await;
22166        let _root_b = mk_collection(&pool, "Beta", None, 1).await;
22167        mk_media(&pool, "In A", "a.png", "image", Some(root_a), "").await;
22168        let body = media_picker_payload(&pool, &MediaPickerQuery::default())
22169            .await
22170            .expect("payload");
22171        let cols = body["collections"].as_array().expect("collections");
22172        let names: Vec<&str> = cols.iter().map(|c| c["name"].as_str().unwrap()).collect();
22173        assert_eq!(names, ["Alpha", "Alpha Child", "Beta"]);
22174        assert_eq!(cols[0]["depth"], 0);
22175        assert_eq!(cols[1]["depth"], 1);
22176        assert_eq!(cols[2]["depth"], 0);
22177        assert_eq!(cols[0]["count"], 1);
22178        assert_eq!(cols[2]["count"], 0);
22179    }
22180
22181    #[tokio::test]
22182    async fn ids_lookup_resolves_any_kind() {
22183        // The label-hydration pass resolves exact ids — including
22184        // non-image kinds, which the default filter would drop.
22185        let pool = mem_pool().await;
22186        mk_media(&pool, "Photo", "p.png", "image", None, "").await;
22187        mk_media(&pool, "Spec", "s.pdf", "document", None, "").await;
22188        let all = media_picker_payload(
22189            &pool,
22190            &MediaPickerQuery {
22191                kind: Some("any".to_owned()),
22192                ..Default::default()
22193            },
22194        )
22195        .await
22196        .expect("payload");
22197        let ids: Vec<i64> = all["items"]
22198            .as_array()
22199            .unwrap()
22200            .iter()
22201            .map(|i| i["id"].as_i64().unwrap())
22202            .collect();
22203        let q = MediaPickerQuery {
22204            ids: Some(
22205                ids.iter()
22206                    .map(|i| i.to_string())
22207                    .collect::<Vec<_>>()
22208                    .join(","),
22209            ),
22210            ..Default::default()
22211        };
22212        let body = media_picker_payload(&pool, &q).await.expect("payload");
22213        let items = body["items"].as_array().expect("items");
22214        assert_eq!(
22215            items.len(),
22216            2,
22217            "document resolves too when ids are explicit"
22218        );
22219        // Explicit kind still narrows an ids lookup.
22220        let q = MediaPickerQuery {
22221            ids: Some(
22222                ids.iter()
22223                    .map(|i| i.to_string())
22224                    .collect::<Vec<_>>()
22225                    .join(","),
22226            ),
22227            kind: Some("image".to_owned()),
22228            ..Default::default()
22229        };
22230        let body = media_picker_payload(&pool, &q).await.expect("payload");
22231        assert_eq!(body["items"].as_array().expect("items").len(), 1);
22232    }
22233
22234    #[tokio::test]
22235    async fn image_items_carry_rendition_thumb_urls() {
22236        let pool = mem_pool().await;
22237        mk_media(&pool, "Pic", "p.png", "image", None, "").await;
22238        let body = media_picker_payload(&pool, &MediaPickerQuery::default())
22239            .await
22240            .expect("payload");
22241        let item = &body["items"][0];
22242        let thumb = item["thumb_url"].as_str().expect("thumb_url");
22243        assert!(
22244            thumb.starts_with("/__media__/fill-320x320"),
22245            "spec-first URL: {thumb}"
22246        );
22247        assert!(thumb.contains("v="), "cache-buster present: {thumb}");
22248        let preview = item["preview_url"].as_str().expect("preview_url");
22249        assert!(preview.contains("max-640x480"), "{preview}");
22250    }
22251}
22252
22253#[cfg(all(test, feature = "sqlite"))]
22254mod forms_list_tests {
22255    //! `forms_list_rows` row-model tests over an in-memory sqlite pool.
22256    use super::forms_list_rows;
22257    use crate::forms::submit::FormEntry;
22258    use crate::snippet::Snippet;
22259    use rustango::core::Model as _;
22260    use rustango::sql::{Auto, FetcherPool as _, Pool};
22261
22262    async fn mem_pool() -> Pool {
22263        let pool = Pool::connect("sqlite::memory:")
22264            .await
22265            .expect("in-memory sqlite");
22266        for schema in [&Snippet::SCHEMA, &FormEntry::SCHEMA] {
22267            let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
22268                pool.dialect(),
22269                schema,
22270            );
22271            for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
22272                rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
22273                    .await
22274                    .expect("ddl");
22275            }
22276        }
22277        pool
22278    }
22279
22280    async fn mk_form(pool: &Pool, slug: &str, title: &str, fields: usize) -> i64 {
22281        let field_json: Vec<serde_json::Value> = (0..fields)
22282            .map(|i| serde_json::json!({"id": format!("f{i}"), "key": format!("k{i}"), "type": "text", "label": "F"}))
22283            .collect();
22284        Snippet {
22285            id: Auto::Unset,
22286            type_name: "form".to_owned(),
22287            folder_path: String::new(),
22288            slug: slug.to_owned(),
22289            title: title.to_owned(),
22290            body_markdown: String::new(),
22291            data: serde_json::json!({
22292                "settings": {},
22293                "pages": [{"id": "p1", "sections": [{"id": "s1", "rows": [{"id": "r1",
22294                    "columns": [{"id": "c1", "width": 12, "fields": field_json}]}]}]}]
22295            }),
22296            created_at: Auto::Unset,
22297            updated_at: Auto::Unset,
22298        }
22299        .insert_pool(pool)
22300        .await
22301        .expect("form insert");
22302        Snippet::objects()
22303            .fetch(pool)
22304            .await
22305            .expect("fetch")
22306            .into_iter()
22307            .find(|s| s.slug == slug)
22308            .and_then(|s| s.id.get().copied())
22309            .expect("form id")
22310    }
22311
22312    async fn mk_entry(pool: &Pool, form_id: i64) {
22313        FormEntry {
22314            id: Auto::Unset,
22315            form_snippet_id: form_id,
22316            form_version: 1,
22317            source_page_id: 0,
22318            source_url: "/contact".to_owned(),
22319            data_json: serde_json::json!({"k0": "hi"}),
22320            locale: "en".to_owned(),
22321            ip: String::new(),
22322            submitted_at: Auto::Unset,
22323        }
22324        .insert_pool(pool)
22325        .await
22326        .expect("entry insert");
22327    }
22328
22329    #[tokio::test]
22330    async fn rows_carry_field_and_submission_counts() {
22331        let pool = mem_pool().await;
22332        let a = mk_form(&pool, "contact", "Contact", 3).await;
22333        let b = mk_form(&pool, "rsvp", "RSVP", 1).await;
22334        mk_entry(&pool, a).await;
22335        mk_entry(&pool, a).await;
22336        let rows = forms_list_rows(&pool).await.expect("rows");
22337        assert_eq!(rows.len(), 2);
22338        let by_slug = |slug: &str| rows.iter().find(|r| r["slug"] == slug).expect("row");
22339        let ra = by_slug("contact");
22340        assert_eq!(ra["fields"], 3);
22341        assert_eq!(ra["submissions"], 2);
22342        assert!(
22343            ra["last_submission"].as_str().unwrap().len() >= 16,
22344            "has a timestamp"
22345        );
22346        assert_eq!(ra["build_url"], format!("/cms-admin/forms/{a}/build"));
22347        assert_eq!(
22348            ra["submissions_url"],
22349            format!("/cms-admin/forms/{a}/submissions")
22350        );
22351        let rb = by_slug("rsvp");
22352        assert_eq!(rb["fields"], 1);
22353        assert_eq!(rb["submissions"], 0);
22354        assert_eq!(rb["last_submission"], "");
22355        assert_eq!(rb["delete_url"], format!("/cms-admin/library/{b}/delete"));
22356    }
22357
22358    #[tokio::test]
22359    async fn only_form_snippets_appear() {
22360        let pool = mem_pool().await;
22361        mk_form(&pool, "contact", "Contact", 1).await;
22362        Snippet {
22363            id: Auto::Unset,
22364            type_name: "branding".to_owned(),
22365            folder_path: String::new(),
22366            slug: "site-branding".to_owned(),
22367            title: "Branding".to_owned(),
22368            body_markdown: String::new(),
22369            data: serde_json::json!({}),
22370            created_at: Auto::Unset,
22371            updated_at: Auto::Unset,
22372        }
22373        .insert_pool(&pool)
22374        .await
22375        .expect("snippet insert");
22376        let rows = forms_list_rows(&pool).await.expect("rows");
22377        assert_eq!(rows.len(), 1);
22378        assert_eq!(rows[0]["slug"], "contact");
22379    }
22380
22381    #[test]
22382    fn user_admin_is_superuser_only() {
22383        // #642 — user management sets is_superuser / active / roles from
22384        // the form, so the whole surface is restricted to superusers.
22385        // A superuser proceeds; a signed-in non-superuser is bounced to
22386        // no-access; an anonymous caller to login. A regression that drops
22387        // the guard (or lets a non-superuser through) fails here.
22388        assert_eq!(super::user_admin_denial_target(Some(true)), None);
22389        assert_eq!(
22390            super::user_admin_denial_target(Some(false)),
22391            Some("/cms-admin/no-access")
22392        );
22393        assert_eq!(super::user_admin_denial_target(None), Some("/login"));
22394    }
22395
22396    #[test]
22397    fn mcp_key_admin_handlers_enforce_the_superuser_gate() {
22398        // #646 — the two /cms-admin/users/{id}/mcp-keys handlers must carry
22399        // the same superuser gate as every other user-admin handler. They
22400        // once gated on "a session exists" only, so a non-superuser could
22401        // mint a key bounded by a superuser's entitlement. Pin the wiring so
22402        // a future edit can't silently drop it again (the gap that untested
22403        // wiring hid the first time). Runs in the default suite — no DB.
22404        let src = include_str!("handlers.rs");
22405        for name in ["users_mcp_key_create", "users_mcp_key_revoke"] {
22406            let start = src
22407                .find(&format!("pub async fn {name}("))
22408                .unwrap_or_else(|| panic!("handler {name} not found"));
22409            // Bound the scan to this fn's body: up to the next top-level fn.
22410            let rest = &src[start + 1..];
22411            let end = rest.find("\npub async fn ").unwrap_or(rest.len());
22412            assert!(
22413                rest[..end].contains("require_superuser_for_user_admin(session_user.as_ref())"),
22414                "{name} is missing the superuser gate (#646)"
22415            );
22416        }
22417    }
22418}
22419
22420#[cfg(test)]
22421mod password_reset_key_tests {
22422    use super::{password_reset_key, password_reset_scope};
22423    use rustango::auth_flows::PasswordReset;
22424    use std::time::Duration;
22425
22426    const SECRET: &[u8] = b"process-wide-signing-secret";
22427    const BASE: &str = "/cms-admin/password-reset/confirm";
22428
22429    fn link(tenant: &str, hash: &str) -> String {
22430        PasswordReset::issue(
22431            &password_reset_scope(tenant),
22432            BASE,
22433            1,
22434            &password_reset_key(SECRET, tenant, hash),
22435            Duration::from_secs(3600),
22436        )
22437    }
22438
22439    #[test]
22440    fn a_link_verifies_for_the_tenant_and_password_it_was_issued_for() {
22441        let url = link("acme", "$argon2id$v=19$old");
22442        let key = password_reset_key(SECRET, "acme", "$argon2id$v=19$old");
22443        assert_eq!(PasswordReset::verify(&password_reset_scope("acme"), &url, &key).ok(), Some(1));
22444    }
22445
22446    #[test]
22447    fn a_link_issued_on_one_tenant_does_not_verify_on_another() {
22448        // User ids restart at 1 per tenant: this is the takeover in #673.
22449        let url = link("acme", "$argon2id$v=19$same");
22450        let other = password_reset_key(SECRET, "globex", "$argon2id$v=19$same");
22451        assert!(PasswordReset::verify(&password_reset_scope("globex"), &url, &other).is_err());
22452    }
22453
22454    #[test]
22455    fn a_link_stops_verifying_once_the_password_changes() {
22456        let url = link("acme", "$argon2id$v=19$before");
22457        let after = password_reset_key(SECRET, "acme", "$argon2id$v=19$after");
22458        assert!(PasswordReset::verify(&password_reset_scope("acme"), &url, &after).is_err());
22459    }
22460}
22461
22462#[cfg(all(test, feature = "sqlite"))]
22463mod publish_gate_tests {
22464    //! A save that puts a page live takes the publish right,
22465    //! judged on the status it lands on after go-live derivation.
22466    use super::{apply_page_edit, PageEditActor, PageEditRefusal};
22467    use crate::page::{Page, PageStatus};
22468    use crate::page_type_model::PageType;
22469    use rustango::core::Column as _;
22470    use rustango::sql::{Auto, Pool};
22471
22472    async fn mem_pool() -> Pool {
22473        let pool = Pool::connect("sqlite::memory:").await.expect("in-memory sqlite");
22474        for entry in inventory::iter::<rustango::core::ModelEntry> {
22475            if !entry.schema.managed {
22476                continue;
22477            }
22478            let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
22479                pool.dialect(),
22480                entry.schema,
22481            );
22482            for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
22483                rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
22484                    .await
22485                    .expect("ddl");
22486            }
22487        }
22488        pool
22489    }
22490
22491    async fn draft(pool: &Pool) -> Page {
22492        let mut pt = PageType {
22493            id: Auto::Unset,
22494            app_label: "cms".to_owned(),
22495            type_name: "TestPage".to_owned(),
22496            verbose_name: "Test page".to_owned(),
22497            default_template: "page.html".to_owned(),
22498            view_mode: "auto".to_owned(),
22499            is_creatable: true,
22500            allowed_parent_types: serde_json::json!([]),
22501            allowed_child_types: serde_json::json!([]),
22502            workflow: String::new(),
22503            created_at: Auto::Unset,
22504            updated_at: Auto::Unset,
22505        };
22506        pt.save_pool(pool).await.expect("page type");
22507        let mut p = draft_template(pt.id.get().copied().expect("type id"));
22508        p.save_pool(pool).await.expect("page");
22509        p
22510    }
22511
22512    fn draft_template(type_id: i64) -> Page {
22513        Page {
22514            id: Auto::Unset,
22515            page_type_id: type_id,
22516            title: "Draft".to_owned(),
22517            slug: "draft".to_owned(),
22518            path: "0001/".to_owned(),
22519            url_path: "/draft".to_owned(),
22520            preview_path: String::new(),
22521            template_override: String::new(),
22522            depth: 1,
22523            parent_id: None,
22524            locale_variant_of: None,
22525            alias_of: None,
22526            theme_id: None,
22527            sort_order: 0,
22528            status: PageStatus::Draft.as_str().to_owned(),
22529            published_at: None,
22530            last_published_at: None,
22531            go_live_at: None,
22532            expire_at: None,
22533            seo_title: String::new(),
22534            seo_description: String::new(),
22535            robots_index: true,
22536            sitemap_priority: 0.5,
22537            show_in_menus: true,
22538            og_title: String::new(),
22539            og_description: String::new(),
22540            og_image_media_id: None,
22541            twitter_card: "summary".to_owned(),
22542            notification_pre_published_sent: false,
22543            created_at: Auto::Unset,
22544            updated_at: Auto::Unset,
22545        }
22546    }
22547
22548    async fn save(
22549        pool: &Pool,
22550        page: &Page,
22551        status: &str,
22552        go_live_days: Option<i64>,
22553        superuser: bool,
22554    ) -> Result<String, &'static str> {
22555        let mut form = crate::page_form::prefill(pool, page).await;
22556        form.insert("status".into(), status.to_owned());
22557        match go_live_days {
22558            Some(d) => form.insert(
22559                "go_live_at".into(),
22560                (chrono::Utc::now() + chrono::Duration::days(d))
22561                    .format("%Y-%m-%dT%H:%M")
22562                    .to_string(),
22563            ),
22564            None => form.remove("go_live_at"),
22565        };
22566        // A user with no roles: edit reached the handler, publish is not held.
22567        let actor = PageEditActor { id: 999, username: "editor".to_owned(), is_superuser: superuser };
22568        let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
22569            std::sync::Arc::new(crate::cache_invalidate::Noop);
22570        let id = page.id.get().copied().expect("id");
22571        match apply_page_edit(pool, "t", &invalidator, None, "", false, id, &form, Some(&actor))
22572            .await
22573            .expect("save")
22574        {
22575            Ok(o) => Ok(o.page.status),
22576            Err(PageEditRefusal::PublishDenied) => Err("publish denied"),
22577            Err(PageEditRefusal::ReviewRequired { .. }) => Err("review required"),
22578            Err(_) => Err("other refusal"),
22579        }
22580    }
22581
22582    async fn stored_status(pool: &Pool, page: &Page) -> String {
22583        Page::objects()
22584            .where_(Page::id.eq(page.id.get().copied().expect("id")))
22585            .first(pool)
22586            .await
22587            .expect("query")
22588            .expect("page")
22589            .status
22590    }
22591
22592    async fn stored_theme(pool: &Pool, page: &Page) -> Option<i64> {
22593        Page::objects()
22594            .where_(Page::id.eq(page.id.get().copied().expect("id")))
22595            .first(pool)
22596            .await
22597            .expect("query")
22598            .expect("page")
22599            .theme_id
22600    }
22601
22602    /// #902 — the editor has no theme input, so its save must keep a theme
22603    /// set some other way; only a posted (empty) `theme_id` changes it.
22604    #[tokio::test]
22605    async fn an_editor_save_keeps_the_page_theme() {
22606        let pool = mem_pool().await;
22607        let mut page = draft(&pool).await;
22608        let mut theme = crate::theme::tests::fixture_theme();
22609        theme.save_pool(&pool).await.expect("theme");
22610        let theme_id = theme.id.get().copied().expect("theme id");
22611        page.theme_id = Some(theme_id);
22612        page.save_pool(&pool).await.expect("set theme");
22613
22614        let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
22615            std::sync::Arc::new(crate::cache_invalidate::Noop);
22616        let id = page.id.get().copied().expect("id");
22617        let mut form = crate::page_form::prefill(&pool, &page).await;
22618        form.remove("theme_id");
22619        assert!(apply_page_edit(&pool, "t", &invalidator, None, "", false, id, &form, None).await.expect("save").is_ok());
22620        assert_eq!(stored_theme(&pool, &page).await, Some(theme_id), "a form without the field keeps it");
22621
22622        form.insert("theme_id".into(), String::new());
22623        assert!(apply_page_edit(&pool, "t", &invalidator, None, "", false, id, &form, None).await.expect("save").is_ok());
22624        assert_eq!(stored_theme(&pool, &page).await, None, "posted empty clears it");
22625    }
22626
22627    /// Publish a page-builder body with one text field, `headline`.
22628    async fn publish_headline_schema(pool: &Pool, type_id: i64) {
22629        let document = serde_json::json!({
22630            "nodes": [{ "kind": "field", "key": "headline", "label": "Headline", "widget": "text" }]
22631        });
22632        rustango::sql::raw_execute_pool(
22633            pool,
22634            "INSERT INTO cms_page_type_schema (page_type_id, status, version, document) \
22635             VALUES (?, 'published', 1, ?)",
22636            vec![
22637                rustango::core::SqlValue::I64(type_id),
22638                rustango::core::SqlValue::Json(document),
22639            ],
22640        )
22641        .await
22642        .expect("schema");
22643    }
22644
22645    /// #857 — the new-page form carries the type's own fields, not only
22646    /// Title, Slug and Status.
22647    #[tokio::test]
22648    async fn the_new_page_form_shows_the_type_fields() {
22649        let pool = mem_pool().await;
22650        let type_id = draft(&pool).await.page_type_id;
22651        publish_headline_schema(&pool, type_id).await;
22652        let mut tera = tera::Tera::default();
22653        crate::admin::register_templates(&mut tera).expect("templates");
22654        let mut ctx = tera::Context::new();
22655        super::insert_type_fields(&mut ctx, &tera, &pool, None, Vec::new(), 0, type_id, None).await;
22656        let body = ctx
22657            .get("builder_body_html")
22658            .and_then(serde_json::Value::as_str)
22659            .expect("builder body on the new form")
22660            .to_owned();
22661        assert!(body.contains("pb__headline"), "headline input missing: {body}");
22662    }
22663
22664    /// #857 — what the new-page form posts for the type's fields is saved
22665    /// with the page, not dropped until a second save.
22666    #[tokio::test]
22667    async fn creating_a_page_saves_its_type_fields() {
22668        let pool = mem_pool().await;
22669        let page = draft(&pool).await;
22670        publish_headline_schema(&pool, page.page_type_id).await;
22671        let page_type = PageType::objects()
22672            .where_(PageType::id.eq(page.page_type_id))
22673            .first(&pool)
22674            .await
22675            .expect("type query");
22676        let id = page.id.get().copied().expect("id");
22677        let form = std::collections::HashMap::from([("pb__headline".to_owned(), "Hello".to_owned())]);
22678        super::save_type_content(&pool, page_type.as_ref(), page.page_type_id, id, &form)
22679            .await
22680            .expect("save");
22681        let data = crate::page_builder::model::data_for_page(&pool, id)
22682            .await
22683            .expect("builder data query")
22684            .expect("builder data row")
22685            .data;
22686        assert_eq!(data["headline"], "Hello", "{data}");
22687    }
22688
22689    #[tokio::test]
22690    async fn going_live_by_any_route_needs_the_publish_right() {
22691        let pool = mem_pool().await;
22692        let page = draft(&pool).await;
22693        for (status, go_live) in [
22694            ("archived", None),
22695            ("published", None),
22696            // Draft plus a future go-live is parked as scheduled.
22697            ("draft", Some(1)),
22698            // Scheduled with a go-live already past: the sweep publishes it.
22699            ("scheduled", Some(-1)),
22700        ] {
22701            assert_eq!(
22702                save(&pool, &page, status, go_live, false).await,
22703                Err("publish denied"),
22704                "{status} / {go_live:?}"
22705            );
22706            assert_eq!(stored_status(&pool, &page).await, "draft", "nothing written");
22707        }
22708        assert_eq!(
22709            save(&pool, &page, "scheduled", None, false).await,
22710            Ok("draft".to_owned()),
22711            "scheduled without a date is parked as a draft, so it is allowed"
22712        );
22713        assert_eq!(
22714            save(&pool, &page, "draft", Some(1), true).await,
22715            Ok("scheduled".to_owned()),
22716            "the publish right schedules"
22717        );
22718    }
22719
22720    /// A page type with a review workflow goes live only through it: a
22721    /// save straight to Published is refused for everyone but a
22722    /// superuser — the owner's review can't be skipped.
22723    /// Bind `type_id` to a one-step "Owner review" workflow.
22724    async fn bind_review(pool: &Pool, type_id: i64, reapproval: bool) -> crate::workflow::Workflow {
22725        let mut wf = crate::workflow::Workflow {
22726            id: Auto::Unset,
22727            name: "Owner review".to_owned(),
22728            description: String::new(),
22729            active: true,
22730            require_reapproval_on_edit: reapproval,
22731            created_at: Auto::Unset,
22732            updated_at: Auto::Unset,
22733        };
22734        wf.save_pool(pool).await.expect("workflow");
22735        rustango::sql::raw_execute_pool(pool, "INSERT INTO rustango_roles (id, name, description) VALUES (1, 'Owner', '')", Vec::new())
22736            .await
22737            .expect("role");
22738        let mut task = crate::workflow::WorkflowTask {
22739            id: Auto::Unset,
22740            workflow_id: wf.id.get().copied().expect("id"),
22741            name: "Owner checks".to_owned(),
22742            role_id: 1,
22743            sort_order: 10,
22744            kind: "group_approval".to_owned(),
22745            webhook_url: String::new(),
22746        };
22747        task.save_pool(pool).await.expect("task");
22748        let mut pt = PageType::objects()
22749            .where_(PageType::id.eq(type_id))
22750            .first(pool)
22751            .await
22752            .expect("q")
22753            .expect("type");
22754        pt.workflow = "Owner review".to_owned();
22755        pt.save_pool(pool).await.expect("bind");
22756        wf
22757    }
22758
22759    #[tokio::test]
22760    async fn a_review_workflow_cannot_be_published_around() {
22761        let pool = mem_pool().await;
22762        let page = draft(&pool).await;
22763        let mut wf = bind_review(&pool, page.page_type_id, false).await;
22764
22765        assert_eq!(save(&pool, &page, "published", None, false).await, Err("review required"));
22766        assert_eq!(save(&pool, &page, "draft", Some(1), false).await, Err("review required"), "nor scheduled");
22767        assert_eq!(stored_status(&pool, &page).await, "draft");
22768        assert_eq!(save(&pool, &page, "draft", None, false).await, Ok("draft".to_owned()), "drafts still save");
22769        assert_eq!(save(&pool, &page, "published", None, true).await, Ok("published".to_owned()), "the owner can");
22770
22771        // Renaming the workflow moves the page type along: still reviewed.
22772        let other = draft_named(&pool, page.page_type_id, "second").await;
22773        wf.name = "Studio review".to_owned();
22774        wf.save_pool(&pool).await.expect("rename");
22775        assert_eq!(crate::workflow::rebind_page_types(&pool, "Owner review", "Studio review").await.expect("rebind"), 1);
22776        assert_eq!(save(&pool, &other, "published", None, false).await, Err("review required"));
22777    }
22778
22779    /// Save `page` with a new title; `actor` None is the CMS's own save.
22780    async fn retitle(pool: &Pool, page: &Page, title: &str, actor: Option<&PageEditActor>) -> super::PageEditOutcome {
22781        let mut form = crate::page_form::prefill(pool, page).await;
22782        form.insert("title".into(), title.to_owned());
22783        let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
22784            std::sync::Arc::new(crate::cache_invalidate::Noop);
22785        let id = page.id.get().copied().expect("id");
22786        match apply_page_edit(pool, "t", &invalidator, None, "", false, id, &form, actor).await.expect("save") {
22787            Ok(o) => o,
22788            Err(_) => panic!("refused"),
22789        }
22790    }
22791
22792    async fn stored_title(pool: &Pool, page: &Page) -> String {
22793        Page::objects()
22794            .where_(Page::id.eq(page.id.get().copied().expect("id")))
22795            .first(pool)
22796            .await
22797            .expect("query")
22798            .expect("page")
22799            .title
22800    }
22801
22802    /// With re-approval on, an editor's save of a live page waits for the
22803    /// review: visitors keep the live version until the approval applies
22804    /// it; cancelling the review drops it; a superuser's save supersedes it.
22805    #[tokio::test]
22806    async fn a_live_page_edit_waits_for_review() {
22807        let pool = mem_pool().await;
22808        let page = draft(&pool).await;
22809        bind_review(&pool, page.page_type_id, true).await;
22810        assert_eq!(save(&pool, &page, "published", None, true).await, Ok("published".to_owned()));
22811        let id = page.id.get().copied().expect("id");
22812        let mut mia = rustango::tenancy::auth::User {
22813            id: Auto::Unset,
22814            username: "mia".to_owned(),
22815            password_hash: String::new(),
22816            email: None,
22817            is_superuser: false,
22818            active: true,
22819            created_at: chrono::Utc::now(),
22820            data: serde_json::json!({}),
22821            password_changed_at: None,
22822            sessions_revoked_at: None,
22823        };
22824        mia.save_pool(&pool).await.expect("user");
22825        let editor = PageEditActor { id: mia.id.get().copied().expect("id"), username: "mia".to_owned(), is_superuser: false };
22826
22827        let out = retitle(&pool, &page, "Proposed", Some(&editor)).await;
22828        assert!(out.held_for_review && out.reapproval_kicked);
22829        assert_eq!(stored_title(&pool, &page).await, "Draft", "the live page is unchanged");
22830        let held = crate::pending_change::for_page(&pool, id).await.expect("q").expect("held");
22831        assert_eq!(held.form_map().get("title").map(String::as_str), Some("Proposed"));
22832        let mut state = crate::workflow::active_state_for_page(&pool, id).await.expect("q").expect("review started");
22833
22834        // The approval applies it through the normal save path.
22835        let tasks = crate::workflow::tasks_for(&pool, state.workflow_id).await.expect("tasks");
22836        crate::workflow::approve_current(&pool, &mut state, &tasks, editor.id, "").await.expect("approve");
22837        let applied = retitle(&pool, &page, "Proposed", None).await;
22838        assert!(!applied.held_for_review);
22839        assert_eq!(stored_title(&pool, &page).await, "Proposed");
22840
22841        // Cancelling the review drops a held change.
22842        retitle(&pool, &page, "Second try", Some(&editor)).await;
22843        let mut state = crate::workflow::active_state_for_page(&pool, id).await.expect("q").expect("review restarted");
22844        crate::workflow::cancel(&pool, &mut state, editor.id).await.expect("cancel");
22845        assert!(crate::pending_change::for_page(&pool, id).await.expect("q").is_none());
22846
22847        // A superuser's direct save supersedes one.
22848        retitle(&pool, &page, "Third try", Some(&editor)).await;
22849        let owner = PageEditActor { id: 1, username: "owner".to_owned(), is_superuser: true };
22850        assert!(!retitle(&pool, &page, "Owner's", Some(&owner)).await.held_for_review);
22851        assert_eq!(stored_title(&pool, &page).await, "Owner's");
22852        assert!(crate::pending_change::for_page(&pool, id).await.expect("q").is_none());
22853    }
22854
22855    async fn draft_named(pool: &Pool, type_id: i64, slug: &str) -> Page {
22856        let mut p = draft_template(type_id);
22857        slug.clone_into(&mut p.slug);
22858        p.path = "0002/".to_owned();
22859        p.url_path = format!("/{slug}");
22860        p.save_pool(pool).await.expect("page");
22861        p
22862    }
22863}
22864
22865#[cfg(test)]
22866mod active_upload_tests {
22867    use super::refuse_active_upload;
22868
22869    #[test]
22870    fn page_like_types_are_refused_and_media_is_not() {
22871        for bad in ["text/html", "application/xhtml+xml", "text/javascript", "application/xml"] {
22872            assert!(refuse_active_upload(bad).is_err(), "{bad}");
22873        }
22874        for ok in ["image/png", "image/svg+xml", "application/pdf", "text/plain", "video/mp4"] {
22875            assert!(refuse_active_upload(ok).is_ok(), "{ok}");
22876        }
22877    }
22878}