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;
22
23/// Process-local HMAC key for signing the flash-messages cookie.
24///
25/// Seeded once per process from `rand::thread_rng().fill_bytes`.
26/// Pending messages stage in the cookie itself, so the only
27/// observable effect of a server restart is that any in-flight
28/// flash from before the restart is silently discarded
29/// ([`rustango::messages::drain`] returns an empty Vec on bad/
30/// missing signatures). Acceptable trade-off for one-shot UI
31/// hints; multi-instance deployments where flashes must survive a
32/// pool of admin servers should run pinned sessions or move to
33/// session-backed storage (queued upstream).
34fn messages_secret() -> &'static [u8] {
35    static SECRET: OnceLock<Vec<u8>> = OnceLock::new();
36    SECRET.get_or_init(|| {
37        // #319 — 32 random bytes straight from the OS CSPRNG via
38        // `getrandom` (rand 0.10 removed `OsRng`; this is the source it
39        // wrapped). Explicit OS entropy at this HMAC-secret boundary,
40        // rather than `rand::random()`'s thread RNG.
41        let mut k = [0u8; 32];
42        getrandom::fill(&mut k).expect("OS CSPRNG unavailable");
43        k.to_vec()
44    })
45}
46
47/// Sanitize WYSIWYG (RichText-widget) HTML server-side before it
48/// reaches a page-type handler's `save_extension`. The TipTap editor
49/// produces constrained HTML, but a bypassed client could POST anything,
50/// so we ammonia-clean every RichText-kind field value (looked up by the
51/// handler's own widget definitions) before persisting. This is the
52/// on-save enforcement point for extension fields; stream rich-text blocks
53/// + markdown bodies already sanitize on their own render paths, and the
54/// `| richtext` filter stays a pure linktype-rewriter that trusts the now-
55/// sanitized stored HTML. Returns a sanitized clone of `form_map`.
56async fn sanitized_extension_form(
57    handler: &dyn crate::page_type::PageTypeHandler,
58    pool: &rustango::sql::Pool,
59    page_id: i64,
60    form_map: &std::collections::HashMap<String, String>,
61) -> std::collections::HashMap<String, String> {
62    let mut out = form_map.clone();
63    if let Ok(widgets) = handler.widgets(pool, page_id).await {
64        for w in widgets {
65            if w.kind == crate::widget::WidgetKind::RichText {
66                if let Some(raw) = out.get(&w.name) {
67                    let cleaned = crate::markdown::sanitize_html(raw);
68                    out.insert(w.name.clone(), cleaned);
69                }
70            }
71        }
72    }
73    out
74}
75
76/// How long a preview token stays valid: long enough for an editor to
77/// click through and iterate, short enough that a URL pasted into a chat
78/// stops working before it becomes a way in.
79const PREVIEW_TOKEN_TTL_SECS: i64 = 3600;
80
81/// Render a CMS-admin Tera template with the CSRF token + drained
82/// flash messages stamped into the context. Returns a `Response`
83/// that carries:
84///   - any `Set-Cookie` the CSRF middleware needs to mint a fresh
85///     token (first GET per session, or when the cookie was
86///     invalidated);
87///   - the clear-cookie that empties the messages store so each
88///     flash renders exactly once.
89///
90/// Every form-rendering admin handler routes through this helper so
91/// `{{ csrf_token | csrf_input | safe }}` and
92/// `{% for msg in messages %}…{% endfor %}` in templates always
93/// resolve correctly.
94pub(crate) fn render_with_csrf(
95    state: &super::AdminState,
96    headers: &HeaderMap,
97    template: &str,
98    ctx: &mut Context,
99) -> Result<Response, AdminError> {
100    // #525/#526 — resolve the admin UI locale per request and expose it to the
101    // template. Done here so every admin page picks it up without threading
102    // through each handler. Precedence: sticky cookie → per-user preference
103    // (#526, surfaced into the ctx by `add_user_chrome`) → Accept-Language →
104    // per-tenant default (#526) → English.
105    let user_pref = ctx
106        .get("user_lang_pref")
107        .and_then(|v| v.as_str())
108        .map(str::to_owned);
109    let tenant_default = super::i18n::tenant_default_locale();
110    let lang = super::i18n::negotiate(
111        headers.get(header::COOKIE).and_then(|v| v.to_str().ok()),
112        headers
113            .get(header::ACCEPT_LANGUAGE)
114            .and_then(|v| v.to_str().ok()),
115        user_pref.as_deref(),
116        tenant_default.as_deref(),
117    );
118    let lang_dir = rustango::i18n::text_direction(&lang);
119    ctx.insert("LANG", &lang);
120    ctx.insert("LANG_DIR", lang_dir);
121    let csrf_cookie = rustango::forms::csrf::stamp_into_context(headers, ctx);
122    let msg_clear = rustango::messages::stamp_into_context(messages_secret(), headers, ctx);
123    let html = state.tera.render(template, ctx)?;
124    let mut resp = Html(html).into_response();
125    if let Some(c) = csrf_cookie {
126        if let Ok(v) = HeaderValue::from_str(&c) {
127            resp.headers_mut().append(header::SET_COOKIE, v);
128        }
129    }
130    if let Some(c) = msg_clear {
131        if let Ok(v) = HeaderValue::from_str(&c) {
132            resp.headers_mut().append(header::SET_COOKIE, v);
133        }
134    }
135    Ok(resp)
136}
137
138/// Redirect to a named route registered in [`crate::urls`] AND
139/// stage a flash message ([`rustango::messages`]) in the response
140/// cookie so the next GET at the destination renders it through
141/// the `messages` Tera context variable. The standard "POST → 303
142/// → render flash" idiom — every cms-admin POST handler returns
143/// through this (or its `_with_params` cousin) so editors get
144/// real feedback instead of a silent navigation.
145fn redirect_named_with_message(
146    name: &'static str,
147    level: MsgLevel,
148    body: &str,
149    headers: &HeaderMap,
150) -> Result<Response, AdminError> {
151    let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
152        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
153    // #528 — localize the flash for the request's admin locale (English source
154    // is the key; untranslated → unchanged).
155    let body = super::i18n::tr(headers, body, &[]);
156    Ok(rustango::messages::redirect_with_message(
157        messages_secret(),
158        headers,
159        level,
160        &body,
161        &url,
162    ))
163}
164
165/// Like [`redirect_named_with_message`] but the message is a **parameterized**
166/// translation key: the English source — with `{name}` placeholders — is
167/// the catalog key, localized + interpolated for the request locale before
168/// staging. Use instead of `&format!(…)` so the flash localizes. The framework
169/// substitutes placeholders into the source-string fallback too, so English
170/// (empty catalog) renders correctly without a catalog entry.
171fn redirect_named_with_message_args(
172    name: &'static str,
173    level: MsgLevel,
174    key: &str,
175    args: &[(&str, &str)],
176    headers: &HeaderMap,
177) -> Result<Response, AdminError> {
178    let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
179        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
180    let body = super::i18n::tr(headers, key, args);
181    Ok(rustango::messages::redirect_with_message(
182        messages_secret(),
183        headers,
184        level,
185        &body,
186        &url,
187    ))
188}
189
190/// Count-aware cousin of [`redirect_named_with_message_args`]:
191/// `key` is a plural source key, the form is chosen for `n` in the request
192/// locale (CLDR rules) and `args` interpolated. Pass the count as an arg too
193/// (e.g. `("count", &n.to_string())`) so the chosen form's `{count}` fills in.
194fn redirect_named_with_message_plural(
195    name: &'static str,
196    level: MsgLevel,
197    key: &str,
198    n: i64,
199    args: &[(&str, &str)],
200    headers: &HeaderMap,
201) -> Result<Response, AdminError> {
202    let url = rustango::urls::reverse(name, &std::collections::HashMap::new())
203        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
204    let body = super::i18n::tr_plural(headers, key, n, args);
205    Ok(rustango::messages::redirect_with_message(
206        messages_secret(),
207        headers,
208        level,
209        &body,
210        &url,
211    ))
212}
213
214/// Plural cousin of [`redirect_named_with_params_and_message`] —
215/// for routes with path params AND a count-aware message.
216fn redirect_named_with_params_and_message_plural(
217    name: &'static str,
218    params: &[(&str, String)],
219    level: MsgLevel,
220    key: &str,
221    n: i64,
222    args: &[(&str, &str)],
223    headers: &HeaderMap,
224) -> Result<Response, AdminError> {
225    let owned: std::collections::HashMap<String, String> = params
226        .iter()
227        .map(|(k, v)| ((*k).to_owned(), v.clone()))
228        .collect();
229    let url = rustango::urls::reverse_owned(name, &owned)
230        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
231    let body = super::i18n::tr_plural(headers, key, n, args);
232    Ok(rustango::messages::redirect_with_message(
233        messages_secret(),
234        headers,
235        level,
236        &body,
237        &url,
238    ))
239}
240
241/// Friendly 401 response for handlers that bail when
242/// `SessionUser` resolves to `None`. Two content-types based on
243/// `Accept`:
244///
245/// - **`application/json`** — JSON `{ error: "session_expired",
246///   message, login_url }`. XHR / fetch clients (notably the bulk
247///   media uploader) used to inline-dump the HTML page into a toast,
248///   which read as garbage. JSON lets the client render a clean
249///   "Sign in again to keep uploading" banner instead.
250/// - **Anything else** — the HTML explainer page below, useful for
251///   `<form>` POSTs that hit Submit after the cookie went stale.
252///
253/// The middleware-level `with_login_required` layer already
254/// 302s anonymous GETs to /login. A POST hitting this guard means
255/// the cookie was DECODED as anonymous (expired / wrong tenant /
256/// stale), so a hard 401 with an explanation lands better than a
257/// redirect loop.
258fn unauthorized_no_session() -> Response {
259    unauthorized_no_session_for(None)
260}
261
262/// Content-negotiating variant of [`unauthorized_no_session`]. Pass
263/// the request `HeaderMap` so the client's `Accept` (and the legacy
264/// `X-Requested-With: XMLHttpRequest`) can pick between the JSON
265/// payload and the HTML page.
266fn unauthorized_no_session_for(headers: Option<&HeaderMap>) -> Response {
267    let wants_json = headers
268        .map(|h| {
269            let accept = h
270                .get(header::ACCEPT)
271                .and_then(|v| v.to_str().ok())
272                .unwrap_or("");
273            if accept.contains("application/json") {
274                return true;
275            }
276            h.get("x-requested-with")
277                .and_then(|v| v.to_str().ok())
278                .is_some_and(|v| v.eq_ignore_ascii_case("XMLHttpRequest"))
279        })
280        .unwrap_or(false);
281    // #528 — localize for the request's admin locale when headers are present
282    // (this is the one polished user-facing admin error page); English otherwise.
283    let t = |key: &str| -> String {
284        match headers {
285            Some(h) => super::i18n::tr(h, key, &[]),
286            None => key.to_owned(),
287        }
288    };
289    if wants_json {
290        let payload = serde_json::json!({
291            "error": "session_expired",
292            "message": t("Sign in again to keep uploading."),
293            "login_url": "/login?next=/cms-admin/",
294        });
295        return (
296            axum::http::StatusCode::UNAUTHORIZED,
297            [(axum::http::header::CONTENT_TYPE, "application/json")],
298            serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
299        )
300            .into_response();
301    }
302    let lang = headers
303        .map(|h| {
304            super::i18n::negotiate(
305                h.get(header::COOKIE).and_then(|v| v.to_str().ok()),
306                h.get(header::ACCEPT_LANGUAGE).and_then(|v| v.to_str().ok()),
307                None,
308                super::i18n::tenant_default_locale().as_deref(),
309            )
310        })
311        .unwrap_or_else(|| "en".to_owned());
312    let dir = rustango::i18n::text_direction(&lang);
313    const STYLE: &str = r#"<style>
314body{font:14px/1.5 -apple-system,system-ui,sans-serif;color:#222;background:#fafafa;margin:0;padding:48px 20px}
315.box{max-width:560px;margin:0 auto;padding:32px;background:#fff;border-radius:12px;box-shadow:0 2px 8px rgba(0,0,0,.08)}
316h1{font-size:18px;margin:0 0 12px}
317p{margin:0 0 12px;color:#444}
318ul{margin:0 0 12px;padding-left:20px;color:#444}
319li{margin:4px 0}
320a{color:#1565c0}
321</style>"#;
322    let mut body = String::with_capacity(STYLE.len() + 1024);
323    body.push_str("<!doctype html>\n<html lang=\"");
324    body.push_str(&crate::forms::render::html_escape(&lang));
325    body.push_str("\" dir=\"");
326    body.push_str(dir);
327    body.push_str("\"><head><meta charset=\"utf-8\"><title>");
328    body.push_str(&crate::forms::render::html_escape(&t("Session expired")));
329    body.push_str(" — ");
330    body.push_str(&crate::forms::render::html_escape(&t("CMS Admin")));
331    body.push_str("</title>");
332    body.push_str(STYLE);
333    body.push_str("</head><body><div class=\"box\">\n<h1>");
334    body.push_str(&crate::forms::render::html_escape(&t(
335        "Your session has expired",
336    )));
337    body.push_str("</h1>\n<p>");
338    body.push_str(&crate::forms::render::html_escape(&t(
339        "The form couldn't be saved because your admin session decoded as anonymous. The most likely causes:",
340    )));
341    body.push_str("</p>\n<ul>\n<li>");
342    body.push_str(&crate::forms::render::html_escape(&t(
343        "Your login session expired or was signed out from another tab.",
344    )));
345    body.push_str("</li>\n<li>");
346    body.push_str(&crate::forms::render::html_escape(&t(
347        "The cookie was issued for a different tenant slug.",
348    )));
349    body.push_str("</li>\n<li>");
350    body.push_str(&crate::forms::render::html_escape(&t(
351        "On sqlite/mysql builds the framework's tenant session store may not be wired up yet (see issue #259).",
352    )));
353    body.push_str("</li>\n</ul>\n<p><a href=\"/login?next=/cms-admin/\">");
354    body.push_str(&crate::forms::render::html_escape(&t("Sign back in")));
355    body.push_str("</a>");
356    body.push_str(&crate::forms::render::html_escape(&t(
357        ", then re-submit the form.",
358    )));
359    body.push_str("</p>\n</div></body></html>");
360    (
361        axum::http::StatusCode::UNAUTHORIZED,
362        [(axum::http::header::CONTENT_TYPE, "text/html; charset=utf-8")],
363        body,
364    )
365        .into_response()
366}
367
368/// Like [`redirect_named_with_message`], but for routes with path
369/// parameters (e.g. `rcms-admin:pages:edit` needing `{id}`).
370pub(crate) fn redirect_named_with_params_and_message(
371    name: &'static str,
372    params: &[(&str, String)],
373    level: MsgLevel,
374    body: &str,
375    headers: &HeaderMap,
376) -> Result<Response, AdminError> {
377    let owned: std::collections::HashMap<String, String> = params
378        .iter()
379        .map(|(k, v)| ((*k).to_owned(), v.clone()))
380        .collect();
381    let url = rustango::urls::reverse_owned(name, &owned)
382        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
383    // #528 — localize the flash for the request's admin locale.
384    let body = super::i18n::tr(headers, body, &[]);
385    Ok(rustango::messages::redirect_with_message(
386        messages_secret(),
387        headers,
388        level,
389        &body,
390        &url,
391    ))
392}
393
394/// Parameterized-key cousin of [`redirect_named_with_params_and_message`]
395/// for routes that take path params AND a localized message with `{name}`
396/// interpolation.
397pub(crate) fn redirect_named_with_params_and_message_args(
398    name: &'static str,
399    params: &[(&str, String)],
400    level: MsgLevel,
401    key: &str,
402    args: &[(&str, &str)],
403    headers: &HeaderMap,
404) -> Result<Response, AdminError> {
405    let owned: std::collections::HashMap<String, String> = params
406        .iter()
407        .map(|(k, v)| ((*k).to_owned(), v.clone()))
408        .collect();
409    let url = rustango::urls::reverse_owned(name, &owned)
410        .map_err(|e| AdminError::Validation(format!("url reversal of `{name}` failed: {e}")))?;
411    let body = super::i18n::tr(headers, key, args);
412    Ok(rustango::messages::redirect_with_message(
413        messages_secret(),
414        headers,
415        level,
416        &body,
417        &url,
418    ))
419}
420
421/// Resolve the post-save redirect from the three-action save
422/// footer (`_save` / `_continue` /
423/// `_addanother`). Shared by `page_new_submit` and `page_edit_submit`
424/// so both honour the same button the editor pressed:
425///
426/// * `continue`   → back to **this** page's edit form (keep editing).
427/// * `addanother` → a fresh new-page form, preselecting the same parent
428///   so the next page lands as a sibling (`pages:new` honours
429///   `?parent=<id>`); root pages omit the query.
430/// * anything else (incl. the default `save` / missing) → the page list.
431///
432/// `body` must already be localized by the caller (via `tr` / `tr_plural`) —
433/// this dispatcher only resolves the destination URL and stages the message,
434/// so every branch (including `addanother`) treats `body` identically.
435fn redirect_after_page_save(
436    action: &str,
437    page_id: i64,
438    parent_id: Option<i64>,
439    body: &str,
440    headers: &HeaderMap,
441) -> Result<Response, AdminError> {
442    let url = match action {
443        "continue" => rustango::urls::reverse_owned(
444            "rcms-admin:pages:edit",
445            &std::iter::once(("id".to_owned(), page_id.to_string())).collect(),
446        )
447        .map_err(|e| AdminError::Validation(format!("url reversal of `pages:edit` failed: {e}")))?,
448        "addanother" => {
449            let base =
450                rustango::urls::reverse("rcms-admin:pages:new", &std::collections::HashMap::new())
451                    .map_err(|e| {
452                        AdminError::Validation(format!("url reversal of `pages:new` failed: {e}"))
453                    })?;
454            match parent_id {
455                Some(pid) => format!("{base}?parent={pid}"),
456                None => base,
457            }
458        }
459        _ => rustango::urls::reverse("rcms-admin:pages:list", &std::collections::HashMap::new())
460            .map_err(|e| {
461                AdminError::Validation(format!("url reversal of `pages:list` failed: {e}"))
462            })?,
463    };
464    Ok(rustango::messages::redirect_with_message(
465        messages_secret(),
466        headers,
467        MsgLevel::Success,
468        body,
469        &url,
470    ))
471}
472
473/// A user's email: the `email` column — what member sign-in, SSO and
474/// sign-up use — else the address older admin versions kept in
475/// `data.email`. Empty when neither is set.
476pub(crate) fn user_email(u: &rustango::tenancy::auth::User) -> String {
477    u.email
478        .as_deref()
479        .map(str::trim)
480        .filter(|e| !e.is_empty())
481        .or_else(|| u.data.get("email").and_then(|v| v.as_str()).map(str::trim))
482        .unwrap_or("")
483        .to_owned()
484}
485
486/// Add the chrome variables every section template reads from
487/// `_base.html`: which sidebar tab is active, the brand-display
488/// name, the current tenant slug, and — when a [`SessionUser`](rustango::extractors::SessionUser) is
489/// in scope — the sidebar gating set + per-user timezone.
490///
491/// Pass `session_user.as_ref()` from the handler signature; pass
492/// `None` for anon flows (login / password-reset). When `None`,
493/// `sidebar_gating` stays `false` so every sidebar item renders.
494///
495/// Public so a host application's [`AdminPageHandler`] can render inside
496/// the admin chrome. Without it the extension point only works for a page
497/// that does NOT extend `rcms_admin/_base.html`, since that template
498/// dereferences roughly two dozen chrome variables — and hand-supplying
499/// them in a host app is a copy that drifts silently on every release.
500///
501/// [`AdminPageHandler`]: super::admin_page::AdminPageHandler
502pub async fn add_chrome(
503    ctx: &mut Context,
504    tenant: &Tenant,
505    active_tab: &str,
506    session_user: Option<&rustango::tenancy::auth::User>,
507) {
508    add_chrome_sync(ctx, tenant, active_tab);
509    // #532 — pull any operator edits from `rustango_translations` into the
510    // shared translator (TTL-throttled) so admin chrome reflects them live.
511    super::i18n::maybe_refresh_overrides(tenant.pool()).await;
512    if let Some(user) = session_user {
513        add_user_chrome(ctx, user, tenant.pool()).await;
514    }
515    // #199 — per-tenant logo + favicon URLs (see [`add_branding_urls`]).
516    add_branding_urls(ctx, tenant).await;
517}
518
519/// Inject the per-tenant admin logo + favicon URLs from the `branding`
520/// site setting into a template context. Missing/empty rows leave the ctx slots
521/// unset, so templates fall back to the brand-name text + default icon. Shared
522/// by the authenticated chrome ([`add_chrome`]) and the pre-auth login /
523/// password-reset screens (which have no `add_chrome`), so those can show the
524/// tenant's branding too. The serve routes (`/__cms-branding/*`) live in
525/// `public_router` so the images load before sign-in.
526pub(crate) async fn add_branding_urls(ctx: &mut Context, tenant: &Tenant) {
527    // The site's name as visitors know it: the owner's Branding "Site
528    // name", else the tenant's display name (set by the operator).
529    let mut site_name = tenant.org.display_name.clone();
530    if let Ok(Some(row)) = crate::site_setting::get(tenant.pool(), "branding").await {
531        if let Some(n) = row.value_json.get("site_name").and_then(|v| v.as_str()).filter(|n| !n.trim().is_empty()) {
532            n.trim().clone_into(&mut site_name);
533        }
534        let is_set = |key: &str| {
535            row.value_json
536                .get(key)
537                .and_then(|v| v.as_str())
538                .is_some_and(|s| !s.is_empty())
539        };
540        if is_set("logo_storage_key") {
541            ctx.insert("branding_logo_url", "/__cms-branding/logo");
542        }
543        if is_set("favicon_storage_key") {
544            ctx.insert("branding_favicon_url", "/__cms-branding/favicon");
545        }
546    }
547    ctx.insert("site_name", &site_name);
548}
549
550/// Sync core of [`add_chrome`] — every call site benefits from
551/// re-using it, so it's broken out for clarity. Stuffs the static
552/// chrome bits (tab, tenant, brand, default tz, registered admin
553/// pages) into the context.
554fn add_chrome_sync(ctx: &mut Context, tenant: &Tenant, active_tab: &str) {
555    ctx.insert("active_tab", active_tab);
556    ctx.insert("tenant_slug", &tenant.org.slug);
557    // #524 — admin UI locale + text direction for `<html lang/dir>` and the
558    // `translate(locale=LANG)` calls. The default here is overridden per
559    // request by `render_with_csrf` (#525 negotiation).
560    ctx.insert("LANG", "en");
561    ctx.insert("LANG_DIR", "ltr");
562    // #525 — the shipped UI locales, for the language switcher.
563    ctx.insert(
564        "ui_locales",
565        &super::i18n::UI_LOCALES
566            .iter()
567            .map(|(c, n)| serde_json::json!({ "code": c, "name": n }))
568            .collect::<Vec<_>>(),
569    );
570    let brand = tenant
571        .org
572        .brand_name
573        .clone()
574        .filter(|s| !s.is_empty())
575        .unwrap_or_else(|| tenant.org.display_name.clone());
576    ctx.insert("brand_name", &brand);
577    // user_timezone defaults to empty; PG-authenticated requests
578    // get it filled in via `add_user_chrome` (called explicitly by
579    // handlers that have a SessionUser extractor in scope).
580    ctx.insert("user_timezone", "");
581    // #13 V2 — tenant default timezone. Sourced from
582    // `RUSTANGO_CMS_DEFAULT_TIMEZONE` so multi-tenant deployments can
583    // pin a sensible regional default without a schema change. The
584    // boot script in _base.html resolves in order:
585    //   user pref → tenant default → browser default.
586    // Process configuration, read once rather than on every admin page.
587    static DEFAULT_TZ: std::sync::OnceLock<String> = std::sync::OnceLock::new();
588    let tenant_default_tz = DEFAULT_TZ
589        .get_or_init(|| crate::config::var("DEFAULT_TIMEZONE").unwrap_or_default())
590        .clone();
591    ctx.insert("tenant_default_timezone", &tenant_default_tz);
592
593    // Custom admin pages (#23) — bucket every registered handler by
594    // its declared sidebar section so `_base.html` can group them
595    // under the right heading. Sort within each bucket by
596    // `(sort_order, label)` so authors can pin position.
597    let mut by_section: std::collections::BTreeMap<String, Vec<serde_json::Value>> =
598        std::collections::BTreeMap::new();
599    for handler in super::admin_page::registered_admin_pages() {
600        let section = handler.section().label().to_owned();
601        by_section
602            .entry(section)
603            .or_default()
604            .push(serde_json::json!({
605                "slug": handler.slug(),
606                "label": handler.label(),
607                "icon": handler.icon(),
608                "sort_order": handler.sort_order(),
609            }));
610    }
611    for items in by_section.values_mut() {
612        items.sort_by(|a, b| {
613            let ao = a.get("sort_order").and_then(|v| v.as_i64()).unwrap_or(100);
614            let bo = b.get("sort_order").and_then(|v| v.as_i64()).unwrap_or(100);
615            ao.cmp(&bo).then_with(|| {
616                a.get("label")
617                    .and_then(|v| v.as_str())
618                    .unwrap_or("")
619                    .cmp(b.get("label").and_then(|v| v.as_str()).unwrap_or(""))
620            })
621        });
622    }
623    ctx.insert("extra_admin_pages_by_section", &by_section);
624    // #439 — registry-driven report links. `_base.html` lists these
625    // under the Reports group below the built-in reports, so a
626    // `register_report!`ed report shows up in the nav with no template
627    // edit. Already title-sorted by `registered_reports()`.
628    let reports_nav: Vec<serde_json::Value> = super::report::registered_reports()
629        .iter()
630        .map(|r| {
631            serde_json::json!({
632                "slug": r.slug(),
633                "title": r.title(),
634                "icon": r.icon(),
635            })
636        })
637        .collect();
638    ctx.insert("registered_reports", &reports_nav);
639    // #107 — plugin-contributed admin menu items (runtime hook B13).
640    // Rendered at the bottom of the sidebar in stable key order.
641    let plugin_menu_items: Vec<serde_json::Value> = crate::hooks::admin_menu_items()
642        .into_iter()
643        .map(|i| {
644            serde_json::json!({
645                "key": i.key,
646                "label": i.label,
647                "icon": i.icon,
648                "href": i.href,
649            })
650        })
651        .collect();
652    ctx.insert("plugin_admin_menu_items", &plugin_menu_items);
653    // #127 — help-menu entries. Rendered in a
654    // dedicated "Help" sidebar section above Plugins.
655    let help_menu_items: Vec<serde_json::Value> = crate::hooks::help_menu_items()
656        .into_iter()
657        .map(|i| {
658            serde_json::json!({
659                "key": i.key,
660                "label": i.label,
661                "icon": i.icon,
662                "href": i.href,
663            })
664        })
665        .collect();
666    ctx.insert("help_menu_items", &help_menu_items);
667    // #422 — plugin-injected global admin CSS / JS. `_base.html` emits each blob inside
668    // a <style> / <script> tag.
669    ctx.insert("admin_css_blobs", &crate::hooks::admin_css());
670    ctx.insert("admin_js_blobs", &crate::hooks::admin_js());
671    // Sidebar gating defaults: when no SessionUser is in scope (anon
672    // public_router flows like login + password-reset), keep every
673    // sidebar item visible. Handlers with a `SessionUser` extractor
674    // override this via `add_user_chrome` below.
675    ctx.insert("sidebar_gating", &false);
676    ctx.insert("user_is_superuser", &false);
677    ctx.insert(
678        "allowed_resources",
679        &std::collections::HashSet::<String>::new(),
680    );
681}
682
683/// Per-request chrome extension for authenticated requests. Fills in
684/// the bits `add_chrome` can't compute without a user in scope:
685///
686/// - `user_timezone` from `User.data.timezone`. Empty when
687///   unset so the no-flash JS falls back to the browser TZ.
688/// - `allowed_resources`: the union of role codenames the user
689///   inherits, used to gate sidebar items + admin-side CRUD chips.
690///   Superusers skip the gating set entirely (the sidebar
691///   template checks `user_is_superuser` first).
692/// - `user_is_superuser`: short-circuit flag exposed to templates so
693///   they don't iterate the codename set when access is unconditional.
694/// - `sidebar_gating: true`: tells `_base.html` to start honoring
695///   the gating set (anon flows leave this `false` so login pages
696///   render their full chrome).
697pub(crate) async fn add_user_chrome(
698    ctx: &mut Context,
699    user: &rustango::tenancy::auth::User,
700    pool: &rustango::sql::Pool,
701) {
702    let user_timezone = user
703        .data
704        .get("timezone")
705        .and_then(serde_json::Value::as_str)
706        .unwrap_or("")
707        .to_owned();
708    ctx.insert("user_timezone", &user_timezone);
709    // #526 — durable per-user admin UI language. Surfaced into the ctx here (the
710    // one place with the authenticated user) so `render_with_csrf` can fold it
711    // into locale negotiation without threading the user through every handler.
712    if let Some(pref) = user
713        .data
714        .get("admin_lang")
715        .and_then(serde_json::Value::as_str)
716        .filter(|s| super::i18n::is_ui_locale(s))
717    {
718        ctx.insert("user_lang_pref", pref);
719    }
720    ctx.insert("user_is_superuser", &user.is_superuser);
721    ctx.insert("user_username", &user.username);
722    // #201 — profile chrome. The display name lives in
723    // rustango_users.data.display_name; fall back to the username.
724    // Avatar lives at /__cms-avatar/<user_id> when the user uploaded
725    // one (avatar_path is set as a side-effect of the upload route).
726    let display_name = user
727        .data
728        .get("display_name")
729        .and_then(serde_json::Value::as_str)
730        .filter(|s| !s.is_empty())
731        .unwrap_or(&user.username)
732        .to_owned();
733    ctx.insert("user_display_name", &display_name);
734    let has_avatar = user
735        .data
736        .get("avatar_path")
737        .and_then(serde_json::Value::as_str)
738        .map(|s| !s.is_empty())
739        .unwrap_or(false);
740    if has_avatar {
741        let uid = user.id.get().copied().unwrap_or(0);
742        ctx.insert("user_avatar_url", &format!("/__cms-avatar/{uid}"));
743    }
744    let codenames = if user.is_superuser {
745        // Superusers bypass gating; we still hand the template an
746        // empty set so unconditional checks work without branching.
747        std::collections::HashSet::<String>::new()
748    } else {
749        let uid = user.id.get().copied().unwrap_or(0);
750        crate::permissions::user_codenames(pool, uid)
751            .await
752            .unwrap_or_default()
753    };
754    ctx.insert("allowed_resources", &codenames);
755    ctx.insert("sidebar_gating", &true);
756}
757
758/// GET /cms-admin/media/collections — manage every collection in the
759/// tenant. Tree view with depth-indented names, per-row rename /
760/// delete + a "new" form per parent.
761pub async fn collections_list(
762    State(state): State<super::AdminState>,
763    tenant: Tenant,
764    headers: HeaderMap,
765    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
766) -> Result<Response, AdminError> {
767    let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
768        .order_by(&[("parent_id", false), ("sort_order", false), ("name", false)])
769        .fetch(tenant.pool())
770        .await?;
771    // Walk into a depth-tagged tree so the template can render
772    // indented names without computing the depth itself.
773    let by_id: std::collections::HashMap<i64, &crate::media::MediaCollection> = collections
774        .iter()
775        .filter_map(|c| c.id.get().copied().map(|id| (id, c)))
776        .collect();
777    fn depth(
778        c: &crate::media::MediaCollection,
779        by_id: &std::collections::HashMap<i64, &crate::media::MediaCollection>,
780        cache: &mut std::collections::HashMap<i64, i32>,
781    ) -> i32 {
782        let id = c.id.get().copied().unwrap_or_default();
783        if let Some(d) = cache.get(&id) {
784            return *d;
785        }
786        let d = match c.parent_id {
787            None => 0,
788            Some(pid) => match by_id.get(&pid) {
789                Some(parent) => depth(parent, by_id, cache) + 1,
790                None => 0,
791            },
792        };
793        cache.insert(id, d);
794        d
795    }
796    // Media counts per collection so editors see usage at a glance.
797    let media: Vec<Media> = Media::objects().fetch(tenant.pool()).await?;
798    let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
799    for m in &media {
800        if let Some(cid) = m.collection_id {
801            *counts.entry(cid).or_insert(0) += 1;
802        }
803    }
804    let mut depth_cache: std::collections::HashMap<i64, i32> = std::collections::HashMap::new();
805    let rows: Vec<serde_json::Value> = collections
806        .iter()
807        .map(|c| {
808            let id = c.id.get().copied().unwrap_or_default();
809            serde_json::json!({
810                "id": id,
811                "name": c.name,
812                "parent_id": c.parent_id,
813                // #318 — resolve the parent FK to its display name so the
814                // list shows "Photos" instead of a raw `#17`.
815                "parent_name": c.parent_id.and_then(|pid| by_id.get(&pid)).map(|p| p.name.clone()),
816                "sort_order": c.sort_order,
817                "depth": depth(c, &by_id, &mut depth_cache),
818                "media_count": counts.get(&id).copied().unwrap_or(0),
819                "created_at": c.created_at.get().copied(),
820            })
821        })
822        .collect();
823
824    let mut ctx = Context::new();
825    add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
826    add_admin_theme(&mut ctx, tenant.pool()).await;
827    ctx.insert("collections", &rows);
828    render_with_csrf(
829        &state,
830        &headers,
831        "rcms_admin/collections_list.html",
832        &mut ctx,
833    )
834}
835
836/// Form payload for create / rename of a collection.
837#[derive(Debug, Deserialize)]
838pub struct CollectionForm {
839    pub name: String,
840    #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
841    pub parent_id: Option<i64>,
842    #[serde(default)]
843    pub sort_order: Option<i32>,
844}
845
846/// POST /cms-admin/media/collections/new — create.
847pub async fn collections_create(
848    State(_state): State<super::AdminState>,
849    tenant: Tenant,
850    headers: HeaderMap,
851    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
852    Form(form): Form<CollectionForm>,
853) -> Result<Response, AdminError> {
854    let name = form.name.trim().to_owned();
855    if name.is_empty() {
856        return Err(AdminError::Validation(
857            "Collection name is required.".to_owned(),
858        ));
859    }
860    let mut row = crate::media::MediaCollection {
861        id: rustango::sql::Auto::Unset,
862        name: name.clone(),
863        parent_id: form.parent_id,
864        sort_order: form.sort_order.unwrap_or(100),
865        created_at: rustango::sql::Auto::Unset,
866    };
867    row.insert_pool(tenant.pool()).await?;
868    redirect_named_with_message_args(
869        "rcms-admin:media:collections",
870        MsgLevel::Success,
871        "Collection “{name}” created.",
872        &[("name", name.as_str())],
873        &headers,
874    )
875}
876
877/// POST /cms-admin/media/collections/{id}/edit — rename + re-parent
878/// + reorder. The form posts all three fields; missing parent_id
879/// (empty / "0") sends the collection to the root.
880pub async fn collections_edit(
881    State(_state): State<super::AdminState>,
882    tenant: Tenant,
883    headers: HeaderMap,
884    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
885    Path(id): Path<i64>,
886    Form(form): Form<CollectionForm>,
887) -> Result<Response, AdminError> {
888    let mut row = crate::media::MediaCollection::objects()
889        .where_(crate::media::MediaCollection::id.eq(id))
890        .first(tenant.pool())
891        .await?
892        .ok_or(AdminError::NotFound(id))?;
893    let name = form.name.trim().to_owned();
894    if name.is_empty() {
895        return Err(AdminError::Validation(
896            "Collection name is required.".to_owned(),
897        ));
898    }
899    // Guard against parent_id = self (would orphan the row from
900    // the tree walk).
901    if form.parent_id == Some(id) {
902        return Err(AdminError::Validation(
903            "A collection cannot be its own parent.".to_owned(),
904        ));
905    }
906    row.name = name;
907    row.parent_id = form.parent_id;
908    if let Some(so) = form.sort_order {
909        row.sort_order = so;
910    }
911    row.save_pool(tenant.pool()).await?;
912    redirect_named_with_message(
913        "rcms-admin:media:collections",
914        MsgLevel::Success,
915        "Collection saved.",
916        &headers,
917    )
918}
919
920/// POST /cms-admin/media/collections/{id}/delete — soft delete via
921/// re-parent then delete. Child collections are re-parented to the
922/// deleted row's parent; media rows lose their collection_id (FK
923/// nulls).
924pub async fn collections_delete(
925    State(_state): State<super::AdminState>,
926    tenant: Tenant,
927    headers: HeaderMap,
928    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
929    Path(id): Path<i64>,
930) -> Result<Response, AdminError> {
931    let row = crate::media::MediaCollection::objects()
932        .where_(crate::media::MediaCollection::id.eq(id))
933        .first(tenant.pool())
934        .await?
935        .ok_or(AdminError::NotFound(id))?;
936    let parent = row.parent_id;
937    let name = row.name.clone();
938    // Re-parent children so the subtree doesn't dangle.
939    for mut child in crate::media::MediaCollection::objects()
940        .where_(crate::media::MediaCollection::parent_id.eq(Some(id)))
941        .fetch(tenant.pool())
942        .await?
943    {
944        child.parent_id = parent;
945        child.save_pool(tenant.pool()).await?;
946    }
947    // Null out media references — media doesn't get deleted, just
948    // moves to "uncategorized".
949    for mut m in Media::objects()
950        .where_(Media::collection_id.eq(Some(id)))
951        .fetch(tenant.pool())
952        .await?
953    {
954        m.collection_id = None;
955        m.save_pool(tenant.pool()).await?;
956    }
957    row.delete_pool(tenant.pool()).await?;
958    redirect_named_with_message_args(
959        "rcms-admin:media:collections",
960        MsgLevel::Success,
961        "Collection “{name}” deleted. Children re-parented; media moved to Uncategorized.",
962        &[("name", name.as_str())],
963        &headers,
964    )
965}
966
967// ============================================================
968// #557 — Categories / Taxonomies admin
969//
970// One vocabulary registry (`cms_taxonomy`) + a per-vocabulary tree of
971// `cms_category` rows. The category editor renders as a `Vec<Widget>`
972// through the shared `_widget.html` macro — the same engine the page
973// editor uses: base fields (name/slug/description + featured-image /
974// thumbnail MediaPickers + parent Select) plus any extension widgets a
975// custom vocabulary's handler contributes.
976// ============================================================
977
978use crate::category::model::{self as category_model, Category, CategoryError};
979
980/// Flash-redirect back to a vocabulary's category tree.
981fn category_tree_redirect(
982    slug: &str,
983    headers: &HeaderMap,
984    level: MsgLevel,
985    key: &str,
986    args: &[(&str, &str)],
987) -> Result<Response, AdminError> {
988    let body = super::i18n::tr(headers, key, args);
989    let url = format!("/cms-admin/taxonomies/{slug}");
990    Ok(rustango::messages::redirect_with_message(
991        messages_secret(),
992        headers,
993        level,
994        &body,
995        &url,
996    ))
997}
998
999fn opt_i64_from_form(form: &std::collections::HashMap<String, String>, key: &str) -> Option<i64> {
1000    form.get(key)
1001        .map(|s| s.trim())
1002        .filter(|s| !s.is_empty())
1003        .and_then(|s| s.parse::<i64>().ok())
1004}
1005
1006/// The category editor's base fields as widgets (rendered via
1007/// `_widget.html`, same as page extension fields). `parent_opts` are the
1008/// selectable parents (excludes self on edit).
1009fn category_base_widgets(
1010    cat: Option<&Category>,
1011    parent_opts: Vec<(String, String)>,
1012) -> Vec<crate::widget::Widget> {
1013    use crate::widget::{Widget, WidgetKind};
1014    let mut opts = vec![(String::new(), "— none (top level) —".to_owned())];
1015    opts.extend(parent_opts);
1016    vec![
1017        Widget::new(WidgetKind::Text, "name", "Name")
1018            .required()
1019            .with_value(cat.map(|c| c.name.clone()).unwrap_or_default()),
1020        Widget::new(WidgetKind::Text, "slug", "Slug")
1021            .with_help("URL identifier — auto-generated from the name if left blank.")
1022            .with_value(cat.map(|c| c.slug.clone()).unwrap_or_default()),
1023        Widget::new(WidgetKind::Textarea, "description", "Description")
1024            .with_value(cat.map(|c| c.description.clone()).unwrap_or_default()),
1025        Widget::new(
1026            WidgetKind::MediaPicker,
1027            "featured_image_id",
1028            "Featured image",
1029        )
1030        .with_value(
1031            cat.and_then(|c| c.featured_image_id)
1032                .map(|i| i.to_string())
1033                .unwrap_or_default(),
1034        ),
1035        Widget::new(WidgetKind::MediaPicker, "thumbnail_id", "Thumbnail").with_value(
1036            cat.and_then(|c| c.thumbnail_id)
1037                .map(|i| i.to_string())
1038                .unwrap_or_default(),
1039        ),
1040        Widget::new(WidgetKind::Select, "parent_id", "Parent")
1041            .with_options(opts)
1042            .with_help("Nest this category under another (siblings share a parent).")
1043            .with_value(
1044                cat.and_then(|c| c.parent_id)
1045                    .map(|i| i.to_string())
1046                    .unwrap_or_default(),
1047            ),
1048    ]
1049}
1050
1051/// Build indented `(id, "— — Name")` parent options for a vocabulary,
1052/// optionally excluding `exclude` (and, on edit, its descendants can't be
1053/// picked — the move guard rejects that at save, so we only drop self here).
1054async fn category_parent_options(
1055    pool: &rustango::sql::Pool,
1056    taxonomy_id: i64,
1057    exclude: Option<i64>,
1058) -> Result<Vec<(String, String)>, AdminError> {
1059    let cats = category_model::all_in_taxonomy(pool, taxonomy_id)
1060        .await
1061        .map_err(|e| AdminError::Validation(e.to_string()))?;
1062    Ok(cats
1063        .iter()
1064        .filter(|c| c.id.get().copied() != exclude)
1065        .map(|c| {
1066            let indent = "— ".repeat((c.depth.max(1) - 1) as usize);
1067            (
1068                c.id.get().copied().unwrap_or_default().to_string(),
1069                format!("{indent}{}", c.name),
1070            )
1071        })
1072        .collect())
1073}
1074
1075/// GET /cms-admin/taxonomies — the vocabulary index.
1076pub async fn taxonomies_index(
1077    State(state): State<super::AdminState>,
1078    tenant: Tenant,
1079    headers: HeaderMap,
1080    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1081) -> Result<Response, AdminError> {
1082    let taxes = crate::category::taxonomies(tenant.pool())
1083        .await
1084        .map_err(|e| AdminError::Validation(e.to_string()))?;
1085    let all_cats: Vec<Category> = Category::objects().fetch(tenant.pool()).await?;
1086    let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
1087    for c in &all_cats {
1088        *counts.entry(c.taxonomy_id).or_insert(0) += 1;
1089    }
1090    let rows: Vec<serde_json::Value> = taxes
1091        .iter()
1092        .map(|t| {
1093            serde_json::json!({
1094                "slug": t.slug,
1095                "verbose_name": t.verbose_name,
1096                "icon": if t.icon.is_empty() { "sell".to_owned() } else { t.icon.clone() },
1097                "description": t.description,
1098                "hierarchical": t.hierarchical,
1099                "count": counts.get(&t.id.get().copied().unwrap_or_default()).copied().unwrap_or(0),
1100            })
1101        })
1102        .collect();
1103    let mut ctx = Context::new();
1104    add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1105    add_admin_theme(&mut ctx, tenant.pool()).await;
1106    ctx.insert("taxonomies", &rows);
1107    render_with_csrf(
1108        &state,
1109        &headers,
1110        "rcms_admin/taxonomies_list.html",
1111        &mut ctx,
1112    )
1113}
1114
1115/// GET /cms-admin/taxonomies/{slug} — one vocabulary's category tree.
1116pub async fn category_tree(
1117    State(state): State<super::AdminState>,
1118    tenant: Tenant,
1119    headers: HeaderMap,
1120    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1121    Path(slug): Path<String>,
1122) -> Result<Response, AdminError> {
1123    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1124        .await
1125        .map_err(|e| AdminError::Validation(e.to_string()))?
1126        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1127    let cats =
1128        category_model::all_in_taxonomy(tenant.pool(), tax.id.get().copied().unwrap_or_default())
1129            .await
1130            .map_err(|e| AdminError::Validation(e.to_string()))?;
1131    let rows: Vec<serde_json::Value> = cats
1132        .iter()
1133        .map(|c| {
1134            serde_json::json!({
1135                "id": c.id.get().copied(),
1136                "name": c.name,
1137                "slug": c.slug,
1138                "description": c.description,
1139                "depth": c.depth,
1140                "thumbnail_id": c.thumbnail_id,
1141                "featured_image_id": c.featured_image_id,
1142            })
1143        })
1144        .collect();
1145    let mut ctx = Context::new();
1146    add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1147    add_admin_theme(&mut ctx, tenant.pool()).await;
1148    ctx.insert("taxonomy_slug", &tax.slug);
1149    ctx.insert("taxonomy_name", &tax.verbose_name);
1150    ctx.insert("categories", &rows);
1151    render_with_csrf(&state, &headers, "rcms_admin/category_tree.html", &mut ctx)
1152}
1153
1154/// GET /cms-admin/taxonomies/{slug}/categories/new — create form.
1155pub async fn category_new_form(
1156    State(state): State<super::AdminState>,
1157    tenant: Tenant,
1158    headers: HeaderMap,
1159    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1160    Path(slug): Path<String>,
1161) -> Result<Response, AdminError> {
1162    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1163        .await
1164        .map_err(|e| AdminError::Validation(e.to_string()))?
1165        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1166    let tid = tax.id.get().copied().unwrap_or_default();
1167    let mut fields = if tax.hierarchical {
1168        category_base_widgets(
1169            None,
1170            category_parent_options(tenant.pool(), tid, None).await?,
1171        )
1172    } else {
1173        // Flat vocabulary — drop the parent picker.
1174        let mut w = category_base_widgets(None, Vec::new());
1175        w.pop();
1176        w
1177    };
1178    // Extension fields are edited after create (they key on the new id).
1179    let _ = &mut fields;
1180    let mut ctx = Context::new();
1181    add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1182    add_admin_theme(&mut ctx, tenant.pool()).await;
1183    ctx.insert("taxonomy_slug", &tax.slug);
1184    ctx.insert("taxonomy_name", &tax.verbose_name);
1185    ctx.insert("mode", "new");
1186    ctx.insert("fields", &fields);
1187    render_with_csrf(&state, &headers, "rcms_admin/category_form.html", &mut ctx)
1188}
1189
1190/// POST /cms-admin/taxonomies/{slug}/categories/new — create.
1191pub async fn category_create(
1192    State(_state): State<super::AdminState>,
1193    tenant: Tenant,
1194    headers: HeaderMap,
1195    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1196    Path(slug): Path<String>,
1197    Form(form): Form<std::collections::HashMap<String, String>>,
1198) -> Result<Response, AdminError> {
1199    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1200        .await
1201        .map_err(|e| AdminError::Validation(e.to_string()))?
1202        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1203    let tid = tax.id.get().copied().unwrap_or_default();
1204    let new = category_model::NewCategory {
1205        name: form
1206            .get("name")
1207            .cloned()
1208            .unwrap_or_default()
1209            .trim()
1210            .to_owned(),
1211        slug: form.get("slug").cloned().unwrap_or_default(),
1212        description: form.get("description").cloned().unwrap_or_default(),
1213        featured_image_id: opt_i64_from_form(&form, "featured_image_id"),
1214        thumbnail_id: opt_i64_from_form(&form, "thumbnail_id"),
1215        parent_id: opt_i64_from_form(&form, "parent_id"),
1216    };
1217    if new.name.is_empty() {
1218        return category_tree_redirect(
1219            &slug,
1220            &headers,
1221            MsgLevel::Error,
1222            "Category name is required.",
1223            &[],
1224        );
1225    }
1226    match category_model::create(tenant.pool(), tid, new).await {
1227        Ok(cat) => {
1228            let id = cat.id.get().copied().unwrap_or_default();
1229            let body = super::i18n::tr(
1230                &headers,
1231                "Category “{name}” created.",
1232                &[("name", cat.name.as_str())],
1233            );
1234            let url = format!("/cms-admin/taxonomies/{slug}/categories/{id}/edit");
1235            Ok(rustango::messages::redirect_with_message(
1236                messages_secret(),
1237                &headers,
1238                MsgLevel::Success,
1239                &body,
1240                &url,
1241            ))
1242        }
1243        Err(e) => category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]),
1244    }
1245}
1246
1247/// GET /cms-admin/taxonomies/{slug}/categories/{id}/edit — edit form.
1248pub async fn category_edit_form(
1249    State(state): State<super::AdminState>,
1250    tenant: Tenant,
1251    headers: HeaderMap,
1252    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1253    Path((slug, id)): Path<(String, i64)>,
1254    Query(q): Query<EditQuery>,
1255) -> Result<Response, AdminError> {
1256    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1257        .await
1258        .map_err(|e| AdminError::Validation(e.to_string()))?
1259        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1260    let tid = tax.id.get().copied().unwrap_or_default();
1261    let cat = Category::objects()
1262        .where_(Category::id.eq(id))
1263        .where_(Category::taxonomy_id.eq(tid))
1264        .first(tenant.pool())
1265        .await?
1266        .ok_or(AdminError::NotFound(id))?;
1267    let mut fields = if tax.hierarchical {
1268        category_base_widgets(
1269            Some(&cat),
1270            category_parent_options(tenant.pool(), tid, Some(id)).await?,
1271        )
1272    } else {
1273        let mut w = category_base_widgets(Some(&cat), Vec::new());
1274        w.pop();
1275        w
1276    };
1277    // Extension widgets from the vocabulary's handler (custom typed fields).
1278    if let Some(handler) = crate::category::find_handler(&slug) {
1279        if let Ok(ext) = handler.ext_widgets(tenant.pool(), id).await {
1280            fields.extend(ext);
1281        }
1282    }
1283    let mut ctx = Context::new();
1284    add_chrome(&mut ctx, &tenant, "taxonomies", session_user.as_ref()).await;
1285    add_admin_theme(&mut ctx, tenant.pool()).await;
1286    ctx.insert("taxonomy_slug", &tax.slug);
1287    ctx.insert("taxonomy_name", &tax.verbose_name);
1288    ctx.insert("mode", "edit");
1289    ctx.insert("category_id", &id);
1290    ctx.insert("fields", &fields);
1291    // #862 — `?locale=<code>` (a non-default active locale) shows the
1292    // name's translation beside the original, like pages and snippets.
1293    let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
1294        .where_(crate::locale::Locale::active.eq(true))
1295        .order_by(&[("sort_order", false), ("code", false)])
1296        .fetch(tenant.pool())
1297        .await?;
1298    let editing_locale = q
1299        .locale
1300        .as_deref()
1301        .filter(|c| !c.is_empty())
1302        .and_then(|code| locales.iter().find(|l| l.code == code && !l.is_default).cloned());
1303    if let Some(loc) = &editing_locale {
1304        let lid = loc.id.get().copied().unwrap_or_default();
1305        let mut existing = crate::category_translation::fetch_for_categories(tenant.pool(), &[id], lid)
1306            .await
1307            .unwrap_or_default();
1308        ctx.insert("translation_mode", &true);
1309        ctx.insert("editing_locale", loc);
1310        ctx.insert("category_name", &cat.name);
1311        ctx.insert("tr_name", &existing.remove(&id).and_then(|mut f| f.remove("name")).unwrap_or_default());
1312    }
1313    ctx.insert("locales", &locales);
1314    render_with_csrf(&state, &headers, "rcms_admin/category_form.html", &mut ctx)
1315}
1316
1317/// POST /cms-admin/taxonomies/{slug}/categories/{id}/translate?locale=<code>
1318/// — save a category's per-locale name. An empty box deletes the
1319/// row, so the original shows again.
1320pub async fn category_translate_submit(
1321    State(_state): State<super::AdminState>,
1322    tenant: Tenant,
1323    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1324    Path((slug, id)): Path<(String, i64)>,
1325    Query(q): Query<EditQuery>,
1326    Form(form): Form<std::collections::HashMap<String, String>>,
1327) -> Result<Response, AdminError> {
1328    use crate::category_translation::{CategoryTranslation, TRANSLATABLE_FIELDS};
1329    let code = q
1330        .locale
1331        .as_deref()
1332        .filter(|c| !c.is_empty())
1333        .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
1334    let locale = crate::locale::Locale::objects()
1335        .where_(crate::locale::Locale::code.eq(code.to_owned()))
1336        .where_(crate::locale::Locale::active.eq(true))
1337        .where_(crate::locale::Locale::is_default.eq(false))
1338        .first(tenant.pool())
1339        .await?
1340        .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
1341    let locale_id = locale.id.get().copied().unwrap_or_default();
1342    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1343        .await
1344        .map_err(|e| AdminError::Validation(e.to_string()))?
1345        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1346    Category::objects()
1347        .where_(Category::id.eq(id))
1348        .where_(Category::taxonomy_id.eq(tax.id.get().copied().unwrap_or_default()))
1349        .first(tenant.pool())
1350        .await?
1351        .ok_or(AdminError::NotFound(id))?;
1352    rustango::atomic!(tenant.pool(), |tx| {
1353        let mut guard = tx.lock().await?;
1354        let tx = &mut *guard;
1355        for field in TRANSLATABLE_FIELDS {
1356            let Some(value) = form.get(&format!("tr__{field}")) else {
1357                continue;
1358            };
1359            let value = value.trim().to_owned();
1360            let existing: Vec<CategoryTranslation> = CategoryTranslation::objects()
1361                .where_(CategoryTranslation::category_id.eq(id))
1362                .where_(CategoryTranslation::locale_id.eq(locale_id))
1363                .where_(CategoryTranslation::field_path.eq(field.to_owned()))
1364                .fetch_tx(tx)
1365                .await?;
1366            if value.is_empty() {
1367                for row in existing {
1368                    row.delete_tx(tx).await?;
1369                }
1370            } else if let Some(mut row) = existing.into_iter().next() {
1371                row.value = value;
1372                row.save_tx(tx).await?;
1373            } else {
1374                let mut row = CategoryTranslation {
1375                    id: rustango::sql::Auto::Unset,
1376                    category_id: id,
1377                    locale_id,
1378                    field_path: field.to_owned(),
1379                    value,
1380                    updated_at: rustango::sql::Auto::Unset,
1381                };
1382                row.save_tx(tx).await?;
1383            }
1384        }
1385        Ok::<_, rustango::sql::ExecError>(())
1386    })
1387    .await?;
1388    Ok(Redirect::to(&format!("/cms-admin/taxonomies/{slug}/categories/{id}/edit?locale={code}")).into_response())
1389}
1390
1391/// POST /cms-admin/taxonomies/{slug}/categories/{id}/edit — update.
1392pub async fn category_update(
1393    State(_state): State<super::AdminState>,
1394    tenant: Tenant,
1395    headers: HeaderMap,
1396    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1397    Path((slug, id)): Path<(String, i64)>,
1398    Form(form): Form<std::collections::HashMap<String, String>>,
1399) -> Result<Response, AdminError> {
1400    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1401        .await
1402        .map_err(|e| AdminError::Validation(e.to_string()))?
1403        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1404    let tid = tax.id.get().copied().unwrap_or_default();
1405    let new = category_model::NewCategory {
1406        name: form
1407            .get("name")
1408            .cloned()
1409            .unwrap_or_default()
1410            .trim()
1411            .to_owned(),
1412        slug: form.get("slug").cloned().unwrap_or_default(),
1413        description: form.get("description").cloned().unwrap_or_default(),
1414        featured_image_id: opt_i64_from_form(&form, "featured_image_id"),
1415        thumbnail_id: opt_i64_from_form(&form, "thumbnail_id"),
1416        parent_id: opt_i64_from_form(&form, "parent_id"),
1417    };
1418    if new.name.is_empty() {
1419        return category_tree_redirect(
1420            &slug,
1421            &headers,
1422            MsgLevel::Error,
1423            "Category name is required.",
1424            &[],
1425        );
1426    }
1427    let new_parent = new.parent_id;
1428    if let Err(e) = category_model::update(tenant.pool(), tid, id, new).await {
1429        return category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]);
1430    }
1431    // Re-parent if the parent changed (cycle-guarded inside move_to;
1432    // a no-op when the parent is unchanged).
1433    if let Err(e) = category_model::move_to(tenant.pool(), tid, id, new_parent).await {
1434        return category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]);
1435    }
1436    // Extension row (custom vocabularies).
1437    if let Some(handler) = crate::category::find_handler(&slug) {
1438        if let Err(e) = handler.save_ext(tenant.pool(), id, &form).await {
1439            tracing::warn!(category_id = id, error = %e, "category extension save failed");
1440        }
1441    }
1442    category_tree_redirect(&slug, &headers, MsgLevel::Success, "Category saved.", &[])
1443}
1444
1445/// POST /cms-admin/taxonomies/{slug}/categories/{id}/delete.
1446pub async fn category_delete(
1447    State(_state): State<super::AdminState>,
1448    tenant: Tenant,
1449    headers: HeaderMap,
1450    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
1451    Path((slug, id)): Path<(String, i64)>,
1452) -> Result<Response, AdminError> {
1453    let tax = crate::category::find_taxonomy(tenant.pool(), &slug)
1454        .await
1455        .map_err(|e| AdminError::Validation(e.to_string()))?
1456        .ok_or_else(|| AdminError::Validation(format!("unknown taxonomy `{slug}`")))?;
1457    let tid = tax.id.get().copied().unwrap_or_default();
1458    match category_model::delete(tenant.pool(), tid, id, false).await {
1459        Ok(_) => {
1460            category_tree_redirect(&slug, &headers, MsgLevel::Success, "Category deleted.", &[])
1461        }
1462        Err(CategoryError::HasChildren(_, n)) => {
1463            let n = n.to_string();
1464            category_tree_redirect(
1465                &slug,
1466                &headers,
1467                MsgLevel::Error,
1468                "Can't delete a category with {count} child categor(ies) — delete or move them first.",
1469                &[("count", n.as_str())],
1470            )
1471        }
1472        Err(e) => category_tree_redirect(&slug, &headers, MsgLevel::Error, &e.to_string(), &[]),
1473    }
1474}
1475
1476// ============================================================
1477// #559/#562 — Page-type field builder (visual schema constructor)
1478//
1479// A Developer authors a page type's body schema in the builder; save
1480// writes a DRAFT row, publish flips it live (versioned). Gated on the
1481// `cms_page_type.build` codename at the handler level (superuser bypass).
1482// ============================================================
1483
1484/// Deny access to the builder unless the user is a superuser or holds
1485/// `cms_page_type.build`. Returns `Some(redirect)` when denied (anon →
1486/// login, otherwise → no-access), `None` when allowed.
1487async fn ensure_builder_access(
1488    tenant: &Tenant,
1489    user: Option<&rustango::tenancy::auth::User>,
1490) -> Option<Response> {
1491    super::codename_gate(tenant, user, "cms_page_type.build").await
1492}
1493
1494/// GET /cms-admin/page-types/{id}/build — the visual builder.
1495pub async fn page_type_build_form(
1496    State(state): State<super::AdminState>,
1497    tenant: Tenant,
1498    headers: HeaderMap,
1499    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1500    Path(id): Path<i64>,
1501) -> Result<Response, AdminError> {
1502    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1503        return Ok(r);
1504    }
1505    let pt = crate::page_type_model::PageType::objects()
1506        .where_(crate::page_type_model::PageType::id.eq(id))
1507        .first(tenant.pool())
1508        .await?
1509        .ok_or(AdminError::NotFound(id))?;
1510
1511    let draft = crate::page_builder::model::draft_for(tenant.pool(), id).await?;
1512    let published = crate::page_builder::model::published_for(tenant.pool(), id).await?;
1513    // Seed the canvas from the draft, else the live published schema,
1514    // else an empty document.
1515    let doc_value = draft
1516        .as_ref()
1517        .map(|d| d.document.clone())
1518        .or_else(|| published.as_ref().map(|p| p.document.clone()))
1519        .unwrap_or_else(|| serde_json::json!({ "nodes": [] }));
1520    let schema_json =
1521        serde_json::to_string(&doc_value).unwrap_or_else(|_| "{\"nodes\":[]}".to_owned());
1522
1523    let components: Vec<serde_json::Value> =
1524        crate::page_builder::model::all_components(tenant.pool())
1525            .await?
1526            .iter()
1527            .map(|c| serde_json::json!({ "slug": c.slug, "label": c.label }))
1528            .collect();
1529    let components_json = serde_json::to_string(&components).unwrap_or_else(|_| "[]".to_owned());
1530    let versions: Vec<serde_json::Value> =
1531        crate::page_builder::model::list_versions(tenant.pool(), id)
1532            .await?
1533            .iter()
1534            .map(|v| {
1535                serde_json::json!({
1536                    "version": v.version,
1537                    "status": v.status,
1538                    "updated_at": v.updated_at.get().copied(),
1539                })
1540            })
1541            .collect();
1542
1543    // #566 — deleting a UI-created type is a danger-zone action on this
1544    // page (not an inline row action). Only for `cms_ui` types, and only
1545    // while no pages use the type.
1546    let is_ui_type = pt.app_label == "cms_ui";
1547    let page_count = if is_ui_type {
1548        Page::objects()
1549            .where_(Page::page_type_id.eq(id))
1550            .fetch(tenant.pool())
1551            .await
1552            .map(|v| v.len())
1553            .unwrap_or(0)
1554    } else {
1555        0
1556    };
1557
1558    let mut ctx = Context::new();
1559    add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
1560    add_admin_theme(&mut ctx, tenant.pool()).await;
1561    ctx.insert("page_type_id", &id);
1562    ctx.insert("title", &pt.verbose_name);
1563    ctx.insert("schema_json", &schema_json);
1564    ctx.insert("build_url", &format!("/cms-admin/page-types/{id}/build"));
1565    ctx.insert(
1566        "publish_url",
1567        &format!("/cms-admin/page-types/{id}/build/publish"),
1568    );
1569    ctx.insert("delete_url", &format!("/cms-admin/page-types/{id}/delete"));
1570    ctx.insert("list_url", "/cms-admin/page-types");
1571    ctx.insert("components_json", &components_json);
1572    ctx.insert("versions", &versions);
1573    ctx.insert("has_unpublished", &draft.is_some());
1574    // #863 — the Translate menu: other languages, once the schema is live.
1575    let translate_locales: Vec<crate::locale::Locale> = if published.is_some() {
1576        crate::locale::Locale::objects()
1577            .where_(crate::locale::Locale::active.eq(true))
1578            .where_(crate::locale::Locale::is_default.eq(false))
1579            .order_by(&[("sort_order", false), ("code", false)])
1580            .fetch(tenant.pool())
1581            .await?
1582    } else {
1583        Vec::new()
1584    };
1585    ctx.insert("translate_locales", &translate_locales);
1586    ctx.insert("translate_url", &format!("/cms-admin/page-types/{id}/translate"));
1587    ctx.insert("is_ui_type", &is_ui_type);
1588    ctx.insert("page_count", &page_count);
1589    ctx.insert("deletable", &(is_ui_type && page_count == 0));
1590    render_with_csrf(
1591        &state,
1592        &headers,
1593        "rcms_admin/page_type_builder.html",
1594        &mut ctx,
1595    )
1596}
1597
1598/// GET /cms-admin/page-types/{id}/translate?locale=<code> — the labels of
1599/// the type's choice options in another language, side by side
1600/// with the originals like every other translation screen.
1601pub async fn page_type_translate_form(
1602    State(state): State<super::AdminState>,
1603    tenant: Tenant,
1604    headers: HeaderMap,
1605    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1606    Path(id): Path<i64>,
1607    Query(q): Query<EditQuery>,
1608) -> Result<Response, AdminError> {
1609    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1610        return Ok(r);
1611    }
1612    let pt = crate::page_type_model::PageType::objects()
1613        .where_(crate::page_type_model::PageType::id.eq(id))
1614        .first(tenant.pool())
1615        .await?
1616        .ok_or(AdminError::NotFound(id))?;
1617    let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
1618    let published = crate::page_builder::model::published_for(tenant.pool(), id).await?;
1619    let fields = published
1620        .as_ref()
1621        .map(|p| crate::page_builder::choice_i18n::choice_fields(&p.document, &locale.code))
1622        .unwrap_or_default();
1623    let mut ctx = Context::new();
1624    add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
1625    add_admin_theme(&mut ctx, tenant.pool()).await;
1626    ctx.insert("title", &pt.verbose_name);
1627    ctx.insert("editing_locale", &locale);
1628    ctx.insert("choice_fields", &fields);
1629    ctx.insert("build_url", &format!("/cms-admin/page-types/{id}/build"));
1630    ctx.insert("translate_url", &format!("/cms-admin/page-types/{id}/translate"));
1631    render_with_csrf(&state, &headers, "rcms_admin/page_type_translate.html", &mut ctx)
1632}
1633
1634/// POST /cms-admin/page-types/{id}/translate?locale=<code> — store the
1635/// option labels (`tr__<field path>__<option value>`) on the published
1636/// schema and on the draft, if one is open, so publishing it keeps them.
1637pub async fn page_type_translate_submit(
1638    State(_state): State<super::AdminState>,
1639    tenant: Tenant,
1640    headers: HeaderMap,
1641    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1642    Path(id): Path<i64>,
1643    Query(q): Query<EditQuery>,
1644    Form(form): Form<Vec<(String, String)>>,
1645) -> Result<Response, AdminError> {
1646    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1647        return Ok(r);
1648    }
1649    let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
1650    let labels: std::collections::HashMap<(String, String), String> = form
1651        .into_iter()
1652        .filter_map(|(k, v)| {
1653            let rest = k.strip_prefix("tr__")?;
1654            let (path, value) = rest.split_once("__")?;
1655            Some(((path.to_owned(), value.to_owned()), v))
1656        })
1657        .collect();
1658    for row in [
1659        crate::page_builder::model::published_for(tenant.pool(), id).await?,
1660        crate::page_builder::model::draft_for(tenant.pool(), id).await?,
1661    ]
1662    .into_iter()
1663    .flatten()
1664    {
1665        let mut row = row;
1666        if crate::page_builder::choice_i18n::set_choice_labels(&mut row.document, &locale.code, &labels) > 0 {
1667            row.save_pool(tenant.pool()).await?;
1668        }
1669    }
1670    let back = format!("/cms-admin/page-types/{id}/translate?locale={}", locale.code);
1671    Ok(rustango::messages::redirect_with_message(
1672        messages_secret(),
1673        &headers,
1674        MsgLevel::Success,
1675        &super::i18n::tr(&headers, "Translations saved.", &[]),
1676        &back,
1677    ))
1678}
1679
1680/// The active, non-default locale named by `?locale=`, for the
1681/// translation screens.
1682async fn translate_locale(tenant: &Tenant, code: Option<&str>) -> Result<crate::locale::Locale, AdminError> {
1683    let code = code
1684        .filter(|c| !c.is_empty())
1685        .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
1686    crate::locale::Locale::objects()
1687        .where_(crate::locale::Locale::code.eq(code.to_owned()))
1688        .where_(crate::locale::Locale::active.eq(true))
1689        .where_(crate::locale::Locale::is_default.eq(false))
1690        .first(tenant.pool())
1691        .await?
1692        .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))
1693}
1694
1695/// Shared body for save/publish: gate, load the page type, parse +
1696/// validate the posted schema. Returns the validated document + the
1697/// problem list, or an early access/redirect / not-found response.
1698async fn parse_builder_submit(
1699    tenant: &Tenant,
1700    user: Option<&rustango::tenancy::auth::User>,
1701    id: i64,
1702    schema_str: &str,
1703) -> Result<Result<(crate::page_builder::Document, Vec<String>), Response>, AdminError> {
1704    if let Some(r) = ensure_builder_access(tenant, user).await {
1705        return Ok(Err(r));
1706    }
1707    // Ensure the page type exists.
1708    let exists = crate::page_type_model::PageType::objects()
1709        .where_(crate::page_type_model::PageType::id.eq(id))
1710        .first(tenant.pool())
1711        .await?
1712        .is_some();
1713    if !exists {
1714        return Err(AdminError::NotFound(id));
1715    }
1716    let value: serde_json::Value = serde_json::from_str(schema_str)
1717        .map_err(|e| AdminError::Validation(format!("invalid schema JSON: {e}")))?;
1718    let doc = crate::page_builder::parse_schema(&value)
1719        .map_err(|e| AdminError::Validation(format!("invalid schema document: {e}")))?;
1720    let components = crate::page_builder::model::component_map(tenant.pool()).await?;
1721    let problems = crate::page_builder::validate_schema(&doc, &components);
1722    Ok(Ok((doc, problems)))
1723}
1724
1725/// POST /cms-admin/page-types/{id}/build — save the schema as a draft.
1726/// Warnings are non-blocking (surfaced in the flash).
1727pub async fn page_type_build_submit(
1728    State(_state): State<super::AdminState>,
1729    tenant: Tenant,
1730    headers: HeaderMap,
1731    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1732    Path(id): Path<i64>,
1733    Form(form): Form<FormBuildSubmit>,
1734) -> Result<Response, AdminError> {
1735    let (doc, problems) =
1736        match parse_builder_submit(&tenant, session_user.as_ref(), id, &form.schema).await? {
1737            Ok(v) => v,
1738            Err(resp) => return Ok(resp),
1739        };
1740    let document =
1741        serde_json::to_value(&doc).unwrap_or_else(|_| serde_json::json!({ "nodes": [] }));
1742    let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
1743    crate::page_builder::model::save_draft(tenant.pool(), id, document, created_by).await?;
1744    let (level, msg) = if problems.is_empty() {
1745        (MsgLevel::Success, "Draft saved.".to_owned())
1746    } else {
1747        (
1748            MsgLevel::Warning,
1749            format!("Draft saved with warnings: {}", problems.join(" ")),
1750        )
1751    };
1752    redirect_named_with_params_and_message(
1753        "rcms-admin:page-types:build",
1754        &[("id", id.to_string())],
1755        level,
1756        &msg,
1757        &headers,
1758    )
1759}
1760
1761/// POST /cms-admin/page-types/{id}/build/publish — validate + publish the
1762/// schema. Validation errors block the publish (draft is still saved).
1763pub async fn page_type_publish_submit(
1764    State(_state): State<super::AdminState>,
1765    tenant: Tenant,
1766    headers: HeaderMap,
1767    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1768    Path(id): Path<i64>,
1769    Form(form): Form<FormBuildSubmit>,
1770) -> Result<Response, AdminError> {
1771    let (doc, problems) =
1772        match parse_builder_submit(&tenant, session_user.as_ref(), id, &form.schema).await? {
1773            Ok(v) => v,
1774            Err(resp) => return Ok(resp),
1775        };
1776    // Persist what's on screen as the draft first, so a blocked publish
1777    // still saves the editor's work.
1778    let document =
1779        serde_json::to_value(&doc).unwrap_or_else(|_| serde_json::json!({ "nodes": [] }));
1780    let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
1781    crate::page_builder::model::save_draft(tenant.pool(), id, document, created_by).await?;
1782    if !problems.is_empty() {
1783        return redirect_named_with_params_and_message(
1784            "rcms-admin:page-types:build",
1785            &[("id", id.to_string())],
1786            MsgLevel::Error,
1787            &format!("Can't publish — fix these first: {}", problems.join(" ")),
1788            &headers,
1789        );
1790    }
1791    crate::page_builder::model::publish(tenant.pool(), id).await?;
1792    redirect_named_with_params_and_message(
1793        "rcms-admin:page-types:build",
1794        &[("id", id.to_string())],
1795        MsgLevel::Success,
1796        "Schema published — the page editor now uses this structure.",
1797        &headers,
1798    )
1799}
1800
1801/// Persist a page's page-builder body values from a posted form, when
1802/// its page type has a published schema. Additive to any code
1803/// handler's `save_extension` — runs regardless of whether a handler
1804/// exists.
1805///
1806/// # Errors
1807/// A failed schema/component lookup or value write. A type with no
1808/// published schema, or one that no longer parses, has nothing to save.
1809pub(crate) async fn save_page_builder_values(
1810    pool: &rustango::sql::Pool,
1811    page_type_id: i64,
1812    page_id: i64,
1813    form_map: &std::collections::HashMap<String, String>,
1814) -> Result<(), rustango::sql::ExecError> {
1815    let Some(row) = crate::page_builder::model::published_for(pool, page_type_id).await? else {
1816        return Ok(());
1817    };
1818    let Ok(doc) = crate::page_builder::parse_schema(&row.document) else {
1819        return Ok(());
1820    };
1821    let components = crate::page_builder::model::component_map(pool).await?;
1822    let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
1823    crate::page_builder::values::save_from_form(pool, page_id, &compiled, form_map).await
1824}
1825
1826/// GET-side: build the editor HTML + rules island + upgrade flag for a
1827/// page whose type has a published schema. Returns `None` when
1828/// the type has no published schema.
1829async fn page_builder_editor_ctx(
1830    tenant: &Tenant,
1831    tera: &tera::Tera,
1832    page_id: i64,
1833    page_type_id: i64,
1834    held: Option<&std::collections::HashMap<String, String>>,
1835) -> Option<(String, String, bool)> {
1836    let row = crate::page_builder::model::published_for(tenant.pool(), page_type_id)
1837        .await
1838        .ok()??;
1839    let doc = crate::page_builder::parse_schema(&row.document).ok()?;
1840    let components = crate::page_builder::model::component_map(tenant.pool())
1841        .await
1842        .unwrap_or_default();
1843    let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
1844    let (mut values, report) =
1845        crate::page_builder::values::load_upgraded(tenant.pool(), page_id, &compiled)
1846            .await
1847            .unwrap_or_else(|_| (serde_json::json!({}), Default::default()));
1848    // A change held for review shows in place of the stored values.
1849    if let Some(form) = held {
1850        values = serde_json::Value::Object(crate::page_builder::values::build_values(&compiled, form));
1851    }
1852    let html =
1853        crate::page_builder::values::render_body(&compiled, &values, tera);
1854    // Conditional-rules island: `[{field, rule}]` for page_builder_rules.js.
1855    let rules: Vec<serde_json::Value> = compiled
1856        .rules
1857        .iter()
1858        .map(|r| serde_json::json!({ "field": r.field, "rule": r.rule }))
1859        .collect();
1860    let rules_json = serde_json::to_string(&rules).unwrap_or_else(|_| "[]".to_owned());
1861    Some((html, rules_json, report.upgraded))
1862}
1863
1864// ---- #563 reusable components library -----------------------------------
1865
1866/// GET /cms-admin/components — the library list (Developer-gated).
1867pub async fn components_index(
1868    State(state): State<super::AdminState>,
1869    tenant: Tenant,
1870    headers: HeaderMap,
1871    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1872) -> Result<Response, AdminError> {
1873    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1874        return Ok(r);
1875    }
1876    let comps = crate::page_builder::model::all_components(tenant.pool()).await?;
1877    let mut rows = Vec::with_capacity(comps.len());
1878    for c in &comps {
1879        let refs = crate::page_builder::model::component_references(tenant.pool(), &c.slug)
1880            .await
1881            .unwrap_or_default();
1882        rows.push(serde_json::json!({
1883            "id": c.id.get().copied(),
1884            "slug": c.slug,
1885            "label": c.label,
1886            "icon": if c.icon.is_empty() { "extension".to_owned() } else { c.icon.clone() },
1887            "description": c.description,
1888            "version": c.version,
1889            "ref_count": refs.len(),
1890        }));
1891    }
1892    let mut ctx = Context::new();
1893    add_chrome(&mut ctx, &tenant, "components", session_user.as_ref()).await;
1894    add_admin_theme(&mut ctx, tenant.pool()).await;
1895    ctx.insert("components", &rows);
1896    ctx.insert("new_url", "/cms-admin/components/new");
1897    render_with_csrf(
1898        &state,
1899        &headers,
1900        "rcms_admin/components_list.html",
1901        &mut ctx,
1902    )
1903}
1904
1905/// Shared render of the component builder shell (new + edit + error re-render).
1906#[allow(clippy::too_many_arguments)]
1907async fn render_component_builder(
1908    state: &super::AdminState,
1909    headers: &HeaderMap,
1910    tenant: &Tenant,
1911    user: Option<&rustango::tenancy::auth::User>,
1912    id: Option<i64>,
1913    slug: &str,
1914    label: &str,
1915    icon: &str,
1916    description: &str,
1917    schema_json: &str,
1918    error: Option<&str>,
1919) -> Result<Response, AdminError> {
1920    let mut ctx = Context::new();
1921    add_chrome(&mut ctx, tenant, "components", user).await;
1922    add_admin_theme(&mut ctx, tenant.pool()).await;
1923    ctx.insert("component_id", &id);
1924    ctx.insert("slug", slug);
1925    ctx.insert("label", label);
1926    ctx.insert("icon", icon);
1927    ctx.insert("description", description);
1928    ctx.insert("schema_json", schema_json);
1929    ctx.insert("is_edit", &id.is_some());
1930    let save_url = match id {
1931        Some(cid) => format!("/cms-admin/components/{cid}/edit"),
1932        None => "/cms-admin/components/new".to_owned(),
1933    };
1934    ctx.insert("save_url", &save_url);
1935    ctx.insert("list_url", "/cms-admin/components");
1936    if let Some(e) = error {
1937        ctx.insert("error", e);
1938    }
1939    render_with_csrf(
1940        state,
1941        headers,
1942        "rcms_admin/component_builder.html",
1943        &mut ctx,
1944    )
1945}
1946
1947/// GET /cms-admin/components/new — empty component builder (fields + rows).
1948pub async fn component_new_form(
1949    State(state): State<super::AdminState>,
1950    tenant: Tenant,
1951    headers: HeaderMap,
1952    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1953) -> Result<Response, AdminError> {
1954    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1955        return Ok(r);
1956    }
1957    render_component_builder(
1958        &state,
1959        &headers,
1960        &tenant,
1961        session_user.as_ref(),
1962        None,
1963        "",
1964        "",
1965        "",
1966        "",
1967        "{\"nodes\":[]}",
1968        None,
1969    )
1970    .await
1971}
1972
1973/// GET /cms-admin/components/{id}/edit — builder seeded from the stored doc.
1974pub async fn component_edit_form(
1975    State(state): State<super::AdminState>,
1976    tenant: Tenant,
1977    headers: HeaderMap,
1978    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
1979    Path(id): Path<i64>,
1980) -> Result<Response, AdminError> {
1981    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
1982        return Ok(r);
1983    }
1984    let c = crate::page_builder::model::component_by_id(tenant.pool(), id)
1985        .await?
1986        .ok_or(AdminError::NotFound(id))?;
1987    // The builder JS reads `{nodes:[…]}`; a component doc stores `children`.
1988    let doc: crate::page_builder::schema::ComponentDoc =
1989        serde_json::from_value(c.document.clone()).unwrap_or_default();
1990    let schema_json =
1991        serde_json::to_string(&serde_json::json!({ "nodes": doc.children })).unwrap_or_default();
1992    render_component_builder(
1993        &state,
1994        &headers,
1995        &tenant,
1996        session_user.as_ref(),
1997        Some(id),
1998        &c.slug,
1999        &c.label,
2000        &c.icon,
2001        &c.description,
2002        &schema_json,
2003        None,
2004    )
2005    .await
2006}
2007
2008/// Parse the posted `{nodes:[…]}` into a validated [`ComponentDoc`].
2009/// `Ok(doc)` on success; `Err(problems)` with the editor-facing errors.
2010fn parse_component_doc(
2011    schema_str: &str,
2012) -> Result<crate::page_builder::schema::ComponentDoc, String> {
2013    let value: serde_json::Value =
2014        serde_json::from_str(schema_str).map_err(|e| format!("invalid schema JSON: {e}"))?;
2015    let doc = crate::page_builder::parse_schema(&value)
2016        .map_err(|e| format!("invalid schema document: {e}"))?;
2017    let cdoc = crate::page_builder::schema::ComponentDoc {
2018        label_format: None,
2019        children: doc.nodes,
2020    };
2021    let problems = crate::page_builder::schema::validate_component(&cdoc);
2022    if problems.is_empty() {
2023        Ok(cdoc)
2024    } else {
2025        Err(problems.join(" "))
2026    }
2027}
2028
2029/// POST /cms-admin/components/new — create a component (version 1).
2030pub async fn component_create(
2031    State(state): State<super::AdminState>,
2032    tenant: Tenant,
2033    headers: HeaderMap,
2034    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2035    Form(form): Form<FormComponentSubmit>,
2036) -> Result<Response, AdminError> {
2037    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2038        return Ok(r);
2039    }
2040    let slug = crate::forms::schema::slugify_key(&form.slug);
2041    // Validate slug → label → document, in order; first failure wins.
2042    let checked: Result<crate::page_builder::schema::ComponentDoc, String> =
2043        if !crate::forms::schema::is_valid_key(&slug) {
2044            Err(
2045                "Slug is invalid — use letters/digits/underscores, starting with a letter."
2046                    .to_owned(),
2047            )
2048        } else if form.label.trim().is_empty() {
2049            Err("Label is required.".to_owned())
2050        } else {
2051            parse_component_doc(&form.schema)
2052        };
2053    // On success, create; a unique-slug clash re-shows with a clear error.
2054    let msg: Option<String> = match checked {
2055        Ok(cdoc) => {
2056            let document = serde_json::to_value(&cdoc).unwrap_or_else(|_| serde_json::json!({}));
2057            match crate::page_builder::model::create_component(
2058                tenant.pool(),
2059                &slug,
2060                form.label.trim(),
2061                form.icon.trim(),
2062                form.description.trim(),
2063                document,
2064            )
2065            .await
2066            {
2067                Ok(_) => {
2068                    return redirect_named_with_message(
2069                        "rcms-admin:components:index",
2070                        MsgLevel::Success,
2071                        "Component created.",
2072                        &headers,
2073                    )
2074                }
2075                Err(_) => Some(format!(
2076                    "Could not create — a component with slug `{slug}` may already exist."
2077                )),
2078            }
2079        }
2080        Err(e) => Some(e),
2081    };
2082    render_component_builder(
2083        &state,
2084        &headers,
2085        &tenant,
2086        session_user.as_ref(),
2087        None,
2088        &form.slug,
2089        &form.label,
2090        &form.icon,
2091        &form.description,
2092        &form.schema,
2093        msg.as_deref(),
2094    )
2095    .await
2096}
2097
2098/// POST /cms-admin/components/{id}/edit — update + bump version.
2099pub async fn component_update(
2100    State(state): State<super::AdminState>,
2101    tenant: Tenant,
2102    headers: HeaderMap,
2103    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2104    Path(id): Path<i64>,
2105    Form(form): Form<FormComponentSubmit>,
2106) -> Result<Response, AdminError> {
2107    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2108        return Ok(r);
2109    }
2110    let existing = crate::page_builder::model::component_by_id(tenant.pool(), id)
2111        .await?
2112        .ok_or(AdminError::NotFound(id))?;
2113    if form.label.trim().is_empty() {
2114        return render_component_builder(
2115            &state,
2116            &headers,
2117            &tenant,
2118            session_user.as_ref(),
2119            Some(id),
2120            &existing.slug,
2121            &form.label,
2122            &form.icon,
2123            &form.description,
2124            &form.schema,
2125            Some("Label is required."),
2126        )
2127        .await;
2128    }
2129    let cdoc = match parse_component_doc(&form.schema) {
2130        Ok(d) => d,
2131        Err(e) => {
2132            return render_component_builder(
2133                &state,
2134                &headers,
2135                &tenant,
2136                session_user.as_ref(),
2137                Some(id),
2138                &existing.slug,
2139                &form.label,
2140                &form.icon,
2141                &form.description,
2142                &form.schema,
2143                Some(&e),
2144            )
2145            .await
2146        }
2147    };
2148    let document = serde_json::to_value(&cdoc).unwrap_or_else(|_| serde_json::json!({}));
2149    crate::page_builder::model::update_component(
2150        tenant.pool(),
2151        id,
2152        form.label.trim(),
2153        form.icon.trim(),
2154        form.description.trim(),
2155        document,
2156    )
2157    .await?;
2158    redirect_named_with_message(
2159        "rcms-admin:components:index",
2160        MsgLevel::Success,
2161        "Component saved — referencing page types pick it up on next open.",
2162        &headers,
2163    )
2164}
2165
2166/// POST /cms-admin/components/{id}/delete — blocked while referenced.
2167pub async fn component_delete(
2168    State(_state): State<super::AdminState>,
2169    tenant: Tenant,
2170    headers: HeaderMap,
2171    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2172    Path(id): Path<i64>,
2173) -> Result<Response, AdminError> {
2174    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2175        return Ok(r);
2176    }
2177    let c = crate::page_builder::model::component_by_id(tenant.pool(), id)
2178        .await?
2179        .ok_or(AdminError::NotFound(id))?;
2180    let refs = crate::page_builder::model::component_references(tenant.pool(), &c.slug).await?;
2181    if !refs.is_empty() {
2182        // Resolve referencing page-type names for a clear error.
2183        let ids: Vec<i64> = refs.iter().map(|(pt, _)| *pt).collect();
2184        let pts: Vec<PageType> = PageType::objects()
2185            .where_(PageType::id.is_in(ids))
2186            .fetch(tenant.pool())
2187            .await
2188            .unwrap_or_default();
2189        let names: Vec<String> = pts.iter().map(|p| p.verbose_name.clone()).collect();
2190        let listed = if names.is_empty() {
2191            format!("{} page type(s)", refs.len())
2192        } else {
2193            names.join(", ")
2194        };
2195        return redirect_named_with_message(
2196            "rcms-admin:components:index",
2197            MsgLevel::Error,
2198            &format!("Can't delete `{}` — still used by: {listed}.", c.slug),
2199            &headers,
2200        );
2201    }
2202    crate::page_builder::model::delete_component(tenant.pool(), id).await?;
2203    redirect_named_with_message(
2204        "rcms-admin:components:index",
2205        MsgLevel::Success,
2206        "Component deleted.",
2207        &headers,
2208    )
2209}
2210
2211// ---- #566 UI-created page types -----------------------------------------
2212
2213/// GET /cms-admin/page-types/new — the create-a-type form.
2214pub async fn page_type_new_form(
2215    State(state): State<super::AdminState>,
2216    tenant: Tenant,
2217    headers: HeaderMap,
2218    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2219) -> Result<Response, AdminError> {
2220    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2221        return Ok(r);
2222    }
2223    let mut ctx = Context::new();
2224    add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2225    add_admin_theme(&mut ctx, tenant.pool()).await;
2226    ctx.insert("list_url", "/cms-admin/page-types");
2227    insert_workflow_choices(&mut ctx, tenant.pool()).await;
2228    render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx)
2229}
2230
2231/// The active workflows, by name, for the page-type form's Workflow field.
2232/// A failed lookup leaves only "publish directly".
2233async fn insert_workflow_choices(ctx: &mut Context, pool: &rustango::sql::Pool) {
2234    let names: Vec<String> = crate::workflow::Workflow::objects()
2235        .where_(crate::workflow::Workflow::active.eq(true))
2236        .order_by(&[("name", false)])
2237        .fetch(pool)
2238        .await
2239        .unwrap_or_default()
2240        .into_iter()
2241        .map(|w| w.name)
2242        .collect();
2243    ctx.insert("workflows", &names);
2244}
2245
2246/// A comma-separated list of type identifiers as the JSON array a page-type
2247/// row stores (empty = no rule).
2248fn type_list_json(raw: &str) -> serde_json::Value {
2249    serde_json::Value::Array(
2250        raw.split(',')
2251            .map(str::trim)
2252            .filter(|s| !s.is_empty())
2253            .map(|s| serde_json::Value::String(s.to_owned()))
2254            .collect(),
2255    )
2256}
2257
2258/// An admin-made page type by id; `None` for a missing or code type, whose
2259/// settings are re-seeded from its handler at every boot.
2260async fn ui_page_type(
2261    pool: &rustango::sql::Pool,
2262    id: i64,
2263) -> Result<Option<crate::page_type_model::PageType>, AdminError> {
2264    Ok(crate::page_type_model::PageType::objects()
2265        .where_(crate::page_type_model::PageType::id.eq(id))
2266        .first(pool)
2267        .await?
2268        .filter(|t| crate::page_type::find_handler(&t.type_name).is_none()))
2269}
2270
2271/// GET /cms-admin/page-types/{id}/edit — an admin-made type's settings.
2272pub async fn page_type_edit_form(
2273    State(state): State<super::AdminState>,
2274    tenant: Tenant,
2275    headers: HeaderMap,
2276    Path(id): Path<i64>,
2277    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2278) -> Result<Response, AdminError> {
2279    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2280        return Ok(r);
2281    }
2282    let Some(pt) = ui_page_type(tenant.pool(), id).await? else {
2283        return Err(AdminError::NotFound(id));
2284    };
2285    let mut ctx = Context::new();
2286    add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2287    add_admin_theme(&mut ctx, tenant.pool()).await;
2288    ctx.insert("list_url", "/cms-admin/page-types");
2289    ctx.insert("edit_id", &id);
2290    ctx.insert("form_verbose_name", &pt.verbose_name);
2291    ctx.insert("form_type_name", &pt.type_name);
2292    ctx.insert("form_allowed_parents", &pt.allowed_parents().join(", "));
2293    ctx.insert("form_allowed_children", &pt.allowed_children().join(", "));
2294    ctx.insert("form_workflow", &pt.workflow);
2295    insert_workflow_choices(&mut ctx, tenant.pool()).await;
2296    render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx)
2297}
2298
2299/// POST /cms-admin/page-types/{id}/edit — save an admin-made type's name,
2300/// parent/child rules and workflow. The identifier can't change.
2301pub async fn page_type_update(
2302    tenant: Tenant,
2303    headers: HeaderMap,
2304    Path(id): Path<i64>,
2305    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2306    Form(form): Form<FormPageTypeCreate>,
2307) -> Result<Response, AdminError> {
2308    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2309        return Ok(r);
2310    }
2311    let Some(mut pt) = ui_page_type(tenant.pool(), id).await? else {
2312        return Err(AdminError::NotFound(id));
2313    };
2314    if form.verbose_name.trim().is_empty() {
2315        return Err(AdminError::Validation("Name is required.".to_owned()));
2316    }
2317    pt.verbose_name = form.verbose_name.trim().to_owned();
2318    pt.allowed_parent_types = type_list_json(&form.allowed_parents);
2319    pt.allowed_child_types = type_list_json(&form.allowed_children);
2320    pt.workflow = form.workflow.trim().to_owned();
2321    pt.save_pool(tenant.pool()).await?;
2322    redirect_named_with_message(
2323        "rcms-admin:page-types",
2324        MsgLevel::Success,
2325        "Page type settings saved.",
2326        &headers,
2327    )
2328}
2329
2330/// POST /cms-admin/page-types/new — create a UI page type
2331/// (`app_label = "cms_ui"`) + an empty draft schema, then jump to the
2332/// field builder so the Developer designs its body immediately.
2333pub async fn page_type_create(
2334    State(state): State<super::AdminState>,
2335    tenant: Tenant,
2336    headers: HeaderMap,
2337    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2338    Form(form): Form<FormPageTypeCreate>,
2339) -> Result<Response, AdminError> {
2340    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2341        return Ok(r);
2342    }
2343    // Blank identifier derives from the name — `slugify_key` is a FIELD-key
2344    // slugifier whose empty-input fallback is the literal "field", which made
2345    // every no-identifier type `cms_ui.field` (and the second one collide).
2346    let ident_src = if form.type_name.trim().is_empty() {
2347        form.verbose_name.as_str()
2348    } else {
2349        form.type_name.as_str()
2350    };
2351    let slug = crate::forms::schema::slugify_key(ident_src);
2352    let err: Option<String> = if form.verbose_name.trim().is_empty() {
2353        Some("Name is required.".to_owned())
2354    } else if !crate::forms::schema::is_valid_key(&slug) {
2355        Some(
2356            "Identifier is invalid — use letters/digits/underscores, starting with a letter."
2357                .to_owned(),
2358        )
2359    } else if crate::page_type_model::PageType::objects()
2360        .where_(crate::page_type_model::PageType::type_name.eq(slug.clone()))
2361        .first(tenant.pool())
2362        .await?
2363        .is_some()
2364        || crate::page_type::find_handler(&slug).is_some()
2365    {
2366        Some(format!(
2367            "A page type with identifier `{slug}` already exists."
2368        ))
2369    } else {
2370        None
2371    };
2372    if let Some(msg) = err {
2373        let mut ctx = Context::new();
2374        add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
2375        add_admin_theme(&mut ctx, tenant.pool()).await;
2376        ctx.insert("list_url", "/cms-admin/page-types");
2377        ctx.insert("error", &msg);
2378        ctx.insert("form_verbose_name", &form.verbose_name);
2379        ctx.insert("form_type_name", &form.type_name);
2380        ctx.insert("form_allowed_parents", &form.allowed_parents);
2381        ctx.insert("form_allowed_children", &form.allowed_children);
2382        ctx.insert("form_workflow", &form.workflow);
2383        insert_workflow_choices(&mut ctx, tenant.pool()).await;
2384        return render_with_csrf(&state, &headers, "rcms_admin/page_type_form.html", &mut ctx);
2385    }
2386    // An API type has no HTML representation, so it gets the blank
2387    // template sentinel rather than the generic schema template —
2388    // otherwise `page_view::resolve_kind` would see a template and
2389    // never reach the JSON branch.
2390    let view_mode = crate::page_view::PageViewMode::parse(&form.view_mode);
2391    let default_template = if view_mode == crate::page_view::PageViewMode::Api {
2392        String::new()
2393    } else {
2394        crate::page_builder::DEFAULT_SCHEMA_TEMPLATE.to_owned()
2395    };
2396    let mut row = crate::page_type_model::PageType {
2397        id: rustango::sql::Auto::Unset,
2398        app_label: "cms_ui".to_owned(),
2399        type_name: slug.clone(),
2400        verbose_name: form.verbose_name.trim().to_owned(),
2401        default_template,
2402        view_mode: view_mode.as_str().to_owned(),
2403        is_creatable: true,
2404        allowed_parent_types: type_list_json(&form.allowed_parents),
2405        allowed_child_types: type_list_json(&form.allowed_children),
2406        workflow: form.workflow.trim().to_owned(),
2407        created_at: rustango::sql::Auto::Unset,
2408        updated_at: rustango::sql::Auto::Unset,
2409    };
2410    row.insert_pool(tenant.pool()).await?;
2411    let new_id = row.id.get().copied().unwrap_or_default();
2412    // Seed an empty draft schema so the builder opens cleanly.
2413    let created_by = session_user.as_ref().and_then(|u| u.id.get().copied());
2414    crate::page_builder::model::save_draft(
2415        tenant.pool(),
2416        new_id,
2417        serde_json::json!({ "nodes": [] }),
2418        created_by,
2419    )
2420    .await
2421        .log_warn("empty builder draft not seeded");
2422    redirect_named_with_params_and_message(
2423        "rcms-admin:page-types:build",
2424        &[("id", new_id.to_string())],
2425        MsgLevel::Success,
2426        "Page type created — design its body, then Publish.",
2427        &headers,
2428    )
2429}
2430
2431/// POST /cms-admin/page-types/{id}/delete — delete a UI-created type.
2432/// Refused for code types and for types with existing pages.
2433pub async fn page_type_delete(
2434    State(_state): State<super::AdminState>,
2435    tenant: Tenant,
2436    headers: HeaderMap,
2437    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2438    Path(id): Path<i64>,
2439) -> Result<Response, AdminError> {
2440    if let Some(r) = ensure_builder_access(&tenant, session_user.as_ref()).await {
2441        return Ok(r);
2442    }
2443    let pt = crate::page_type_model::PageType::objects()
2444        .where_(crate::page_type_model::PageType::id.eq(id))
2445        .first(tenant.pool())
2446        .await?
2447        .ok_or(AdminError::NotFound(id))?;
2448    // Only UI-created types are deletable; code types never are.
2449    if pt.app_label != "cms_ui" {
2450        return redirect_named_with_message(
2451            "rcms-admin:page-types",
2452            MsgLevel::Error,
2453            "Only UI-created page types can be deleted.",
2454            &headers,
2455        );
2456    }
2457    let page_count = Page::objects()
2458        .where_(Page::page_type_id.eq(id))
2459        .fetch(tenant.pool())
2460        .await
2461        .map(|v| v.len())
2462        .unwrap_or(0);
2463    if page_count > 0 {
2464        return redirect_named_with_message(
2465            "rcms-admin:page-types",
2466            MsgLevel::Error,
2467            "Can't delete — pages still use this type. Delete or move them first.",
2468            &headers,
2469        );
2470    }
2471    // Drop the type's schema rows (draft/published/archived) then the row.
2472    for row in crate::page_builder::model::list_versions(tenant.pool(), id)
2473        .await
2474        .unwrap_or_default()
2475    {
2476        row.delete_pool(tenant.pool()).await.log_warn("page-builder schema version not deleted");
2477    }
2478    pt.delete_pool(tenant.pool()).await?;
2479    redirect_named_with_message(
2480        "rcms-admin:page-types",
2481        MsgLevel::Success,
2482        "Page type deleted.",
2483        &headers,
2484    )
2485}
2486
2487/// The canonical column of a translation row shows rich text formatted,
2488/// not as `<p>…</p>` markup. Sanitized: it is author content rendered
2489/// into the admin. Empty for every other widget kind (shown as text).
2490fn translation_canonical_html(widget_tag: &str, canonical: &str) -> String {
2491    if widget_tag == "richtext" && !canonical.trim().is_empty() {
2492        crate::markdown::sanitize_html(canonical)
2493    } else {
2494        String::new()
2495    }
2496}
2497
2498/// Translation-surface groups for a page's builder body: the
2499/// canonical text leaves (fixed fields, group members, zone stream
2500/// blocks) grouped like the StreamField leaf rows, each prefilled with
2501/// its existing per-locale override. Returns `[]` when the type has no
2502/// published schema. Paths are `builder.<…>` (see `values::…leaves`).
2503async fn builder_translation_groups(
2504    tenant: &Tenant,
2505    page_id: i64,
2506    page_type_id: i64,
2507    existing: &std::collections::HashMap<String, String>,
2508) -> (Vec<serde_json::Value>, std::collections::HashSet<String>) {
2509    let mut paths = std::collections::HashSet::new();
2510    let Ok(Some(row)) =
2511        crate::page_builder::model::published_for(tenant.pool(), page_type_id).await
2512    else {
2513        return (Vec::new(), paths);
2514    };
2515    let Ok(doc) = crate::page_builder::parse_schema(&row.document) else {
2516        return (Vec::new(), paths);
2517    };
2518    let components = crate::page_builder::model::component_map(tenant.pool())
2519        .await
2520        .unwrap_or_default();
2521    let compiled = crate::page_builder::compile(&doc, &components, row.version.max(1) as u32);
2522    let (values, _) = crate::page_builder::values::load_upgraded(tenant.pool(), page_id, &compiled)
2523        .await
2524        .unwrap_or_else(|_| (serde_json::json!({}), Default::default()));
2525    let leaves = crate::page_builder::values::builder_translatable_leaves(&compiled, &values);
2526    // Group consecutively by block instance, mirroring stream_translations.
2527    let mut groups: Vec<serde_json::Value> = Vec::new();
2528    let mut cur = String::new();
2529    for leaf in &leaves {
2530        paths.insert(leaf.path.clone());
2531        let rowv = serde_json::json!({
2532            "path": leaf.path,
2533            "widget_kind": leaf.widget_kind.as_tag(),
2534            "field_label": leaf.field_label,
2535            "canonical": leaf.canonical_text,
2536            "canonical_html": translation_canonical_html(leaf.widget_kind.as_tag(), &leaf.canonical_text),
2537            "value": existing.get(&leaf.path).cloned().unwrap_or_default(),
2538        });
2539        if leaf.block_id != cur {
2540            cur.clone_from(&leaf.block_id);
2541            groups.push(serde_json::json!({
2542                "block_type": leaf.block_type,
2543                "block_label": leaf.block_label,
2544                "block_id": leaf.block_id,
2545                "depth": leaf.depth,
2546                "leaves": [rowv],
2547            }));
2548        } else if let Some(arr) = groups
2549            .last_mut()
2550            .and_then(|g| g.get_mut("leaves"))
2551            .and_then(|v| v.as_array_mut())
2552        {
2553            arr.push(rowv);
2554        }
2555    }
2556    (groups, paths)
2557}
2558
2559/// POST /cms-admin/media/bulk-move-collection — move every checked
2560/// media id into the selected `collection_id` (or NULL for
2561/// uncategorized).
2562pub async fn media_bulk_move_collection(
2563    State(_state): State<super::AdminState>,
2564    tenant: Tenant,
2565    headers: HeaderMap,
2566    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
2567    Form(form): Form<Vec<(String, String)>>,
2568) -> Result<Response, AdminError> {
2569    let target: Option<i64> = form
2570        .iter()
2571        .find(|(k, _)| k == "collection_id")
2572        .and_then(|(_, v)| v.parse::<i64>().ok())
2573        .filter(|id| *id > 0);
2574    let ids: Vec<i64> = form
2575        .iter()
2576        .filter(|(k, _)| k == "ids" || k == "id")
2577        .filter_map(|(_, v)| v.parse::<i64>().ok())
2578        .collect();
2579    let kind = form
2580        .iter()
2581        .find(|(k, _)| k == "kind")
2582        .map(|(_, v)| v.clone())
2583        .unwrap_or_else(|| "image".to_owned());
2584    let mut touched = 0;
2585    for id in ids {
2586        if let Some(mut m) = Media::objects()
2587            .where_(Media::id.eq(id))
2588            .first(tenant.pool())
2589            .await?
2590        {
2591            m.collection_id = target;
2592            m.save_pool(tenant.pool()).await?;
2593            touched += 1;
2594        }
2595    }
2596    let redirect_url = if kind == "document" {
2597        "rcms-admin:documents:list"
2598    } else {
2599        "rcms-admin:media:list"
2600    };
2601    let dest = match target {
2602        Some(id) => format!("to collection #{id}"),
2603        None => "to Uncategorized".to_owned(),
2604    };
2605    redirect_named_with_message_plural(
2606        redirect_url,
2607        MsgLevel::Success,
2608        "Moved {count} item(s) {dest}.",
2609        touched as i64,
2610        &[("count", &touched.to_string()), ("dest", &dest)],
2611        &headers,
2612    )
2613}
2614
2615/// GET /cms-admin/media/collections/{id}/permissions — per-collection
2616/// permission editor. Same role × action grid shape as the
2617/// page permissions tab, just retargeted at `cms_collection_permission`.
2618pub async fn collection_permissions_form(
2619    State(state): State<super::AdminState>,
2620    tenant: Tenant,
2621    headers: HeaderMap,
2622    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
2623    Path(id): Path<i64>,
2624) -> Result<Response, AdminError> {
2625    let collection = crate::media::MediaCollection::objects()
2626        .where_(crate::media::MediaCollection::id.eq(id))
2627        .first(tenant.pool())
2628        .await?
2629        .ok_or(AdminError::NotFound(id))?;
2630    let roles: Vec<rustango::tenancy::permissions::Role> =
2631        rustango::tenancy::permissions::Role::objects()
2632            .order_by(&[("name", false)])
2633            .fetch(tenant.pool())
2634            .await?;
2635    let grants: Vec<crate::permissions::CollectionPermission> =
2636        crate::permissions::CollectionPermission::objects()
2637            .where_(crate::permissions::CollectionPermission::collection_id.eq(id))
2638            .fetch(tenant.pool())
2639            .await?;
2640    let granted: std::collections::HashSet<(i64, String)> = grants
2641        .iter()
2642        .map(|g| (g.role_id, g.permission.clone()))
2643        .collect();
2644    let actions: Vec<&str> = crate::permissions::Action::all()
2645        .iter()
2646        .map(|a| a.as_str())
2647        .collect();
2648    let perm_grid: Vec<serde_json::Value> = roles
2649        .iter()
2650        .map(|r| {
2651            let rid = r.id.get().copied().unwrap_or_default();
2652            let row_cells: Vec<serde_json::Value> = actions
2653                .iter()
2654                .map(|a| {
2655                    serde_json::json!({
2656                        "action": a,
2657                        "granted": granted.contains(&(rid, (*a).to_owned())),
2658                    })
2659                })
2660                .collect();
2661            serde_json::json!({
2662                "role_id": rid,
2663                "role_name": r.name,
2664                "role_description": r.description,
2665                "cells": row_cells,
2666            })
2667        })
2668        .collect();
2669
2670    let mut ctx = Context::new();
2671    add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
2672    add_admin_theme(&mut ctx, tenant.pool()).await;
2673    ctx.insert("collection_id", &id);
2674    ctx.insert("collection_name", &collection.name);
2675    ctx.insert("perm_actions", &actions);
2676    ctx.insert("perm_grid", &perm_grid);
2677
2678    // #195 — view restriction picker. Surface the current direct
2679    // restriction (if any) and the role list for the groups option.
2680    let restriction = crate::collection_view_restriction::direct_for_collection(tenant.pool(), id)
2681        .await
2682        .unwrap_or_default();
2683    let restriction_kind = restriction
2684        .as_ref()
2685        .map(|r| r.kind.clone())
2686        .unwrap_or_else(|| "none".to_owned());
2687    let restriction_groups: std::collections::HashSet<i64> = restriction
2688        .as_ref()
2689        .map(|r| r.parsed_groups().into_iter().collect())
2690        .unwrap_or_default();
2691    let restriction_has_password = restriction
2692        .as_ref()
2693        .map(|r| !r.password_hash.is_empty())
2694        .unwrap_or(false);
2695    let role_options: Vec<serde_json::Value> = roles
2696        .iter()
2697        .map(|r| {
2698            let rid = r.id.get().copied().unwrap_or_default();
2699            serde_json::json!({
2700                "id": rid,
2701                "name": r.name,
2702                "selected": restriction_groups.contains(&rid),
2703            })
2704        })
2705        .collect();
2706    // #members — permission-codename picker (the permission-engine gate).
2707    let restriction_codenames: Vec<String> = restriction
2708        .as_ref()
2709        .map(|r| r.parsed_codenames())
2710        .unwrap_or_default();
2711    let restriction_codenames_str = restriction_codenames.join(",");
2712    let codename_choices: Vec<serde_json::Value> = super::resources::membership_codenames()
2713        .into_iter()
2714        .map(|(codename, label)| {
2715            serde_json::json!({
2716                "codename": codename,
2717                "label": label,
2718                "checked": restriction_codenames.contains(&codename),
2719            })
2720        })
2721        .collect();
2722    ctx.insert("restriction_kind", &restriction_kind);
2723    ctx.insert("restriction_has_password", &restriction_has_password);
2724    ctx.insert("restriction_roles", &role_options);
2725    ctx.insert("restriction_codenames_str", &restriction_codenames_str);
2726    ctx.insert("restriction_codename_choices", &codename_choices);
2727
2728    render_with_csrf(
2729        &state,
2730        &headers,
2731        "rcms_admin/collection_permissions.html",
2732        &mut ctx,
2733    )
2734}
2735
2736/// Form body for `POST /cms-admin/media/collections/{id}/privacy`.
2737#[derive(Deserialize)]
2738pub struct CollectionPrivacyForm {
2739    pub kind: String,
2740    #[serde(default)]
2741    pub password: String,
2742    #[serde(default)]
2743    pub group_ids: String,
2744    /// Comma-separated permission codenames — used when `kind =
2745    /// permission` (the permission-engine gate). Empty otherwise.
2746    #[serde(default)]
2747    pub codenames: String,
2748}
2749
2750/// POST /cms-admin/media/collections/{id}/privacy — upsert the view
2751/// restriction for a collection. `kind=none` deletes the row.
2752/// Mirrors the page-privacy submit handler exactly.
2753pub async fn collection_privacy_submit(
2754    State(_state): State<super::AdminState>,
2755    tenant: Tenant,
2756    headers: HeaderMap,
2757    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
2758    Path(id): Path<i64>,
2759    Form(form): Form<CollectionPrivacyForm>,
2760) -> Result<Response, AdminError> {
2761    use rustango::sql::Auto;
2762    let existing =
2763        crate::collection_view_restriction::direct_for_collection(tenant.pool(), id).await?;
2764    if form.kind == "none" {
2765        if let Some(row) = existing {
2766            row.delete_pool(tenant.pool()).await?;
2767            return redirect_named_with_params_and_message(
2768                "rcms-admin:media:collection-permissions",
2769                &[("id", id.to_string())],
2770                MsgLevel::Success,
2771                "Removed view restriction — collection is now public.",
2772                &headers,
2773            );
2774        }
2775        return redirect_named_with_params_and_message(
2776            "rcms-admin:media:collection-permissions",
2777            &[("id", id.to_string())],
2778            MsgLevel::Info,
2779            "No restriction to remove.",
2780            &headers,
2781        );
2782    }
2783    let Some(kind) = crate::collection_view_restriction::RestrictionKind::parse(&form.kind) else {
2784        return Err(AdminError::Validation(format!(
2785            "unknown restriction kind `{}`",
2786            form.kind
2787        )));
2788    };
2789    let password_hash = match kind {
2790        crate::collection_view_restriction::RestrictionKind::Password => {
2791            if form.password.is_empty() {
2792                if let Some(row) = &existing {
2793                    if row.kind == kind.as_str() {
2794                        row.password_hash.clone()
2795                    } else {
2796                        return redirect_named_with_params_and_message(
2797                            "rcms-admin:media:collection-permissions",
2798                            &[("id", id.to_string())],
2799                            MsgLevel::Error,
2800                            "Password is required when switching the restriction kind to password.",
2801                            &headers,
2802                        );
2803                    }
2804                } else {
2805                    return redirect_named_with_params_and_message(
2806                        "rcms-admin:media:collection-permissions",
2807                        &[("id", id.to_string())],
2808                        MsgLevel::Error,
2809                        "Password is required for password-protected collections.",
2810                        &headers,
2811                    );
2812                }
2813            } else {
2814                crate::passwords::hash(&form.password).await
2815                    .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?
2816            }
2817        }
2818        _ => String::new(),
2819    };
2820    let group_ids: Vec<i64> = if matches!(
2821        kind,
2822        crate::collection_view_restriction::RestrictionKind::Groups
2823    ) {
2824        form.group_ids
2825            .split(',')
2826            .filter_map(|s| s.trim().parse::<i64>().ok())
2827            .collect()
2828    } else {
2829        Vec::new()
2830    };
2831    let group_json = serde_json::json!(group_ids);
2832    let codenames: Vec<String> = if matches!(
2833        kind,
2834        crate::collection_view_restriction::RestrictionKind::Permission
2835    ) {
2836        form.codenames
2837            .split(',')
2838            .map(str::trim)
2839            .filter(|s| !s.is_empty())
2840            .map(str::to_owned)
2841            .collect()
2842    } else {
2843        Vec::new()
2844    };
2845    let codenames_json = serde_json::json!(codenames);
2846    match existing {
2847        Some(mut row) => {
2848            row.kind = kind.as_str().to_owned();
2849            row.password_hash = password_hash;
2850            row.group_ids = group_json;
2851            row.codenames = codenames_json;
2852            row.save_pool(tenant.pool()).await?;
2853        }
2854        None => {
2855            let mut row = crate::collection_view_restriction::CollectionViewRestriction {
2856                id: Auto::Unset,
2857                collection_id: id,
2858                kind: kind.as_str().to_owned(),
2859                password_hash,
2860                group_ids: group_json,
2861                codenames: codenames_json,
2862                created_at: Auto::Unset,
2863                updated_at: Auto::Unset,
2864            };
2865            row.insert_pool(tenant.pool()).await?;
2866        }
2867    }
2868    redirect_named_with_params_and_message(
2869        "rcms-admin:media:collection-permissions",
2870        &[("id", id.to_string())],
2871        MsgLevel::Success,
2872        "Collection privacy updated. New requests to /__media__/<spec>/<id> will enforce it.",
2873        &headers,
2874    )
2875}
2876
2877/// POST /cms-admin/media/collections/{id}/permissions — replace the
2878/// collection's permission set with the JSON body's grant list.
2879/// Idempotent want/have diff, returns 204 on success. Mirrors the
2880/// page-permission save endpoint exactly.
2881pub async fn collection_permissions_submit(
2882    State(_state): State<super::AdminState>,
2883    tenant: Tenant,
2884    Path(collection_id): Path<i64>,
2885    axum::Json(payload): axum::Json<PagePermissionsPayload>,
2886) -> Result<Response, AdminError> {
2887    use rustango::sql::Auto;
2888    let valid_actions: std::collections::HashSet<&str> = crate::permissions::Action::all()
2889        .iter()
2890        .map(|a| a.as_str())
2891        .collect();
2892    let want: std::collections::BTreeSet<(i64, String)> = payload
2893        .grants
2894        .iter()
2895        .filter(|g| valid_actions.contains(g.action.as_str()))
2896        .map(|g| (g.role_id, g.action.clone()))
2897        .collect();
2898
2899    let existing: Vec<crate::permissions::CollectionPermission> =
2900        crate::permissions::CollectionPermission::objects()
2901            .where_(crate::permissions::CollectionPermission::collection_id.eq(collection_id))
2902            .fetch(tenant.pool())
2903            .await?;
2904    let have: std::collections::BTreeSet<(i64, String)> = existing
2905        .iter()
2906        .map(|p| (p.role_id, p.permission.clone()))
2907        .collect();
2908
2909    for p in &existing {
2910        let key = (p.role_id, p.permission.clone());
2911        if !want.contains(&key) {
2912            p.clone().delete_pool(tenant.pool()).await?;
2913        }
2914    }
2915    for (role_id, action) in &want {
2916        if !have.contains(&(*role_id, action.clone())) {
2917            let mut row = crate::permissions::CollectionPermission {
2918                id: Auto::Unset,
2919                collection_id,
2920                role_id: *role_id,
2921                permission: action.clone(),
2922                created_at: Auto::Unset,
2923            };
2924            row.insert_pool(tenant.pool()).await?;
2925        }
2926    }
2927    Ok(axum::http::StatusCode::NO_CONTENT.into_response())
2928}
2929
2930/// JSON payload for the permission tab's bulk save endpoint —
2931/// the grid POSTs a list of `(role_id, action)` pairs and the
2932/// handler replaces the page's grant set with that list.
2933#[derive(Debug, Deserialize)]
2934pub struct PagePermissionsPayload {
2935    pub grants: Vec<PagePermissionGrant>,
2936}
2937#[derive(Debug, Deserialize)]
2938pub struct PagePermissionGrant {
2939    pub role_id: i64,
2940    pub action: String,
2941}
2942
2943/// POST /cms-admin/pages/{id}/permissions — replace the page's
2944/// permission set with the list in the JSON body. Idempotent;
2945/// computes the want/have diff and applies the minimum INSERTs +
2946/// DELETEs. Returns 204 on success.
2947pub async fn page_permissions_submit(
2948    State(_state): State<super::AdminState>,
2949    tenant: Tenant,
2950    Path(page_id): Path<i64>,
2951    axum::Json(payload): axum::Json<PagePermissionsPayload>,
2952) -> Result<Response, AdminError> {
2953    use rustango::sql::Auto;
2954    let valid_actions: std::collections::HashSet<&str> = crate::permissions::Action::all()
2955        .iter()
2956        .map(|a| a.as_str())
2957        .collect();
2958    let want: std::collections::BTreeSet<(i64, String)> = payload
2959        .grants
2960        .iter()
2961        .filter(|g| valid_actions.contains(g.action.as_str()))
2962        .map(|g| (g.role_id, g.action.clone()))
2963        .collect();
2964
2965    let existing: Vec<crate::permissions::PagePermission> =
2966        crate::permissions::PagePermission::objects()
2967            .where_(crate::permissions::PagePermission::page_id.eq(page_id))
2968            .fetch(tenant.pool())
2969            .await?;
2970    let have: std::collections::BTreeSet<(i64, String)> = existing
2971        .iter()
2972        .map(|p| (p.role_id, p.permission.clone()))
2973        .collect();
2974
2975    // Drop rows that aren't wanted.
2976    for p in &existing {
2977        let key = (p.role_id, p.permission.clone());
2978        if !want.contains(&key) {
2979            p.clone().delete_pool(tenant.pool()).await?;
2980        }
2981    }
2982    // Insert rows that don't exist yet.
2983    for (role_id, action) in &want {
2984        if !have.contains(&(*role_id, action.clone())) {
2985            let mut row = crate::permissions::PagePermission {
2986                id: Auto::Unset,
2987                page_id,
2988                role_id: *role_id,
2989                permission: action.clone(),
2990                created_at: Auto::Unset,
2991            };
2992            row.insert_pool(tenant.pool()).await?;
2993        }
2994    }
2995
2996    Ok(axum::http::StatusCode::NO_CONTENT.into_response())
2997}
2998
2999/// Resolve every [`TabSpec`](crate::page_type::TabSpec) variant
3000/// into the flat shape page_form.html iterates: `{name, label, icon,
3001/// badge, html}`. Failures on `Template` / `Widgets` rendering
3002/// fall back to an inline error banner instead of crashing the page
3003/// editor — the author sees the Tera message + can fix the template.
3004fn render_extra_tabs(
3005    specs: Vec<crate::page_type::TabSpec>,
3006    tera: &std::sync::Arc<tera::Tera>,
3007    base_ctx: &Context,
3008    headers: &HeaderMap,
3009) -> Vec<serde_json::Value> {
3010    use crate::page_type::TabBody;
3011    specs
3012        .into_iter()
3013        .map(|spec| {
3014            let html = match spec.body {
3015                TabBody::Html(s) => s,
3016                TabBody::Template { path, context } => {
3017                    let mut tab_ctx = base_ctx.clone();
3018                    for (k, v) in context {
3019                        tab_ctx.insert(&k, &v);
3020                    }
3021                    tera.render(&path, &tab_ctx).unwrap_or_else(|e| {
3022                        format!(
3023                            r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3024    <span class="rcms-flash-body"><strong>{label}</strong> {failed} <code>{path}</code>: {e}</span>
3025</div>"#,
3026                            label = tera::escape_html(&super::i18n::tr(headers, "Tab template error:", &[])),
3027                            failed = tera::escape_html(&super::i18n::tr(headers, "failed to render", &[])),
3028                            path = tera::escape_html(&path),
3029                            e = tera::escape_html(&e.to_string()),
3030                        )
3031                    })
3032                }
3033                TabBody::Widgets(widgets) => {
3034                    let mut ctx = Context::new();
3035                    ctx.insert("widgets", &widgets);
3036                    tera.render("rcms_admin/_widget_group.html", &ctx)
3037                        .unwrap_or_else(|e| {
3038                            format!(
3039                                r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3040    <span class="rcms-flash-body"><strong>{label}</strong> {e}</span>
3041</div>"#,
3042                                label = tera::escape_html(&super::i18n::tr(headers, "Widget-group tab error:", &[])),
3043                                e = tera::escape_html(&e.to_string()),
3044                            )
3045                        })
3046                }
3047                TabBody::Group { heading, help, layout, widgets } => {
3048                    // Field group panel (column or row layout).
3049                    // Wrap the same _widget_group output in a
3050                    // <fieldset> with a heading + (optional) help
3051                    // paragraph + layout class.
3052                    let mut ctx = Context::new();
3053                    ctx.insert("widgets", &widgets);
3054                    let inner = tera
3055                        .render("rcms_admin/_widget_group.html", &ctx)
3056                        .unwrap_or_else(|e| {
3057                            format!(
3058                                r#"<div class="rcms-flash rcms-flash--error" style="margin: 12px 0;">
3059    <span class="rcms-flash-body"><strong>{label}</strong> {e}</span>
3060</div>"#,
3061                                label = tera::escape_html(&super::i18n::tr(headers, "Panel-group tab error:", &[])),
3062                                e = tera::escape_html(&e.to_string()),
3063                            )
3064                        });
3065                    let help_html = if help.is_empty() {
3066                        String::new()
3067                    } else {
3068                        format!(
3069                            r#"<p class="rcms-hint rcms-panel-group-help">{}</p>"#,
3070                            tera::escape_html(&help),
3071                        )
3072                    };
3073                    format!(
3074                        r#"<fieldset class="rcms-panel-group rcms-panel-group--{layout}">
3075    <legend>{heading}</legend>
3076    {help_html}
3077    <div class="rcms-panel-group-body">{inner}</div>
3078</fieldset>"#,
3079                        layout = layout.class_suffix(),
3080                        heading = tera::escape_html(&heading),
3081                        help_html = help_html,
3082                        inner = inner,
3083                    )
3084                }
3085                TabBody::Help { content } => {
3086                    // Static help block. Author-supplied HTML; emit
3087                    // raw inside a hint-styled container.
3088                    format!(
3089                        r#"<div class="rcms-panel-help">{content}</div>"#,
3090                        content = content,
3091                    )
3092                }
3093            };
3094            serde_json::json!({
3095                "name": spec.name,
3096                "label": spec.label,
3097                "icon": spec.icon,
3098                "badge": spec.badge,
3099                "html": html,
3100            })
3101        })
3102        .collect()
3103}
3104
3105/// GET /cms-admin/x/{slug} — custom admin page dispatcher. Looks up the
3106/// registered [`AdminPageHandler`](super::admin_page::AdminPageHandler)
3107/// matching `slug` and forwards to its `render`. Unknown slugs map
3108/// to 404.
3109pub async fn admin_page_dispatch(
3110    State(state): State<super::AdminState>,
3111    tenant: Tenant,
3112    headers: HeaderMap,
3113    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3114    Path(slug): Path<String>,
3115) -> Result<Response, AdminError> {
3116    match super::admin_page::find_admin_page(&slug) {
3117        Some(handler) => Ok(handler
3118            .render(super::admin_page::AdminPageCtx {
3119                tera: &state.tera,
3120                tenant: &tenant,
3121                headers: &headers,
3122                user: session_user.as_ref(),
3123            })
3124            .await),
3125        None => Err(AdminError::NotFound(0)),
3126    }
3127}
3128
3129/// Load the active admin theme + its brand colors and stuff the
3130/// rendered CSS / data-attrs into the Tera context so `_base.html`
3131/// can drop them straight into the page chrome. Falls back gracefully
3132/// if no theme is configured (admin renders with built-in defaults).
3133pub(crate) async fn add_admin_theme(ctx: &mut Context, pool: &rustango::sql::Pool) {
3134    // Pick the row flagged `is_admin_default`; if none, fall back to
3135    // whichever is `is_default`; if still none, the first row.
3136    let mut admin_default: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3137        .where_(crate::theme::Theme::is_admin_default.eq(true))
3138        .fetch(pool)
3139        .await
3140        .unwrap_or_default();
3141    let theme = if let Some(t) = admin_default.pop() {
3142        t
3143    } else {
3144        let mut any: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3145            .where_(crate::theme::Theme::is_default.eq(true))
3146            .fetch(pool)
3147            .await
3148            .unwrap_or_default();
3149        match any.pop() {
3150            Some(t) => t,
3151            None => {
3152                let mut first: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
3153                    .order_by(&[("name", false)])
3154                    .fetch(pool)
3155                    .await
3156                    .unwrap_or_default();
3157                let Some(t) = first.pop() else {
3158                    // No themes at all — set empty strings so the
3159                    // template's `{% if %}` guards short-circuit.
3160                    ctx.insert("theme_css", &String::new());
3161                    ctx.insert("theme_slug", &String::new());
3162                    ctx.insert("theme_default_mode", &"light");
3163                    ctx.insert("theme_font_url", &String::new());
3164                    return;
3165                };
3166                t
3167            }
3168        }
3169    };
3170    let theme_id = theme.id.get().copied().unwrap_or_default();
3171    let brand_colors: Vec<crate::theme::BrandColor> = crate::theme::BrandColor::objects()
3172        .where_(crate::theme::BrandColor::theme_id.eq(theme_id))
3173        .order_by(&[("sort_order", false)])
3174        .fetch(pool)
3175        .await
3176        .unwrap_or_default();
3177    let css = crate::theme::emit_css(&theme, &brand_colors);
3178    ctx.insert("theme_css", &css);
3179    ctx.insert("theme_slug", &theme.slug);
3180    ctx.insert("theme_name", &theme.name);
3181    ctx.insert("theme_default_mode", &theme.default_mode);
3182    ctx.insert("theme_font_url", &theme.font_url);
3183}
3184
3185/// Query string for the page list / search view.
3186#[derive(Debug, Deserialize)]
3187pub struct ListQuery {
3188    /// Filter children of this parent only. Omitted = root listing.
3189    /// Ignored when `q` is set — search always spans the full tree.
3190    #[serde(default)]
3191    pub parent: Option<i64>,
3192    /// Full-tree search query. Case-insensitive substring match
3193    /// across title, slug, and url_path. Empty string skips the
3194    /// search path and shows the current parent's children.
3195    #[serde(default)]
3196    pub q: Option<String>,
3197    /// Filter results by page type slug — pairs with `q` or stands
3198    /// alone. Matches `cms_page_type.type_name`.
3199    #[serde(default)]
3200    pub r#type: Option<String>,
3201    /// Filter results by status (`draft|scheduled|published|archived`).
3202    #[serde(default)]
3203    pub status: Option<String>,
3204}
3205
3206/// GET /cms-admin/pages — flat list of pages directly under the
3207/// current parent (root by default). Editors drill into a subtree
3208/// via the per-row "View children" action; the breadcrumb trail
3209/// at the top lets them navigate back up. Replaces the previous
3210/// indented full-tree view.
3211///
3212/// Per-page permissions: when the request carries a
3213/// session cookie, the resolver filters out rows the user can't
3214/// `view`. Superusers + anonymous / no-session contexts (sqlite
3215/// dev) see every row.
3216pub async fn page_list(
3217    State(state): State<super::AdminState>,
3218    tenant: Tenant,
3219    headers: HeaderMap,
3220    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3221    Query(q): Query<ListQuery>,
3222) -> Result<Response, AdminError> {
3223    // Best-effort schedule sweep so editors always see current state.
3224    // #207 — uses the mailer-aware variant so the pre-publish
3225    // reminder pass runs on the same tick.
3226    match crate::page::run_schedule_sweep_with_mailer(
3227        tenant.pool(),
3228        state.mailer.as_deref(),
3229        &state.mailer_from,
3230        &tenant.org.slug,
3231    )
3232    .await
3233    {
3234        // A page this sweep put live or took down must leave the cache
3235        // too, as the timed sweep's purge does (#692).
3236        Ok(result) if !result.changed_urls.is_empty() => {
3237            crate::task_queue::purge_urls(
3238                state.cache_invalidator.clone(),
3239                tenant.org.slug.clone(),
3240                result.changed_urls,
3241            )
3242            .await;
3243        }
3244        Ok(_) => {}
3245        Err(e) => tracing::warn!(target: "rustango_cms::admin", error = %e, "schedule sweep failed"),
3246    }
3247
3248    // Pull every page once — we need the full list both for
3249    // breadcrumb computation (walk ancestors of `parent`) and child
3250    // counts (how many pages live under each row in the current
3251    // listing). Tenants stay in the small-N range; the materialized
3252    // list is cheap.
3253    let all_pages: Vec<Page> = Page::objects()
3254        .order_by(&[("path", false), ("sort_order", false)])
3255        .fetch(tenant.pool())
3256        .await?;
3257
3258    // Index pages by id for ancestor walk.
3259    let by_id: std::collections::HashMap<i64, &Page> = all_pages
3260        .iter()
3261        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
3262        .collect();
3263
3264    // Current parent — None means root listing.
3265    let parent_page: Option<&Page> = q.parent.and_then(|pid| by_id.get(&pid).copied());
3266
3267    // Breadcrumb: walk parent chain up to root, then reverse.
3268    let mut breadcrumbs: Vec<serde_json::Value> = Vec::new();
3269    if let Some(mut cur) = parent_page {
3270        breadcrumbs.push(serde_json::json!({
3271            "id": cur.id.get().copied(),
3272            "title": cur.title.clone(),
3273        }));
3274        while let Some(ppid) = cur.parent_id {
3275            if let Some(p) = by_id.get(&ppid).copied() {
3276                breadcrumbs.push(serde_json::json!({
3277                    "id": p.id.get().copied(),
3278                    "title": p.title.clone(),
3279                }));
3280                cur = p;
3281            } else {
3282                break;
3283            }
3284        }
3285        breadcrumbs.reverse();
3286    }
3287
3288    // Determine the working set:
3289    //   - search mode (`q`): full tree, filtered by ILIKE on title/slug/url_path
3290    //   - browse mode (no `q`): direct children of `parent` only
3291    let search_query =
3292        q.q.as_deref()
3293            .map(str::trim)
3294            .filter(|s| !s.is_empty())
3295            .map(str::to_owned);
3296    let status_filter = q
3297        .status
3298        .as_deref()
3299        .map(str::trim)
3300        .filter(|s| !s.is_empty())
3301        .map(str::to_owned);
3302    let type_filter_slug = q
3303        .r#type
3304        .as_deref()
3305        .map(str::trim)
3306        .filter(|s| !s.is_empty())
3307        .map(str::to_owned);
3308
3309    // Per-page permissions filter (#18 phase 3). Skipped when the
3310    // request is anonymous (sqlite dev / no session) or the user
3311    // is a tenant superuser — both paths see every page. For
3312    // authenticated, non-superuser sessions we pre-compute the
3313    // viewable set so the browse/search filter below can apply it.
3314    let viewer_user_id: Option<i64> = session_user
3315        .as_ref()
3316        .filter(|u| u.active)
3317        .and_then(|u| u.id.get().copied());
3318    let viewer_is_superuser = session_user.as_ref().is_some_and(|u| u.is_superuser);
3319    let permission_filter_enabled = viewer_user_id.is_some() && !viewer_is_superuser;
3320    let viewable_ids: Option<std::collections::HashSet<i64>> = match viewer_user_id {
3321        Some(uid) if permission_filter_enabled => {
3322            let pages: Vec<(i64, Option<i64>)> = all_pages
3323                .iter()
3324                .filter_map(|p| p.id.get().copied().map(|id| (id, p.parent_id)))
3325                .collect();
3326            Some(
3327                crate::permissions::viewable_page_ids(tenant.pool(), uid, &pages)
3328                    .await
3329                    .unwrap_or_default(),
3330            )
3331        }
3332        _ => None,
3333    };
3334
3335    // #408 — relevance-ranked, all-status admin search on Postgres: FTS
3336    // finds stemmed / word-boundary matches the substring filter misses
3337    // (across drafts too) and orders by relevance. `None` on non-PG / a
3338    // query error → the substring filter below stands.
3339    let fts_rank: Option<std::collections::HashMap<i64, usize>> = match search_query.as_deref() {
3340        Some(q) => crate::search::search_page_ids_all_statuses(tenant.pool(), q, 1000)
3341            .await
3342            .map(|ids| ids.iter().enumerate().map(|(i, id)| (*id, i)).collect()),
3343        None => None,
3344    };
3345    let visible: Vec<&Page> = if search_query.is_some()
3346        || status_filter.is_some()
3347        || type_filter_slug.is_some()
3348    {
3349        // Search / filter mode — full-tree.
3350        let q_lower = search_query.as_deref().map(str::to_lowercase);
3351        // Resolve type slug → id via the not-yet-fetched type list.
3352        // We pull `cms_page_type` below for the verbose-name map
3353        // either way; do it inline here for the filter id.
3354        let prefetch_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3355        let type_id_by_slug: std::collections::HashMap<String, i64> = prefetch_types
3356            .iter()
3357            .filter_map(|t| t.id.get().copied().map(|id| (t.type_name.clone(), id)))
3358            .collect();
3359        let type_id_filter = type_filter_slug
3360            .as_deref()
3361            .and_then(|s| type_id_by_slug.get(s).copied());
3362        all_pages
3363            .iter()
3364            .filter(|p| {
3365                // A full-text hit OR a substring match (#702): full-text finds
3366                // stemmed words, but not a partial word, a slug fragment or a
3367                // URL path, so on Postgres it must add to the substring match
3368                // the other backends use, not replace it. Relevance order is
3369                // the re-sort below; substring-only hits follow the ranked ones.
3370                let matches_search = match &q_lower {
3371                    None => true,
3372                    Some(needle) => {
3373                        fts_rank.as_ref().is_some_and(|rank| {
3374                            p.id.get().copied().is_some_and(|id| rank.contains_key(&id))
3375                        }) || p.title.to_lowercase().contains(needle)
3376                            || p.slug.to_lowercase().contains(needle)
3377                            || p.url_path.to_lowercase().contains(needle)
3378                    }
3379                };
3380                let matches_status = match &status_filter {
3381                    None => true,
3382                    Some(s) => p.status == *s,
3383                };
3384                let matches_type = match type_id_filter {
3385                    None => true,
3386                    Some(id) => p.page_type_id == id,
3387                };
3388                matches_search && matches_status && matches_type
3389            })
3390            .collect()
3391    } else {
3392        // Browse mode — direct children only.
3393        all_pages
3394            .iter()
3395            .filter(|p| p.parent_id == q.parent)
3396            .collect()
3397    };
3398    // Snapshot the pre-permission visible count so the empty-state
3399    // copy can distinguish "tree is empty here" from "you can't see
3400    // any of these pages" (#70).
3401    let visible_before_permission_filter = visible.len();
3402    // Apply per-page view filter as a final pass — affects both
3403    // search and browse modes uniformly.
3404    let visible: Vec<&Page> = match &viewable_ids {
3405        None => visible,
3406        Some(set) => visible
3407            .into_iter()
3408            .filter(|p| p.id.get().copied().is_some_and(|id| set.contains(&id)))
3409            .collect(),
3410    };
3411    // #408 — when FTS drove the search, order results by relevance
3412    // (overriding the default path order in search mode).
3413    let visible: Vec<&Page> = if let Some(rank) = &fts_rank {
3414        let mut v = visible;
3415        v.sort_by_key(|p| {
3416            p.id.get()
3417                .copied()
3418                .and_then(|id| rank.get(&id).copied())
3419                .unwrap_or(usize::MAX)
3420        });
3421        v
3422    } else {
3423        visible
3424    };
3425    let is_search_mode =
3426        search_query.is_some() || status_filter.is_some() || type_filter_slug.is_some();
3427    // #70 — empty-state classification. Exactly one of these is
3428    // surfaced into the template when `rows | length == 0`:
3429    //   * `empty_filtered`         — search/filter mode dropped every row
3430    //   * `empty_hidden_by_perms`  — per-page permissions dropped every row
3431    //                                that would otherwise be visible
3432    //   * (default)                — genuinely empty section
3433    let empty_filtered = is_search_mode && visible.is_empty();
3434    let empty_hidden_by_perms = !is_search_mode
3435        && visible.is_empty()
3436        && visible_before_permission_filter > 0
3437        && permission_filter_enabled;
3438
3439    // Child counts — for the "View children" CTA.
3440    let mut child_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
3441    for p in &all_pages {
3442        if let Some(ppid) = p.parent_id {
3443            *child_counts.entry(ppid).or_insert(0) += 1;
3444        }
3445    }
3446
3447    let types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3448    let type_map: std::collections::HashMap<i64, String> = types
3449        .iter()
3450        .filter_map(|t| t.id.get().copied().map(|id| (id, t.verbose_name.clone())))
3451        .collect();
3452
3453    let live_urls = build_live_url_map(&all_pages);
3454
3455    // Helper: walk a page's parent chain into a list of `{id, title}`
3456    // crumbs (root → page). Only computed in search mode where the
3457    // editor needs context for results that live deep in the tree.
3458    let ancestors_for = |p: &Page| -> Vec<serde_json::Value> {
3459        let mut chain: Vec<serde_json::Value> = Vec::new();
3460        let mut cur_parent = p.parent_id;
3461        while let Some(pid) = cur_parent {
3462            match by_id.get(&pid).copied() {
3463                Some(ancestor) => {
3464                    chain.push(serde_json::json!({
3465                        "id": ancestor.id.get().copied(),
3466                        "title": ancestor.title.clone(),
3467                    }));
3468                    cur_parent = ancestor.parent_id;
3469                }
3470                None => break,
3471            }
3472        }
3473        chain.reverse();
3474        chain
3475    };
3476
3477    let rows: Vec<serde_json::Value> = visible
3478        .iter()
3479        .map(|p| {
3480            let id = p.id.get().copied();
3481            let ancestors = if is_search_mode {
3482                ancestors_for(p)
3483            } else {
3484                Vec::new()
3485            };
3486            serde_json::json!({
3487                "id": id,
3488                "title": p.title,
3489                "slug": p.slug,
3490                "path": p.path,
3491                "url_path": p.url_path,
3492                "status": p.status,
3493                "page_type_id": p.page_type_id,
3494                "go_live_at": p.go_live_at,
3495                "expire_at": p.expire_at,
3496                "updated_at": p.updated_at.get().copied(),
3497                "published_at": p.published_at,
3498                "locale_variant_of": p.locale_variant_of,
3499                "alias_of": p.alias_of,
3500                "child_count": id.and_then(|i| child_counts.get(&i).copied()).unwrap_or(0),
3501                "ancestors": ancestors,
3502            })
3503        })
3504        .collect();
3505
3506    let mut ctx = Context::new();
3507    add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3508    add_admin_theme(&mut ctx, tenant.pool()).await;
3509    ctx.insert("rows", &rows);
3510    ctx.insert("type_map", &type_map);
3511    // #614 — the "+ New root page" menu must offer only root-legal types.
3512    ctx.insert("creatable_types", &allowed_root_types(&types));
3513    ctx.insert("live_urls", &live_urls);
3514    ctx.insert("breadcrumbs", &breadcrumbs);
3515    ctx.insert("parent_id", &q.parent);
3516    ctx.insert("parent_title", &parent_page.map(|p| p.title.clone()));
3517    ctx.insert("search_query", &search_query);
3518    ctx.insert("status_filter", &status_filter);
3519    ctx.insert("type_filter", &type_filter_slug);
3520    ctx.insert("is_search_mode", &is_search_mode);
3521    ctx.insert("empty_filtered", &empty_filtered);
3522    ctx.insert("empty_hidden_by_perms", &empty_hidden_by_perms);
3523    // For the type/status filter dropdowns the template renders, we
3524    // pass a slug → verbose-name map and a sorted slug list.
3525    let mut type_slugs: Vec<(String, String)> = types
3526        .iter()
3527        .map(|t| (t.type_name.clone(), t.verbose_name.clone()))
3528        .collect();
3529    type_slugs.sort_by(|a, b| a.1.cmp(&b.1));
3530    ctx.insert("type_choices", &type_slugs);
3531
3532    // #65 — Move-to destination picker for the bulk action bar.
3533    // Every page (any depth) is a valid parent except the visible
3534    // selection itself; we expose the full tree pre-formatted with
3535    // an indent prefix so the dropdown reads as a tree. JS filters
3536    // out self/descendants of the actual selection at click time.
3537    let move_choices: Vec<serde_json::Value> = all_pages
3538        .iter()
3539        .map(|p| {
3540            let indent = "—".repeat(p.depth.max(1) as usize - 1);
3541            let label = if indent.is_empty() {
3542                p.title.clone()
3543            } else {
3544                format!("{indent} {}", p.title)
3545            };
3546            serde_json::json!({
3547                "id": p.id.get().copied(),
3548                "label": label,
3549                "path": p.path.clone(),
3550            })
3551        })
3552        .collect();
3553    ctx.insert("move_choices", &move_choices);
3554    // #107 — plugin-contributed per-row buttons. Hand the raw button
3555    // templates over; the template substitutes `{page_id}` per row.
3556    ctx.insert(
3557        "plugin_page_listing_buttons",
3558        &crate::hooks::page_listing_buttons_raw(),
3559    );
3560    // #134 — plugin-contributed bulk actions targeting `cms_page`.
3561    let plugin_bulk_actions: Vec<serde_json::Value> = crate::hooks::bulk_actions_for("cms_page")
3562        .into_iter()
3563        .map(|a| {
3564            serde_json::json!({
3565                "key": a.key,
3566                "label": a.label,
3567                "icon": a.icon,
3568                "danger": a.danger,
3569                "confirm_message": a.confirm_message,
3570                "action_url": a.action_url,
3571            })
3572        })
3573        .collect();
3574    ctx.insert("plugin_bulk_actions", &plugin_bulk_actions);
3575    // #438 — active non-default locales for the copy-to-locale bulk
3576    // action (the default locale already holds canonical content).
3577    let copy_locales: Vec<Locale> = Locale::objects()
3578        .where_(Locale::active.eq(true))
3579        .order_by(&[("sort_order", false), ("code", false)])
3580        .fetch(tenant.pool())
3581        .await
3582        .unwrap_or_default()
3583        .into_iter()
3584        .filter(|l| !l.is_default)
3585        .collect();
3586    ctx.insert("copy_locales", &copy_locales);
3587    render_with_csrf(&state, &headers, "rcms_admin/page_list.html", &mut ctx)
3588}
3589
3590/// Build a map of `page_id → public URL` for every row in `pages`.
3591/// Walks the list once in tree order (the list is already sorted by
3592/// `path` + `sort_order`), so each parent's URL is computed before
3593/// its children. Root pages with empty slug map to `/`.
3594/// Reassemble inline-panel rows from the posted form map.
3595///
3596/// Form keys are shaped `inline__<panel>__<row_idx>__<field>`. The
3597/// extractor iterates the spec's fields (so unknown / extraneous
3598/// keys are ignored), groups them by `row_idx`, and returns rows in
3599/// `row_idx` order so the handler can persist sort_order from the
3600/// position in the slice.
3601///
3602/// Rows are emitted whenever ANY of the spec's fields appears for
3603/// that index. The optional `inline__<panel>__<row_idx>____deleted`
3604/// sentinel hides a row entirely (so the editor can remove rows
3605/// without re-numbering everything).
3606fn extract_inline_panel_rows(
3607    form: &std::collections::HashMap<String, String>,
3608    spec: &crate::page_type::InlinePanelSpec,
3609) -> Vec<serde_json::Map<String, serde_json::Value>> {
3610    let mut by_idx: std::collections::BTreeMap<usize, serde_json::Map<String, serde_json::Value>> =
3611        std::collections::BTreeMap::new();
3612    let prefix = format!("inline__{}__", spec.name);
3613    for (key, value) in form {
3614        let Some(rest) = key.strip_prefix(&prefix) else {
3615            continue;
3616        };
3617        let Some((idx_str, field_name)) = rest.split_once("__") else {
3618            continue;
3619        };
3620        let Ok(idx) = idx_str.parse::<usize>() else {
3621            continue;
3622        };
3623        if field_name == "__deleted" && value == "1" {
3624            by_idx.remove(&idx);
3625            // Mark this index as tombstone — any later entries for
3626            // it get re-inserted into a fresh row that we then drop
3627            // at the end. Use a sentinel key to track.
3628            let mut row = serde_json::Map::new();
3629            row.insert("__deleted".to_owned(), serde_json::Value::Bool(true));
3630            by_idx.insert(idx, row);
3631            continue;
3632        }
3633        if !spec.fields.iter().any(|f| f.name == field_name) {
3634            continue;
3635        }
3636        let row = by_idx.entry(idx).or_default();
3637        if row.contains_key("__deleted") {
3638            continue;
3639        }
3640        row.insert(
3641            field_name.to_owned(),
3642            serde_json::Value::String(value.clone()),
3643        );
3644    }
3645    by_idx
3646        .into_iter()
3647        .filter_map(|(_, row)| {
3648            if row.contains_key("__deleted") {
3649                None
3650            } else {
3651                Some(row)
3652            }
3653        })
3654        .collect()
3655}
3656
3657fn build_live_url_map(pages: &[Page]) -> std::collections::HashMap<String, String> {
3658    let mut by_id: std::collections::HashMap<String, String> = std::collections::HashMap::new();
3659    for p in pages {
3660        let Some(pid) = p.id.get().copied() else {
3661            continue;
3662        };
3663        let url = match p.parent_id {
3664            None => {
3665                if p.slug.is_empty() {
3666                    "/".to_owned()
3667                } else {
3668                    format!("/{}", p.slug)
3669                }
3670            }
3671            Some(parent_id) => {
3672                let parent_url = by_id
3673                    .get(&parent_id.to_string())
3674                    .cloned()
3675                    .unwrap_or_else(|| "/".to_owned());
3676                if p.slug.is_empty() {
3677                    parent_url
3678                } else if parent_url == "/" {
3679                    format!("/{}", p.slug)
3680                } else {
3681                    format!("{}/{}", parent_url, p.slug)
3682                }
3683            }
3684        };
3685        // Stringify the id key so Tera's `m[page.id]` lookup works
3686        // when the serializer flattens to JSON.
3687        by_id.insert(pid.to_string(), url);
3688    }
3689    by_id
3690}
3691
3692/// GET /cms-admin/pages/new[?parent=<id>][&type=<page_type_id>] —
3693/// create flow. Two steps:
3694///
3695/// 1. Without `?type=`, render the page-type picker — a tile grid of
3696///    every creatable type (filtered to the parent's `allowed_child_
3697///    types` when `?parent=` is set). Picking a tile sends the
3698///    editor to step 2.
3699/// 2. With `?type=<id>`, render the page form with the chosen type
3700///    locked. The hidden `page_type_id` input carries it through to
3701///    the POST; the editor can NOT change it after this point.
3702///
3703/// Splitting the type selection out of the form is what makes the
3704/// "page-type is permanent" guarantee actually visible to authors —
3705/// once they're filling fields they're committed to the type.
3706#[derive(Debug, Deserialize)]
3707pub struct NewQuery {
3708    #[serde(default)]
3709    pub parent: Option<i64>,
3710    #[serde(default, rename = "type")]
3711    pub type_id: Option<i64>,
3712}
3713
3714pub async fn page_new_form(
3715    State(state): State<super::AdminState>,
3716    tenant: Tenant,
3717    headers: HeaderMap,
3718    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3719    Query(q): Query<NewQuery>,
3720) -> Result<Response, AdminError> {
3721    let all_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
3722
3723    let (parent, allowed_types) = match q.parent {
3724        Some(pid) => {
3725            let parent_row = Page::objects()
3726                .where_(Page::id.eq(pid))
3727                .first(tenant.pool())
3728                .await?
3729                .ok_or(AdminError::NotFound(pid))?;
3730            let allowed = allowed_children_for(&parent_row, &all_types);
3731            (Some(parent_row), allowed)
3732        }
3733        // Root: only types that may legally be roots (#614).
3734        None => (None, allowed_root_types(&all_types)),
3735    };
3736
3737    // Step 1: no type picked yet → show the picker tile grid.
3738    let Some(type_id) = q.type_id else {
3739        // Enrich each PageType row with the registered handler's
3740        // `icon()` + `description()` so the picker can show them.
3741        // Plain `PageType` rows only carry table-level metadata
3742        // (type_name, verbose_name).
3743        #[derive(serde::Serialize)]
3744        struct PickerType<'a> {
3745            id: i64,
3746            type_name: &'a str,
3747            verbose_name: &'a str,
3748            icon: Option<&'static str>,
3749            description: Option<&'static str>,
3750        }
3751        let allowed_enriched: Vec<PickerType<'_>> = allowed_types
3752            .iter()
3753            .map(|t| {
3754                let handler = find_handler(&t.type_name);
3755                PickerType {
3756                    id: t.id.get().copied().unwrap_or_default(),
3757                    type_name: t.type_name.as_str(),
3758                    verbose_name: t.verbose_name.as_str(),
3759                    icon: handler.as_ref().and_then(|h| h.icon()),
3760                    description: handler.as_ref().and_then(|h| h.description()),
3761                }
3762            })
3763            .collect();
3764
3765        let mut ctx = Context::new();
3766        add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3767        add_admin_theme(&mut ctx, tenant.pool()).await;
3768        ctx.insert("parent", &parent);
3769        ctx.insert("allowed_types", &allowed_enriched);
3770        return render_with_csrf(
3771            &state,
3772            &headers,
3773            "rcms_admin/page_type_picker.html",
3774            &mut ctx,
3775        );
3776    };
3777
3778    // Step 2: type picked → validate it sits in the allowed set for
3779    // this parent, then render the form with the type locked. Reject
3780    // out-of-set selections so a hand-crafted URL can't bypass the
3781    // parent's whitelist.
3782    let chosen_type = allowed_types
3783        .iter()
3784        .find(|t| t.id.get().copied() == Some(type_id))
3785        .cloned()
3786        .ok_or_else(|| {
3787            AdminError::Validation(format!(
3788                "page type {type_id} is not creatable under the chosen parent"
3789            ))
3790        })?;
3791
3792    let mut page_seed = empty_page_form_values();
3793    if let Some(obj) = page_seed.as_object_mut() {
3794        obj.insert("page_type_id".to_owned(), serde_json::json!(type_id));
3795    }
3796
3797    let mut ctx = Context::new();
3798    add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
3799    add_admin_theme(&mut ctx, tenant.pool()).await;
3800    ctx.insert("mode", "new");
3801    ctx.insert("parent", &parent);
3802    ctx.insert("chosen_type", &chosen_type);
3803    ctx.insert("page", &page_seed);
3804    let review_required = !session_user.as_ref().is_some_and(|u| u.is_superuser)
3805        && crate::workflow::review_workflow_for_type(tenant.pool(), type_id).await?.is_some();
3806    ctx.insert("review_required", &review_required);
3807    // Custom tabs — only the existing-page editor
3808    // calls the handler for them. New-page mode shows the built-in
3809    // tabs only.
3810    ctx.insert("extra_tabs", &Vec::<crate::page_type::TabSpec>::new());
3811    // Stream-field picker options — every registered block surfaces
3812    // as an option even on the new-page form (so authors can drop
3813    // blocks before the first save). Empty
3814    // [`extension_fields`] keeps the new form lean otherwise.
3815    ctx.insert("extension_fields", &Vec::<crate::widget::Widget>::new());
3816    ctx.insert(
3817        "picker_options",
3818        &crate::block::admin::picker_options(&state.tera),
3819    );
3820    ctx.insert("page_tags", &Vec::<String>::new());
3821    ctx.insert("page_tags_csv", "");
3822    ctx.insert("all_tags", &Vec::<serde_json::Value>::new());
3823    insert_category_choices(&mut ctx, tenant.pool(), None).await;
3824    render_with_csrf(&state, &headers, "rcms_admin/page_form.html", &mut ctx)
3825}
3826
3827/// Slugify a raw string for the `cms_page.slug` column. Mirrors the
3828/// JS-side slugifier in `page_form.html` so the auto-fill the
3829/// editor sees stays consistent with what the server would have
3830/// generated.
3831///
3832/// Lowercase ASCII, hyphens for whitespace, drop everything else,
3833/// collapse runs of hyphens, trim leading / trailing hyphens, cap
3834/// length at 60 chars.
3835pub(crate) fn slugify(raw: &str) -> String {
3836    let mut out = String::with_capacity(raw.len());
3837    let mut last_hyphen = true;
3838    for ch in raw.chars() {
3839        let c = ch.to_ascii_lowercase();
3840        if c.is_ascii_alphanumeric() {
3841            out.push(c);
3842            last_hyphen = false;
3843        } else if !last_hyphen {
3844            out.push('-');
3845            last_hyphen = true;
3846        }
3847    }
3848    while out.ends_with('-') {
3849        out.pop();
3850    }
3851    if out.len() > 60 {
3852        out.truncate(60);
3853        while out.ends_with('-') {
3854            out.pop();
3855        }
3856    }
3857    out
3858}
3859
3860/// Pick a slug that doesn't collide with any sibling of
3861/// `parent_id`. If `candidate` is free, return it unchanged. If
3862/// taken, try `<base>-copy`, then `<base>-copy-2`, `<base>-copy-3`,
3863/// … up to a safety limit of 50 attempts (past which we surface an
3864/// error so the editor sees the collision).
3865///
3866/// Roots compare against other roots (`parent_id IS NULL`); children
3867/// compare against same-parent siblings only.
3868pub(crate) async fn dedup_slug_under_parent(
3869    pool: &rustango::sql::Pool,
3870    parent_id: Option<i64>,
3871    candidate: &str,
3872) -> Result<String, AdminError> {
3873    let taken: std::collections::HashSet<String> = {
3874        let q = Page::objects();
3875        let rows = match parent_id {
3876            Some(pid) => q.where_(Page::parent_id.eq(pid)).fetch(pool).await?,
3877            None => q.where_(Page::parent_id.is_null()).fetch(pool).await?,
3878        };
3879        rows.into_iter().map(|p| p.slug).collect()
3880    };
3881
3882    if !taken.contains(candidate) {
3883        return Ok(candidate.to_owned());
3884    }
3885    let with_copy = format!("{candidate}-copy");
3886    if !taken.contains(&with_copy) {
3887        return Ok(with_copy);
3888    }
3889    for n in 2..50_u32 {
3890        let trial = format!("{candidate}-copy-{n}");
3891        if !taken.contains(&trial) {
3892            return Ok(trial);
3893        }
3894    }
3895    Err(AdminError::Validation(format!(
3896        "could not find a free slug for “{candidate}” after 50 -copy attempts"
3897    )))
3898}
3899
3900/// Whether a root page already has the empty slug, i.e. serves "/".
3901async fn front_page_taken(pool: &rustango::sql::Pool) -> Result<bool, AdminError> {
3902    use rustango::sql::CounterPool as _;
3903    let n = Page::objects()
3904        .where_(Page::parent_id.is_null())
3905        .where_(Page::slug.eq(String::new()))
3906        .count(pool)
3907        .await?;
3908    Ok(n > 0)
3909}
3910
3911/// The page editor's Categories field. A failed lookup leaves the
3912/// field out rather than failing the form.
3913async fn insert_category_choices(ctx: &mut tera::Context, pool: &rustango::sql::Pool, page_id: Option<i64>) {
3914    let (groups, checked) = match crate::category::assign::editor_groups(pool, page_id).await {
3915        Ok(v) => v,
3916        Err(e) => {
3917            tracing::warn!(error = %e, "category choices not loaded; the field is hidden");
3918            Default::default()
3919        }
3920    };
3921    ctx.insert("category_groups", &groups);
3922    ctx.insert("page_category_ids", &checked);
3923}
3924
3925/// POST /cms-admin/pages/new — submit. Dispatches to
3926/// `Page::create_root` when no parent_id is in the form, otherwise
3927/// `Page::create_child`. Both paths compute path/depth/sort_order
3928/// and enforce the type whitelist.
3929pub async fn page_new_submit(
3930    State(_state): State<super::AdminState>,
3931    tenant: Tenant,
3932    headers: HeaderMap,
3933    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
3934    Form(form): Form<PageForm>,
3935) -> Result<Response, AdminError> {
3936    // #614 — a type that names `allowed_parent_types` may only live under one
3937    // of those parents, so it can never be a root. The picker now hides such
3938    // types at the root, but `page_type_id` arrives in the form (and the
3939    // picker is reachable as `?type=<id>`), so re-check it here rather than
3940    // trusting the UI.
3941    if form.parent_id.is_none() {
3942        let types = PageType::objects().fetch(tenant.pool()).await?;
3943        if let Some(row) = types
3944            .iter()
3945            .find(|t| t.id.get().copied() == Some(form.page_type_id))
3946        {
3947            let parents = row.allowed_parents();
3948            if !parents.is_empty() {
3949                return Err(AdminError::Validation(format!(
3950                    "`{}` can't be a root page — it may only be created under: {}",
3951                    row.type_name,
3952                    parents.join(", ")
3953                )));
3954            }
3955        }
3956    }
3957
3958    // An empty slug on a root page makes it the front page ("/"), as the
3959    // form's hint says — unless another root already is; otherwise the
3960    // slug comes from the title.
3961    let mut effective_slug = if !form.slug.trim().is_empty() {
3962        slugify(&form.slug)
3963    } else if form.parent_id.is_none() && !front_page_taken(tenant.pool()).await? {
3964        String::new()
3965    } else {
3966        slugify(&form.title)
3967    };
3968    if !effective_slug.is_empty() {
3969        effective_slug =
3970            dedup_slug_under_parent(tenant.pool(), form.parent_id, &effective_slug).await?;
3971    }
3972
3973    // A new page that would go live takes the publish right (#761, as on
3974    // edit), and a type with a review workflow goes live only through
3975    // it. Decided before the insert and saved as a draft instead, so the
3976    // page is never live for a moment and nothing typed is lost.
3977    let intended = derive_scheduled_status(form.parsed_status().as_str(), form.parsed_go_live_at());
3978    let mut held_back: Option<String> = None;
3979    if let Some(user) = session_user.as_ref().filter(|u| !u.is_superuser) {
3980        if crate::page::PageStatus::str_goes_live(crate::page::PageStatus::Draft.as_str(), &intended) {
3981            let uid = user.id.get().copied().unwrap_or_default();
3982            let req = super::route_perms::Requirement {
3983                codename: "cms_page.publish".to_owned(),
3984                page: form.parent_id.map(|pid| (pid, crate::permissions::Action::Publish)),
3985            };
3986            if let Some(wf) = crate::workflow::review_workflow_for_type(tenant.pool(), form.page_type_id).await? {
3987                held_back = Some(super::i18n::tr(
3988                    &headers,
3989                    "Saved as a draft: pages of this type go live after review (“{workflow}”). Click Submit for review.",
3990                    &[("workflow", wf.name.as_str())],
3991                ));
3992            } else if !super::route_perms::allows_id(tenant.pool(), uid, false, &req).await {
3993                held_back = Some(super::i18n::tr(
3994                    &headers,
3995                    "Saved as a draft: you don't have permission to publish pages here.",
3996                    &[],
3997                ));
3998            }
3999        }
4000    }
4001
4002    let new = NewPage::new(
4003        form.page_type_id,
4004        form.title.clone(),
4005        effective_slug.clone(),
4006    )
4007    .with_status(if held_back.is_some() { crate::page::PageStatus::Draft } else { form.parsed_status() })
4008    .with_seo(form.seo_title.clone(), form.seo_description.clone());
4009
4010    let mut page = match form.parent_id {
4011        Some(pid) => {
4012            let parent = Page::objects()
4013                .where_(Page::id.eq(pid))
4014                .first(tenant.pool())
4015                .await?
4016                .ok_or(AdminError::NotFound(pid))?;
4017            Page::create_child(&tenant, &parent, new).await?
4018        }
4019        None => Page::create_root(&tenant, new).await?,
4020    };
4021
4022    // Apply the non-tree-shape fields that NewPage doesn't carry
4023    // (robots, sitemap_priority) via a follow-up save.
4024    page.robots_index = form.parsed_robots_index();
4025    page.sitemap_priority = form.parsed_sitemap_priority();
4026    page.theme_id = form.theme_id;
4027    // A held-back page keeps no go-live date: a dated draft would be
4028    // scheduled, and go live without the review.
4029    page.go_live_at = if held_back.is_some() { None } else { form.parsed_go_live_at() };
4030    page.expire_at = form.parsed_expire_at();
4031    page.status = derive_scheduled_status(&page.status, page.go_live_at);
4032    page.show_in_menus = form.parsed_show_in_menus();
4033    page.preview_path = form.preview_path.trim().to_owned();
4034    page.template_override = form.template_override.trim().to_owned();
4035    // #183 — social sharing fields.
4036    page.og_title = form.og_title.clone();
4037    page.og_description = form.og_description.clone();
4038    page.og_image_media_id = form.og_image_media_id;
4039    if let Some(tc) = form.twitter_card.as_deref() {
4040        if matches!(tc, "summary" | "summary_large_image") {
4041            page.twitter_card = tc.to_owned();
4042        }
4043    }
4044    page.save_pool(tenant.pool()).await?;
4045    let new_id = page.id.get().copied().unwrap_or_default();
4046    // Tags and categories are on the new-page form too; they used to be
4047    // dropped here, and only an edit saved them.
4048    if let Some(raw) = form.tags.as_deref().filter(|t| !t.trim().is_empty()) {
4049        let names: Vec<String> = raw.split(',').map(str::to_owned).collect();
4050        crate::page_tag::replace_tags(tenant.pool(), new_id, &names).await?;
4051    }
4052    crate::category::assign::save_from_form(tenant.pool(), new_id, form.categories.as_deref()).await?;
4053
4054    // Capture revision #1 for this page so the history
4055    // panel has something to show from the moment a page is born.
4056    crate::revision::capture(tenant.pool(), &page, None)
4057        .await
4058        .log_warn("revision not captured; the history has a gap");
4059
4060    // Public render cache (rustango::cache_page::CachePageLayer)
4061    // expires on TTL; no manual invalidation needed here.
4062    let message = held_back.unwrap_or_else(|| {
4063        super::i18n::tr(&headers, "Created page “{title}”.", &[("title", page.title.as_str())])
4064    });
4065    redirect_after_page_save(
4066        &form.action,
4067        page.id.get().copied().unwrap_or_default(),
4068        page.parent_id,
4069        &message,
4070        &headers,
4071    )
4072}
4073
4074/// GET /cms-admin/pages/{id}/edit — load and render the form.
4075/// Query string for the page-edit form. `locale=<code>` flips the
4076/// editor into translation mode for that locale; absent OR pointing
4077/// at the default locale shows the canonical edit form.
4078#[derive(Debug, Deserialize, Default)]
4079pub struct EditQuery {
4080    #[serde(default)]
4081    pub locale: Option<String>,
4082}
4083
4084pub async fn page_edit_form(
4085    State(state): State<super::AdminState>,
4086    tenant: Tenant,
4087    headers: HeaderMap,
4088    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
4089    Path(id): Path<i64>,
4090    Query(q): Query<EditQuery>,
4091) -> Result<Response, AdminError> {
4092    let page = Page::objects()
4093        .where_(Page::id.eq(id))
4094        .first(tenant.pool())
4095        .await?
4096        .ok_or(AdminError::NotFound(id))?;
4097
4098    // #75 — alias proxy. Editing an alias means editing the source;
4099    // bounce the editor there so they're never tweaking a row that
4100    // can't actually accept content changes. Flash explains the
4101    // redirect so it isn't surprising.
4102    if let Some(source_id) = page.alias_of {
4103        return redirect_named_with_params_and_message_args(
4104            "rcms-admin:pages:edit",
4105            &[("id", source_id.to_string())],
4106            MsgLevel::Info,
4107            "Editing the source — alias “{title}” shares content with this row.",
4108            &[("title", page.title.as_str())],
4109            &headers,
4110        );
4111    }
4112
4113    // Load all active locales for the picker + translation lookup.
4114    let locales: Vec<Locale> = Locale::objects()
4115        .where_(Locale::active.eq(true))
4116        .order_by(&[("is_default", false), ("code", false)])
4117        .fetch(tenant.pool())
4118        .await?;
4119    let editing_locale: Option<Locale> = match q.locale.as_deref() {
4120        Some(code) if !code.is_empty() => locales.iter().find(|l| l.code == code).cloned(),
4121        _ => None,
4122    };
4123    let translation_mode = editing_locale
4124        .as_ref()
4125        .map(|l| !l.is_default)
4126        .unwrap_or(false);
4127    let pending = crate::pending_change::for_page(tenant.pool(), id).await?;
4128    let existing_translations = if translation_mode {
4129        let lid = editing_locale
4130            .as_ref()
4131            .and_then(|l| l.id.get().copied())
4132            .unwrap_or(0);
4133        crate::translation::fetch_for(tenant.pool(), id, lid)
4134            .await
4135            .unwrap_or_default()
4136    } else {
4137        std::collections::HashMap::new()
4138    };
4139
4140    // Theme picker dropdown options.
4141    let themes_for_picker: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
4142        .order_by(&[("name", false)])
4143        .fetch(tenant.pool())
4144        .await?;
4145
4146    // Page type is permanent — assigned once at create-time, never
4147    // reassigned. We surface the type as a read-only chip in the
4148    // form so authors can still see what they're editing; the edit
4149    // submit handler also strips `page_type_id` from its canonical
4150    // keys as a defense-in-depth measure.
4151    let chosen_type: PageType = PageType::objects()
4152        .where_(PageType::id.eq(page.page_type_id))
4153        .first(tenant.pool())
4154        .await?
4155        .ok_or_else(|| {
4156            AdminError::Validation(format!(
4157                "page_type_id {} on cms_page row has no cms_page_type row",
4158                page.page_type_id
4159            ))
4160        })?;
4161
4162    // Public URL for the "View live" link in the edit form chrome.
4163    let ancestors = page.ancestors(tenant.pool()).await.unwrap_or_default();
4164    let mut segments: Vec<&str> = ancestors
4165        .iter()
4166        .filter(|a| !a.slug.is_empty())
4167        .map(|a| a.slug.as_str())
4168        .collect();
4169    if !page.slug.is_empty() {
4170        segments.push(page.slug.as_str());
4171    }
4172    let live_url = if segments.is_empty() {
4173        "/".to_owned()
4174    } else {
4175        format!("/{}", segments.join("/"))
4176    };
4177
4178    // Fetch the revision history for the sidebar
4179    // panel. Sorted newest first, capped at 20 for the panel; older
4180    // revisions stay queryable via direct URL.
4181    //
4182    // The cap is applied in SQL (`.limit`), not after the fetch: every
4183    // `Revision` row carries a full JSON `snapshot` of the page, so
4184    // fetching the whole history to show 20 grew the edit-form cost with
4185    // every save (a page edited 300 times pulled 300 page snapshots).
4186    let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
4187        .where_(crate::revision::Revision::page_id.eq(id))
4188        .order_by(&[("sequence", true)]) // desc
4189        .limit(20)
4190        .fetch(tenant.pool())
4191        .await?;
4192
4193    // Sort existing translations into "core" (title / seo_title /
4194    // seo_description) and "extra" so the template can render the
4195    // core fields side-by-side with the canonical, and list the rest
4196    // as editable rows below.
4197    let core_fields = ["title", "seo_title", "seo_description"];
4198    let core_translations: std::collections::HashMap<String, String> = core_fields
4199        .iter()
4200        .map(|f| {
4201            (
4202                (*f).to_owned(),
4203                existing_translations.get(*f).cloned().unwrap_or_default(),
4204            )
4205        })
4206        .collect();
4207    let mut extra_translations: Vec<(String, String)> = existing_translations
4208        .iter()
4209        .filter(|(k, _)| !core_fields.contains(&k.as_str()))
4210        .map(|(k, v)| (k.clone(), v.clone()))
4211        .collect();
4212    extra_translations.sort_by(|a, b| a.0.cmp(&b.0));
4213
4214    let mut ctx = Context::new();
4215    add_chrome(&mut ctx, &tenant, "pages", session_user.as_ref()).await;
4216    add_admin_theme(&mut ctx, tenant.pool()).await;
4217    ctx.insert("mode", "edit");
4218    ctx.insert("parent", &Option::<Page>::None);
4219    ctx.insert("chosen_type", &chosen_type);
4220    ctx.insert("page", &page);
4221    ctx.insert("live_url", &live_url);
4222    // Headless preview: when the tenant has configured a decoupled
4223    // frontend, mint a token now and hand the editor a link that carries
4224    // it. The mint endpoint is inside the session-gated admin, so an
4225    // editor could otherwise only use preview by copying a token by hand
4226    // — which meant decoupled sites had no working preview at all.
4227    //
4228    // Minted per render rather than per click: the token is short-lived
4229    // and page-scoped, and generating it here keeps the link a plain
4230    // anchor instead of requiring JS. `None` (no secret configured, or
4231    // no frontend set) simply hides the action.
4232    // The site-wide template, which the page may override. A lookup
4233    // failure is not fatal — it costs the preview action, not the editor.
4234    let site_preview_base = match crate::preview_url::configured_base(tenant.pool()).await {
4235        Ok(base) => base,
4236        Err(e) => {
4237            tracing::warn!(
4238                target: "rustango_cms::admin",
4239                error = %e,
4240                "headless preview setting lookup failed",
4241            );
4242            None
4243        }
4244    };
4245    // Minted only when there is somewhere to send it: a page with no
4246    // override on a tenant with no frontend has no preview URL at all.
4247    let headless_preview_url = if site_preview_base.is_some() || !page.preview_path.trim().is_empty()
4248    {
4249        crate::preview_token::mint(&tenant.org.slug, id, chrono::Utc::now().timestamp() + PREVIEW_TOKEN_TTL_SECS)
4250            .and_then(|token| {
4251                crate::preview_url::for_page(
4252                    site_preview_base.as_deref(),
4253                    &page.preview_path,
4254                    &token,
4255                    id,
4256                    &page.url_path,
4257                )
4258            })
4259    } else {
4260        None
4261    };
4262    ctx.insert("headless_preview_url", &headless_preview_url);
4263    // #532 — full ancestor trail for the editor breadcrumb (each crumb links
4264    // to that level's children list); plus the immediate parent for "back".
4265    let ancestor_crumbs: Vec<serde_json::Value> = ancestors
4266        .iter()
4267        .map(|a| serde_json::json!({ "id": a.id.get().copied(), "title": a.title }))
4268        .collect();
4269    ctx.insert("ancestors", &ancestor_crumbs);
4270    ctx.insert(
4271        "parent_crumb",
4272        &ancestors
4273            .last()
4274            .map(|a| serde_json::json!({ "id": a.id.get().copied(), "title": a.title })),
4275    );
4276    // #107 — plugin-contributed kebab entries. Server-side substitutes the
4277    // page id into each entry's `href_template`.
4278    ctx.insert(
4279        "plugin_page_action_menu_items",
4280        &crate::hooks::page_action_menu_items(id),
4281    );
4282    // #140 — plugin-contributed page header buttons (next to Save).
4283    ctx.insert(
4284        "plugin_page_header_buttons",
4285        &crate::hooks::page_header_buttons(id),
4286    );
4287    // #115 — is the viewing user subscribed to publish events on
4288    // this page? Drives the Subscribe / Unsubscribe toggle on the
4289    // Status field.
4290    let is_subscribed = match session_user.as_ref().and_then(|u| u.id.get().copied()) {
4291        Some(uid) => crate::page_subscription::is_subscribed(tenant.pool(), id, uid)
4292            .await
4293            .unwrap_or(false),
4294        None => false,
4295    };
4296    ctx.insert("is_subscribed", &is_subscribed);
4297    // #189 — page tags.
4298    let page_tags: Vec<String> = crate::page_tag::tags_for_page(tenant.pool(), id)
4299        .await
4300        .unwrap_or_default()
4301        .into_iter()
4302        .map(|t| t.name)
4303        .collect();
4304    let page_tags_csv = page_tags.join(", ");
4305    ctx.insert("page_tags", &page_tags);
4306    ctx.insert("page_tags_csv", &page_tags_csv);
4307    let all_tags = crate::page_tag::all_tags(tenant.pool())
4308        .await
4309        .unwrap_or_default()
4310        .into_iter()
4311        .map(|(name, count)| serde_json::json!({ "name": name, "count": count }))
4312        .collect::<Vec<_>>();
4313    ctx.insert("all_tags", &all_tags);
4314    insert_category_choices(&mut ctx, tenant.pool(), Some(id)).await;
4315    // #146/#419 — inbound usage ("what links here"), aggregated per
4316    // referrer with resolved titles + a "used in N places" count.
4317    // Best-effort; failure leaves the panel empty.
4318    let usage =
4319        crate::reference_index::usage_summary(tenant.pool(), crate::reference_index::KIND_PAGE, id)
4320            .await;
4321    ctx.insert("usage", &usage);
4322
4323    // #116 — accessibility heuristics. Run server-side on every
4324    // page editor open. `body_html` comes from the handler's
4325    // `load_extension`-rendered HTML when one is available; only the
4326    // canonical Page fields are checked, since extension shape is
4327    // per-handler.
4328    let a11y_violations = crate::a11y::check_page(&page, None);
4329    let (a11y_errors, a11y_warnings, a11y_infos) = crate::a11y::count_by_severity(&a11y_violations);
4330    ctx.insert("a11y_violations", &a11y_violations);
4331    ctx.insert("a11y_errors", &a11y_errors);
4332    ctx.insert("a11y_warnings", &a11y_warnings);
4333    ctx.insert("a11y_infos", &a11y_infos);
4334    // #417 — extensible content/SEO checks (registry-driven). Rendered
4335    // in a sibling "Content & SEO" panel; same Severity buckets as a11y.
4336    let mut content_findings = crate::content_checks::run_all(&page);
4337    // No share image chosen is fine when the page has a photo: the public
4338    // page uses it (see `meta_tags::fallback_share_image`).
4339    if content_findings.iter().any(|f| f.code == "missing_og_image")
4340        && crate::meta_tags::fallback_share_image(tenant.pool(), &page).await.is_some()
4341    {
4342        content_findings.retain(|f| f.code != "missing_og_image");
4343    }
4344    let (content_errors, content_warnings, content_infos) =
4345        crate::content_checks::count_by_severity(&content_findings);
4346    ctx.insert("content_findings", &content_findings);
4347    ctx.insert("content_errors", &content_errors);
4348    ctx.insert("content_warnings", &content_warnings);
4349    ctx.insert("content_infos", &content_infos);
4350    ctx.insert("revisions", &revisions);
4351
4352    // #192 — audit-log timeline for this page. Capped at 100 entries
4353    // for the inline table; the full set is downloadable via the CSV
4354    // export endpoint linked alongside the table.
4355    let log_entries = crate::page_log::for_page(tenant.pool(), id, Some(100))
4356        .await
4357        .unwrap_or_default();
4358    let log_user_ids: std::collections::BTreeSet<i64> =
4359        log_entries.iter().filter_map(|e| e.actor_id).collect();
4360    let log_users: std::collections::HashMap<i64, String> = if log_user_ids.is_empty() {
4361        std::collections::HashMap::new()
4362    } else {
4363        rustango::tenancy::auth::User::objects()
4364            .where_(
4365                rustango::tenancy::auth::User::id
4366                    .is_in(log_user_ids.into_iter().collect::<Vec<_>>()),
4367            )
4368            .fetch(tenant.pool())
4369            .await
4370            .unwrap_or_default()
4371            .into_iter()
4372            .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
4373            .collect()
4374    };
4375    let log_view: Vec<serde_json::Value> = log_entries
4376        .iter()
4377        .map(|e| {
4378            serde_json::json!({
4379                "id": e.id.get().copied(),
4380                "action": e.action,
4381                "actor_id": e.actor_id,
4382                "actor_username": e.actor_id.and_then(|uid| log_users.get(&uid).cloned()),
4383                "message": e.message,
4384                "created_at": e.created_at.get().copied(),
4385            })
4386        })
4387        .collect();
4388    ctx.insert("page_log", &log_view);
4389
4390    ctx.insert("locales", &locales);
4391    ctx.insert("editing_locale", &editing_locale);
4392    ctx.insert("translation_mode", &translation_mode);
4393    ctx.insert("core_translations", &core_translations);
4394    ctx.insert("extra_translations", &extra_translations);
4395    ctx.insert("themes_for_picker", &themes_for_picker);
4396
4397    // Extension fields contributed by the page-type handler — typed
4398    // body / hero / etc. The admin form renders one widget per entry
4399    // alongside the canonical fields so authors edit "Content" in
4400    // one place.
4401    // Resolve the registered handler for this page's type once —
4402    // both `extension_fields` and `display_fields` come off the
4403    // same instance.
4404    // Reuses `chosen_type` (fetched above for the read-only type chip)
4405    // instead of re-querying the identical `cms_page_type` row.
4406    let resolved_handler: Option<Box<dyn crate::page_type::PageTypeHandler>> =
4407        find_handler(&chosen_type.type_name);
4408
4409    // Which preview surface the pane should render: the iframe, the JSON
4410    // body, or a plain "not available" notice.
4411    //
4412    // "No template" is not just an empty string — a non-empty name that
4413    // was never registered in Tera fails identically at render time, so
4414    // both cases have to count or the pane would lazy-load an iframe
4415    // that can only 500.
4416    let preview_mode = {
4417        let kind = crate::page_view::kind_for(&chosen_type);
4418        let template_renders = !chosen_type.default_template.trim().is_empty()
4419            && state
4420                .tera
4421                .get_template_names()
4422                .any(|n| n == chosen_type.default_template);
4423        if kind.serves_json() && !kind.serves_html() {
4424            "json"
4425        } else if template_renders {
4426            "html"
4427        } else {
4428            "none"
4429        }
4430    };
4431    ctx.insert("preview_mode", preview_mode);
4432
4433    // Pull widgets via the rich-typed `widgets()` method, which by
4434    // default delegates to the legacy `extension_fields()` shape
4435    // for handlers that haven't migrated. Returns `Vec<Widget>`
4436    // directly so new handlers can use the full 26-kind catalog
4437    // (Date, Color, Radio, Checkboxes, MultiSelect, Custom, …).
4438    let raw_widgets: Vec<crate::widget::Widget> = match &resolved_handler {
4439        Some(h) => h.widgets(tenant.pool(), id).await.unwrap_or_default(),
4440        None => Vec::new(),
4441    };
4442
4443    // #416 — content metrics (word count / reading time / readability)
4444    // from the content-bearing widget values, so the editor shows them
4445    // without opening the preview. Computed before the widgets are
4446    // mutated for rendering (chooser options etc.).
4447    let content_metrics =
4448        crate::metrics::analyze(&crate::metrics::collect_widget_text(&raw_widgets));
4449    ctx.insert("content_metrics", &content_metrics);
4450
4451    // #i18n — per-leaf StreamField translation rows. In translation mode,
4452    // walk each Stream widget's canonical JSON, enumerate every
4453    // translatable text leaf (recursively, incl. nested blocks), group by
4454    // block instance, and prefill each from the existing per-locale
4455    // overrides. `raw_widgets` still holds canonical values here (it is
4456    // mutated for chooser-option rendering further below).
4457    if translation_mode {
4458        let mut stream_translations: Vec<serde_json::Value> = Vec::new();
4459        let mut leaf_paths: std::collections::HashSet<String> = std::collections::HashSet::new();
4460        for w in &raw_widgets {
4461            if !matches!(w.kind, crate::widget::WidgetKind::Stream) {
4462                continue;
4463            }
4464            let base: serde_json::Value = serde_json::from_str(&w.value)
4465                .unwrap_or_else(|_| serde_json::Value::Array(Vec::new()));
4466            let leaves = crate::block::translate::collect_translatable_leaves(&w.name, &base);
4467            if leaves.is_empty() {
4468                continue;
4469            }
4470            let mut groups: Vec<serde_json::Value> = Vec::new();
4471            let mut cur_id = String::new();
4472            for leaf in &leaves {
4473                leaf_paths.insert(leaf.path.clone());
4474                let row = serde_json::json!({
4475                    "path": leaf.path,
4476                    "widget_kind": leaf.widget_kind.as_tag(),
4477                    "field_label": leaf.field_label,
4478                    "canonical": leaf.canonical_text,
4479                    "canonical_html": translation_canonical_html(leaf.widget_kind.as_tag(), &leaf.canonical_text),
4480                    "value": existing_translations.get(&leaf.path).cloned().unwrap_or_default(),
4481                });
4482                if leaf.block_id != cur_id {
4483                    cur_id.clone_from(&leaf.block_id);
4484                    groups.push(serde_json::json!({
4485                        "block_type": leaf.block_type,
4486                        "block_label": leaf.block_label,
4487                        "block_id": leaf.block_id,
4488                        "depth": leaf.depth,
4489                        "leaves": [row],
4490                    }));
4491                } else if let Some(arr) = groups
4492                    .last_mut()
4493                    .and_then(|g| g.get_mut("leaves"))
4494                    .and_then(|v| v.as_array_mut())
4495                {
4496                    arr.push(row);
4497                }
4498            }
4499            stream_translations.push(serde_json::json!({ "field": w.name, "label": w.label, "groups": groups }));
4500        }
4501        // A code-made type's own text fields (a home page's heading, …).
4502        // Flat keys — the field's name — which the renderer overlays onto
4503        // `extension.<name>` (`translation::overlay_translations`). They
4504        // were translatable but never listed, so the form could not reach
4505        // them.
4506        let field_rows: Vec<serde_json::Value> = raw_widgets
4507            .iter()
4508            .filter(|w| {
4509                use crate::widget::WidgetKind as K;
4510                matches!(w.kind, K::Text | K::Textarea | K::Markdown | K::RichText)
4511                    && !w.name.starts_with(crate::page_builder::compile::FIELD_PREFIX)
4512            })
4513            .map(|w| {
4514                leaf_paths.insert(w.name.clone());
4515                serde_json::json!({
4516                    "path": w.name,
4517                    "widget_kind": w.kind.as_tag(),
4518                    "field_label": w.label,
4519                    "canonical": w.value,
4520                    "canonical_html": translation_canonical_html(w.kind.as_tag(), &w.value),
4521                    "value": existing_translations.get(&w.name).cloned().unwrap_or_default(),
4522                })
4523            })
4524            .collect();
4525        if !field_rows.is_empty() {
4526            stream_translations.insert(
4527                0,
4528                serde_json::json!({
4529                    "field": "fields",
4530                    "label": super::i18n::tr(&headers, "Fields", &[]),
4531                    "groups": [{
4532                        "block_type": "fields",
4533                        "block_label": "",
4534                        "block_id": "fields",
4535                        "depth": 0,
4536                        "leaves": field_rows,
4537                    }],
4538                }),
4539            );
4540        }
4541        // #567 — page-builder body leaves (fixed fields, group members,
4542        // repeater/flex zone blocks). Listed as one more translatable
4543        // "field" alongside the StreamField leaves, keyed `builder.<…>`.
4544        let (builder_groups, builder_paths) =
4545            builder_translation_groups(&tenant, id, page.page_type_id, &existing_translations)
4546                .await;
4547        if !builder_groups.is_empty() {
4548            leaf_paths.extend(builder_paths);
4549            stream_translations
4550                .push(serde_json::json!({
4551                    "field": "builder",
4552                    "label": super::i18n::tr(&headers, "Fields", &[]),
4553                    "groups": builder_groups,
4554                }));
4555        }
4556        // Don't also list dotted leaf paths under the raw "custom keys"
4557        // section (orphaned paths whose block was deleted still appear
4558        // there so editors can clear them).
4559        extra_translations.retain(|(k, _)| !leaf_paths.contains(k));
4560        ctx.insert("stream_translations", &stream_translations);
4561        ctx.insert("extra_translations", &extra_translations);
4562    }
4563
4564    // Computed display chips for the "At a glance" panel above the
4565    // form. See `PageTypeHandler::display_fields` — handlers can
4566    // surface word counts / derived metadata / linked-snippet
4567    // previews without subclassing a panel.
4568    let display_fields: Vec<crate::page_type::DisplayField> = match &resolved_handler {
4569        Some(h) => h
4570            .display_fields(tenant.pool(), id)
4571            .await
4572            .unwrap_or_default(),
4573        None => Vec::new(),
4574    };
4575    ctx.insert("display_fields", &display_fields);
4576
4577    // Handler-contributed tabs — appended to the built-in tab strip
4578    // (Content / Promote / Theme / Revisions). See
4579    // `PageTypeHandler::extra_tabs`.
4580    let mut raw_extra_tabs: Vec<crate::page_type::TabSpec> = match &resolved_handler {
4581        Some(h) => h.extra_tabs(tenant.pool(), id).await.unwrap_or_default(),
4582        None => Vec::new(),
4583    };
4584
4585    // Role list — shared by the Permissions-tab grid below and the
4586    // Privacy tab's "allowed roles" picker further down. Fetched once:
4587    // both used to run the same full-table query independently.
4588    let all_roles: Vec<rustango::tenancy::permissions::Role> =
4589        rustango::tenancy::permissions::Role::objects()
4590            .order_by(&[("name", false)])
4591            .fetch(tenant.pool())
4592            .await
4593            .unwrap_or_default();
4594
4595    // (#18) Permissions tab — every page gets one, regardless of
4596    // page type. Inject a TabSpec::template entry at the front of
4597    // the list so it sits right after Theme.
4598    {
4599        let grants: Vec<crate::permissions::PagePermission> =
4600            crate::permissions::PagePermission::objects()
4601                .where_(crate::permissions::PagePermission::page_id.eq(id))
4602                .fetch(tenant.pool())
4603                .await
4604                .unwrap_or_default();
4605        // (role_id, action) → granted?
4606        let granted: std::collections::HashSet<(i64, String)> = grants
4607            .iter()
4608            .map(|g| (g.role_id, g.permission.clone()))
4609            .collect();
4610        let actions: Vec<&str> = crate::permissions::Action::all()
4611            .iter()
4612            .map(|a| a.as_str())
4613            .collect();
4614        let perm_grid: Vec<serde_json::Value> = all_roles
4615            .iter()
4616            .map(|r| {
4617                let rid = r.id.get().copied().unwrap_or_default();
4618                let row_cells: Vec<serde_json::Value> = actions
4619                    .iter()
4620                    .map(|a| {
4621                        serde_json::json!({
4622                            "action": a,
4623                            "granted": granted.contains(&(rid, (*a).to_owned())),
4624                        })
4625                    })
4626                    .collect();
4627                serde_json::json!({
4628                    "role_id": rid,
4629                    "role_name": r.name,
4630                    "role_description": r.description,
4631                    "cells": row_cells,
4632                })
4633            })
4634            .collect();
4635        let perm_tab = crate::page_type::TabSpec::template(
4636            "permissions",
4637            "Permissions",
4638            "rcms_admin/_permissions_tab.html",
4639        )
4640        .with_icon("admin_panel_settings")
4641        .with_context_value(
4642            "perm_actions",
4643            serde_json::to_value(&actions).unwrap_or_default(),
4644        )
4645        .with_context_value(
4646            "perm_grid",
4647            serde_json::to_value(&perm_grid).unwrap_or_default(),
4648        )
4649        .with_context_value("perm_page_id", serde_json::Value::Number(id.into()));
4650        raw_extra_tabs.insert(0, perm_tab);
4651    }
4652    // (#20) Resolve each `TabSpec` into the flat `{name, label,
4653    // icon, badge, html}` shape the page_form.html template
4654    // expects. `Html` variants pass through; `Template` variants
4655    // render the named Tera template with the standard chrome
4656    // context + the spec's own context map merged in; `Widgets`
4657    // variants route through `_widget_group.html` so widget visuals
4658    // match the Content tab's main stack exactly.
4659    let extra_tabs: Vec<serde_json::Value> =
4660        render_extra_tabs(raw_extra_tabs, &state.tera, &ctx, &headers);
4661    ctx.insert("extra_tabs", &extra_tabs);
4662
4663    let mut extension_fields: Vec<crate::widget::Widget> = raw_widgets;
4664    // A change held for review shows in place of the live values.
4665    let pending_form = pending.as_ref().filter(|_| !translation_mode).map(crate::pending_change::PendingChange::form_map);
4666    if let Some(form) = pending_form.as_ref() {
4667        overlay_pending_widgets(&mut extension_fields, form);
4668    }
4669    // Pre-render `Custom`-kind widgets via the inventory registry.
4670    // Tera's `{% include %}` requires a string literal, so we
4671    // render once on the Rust side and stash the result on each
4672    // widget — same shape `cms_snippet` uses for its
4673    // pre-fetched-snippet HTML map.
4674    for w in &mut extension_fields {
4675        if matches!(w.kind, crate::widget::WidgetKind::Custom) {
4676            if let Some(reg) = crate::widget::registry::find_custom_widget(&w.custom_name) {
4677                let mut sub = Context::new();
4678                sub.insert("w", &w);
4679                w.custom_html = state.tera.render(reg.template, &sub).unwrap_or_else(|e| {
4680                    tracing::warn!(
4681                        target: "rustango_cms::widget",
4682                        custom_name = %w.custom_name,
4683                        template = reg.template,
4684                        error = %e,
4685                        "custom widget template render failed",
4686                    );
4687                    String::new()
4688                });
4689            }
4690        }
4691    }
4692
4693    // -- StreamField pre-render --------------------------------------
4694    // Walk each `Widget::Stream` once: parse its stored JSON, render
4695    // every contained block's editor markup + `<template>` clones
4696    // for each allowed type. The output lives on `w.custom_html`
4697    // (same stash slot the Custom widget arm uses); the `_widget.html`
4698    // macro emits it `| safe` for the stream arm.
4699    for w in &mut extension_fields {
4700        if matches!(w.kind, crate::widget::WidgetKind::Stream) {
4701            w.custom_html =
4702                crate::block::admin::render_stream_editor(w, &state.tera);
4703        }
4704    }
4705    ctx.insert("extension_fields", &extension_fields);
4706
4707    // #564 — page-builder body. When the page type has a published
4708    // schema, pre-render its fixed fields/rows/groups + repeater/flex
4709    // stream editors (prefilled + lazily upgraded) into one HTML blob the
4710    // Body fieldset emits, plus a conditional-rules island.
4711    if let Some((body_html, rules_json, upgraded)) = page_builder_editor_ctx(
4712        &tenant,
4713        &state.tera,
4714        id,
4715        page.page_type_id,
4716        pending_form.as_ref(),
4717    )
4718    .await
4719    {
4720        ctx.insert("builder_body_html", &body_html);
4721        ctx.insert("builder_rules_json", &rules_json);
4722        ctx.insert("builder_upgraded", &upgraded);
4723    }
4724
4725    // #117 — inline panels. Collect each spec the handler declared
4726    // and the persisted rows behind it. Each panel renders as a
4727    // section with N rows; per-row fields come from the spec.
4728    let mut inline_panels: Vec<serde_json::Value> = Vec::new();
4729    if let Some(h) = resolved_handler.as_deref() {
4730        for spec in h.inline_panels() {
4731            let rows = h
4732                .load_inline_panel(tenant.pool(), id, &spec.name)
4733                .await
4734                .unwrap_or_default();
4735            inline_panels.push(serde_json::json!({
4736                "spec": spec,
4737                "rows": rows,
4738            }));
4739        }
4740    }
4741    ctx.insert("inline_panels", &inline_panels);
4742
4743    // Picker options — every registered block surfaces as an option in
4744    // the block-picker dialog inside each stream editor. The dialog
4745    // filters client-side by `data-allowed` at open time.
4746    ctx.insert(
4747        "picker_options",
4748        &crate::block::admin::picker_options(&state.tera),
4749    );
4750
4751    // #72 — editor lock. Best-effort claim on form open: if the page
4752    // is unlocked or already owned by us, we hold the lock and the
4753    // form renders normally. If someone else holds an unexpired
4754    // lock, render the banner with their username + force-unlock
4755    // affordance; the form itself stays editable (we'll reject the
4756    // POST unless the user force-unlocks first).
4757    let mut lock_banner: Option<serde_json::Value> = None;
4758    let mut lock_owned_by_me = false;
4759    let reviewing_elsewhere = match session_user.as_ref() {
4760        Some(u) => read_only_under_review(tenant.pool(), id, u).await?,
4761        None => false,
4762    };
4763    if let Some(viewer_id) = session_user
4764        .as_ref()
4765        .and_then(|u| u.id.get().copied())
4766        .filter(|_| !reviewing_elsewhere)
4767    {
4768        match crate::lock::acquire(tenant.pool(), id, viewer_id, false).await {
4769            Ok(crate::lock::AcquireOutcome::Acquired(_)) => {
4770                lock_owned_by_me = true;
4771            }
4772            Ok(crate::lock::AcquireOutcome::Held(other)) => {
4773                let holder_name = rustango::tenancy::auth::User::objects()
4774                    .where_(rustango::tenancy::auth::User::id.eq(other.user_id))
4775                    .fetch(tenant.pool())
4776                    .await
4777                    .ok()
4778                    .and_then(|v| v.into_iter().next())
4779                    .map(|u| u.username)
4780                    .unwrap_or_else(|| format!("user#{}", other.user_id));
4781                lock_banner = Some(serde_json::json!({
4782                    "holder_username": holder_name,
4783                    "holder_id": other.user_id,
4784                    "acquired_at": other.acquired_at.get().copied(),
4785                    "expires_at": other.expires_at,
4786                }));
4787            }
4788            Err(e) => {
4789                tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "lock acquire failed");
4790            }
4791        }
4792    }
4793    ctx.insert("lock_banner", &lock_banner);
4794    ctx.insert("lock_owned_by_me", &lock_owned_by_me);
4795    ctx.insert("lock_heartbeat_secs", &crate::lock::HEARTBEAT_INTERVAL_SECS);
4796
4797    // #73 PR 2 — workflow context for the action bar + side panel.
4798    // Surface:
4799    //   * `workflow_slug` — the slug the page-type opted into (None if direct-publish)
4800    //   * `workflow` — the resolved Workflow row, if found + active
4801    //   * `workflow_state` — the active WorkflowState row, if one exists
4802    //   * `workflow_current_task` — task currently waiting for a decision (when in_progress)
4803    //   * `workflow_history` — [{task_name, status, decided_by_username, decided_at, comment}, …]
4804    //   * `workflow_viewer_can_decide` — true when viewer is in the current task's role (or superuser)
4805    let workflow_slug: Option<String> = chosen_type.workflow_name();
4806    let mut workflow_ctx: Option<serde_json::Value> = None;
4807    let mut workflow_state_ctx: Option<serde_json::Value> = None;
4808    let mut workflow_current_task_ctx: Option<serde_json::Value> = None;
4809    let mut workflow_history_ctx: Vec<serde_json::Value> = Vec::new();
4810    let mut workflow_viewer_can_decide = false;
4811    if let Some(slug) = workflow_slug.as_deref() {
4812        let workflow = crate::workflow::find_by_name(tenant.pool(), slug)
4813            .await
4814            .unwrap_or(None);
4815        if let Some(wf) = workflow {
4816            let wf_id = wf.id.get().copied().unwrap_or_default();
4817            let tasks = crate::workflow::tasks_for(tenant.pool(), wf_id)
4818                .await
4819                .unwrap_or_default();
4820            workflow_ctx = Some(serde_json::json!({
4821                "id": wf_id,
4822                "name": wf.name,
4823                "description": wf.description,
4824                "task_count": tasks.len(),
4825            }));
4826            // The latest round, whatever its outcome: an approved page says
4827            // so (and can go through review again), not what an earlier
4828            // round ended with.
4829            if let Some(state_row) = crate::workflow::latest_state_for_page(tenant.pool(), id)
4830                .await
4831                .unwrap_or(None)
4832            {
4833                let state_id = state_row.id.get().copied().unwrap_or_default();
4834                // Current task (when in_progress).
4835                if let Some(current) = state_row
4836                    .current_task_id
4837                    .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
4838                {
4839                    workflow_current_task_ctx = Some(serde_json::json!({
4840                        "id": current.id.get().copied(),
4841                        "name": current.name,
4842                        "role_id": current.role_id,
4843                    }));
4844                    if let Some(viewer) = session_user.as_ref() {
4845                        let viewer_id = viewer.id.get().copied().unwrap_or_default();
4846                        workflow_viewer_can_decide = viewer.is_superuser
4847                            || user_is_in_role(tenant.pool(), viewer_id, current.role_id)
4848                                .await
4849                                .unwrap_or(false);
4850                    }
4851                }
4852                workflow_state_ctx = Some(serde_json::json!({
4853                    "id": state_id,
4854                    "status": state_row.status,
4855                    "requested_by": state_row.requested_by,
4856                    "requested_at": state_row.requested_at.get().copied(),
4857                    "finished_at": state_row.finished_at,
4858                }));
4859                // Decision history — flatten task name + reviewer username.
4860                if let Ok(history) = crate::workflow::history_for_page(tenant.pool(), id).await {
4861                    // Pre-resolve user ids to usernames in one batch.
4862                    let reviewer_ids: Vec<i64> =
4863                        history.iter().filter_map(|h| h.decided_by).collect();
4864                    let reviewers: std::collections::HashMap<i64, String> =
4865                        if reviewer_ids.is_empty() {
4866                            std::collections::HashMap::new()
4867                        } else {
4868                            rustango::tenancy::auth::User::objects()
4869                                .where_(rustango::tenancy::auth::User::id.is_in(reviewer_ids))
4870                                .fetch(tenant.pool())
4871                                .await
4872                                .unwrap_or_default()
4873                                .into_iter()
4874                                .filter_map(|u| u.id.get().copied().map(|uid| (uid, u.username)))
4875                                .collect()
4876                        };
4877                    let task_name_by_id: std::collections::HashMap<i64, String> = tasks
4878                        .iter()
4879                        .filter_map(|t| t.id.get().copied().map(|tid| (tid, t.name.clone())))
4880                        .collect();
4881                    workflow_history_ctx = history
4882                        .iter()
4883                        .map(|h| {
4884                            serde_json::json!({
4885                                "task_name": task_name_by_id
4886                                    .get(&h.task_id)
4887                                    .cloned()
4888                                    .unwrap_or_else(|| format!("task #{}", h.task_id)),
4889                                "status": h.status,
4890                                "comment": h.comment,
4891                                "decided_by_username": h
4892                                    .decided_by
4893                                    .and_then(|uid| reviewers.get(&uid).cloned()),
4894                                "decided_at": h.decided_at,
4895                            })
4896                        })
4897                        .collect();
4898                }
4899            }
4900        }
4901    }
4902    // #73 PR 3 — workflow-driven lock. When the page is in_progress
4903    // AND the viewer is not authorized for the current task (and not
4904    // a superuser), the form is read-only — the page belongs to
4905    // whoever is reviewing it right now. Submitter waits for the
4906    // verdict; non-reviewers can't sneak edits in mid-review.
4907    let workflow_locked = workflow_state_ctx
4908        .as_ref()
4909        .and_then(|s| s.get("status"))
4910        .and_then(|v| v.as_str())
4911        .map(|s| s == crate::workflow::WorkflowStatus::InProgress.as_str())
4912        .unwrap_or(false)
4913        && !workflow_viewer_can_decide;
4914    ctx.insert("workflow_slug", &workflow_slug);
4915    ctx.insert("workflow", &workflow_ctx);
4916    ctx.insert("workflow_state", &workflow_state_ctx);
4917    ctx.insert("workflow_current_task", &workflow_current_task_ctx);
4918    ctx.insert("workflow_history", &workflow_history_ctx);
4919    ctx.insert("workflow_viewer_can_decide", &workflow_viewer_can_decide);
4920    ctx.insert("workflow_locked", &workflow_locked);
4921    let review_required = !session_user.as_ref().is_some_and(|u| u.is_superuser)
4922        && crate::workflow::review_workflow_for_type(tenant.pool(), page.page_type_id).await?.is_some();
4923    ctx.insert("review_required", &review_required);
4924    if let (Some(held), Some(form)) = (pending.as_ref(), pending_form.as_ref()) {
4925        ctx.insert("page", &overlay_pending_page(&page, form));
4926        let by = match held.created_by {
4927            Some(uid) => rustango::tenancy::auth::User::objects()
4928                .where_(rustango::tenancy::auth::User::id.eq(uid))
4929                .first(tenant.pool())
4930                .await?
4931                .map(|u| u.username),
4932            None => None,
4933        };
4934        ctx.insert(
4935            "pending_change",
4936            &serde_json::json!({ "by": by, "updated_at": held.updated_at.get().copied() }),
4937        );
4938    }
4939
4940    // #76 — view-restriction context for the Privacy widget.
4941    let view_restriction = crate::view_restriction::direct_for_page(tenant.pool(), id)
4942        .await
4943        .unwrap_or(None);
4944    let restriction_kind = view_restriction
4945        .as_ref()
4946        .map(|r| r.kind.clone())
4947        .unwrap_or_else(|| "none".to_owned());
4948    let restriction_groups = view_restriction
4949        .as_ref()
4950        .map(|r| r.parsed_groups())
4951        .unwrap_or_default();
4952    let restriction_groups_str = restriction_groups
4953        .iter()
4954        .map(i64::to_string)
4955        .collect::<Vec<_>>()
4956        .join(",");
4957    // For the role picker dropdown — reuses the `all_roles` list already
4958    // fetched once above for the Permissions tab.
4959    let role_choices: Vec<serde_json::Value> = all_roles
4960        .iter()
4961        .map(|r| {
4962            serde_json::json!({
4963                "id": r.id.get().copied(),
4964                "name": r.name,
4965                "checked": r.id.get().copied().is_some_and(|rid| restriction_groups.contains(&rid)),
4966            })
4967        })
4968        .collect();
4969    // #members — permission-codename picker (the permission-engine gate).
4970    let restriction_codenames = view_restriction
4971        .as_ref()
4972        .map(|r| r.parsed_codenames())
4973        .unwrap_or_default();
4974    let restriction_codenames_str = restriction_codenames.join(",");
4975    let codename_choices: Vec<serde_json::Value> = super::resources::membership_codenames()
4976        .into_iter()
4977        .map(|(codename, label)| {
4978            serde_json::json!({
4979                "codename": codename,
4980                "label": label,
4981                "checked": restriction_codenames.contains(&codename),
4982            })
4983        })
4984        .collect();
4985    ctx.insert("restriction_kind", &restriction_kind);
4986    ctx.insert("restriction_groups_str", &restriction_groups_str);
4987    ctx.insert("restriction_role_choices", &role_choices);
4988    ctx.insert("restriction_codenames_str", &restriction_codenames_str);
4989    ctx.insert("restriction_codename_choices", &codename_choices);
4990    ctx.insert(
4991        "restriction_has_password",
4992        &view_restriction
4993            .as_ref()
4994            .map(|r| !r.password_hash.is_empty())
4995            .unwrap_or(false),
4996    );
4997
4998    // #81 PR 1 — comments side panel. Fetch every thread on this
4999    // page + every reply in one batched query, group per thread,
5000    // resolve author usernames, and surface as JSON for the panel
5001    // template. Threads with `resolved_at` set render in a
5002    // collapsed "Resolved" bucket client-side.
5003    let threads = crate::comment::threads_for_page(tenant.pool(), id)
5004        .await
5005        .unwrap_or_default();
5006    let thread_ids: Vec<i64> = threads.iter().filter_map(|c| c.id.get().copied()).collect();
5007    let replies_by_thread = crate::comment::replies_for_threads(tenant.pool(), &thread_ids)
5008        .await
5009        .unwrap_or_default();
5010    let mut comment_user_ids: std::collections::BTreeSet<i64> =
5011        threads.iter().map(|c| c.author_id).collect();
5012    for replies in replies_by_thread.values() {
5013        for r in replies {
5014            comment_user_ids.insert(r.author_id);
5015        }
5016    }
5017    let comment_users: std::collections::HashMap<i64, String> = if comment_user_ids.is_empty() {
5018        std::collections::HashMap::new()
5019    } else {
5020        rustango::tenancy::auth::User::objects()
5021            .where_(rustango::tenancy::auth::User::id.is_in(comment_user_ids.iter().copied()))
5022            .fetch(tenant.pool())
5023            .await
5024            .unwrap_or_default()
5025            .into_iter()
5026            .filter_map(|u| u.id.get().copied().map(|uid| (uid, u.username)))
5027            .collect()
5028    };
5029    let comment_threads: Vec<serde_json::Value> = threads
5030        .iter()
5031        .map(|c| {
5032            let tid = c.id.get().copied().unwrap_or_default();
5033            let replies = replies_by_thread.get(&tid).cloned().unwrap_or_default();
5034            let rendered_replies: Vec<serde_json::Value> = replies
5035                .iter()
5036                .map(|r| {
5037                    serde_json::json!({
5038                        "id": r.id.get().copied(),
5039                        "author_username": comment_users.get(&r.author_id).cloned(),
5040                        "body": r.body,
5041                        "created_at": r.created_at.get().copied(),
5042                    })
5043                })
5044                .collect();
5045            serde_json::json!({
5046                "id": tid,
5047                "field_path": c.field_path,
5048                "author_username": comment_users.get(&c.author_id).cloned(),
5049                "body": c.body,
5050                "created_at": c.created_at.get().copied(),
5051                "resolved_at": c.resolved_at,
5052                "replies": rendered_replies,
5053                "reply_count": replies.len(),
5054            })
5055        })
5056        .collect();
5057    ctx.insert("comment_threads", &comment_threads);
5058    ctx.insert(
5059        "comment_open_count",
5060        &comment_threads
5061            .iter()
5062            .filter(|t| t.get("resolved_at").map(|v| v.is_null()).unwrap_or(true))
5063            .count(),
5064    );
5065    ctx.insert(
5066        "comment_resolved_count",
5067        &comment_threads
5068            .iter()
5069            .filter(|t| t.get("resolved_at").map(|v| !v.is_null()).unwrap_or(false))
5070            .count(),
5071    );
5072    // For the field-picker dropdown when adding a new comment.
5073    ctx.insert(
5074        "comment_field_choices",
5075        &serde_json::json!([
5076            {"value": "title", "label": "Title"},
5077            {"value": "slug", "label": "Slug"},
5078            {"value": "seo_title", "label": "SEO title"},
5079            {"value": "seo_description", "label": "SEO description"},
5080            {"value": "body", "label": "Body / stream content"},
5081            {"value": "general", "label": "General — whole page"},
5082        ]),
5083    );
5084
5085    render_with_csrf(&state, &headers, "rcms_admin/page_form.html", &mut ctx)
5086}
5087
5088/// POST /cms-admin/pages/{id}/edit — apply edits.
5089/// POST /cms-admin/pages/{id}/autosave — silent revision capture.
5090/// Takes the same form payload as
5091/// `page_edit_submit` but:
5092///   - Skips status-promotion logic (draft → published doesn't fire).
5093///   - Captures a revision row tagged `autosave: true` so the
5094///     timeline distinguishes autosaves from manual saves.
5095///   - Does NOT cascade slug / url_path recomputation, redirects,
5096///     workflow events, cache invalidation, or page_subscription
5097///     notifications — autosaves are scratch state, not publish
5098///     events.
5099///   - Returns 204 No Content so the editor JS treats success as a
5100///     quiet acknowledgement (no flash banner).
5101pub async fn page_autosave_submit(
5102    State(_state): State<super::AdminState>,
5103    tenant: Tenant,
5104    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
5105    Path(id): Path<i64>,
5106    Form(form_map): Form<std::collections::HashMap<String, String>>,
5107) -> Result<Response, AdminError> {
5108    use rustango::sql::FetcherPool as _;
5109    let mut page = Page::objects()
5110        .where_(Page::id.eq(id))
5111        .first(tenant.pool())
5112        .await?
5113        .ok_or(AdminError::NotFound(id))?;
5114    // Lock-respect — same as the regular save path. Refuse the
5115    // autosave when someone else holds the lock; the editor JS
5116    // surfaces this by suspending future autosaves until the user
5117    // reloads.
5118    if let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) {
5119        if let Ok(Some(lock)) = crate::lock::current(tenant.pool(), id).await {
5120            if lock.user_id != viewer_id {
5121                return Ok((axum::http::StatusCode::CONFLICT, "locked").into_response());
5122            }
5123        }
5124    }
5125    // Autosave writes the page row itself, so it only touches drafts:
5126    // on a live (or scheduled) page it would publish half-typed edits,
5127    // skipping the publish right and any review. The real Save handles
5128    // those pages; here nothing is written.
5129    if page.status != crate::page::PageStatus::Draft.as_str() {
5130        return Ok((axum::http::StatusCode::NO_CONTENT, "").into_response());
5131    }
5132    if let Some(u) = session_user.as_ref() {
5133        if read_only_under_review(tenant.pool(), id, u).await? {
5134            return Ok((axum::http::StatusCode::CONFLICT, "under review").into_response());
5135        }
5136    }
5137    // Overlay mutable fields. Tree placement (parent / path /
5138    // url_path / depth / sort_order) intentionally left alone —
5139    // autosaves never move the page. That includes the slug: writing it
5140    // here without url_path made the next real save see "no slug change",
5141    // so the rename never cascaded to url_path, children or a 301 (#679).
5142    // The edited slug stays in the form and the real save applies it.
5143    if let Some(v) = form_map.get("title") {
5144        page.title = v.clone();
5145    }
5146    if let Some(v) = form_map.get("seo_title") {
5147        page.seo_title = v.clone();
5148    }
5149    if let Some(v) = form_map.get("seo_description") {
5150        page.seo_description = v.clone();
5151    }
5152    // Skip status promotion. If the editor changed status, we
5153    // record it for the diff but don't fire any publish-side
5154    // effects.
5155    let posted_status = form_map.get("status").cloned();
5156    page.save_pool(tenant.pool()).await?;
5157    // Persist extension fields via handler (idempotent upserts).
5158    let pts: Vec<PageType> = PageType::objects()
5159        .where_(PageType::id.eq(page.page_type_id))
5160        .fetch(tenant.pool())
5161        .await?;
5162    if let Some(pt) = pts.into_iter().next() {
5163        if let Some(handler) = find_handler(&pt.type_name) {
5164            let ext_form =
5165                sanitized_extension_form(handler.as_ref(), tenant.pool(), id, &form_map).await;
5166            handler.save_extension(tenant.pool(), id, &ext_form).await?;
5167        }
5168    }
5169    // #564 — page-builder body values (additive to any code handler).
5170    save_page_builder_values(tenant.pool(), page.page_type_id, id, &form_map).await?;
5171    // Capture an autosave-flagged revision. Failure here is
5172    // best-effort.
5173    let by = session_user.as_ref().and_then(|u| u.id.get().copied());
5174    if let Ok(mut rev) = crate::revision::capture(tenant.pool(), &page, by).await {
5175        // Inject the autosave marker into the snapshot before
5176        // re-saving the row. The snapshot column is a plain
5177        // serde_json::Value so we can mutate + re-persist.
5178        if let serde_json::Value::Object(ref mut map) = rev.snapshot {
5179            map.insert("__autosave".to_owned(), serde_json::Value::Bool(true));
5180            if let Some(status) = posted_status {
5181                map.insert(
5182                    "__autosave_posted_status".to_owned(),
5183                    serde_json::Value::String(status),
5184                );
5185            }
5186            rev.save_pool(tenant.pool()).await.log_warn("autosave revision not stored");
5187        }
5188    }
5189    Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
5190}
5191
5192/// Allow-list of POST keys that `page_edit_submit` re-feeds into
5193/// [`PageForm`]. The submit handler filters the incoming form map
5194/// through this list to drop extension-field entries the page type
5195/// handler owns. Every field [`PageForm`] consumes — and every field
5196/// the body of `page_edit_submit` reads off the parsed form — MUST
5197/// be listed here, or the value is silently dropped on save.
5198///
5199/// `page_type_id` is intentionally absent: type is assigned at
5200/// create-time and is permanent (see comment in the handler).
5201/// Page fields the editor shows as text, overlaid from a held change.
5202const PENDING_TEXT_KEYS: &[&str] = &[
5203    "title",
5204    "slug",
5205    "seo_title",
5206    "seo_description",
5207    "og_title",
5208    "og_description",
5209    "preview_path",
5210];
5211
5212/// `page` as the editor shows it with a held change on top: its text
5213/// fields take the proposed values.
5214fn overlay_pending_page(
5215    page: &Page,
5216    form: &std::collections::HashMap<String, String>,
5217) -> serde_json::Value {
5218    let mut value = serde_json::to_value(page).unwrap_or_default();
5219    if let Some(obj) = value.as_object_mut() {
5220        for key in PENDING_TEXT_KEYS {
5221            if let Some(v) = form.get(*key) {
5222                obj.insert((*key).to_owned(), serde_json::Value::String(v.clone()));
5223            }
5224        }
5225    }
5226    value
5227}
5228
5229/// Give each widget its value from a held change. An unticked checkbox
5230/// isn't posted, so a Boolean the form lacks is off.
5231fn overlay_pending_widgets(
5232    widgets: &mut [crate::widget::Widget],
5233    form: &std::collections::HashMap<String, String>,
5234) {
5235    for w in widgets {
5236        match form.get(&w.name) {
5237            Some(v) => w.value.clone_from(v),
5238            None if matches!(w.kind, crate::widget::WidgetKind::Boolean) => w.value.clear(),
5239            None => {}
5240        }
5241    }
5242}
5243
5244const PAGE_FORM_CANONICAL_KEYS: &[&str] = &[
5245    "title",
5246    "slug",
5247    "status",
5248    "seo_title",
5249    "seo_description",
5250    "robots_index",
5251    "sitemap_priority",
5252    "parent_id",
5253    "theme_id",
5254    // #207 — schedule + auto-archive.
5255    "go_live_at",
5256    "expire_at",
5257    // #22 — surface in navigation editor.
5258    "show_in_menus",
5259    // Headless preview — per-page frontend route override.
5260    "preview_path",
5261    // Per-page template, overriding the page type's.
5262    "template_override",
5263    // #183 — social sharing.
5264    "og_title",
5265    "og_description",
5266    "og_image_media_id",
5267    "twitter_card",
5268    // #189 — page tags (comma-separated).
5269    "tags",
5270];
5271
5272/// The acting user for [`apply_page_edit`] — carries exactly what the
5273/// lock / workflow / attribution logic needs, decoupled from the HTTP
5274/// session type so the MCP tools can act as a key's owner.
5275pub(crate) struct PageEditActor {
5276    pub id: i64,
5277    pub username: String,
5278    pub is_superuser: bool,
5279}
5280
5281/// A save refused for a *policy* reason (not an error): the caller
5282/// renders it in its own shape — the HTTP handler as a flash+redirect,
5283/// an MCP tool as a structured tool error.
5284pub(crate) enum PageEditRefusal {
5285    /// Page is mid-review on a workflow step the actor can't edit.
5286    WorkflowReview { task_name: String },
5287    /// Another editor holds the edit lock.
5288    LockedBy { holder: String },
5289    /// Archived pages can't be unpublished in place.
5290    ArchivedUnpublish,
5291    /// The save would put the page live and the actor lacks the publish
5292    /// right.
5293    PublishDenied,
5294    /// The save would put the page live, but pages of its type go live
5295    /// through the named review workflow.
5296    ReviewRequired { workflow: String },
5297}
5298
5299/// What a successful [`apply_page_edit`] produced, for caller messaging.
5300pub(crate) struct PageEditOutcome {
5301    pub page: Page,
5302    pub redirects_created: usize,
5303    pub reapproval_kicked: bool,
5304    /// The save was kept for review; the live page is unchanged.
5305    pub held_for_review: bool,
5306}
5307
5308/// Apply one page edit end-to-end from a canonical+extension form map —
5309/// the single write path behind both `page_edit_submit` (HTTP) and the
5310/// MCP `update_page`/`publish_page` tools. Covers: workflow + editor
5311/// lock policy, the canonical-key overlay (`PAGE_FORM_CANONICAL_KEYS`),
5312/// scheduled-status derivation + publish timestamps, the atomic tree
5313/// save with url-path cascade + on-commit cache purges, tags, revision
5314/// capture (attributed to `actor`), reference reindex, search sync,
5315/// publish hooks + page log, extension + inline-panel + page-builder
5316/// value persistence, auto-301s on slug moves, redirect auto-disable on
5317/// unpublish, and reapproval-on-edit. `notify = false` skips the
5318/// publish subscription mail (MCP v1). Flash/redirect rendering stays
5319/// with the HTTP handler.
5320#[allow(clippy::too_many_arguments)]
5321pub(crate) async fn apply_page_edit(
5322    pool: &rustango::sql::Pool,
5323    org_slug: &str,
5324    invalidator: &std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator>,
5325    mailer: Option<&dyn rustango::email::Mailer>,
5326    mailer_from: &str,
5327    notify: bool,
5328    id: i64,
5329    form_map: &std::collections::HashMap<String, String>,
5330    actor: Option<&PageEditActor>,
5331) -> Result<Result<PageEditOutcome, PageEditRefusal>, AdminError> {
5332    // #73 PR 3 — workflow lock. While the page is in_progress on a
5333    // workflow, only members of the current task's role (and
5334    // superusers) can save edits. Submitter waits for the verdict;
5335    // non-reviewers can't sneak fixes in mid-review. Checked BEFORE
5336    // the editor lock — workflow restrictions outrank concurrency.
5337    if let Some(actor) = actor {
5338        if let Some(active) = crate::workflow::active_state_for_page(pool, id).await? {
5339            if active.status == crate::workflow::WorkflowStatus::InProgress.as_str()
5340                && !actor.is_superuser
5341            {
5342                let tasks = crate::workflow::tasks_for(pool, active.workflow_id).await?;
5343                if let Some(current_task) = active
5344                    .current_task_id
5345                    .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
5346                {
5347                    if !user_is_in_role(pool, actor.id, current_task.role_id).await? {
5348                        return Ok(Err(PageEditRefusal::WorkflowReview {
5349                            task_name: current_task.name.clone(),
5350                        }));
5351                    }
5352                }
5353            }
5354        }
5355    }
5356
5357    // #72 — refuse the write if the page is locked by someone else.
5358    // The GET path acquires the lock for the viewer; if they got
5359    // through, this is a no-op. If a second editor saves anyway
5360    // (race or curl), they hit a 409-flavored redirect with a flash
5361    // explaining who holds the lock. Force-unlock is a separate
5362    // POST so accidental clobbers stay impossible.
5363    if let Some(actor) = actor {
5364        match crate::lock::current(pool, id).await {
5365            Ok(Some(lock)) if lock.user_id != actor.id => {
5366                let holder = rustango::tenancy::auth::User::objects()
5367                    .where_(rustango::tenancy::auth::User::id.eq(lock.user_id))
5368                    .fetch(pool)
5369                    .await
5370                    .ok()
5371                    .and_then(|v| v.into_iter().next())
5372                    .map(|u| u.username)
5373                    .unwrap_or_else(|| format!("user#{}", lock.user_id));
5374                return Ok(Err(PageEditRefusal::LockedBy { holder }));
5375            }
5376            _ => {}
5377        }
5378    }
5379
5380    // Re-deserialize as PageForm using only the canonical keys. The
5381    // form map also carries extension-field entries (typed body /
5382    // hero / etc.) the type's handler is interested in; we hand that
5383    // raw HashMap to `save_extension` after the canonical save.
5384    //
5385    // `page_type_id` is *not* in this list — page type is assigned at
5386    // create-time and is permanent. Any value posted is ignored. The
5387    // template hides the selector and the handler defensively drops
5388    // the key here. Caller scenarios that *must* change a page's
5389    // type can delete + recreate (preserves slug history via
5390    // `cms_redirect`).
5391    let canonical_keys = PAGE_FORM_CANONICAL_KEYS;
5392    let mut canonical_only: std::collections::HashMap<&str, String> = form_map
5393        .iter()
5394        .filter(|(k, _)| canonical_keys.contains(&k.as_str()))
5395        .map(|(k, v)| (k.as_str(), v.clone()))
5396        .collect();
5397
5398    let mut page = Page::objects()
5399        .where_(Page::id.eq(id))
5400        .first(pool)
5401        .await?
5402        .ok_or(AdminError::NotFound(id))?;
5403
5404    // Re-inject the immutable `page_type_id` from the persisted row
5405    // so `PageForm`'s deserializer is satisfied without trusting
5406    // anything the client posted.
5407    let frozen_type_id = page.page_type_id.to_string();
5408    canonical_only.insert("page_type_id", frozen_type_id);
5409    let canonical_view: std::collections::HashMap<&str, &str> = canonical_only
5410        .iter()
5411        .map(|(k, v)| (*k, v.as_str()))
5412        .collect();
5413    let form: PageForm = serde_urlencoded::from_str(
5414        &serde_urlencoded::to_string(&canonical_view).unwrap_or_default(),
5415    )
5416    .map_err(|e| AdminError::Validation(format!("canonical form: {e}")))?;
5417
5418    // A live page of a type whose review workflow asks for re-approval
5419    // on edit: a non-superuser's save waits for that review instead of
5420    // changing what visitors see. The final approval applies it (a save
5421    // with no actor, so it isn't held again).
5422    if let Some(actor) = actor.filter(|a| !a.is_superuser) {
5423        if page.status == crate::page::PageStatus::Published.as_str() {
5424            if let Some(wf) = crate::workflow::review_workflow_for_type(pool, page.page_type_id)
5425                .await?
5426                .filter(|wf| wf.require_reapproval_on_edit)
5427            {
5428                crate::pending_change::hold(pool, id, form_map, Some(actor.id)).await?;
5429                let mut started = false;
5430                if crate::workflow::active_state_for_page(pool, id).await?.is_none() {
5431                    let tasks =
5432                        crate::workflow::tasks_for(pool, wf.id.get().copied().unwrap_or_default())
5433                            .await?;
5434                    crate::workflow::submit_for_review(pool, id, &wf, &tasks, actor.id).await?;
5435                    started = true;
5436                }
5437                return Ok(Ok(PageEditOutcome {
5438                    page,
5439                    redirects_created: 0,
5440                    reapproval_kicked: started,
5441                    held_for_review: true,
5442                }));
5443            }
5444        }
5445    }
5446
5447    page.title = form.title.clone();
5448    // #703 — the same normalisation a new page gets, and no two siblings
5449    // on one slug: they would share a URL and serve whichever row the
5450    // driver returned. The pattern attribute alone is bypassed by any
5451    // direct POST (and by MCP update_page, which lands here).
5452    let new_slug = if form.slug.trim().is_empty() {
5453        String::new()
5454    } else {
5455        slugify(&form.slug)
5456    };
5457    let slug_changed = page.slug != new_slug;
5458    if slug_changed && !new_slug.is_empty() {
5459        let sibling = Page::objects()
5460            .where_(Page::slug.eq(new_slug.clone()))
5461            .where_(Page::id.ne(id));
5462        let sibling = match page.parent_id {
5463            Some(pid) => sibling.where_(Page::parent_id.eq(pid)),
5464            None => sibling.where_(Page::parent_id.is_null()),
5465        };
5466        if sibling.first(pool).await?.is_some() {
5467            return Err(AdminError::Validation(format!(
5468                "another page under the same parent already uses the slug “{new_slug}”"
5469            )));
5470        }
5471    }
5472    // Capture the OLD url_path BEFORE the recomputation block below
5473    // overwrites it. Used after commit to evict the now-stale cache
5474    // entry under the page's previous URL.
5475    let old_url_path = page.url_path.clone();
5476    page.slug = new_slug;
5477    // #553 — remember whether this save takes the page out of
5478    // Published, so linked redirect rules can be auto-disabled below.
5479    let was_published = page.status == crate::page::PageStatus::Published.as_str();
5480    // #556 — remember whether it was archived, to block an unpublish
5481    // (archived → draft) below. Archived → published is the unarchive
5482    // path and stays allowed.
5483    let was_archived = page.status == crate::page::PageStatus::Archived.as_str();
5484    let old_status = page.status.clone();
5485    // page.page_type_id stays as-is — see comment on `canonical_keys`.
5486    page.status = form.parsed_status().as_str().to_owned();
5487    page.seo_title = form.seo_title.clone();
5488    page.seo_description = form.seo_description.clone();
5489    page.robots_index = form.parsed_robots_index();
5490    page.sitemap_priority = form.parsed_sitemap_priority();
5491    page.theme_id = form.theme_id;
5492    // #207 — clear the pre-publish reminder flag when go_live_at
5493    // moves so a fresh schedule horizon gets a fresh reminder.
5494    let new_go_live = form.parsed_go_live_at();
5495    if page.go_live_at != new_go_live {
5496        page.notification_pre_published_sent = false;
5497    }
5498    page.go_live_at = new_go_live;
5499    page.expire_at = form.parsed_expire_at();
5500    // #264 — derive scheduled state from go_live_at AFTER the form's
5501    // chosen status has been applied above, so picking "Draft" +
5502    // setting a future go-live still parks the row in the sweep's
5503    // pickup queue.
5504    page.status = derive_scheduled_status(&page.status, page.go_live_at);
5505    page.show_in_menus = form.parsed_show_in_menus();
5506    page.preview_path = form.preview_path.trim().to_owned();
5507    page.template_override = form.template_override.trim().to_owned();
5508    // #251 — first/last publish timestamps. `published_at` is set
5509    // once on the first published transition (still the
5510    // chronological-ordering anchor). `last_published_at` bumps on
5511    // every save while status=published — sitemap / cache use it
5512    // for freshness.
5513    if page.status == crate::page::PageStatus::Published.as_str() {
5514        let now = chrono::Utc::now();
5515        if page.published_at.is_none() {
5516            page.published_at = Some(now);
5517        }
5518        page.last_published_at = Some(now);
5519    }
5520    // #556 — an archived page can't be unpublished to Draft in place;
5521    // it must be revived (→ Published) or explicitly unarchived first.
5522    // This runs before any DB mutation below.
5523    if was_archived && page.status == crate::page::PageStatus::Draft.as_str() {
5524        return Ok(Err(PageEditRefusal::ArchivedUnpublish));
5525    }
5526    // #761 — judged on the status this save actually lands on, after
5527    // `derive_scheduled_status`, so neither `archived` nor Draft plus a
5528    // go-live date gets a draft public without the publish right. Here so
5529    // the admin form and MCP share one rule. A save with no actor is the
5530    // CMS's own.
5531    if let Some(actor) = actor {
5532        if crate::page::PageStatus::str_goes_live(&old_status, &page.status) {
5533            // A workflow on the page type is only a promise if nobody can
5534            // publish around it: only its approval (or a superuser) puts
5535            // such a page live. Asked first — "submit it for review" is
5536            // the useful answer whatever the actor's rights.
5537            if !actor.is_superuser {
5538                if let Some(wf) = crate::workflow::review_workflow_for_type(pool, page.page_type_id).await? {
5539                    return Ok(Err(PageEditRefusal::ReviewRequired { workflow: wf.name }));
5540                }
5541            }
5542            let req = super::route_perms::Requirement {
5543                codename: "cms_page.publish".to_owned(),
5544                page: Some((id, crate::permissions::Action::Publish)),
5545            };
5546            if !super::route_perms::allows_id(pool, actor.id, actor.is_superuser, &req).await {
5547                return Ok(Err(PageEditRefusal::PublishDenied));
5548            }
5549        }
5550    }
5551    // #183 — social sharing fields.
5552    page.og_title = form.og_title.clone();
5553    page.og_description = form.og_description.clone();
5554    page.og_image_media_id = form.og_image_media_id;
5555    if let Some(tc) = form.twitter_card.as_deref() {
5556        if matches!(tc, "summary" | "summary_large_image") {
5557            page.twitter_card = tc.to_owned();
5558        }
5559    }
5560
5561    // Recompute the materialized `url_path` when the
5562    // slug changes, and cascade the recomputation to
5563    // every descendant so deep trees stay correct after an ancestor
5564    // rename.
5565    if slug_changed {
5566        let parent_url_path = match page.parent_id {
5567            None => None,
5568            Some(pid) => Page::objects()
5569                .where_(Page::id.eq(pid))
5570                .first(pool)
5571                .await?
5572                .map(|p| p.url_path),
5573        };
5574        page.url_path = crate::tree_ops::compute_url_path(parent_url_path.as_deref(), &page.slug);
5575    }
5576    let new_url_path = page.url_path.clone();
5577
5578    // Wrap self-save + cascade in one atomic_tree block so the tree
5579    // never observes a mixed state (own page updated but children
5580    // stale). The #78 purge of the affected URLs — this page's new
5581    // URL, plus (on a slug change) its old URL and every descendant —
5582    // is registered via on_commit, so it fires only once the save
5583    // commits (never on rollback) and runs detached. #317.
5584    let invalidator = invalidator.clone();
5585    let tenant_slug = org_slug.to_owned();
5586    let purge_new = new_url_path.clone();
5587    let purge_old = old_url_path.clone();
5588    let (page, descendant_urls) = crate::tree_ops::atomic_tree(pool, move |tx| {
5589        Box::pin(async move {
5590            page.save_tx(tx).await?;
5591            let descendants: Vec<Page> = if slug_changed {
5592                crate::tree_ops::cascade_url_path_to_descendants(tx, &page).await?;
5593                Page::objects()
5594                    .where_(Page::path.like(crate::tree::descendants_like(&page.path)))
5595                    .where_(Page::path.ne(page.path.clone()))
5596                    .fetch_tx(tx)
5597                    .await?
5598            } else {
5599                Vec::new()
5600            };
5601            // A rename moves this page and everything under it: keep the
5602            // old addresses of the public ones working (redirects that
5603            // follow the page).
5604            if slug_changed {
5605                let public = |p: &Page| matches!(p.status.as_str(), "published" | "archived");
5606                let mut moves = Vec::with_capacity(1 + descendants.len());
5607                if public(&page) {
5608                    moves.push((page.id.get().copied().unwrap_or_default(), purge_old.clone(), purge_new.clone()));
5609                }
5610                for d in descendants.iter().filter(|d| public(d)) {
5611                    if let Some(old) = crate::redirect::rebase_path(&d.url_path, &purge_new, &purge_old) {
5612                        moves.push((d.id.get().copied().unwrap_or_default(), old, d.url_path.clone()));
5613                    }
5614                }
5615                crate::redirect::record_renames_tx(tx, &moves).await?;
5616            }
5617            let descendant_urls: Vec<String> = descendants.into_iter().map(|d| d.url_path).collect();
5618            let mut urls = Vec::with_capacity(2 + descendant_urls.len());
5619            urls.push(purge_new.clone());
5620            if slug_changed && purge_old != purge_new && !purge_old.is_empty() {
5621                urls.push(purge_old);
5622            }
5623            urls.extend(descendant_urls.iter().cloned());
5624            crate::cache_invalidate::invalidate_urls_on_commit(invalidator, tenant_slug, urls);
5625            Ok((page, descendant_urls))
5626        })
5627    })
5628    .await?;
5629    // #705 — the page's content goes in straight after the core row, and
5630    // before anything announces the save: the revision, the reference
5631    // index, search, publish hooks, subscriber mail and the page log all
5632    // describe this content. A failed write is returned to the caller,
5633    // not logged and swallowed behind a "Saved" flash. (The writes can't
5634    // join the core row's transaction yet — the handler hooks take a
5635    // pool — so the core row stays committed; resubmitting is safe, the
5636    // upserts are idempotent.)
5637    //
5638    // #189 — tags from the comma-separated `tags` field. Missing → left
5639    // alone; posted empty → cleared.
5640    if let Some(tags_raw) = form_map.get("tags") {
5641        let names: Vec<String> = if tags_raw.is_empty() {
5642            Vec::new()
5643        } else {
5644            tags_raw.split(',').map(|s| s.to_owned()).collect()
5645        };
5646        crate::page_tag::replace_tags(pool, id, &names).await?;
5647    }
5648    // #842 — categories, same missing/empty rule as tags.
5649    crate::category::assign::save_from_form(
5650        pool,
5651        id,
5652        form_map.get(crate::category::assign::FORM_KEY).map(String::as_str),
5653    )
5654    .await?;
5655    let pts: Vec<PageType> = PageType::objects()
5656        .where_(PageType::id.eq(page.page_type_id))
5657        .fetch(pool)
5658        .await?;
5659    let pt_opt: Option<PageType> = pts.into_iter().next();
5660    if let Some(pt) = &pt_opt {
5661        if let Some(handler) = find_handler(&pt.type_name) {
5662            let ext_form = sanitized_extension_form(handler.as_ref(), pool, id, &form_map).await;
5663            handler.save_extension(pool, id, &ext_form).await?;
5664            // #117 — inline panels. Reassemble row dicts from the
5665            // posted `inline__<panel>__<idx>__<field>` keys and hand
5666            // them to the handler. Handler is responsible for the
5667            // upsert / delete-removed semantics.
5668            for spec in handler.inline_panels() {
5669                let rows = extract_inline_panel_rows(&form_map, &spec);
5670                handler.save_inline_panel(pool, id, &spec.name, &rows).await?;
5671            }
5672        }
5673    }
5674    // #564 — page-builder body values (additive to any code handler).
5675    save_page_builder_values(pool, page.page_type_id, id, &form_map).await?;
5676
5677    // Capture revision after commit so the committed
5678    // page row is visible to the sequence SELECT inside capture.
5679    crate::revision::capture(pool, &page, actor.map(|a| a.id))
5680        .await
5681        .log_warn("revision not captured; the history has a gap");
5682
5683    // #146 — reindex the reference graph from the just-saved form
5684    // values. The (cheap, in-memory) scan stays here where the form is
5685    // in hand; #432 moves the (DB-write) reindex onto the task queue
5686    // via `reindex_page` — dispatched + retried when a sink is
5687    // installed, inline otherwise. Best-effort either way.
5688    {
5689        let mut refs: Vec<crate::reference_index::Reference> = Vec::new();
5690        for (key, value) in form_map {
5691            // Scan every form field for /__media__/... + page/snippet
5692            // links. Field-scoped so the index records which input
5693            // produced each reference.
5694            let mut found = crate::reference_index::scan(value, key);
5695            refs.append(&mut found);
5696        }
5697        let page_id = page.id.get().copied().unwrap_or_default();
5698        crate::task_queue::reindex_page(pool, org_slug, page_id, refs).await;
5699    }
5700
5701    // #408 — keep an external search index (Elasticsearch) in sync:
5702    // published → indexed, otherwise removed. No-op when no backend is
5703    // installed (the Postgres FTS path needs no maintained index).
5704    crate::task_queue::sync_page_search(org_slug, &page).await;
5705
5706    // #107 — fan out to plugin `after_publish_page` hooks.
5707    let actor_id = actor.map(|a| a.id);
5708    if page.status == crate::page::PageStatus::Published.as_str() {
5709        crate::hooks::fire_after_publish_page(&page);
5710        // #115 — notify-on-publish subscribers.
5711        if notify {
5712            let actor_name = actor.map(|a| a.username.as_str());
5713            crate::page_subscription::notify_publish(
5714                mailer,
5715                mailer_from,
5716                pool,
5717                org_slug,
5718                page.id.get().copied().unwrap_or_default(),
5719                &page.title,
5720                &page.url_path,
5721                actor_name,
5722            )
5723            .await;
5724        }
5725        // #192 — record the publish in the audit log.
5726        crate::page_log::record_or_warn(
5727            pool,
5728            id,
5729            crate::page_log::ACTION_PUBLISH,
5730            actor_id,
5731            format!("Published “{}”.", page.title),
5732            None,
5733        )
5734        .await;
5735    } else {
5736        // #192 — log the edit even when the new status isn't Published.
5737        crate::page_log::record_or_warn(
5738            pool,
5739            id,
5740            crate::page_log::ACTION_EDIT,
5741            actor_id,
5742            format!("Edited “{}”.", page.title),
5743            Some(serde_json::json!({ "status": page.status })),
5744        )
5745        .await;
5746    }
5747
5748
5749    // #64 — auto-create 301 redirects from old paths to new ones
5750    // when a slug change cascades through the URL tree. Editors
5751    // rename pages all the time; keeping the old URL alive prevents
5752    // external links + SEO rank from going dead.
5753    let mut redirects_created = 0usize;
5754    if slug_changed && old_url_path != new_url_path && !old_url_path.is_empty() {
5755        // Capture the descendant before/after pairs alongside the
5756        // page itself. The cascade already updated every descendant's
5757        // url_path in the same transaction; rebuild the OLD → NEW
5758        // map from the path prefix relationship: a descendant whose
5759        // new url_path begins with `new_url_path` had its OLD url at
5760        // `old_url_path + suffix`.
5761        let new_prefix = if new_url_path == "/" {
5762            String::new()
5763        } else {
5764            new_url_path.clone()
5765        };
5766        let old_prefix = if old_url_path == "/" {
5767            String::new()
5768        } else {
5769            old_url_path.clone()
5770        };
5771        let mut pairs: Vec<(String, String)> = vec![(old_url_path.clone(), new_url_path.clone())];
5772        for new_d in &descendant_urls {
5773            if let Some(suffix) = new_d.strip_prefix(new_prefix.as_str()) {
5774                let old_d = format!("{old_prefix}{suffix}");
5775                if old_d != *new_d {
5776                    pairs.push((old_d, new_d.clone()));
5777                }
5778            }
5779        }
5780        // Upsert each pair. If an existing redirect already targets the
5781        // old path (e.g. from a previous rename), update its `to_path`
5782        // so the chain compresses to one hop instead of `foo → bar →
5783        // baz`. New rows land with is_permanent=true (301) + a stamped
5784        // note for auditability.
5785        let now = chrono::Utc::now().to_rfc3339();
5786        for (old_path, new_path) in pairs {
5787            // Look up any existing row keyed on the old URL.
5788            let existing: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
5789                .where_(crate::redirect::Redirect::from_path.eq(old_path.clone()))
5790                .fetch(pool)
5791                .await
5792                .unwrap_or_default();
5793            if let Some(mut r) = existing.into_iter().next() {
5794                // Compress chain: rewrite the existing row's target
5795                // unless it already points at the new URL.
5796                if r.to_path != new_path {
5797                    r.to_path = new_path.clone();
5798                    r.is_permanent = true;
5799                    r.note = format!("auto-updated on page rename at {now}");
5800                    // #553 — link the source page so the rule
5801                    // auto-disables if the page is later removed.
5802                    if r.from_page_id.is_none() {
5803                        r.from_page_id = Some(id);
5804                    }
5805                    r.save_pool(pool).await.log_warn("redirect not linked to its source page");
5806                }
5807                continue;
5808            }
5809            // Compress incoming chain: if an OLD existing row was
5810            // pointing TO old_path, redirect it straight to new_path
5811            // instead so the chain stays one hop.
5812            let stale_chain: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
5813                .where_(crate::redirect::Redirect::to_path.eq(old_path.clone()))
5814                .fetch(pool)
5815                .await
5816                .unwrap_or_default();
5817            for mut r in stale_chain {
5818                // #708 — renaming back (A → B, then B → A) would chain
5819                // A → B into A → A. The page lives at A again, so the
5820                // rule has nothing left to do.
5821                if r.from_path == new_path {
5822                    r.delete_pool(pool)
5823                        .await
5824                        .log_warn("self-redirect left after a rename back not deleted");
5825                    continue;
5826                }
5827                r.to_path = new_path.clone();
5828                r.note = format!("auto-chained on page rename at {now}");
5829                r.save_pool(pool).await.log_warn("redirect chain not updated after a rename");
5830            }
5831            // Insert the fresh old → new row.
5832            let mut row = crate::redirect::Redirect {
5833                id: rustango::sql::Auto::Unset,
5834                from_path: old_path,
5835                to_path: new_path,
5836                is_permanent: true,
5837                note: format!("auto-created on page rename at {now}"),
5838                hit_count: 0,
5839                overrides_live: false,
5840                // Link the renamed page so the rule auto-disables if the
5841                // page is later deleted/unpublished (#553).
5842                from_page_id: Some(id),
5843                to_page_id: None,
5844                is_active: true,
5845                disabled_reason: String::new(),
5846                last_hit_at: None,
5847                created_at: rustango::sql::Auto::Unset,
5848                updated_at: rustango::sql::Auto::Unset,
5849            };
5850            if row.insert_pool(pool).await.is_ok() {
5851                redirects_created += 1;
5852            }
5853        }
5854    }
5855
5856    // #78 cache invalidation for the affected URLs is registered via
5857    // `on_commit` inside the save block above (#317), so it fires only
5858    // once the save commits and doesn't block this response.
5859
5860    // #73 PR 3 — reapproval-on-edit. When the page type is bound to
5861    // a workflow whose `require_reapproval_on_edit` flag is set, and
5862    // the page has previously been through review (any approved
5863    // WorkflowState in its history), restart the workflow on this
5864    // save. The page stays at its current status; a fresh
5865    // WorkflowState pinned to task #1 kicks off a new approval
5866    // cycle. No-op when no active workflow exists for the type, or
5867    // when the page hasn't been approved yet (first-time submitters
5868    // explicitly submit via the action bar).
5869    let mut reapproval_kicked = false;
5870    if let (Some(viewer_id), Some(pt)) = (actor.map(|a| a.id), pt_opt.as_ref()) {
5871        if let Some(slug) = pt.workflow_name() {
5872            if let Some(workflow) = crate::workflow::find_by_name(pool, &slug).await? {
5873                if workflow.require_reapproval_on_edit
5874                    && crate::workflow::active_state_for_page(pool, id)
5875                        .await?
5876                        .is_none()
5877                    && crate::workflow::has_prior_approval(pool, id).await?
5878                {
5879                    let tasks = crate::workflow::tasks_for(
5880                        pool,
5881                        workflow.id.get().copied().unwrap_or_default(),
5882                    )
5883                    .await?;
5884                    if !tasks.is_empty() {
5885                        crate::workflow::submit_for_review(
5886                            pool, id, &workflow, &tasks, viewer_id,
5887                        )
5888                        .await?;
5889                        reapproval_kicked = true;
5890                    }
5891                }
5892            }
5893        }
5894    }
5895
5896    // Public render cache (rustango::cache_page::CachePageLayer)
5897    // is TTL-based; the new/old/descendant URLs propagate after the
5898    // configured TTL elapses.
5899    let _ = (&new_url_path, slug_changed, &old_url_path, &descendant_urls);
5900    // #553 — this save took the page out of Published: redirect rules
5901    // linked to it must not keep serving (a dead source URL, or a
5902    // destination that now 404s). Best-effort; the save itself stands.
5903    if was_published && page.status != crate::page::PageStatus::Published.as_str() {
5904        match crate::redirect::disable_for_page(
5905            pool,
5906            id,
5907            &format!("Linked page “{}” was unpublished", page.title),
5908        )
5909        .await
5910        {
5911            Ok(0) => {}
5912            Ok(n) => {
5913                tracing::info!(
5914                    page_id = id,
5915                    disabled = n,
5916                    "disabled redirects for unpublished page"
5917                );
5918            }
5919            Err(e) => {
5920                tracing::warn!(page_id = id, error = %e, "failed to disable redirects for unpublished page");
5921            }
5922        }
5923    }
5924
5925    // A save that went through directly (a superuser's) supersedes a
5926    // change held for review; the editor showed it pre-filled.
5927    if actor.is_some() {
5928        crate::pending_change::discard(pool, id).await?;
5929    }
5930
5931    Ok(Ok(PageEditOutcome {
5932        page,
5933        redirects_created,
5934        reapproval_kicked,
5935        held_for_review: false,
5936    }))
5937}
5938
5939pub async fn page_edit_submit(
5940    State(_state): State<super::AdminState>,
5941    tenant: Tenant,
5942    headers: HeaderMap,
5943    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
5944    Path(id): Path<i64>,
5945    Form(form_map): Form<std::collections::HashMap<String, String>>,
5946) -> Result<Response, AdminError> {
5947    let actor = session_user.as_ref().map(|u| PageEditActor {
5948        id: u.id.get().copied().unwrap_or_default(),
5949        username: u.username.clone(),
5950        is_superuser: u.is_superuser,
5951    });
5952    let outcome = apply_page_edit(
5953        tenant.pool(),
5954        &tenant.org.slug,
5955        &_state.cache_invalidator,
5956        _state.mailer.as_deref(),
5957        &_state.mailer_from,
5958        true,
5959        id,
5960        &form_map,
5961        actor.as_ref(),
5962    )
5963    .await?;
5964    let PageEditOutcome {
5965        page,
5966        redirects_created,
5967        reapproval_kicked,
5968        held_for_review,
5969    } = match outcome {
5970        Ok(o) => o,
5971        Err(PageEditRefusal::WorkflowReview { task_name }) => {
5972            return redirect_named_with_params_and_message_args(
5973                "rcms-admin:pages:edit",
5974                &[("id", id.to_string())],
5975                MsgLevel::Error,
5976                "Couldn't save — page is under review on “{name}”. Only reviewers of that step can edit during review.",
5977                &[("name", task_name.as_str())],
5978                &headers,
5979            );
5980        }
5981        Err(PageEditRefusal::LockedBy { holder }) => {
5982            return redirect_named_with_params_and_message_args(
5983                "rcms-admin:pages:edit",
5984                &[("id", id.to_string())],
5985                MsgLevel::Error,
5986                "Couldn't save — “{holder}” is editing this page right now. Force-unlock to take over.",
5987                &[("holder", holder.as_str())],
5988                &headers,
5989            );
5990        }
5991        Err(PageEditRefusal::ArchivedUnpublish) => {
5992            return redirect_named_with_params_and_message_args(
5993                "rcms-admin:pages:edit",
5994                &[("id", id.to_string())],
5995                MsgLevel::Error,
5996                "Can't unpublish an archived page. Set it back to Published to unarchive, or delete it after unarchiving.",
5997                &[],
5998                &headers,
5999            );
6000        }
6001        Err(PageEditRefusal::PublishDenied) => {
6002            return redirect_named_with_params_and_message(
6003                "rcms-admin:pages:edit",
6004                &[("id", id.to_string())],
6005                MsgLevel::Error,
6006                "You don't have permission to publish this page — save it as a draft or submit it for review.",
6007                &headers,
6008            );
6009        }
6010        Err(PageEditRefusal::ReviewRequired { workflow }) => {
6011            return redirect_named_with_params_and_message_args(
6012                "rcms-admin:pages:edit",
6013                &[("id", id.to_string())],
6014                MsgLevel::Error,
6015                "Pages of this type go live after review (“{workflow}”). Save it as a draft and click Submit for review.",
6016                &[("workflow", workflow.as_str())],
6017                &headers,
6018            );
6019        }
6020    };
6021    if held_for_review {
6022        return redirect_after_page_save(
6023            form_map.get("_action").map_or("save", String::as_str),
6024            id,
6025            page.parent_id,
6026            &super::i18n::tr(
6027                &headers,
6028                "Your changes to “{title}” wait for review. Visitors see the live page until they are approved.",
6029                &[("title", page.title.as_str())],
6030            ),
6031            &headers,
6032        );
6033    }
6034    let mut message = if redirects_created > 0 {
6035        let count = redirects_created.to_string();
6036        super::i18n::tr_plural(
6037            &headers,
6038            "Saved “{title}”. Auto-created {count} redirect(s) from the old URL(s).",
6039            redirects_created as i64,
6040            &[("title", page.title.as_str()), ("count", count.as_str())],
6041        )
6042    } else {
6043        super::i18n::tr(
6044            &headers,
6045            "Saved “{title}”.",
6046            &[("title", page.title.as_str())],
6047        )
6048    };
6049    if reapproval_kicked {
6050        message.push(' ');
6051        message.push_str(&super::i18n::tr(
6052            &headers,
6053            "Workflow restarted — page enters review again.",
6054            &[],
6055        ));
6056    }
6057    redirect_after_page_save(
6058        form_map.get("_action").map_or("save", String::as_str),
6059        id,
6060        page.parent_id,
6061        &message,
6062        &headers,
6063    )
6064}
6065
6066/// POST /cms-admin/pages/{id}/translate?locale=<code> — upsert
6067/// `cms_translation` rows for the given locale. Empty values delete
6068/// the matching row so the canonical content shows through.
6069///
6070/// Accepts arbitrary field paths (the three core ones — `title`,
6071/// `seo_title`, `seo_description` — plus any custom `field_path`
6072/// referenced by the page's template, e.g. `intro`, `body`,
6073/// `nav_about`). The form sends them as `tr__<path>` keys; the
6074/// "add new key" row uses `new_field_path` + `new_field_value`.
6075/// Apply one batch of translation overrides for `(page_id, locale_id)`:
6076/// an empty value deletes the override row, a non-empty one upserts it.
6077/// Wrapped in `atomic!` so a mid-loop failure rolls back the whole batch —
6078/// callers never leave half-applied translations behind. Callers are
6079/// responsible for locale validation (in particular: never the default
6080/// locale — canonical content lives on `cms_page`).
6081pub(crate) async fn upsert_page_translations(
6082    pool: &rustango::sql::Pool,
6083    page_id: i64,
6084    locale_id: i64,
6085    updates: Vec<(String, String)>,
6086) -> Result<(), rustango::sql::ExecError> {
6087    rustango::atomic!(pool, |tx| {
6088        let mut guard = tx.lock().await?;
6089        let tx = &mut *guard;
6090        for (path, value) in updates {
6091            if value.is_empty() {
6092                let rows: Vec<crate::translation::Translation> =
6093                    crate::translation::Translation::objects()
6094                        .where_(crate::translation::Translation::page_id.eq(page_id))
6095                        .where_(crate::translation::Translation::locale_id.eq(locale_id))
6096                        .where_(crate::translation::Translation::field_path.eq(path.clone()))
6097                        .fetch_tx(tx)
6098                        .await?;
6099                for row in rows {
6100                    row.delete_tx(tx).await?;
6101                }
6102            } else {
6103                let existing: Vec<crate::translation::Translation> =
6104                    crate::translation::Translation::objects()
6105                        .where_(crate::translation::Translation::page_id.eq(page_id))
6106                        .where_(crate::translation::Translation::locale_id.eq(locale_id))
6107                        .where_(crate::translation::Translation::field_path.eq(path.clone()))
6108                        .fetch_tx(tx)
6109                        .await?;
6110                if let Some(mut row) = existing.into_iter().next() {
6111                    row.value = value;
6112                    row.save_tx(tx).await?;
6113                } else {
6114                    let mut row = crate::translation::Translation {
6115                        id: rustango::sql::Auto::Unset,
6116                        page_id,
6117                        locale_id,
6118                        field_path: path,
6119                        value,
6120                        updated_at: rustango::sql::Auto::Unset,
6121                    };
6122                    row.save_tx(tx).await?;
6123                }
6124            }
6125        }
6126        Ok::<_, rustango::sql::ExecError>(())
6127    })
6128    .await
6129}
6130
6131pub async fn page_translate_submit(
6132    State(_state): State<super::AdminState>,
6133    tenant: Tenant,
6134    Path(id): Path<i64>,
6135    Query(q): Query<EditQuery>,
6136    Form(form): Form<std::collections::HashMap<String, String>>,
6137) -> Result<Response, AdminError> {
6138    let code = q
6139        .locale
6140        .as_deref()
6141        .filter(|c| !c.is_empty())
6142        .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
6143    let locale = Locale::objects()
6144        .where_(Locale::code.eq(code.to_owned()))
6145        .where_(Locale::active.eq(true))
6146        .first(tenant.pool())
6147        .await?
6148        .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
6149    if locale.is_default {
6150        return Ok((
6151            axum::http::StatusCode::BAD_REQUEST,
6152            "cannot translate INTO the default locale; canonical content lives on cms_page",
6153        )
6154            .into_response());
6155    }
6156    let locale_id = locale
6157        .id
6158        .get()
6159        .copied()
6160        .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
6161    // Verify the page exists; cheap one-row select.
6162    let _page = Page::objects()
6163        .where_(Page::id.eq(id))
6164        .first(tenant.pool())
6165        .await?
6166        .ok_or(AdminError::NotFound(id))?;
6167
6168    // Collect updates from the form. Keys starting with `tr__` are
6169    // existing-row edits; `new_field_path` + `new_field_value` is the
6170    // single "add new key" row at the bottom of the editor.
6171    let mut updates: Vec<(String, String)> = Vec::new();
6172    for (k, v) in &form {
6173        if let Some(path) = k.strip_prefix("tr__") {
6174            if path.is_empty() {
6175                continue;
6176            }
6177            updates.push((path.to_owned(), v.clone()));
6178        }
6179    }
6180    let new_path = form
6181        .get("new_field_path")
6182        .map(|s| s.trim().to_owned())
6183        .unwrap_or_default();
6184    if !new_path.is_empty() {
6185        let new_value = form.get("new_field_value").cloned().unwrap_or_default();
6186        // Validate shape via the shared guard (≤255, alphanumeric + `_`
6187        // `.` `-`) — allows dotted block-UUID paths into StreamFields.
6188        if let Ok(path) = crate::translation::validate_field_path(&new_path) {
6189            updates.push((path, new_value));
6190        }
6191    }
6192
6193    upsert_page_translations(tenant.pool(), id, locale_id, updates).await?;
6194
6195    // Invalidate cache for both the canonical and `?lang=` keys so
6196    // the next public hit re-renders with the updated translations.
6197    let page = Page::objects()
6198        .where_(Page::id.eq(id))
6199        .first(tenant.pool())
6200        .await?
6201        .ok_or(AdminError::NotFound(id))?;
6202    // Public render cache (rustango::cache_page::CachePageLayer)
6203    // expires on TTL; translation edits propagate after the
6204    // configured timeout.
6205    let _ = (page, &code);
6206
6207    Ok(Redirect::to(&format!("/cms-admin/pages/{id}/edit?locale={code}")).into_response())
6208}
6209
6210/// POST /cms-admin/pages/{id}/delete — refuse if page has children,
6211/// otherwise delete the row. Cascade-delete-with-children deferred.
6212pub async fn page_delete_submit(
6213    State(_state): State<super::AdminState>,
6214    tenant: Tenant,
6215    headers: HeaderMap,
6216    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6217    Path(id): Path<i64>,
6218) -> Result<Response, AdminError> {
6219    let page = Page::objects()
6220        .where_(Page::id.eq(id))
6221        .first(tenant.pool())
6222        .await?
6223        .ok_or(AdminError::NotFound(id))?;
6224
6225    // #556 — archived pages are frozen against deletion (archive is a
6226    // preservation lock, not a step toward removal). The editor must
6227    // unarchive first.
6228    if page.status == crate::page::PageStatus::Archived.as_str() {
6229        return redirect_named_with_message_args(
6230            "rcms-admin:pages:list",
6231            MsgLevel::Error,
6232            "Can't delete “{title}” while archived — unarchive it first.",
6233            &[("title", page.title.as_str())],
6234            &headers,
6235        );
6236    }
6237
6238    let child_count: Vec<Page> = Page::objects()
6239        .where_(Page::parent_id.eq(id))
6240        .fetch(tenant.pool())
6241        .await?;
6242    if !child_count.is_empty() {
6243        let count = child_count.len().to_string();
6244        return redirect_named_with_message_plural(
6245            "rcms-admin:pages:list",
6246            MsgLevel::Error,
6247            "Can't delete “{title}” — it has {count} child page(s). Delete or move them first.",
6248            child_count.len() as i64,
6249            &[("title", page.title.as_str()), ("count", count.as_str())],
6250            &headers,
6251        );
6252    }
6253
6254    // A hostname pointing at this root has a foreign key to it, so the
6255    // delete would fail with an opaque FK error. Refuse with the names
6256    // instead — and refuse rather than dropping the mapping, because a
6257    // live domain quietly falling back to a different site is a change
6258    // only visitors would notice.
6259    let serving_hosts = crate::site::hosts_for_root(tenant.pool(), id).await?;
6260    if !serving_hosts.is_empty() {
6261        let hosts = serving_hosts.join(", ");
6262        return redirect_named_with_message_args(
6263            "rcms-admin:pages:list",
6264            MsgLevel::Error,
6265            "Can't delete “{title}” — it is the root served by {hosts}. Change that on the Sites screen first.",
6266            &[("title", page.title.as_str()), ("hosts", hosts.as_str())],
6267            &headers,
6268        );
6269    }
6270
6271    // #75 — promote any aliases of this page to standalone pages
6272    // before deleting the source. Each alias inherits a snapshot of
6273    // the source's content (title / SEO / status / theme) so its
6274    // public URL keeps rendering coherent content after the source
6275    // is gone. Without this step the FK guard would refuse the
6276    // delete, or worse — aliases would point at a dead row.
6277    let aliases: Vec<Page> = Page::objects()
6278        .where_(Page::alias_of.eq(id))
6279        .fetch(tenant.pool())
6280        .await?;
6281    let alias_count = aliases.len();
6282    let title = page.title.clone();
6283    let url_path = page.url_path.clone();
6284
6285    // #317 — alias promotion + the delete run in one `atomic!` block,
6286    // so a failure can't leave aliases promoted against a still-present
6287    // source. The #78 cache purge is registered via `on_commit`, so it
6288    // fires only once the delete commits — a rollback never evicts a
6289    // still-valid public render. The purge runs detached, so the next
6290    // visitor sees a 404, not a stale 200, without blocking this
6291    // response on the cache round-trip.
6292    let invalidator = _state.cache_invalidator.clone();
6293    let tenant_slug = tenant.org.slug.clone();
6294    let purge_url = url_path.clone();
6295    rustango::atomic!(tenant.pool(), |tx| {
6296        let mut guard = tx.lock().await?;
6297        let tx = &mut *guard;
6298        for mut alias in aliases {
6299            alias.alias_of = None;
6300            alias.title = page.title.clone();
6301            alias.seo_title = page.seo_title.clone();
6302            alias.seo_description = page.seo_description.clone();
6303            alias.status = page.status.clone();
6304            alias.published_at = page.published_at;
6305            alias.last_published_at = page.last_published_at;
6306            alias.theme_id = page.theme_id;
6307            alias.show_in_menus = page.show_in_menus;
6308            alias.save_tx(tx).await?;
6309        }
6310        // Revisions, tags, logs… point at the page with no ON DELETE
6311        // action; clear them first or the delete fails.
6312        crate::page_delete::clear_page_references_tx(tx, id).await?;
6313        page.delete_tx(tx).await?;
6314        crate::cache_invalidate::invalidate_urls_on_commit(
6315            invalidator,
6316            tenant_slug,
6317            vec![purge_url],
6318        );
6319        Ok(())
6320    })
6321    .await?;
6322    // #408 — drop the deleted page from the external search index
6323    // (no-op when no backend is installed).
6324    crate::task_queue::remove_page_search(&tenant.org.slug, id).await;
6325    // #553 — redirect rules linked to this page must not keep serving.
6326    // Best-effort; the delete already committed.
6327    if let Err(e) = crate::redirect::disable_for_page(
6328        tenant.pool(),
6329        id,
6330        &format!("Linked page “{title}” was deleted"),
6331    )
6332    .await
6333    {
6334        tracing::warn!(page_id = id, error = %e, "failed to disable redirects for deleted page");
6335    }
6336    if alias_count > 0 {
6337        redirect_named_with_message_plural(
6338            "rcms-admin:pages:list",
6339            MsgLevel::Success,
6340            "Deleted “{title}”. Promoted {count} alias(es) to standalone page(s) with the source's last content.",
6341            alias_count as i64,
6342            &[("title", title.as_str()), ("count", &alias_count.to_string())],
6343            &headers,
6344        )
6345    } else {
6346        redirect_named_with_message_args(
6347            "rcms-admin:pages:list",
6348            MsgLevel::Success,
6349            "Deleted “{title}”.",
6350            &[("title", title.as_str())],
6351            &headers,
6352        )
6353    }
6354}
6355
6356// =====================================================================
6357// Slice 6 — drag-reorder + locale variants
6358// =====================================================================
6359
6360/// Form payload for `POST /cms-admin/pages/{id}/move` — emitted by
6361/// the tree view's drag-and-drop JS.
6362#[derive(Debug, Deserialize)]
6363pub struct MoveForm {
6364    /// The drop target's page id. The moved page becomes a child of
6365    /// this row (appended at the bottom of its existing children).
6366    /// Negative or zero values mean "move to root".
6367    pub new_parent: i64,
6368}
6369
6370/// POST /cms-admin/pages/{id}/move — change a page's parent +
6371/// sort_order via the existing `Page::move_to`. Wraps the cascade so
6372/// every descendant's `url_path` is re-materialized.
6373pub async fn page_move_submit(
6374    State(_state): State<super::AdminState>,
6375    tenant: Tenant,
6376    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6377    Path(id): Path<i64>,
6378    Form(form): Form<MoveForm>,
6379) -> Result<Response, AdminError> {
6380    let mut page = Page::objects()
6381        .where_(Page::id.eq(id))
6382        .first(tenant.pool())
6383        .await?
6384        .ok_or(AdminError::NotFound(id))?;
6385    let new_parent: Option<Page> = if form.new_parent > 0 {
6386        Page::objects()
6387            .where_(Page::id.eq(form.new_parent))
6388            .first(tenant.pool())
6389            .await?
6390    } else {
6391        None
6392    };
6393    let old_url_path = page.url_path.clone();
6394    let old_descendant_urls: Vec<String> =
6395        page.descendants(tenant.pool()).await?.into_iter().map(|d| d.url_path).collect();
6396    // One transaction moves the tree and its URLs together (#706).
6397    page.move_to(&tenant, new_parent.as_ref()).await?;
6398    let new_url_path = page.url_path.clone();
6399
6400    // #78 — purge the old and new URL of the page and every descendant,
6401    // now that the move has committed; detached so the response isn't
6402    // blocked on the cache round-trips.
6403    let mut urls = old_descendant_urls;
6404    urls.push(old_url_path.clone());
6405    urls.push(new_url_path.clone());
6406    urls.extend(page.descendants(tenant.pool()).await?.into_iter().map(|d| d.url_path));
6407    let invalidator = _state.cache_invalidator.clone();
6408    let tenant_slug = tenant.org.slug.clone();
6409    rustango::__private_runtime::tokio::spawn(async move {
6410        crate::task_queue::purge_urls(invalidator, tenant_slug, urls).await;
6411    });
6412
6413    // #192 — audit-log the move.
6414    let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6415    crate::page_log::record_or_warn(
6416        tenant.pool(),
6417        id,
6418        crate::page_log::ACTION_MOVE,
6419        actor_id,
6420        format!(
6421            "Moved “{}” from {old_url_path} to {new_url_path}.",
6422            page.title
6423        ),
6424        Some(serde_json::json!({
6425            "old_url_path": old_url_path,
6426            "new_url_path": new_url_path,
6427            "new_parent_id": form.new_parent,
6428        })),
6429    )
6430    .await;
6431
6432    Ok((axum::http::StatusCode::OK, "ok").into_response())
6433}
6434
6435/// POST /cms-admin/pages/{id}/clone — duplicate the source page as a
6436/// draft sibling. The copy carries everything the page stores —
6437/// core fields (SEO, OG/Twitter, theme, template override), tags, the
6438/// extension row, inline panels and the page-builder body — because it
6439/// is saved through the same pipeline as an edit, from the source's
6440/// [`crate::page_form::prefill`]. The new row:
6441///
6442/// - Lives under the same parent as the source.
6443/// - Title gets a " (copy)" suffix.
6444/// - Slug gets a "-copy" suffix; on conflict with an existing
6445///   sibling slug, we suffix `-copy-2`, `-copy-3`, … until unique.
6446/// - Status forces back to Draft, with no schedule, so editors review
6447///   before publishing.
6448/// - Locale-variant pointer cleared (variants stay independent of
6449///   any single source).
6450///
6451/// Subtree clone (source + all descendants) is not supported yet.
6452pub async fn page_clone_submit(
6453    State(state): State<super::AdminState>,
6454    tenant: Tenant,
6455    headers: HeaderMap,
6456    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6457    Path(id): Path<i64>,
6458) -> Result<Response, AdminError> {
6459    let source = Page::objects()
6460        .where_(Page::id.eq(id))
6461        .first(tenant.pool())
6462        .await?
6463        .ok_or(AdminError::NotFound(id))?;
6464
6465    let title = format!("{} (copy)", source.title);
6466    let base_slug = source.slug.trim_matches('-').to_owned();
6467    let slug = unique_sibling_slug(
6468        tenant.pool(),
6469        source.parent_id,
6470        &format!("{base_slug}-copy"),
6471    )
6472    .await?;
6473
6474    let new = crate::tree_ops::NewPage::new(source.page_type_id, title, slug)
6475        .with_status(crate::page::PageStatus::Draft)
6476        .with_seo(source.seo_title.clone(), source.seo_description.clone());
6477
6478    let clone = match source.parent_id {
6479        Some(pid) => {
6480            let parent = Page::objects()
6481                .where_(Page::id.eq(pid))
6482                .first(tenant.pool())
6483                .await?
6484                .ok_or(AdminError::NotFound(pid))?;
6485            Page::create_child(&tenant, &parent, new).await?
6486        }
6487        None => Page::create_root(&tenant, new).await?,
6488    };
6489    let new_id = clone.id.get().copied().unwrap_or_default();
6490
6491    // Copy the content by saving the source's full form onto the new
6492    // row: the edit pipeline writes the core fields, tags, extension,
6493    // inline panels and builder body, and captures the first revision
6494    // with all of it.
6495    let mut form = crate::page_form::prefill(tenant.pool(), &source).await;
6496    form.insert("title".into(), clone.title.clone());
6497    form.insert("slug".into(), clone.slug.clone());
6498    form.insert(
6499        "status".into(),
6500        crate::page::PageStatus::Draft.as_str().to_owned(),
6501    );
6502    form.remove("go_live_at");
6503    form.remove("expire_at");
6504    let actor = session_user.as_ref().map(|u| PageEditActor {
6505        id: u.id.get().copied().unwrap_or_default(),
6506        username: u.username.clone(),
6507        is_superuser: u.is_superuser,
6508    });
6509    let saved = apply_page_edit(
6510        tenant.pool(),
6511        &tenant.org.slug,
6512        &state.cache_invalidator,
6513        None,
6514        "",
6515        false,
6516        new_id,
6517        &form,
6518        actor.as_ref(),
6519    )
6520    .await?;
6521    if saved.is_err() {
6522        // A page created a moment ago has no workflow or editor lock.
6523        return Err(AdminError::Validation(
6524            "the copy was created but its content could not be saved".to_owned(),
6525        ));
6526    }
6527    // #192 — audit-log the clone on BOTH the new row (so the new
6528    // page's history shows where it came from) and the source (so
6529    // the source's history records its descendants).
6530    let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6531    crate::page_log::record_or_warn(
6532        tenant.pool(),
6533        new_id,
6534        crate::page_log::ACTION_COPY,
6535        actor_id,
6536        format!("Cloned from “{}” (page #{id}).", source.title),
6537        Some(serde_json::json!({ "source_page_id": id })),
6538    )
6539    .await;
6540    crate::page_log::record_or_warn(
6541        tenant.pool(),
6542        id,
6543        crate::page_log::ACTION_COPY,
6544        actor_id,
6545        format!("Cloned to new draft page #{new_id}."),
6546        Some(serde_json::json!({ "clone_page_id": new_id })),
6547    )
6548    .await;
6549    redirect_named_with_params_and_message_args(
6550        "rcms-admin:pages:edit",
6551        &[("id", new_id.to_string())],
6552        MsgLevel::Success,
6553        "Cloned “{title}” as a draft. Review before publishing.",
6554        &[("title", source.title.as_str())],
6555        &headers,
6556    )
6557}
6558
6559/// Form payload for `POST /cms-admin/pages/{id}/privacy`.
6560/// `kind` is one of `"none"`, `"login"`, `"groups"`, `"password"`.
6561/// `password` is the cleartext entered when `kind=password` (hashed
6562/// + discarded server-side). `group_ids` is the comma-separated list
6563/// for `kind=groups`.
6564#[derive(Deserialize)]
6565pub struct PrivacyForm {
6566    pub kind: String,
6567    #[serde(default)]
6568    pub password: String,
6569    #[serde(default)]
6570    pub group_ids: String,
6571    /// Comma-separated permission codenames — used when `kind =
6572    /// permission` (the permission-engine gate). Empty otherwise.
6573    #[serde(default)]
6574    pub codenames: String,
6575}
6576
6577pub async fn page_privacy_submit(
6578    State(_state): State<super::AdminState>,
6579    tenant: Tenant,
6580    headers: HeaderMap,
6581    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6582    Path(id): Path<i64>,
6583    Form(form): Form<PrivacyForm>,
6584) -> Result<Response, AdminError> {
6585    use rustango::sql::Auto;
6586    let existing = crate::view_restriction::direct_for_page(tenant.pool(), id).await?;
6587    if form.kind == "none" {
6588        if let Some(row) = existing {
6589            row.delete_pool(tenant.pool()).await?;
6590            return redirect_named_with_params_and_message(
6591                "rcms-admin:pages:edit",
6592                &[("id", id.to_string())],
6593                MsgLevel::Success,
6594                "Removed view restriction — page is now public.",
6595                &headers,
6596            );
6597        }
6598        return redirect_named_with_params_and_message(
6599            "rcms-admin:pages:edit",
6600            &[("id", id.to_string())],
6601            MsgLevel::Info,
6602            "No restriction to remove.",
6603            &headers,
6604        );
6605    }
6606    let Some(kind) = crate::view_restriction::RestrictionKind::parse(&form.kind) else {
6607        return Err(AdminError::Validation(format!(
6608            "unknown restriction kind `{}`",
6609            form.kind
6610        )));
6611    };
6612    let password_hash = match kind {
6613        crate::view_restriction::RestrictionKind::Password => {
6614            // Reuse the existing hash when the editor left the
6615            // field blank on a page that's already password-
6616            // protected — lets them flip groups/login back to
6617            // password without remembering the original.
6618            if form.password.is_empty() {
6619                if let Some(row) = &existing {
6620                    if row.kind == kind.as_str() {
6621                        row.password_hash.clone()
6622                    } else {
6623                        return redirect_named_with_params_and_message(
6624                            "rcms-admin:pages:edit",
6625                            &[("id", id.to_string())],
6626                            MsgLevel::Error,
6627                            "Password is required when switching the restriction kind to password.",
6628                            &headers,
6629                        );
6630                    }
6631                } else {
6632                    return redirect_named_with_params_and_message(
6633                        "rcms-admin:pages:edit",
6634                        &[("id", id.to_string())],
6635                        MsgLevel::Error,
6636                        "Password is required for password-protected pages.",
6637                        &headers,
6638                    );
6639                }
6640            } else {
6641                crate::passwords::hash(&form.password).await
6642                    .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?
6643            }
6644        }
6645        _ => String::new(),
6646    };
6647    let group_ids: Vec<i64> = if matches!(kind, crate::view_restriction::RestrictionKind::Groups) {
6648        form.group_ids
6649            .split(',')
6650            .filter_map(|s| s.trim().parse::<i64>().ok())
6651            .collect()
6652    } else {
6653        Vec::new()
6654    };
6655    let group_json = serde_json::json!(group_ids);
6656    let codenames: Vec<String> =
6657        if matches!(kind, crate::view_restriction::RestrictionKind::Permission) {
6658            form.codenames
6659                .split(',')
6660                .map(str::trim)
6661                .filter(|s| !s.is_empty())
6662                .map(str::to_owned)
6663                .collect()
6664        } else {
6665            Vec::new()
6666        };
6667    let codenames_json = serde_json::json!(codenames);
6668    match existing {
6669        Some(mut row) => {
6670            row.kind = kind.as_str().to_owned();
6671            row.password_hash = password_hash;
6672            row.group_ids = group_json;
6673            row.codenames = codenames_json;
6674            row.save_pool(tenant.pool()).await?;
6675        }
6676        None => {
6677            let mut row = crate::view_restriction::PageViewRestriction {
6678                id: Auto::Unset,
6679                page_id: id,
6680                kind: kind.as_str().to_owned(),
6681                password_hash,
6682                group_ids: group_json,
6683                codenames: codenames_json,
6684                created_at: Auto::Unset,
6685                updated_at: Auto::Unset,
6686            };
6687            row.insert_pool(tenant.pool()).await?;
6688        }
6689    }
6690    redirect_named_with_params_and_message_args(
6691        "rcms-admin:pages:edit",
6692        &[("id", id.to_string())],
6693        MsgLevel::Success,
6694        match kind {
6695            crate::view_restriction::RestrictionKind::Login => "Only signed-in people can see this page now.",
6696            crate::view_restriction::RestrictionKind::Groups => "Only the chosen roles can see this page now.",
6697            crate::view_restriction::RestrictionKind::Permission => "Only people with the chosen permissions can see this page now.",
6698            crate::view_restriction::RestrictionKind::Password => "This page asks for a password now.",
6699        },
6700        &[],
6701        &headers,
6702    )
6703}
6704
6705// =====================================================================
6706// Inline comments (#81 PR 1)
6707// =====================================================================
6708
6709#[derive(Debug, Deserialize)]
6710pub struct CommentNewForm {
6711    pub field_path: String,
6712    pub body: String,
6713}
6714
6715pub async fn comment_new_submit(
6716    State(_state): State<super::AdminState>,
6717    tenant: Tenant,
6718    headers: HeaderMap,
6719    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6720    Path(id): Path<i64>,
6721    Form(form): Form<CommentNewForm>,
6722) -> Result<Response, AdminError> {
6723    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6724        return Ok(unauthorized_no_session());
6725    };
6726    let body = form.body.trim();
6727    let field_path = form.field_path.trim();
6728    if body.is_empty() || field_path.is_empty() {
6729        return redirect_named_with_params_and_message(
6730            "rcms-admin:pages:edit",
6731            &[("id", id.to_string())],
6732            MsgLevel::Warning,
6733            "Comment body and field are both required.",
6734            &headers,
6735        );
6736    }
6737    let mut row = crate::comment::Comment {
6738        id: rustango::sql::Auto::Unset,
6739        page_id: id,
6740        field_path: field_path.to_owned(),
6741        author_id: viewer_id,
6742        body: body.to_owned(),
6743        resolved_at: None,
6744        resolved_by: None,
6745        created_at: rustango::sql::Auto::Unset,
6746    };
6747    row.insert_pool(tenant.pool()).await?;
6748    redirect_named_with_params_and_message(
6749        "rcms-admin:pages:edit",
6750        &[("id", id.to_string())],
6751        MsgLevel::Success,
6752        "Comment posted.",
6753        &headers,
6754    )
6755}
6756
6757#[derive(Debug, Deserialize)]
6758pub struct CommentReplyForm {
6759    pub body: String,
6760}
6761
6762pub async fn comment_reply_submit(
6763    State(_state): State<super::AdminState>,
6764    tenant: Tenant,
6765    headers: HeaderMap,
6766    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6767    Path((id, comment_id)): Path<(i64, i64)>,
6768    Form(form): Form<CommentReplyForm>,
6769) -> Result<Response, AdminError> {
6770    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6771        return Ok(unauthorized_no_session());
6772    };
6773    let body = form.body.trim();
6774    if body.is_empty() {
6775        return redirect_named_with_params_and_message(
6776            "rcms-admin:pages:edit",
6777            &[("id", id.to_string())],
6778            MsgLevel::Warning,
6779            "Reply body is required.",
6780            &headers,
6781        );
6782    }
6783    let mut row = crate::comment::CommentReply {
6784        id: rustango::sql::Auto::Unset,
6785        comment_id,
6786        author_id: viewer_id,
6787        body: body.to_owned(),
6788        created_at: rustango::sql::Auto::Unset,
6789    };
6790    row.insert_pool(tenant.pool()).await?;
6791    redirect_named_with_params_and_message(
6792        "rcms-admin:pages:edit",
6793        &[("id", id.to_string())],
6794        MsgLevel::Success,
6795        "Reply posted.",
6796        &headers,
6797    )
6798}
6799
6800pub async fn comment_resolve_submit(
6801    State(_state): State<super::AdminState>,
6802    tenant: Tenant,
6803    headers: HeaderMap,
6804    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6805    Path((id, comment_id)): Path<(i64, i64)>,
6806) -> Result<Response, AdminError> {
6807    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
6808        return Ok(unauthorized_no_session());
6809    };
6810    let mut row = crate::comment::Comment::objects()
6811        .where_(crate::comment::Comment::id.eq(comment_id))
6812        .where_(crate::comment::Comment::page_id.eq(id))
6813        .first(tenant.pool())
6814        .await?
6815        .ok_or(AdminError::NotFound(comment_id))?;
6816    row.resolved_at = Some(chrono::Utc::now());
6817    row.resolved_by = Some(viewer_id);
6818    row.save_pool(tenant.pool()).await?;
6819    redirect_named_with_params_and_message(
6820        "rcms-admin:pages:edit",
6821        &[("id", id.to_string())],
6822        MsgLevel::Success,
6823        "Comment resolved.",
6824        &headers,
6825    )
6826}
6827
6828pub async fn comment_reopen_submit(
6829    State(_state): State<super::AdminState>,
6830    tenant: Tenant,
6831    headers: HeaderMap,
6832    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
6833    Path((id, comment_id)): Path<(i64, i64)>,
6834) -> Result<Response, AdminError> {
6835    let mut row = crate::comment::Comment::objects()
6836        .where_(crate::comment::Comment::id.eq(comment_id))
6837        .where_(crate::comment::Comment::page_id.eq(id))
6838        .first(tenant.pool())
6839        .await?
6840        .ok_or(AdminError::NotFound(comment_id))?;
6841    row.resolved_at = None;
6842    row.resolved_by = None;
6843    row.save_pool(tenant.pool()).await?;
6844    redirect_named_with_params_and_message(
6845        "rcms-admin:pages:edit",
6846        &[("id", id.to_string())],
6847        MsgLevel::Info,
6848        "Comment reopened.",
6849        &headers,
6850    )
6851}
6852
6853/// POST /cms-admin/pages/{id}/alias — create a live alias of this
6854/// page as a sibling. The alias is a real tree row at a
6855/// distinct URL but its content fields proxy to the source. Edits
6856/// to the source propagate instantly; edits to the alias redirect
6857/// the editor to the source.
6858///
6859/// Differentiation from sibling actions:
6860///   * Clone (`/clone`)         — deep copy, divergent content
6861///   * Alias (this)             — one source, multiple URLs
6862///
6863/// Localization uses the `cms_translation` per-field override table
6864/// (see [`crate::translation`]); the legacy structural-variant flow
6865/// was removed.
6866pub async fn page_alias_submit(
6867    State(state): State<super::AdminState>,
6868    tenant: Tenant,
6869    headers: HeaderMap,
6870    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
6871    Path(id): Path<i64>,
6872) -> Result<Response, AdminError> {
6873    let source = Page::objects()
6874        .where_(Page::id.eq(id))
6875        .first(tenant.pool())
6876        .await?
6877        .ok_or(AdminError::NotFound(id))?;
6878
6879    // Refuse to alias an alias — the chain would be impossible to
6880    // resolve without cycle detection, and there's no editorial use
6881    // case for it. Authors should alias the underlying source.
6882    if let Some(src_id) = source.alias_of {
6883        let src_id_str = src_id.to_string();
6884        return redirect_named_with_params_and_message_args(
6885            "rcms-admin:pages:edit",
6886            &[("id", id.to_string())],
6887            MsgLevel::Error,
6888            "Can't alias an alias — point your new alias at the underlying source page (#{source_id}) instead.",
6889            &[("source_id", src_id_str.as_str())],
6890            &headers,
6891        );
6892    }
6893
6894    let base_slug = source.slug.trim_matches('-').to_owned();
6895    let slug = unique_sibling_slug(
6896        tenant.pool(),
6897        source.parent_id,
6898        &if base_slug.is_empty() {
6899            "alias".to_owned()
6900        } else {
6901            format!("{base_slug}-alias")
6902        },
6903    )
6904    .await?;
6905
6906    // tree_ops::NewPage carries title/slug/page_type but the title
6907    // gets shadowed by the source on render. Use the source's title
6908    // verbatim so the admin lists still show something meaningful.
6909    let new = crate::tree_ops::NewPage::new(source.page_type_id, source.title.clone(), slug)
6910        .with_status(crate::page::PageStatus::Draft)
6911        .with_seo(source.seo_title.clone(), source.seo_description.clone());
6912
6913    let mut alias = match source.parent_id {
6914        Some(pid) => {
6915            let parent = Page::objects()
6916                .where_(Page::id.eq(pid))
6917                .first(tenant.pool())
6918                .await?
6919                .ok_or(AdminError::NotFound(pid))?;
6920            Page::create_child(&tenant, &parent, new).await?
6921        }
6922        None => Page::create_root(&tenant, new).await?,
6923    };
6924    alias.alias_of = Some(id);
6925    // Aliases inherit publish status from the source on render —
6926    // the underlying status column on the alias row is irrelevant
6927    // for live viewing, but setting it here keeps the admin list
6928    // visually accurate.
6929    alias.status = source.status.clone();
6930    alias.published_at = source.published_at;
6931    alias.last_published_at = source.last_published_at;
6932    alias.theme_id = source.theme_id;
6933    alias.show_in_menus = source.show_in_menus;
6934    alias.save_pool(tenant.pool()).await?;
6935
6936    crate::revision::capture(tenant.pool(), &alias, None)
6937        .await
6938        .log_warn("revision not captured; the history has a gap");
6939    let new_id = alias.id.get().copied().unwrap_or_default();
6940    let _ = state;
6941    // #192 — audit log on both source + alias.
6942    let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
6943    crate::page_log::record_or_warn(
6944        tenant.pool(),
6945        new_id,
6946        crate::page_log::ACTION_ALIAS_CREATE,
6947        actor_id,
6948        format!("Alias of “{}” (page #{id}).", source.title),
6949        Some(serde_json::json!({ "alias_of": id })),
6950    )
6951    .await;
6952    crate::page_log::record_or_warn(
6953        tenant.pool(),
6954        id,
6955        crate::page_log::ACTION_ALIAS_CREATE,
6956        actor_id,
6957        format!("New alias #{new_id} pointing here."),
6958        Some(serde_json::json!({ "alias_page_id": new_id })),
6959    )
6960    .await;
6961    redirect_named_with_params_and_message_args(
6962        "rcms-admin:pages:list",
6963        // Land on the page list (alias's edit form proxies to the
6964        // source, so /edit just bounces; the list is the right
6965        // landing). Include the alias's parent if available so the
6966        // editor sees the new alias in context.
6967        &[],
6968        MsgLevel::Success,
6969        "Created alias of “{title}”. Edits to the source will propagate to every alias's URL.",
6970        &[("title", source.title.as_str())],
6971        &headers,
6972    )
6973}
6974
6975/// Canonical fields seeded into `cms_translation` by the
6976/// copy-to-locale bulk action: the page's `title`, `seo_title`, and
6977/// `seo_description`, skipping empties. The source text gives
6978/// translators a starting point.
6979fn copy_fields_for(p: &Page) -> Vec<(&'static str, String)> {
6980    copy_translatable_fields(&p.title, &p.seo_title, &p.seo_description)
6981}
6982
6983/// Pure core of [`copy_fields_for`] — selects the non-empty canonical
6984/// fields. Split out so the selection is unit-testable without a full
6985/// `Page`.
6986fn copy_translatable_fields(
6987    title: &str,
6988    seo_title: &str,
6989    seo_description: &str,
6990) -> Vec<(&'static str, String)> {
6991    [
6992        ("title", title),
6993        ("seo_title", seo_title),
6994        ("seo_description", seo_description),
6995    ]
6996    .into_iter()
6997    .filter(|(_, v)| !v.trim().is_empty())
6998    .map(|(k, v)| (k, v.to_owned()))
6999    .collect()
7000}
7001
7002/// POST /cms-admin/pages/bulk — multi-select dispatcher for the
7003/// page list. Body shape (urlencoded):
7004/// `action=<verb>&ids=<id>&ids=<id>[&new_parent=<id>]`.
7005///
7006/// Verbs:
7007///   - `publish`     → flips every selected page's `status` to
7008///                     Published (no-op for already-published rows).
7009///   - `unpublish`   → flips to Draft (no-op for already-draft rows).
7010///   - `delete`      → bulk delete. Rejects atomically if ANY selected
7011///                     page has children — matches the per-row guard.
7012///   - `move`        → reparent every selected page under `new_parent`
7013///                     (or to root when `new_parent=0`); cascades
7014///                     `url_path` to descendants. Filters out rows
7015///                     that would form a self-loop (you can't move a
7016///                     page under itself or one of its descendants).
7017///
7018/// All four are wrapped in a single transaction so a partial failure
7019/// rolls back the entire batch. The response is a redirect back to
7020/// the page list with a flash message summarizing how many rows were
7021/// touched + which were skipped (with reason).
7022pub async fn page_bulk_submit(
7023    State(_state): State<super::AdminState>,
7024    tenant: Tenant,
7025    headers: HeaderMap,
7026    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7027    Form(form): Form<Vec<(String, String)>>,
7028) -> Result<Response, AdminError> {
7029    let action = form
7030        .iter()
7031        .find(|(k, _)| k == "action")
7032        .map(|(_, v)| v.clone())
7033        .unwrap_or_default();
7034    let ids: Vec<i64> = form
7035        .iter()
7036        .filter(|(k, _)| k == "ids" || k == "id")
7037        .filter_map(|(_, v)| v.parse::<i64>().ok())
7038        .collect();
7039    let new_parent_raw = form
7040        .iter()
7041        .find(|(k, _)| k == "new_parent")
7042        .and_then(|(_, v)| v.parse::<i64>().ok());
7043    // #556 — archive cascade: mark every descendant's own row, not just
7044    // rely on inheritance. Accepts the checkbox/select truthy forms.
7045    let archive_cascade = form.iter().any(|(k, v)| {
7046        k == "archive_cascade" && matches!(v.as_str(), "1" | "on" | "subtree" | "true")
7047    });
7048
7049    if action.is_empty() || ids.is_empty() {
7050        return redirect_named_with_message(
7051            "rcms-admin:pages:list",
7052            MsgLevel::Warning,
7053            "Pick at least one row + an action before submitting.",
7054            &headers,
7055        );
7056    }
7057
7058    // Load the selected rows in one shot so per-id validation can run
7059    // before any mutation. The IN-list is small (page list pagination
7060    // caps the visible set; even an unbounded multi-select is dwarfed
7061    // by site-wide page counts).
7062    let pool = tenant.pool();
7063    let pages: Vec<Page> = {
7064        let mut out = Vec::with_capacity(ids.len());
7065        for id in &ids {
7066            if let Some(p) = Page::objects().where_(Page::id.eq(*id)).first(pool).await? {
7067                out.push(p);
7068            }
7069        }
7070        out
7071    };
7072    if pages.is_empty() {
7073        return redirect_named_with_message(
7074            "rcms-admin:pages:list",
7075            MsgLevel::Warning,
7076            "None of the selected ids matched a live page.",
7077            &headers,
7078        );
7079    }
7080
7081    // #672 — the route gate only knows this is a page edit; the action
7082    // posted decides what it really needs, on every selected page.
7083    let needs = match action.as_str() {
7084        "publish" | "unpublish" => crate::permissions::Action::Publish,
7085        "delete" => crate::permissions::Action::Delete,
7086        _ => crate::permissions::Action::Edit,
7087    };
7088    if let Some(user) = session_user.as_ref() {
7089        for p in &pages {
7090            let req = super::route_perms::Requirement {
7091                codename: format!("cms_page.{}", needs.as_str()),
7092                page: p.id.get().copied().map(|id| (id, needs)),
7093            };
7094            if !super::route_perms::allows(pool, user, &req).await {
7095                return redirect_named_with_message_args(
7096                    "rcms-admin:pages:list",
7097                    MsgLevel::Error,
7098                    "You don't have permission to {action} “{title}”.",
7099                    &[("action", action.as_str()), ("title", p.title.as_str())],
7100                    &headers,
7101                );
7102            }
7103        }
7104    }
7105
7106    match action.as_str() {
7107        "publish" | "unpublish" => {
7108            let target = if action == "publish" {
7109                crate::page::PageStatus::Published
7110            } else {
7111                crate::page::PageStatus::Draft
7112            };
7113            let invalidator = _state.cache_invalidator.clone();
7114            let tenant_slug = tenant.org.slug.clone();
7115            let purge_urls: Vec<String> = pages.iter().map(|p| p.url_path.clone()).collect();
7116            let pages_for_tx = pages.clone();
7117            // #317 — flip the batch's status in one atomic! block and
7118            // register the #78 per-URL purge via on_commit, so it fires
7119            // only once the batch commits (detached; dropped on rollback).
7120            let touched = rustango::atomic!(pool, |tx| {
7121                let mut guard = tx.lock().await?;
7122                let tx = &mut *guard;
7123                let mut touched = 0usize;
7124                for mut p in pages_for_tx {
7125                    // #556 — archived pages are frozen against unpublish;
7126                    // they must be explicitly unarchived. Skip them in a
7127                    // bulk unpublish (bulk publish still revives them).
7128                    if matches!(target, crate::page::PageStatus::Draft)
7129                        && p.status == crate::page::PageStatus::Archived.as_str()
7130                    {
7131                        continue;
7132                    }
7133                    if p.status != target.as_str() {
7134                        p.status = target.as_str().to_owned();
7135                        if matches!(target, crate::page::PageStatus::Published) {
7136                            let now = chrono::Utc::now();
7137                            if p.published_at.is_none() {
7138                                p.published_at = Some(now);
7139                            }
7140                            // #251 — bulk publish also bumps last-publish.
7141                            p.last_published_at = Some(now);
7142                        }
7143                        p.save_tx(tx).await?;
7144                        touched += 1;
7145                    }
7146                }
7147                crate::cache_invalidate::invalidate_urls_on_commit(
7148                    invalidator,
7149                    tenant_slug,
7150                    purge_urls,
7151                );
7152                Ok::<usize, rustango::sql::ExecError>(touched)
7153            })
7154            .await?;
7155            // Capture revisions outside the transaction; failure here
7156            // only affects history bookkeeping.
7157            for p in &pages {
7158                crate::revision::capture(pool, p, None)
7159                    .await
7160                    .log_warn("revision not captured; the history has a gap");
7161            }
7162            // #553 — bulk unpublish: rules linked to pages leaving
7163            // Published must not keep serving. `pages` holds the
7164            // pre-flip rows, so filter on the OLD status.
7165            if !matches!(target, crate::page::PageStatus::Published) {
7166                for p in &pages {
7167                    if p.status != crate::page::PageStatus::Published.as_str() {
7168                        continue;
7169                    }
7170                    let pid = p.id.get().copied().unwrap_or_default();
7171                    if let Err(e) = crate::redirect::disable_for_page(
7172                        pool,
7173                        pid,
7174                        &format!("Linked page “{}” was unpublished", p.title),
7175                    )
7176                    .await
7177                    {
7178                        tracing::warn!(page_id = pid, error = %e, "failed to disable redirects for unpublished page");
7179                    }
7180                }
7181            }
7182            // #107 — plugin after_publish_page on bulk publish only.
7183            if matches!(target, crate::page::PageStatus::Published) {
7184                for p in &pages {
7185                    crate::hooks::fire_after_publish_page(p);
7186                }
7187                // #115 — notify-on-publish subscribers (per page).
7188                let actor = session_user.as_ref().map(|u| u.username.as_str());
7189                for p in &pages {
7190                    crate::page_subscription::notify_publish(
7191                        _state.mailer.as_deref(),
7192                        &_state.mailer_from,
7193                        pool,
7194                        &tenant.org.slug,
7195                        p.id.get().copied().unwrap_or_default(),
7196                        &p.title,
7197                        &p.url_path,
7198                        actor,
7199                    )
7200                    .await;
7201                }
7202            }
7203            let already = (pages.len() - touched).to_string();
7204            let key = if action == "publish" {
7205                "Published {count} page(s) ({already} already in the target state)."
7206            } else {
7207                "Unpublished {count} page(s) ({already} already in the target state)."
7208            };
7209            redirect_named_with_message_plural(
7210                "rcms-admin:pages:list",
7211                MsgLevel::Success,
7212                key,
7213                touched as i64,
7214                &[("count", &touched.to_string()), ("already", already.as_str())],
7215                &headers,
7216            )
7217        }
7218        "delete" => {
7219            // #556 — archived pages are a preservation lock: they can't
7220            // be deleted until explicitly unarchived. Reject the whole
7221            // batch if any selected page is archived (mirrors the child
7222            // guard's all-or-nothing rule).
7223            let archived_names: Vec<String> = pages
7224                .iter()
7225                .filter(|p| p.status == crate::page::PageStatus::Archived.as_str())
7226                .map(|p| format!("“{}”", p.title))
7227                .collect();
7228            if !archived_names.is_empty() {
7229                let list = archived_names.join(", ");
7230                return redirect_named_with_message_args(
7231                    "rcms-admin:pages:list",
7232                    MsgLevel::Error,
7233                    "Can't delete archived page(s) {names} — unarchive them first.",
7234                    &[("names", list.as_str())],
7235                    &headers,
7236                );
7237            }
7238            // Atomic guard: if ANY selected page has children, the
7239            // whole batch fails. Matches the per-row delete rule and
7240            // the acceptance criterion on the issue.
7241            let id_set: std::collections::HashSet<i64> =
7242                pages.iter().filter_map(|p| p.id.get().copied()).collect();
7243            let mut offenders: Vec<String> = Vec::new();
7244            for p in &pages {
7245                let pid = p.id.get().copied().unwrap_or_default();
7246                let children: Vec<Page> = Page::objects()
7247                    .where_(Page::parent_id.eq(pid))
7248                    .fetch(pool)
7249                    .await?;
7250                // Children that are themselves part of this batch
7251                // don't count as blockers — they'll be deleted in
7252                // the same transaction.
7253                let external_children = children
7254                    .iter()
7255                    .filter(|c| !id_set.contains(&c.id.get().copied().unwrap_or_default()))
7256                    .count();
7257                if external_children > 0 {
7258                    offenders.push(format!("#{pid} “{}” ({external_children})", p.title));
7259                }
7260            }
7261            if !offenders.is_empty() {
7262                let offenders_list = offenders.join(", ");
7263                return redirect_named_with_message_args(
7264                    "rcms-admin:pages:list",
7265                    MsgLevel::Error,
7266                    "Bulk delete blocked — these page(s) still have external children: {offenders}.",
7267                    &[("offenders", offenders_list.as_str())],
7268                    &headers,
7269                );
7270            }
7271            // Delete deepest-first so child rows go before parents
7272            // and FK guards stay green. Every row that points at a page
7273            // (revisions, tags, logs, host extension rows…) is cleared
7274            // first: those FKs have no ON DELETE action.
7275            let mut ordered = pages.clone();
7276            ordered.sort_by(|a, b| b.depth.cmp(&a.depth));
7277            let invalidator = _state.cache_invalidator.clone();
7278            let tenant_slug = tenant.org.slug.clone();
7279            // #78 — purge every deleted URL so the next visitor sees a
7280            // 404, not a stale 200. #317 — registered via on_commit so
7281            // it fires only once the whole batch delete commits.
7282            let purge_urls: Vec<String> = pages.iter().map(|p| p.url_path.clone()).collect();
7283            rustango::atomic!(pool, |tx| {
7284                let mut guard = tx.lock().await?;
7285                let tx = &mut *guard;
7286                for p in &ordered {
7287                    let pid = p.id.get().copied().unwrap_or_default();
7288                    crate::page_delete::clear_page_references_tx(tx, pid).await?;
7289                }
7290                for p in ordered {
7291                    p.delete_tx(tx).await?;
7292                }
7293                crate::cache_invalidate::invalidate_urls_on_commit(
7294                    invalidator,
7295                    tenant_slug,
7296                    purge_urls,
7297                );
7298                Ok::<(), rustango::sql::ExecError>(())
7299            })
7300            .await?;
7301            // #553 — disable redirect rules linked to any deleted page.
7302            for p in &pages {
7303                let pid = p.id.get().copied().unwrap_or_default();
7304                if let Err(e) = crate::redirect::disable_for_page(
7305                    pool,
7306                    pid,
7307                    &format!("Linked page “{}” was deleted", p.title),
7308                )
7309                .await
7310                {
7311                    tracing::warn!(page_id = pid, error = %e, "failed to disable redirects for deleted page");
7312                }
7313            }
7314            redirect_named_with_message_plural(
7315                "rcms-admin:pages:list",
7316                MsgLevel::Success,
7317                "Deleted {count} page(s).",
7318                pages.len() as i64,
7319                &[("count", &pages.len().to_string())],
7320                &headers,
7321            )
7322        }
7323        "move" => {
7324            let Some(new_parent_id) = new_parent_raw else {
7325                return redirect_named_with_message(
7326                    "rcms-admin:pages:list",
7327                    MsgLevel::Warning,
7328                    "Bulk move requires a destination — pick a parent page.",
7329                    &headers,
7330                );
7331            };
7332            let new_parent: Option<Page> = if new_parent_id > 0 {
7333                Page::objects()
7334                    .where_(Page::id.eq(new_parent_id))
7335                    .first(pool).await?
7336            } else {
7337                None
7338            };
7339            // Self-loop guard: can't move a page under itself or any
7340            // of its descendants. Path-prefix check is cheap.
7341            if let Some(np) = &new_parent {
7342                for p in &pages {
7343                    if np.path.starts_with(&p.path) {
7344                        return redirect_named_with_message_args(
7345                            "rcms-admin:pages:list",
7346                            MsgLevel::Error,
7347                            "Can't move “{title}” under “{parent}” — destination is itself or a descendant.",
7348                            &[("title", p.title.as_str()), ("parent", np.title.as_str())],
7349                            &headers,
7350                        );
7351                    }
7352                }
7353            }
7354
7355            // Pre-validate page-type placement for every selected row
7356            // before mutating anything. If a single page rejects the
7357            // destination, the whole batch fails — matches the issue's
7358            // atomicity requirement so editors never end up with a
7359            // partial reparent.
7360            if let Some(np) = &new_parent {
7361                for p in &pages {
7362                    if let Err(e) =
7363                        crate::tree_ops::validate_child_placement(pool, np.page_type_id, p.page_type_id)
7364                            .await
7365                    {
7366                        let err = e.to_string();
7367                        return redirect_named_with_message_args(
7368                            "rcms-admin:pages:list",
7369                            MsgLevel::Error,
7370                            "Move blocked — “{title}” can't live under “{parent}”: {error}",
7371                            &[("title", p.title.as_str()), ("parent", np.title.as_str()), ("error", err.as_str())],
7372                            &headers,
7373                        );
7374                    }
7375                }
7376            }
7377
7378            // F2 / #317 — reparent the whole batch in ONE atomic_tree so a
7379            // mid-batch failure rolls back every move (no partial reparent;
7380            // placement was already pre-validated above). Each page's
7381            // subtree is pre-read on the pool *before* the transaction, so
7382            // nothing inside the tx reads the pool (which would deadlock a
7383            // single-connection SQLite pool); `move_to_in_tx` then reparents
7384            // each page within the shared tx. The #78 purge of every page's
7385            // old + new URL + descendant URLs (captured pre-cascade) is
7386            // registered via on_commit, firing only once the batch commits.
7387            let mut to_move: Vec<(Page, Vec<Page>)> = Vec::with_capacity(pages.len());
7388            for p in pages.iter().cloned() {
7389                let subtree = p.descendants(pool).await?;
7390                to_move.push((p, subtree));
7391            }
7392            let moved = to_move.len();
7393            let invalidator = _state.cache_invalidator.clone();
7394            let tenant_slug = tenant.org.slug.clone();
7395            let np_for_tx = new_parent.clone();
7396            crate::tree_ops::atomic_tree(pool, move |tx| {
7397                Box::pin(async move {
7398                    let mut purge: Vec<String> = Vec::new();
7399                    for (mut p, subtree) in to_move {
7400                        let old_url = p.url_path.clone();
7401                        let descendant_old_urls: Vec<String> =
7402                            subtree.iter().map(|d| d.url_path.clone()).collect();
7403                        // Moves the URLs with the tree (#706).
7404                        p.move_to_in_tx(np_for_tx.as_ref(), subtree, tx).await?;
7405                        purge.push(old_url);
7406                        purge.push(p.url_path.clone());
7407                        purge.extend(descendant_old_urls);
7408                    }
7409                    crate::cache_invalidate::invalidate_urls_on_commit(
7410                        invalidator,
7411                        tenant_slug,
7412                        purge,
7413                    );
7414                    Ok(())
7415                })
7416            })
7417            .await?;
7418            redirect_named_with_message_plural(
7419                "rcms-admin:pages:list",
7420                MsgLevel::Success,
7421                "Moved {count} page(s) under “{parent}”.",
7422                moved as i64,
7423                &[
7424                    ("count", &moved.to_string()),
7425                    (
7426                        "parent",
7427                        &new_parent.map(|p| p.title).unwrap_or_else(|| "Root".to_owned()),
7428                    ),
7429                ],
7430                &headers,
7431            )
7432        }
7433        "copy-to-locale" => {
7434            // #438 — simple-translation bulk: seed `cms_translation`
7435            // rows for each selected page from its canonical text, so
7436            // translators start from the source rather than a blank
7437            // form. Existing translations are left untouched.
7438            let code = form
7439                .iter()
7440                .find(|(k, _)| k == "locale")
7441                .map(|(_, v)| v.as_str())
7442                .unwrap_or("");
7443            let locale = Locale::objects()
7444                .where_(Locale::code.eq(code.to_owned()))
7445                .where_(Locale::active.eq(true))
7446                .first(pool)
7447                .await?;
7448            let Some(locale) = locale.filter(|l| !l.is_default) else {
7449                return redirect_named_with_message(
7450                    "rcms-admin:pages:list",
7451                    MsgLevel::Warning,
7452                    "Copy to locale needs a target locale (and not the default — canonical content already lives there).",
7453                    &headers,
7454                );
7455            };
7456            let locale_id = locale.id.get().copied().unwrap_or_default();
7457            let pages_for_tx = pages.clone();
7458            let (seeded_pages, seeded_fields) = rustango::atomic!(pool, |tx| {
7459                let mut guard = tx.lock().await?;
7460                let tx = &mut *guard;
7461                let mut sp = 0usize;
7462                let mut sf = 0usize;
7463                for p in &pages_for_tx {
7464                    let Some(pid) = p.id.get().copied() else {
7465                        continue;
7466                    };
7467                    // Field paths already translated for this locale —
7468                    // never overwrite a translator's work.
7469                    let existing: Vec<crate::translation::Translation> =
7470                        crate::translation::Translation::objects()
7471                            .where_(crate::translation::Translation::page_id.eq(pid))
7472                            .where_(crate::translation::Translation::locale_id.eq(locale_id))
7473                            .fetch_tx(tx)
7474                            .await?;
7475                    let have: std::collections::HashSet<String> =
7476                        existing.into_iter().map(|t| t.field_path).collect();
7477                    let mut touched = false;
7478                    for (path, value) in copy_fields_for(p) {
7479                        if have.contains(path) {
7480                            continue;
7481                        }
7482                        let mut row = crate::translation::Translation {
7483                            id: rustango::sql::Auto::Unset,
7484                            page_id: pid,
7485                            locale_id,
7486                            field_path: path.to_owned(),
7487                            value,
7488                            updated_at: rustango::sql::Auto::Unset,
7489                        };
7490                        row.save_tx(tx).await?;
7491                        sf += 1;
7492                        touched = true;
7493                    }
7494                    if touched {
7495                        sp += 1;
7496                    }
7497                }
7498                Ok::<_, rustango::sql::ExecError>((sp, sf))
7499            })
7500            .await?;
7501            // Two independent counts → compose localized noun-phrases into a
7502            // localized sentence template (#528/#1102).
7503            let fields = super::i18n::tr_plural(
7504                &headers,
7505                "{count} field(s)",
7506                seeded_fields as i64,
7507                &[("count", &seeded_fields.to_string())],
7508            );
7509            let pages_ph = super::i18n::tr_plural(
7510                &headers,
7511                "{count} page(s)",
7512                seeded_pages as i64,
7513                &[("count", &seeded_pages.to_string())],
7514            );
7515            redirect_named_with_message_args(
7516                "rcms-admin:pages:list",
7517                MsgLevel::Success,
7518                "Seeded {fields} across {pages} into “{locale}”. Existing translations were left untouched.",
7519                &[
7520                    ("fields", fields.as_str()),
7521                    ("pages", pages_ph.as_str()),
7522                    ("locale", locale.name.as_str()),
7523                ],
7524                &headers,
7525            )
7526        }
7527        "archive" | "unarchive" => {
7528            // #556 — archive: preserve superseded content (serve 200,
7529            // stay searchable, frozen against delete/unpublish).
7530            // Unarchive: revive to published. Descendants inherit the
7531            // treatment at render time, so the whole public subtree is
7532            // purged; with `archive_cascade` their own rows flip too.
7533            let archive = action == "archive";
7534            let plan =
7535                crate::page::plan_archive(pool, &pages, archive, archive_cascade).await?;
7536            let invalidator = _state.cache_invalidator.clone();
7537            let tenant_slug = tenant.org.slug.clone();
7538            let purge = plan.changed_urls.clone();
7539            let flips = plan.to_flip.clone();
7540            let touched = rustango::atomic!(pool, |tx| {
7541                let mut guard = tx.lock().await?;
7542                let tx = &mut *guard;
7543                let mut n = 0usize;
7544                for mut p in flips {
7545                    p.save_tx(tx).await?;
7546                    n += 1;
7547                }
7548                crate::cache_invalidate::invalidate_urls_on_commit(
7549                    invalidator,
7550                    tenant_slug,
7551                    purge,
7552                );
7553                Ok::<usize, rustango::sql::ExecError>(n)
7554            })
7555            .await?;
7556            // Bookkeeping outside the tx (best-effort): a revision per
7557            // flipped row + search-index sync (archived stays indexed;
7558            // the FTS path is query-time so this is a no-op there).
7559            for p in &plan.to_flip {
7560                crate::revision::capture(pool, p, None)
7561                    .await
7562                    .log_warn("revision not captured; the history has a gap");
7563                crate::task_queue::sync_page_search(&tenant.org.slug, p).await;
7564            }
7565            let key = if archive {
7566                "Archived {count} page(s)."
7567            } else {
7568                "Unarchived {count} page(s)."
7569            };
7570            redirect_named_with_message_plural(
7571                "rcms-admin:pages:list",
7572                MsgLevel::Success,
7573                key,
7574                touched as i64,
7575                &[("count", &touched.to_string())],
7576                &headers,
7577            )
7578        }
7579        other => Err(AdminError::Validation(format!(
7580            "unknown bulk action `{other}` (expected publish / unpublish / archive / unarchive / delete / move / copy-to-locale)"
7581        ))),
7582    }
7583}
7584
7585/// POST /cms-admin/pages/{id}/unlock — force-release the editor lock.
7586/// Anyone with Edit permission on this page can call it. The
7587/// row is deleted and an audit-log entry is written so the action is
7588/// reversible to inspect.
7589/// POST /cms-admin/pages/{id}/lock-release — the editor was left: give
7590/// up our own lock right away, not 30 minutes later, so a colleague who
7591/// opens the page next can save. Only ever releases the caller's lock.
7592pub async fn page_lock_release(
7593    tenant: Tenant,
7594    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7595    Path(id): Path<i64>,
7596) -> Result<Response, AdminError> {
7597    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7598        return Ok(unauthorized_no_session());
7599    };
7600    crate::lock::release(tenant.pool(), id, viewer_id).await?;
7601    Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
7602}
7603
7604pub async fn page_unlock_submit(
7605    State(_state): State<super::AdminState>,
7606    tenant: Tenant,
7607    headers: HeaderMap,
7608    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7609    Path(id): Path<i64>,
7610) -> Result<Response, AdminError> {
7611    let released = crate::lock::force_release(tenant.pool(), id).await?;
7612    let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
7613    let message = if let Some(row) = released {
7614        let holder = rustango::tenancy::auth::User::objects()
7615            .where_(rustango::tenancy::auth::User::id.eq(row.user_id))
7616            .fetch(tenant.pool())
7617            .await
7618            .ok()
7619            .and_then(|v| v.into_iter().next())
7620            .map(|u| u.username)
7621            .unwrap_or_else(|| format!("user#{}", row.user_id));
7622        // #192 — audit log the forced unlock.
7623        crate::page_log::record_or_warn(
7624            tenant.pool(),
7625            id,
7626            crate::page_log::ACTION_FORCE_UNLOCK,
7627            actor_id,
7628            format!("Force-unlocked — “{holder}” no longer holds the editor lock."),
7629            Some(serde_json::json!({ "previous_holder_user_id": row.user_id })),
7630        )
7631        .await;
7632        format!("Lock released — “{holder}” no longer holds the editor lock on this page.")
7633    } else {
7634        "Lock was already released.".to_owned()
7635    };
7636    redirect_named_with_params_and_message(
7637        "rcms-admin:pages:edit",
7638        &[("id", id.to_string())],
7639        MsgLevel::Success,
7640        &message,
7641        &headers,
7642    )
7643}
7644
7645/// POST /cms-admin/pages/{id}/subscribe — opt the current user in
7646/// to publish notifications for this page.
7647/// Idempotent — re-subscribing returns success without inserting a
7648/// duplicate row.
7649pub async fn page_subscribe_submit(
7650    State(_state): State<super::AdminState>,
7651    tenant: Tenant,
7652    headers: HeaderMap,
7653    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7654    Path(id): Path<i64>,
7655) -> Result<Response, AdminError> {
7656    let Some(viewer) = session_user.as_ref() else {
7657        return Ok(unauthorized_no_session());
7658    };
7659    let viewer_id = viewer.id.get().copied().unwrap_or_default();
7660    crate::page_subscription::subscribe(tenant.pool(), id, viewer_id).await?;
7661    redirect_named_with_params_and_message(
7662        "rcms-admin:pages:edit",
7663        &[("id", id.to_string())],
7664        MsgLevel::Success,
7665        "Subscribed — you'll get an email when this page publishes.",
7666        &headers,
7667    )
7668}
7669
7670/// POST /cms-admin/pages/{id}/unsubscribe — opt the current user out
7671/// of publish notifications. No-op when not subscribed.
7672pub async fn page_unsubscribe_submit(
7673    State(_state): State<super::AdminState>,
7674    tenant: Tenant,
7675    headers: HeaderMap,
7676    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7677    Path(id): Path<i64>,
7678) -> Result<Response, AdminError> {
7679    let Some(viewer) = session_user.as_ref() else {
7680        return Ok(unauthorized_no_session());
7681    };
7682    let viewer_id = viewer.id.get().copied().unwrap_or_default();
7683    crate::page_subscription::unsubscribe(tenant.pool(), id, viewer_id).await?;
7684    redirect_named_with_params_and_message(
7685        "rcms-admin:pages:edit",
7686        &[("id", id.to_string())],
7687        MsgLevel::Success,
7688        "Unsubscribed — you won't get future publish notifications for this page.",
7689        &headers,
7690    )
7691}
7692
7693/// True while the page is mid-review and `user` may not decide the
7694/// current step: the editor is read-only for them, so they must not
7695/// take (or keep) the edit lock — a submitter who reopens the page
7696/// would otherwise lock the reviewer out.
7697async fn read_only_under_review(
7698    pool: &rustango::sql::Pool,
7699    page_id: i64,
7700    user: &rustango::tenancy::auth::User,
7701) -> Result<bool, AdminError> {
7702    if user.is_superuser {
7703        return Ok(false);
7704    }
7705    let Some(state) = crate::workflow::active_state_for_page(pool, page_id).await? else {
7706        return Ok(false);
7707    };
7708    if state.status != crate::workflow::WorkflowStatus::InProgress.as_str() {
7709        return Ok(false);
7710    }
7711    let tasks = crate::workflow::tasks_for(pool, state.workflow_id).await?;
7712    let Some(task) = state
7713        .current_task_id
7714        .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
7715    else {
7716        return Ok(false);
7717    };
7718    let uid = user.id.get().copied().unwrap_or_default();
7719    Ok(!user_is_in_role(pool, uid, task.role_id).await?)
7720}
7721
7722/// POST /cms-admin/pages/{id}/lock-heartbeat — refresh the TTL on
7723/// the caller's lock. Called every
7724/// `lock::HEARTBEAT_INTERVAL_SECS` from the page-editor JS while the
7725/// tab stays open. Returns:
7726///   * 204 — heartbeat accepted (lock refreshed, or first claim).
7727///   * 409 — someone else owns the lock; the editor JS should
7728///           reload to surface the banner.
7729/// Heartbeat query: editors send `?is_editing=1` once they've
7730/// touched the form so the presence banner can show "editing" vs
7731/// "viewing" for other viewers.
7732#[derive(Debug, Deserialize)]
7733pub struct HeartbeatQuery {
7734    #[serde(default)]
7735    pub is_editing: Option<String>,
7736}
7737
7738pub async fn page_lock_heartbeat(
7739    State(_state): State<super::AdminState>,
7740    tenant: Tenant,
7741    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7742    Path(id): Path<i64>,
7743    Query(q): Query<HeartbeatQuery>,
7744) -> Result<Response, AdminError> {
7745    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7746        return Ok(unauthorized_no_session());
7747    };
7748
7749    // #106 — touch the editing-session row on every ping. Stale
7750    // rows GC lazily here so we don't need a cron.
7751    let is_editing = q.is_editing.as_deref() == Some("1");
7752    if let Err(e) = crate::editing_session::touch(tenant.pool(), id, viewer_id, is_editing).await {
7753        tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "editing-session touch failed (continuing)");
7754    }
7755    // GC every ~50 heartbeats to keep the table bounded without
7756    // doing the SELECT on every call. Probabilistic — fine for v1.
7757    if rand::random::<u8>() < 5 {
7758        crate::editing_session::gc_stale(tenant.pool())
7759            .await
7760            .log_warn("stale editing sessions not collected");
7761    }
7762
7763    // Read-only during someone else's review step: no lock to keep.
7764    if let Some(u) = session_user.as_ref() {
7765        if read_only_under_review(tenant.pool(), id, u).await? {
7766            return Ok((axum::http::StatusCode::NO_CONTENT, "").into_response());
7767        }
7768    }
7769    match crate::lock::acquire(tenant.pool(), id, viewer_id, false).await {
7770        Ok(crate::lock::AcquireOutcome::Acquired(_)) => {
7771            Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
7772        }
7773        Ok(crate::lock::AcquireOutcome::Held(_)) => Ok((
7774            axum::http::StatusCode::CONFLICT,
7775            "lock held by another editor",
7776        )
7777            .into_response()),
7778        Err(e) => {
7779            tracing::warn!(target: "rustango_cms::admin", page_id = id, error = %e, "lock heartbeat failed");
7780            Err(e.into())
7781        }
7782    }
7783}
7784
7785/// GET /cms-admin/pages/{id}/sessions — JSON list of OTHER active
7786/// editors / viewers on this page. Returns
7787/// `[{user_id, username, last_seen_at, is_editing}, ...]`.
7788pub async fn page_sessions_json(
7789    State(_state): State<super::AdminState>,
7790    tenant: Tenant,
7791    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7792    Path(id): Path<i64>,
7793) -> Result<Response, AdminError> {
7794    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
7795        return Ok(unauthorized_no_session());
7796    };
7797    let others = crate::editing_session::others_on_page(tenant.pool(), id, viewer_id)
7798        .await
7799        .unwrap_or_default();
7800    if others.is_empty() {
7801        return Ok(([(header::CONTENT_TYPE, "application/json")], "[]").into_response());
7802    }
7803    // Resolve usernames in one batched lookup.
7804    let user_ids: Vec<i64> = others.iter().map(|s| s.user_id).collect();
7805    let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
7806        .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
7807        .fetch(tenant.pool())
7808        .await
7809        .unwrap_or_default();
7810    let username_by_id: std::collections::HashMap<i64, String> = users
7811        .into_iter()
7812        .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
7813        .collect();
7814    let payload: Vec<serde_json::Value> = others
7815        .iter()
7816        .map(|s| {
7817            serde_json::json!({
7818                "user_id": s.user_id,
7819                "username": username_by_id.get(&s.user_id).cloned(),
7820                "last_seen_at": s.last_seen_at,
7821                "is_editing": s.is_editing,
7822            })
7823        })
7824        .collect();
7825    let body = serde_json::to_string(&payload).unwrap_or_else(|_| "[]".to_owned());
7826    Ok(([(header::CONTENT_TYPE, "application/json")], body).into_response())
7827}
7828
7829/// Pick a slug not already used by any sibling under `parent_id`.
7830/// Tries `desired`, then `desired-2`, `desired-3`, … up to 100
7831/// attempts. Returns the first available one.
7832async fn unique_sibling_slug(
7833    pool: &rustango::sql::Pool,
7834    parent_id: Option<i64>,
7835    desired: &str,
7836) -> Result<String, AdminError> {
7837    use rustango::core::Column as _;
7838    let qs = Page::objects().order_by(&[("slug", false)]);
7839    let siblings: Vec<Page> = match parent_id {
7840        Some(pid) => qs.where_(Page::parent_id.eq(pid)).fetch(pool).await?,
7841        None => qs.where_(Page::parent_id.is_null()).fetch(pool).await?,
7842    };
7843    let taken: std::collections::HashSet<String> = siblings.into_iter().map(|p| p.slug).collect();
7844    if !taken.contains(desired) {
7845        return Ok(desired.to_owned());
7846    }
7847    for n in 2..=100 {
7848        let candidate = format!("{desired}-{n}");
7849        if !taken.contains(&candidate) {
7850            return Ok(candidate);
7851        }
7852    }
7853    Err(AdminError::Validation(
7854        "Could not allocate a unique slug for the clone — over 100 siblings share the same base."
7855            .to_owned(),
7856    ))
7857}
7858
7859/// POST /cms-admin/pages/{id}/revert/{rev_id} — replace the page's
7860/// mutable fields with those from the given revision, then capture a
7861/// NEW revision recording the revert. URL-shaped fields (slug, path,
7862/// depth, parent_id, sort_order) are NOT reverted — moving the page
7863/// is a tree-ops concern, not a content concern.
7864///
7865/// Returns to the edit form afterward so the editor can verify the
7866/// state and continue editing.
7867pub async fn page_revert_submit(
7868    State(_state): State<super::AdminState>,
7869    tenant: Tenant,
7870    headers: HeaderMap,
7871    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
7872    Path((id, rev_id)): Path<(i64, i64)>,
7873) -> Result<Response, AdminError> {
7874    let mut page = Page::objects()
7875        .where_(Page::id.eq(id))
7876        .first(tenant.pool())
7877        .await?
7878        .ok_or(AdminError::NotFound(id))?;
7879    let rev = crate::revision::Revision::objects()
7880        .where_(crate::revision::Revision::id.eq(rev_id))
7881        .where_(crate::revision::Revision::page_id.eq(id))
7882        .first(tenant.pool())
7883        .await?
7884        .ok_or(AdminError::NotFound(rev_id))?;
7885
7886    // Decode the snapshot into a Page shell. Tree-shape fields
7887    // (parent_id, path, depth, sort_order, slug, url_path) are
7888    // preserved from the LIVE row — a revert restores content +
7889    // status, not tree placement.
7890    let snapshot: Page = match serde_json::from_value(rev.snapshot.clone()) {
7891        Ok(p) => p,
7892        Err(e) => {
7893            return Ok((
7894                axum::http::StatusCode::BAD_REQUEST,
7895                format!("revision snapshot could not be decoded: {e}"),
7896            )
7897                .into_response());
7898        }
7899    };
7900
7901    let old_url_path = page.url_path.clone();
7902    page.title = snapshot.title;
7903    page.page_type_id = snapshot.page_type_id;
7904    page.status = snapshot.status;
7905    page.published_at = snapshot.published_at;
7906    page.go_live_at = snapshot.go_live_at;
7907    page.expire_at = snapshot.expire_at;
7908    page.seo_title = snapshot.seo_title;
7909    page.seo_description = snapshot.seo_description;
7910    page.robots_index = snapshot.robots_index;
7911    page.sitemap_priority = snapshot.sitemap_priority;
7912
7913    let mut tx = transaction_pool(tenant.pool()).await?;
7914    page.save_tx(&mut tx).await?;
7915    tx.commit().await?;
7916    crate::revision::capture(tenant.pool(), &page, None)
7917        .await
7918        .log_warn("revision not captured; the history has a gap");
7919
7920    let _ = old_url_path; // TTL-based cache propagation per rustango::cache_page
7921                          // #192 — audit log the restore.
7922    let actor_id = session_user.as_ref().and_then(|u| u.id.get().copied());
7923    crate::page_log::record_or_warn(
7924        tenant.pool(),
7925        id,
7926        crate::page_log::ACTION_RESTORE,
7927        actor_id,
7928        format!("Reverted to revision #{}.", rev.sequence),
7929        Some(serde_json::json!({ "revision_id": rev_id, "sequence": rev.sequence })),
7930    )
7931    .await;
7932    let sequence_str = rev.sequence.to_string();
7933    redirect_named_with_params_and_message_args(
7934        "rcms-admin:pages:edit",
7935        &[("id", id.to_string())],
7936        MsgLevel::Success,
7937        "Reverted to revision #{sequence}.",
7938        &[("sequence", sequence_str.as_str())],
7939        &headers,
7940    )
7941}
7942
7943// =====================================================================
7944// Live preview
7945// =====================================================================
7946
7947/// Stamp the response with anti-cache headers so the editor's preview
7948/// iframe always renders the latest content. Browsers cache HTML
7949/// aggressively by default; the editor's "Refresh" button and the
7950/// initial load both need to hit fresh markup.
7951fn stamp_no_cache(mut response: Response) -> Response {
7952    let h = response.headers_mut();
7953    h.insert(
7954        header::CACHE_CONTROL,
7955        HeaderValue::from_static("no-store, no-cache, must-revalidate, max-age=0"),
7956    );
7957    h.insert(header::PRAGMA, HeaderValue::from_static("no-cache"));
7958    h.insert(header::EXPIRES, HeaderValue::from_static("0"));
7959    // Tell upstream caches the response varies per-request even
7960    // for the same URL (preview pulls live data on every load).
7961    h.insert(header::VARY, HeaderValue::from_static("*"));
7962    // Block embedding outside our own admin so other origins can't
7963    // frame the preview for clickjacking.
7964    h.insert(
7965        header::X_FRAME_OPTIONS,
7966        HeaderValue::from_static("SAMEORIGIN"),
7967    );
7968    response
7969}
7970
7971/// Inject the axe-core preview-glue script into the
7972/// rendered preview HTML so the editor can surface client-side
7973/// accessibility findings alongside the server-side heuristics.
7974/// Reads the response body, locates the closing `</body>`
7975/// tag (case-insensitive), and splices two `<script src="…">`
7976/// tags before it: axe-core itself, then the small glue script
7977/// that calls `axe.run()` + `postMessage`s the results back to
7978/// the editor's parent window.
7979///
7980/// Non-HTML responses pass through unchanged; pages without a
7981/// `</body>` tag (malformed templates, plain-text responses) also
7982/// pass through so the injection is best-effort + non-breaking.
7983async fn inject_axe_into_preview(response: Response) -> Response {
7984    // Only touch text/html responses.
7985    let is_html = response
7986        .headers()
7987        .get(header::CONTENT_TYPE)
7988        .and_then(|v| v.to_str().ok())
7989        .is_some_and(|ct| ct.to_ascii_lowercase().contains("text/html"));
7990    if !is_html {
7991        return response;
7992    }
7993    let (parts, body) = response.into_parts();
7994    // 4 MiB cap matches the rendition route's preview-safe upper
7995    // bound; admin preview HTML should never approach this.
7996    let bytes = match axum::body::to_bytes(body, 4 * 1024 * 1024).await {
7997        Ok(b) => b,
7998        Err(_) => {
7999            // Body read failed — return a minimal 500 since we
8000            // already consumed the original.
8001            return (
8002                axum::http::StatusCode::INTERNAL_SERVER_ERROR,
8003                "preview body read failed",
8004            )
8005                .into_response();
8006        }
8007    };
8008    let body_str = match std::str::from_utf8(&bytes) {
8009        Ok(s) => s,
8010        Err(_) => {
8011            // Non-UTF-8 HTML — rebuild without injection.
8012            return axum::http::Response::from_parts(parts, axum::body::Body::from(bytes));
8013        }
8014    };
8015    let new_body = inject_axe_into_body_str(body_str);
8016    // Rebuild the response with the patched body + a refreshed
8017    // Content-Length so axum doesn't emit the stale value.
8018    let mut resp = axum::http::Response::from_parts(parts, axum::body::Body::from(new_body));
8019    resp.headers_mut().remove(header::CONTENT_LENGTH);
8020    resp
8021}
8022
8023/// Pure string helper for [`inject_axe_into_preview`] — splice the
8024/// axe-core + glue `<script>` tags before the closing `</body>`
8025/// (case-insensitive `rfind`). Pages with no closing body tag get
8026/// the scripts appended at the end (browsers tolerate trailing
8027/// `<script>` after `</html>`). Extracted so the injection logic
8028/// is unit-testable without spinning up an axum Response stack.
8029fn inject_axe_into_body_str(body: &str) -> String {
8030    // Fingerprinted like every other admin asset (`?v=`): these are served
8031    // `immutable`, so an unversioned URL would let a year-old cached copy
8032    // mask an update.
8033    let v = super::cms_asset_version();
8034    let scripts = format!(
8035        "<script src=\"/cms-admin/static/vendor/axe-core.min.js?v={v}\" defer></script>\n\
8036         <script src=\"/cms-admin/static/cms-preview-guard.js?v={v}\" defer></script>\n\
8037         <script src=\"/cms-admin/static/cms-axe-preview.js?v={v}\" defer></script>\n"
8038    );
8039    let lower = body.to_ascii_lowercase();
8040    if let Some(idx) = lower.rfind("</body>") {
8041        let mut out = String::with_capacity(body.len() + scripts.len());
8042        out.push_str(&body[..idx]);
8043        out.push_str(&scripts);
8044        out.push_str(&body[idx..]);
8045        out
8046    } else {
8047        let mut out = String::with_capacity(body.len() + scripts.len());
8048        out.push_str(body);
8049        out.push_str(&scripts);
8050        out
8051    }
8052}
8053
8054#[cfg(test)]
8055mod axe_injection_tests {
8056    use super::inject_axe_into_body_str;
8057
8058    #[test]
8059    fn splices_before_lowercase_body_close() {
8060        let html = "<html><body><h1>hi</h1></body></html>";
8061        let out = inject_axe_into_body_str(html);
8062        assert!(out.contains("axe-core.min.js"), "axe script missing: {out}");
8063        assert!(
8064            out.contains("cms-axe-preview.js"),
8065            "glue script missing: {out}"
8066        );
8067        assert!(
8068            out.contains("cms-preview-guard.js"),
8069            "preview-guard script missing: {out}"
8070        );
8071        // Both scripts land BEFORE the body close.
8072        let close = out.find("</body>").expect("body close kept");
8073        assert!(
8074            out[..close].contains("axe-core.min.js"),
8075            "axe script should be before </body>: {out}"
8076        );
8077        assert!(
8078            out[..close].contains("cms-axe-preview.js"),
8079            "glue script should be before </body>: {out}"
8080        );
8081    }
8082
8083    #[test]
8084    fn splices_before_uppercase_body_close() {
8085        let html = "<HTML><BODY><h1>hi</h1></BODY></HTML>";
8086        let out = inject_axe_into_body_str(html);
8087        // The original close tag stays uppercase; injection is still
8088        // positioned in front of it.
8089        let close = out.find("</BODY>").expect("uppercase body close kept");
8090        assert!(out[..close].contains("axe-core.min.js"));
8091    }
8092
8093    #[test]
8094    fn appends_when_no_body_close() {
8095        let html = "<html><h1>hi</h1>";
8096        let out = inject_axe_into_body_str(html);
8097        // URLs carry a `?v=<fingerprint>` cache-bust token, so assert on the
8098        // script identity + trailing position rather than an exact URL.
8099        assert!(out.contains("cms-axe-preview.js?v="));
8100        assert!(out.trim_end().ends_with("defer></script>"));
8101        assert!(out.contains("axe-core.min.js"));
8102        // Original content preserved.
8103        assert!(out.starts_with("<html><h1>hi</h1>"));
8104    }
8105
8106    #[test]
8107    fn uses_rfind_for_nested_body_close_text() {
8108        // A template that mentions "</body>" inside a comment / text
8109        // string and ALSO has a real closing tag — we want to splice
8110        // before the LAST one, not the first.
8111        let html = "<html><body><pre>literal: &lt;/body&gt;</pre></body></html>";
8112        let out = inject_axe_into_body_str(html);
8113        let close = out.rfind("</body>").unwrap();
8114        assert!(out[..close].contains("axe-core.min.js"));
8115        // Make sure the literal in the <pre> survived.
8116        assert!(out.contains("literal: &lt;/body&gt;"));
8117    }
8118
8119    #[test]
8120    fn empty_body_renders_clean() {
8121        let out = inject_axe_into_body_str("");
8122        // Nothing to splice before; just the scripts.
8123        assert!(out.contains("axe-core.min.js"));
8124        assert!(out.contains("cms-axe-preview.js"));
8125    }
8126}
8127
8128/// Query string for the preview endpoints — carries the editing locale
8129/// when the editor is in translation mode (`?locale=fr`) so the preview
8130/// renders that locale's translation instead of the canonical content.
8131#[derive(serde::Deserialize, Default)]
8132pub struct PreviewLocaleQuery {
8133    #[serde(default)]
8134    locale: Option<String>,
8135    /// `?format=json` — show the page's API representation instead of
8136    /// its rendered HTML. This is the editor's preview switch, and it
8137    /// works for **any** page type, not just ones whose `view_mode`
8138    /// opts into a public JSON view: an authenticated editor asking to
8139    /// inspect the API shape is a different act from an anonymous
8140    /// client negotiating for it.
8141    #[serde(default)]
8142    format: Option<String>,
8143}
8144
8145/// The Tera a preview must render through: the tenant's, not the global set.
8146///
8147/// The public renderer resolves templates per tenant (`router.rs` →
8148/// [`crate::tenant_templates::TenantTemplates::for_tenant`]), so a
8149/// preview built from `state.tera` shows a page the visitor will never
8150/// get. Three ways it goes wrong, all silent: a tenant's override of a
8151/// shared template is ignored; a `Page::template_override` naming a
8152/// template that exists only as an override fails `pick_template`'s
8153/// existence check and falls back to the page type's default; and a
8154/// block whose template is a tenant override renders its
8155/// "missing template" fallback.
8156///
8157/// Falls back to the global set when no overlay is installed, which is
8158/// every single-template-set deployment.
8159fn preview_tera(state: &super::AdminState, tenant: &Tenant) -> std::sync::Arc<tera::Tera> {
8160    crate::tenant_templates::installed()
8161        .map(|tt| tt.for_tenant(&tenant.org.slug))
8162        .unwrap_or_else(|| state.tera.clone())
8163}
8164
8165/// GET /cms-admin/pages/{id}/preview — renders the saved page through
8166/// the public render pipeline (no admin chrome) so the editor's
8167/// iframe shows exactly what a visitor would see. Anti-cache headers
8168/// ensure the iframe always pulls fresh markup. `?locale=` (translation
8169/// mode) renders that locale's saved translation.
8170pub async fn page_preview(
8171    State(state): State<super::AdminState>,
8172    tenant: Tenant,
8173    Path(id): Path<i64>,
8174    axum::extract::Query(q): axum::extract::Query<PreviewLocaleQuery>,
8175) -> Result<Response, AdminError> {
8176    let page = Page::objects()
8177        .where_(Page::id.eq(id))
8178        .first(tenant.pool())
8179        .await?
8180        .ok_or(AdminError::NotFound(id))?;
8181    let response = crate::render::render(
8182        &tenant,
8183        &preview_tera(&state, &tenant),
8184        &page,
8185        "",
8186        // No site prefix: this path renders the tenant-absolute
8187        // tree, so links must stay absolute.
8188        "",
8189        q.locale.as_deref(),
8190        None,
8191        None,
8192    )
8193    .await;
8194    // #208 — splice axe-core + the iframe-glue script before the
8195    // closing </body> so the editor's accessibility panel can
8196    // surface client-side findings alongside the server-side ones.
8197    Ok(stamp_no_cache(inject_axe_into_preview(response).await))
8198}
8199
8200/// GET /cms-admin/pages/{id}/preview-token — mint a short-lived
8201/// signed preview token so a decoupled / headless frontend can fetch
8202/// this page's DRAFT via `/api/v2/pages/{id}/?preview_token=…`. Returns
8203/// JSON `{token, expires_at, api_path}`. Auth is enforced by the admin
8204/// router's login guard. 422 when no signing secret is configured.
8205pub async fn page_preview_token(
8206    tenant: Tenant,
8207    Path(id): Path<i64>,
8208) -> Result<Response, AdminError> {
8209    let exists = Page::objects()
8210        .where_(Page::id.eq(id))
8211        .first(tenant.pool())
8212        .await?
8213        .is_some();
8214    if !exists {
8215        return Err(AdminError::NotFound(id));
8216    }
8217    // 1-hour token: long enough to click through + iterate, short
8218    // enough to bound exposure of an unpublished page.
8219    let expires = chrono::Utc::now().timestamp() + PREVIEW_TOKEN_TTL_SECS;
8220    match crate::preview_token::mint(&tenant.org.slug, id, expires) {
8221        Some(token) => Ok(Json(serde_json::json!({
8222            "token": token,
8223            "expires_at": expires,
8224            "api_path": format!("/api/v2/pages/{id}/?preview_token={token}"),
8225        }))
8226        .into_response()),
8227        None => Err(AdminError::Validation(
8228            "Preview tokens are disabled — set RCMS_SECRET_KEY to enable headless draft preview."
8229                .to_owned(),
8230        )),
8231    }
8232}
8233
8234/// POST /cms-admin/pages/{id}/preview — same as the GET variant, but
8235/// renders a *virtual* page assembled from the posted form values so
8236/// the editor can preview unsaved changes. Nothing is persisted. Anti-cache
8237/// headers + same-origin frame policy mirror the GET handler.
8238pub async fn page_preview_draft(
8239    State(state): State<super::AdminState>,
8240    tenant: Tenant,
8241    Path(id): Path<i64>,
8242    axum::extract::Query(q): axum::extract::Query<PreviewLocaleQuery>,
8243    headers: HeaderMap,
8244    Form(form_map): Form<std::collections::HashMap<String, String>>,
8245) -> Result<Response, AdminError> {
8246    let mut page = Page::objects()
8247        .where_(Page::id.eq(id))
8248        .first(tenant.pool())
8249        .await?
8250        .ok_or(AdminError::NotFound(id))?;
8251
8252    // Overlay the canonical form fields onto the virtual page. The
8253    // tree placement (parent / path / url_path) stays as-saved so
8254    // breadcrumb + ancestor lookups still work.
8255    if let Some(v) = form_map.get("title") {
8256        page.title = v.clone();
8257    }
8258    if let Some(v) = form_map.get("slug") {
8259        page.slug = v.clone();
8260    }
8261    if let Some(v) = form_map
8262        .get("page_type_id")
8263        .and_then(|s| s.parse::<i64>().ok())
8264    {
8265        page.page_type_id = v;
8266    }
8267    if let Some(v) = form_map.get("status") {
8268        page.status = v.clone();
8269    }
8270    if let Some(v) = form_map.get("seo_title") {
8271        page.seo_title = v.clone();
8272    }
8273    if let Some(v) = form_map.get("seo_description") {
8274        page.seo_description = v.clone();
8275    }
8276    // Checkboxes submit `on` when checked, absent when unchecked.
8277    page.robots_index = form_map
8278        .get("robots_index")
8279        .map(|v| matches!(v.as_str(), "on" | "true" | "1"))
8280        .unwrap_or(page.robots_index);
8281    if let Some(v) = form_map
8282        .get("sitemap_priority")
8283        .and_then(|s| s.parse::<f32>().ok())
8284    {
8285        page.sitemap_priority = v;
8286    }
8287    if let Some(raw) = form_map.get("theme_id") {
8288        page.theme_id = if raw.is_empty() || raw == "0" {
8289            None
8290        } else {
8291            raw.parse::<i64>().ok()
8292        };
8293    }
8294
8295    // The editor's JSON pane sends `Accept: application/json`, so the
8296    // same renderer that answers the public URL answers the preview —
8297    // which is what makes the pane show the real response body rather
8298    // than an admin-side reconstruction of it.
8299    let accept = crate::page_view::parse_accept(
8300        headers
8301            .get(axum::http::header::ACCEPT)
8302            .and_then(|v| v.to_str().ok()),
8303    );
8304    let force_json = q.format.as_deref() == Some("json");
8305    let response = crate::render::render_preview(
8306        &tenant,
8307        &preview_tera(&state, &tenant),
8308        &page,
8309        "",
8310        // Preview renders tenant-absolute paths — see the GET twin.
8311        "",
8312        q.locale.as_deref(),
8313        &form_map,
8314        accept,
8315        force_json,
8316    )
8317    .await;
8318    // #208 — same axe splice as the GET preview handler above. It gates
8319    // on `text/html`, so a JSON preview passes through untouched and
8320    // never pulls axe-core into the pane.
8321    Ok(stamp_no_cache(inject_axe_into_preview(response).await))
8322}
8323
8324// =====================================================================
8325// Library tab
8326// =====================================================================
8327
8328/// GET /cms-admin/library — placeholder until a real
8329/// `register_library_type!` macro lands. Shows the registered
8330/// PageTypeHandlers as a stand-in so the chrome demos cleanly.
8331/// Query for the paginated, filtered, folder-scoped snippet list.
8332#[derive(Debug, Deserialize, Default)]
8333pub struct LibraryListQuery {
8334    /// When set, focuses the list to one library type. When absent,
8335    /// the overview (one card per registered type with counts) shows.
8336    #[serde(default)]
8337    pub r#type: Option<String>,
8338    /// Folder prefix to scope the list to. Empty / unset = root.
8339    #[serde(default)]
8340    pub folder: Option<String>,
8341    /// Free-text query — matched against the type handler's
8342    /// `search_fields()`.
8343    #[serde(default)]
8344    pub q: Option<String>,
8345    /// 1-based page number.
8346    #[serde(default)]
8347    pub page: Option<u32>,
8348    /// Rows per page. Named so it is consumed here rather than falling
8349    /// into `raw_filters` and being read as a filter chip.
8350    #[serde(default)]
8351    pub per_page: Option<usize>,
8352    /// Catch-all bucket for `filter_<key>=<value>` filter chips. Any
8353    /// query parameter starting with `filter_` lands here.
8354    #[serde(flatten)]
8355    pub raw_filters: std::collections::HashMap<String, String>,
8356}
8357
8358pub async fn library_list(
8359    State(state): State<super::AdminState>,
8360    tenant: Tenant,
8361    headers: HeaderMap,
8362    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8363    Query(q): Query<LibraryListQuery>,
8364    axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
8365) -> Result<Response, AdminError> {
8366    // Sidebar / overview data — all types + total counts. Forms are excluded:
8367    // they have their own dedicated area (`/cms-admin/forms`, sidebar "Forms")
8368    // with per-form submission counts, so listing them here would be a second,
8369    // weaker path to the same thing. Direct `?type=form` URLs still work.
8370    let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8371        .order_by(&[("type_name", false)])
8372        .fetch(tenant.pool())
8373        .await?
8374        .into_iter()
8375        .filter(|t| t.type_name != "form")
8376        .collect();
8377    let all_snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
8378        .fetch(tenant.pool())
8379        .await?;
8380    let mut counts_by_type: std::collections::HashMap<String, i64> =
8381        std::collections::HashMap::new();
8382    for s in &all_snippets {
8383        *counts_by_type.entry(s.type_name.clone()).or_default() += 1;
8384    }
8385
8386    let mut ctx = Context::new();
8387    add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8388    add_admin_theme(&mut ctx, tenant.pool()).await;
8389    // #316 — raw query string for the `| querystring(page=…)` filter in
8390    // the pagination links (preserves type/folder/q/filter_* + sets page).
8391    ctx.insert("query_string", &raw_query.unwrap_or_default());
8392    ctx.insert("types", &types);
8393    ctx.insert("counts_by_type", &counts_by_type);
8394
8395    // Overview mode — no `?type=`, show one card per registered type.
8396    let Some(type_name) = q.r#type.as_deref().filter(|s| !s.is_empty()) else {
8397        ctx.insert("mode", "overview");
8398        return render_with_csrf(&state, &headers, "rcms_admin/library_list.html", &mut ctx);
8399    };
8400
8401    // Resolve the handler so we can call list_display / search_fields
8402    // / list_filter / render_cell.
8403    let handler = crate::library::find_handler(type_name);
8404    let list_display = handler
8405        .as_ref()
8406        .map(|h| h.list_display())
8407        .unwrap_or_else(|| {
8408            vec![
8409                crate::library::ListColumn::Field {
8410                    column: "title",
8411                    label: "Title",
8412                },
8413                crate::library::ListColumn::Field {
8414                    column: "slug",
8415                    label: "Slug",
8416                },
8417                crate::library::ListColumn::Field {
8418                    column: "updated_at",
8419                    label: "Updated",
8420                },
8421            ]
8422        });
8423    let search_fields = handler
8424        .as_ref()
8425        .map(|h| h.search_fields())
8426        .unwrap_or_else(|| vec!["title", "slug"]);
8427    let filter_keys = handler
8428        .as_ref()
8429        .map(|h| h.list_filter())
8430        .unwrap_or_default();
8431
8432    // Folder scoping. Snippets with `folder_path = <current>` are
8433    // direct contents; we also surface the immediate sub-folder
8434    // names so the user can drill in.
8435    let folder = crate::snippet::normalize_folder(q.folder.as_deref().unwrap_or(""));
8436    let child_folders = crate::snippet::child_folders(tenant.pool(), &folder)
8437        .await
8438        .unwrap_or_default();
8439
8440    // Apply filters — type, folder, then per-data.<key> chips +
8441    // per-row `can_view` (#21 phase 1) so handler-supplied hooks
8442    // suppress rows from the list.
8443    let mut filtered: Vec<crate::snippet::Snippet> = all_snippets
8444        .iter()
8445        .filter(|s| s.type_name == type_name && s.folder_path == folder)
8446        .filter(|s| handler.as_ref().map(|h| h.can_view(s)).unwrap_or(true))
8447        .cloned()
8448        .collect();
8449
8450    // Search — ILIKE pattern on each search_field, ANY match wins.
8451    let search_q = q.q.as_deref().map(|s| s.trim()).filter(|s| !s.is_empty());
8452    if let Some(needle) = search_q {
8453        let needle_lower = needle.to_lowercase();
8454        filtered.retain(|s| {
8455            search_fields.iter().any(|field| {
8456                let hay = match *field {
8457                    "title" => s.title.to_lowercase(),
8458                    "slug" => s.slug.to_lowercase(),
8459                    "body_markdown" => s.body_markdown.to_lowercase(),
8460                    other => s
8461                        .data
8462                        .get(other)
8463                        .and_then(serde_json::Value::as_str)
8464                        .map(str::to_lowercase)
8465                        .unwrap_or_default(),
8466                };
8467                hay.contains(&needle_lower)
8468            })
8469        });
8470    }
8471
8472    // `filter_<key>=<value>` chips — flatten raw_filters into a
8473    // typed map first so we don't carry useless keys into context.
8474    let mut active_filters: std::collections::HashMap<String, String> =
8475        std::collections::HashMap::new();
8476    for (k, v) in &q.raw_filters {
8477        if let Some(stripped) = k.strip_prefix("filter_") {
8478            if !v.is_empty() {
8479                active_filters.insert(stripped.to_owned(), v.clone());
8480            }
8481        }
8482    }
8483    if !active_filters.is_empty() {
8484        filtered.retain(|s| {
8485            active_filters.iter().all(|(key, want)| {
8486                let got = s
8487                    .data
8488                    .get(key)
8489                    .map(|v| match v {
8490                        serde_json::Value::String(s) => s.clone(),
8491                        other => other.to_string(),
8492                    })
8493                    .unwrap_or_default();
8494                got == *want
8495            })
8496        });
8497    }
8498
8499    // Filter chip options (distinct values per filterable key).
8500    let filter_options: std::collections::HashMap<String, Vec<String>> = filter_keys
8501        .iter()
8502        .map(|k| {
8503            let mut opts: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
8504            for s in &all_snippets {
8505                if s.type_name != type_name {
8506                    continue;
8507                }
8508                if let Some(v) = s.data.get(*k) {
8509                    let s = match v {
8510                        serde_json::Value::String(s) => s.clone(),
8511                        other => other.to_string(),
8512                    };
8513                    if !s.is_empty() {
8514                        opts.insert(s);
8515                    }
8516                }
8517            }
8518            ((*k).to_owned(), opts.into_iter().collect())
8519        })
8520        .collect();
8521
8522    // Pagination — driven by `rustango::pagination::Paginator`.
8523    // `get_page()` never errors; out-of-range numbers clamp to the
8524    // last page (or 1 when empty). The slice indices come from
8525    // `start_index() - 1 .. end_index()` (the paginator returns
8526    // 1-based inclusive indices for "Showing X–Y" UI lines).
8527    let total = filtered.len();
8528    let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
8529    let paginator = rustango::pagination::Paginator::new(total, page_size);
8530    let requested_page = q.page.unwrap_or(1).max(1) as i64;
8531    let page_obj = paginator.get_page(requested_page);
8532    let page = page_obj.number;
8533    let total_pages = paginator.num_pages().max(1);
8534    let page_rows: Vec<crate::snippet::Snippet> = if total == 0 {
8535        Vec::new()
8536    } else {
8537        let start = page_obj.start_index().saturating_sub(1);
8538        let end = page_obj.end_index();
8539        filtered[start..end].to_vec()
8540    };
8541
8542    // Pre-render each row's cells so the template doesn't need to
8543    // know about ListColumn variants. Each row → Vec<String> of
8544    // pre-escaped HTML strings (cells), aligned with `column_headers`.
8545    let column_headers: Vec<serde_json::Value> = list_display
8546        .iter()
8547        .map(|c| {
8548            serde_json::json!({
8549                "key": c.key(),
8550                "label": c.label(),
8551            })
8552        })
8553        .collect();
8554    let rows_html: Vec<serde_json::Value> = page_rows
8555        .iter()
8556        .map(|row| {
8557            let cells: Vec<String> = list_display
8558                .iter()
8559                .map(|c| render_list_cell(c, row, handler.as_deref()))
8560                .collect();
8561            serde_json::json!({
8562                "id": row.id.get().copied().unwrap_or_default(),
8563                "slug": row.slug,
8564                "cells": cells,
8565            })
8566        })
8567        .collect();
8568
8569    let active_filters_json: Vec<serde_json::Value> = active_filters
8570        .iter()
8571        .map(|(k, v)| serde_json::json!({ "key": k, "value": v }))
8572        .collect();
8573
8574    // Handler-declared bulk + row actions (#21 phase 2). Serialize
8575    // the structs into the JSON shape the template iterates.
8576    let bulk_actions: Vec<serde_json::Value> = handler
8577        .as_ref()
8578        .map(|h| h.bulk_actions())
8579        .unwrap_or_default()
8580        .iter()
8581        .map(serialize_bulk_action)
8582        .collect();
8583    let row_actions: Vec<serde_json::Value> = handler
8584        .as_ref()
8585        .map(|h| h.row_actions())
8586        .unwrap_or_default()
8587        .iter()
8588        .map(serialize_bulk_action)
8589        .collect();
8590
8591    // #134 — plugin-contributed bulk actions targeting `cms_snippet`.
8592    let plugin_bulk_actions: Vec<serde_json::Value> = crate::hooks::bulk_actions_for("cms_snippet")
8593        .into_iter()
8594        .map(|a| {
8595            serde_json::json!({
8596                "key": a.key,
8597                "label": a.label,
8598                "icon": a.icon,
8599                "danger": a.danger,
8600                "confirm_message": a.confirm_message,
8601                "action_url": a.action_url,
8602            })
8603        })
8604        .collect();
8605
8606    // #196 — full folder tree for the left rail. Flat list of every
8607    // folder_path (including derived intermediates), sorted; the
8608    // template renders each row with depth-based indentation based
8609    // on the slash count.
8610    let folder_tree_paths = crate::snippet::folder_tree_for_type(tenant.pool(), type_name)
8611        .await
8612        .unwrap_or_default();
8613    let folder_tree: Vec<serde_json::Value> = folder_tree_paths
8614        .iter()
8615        .map(|p| {
8616            let depth = p.matches('/').count(); // root="" → 0; "a/" → 1; "a/b/" → 2
8617            let display = if p.is_empty() {
8618                "Root".to_owned()
8619            } else {
8620                // Last non-empty segment is the displayed name.
8621                p.trim_end_matches('/')
8622                    .rsplit('/')
8623                    .next()
8624                    .unwrap_or("")
8625                    .to_owned()
8626            };
8627            serde_json::json!({
8628                "path": p,
8629                "name": display,
8630                "depth": depth,
8631                "active": *p == folder,
8632            })
8633        })
8634        .collect();
8635
8636    ctx.insert("mode", "type");
8637    ctx.insert("active_type", type_name);
8638    ctx.insert("folder", &folder);
8639    ctx.insert("child_folders", &child_folders);
8640    ctx.insert("folder_tree", &folder_tree);
8641    ctx.insert("column_headers", &column_headers);
8642    ctx.insert("rows", &rows_html);
8643    ctx.insert("plugin_bulk_actions", &plugin_bulk_actions);
8644    ctx.insert("page", &page);
8645    ctx.insert("total_pages", &total_pages);
8646    // Shared control row (`rcms_admin/_pagination.html`); the bespoke
8647    // vars above stay for the rest of the template.
8648    ctx.insert(
8649        "pagination",
8650        &crate::admin::pagination::context(page as i64, page_size, total),
8651    );
8652    ctx.insert("total", &total);
8653    ctx.insert("page_size", &page_size);
8654    ctx.insert("search_q", &search_q.unwrap_or(""));
8655    ctx.insert("filter_keys", &filter_keys);
8656    ctx.insert("filter_options", &filter_options);
8657    ctx.insert("active_filters", &active_filters_json);
8658    ctx.insert("bulk_actions", &bulk_actions);
8659    ctx.insert("row_actions", &row_actions);
8660    render_with_csrf(&state, &headers, "rcms_admin/library_list.html", &mut ctx)
8661}
8662
8663/// Bulk-action button shape the library_list template iterates.
8664fn serialize_bulk_action(a: &crate::library::BulkAction) -> serde_json::Value {
8665    use crate::library::BulkActionStyle;
8666    let style_class = match a.style {
8667        BulkActionStyle::Primary => "btn",
8668        BulkActionStyle::Outlined => "btn btn-outlined",
8669        BulkActionStyle::Danger => "btn btn-danger",
8670    };
8671    serde_json::json!({
8672        "name": a.name,
8673        "label": a.label,
8674        "icon": a.icon,
8675        "confirm_message": a.confirm_message,
8676        "style_class": style_class,
8677    })
8678}
8679
8680/// POST /cms-admin/library/{type}/bulk — dispatch a bulk action
8681/// to the registered LibraryTypeHandler. Body shape:
8682/// `action=<name>&ids=<id>&ids=<id>...`. Returns the editor back
8683/// to the type's list view with a flash message reporting how many
8684/// rows the handler processed.
8685pub async fn library_bulk_submit(
8686    State(_state): State<super::AdminState>,
8687    tenant: Tenant,
8688    headers: HeaderMap,
8689    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
8690    Path(type_name): Path<String>,
8691    Form(form): Form<Vec<(String, String)>>,
8692) -> Result<Response, AdminError> {
8693    let action = form
8694        .iter()
8695        .find(|(k, _)| k == "action")
8696        .map(|(_, v)| v.clone())
8697        .unwrap_or_default();
8698    let ids: Vec<i64> = form
8699        .iter()
8700        .filter(|(k, _)| k == "ids" || k == "id")
8701        .filter_map(|(_, v)| v.parse::<i64>().ok())
8702        .collect();
8703    if action.is_empty() || ids.is_empty() {
8704        return redirect_named_with_message(
8705            "rcms-admin:library:list",
8706            MsgLevel::Warning,
8707            "Pick at least one row + a bulk action before submitting.",
8708            &headers,
8709        );
8710    }
8711    let Some(handler) = crate::library::find_handler(&type_name) else {
8712        return Err(AdminError::Validation(format!(
8713            "unknown library type `{type_name}`"
8714        )));
8715    };
8716    // Validate that the named action is in the handler's declared
8717    // set — guards against forged form posts.
8718    let declared: std::collections::HashSet<&'static str> = handler
8719        .bulk_actions()
8720        .iter()
8721        .chain(handler.row_actions().iter())
8722        .map(|a| a.name)
8723        .collect();
8724    if !declared.contains(action.as_str()) {
8725        return Err(AdminError::Validation(format!(
8726            "library type `{type_name}` doesn't declare bulk action `{action}`"
8727        )));
8728    }
8729    let touched = handler
8730        .handle_bulk_action(tenant.pool(), &action, &ids)
8731        .await?;
8732    let count = touched.to_string();
8733    redirect_named_with_message_plural(
8734        "rcms-admin:library:list",
8735        MsgLevel::Success,
8736        "{action}: touched {count} row(s) in `{type_name}`.",
8737        touched as i64,
8738        &[
8739            ("action", action.as_str()),
8740            ("count", count.as_str()),
8741            ("type_name", type_name.as_str()),
8742        ],
8743        &headers,
8744    )
8745}
8746
8747/// Render one cell for a [`ListColumn`] / row pair into pre-escaped
8748/// HTML. Handles type-aware formatting: booleans → ✓/✗, datetimes →
8749/// 10-char prefix, FK-ish text → escape, JSON lookups → kind-driven
8750/// formatting, method fields → handler-supplied HTML (trusted —
8751/// caller is responsible for escaping).
8752fn render_list_cell(
8753    col: &crate::library::ListColumn,
8754    row: &crate::snippet::Snippet,
8755    handler: Option<&dyn crate::library::LibraryTypeHandler>,
8756) -> String {
8757    use crate::library::{ListColumn, ListColumnKind};
8758    match col {
8759        ListColumn::Field { column, .. } => match *column {
8760            "id" => row.id.get().copied().unwrap_or_default().to_string(),
8761            "type_name" => html_escape(&row.type_name),
8762            "slug" => format!("<code>{}</code>", html_escape(&row.slug)),
8763            "folder_path" => html_escape(&row.folder_path),
8764            "title" => format!("<strong>{}</strong>", html_escape(&row.title)),
8765            "body_markdown" => {
8766                let preview: String = row.body_markdown.chars().take(80).collect();
8767                format!("<span>{}</span>", html_escape(&preview))
8768            }
8769            "created_at" => row
8770                .created_at
8771                .get()
8772                .map(|d| d.format("%Y-%m-%d").to_string())
8773                .unwrap_or_default(),
8774            "updated_at" => row
8775                .updated_at
8776                .get()
8777                .map(|d| d.format("%Y-%m-%d").to_string())
8778                .unwrap_or_default(),
8779            other => format!("<em>(unknown field: {})</em>", html_escape(other)),
8780        },
8781        ListColumn::JsonField { key, kind, .. } => {
8782            let val = row.data.get(*key);
8783            match (kind, val) {
8784                (ListColumnKind::Bool, Some(serde_json::Value::Bool(b))) => bool_checkbox_html(*b),
8785                (_, Some(serde_json::Value::Bool(b))) => bool_checkbox_html(*b),
8786                (ListColumnKind::Integer, Some(serde_json::Value::Number(n)))
8787                | (ListColumnKind::Float, Some(serde_json::Value::Number(n))) => {
8788                    html_escape(&n.to_string())
8789                }
8790                (_, Some(serde_json::Value::String(s))) => html_escape(s),
8791                (_, Some(other)) => html_escape(&other.to_string()),
8792                (_, None) => String::new(),
8793            }
8794        }
8795        ListColumn::Method { name, .. } | ListColumn::Computed { name, .. } => handler
8796            .map(|h| h.render_cell(name, row))
8797            .unwrap_or_default(),
8798    }
8799}
8800
8801fn html_escape(s: &str) -> String {
8802    s.replace('&', "&amp;")
8803        .replace('<', "&lt;")
8804        .replace('>', "&gt;")
8805        .replace('"', "&quot;")
8806}
8807
8808fn bool_checkbox_html(b: bool) -> String {
8809    if b {
8810        r#"<span class="material-symbols-rounded sm filled" style="color: var(--accent);" aria-label="true">check_box</span>"#.to_owned()
8811    } else {
8812        r#"<span class="material-symbols-rounded sm" style="color: var(--muted-2);" aria-label="false">check_box_outline_blank</span>"#.to_owned()
8813    }
8814}
8815
8816/// GET /cms-admin/library/new?type=<type_name> — render the create
8817/// form for a new snippet. The type pre-selects from the query string
8818/// so the "+ New <Type>" CTA on the list page lands here.
8819#[derive(Debug, Deserialize)]
8820pub struct SnippetNewQuery {
8821    #[serde(default)]
8822    pub r#type: Option<String>,
8823    #[serde(default)]
8824    pub folder: Option<String>,
8825}
8826
8827pub async fn snippet_new_form(
8828    State(state): State<super::AdminState>,
8829    tenant: Tenant,
8830    headers: HeaderMap,
8831    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8832    Query(q): Query<SnippetNewQuery>,
8833) -> Result<Response, AdminError> {
8834    let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8835        .order_by(&[("type_name", false)])
8836        .fetch(tenant.pool())
8837        .await?;
8838    let mut ctx = Context::new();
8839    add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8840    add_admin_theme(&mut ctx, tenant.pool()).await;
8841    ctx.insert("mode", "new");
8842    ctx.insert("types", &types);
8843    ctx.insert("preselect_type", &q.r#type.unwrap_or_default());
8844    let folder = q.folder.unwrap_or_default();
8845    ctx.insert(
8846        "snippet",
8847        &serde_json::json!({
8848            "type_name": "",
8849            "slug": "",
8850            "title": "",
8851            "body_markdown": "",
8852            "folder_path": folder,
8853        }),
8854    );
8855    render_with_csrf(&state, &headers, "rcms_admin/snippet_form.html", &mut ctx)
8856}
8857
8858pub async fn snippet_edit_form(
8859    State(state): State<super::AdminState>,
8860    tenant: Tenant,
8861    headers: HeaderMap,
8862    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
8863    Path(id): Path<i64>,
8864    Query(q): Query<EditQuery>,
8865) -> Result<Response, AdminError> {
8866    let snippet = crate::snippet::Snippet::objects()
8867        .where_(crate::snippet::Snippet::id.eq(id))
8868        .first(tenant.pool())
8869        .await?
8870        .ok_or(AdminError::NotFound(id))?;
8871    // FB-04 (#537) — forms are edited in the dedicated visual builder, not
8872    // the generic snippet form. The list's Edit link lands here; bounce to
8873    // the builder so the entry point "just works".
8874    if snippet.type_name == "form" {
8875        let url = rustango::urls::reverse_owned(
8876            "rcms-admin:forms:build",
8877            &std::collections::HashMap::from([("id".to_owned(), id.to_string())]),
8878        )
8879        .map_err(|e| AdminError::Validation(format!("url reversal failed: {e}")))?;
8880        return Ok(axum::response::Redirect::to(&url).into_response());
8881    }
8882    // Permission gate (#21 phase 3) — `can_view = false` denies
8883    // the edit page entirely (404 rather than 403 to avoid leaking
8884    // existence). `can_edit = false` lets the page render read-only
8885    // — we surface it via a `read_only` context var.
8886    let handler = crate::library::find_handler(&snippet.type_name);
8887    if let Some(h) = handler.as_ref() {
8888        if !h.can_view(&snippet) {
8889            return Err(AdminError::NotFound(id));
8890        }
8891    }
8892    let read_only = handler
8893        .as_ref()
8894        .map(|h| !h.can_edit(&snippet))
8895        .unwrap_or(false);
8896    let can_delete = handler
8897        .as_ref()
8898        .map(|h| h.can_delete(&snippet))
8899        .unwrap_or(true);
8900    // Optional custom edit template — falls back to the default
8901    // `snippet_form.html` when not overridden.
8902    let template_path = handler
8903        .as_ref()
8904        .and_then(|h| h.edit_template())
8905        .unwrap_or("rcms_admin/snippet_form.html");
8906
8907    let types: Vec<crate::library::LibraryType> = crate::library::LibraryType::objects()
8908        .order_by(&[("type_name", false)])
8909        .fetch(tenant.pool())
8910        .await?;
8911    let mut ctx = Context::new();
8912    add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
8913    add_admin_theme(&mut ctx, tenant.pool()).await;
8914    ctx.insert("mode", "edit");
8915    ctx.insert("types", &types);
8916    ctx.insert("snippet", &snippet);
8917    ctx.insert("read_only", &read_only);
8918    ctx.insert("can_delete", &can_delete);
8919    // Types that let each element name its own template get the field;
8920    // for every other type the concept doesn't exist and the form
8921    // shouldn't imply it does.
8922    ctx.insert(
8923        "allows_element_template",
8924        &handler
8925            .as_ref()
8926            .map(|h| h.allows_element_template())
8927            .unwrap_or(false),
8928    );
8929    // #123 — surface revision history + preview opt-in flags so the
8930    // edit template can render a History card + Preview link only
8931    // for types that opted in.
8932    let revisions_enabled = handler.as_ref().is_some_and(|h| h.revisions_enabled());
8933    let preview_enabled = handler.as_ref().is_some_and(|h| h.preview_enabled());
8934    let revisions: Vec<crate::snippet::SnippetRevision> = if revisions_enabled {
8935        crate::snippet::revisions_for(tenant.pool(), id)
8936            .await
8937            .unwrap_or_default()
8938    } else {
8939        Vec::new()
8940    };
8941    ctx.insert("revisions_enabled", &revisions_enabled);
8942    ctx.insert("preview_enabled", &preview_enabled);
8943    ctx.insert("snippet_revisions", &revisions);
8944    // #409 — snippet translation mode. `?locale=<code>` (a non-default
8945    // active locale) shows a per-field translation editor beside the
8946    // canonical content, mirroring the page translate flow.
8947    let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
8948        .where_(crate::locale::Locale::active.eq(true))
8949        .order_by(&[("sort_order", false), ("code", false)])
8950        .fetch(tenant.pool())
8951        .await?;
8952    let editing_locale = q
8953        .locale
8954        .as_deref()
8955        .filter(|c| !c.is_empty())
8956        .and_then(|code| locales.iter().find(|l| l.code == code).cloned());
8957    let translation_mode = editing_locale.as_ref().is_some_and(|l| !l.is_default);
8958    let mut core_translations: std::collections::HashMap<String, String> =
8959        std::collections::HashMap::new();
8960    let mut extra_translations: Vec<(String, String)> = Vec::new();
8961    if translation_mode {
8962        let lid = editing_locale
8963            .as_ref()
8964            .and_then(|l| l.id.get().copied())
8965            .unwrap_or_default();
8966        let existing = crate::snippet_translation::fetch_for(tenant.pool(), id, lid)
8967            .await
8968            .unwrap_or_default();
8969        let core_keys = ["title", "body_markdown"];
8970        core_translations = core_keys
8971            .iter()
8972            .map(|k| {
8973                (
8974                    (*k).to_owned(),
8975                    existing.get(*k).cloned().unwrap_or_default(),
8976                )
8977            })
8978            .collect();
8979        extra_translations = existing
8980            .iter()
8981            .filter(|(k, _)| !core_keys.contains(&k.as_str()))
8982            .map(|(k, v)| (k.clone(), v.clone()))
8983            .collect();
8984    }
8985    ctx.insert("locales", &locales);
8986    ctx.insert("editing_locale", &editing_locale);
8987    ctx.insert("translation_mode", &translation_mode);
8988    ctx.insert("core_translations", &core_translations);
8989    ctx.insert("extra_translations", &extra_translations);
8990    render_with_csrf(&state, &headers, template_path, &mut ctx)
8991}
8992
8993/// POST `/cms-admin/library/{id}/translate?locale=<code>` —
8994/// upsert per-field snippet translations for a non-default locale.
8995/// Mirrors [`page_translate_submit`]: `tr__<field>` keys edit existing
8996/// fields, `new_field_path` + `new_field_value` adds one; an empty
8997/// value deletes the row (canonical shows through). Atomic batch.
8998pub async fn snippet_translate_submit(
8999    State(_state): State<super::AdminState>,
9000    tenant: Tenant,
9001    Path(id): Path<i64>,
9002    Query(q): Query<EditQuery>,
9003    Form(form): Form<std::collections::HashMap<String, String>>,
9004) -> Result<Response, AdminError> {
9005    use crate::snippet_translation::SnippetTranslation;
9006    let code = q
9007        .locale
9008        .as_deref()
9009        .filter(|c| !c.is_empty())
9010        .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
9011    let locale = crate::locale::Locale::objects()
9012        .where_(crate::locale::Locale::code.eq(code.to_owned()))
9013        .where_(crate::locale::Locale::active.eq(true))
9014        .first(tenant.pool())
9015        .await?
9016        .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
9017    if locale.is_default {
9018        return Ok((
9019            axum::http::StatusCode::BAD_REQUEST,
9020            "cannot translate INTO the default locale; canonical content lives on cms_snippet",
9021        )
9022            .into_response());
9023    }
9024    let locale_id = locale
9025        .id
9026        .get()
9027        .copied()
9028        .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
9029    // Verify the snippet exists.
9030    let snippet = crate::snippet::Snippet::objects()
9031        .where_(crate::snippet::Snippet::id.eq(id))
9032        .first(tenant.pool())
9033        .await?
9034        .ok_or(AdminError::NotFound(id))?;
9035
9036    // Collect `tr__<field>` edits + an optional new-field row.
9037    let mut updates: Vec<(String, String)> = Vec::new();
9038    for (k, v) in &form {
9039        if let Some(path) = k.strip_prefix("tr__") {
9040            if !path.is_empty() {
9041                updates.push((path.to_owned(), v.clone()));
9042            }
9043        }
9044    }
9045    let new_path_raw = form.get("new_field_path").map(String::as_str).unwrap_or("");
9046    if !new_path_raw.trim().is_empty() {
9047        // Reuse the model's validator; silently skip a malformed path
9048        // rather than 400 the whole batch.
9049        if let Ok(path) = crate::snippet_translation::validate_field_path(new_path_raw) {
9050            let value = form.get("new_field_value").cloned().unwrap_or_default();
9051            updates.push((path, value));
9052        }
9053    }
9054
9055    // Empty value → delete; non-empty → upsert. Atomic batch.
9056    rustango::atomic!(tenant.pool(), |tx| {
9057        let mut guard = tx.lock().await?;
9058        let tx = &mut *guard;
9059        for (path, value) in updates {
9060            let existing: Vec<SnippetTranslation> = SnippetTranslation::objects()
9061                .where_(SnippetTranslation::snippet_id.eq(id))
9062                .where_(SnippetTranslation::locale_id.eq(locale_id))
9063                .where_(SnippetTranslation::field_path.eq(path.clone()))
9064                .fetch_tx(tx)
9065                .await?;
9066            if value.is_empty() {
9067                for row in existing {
9068                    row.delete_tx(tx).await?;
9069                }
9070            } else if let Some(mut row) = existing.into_iter().next() {
9071                row.value = value;
9072                row.save_tx(tx).await?;
9073            } else {
9074                let mut row = SnippetTranslation {
9075                    id: rustango::sql::Auto::Unset,
9076                    snippet_id: id,
9077                    locale_id,
9078                    field_path: path,
9079                    value,
9080                    updated_at: rustango::sql::Auto::Unset,
9081                };
9082                row.save_tx(tx).await?;
9083            }
9084        }
9085        Ok::<_, rustango::sql::ExecError>(())
9086    })
9087    .await?;
9088
9089    // A form is translated on its own screen; its library edit page
9090    // forwards to the builder and would drop the language.
9091    let back = if snippet.type_name == "form" {
9092        format!("/cms-admin/forms/{id}/build?locale={code}")
9093    } else {
9094        format!("/cms-admin/library/{id}/edit?locale={code}")
9095    };
9096    Ok(Redirect::to(&back).into_response())
9097}
9098
9099/// POST /cms-admin/library/snippets/{id}/revert/{seq} — restore a
9100/// snippet to the snapshot stored in the named revision. Captures a
9101/// fresh revision after the revert so the timeline stays linear.
9102pub async fn snippet_revert_submit(
9103    State(_state): State<super::AdminState>,
9104    tenant: Tenant,
9105    headers: HeaderMap,
9106    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9107    Path((id, sequence)): Path<(i64, i32)>,
9108) -> Result<Response, AdminError> {
9109    let Some(rev) = crate::snippet::revision_by_sequence(tenant.pool(), id, sequence).await? else {
9110        return Err(AdminError::NotFound(id));
9111    };
9112    let mut snippet = crate::snippet::Snippet::objects()
9113        .where_(crate::snippet::Snippet::id.eq(id))
9114        .first(tenant.pool())
9115        .await?
9116        .ok_or(AdminError::NotFound(id))?;
9117    // Re-hydrate from the snapshot — title / body / slug / data /
9118    // folder_path / type_name. Skip primary key + audit timestamps.
9119    let snap = &rev.snapshot;
9120    if let Some(v) = snap.get("title").and_then(|v| v.as_str()) {
9121        snippet.title = v.to_owned();
9122    }
9123    if let Some(v) = snap.get("slug").and_then(|v| v.as_str()) {
9124        snippet.slug = v.to_owned();
9125    }
9126    if let Some(v) = snap.get("body_markdown").and_then(|v| v.as_str()) {
9127        snippet.body_markdown = v.to_owned();
9128    }
9129    if let Some(v) = snap.get("folder_path").and_then(|v| v.as_str()) {
9130        snippet.folder_path = v.to_owned();
9131    }
9132    if let Some(v) = snap.get("type_name").and_then(|v| v.as_str()) {
9133        snippet.type_name = v.to_owned();
9134    }
9135    if let Some(v) = snap.get("data") {
9136        snippet.data = v.clone();
9137    }
9138    snippet.save_pool(tenant.pool()).await?;
9139    // Capture the revert itself so the timeline shows it.
9140    if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9141        if handler.revisions_enabled() {
9142            let captured_by = session_user.as_ref().and_then(|u| u.id.get().copied());
9143            crate::snippet::capture_revision(tenant.pool(), &snippet, captured_by)
9144                .await
9145                .log_warn("revision not captured; the history has a gap");
9146        }
9147    }
9148    let sequence_str = sequence.to_string();
9149    redirect_named_with_params_and_message_args(
9150        "rcms-admin:library:edit",
9151        &[("id", id.to_string())],
9152        MsgLevel::Success,
9153        "Reverted to revision #{sequence}.",
9154        &[("sequence", sequence_str.as_str())],
9155        &headers,
9156    )
9157}
9158
9159pub async fn snippet_create_submit(
9160    State(_state): State<super::AdminState>,
9161    tenant: Tenant,
9162    headers: HeaderMap,
9163    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9164    Form(form): Form<std::collections::HashMap<String, String>>,
9165) -> Result<Response, AdminError> {
9166    let type_name = form.get("type_name").cloned().unwrap_or_default();
9167    let slug = form.get("slug").cloned().unwrap_or_default();
9168    let title = form.get("title").cloned().unwrap_or_default();
9169    let body = form.get("body_markdown").cloned().unwrap_or_default();
9170    let folder_path = form
9171        .get("folder_path")
9172        .map(|s| crate::snippet::normalize_folder(s))
9173        .unwrap_or_default();
9174    if type_name.is_empty() || slug.is_empty() || title.is_empty() {
9175        return Err(AdminError::Validation(
9176            "type, slug, and title are all required".to_owned(),
9177        ));
9178    }
9179    let mut row = crate::snippet::Snippet {
9180        id: rustango::sql::Auto::Unset,
9181        type_name,
9182        slug,
9183        folder_path,
9184        title,
9185        body_markdown: body,
9186        data: serde_json::Value::Object(serde_json::Map::new()),
9187        created_at: rustango::sql::Auto::Unset,
9188        updated_at: rustango::sql::Auto::Unset,
9189    };
9190    row.save_pool(tenant.pool()).await?;
9191    // A new form is empty until its fields are built — go straight to the
9192    // Form Builder rather than back to the Library list.
9193    if row.type_name == "form" {
9194        let id = row.id.get().copied().unwrap_or_default();
9195        return redirect_named_with_params_and_message(
9196            "rcms-admin:forms:build",
9197            &[("id", id.to_string())],
9198            MsgLevel::Success,
9199            &super::i18n::tr(
9200                &headers,
9201                "Created snippet “{title}”.",
9202                &[("title", row.title.as_str())],
9203            ),
9204            &headers,
9205        );
9206    }
9207    redirect_named_with_message_args(
9208        "rcms-admin:library:list",
9209        MsgLevel::Success,
9210        "Created snippet “{title}”.",
9211        &[("title", row.title.as_str())],
9212        &headers,
9213    )
9214}
9215
9216pub async fn snippet_edit_submit(
9217    State(_state): State<super::AdminState>,
9218    tenant: Tenant,
9219    headers: HeaderMap,
9220    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9221    Path(id): Path<i64>,
9222    Form(form): Form<std::collections::HashMap<String, String>>,
9223) -> Result<Response, AdminError> {
9224    let mut snippet = crate::snippet::Snippet::objects()
9225        .where_(crate::snippet::Snippet::id.eq(id))
9226        .first(tenant.pool())
9227        .await?
9228        .ok_or(AdminError::NotFound(id))?;
9229    // Permission gate (#21 phase 3) — handler-declared can_edit
9230    // hook short-circuits the save. V1 default is `true`; hosts
9231    // override to wire role-aware logic.
9232    if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9233        if !handler.can_edit(&snippet) {
9234            return Err(AdminError::Validation(format!(
9235                "Library type `{}` denies edit on this row.",
9236                snippet.type_name
9237            )));
9238        }
9239        // Cross-field validation hook — surfaces field-scoped error
9240        // strings before any mutation lands.
9241        if let Err(errors) = handler.validate(&form) {
9242            let summary: Vec<String> = errors
9243                .into_iter()
9244                .map(|(field, msg)| format!("{field}: {msg}"))
9245                .collect();
9246            return Err(AdminError::Validation(summary.join("; ")));
9247        }
9248    }
9249    if let Some(v) = form.get("type_name") {
9250        if !v.is_empty() {
9251            snippet.type_name = v.clone();
9252        }
9253    }
9254    if let Some(v) = form.get("slug") {
9255        if !v.is_empty() {
9256            snippet.slug = v.clone();
9257        }
9258    }
9259    if let Some(v) = form.get("title") {
9260        snippet.title = v.clone();
9261    }
9262    if let Some(v) = form.get("body_markdown") {
9263        snippet.body_markdown = v.clone();
9264    }
9265    if let Some(v) = form.get("folder_path") {
9266        snippet.folder_path = crate::snippet::normalize_folder(v);
9267    }
9268    // Per-element template name, for types that opted in via
9269    // `allows_element_template()`. Only that one `data` key is read
9270    // here: the generic form deliberately does not own `data` (typed
9271    // extras belong to a type's own `edit_template`), so a type that
9272    // never opted in cannot have its render repointed from this form.
9273    if crate::library::find_handler(&snippet.type_name)
9274        .is_some_and(|h| h.allows_element_template())
9275    {
9276        if let Some(v) = form.get("data__template") {
9277            crate::snippet::set_element_template(&mut snippet.data, v.trim());
9278        }
9279    }
9280    snippet.save_pool(tenant.pool()).await?;
9281    // #123 — capture a versioned snapshot when the handler opts in
9282    // via `revisions_enabled()`. Best-effort: capture failure logs
9283    // + does NOT abort the save.
9284    if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9285        if handler.revisions_enabled() {
9286            let captured_by = session_user.as_ref().and_then(|u| u.id.get().copied());
9287            if let Err(e) =
9288                crate::snippet::capture_revision(tenant.pool(), &snippet, captured_by).await
9289            {
9290                tracing::warn!(
9291                    target: "rustango_cms::admin",
9292                    snippet_id = id,
9293                    type_name = %snippet.type_name,
9294                    error = %e,
9295                    "snippet revision capture failed",
9296                );
9297            }
9298        }
9299    }
9300    // #146 — reindex references from the saved snippet form.
9301    {
9302        let mut refs: Vec<crate::reference_index::Reference> = Vec::new();
9303        for (key, value) in &form {
9304            let mut found = crate::reference_index::scan(value, key);
9305            refs.append(&mut found);
9306        }
9307        if let Err(e) = crate::reference_index::reindex_source(
9308            tenant.pool(),
9309            crate::reference_index::KIND_SNIPPET,
9310            id,
9311            refs,
9312        )
9313        .await
9314        {
9315            tracing::warn!(
9316                target: "rustango_cms::reference_index",
9317                snippet_id = id, error = %e,
9318                "snippet reindex failed (best-effort)"
9319            );
9320        }
9321    }
9322    redirect_named_with_message_args(
9323        "rcms-admin:library:list",
9324        MsgLevel::Success,
9325        "Saved snippet “{title}”.",
9326        &[("title", snippet.title.as_str())],
9327        &headers,
9328    )
9329}
9330
9331pub async fn snippet_delete_submit(
9332    State(_state): State<super::AdminState>,
9333    tenant: Tenant,
9334    headers: HeaderMap,
9335    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9336    Path(id): Path<i64>,
9337) -> Result<Response, AdminError> {
9338    let snippet = crate::snippet::Snippet::objects()
9339        .where_(crate::snippet::Snippet::id.eq(id))
9340        .first(tenant.pool())
9341        .await?
9342        .ok_or(AdminError::NotFound(id))?;
9343    // Permission gate (#21 phase 3) — handler can deny delete.
9344    if let Some(handler) = crate::library::find_handler(&snippet.type_name) {
9345        if !handler.can_delete(&snippet) {
9346            return Err(AdminError::Validation(format!(
9347                "Library type `{}` denies delete on this row.",
9348                snippet.type_name
9349            )));
9350        }
9351    }
9352    let title = snippet.title.clone();
9353    let is_form = snippet.type_name == "form";
9354    snippet.delete_pool(tenant.pool()).await?;
9355    // Forms are deleted from the Forms screen — go back there.
9356    if is_form {
9357        let body = super::i18n::tr(&headers, "Deleted snippet “{title}”.", &[("title", title.as_str())]);
9358        return Ok(rustango::messages::redirect_with_message(
9359            messages_secret(),
9360            &headers,
9361            MsgLevel::Success,
9362            &body,
9363            "/cms-admin/forms",
9364        ));
9365    }
9366    redirect_named_with_message_args(
9367        "rcms-admin:library:list",
9368        MsgLevel::Success,
9369        "Deleted snippet “{title}”.",
9370        &[("title", title.as_str())],
9371        &headers,
9372    )
9373}
9374
9375// =====================================================================
9376// Media + Documents tabs
9377// =====================================================================
9378
9379/// Parse a `YYYY-MM-DD` filter into the UTC instant at start-of-day.
9380/// Empty / unparseable → None.
9381fn parse_date_floor(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
9382    let raw = raw?.trim();
9383    if raw.is_empty() {
9384        return None;
9385    }
9386    chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d")
9387        .ok()
9388        .map(|d| {
9389            chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
9390                d.and_hms_opt(0, 0, 0).unwrap_or_default(),
9391                chrono::Utc,
9392            )
9393        })
9394}
9395
9396/// Parse a `YYYY-MM-DD` filter into the UTC instant at end-of-day
9397/// (23:59:59) so the inclusive ceiling matches editor intent.
9398fn parse_date_ceil(raw: Option<&str>) -> Option<chrono::DateTime<chrono::Utc>> {
9399    let raw = raw?.trim();
9400    if raw.is_empty() {
9401        return None;
9402    }
9403    chrono::NaiveDate::parse_from_str(raw, "%Y-%m-%d")
9404        .ok()
9405        .map(|d| {
9406            chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
9407                d.and_hms_opt(23, 59, 59).unwrap_or_default(),
9408                chrono::Utc,
9409            )
9410        })
9411}
9412
9413/// Query string for the media + documents list views. All filters
9414/// optional; URL state persists so editors can bookmark filtered
9415/// views.
9416#[derive(Debug, Deserialize)]
9417pub struct MediaListQuery {
9418    /// 1-based page number. Out-of-range values clamp to the last page.
9419    #[serde(default)]
9420    pub page: Option<i64>,
9421    /// Rows per page; clamped to `admin::pagination::MAX_PER_PAGE`.
9422    #[serde(default)]
9423    pub per_page: Option<usize>,
9424    /// Filter to a specific collection. Omitted = all collections.
9425    #[serde(default)]
9426    pub collection: Option<i64>,
9427    /// Case-insensitive substring search across title, filename,
9428    /// alt_text.
9429    #[serde(default)]
9430    pub q: Option<String>,
9431    /// Date range floor — `YYYY-MM-DD`. Matches `uploaded_at >= from`.
9432    #[serde(default)]
9433    pub from: Option<String>,
9434    /// Date range ceiling — `YYYY-MM-DD`. Matches `uploaded_at <= to`
9435    /// (end of day in UTC).
9436    #[serde(default)]
9437    pub to: Option<String>,
9438}
9439
9440// =====================================================================
9441// Image hard crop (#24) — apply / clone-and-crop
9442// =====================================================================
9443
9444/// Form payload for both crop handlers. Coords are in source-image
9445/// pixel space; `mode` distinguishes apply vs clone-and-crop.
9446#[derive(Debug, Deserialize)]
9447pub struct CropForm {
9448    pub crop_x: u32,
9449    pub crop_y: u32,
9450    pub crop_w: u32,
9451    pub crop_h: u32,
9452    /// Either "apply" (destructive — overwrites source) or "clone"
9453    /// (creates a new media row from the cropped bytes).
9454    pub mode: String,
9455}
9456
9457/// POST /cms-admin/media/{id}/crop — apply the crop rect to the
9458/// source bytes. Two modes:
9459/// - `mode=apply` — replaces the row's bytes in-place, bumps
9460///   content_hash, recomputes width/height, purges every rendition
9461///   for the old hash. Destructive — the original bytes are gone.
9462/// - `mode=clone` — creates a new media row whose bytes are the
9463///   cropped output. Original row is untouched. New row inherits
9464///   title (" — crop" suffix) + alt_text + collection_id; focal
9465///   point clears so the editor re-marks on the crop.
9466pub async fn media_crop_submit(
9467    State(_state): State<super::AdminState>,
9468    tenant: Tenant,
9469    headers: HeaderMap,
9470    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9471    Path(id): Path<i64>,
9472    Form(form): Form<CropForm>,
9473) -> Result<Response, AdminError> {
9474    use rustango::sql::Auto;
9475    let mut media = Media::objects()
9476        .where_(Media::id.eq(id))
9477        .first(tenant.pool())
9478        .await?
9479        .ok_or(AdminError::NotFound(id))?;
9480    if media.kind != "image" {
9481        return Err(AdminError::Validation(
9482            "Crop applies to images only.".to_owned(),
9483        ));
9484    }
9485
9486    let bytes = crate::media_storage::disk_for(&tenant.org.slug)
9487        .load(&crate::media_storage::key(
9488            &tenant.org.slug,
9489            &media.storage_key,
9490        ))
9491        .await
9492        .map_err(|e| AdminError::Validation(format!("read source: {e}")))?;
9493    let (cropped_bytes, out_mime) = crate::rendition::crop_image_off_runtime(
9494        bytes,
9495        media.mime.clone(),
9496        (form.crop_x, form.crop_y, form.crop_w, form.crop_h),
9497    )
9498    .await
9499    .map_err(AdminError::Validation)?;
9500
9501    let new_hash = {
9502        use sha2::Digest;
9503        let mut hasher = sha2::Sha256::new();
9504        hasher.update(&cropped_bytes);
9505        let digest = hasher.finalize();
9506        let mut hex = String::with_capacity(digest.len() * 2);
9507        for b in digest.iter() {
9508            hex.push_str(&format!("{b:02x}"));
9509        }
9510        hex
9511    };
9512
9513    match form.mode.as_str() {
9514        "apply" => {
9515            // In-place: overwrite the same storage_key. The backend
9516            // writes the object wholesale (atomic PUT on S3), which
9517            // replaces the old tmp-file + rename dance.
9518            crate::media_storage::disk_for(&tenant.org.slug)
9519                .save(
9520                    &crate::media_storage::key(&tenant.org.slug, &media.storage_key),
9521                    &cropped_bytes,
9522                )
9523                .await
9524                .map_err(|e| AdminError::Validation(format!("write crop: {e}")))?;
9525            let old_hash = media.content_hash.clone();
9526            media.content_hash = new_hash;
9527            media.size = cropped_bytes.len() as i64;
9528            media.mime = out_mime;
9529            media.width = Some(form.crop_w as i32);
9530            media.height = Some(form.crop_h as i32);
9531            // Focal point in original coords no longer maps; clear.
9532            media.focal_point_x = None;
9533            media.focal_point_y = None;
9534            media.save_pool(tenant.pool()).await?;
9535
9536            // Purge renditions for the OLD content_hash (the route
9537            // looks them up by hash + filter spec; bytes on disk
9538            // also need cleaning).
9539            for r in crate::rendition::MediaRendition::objects()
9540                .where_(crate::rendition::MediaRendition::content_hash.eq(old_hash))
9541                .fetch(tenant.pool())
9542                .await?
9543            {
9544                crate::media_storage::disk_for(&tenant.org.slug)
9545                    .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
9546                    .await
9547                    .log_warn("stored file not deleted; the blob is orphaned");
9548                r.delete_pool(tenant.pool()).await?;
9549            }
9550            let crop_w = form.crop_w.to_string();
9551            let crop_h = form.crop_h.to_string();
9552            redirect_named_with_params_and_message_args(
9553                "rcms-admin:media:edit",
9554                &[("id", id.to_string())],
9555                MsgLevel::Success,
9556                "Crop applied. New dimensions {width}×{height}; renditions purged.",
9557                &[("width", crop_w.as_str()), ("height", crop_h.as_str())],
9558                &headers,
9559            )
9560        }
9561        "clone" => {
9562            // Save as new. Fresh storage_key under the source's
9563            // content-hash prefix so the on-disk bytes are
9564            // discoverable. Suffix the title with " — crop" so the
9565            // new row reads distinctly in lists.
9566            let ext = match out_mime.as_str() {
9567                "image/jpeg" => "jpg",
9568                "image/webp" => "webp",
9569                _ => "png",
9570            };
9571            let new_key = format!("{}-crop-{}.{ext}", &new_hash[..16.min(new_hash.len())], id);
9572            crate::media_storage::disk_for(&tenant.org.slug)
9573                .save(
9574                    &crate::media_storage::key(&tenant.org.slug, &new_key),
9575                    &cropped_bytes,
9576                )
9577                .await
9578                .map_err(|e| AdminError::Validation(format!("write clone: {e}")))?;
9579
9580            let clone_title = if media.title.contains(" — crop") {
9581                media.title.clone()
9582            } else {
9583                format!("{} — crop", media.title)
9584            };
9585            let mut clone = Media {
9586                id: Auto::Unset,
9587                filename: format!(
9588                    "{}.crop.{ext}",
9589                    std::path::Path::new(&media.filename)
9590                        .file_stem()
9591                        .map(|s| s.to_string_lossy().to_string())
9592                        .unwrap_or_else(|| "crop".to_owned())
9593                ),
9594                content_hash: new_hash,
9595                mime: out_mime,
9596                size: cropped_bytes.len() as i64,
9597                kind: "image".to_owned(),
9598                width: Some(form.crop_w as i32),
9599                height: Some(form.crop_h as i32),
9600                storage_key: new_key,
9601                title: clone_title,
9602                alt_text: media.alt_text.clone(),
9603                description: media.description.clone(),
9604                uploaded_by: media.uploaded_by,
9605                collection_id: media.collection_id,
9606                focal_point_x: None,
9607                focal_point_y: None,
9608                uploaded_at: Auto::Unset,
9609            };
9610            clone.insert_pool(tenant.pool()).await?;
9611            let new_id = clone.id.get().copied().unwrap_or_default();
9612            let new_id_str = new_id.to_string();
9613            let crop_w = form.crop_w.to_string();
9614            let crop_h = form.crop_h.to_string();
9615            redirect_named_with_params_and_message_args(
9616                "rcms-admin:media:edit",
9617                &[("id", new_id.to_string())],
9618                MsgLevel::Success,
9619                "Saved cropped clone as new media #{id} ({width}×{height}).",
9620                &[
9621                    ("id", new_id_str.as_str()),
9622                    ("width", crop_w.as_str()),
9623                    ("height", crop_h.as_str()),
9624                ],
9625                &headers,
9626            )
9627        }
9628        other => Err(AdminError::Validation(format!(
9629            "Unknown crop mode `{other}` — expected `apply` or `clone`."
9630        ))),
9631    }
9632}
9633
9634// =====================================================================
9635// Image replace (#190)
9636// =====================================================================
9637
9638/// POST /cms-admin/media/{id}/replace — re-upload bytes for an existing
9639/// media row. Keeps the row id (so every page that references it stays
9640/// linked) and the editorial metadata (title, alt_text). Updates the
9641/// physical fields: storage_key, content_hash, mime, size, width,
9642/// height, filename. Focal point survives unless the new dimensions
9643/// require it to be clamped — it's stored as a 0..1 fraction so it
9644/// already scales across resizes.
9645///
9646/// Old on-disk bytes are best-effort deleted; every cached rendition
9647/// for the old content_hash is purged so subsequent requests
9648/// regenerate from the replacement.
9649pub async fn media_replace_submit(
9650    State(_state): State<super::AdminState>,
9651    tenant: Tenant,
9652    headers: HeaderMap,
9653    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9654    Path(id): Path<i64>,
9655    mut multipart: axum::extract::Multipart,
9656) -> Result<Response, AdminError> {
9657    use sha2::{Digest, Sha256};
9658
9659    let mut media = Media::objects()
9660        .where_(Media::id.eq(id))
9661        .first(tenant.pool())
9662        .await?
9663        .ok_or(AdminError::NotFound(id))?;
9664
9665    let mut filename = String::new();
9666    let mut bytes: Vec<u8> = Vec::new();
9667    while let Some(field) = multipart
9668        .next_field()
9669        .await
9670        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
9671    {
9672        if field.name().unwrap_or("") == "file" {
9673            if let Some(fname) = field.file_name() {
9674                filename = sanitize_filename(fname);
9675            }
9676            bytes = field
9677                .bytes()
9678                .await
9679                .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
9680                .to_vec();
9681        } else {
9682            let _ = field.bytes().await;
9683        }
9684    }
9685    if filename.is_empty() || bytes.is_empty() {
9686        return Err(AdminError::Upload("no file submitted".into()));
9687    }
9688
9689    let new_mime = mime_guess::from_path(&filename)
9690        .first_or_octet_stream()
9691        .essence_str()
9692        .to_owned();
9693    refuse_active_upload(&new_mime)?;
9694    // Replacing an image with a non-image (or vice versa) would
9695    // silently break every consumer that branches on `kind`.
9696    let new_kind = Media::classify_mime(&new_mime).to_owned();
9697    if new_kind != media.kind {
9698        return Err(AdminError::Validation(format!(
9699            "Replacement kind `{new_kind}` does not match existing `{}` — replace must keep the media type.",
9700            media.kind
9701        )));
9702    }
9703
9704    // EXIF strip + decode for dimensions, same as the upload path.
9705    let (stored, decoded_dims) =
9706        crate::rendition::strip_exif_off_runtime(bytes, new_mime.clone()).await;
9707    bytes = stored;
9708
9709    let mut hasher = Sha256::new();
9710    hasher.update(&bytes);
9711    let digest = hasher.finalize();
9712    let new_hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
9713        use std::fmt::Write as _;
9714        let _ = write!(acc, "{b:02x}");
9715        acc
9716    });
9717
9718    let new_storage_key = format!("{}-{}", &new_hash[..16.min(new_hash.len())], filename);
9719    crate::media_storage::disk_for(&tenant.org.slug)
9720        .save(
9721            &crate::media_storage::key(&tenant.org.slug, &new_storage_key),
9722            &bytes,
9723        )
9724        .await
9725        .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
9726
9727    let old_storage_key = media.storage_key.clone();
9728    let old_hash = media.content_hash.clone();
9729
9730    let (new_w, new_h): (Option<i32>, Option<i32>) = decoded_dims
9731        .map(|(w, h)| (Some(w as i32), Some(h as i32)))
9732        .unwrap_or((None, None));
9733
9734    media.filename = filename;
9735    media.storage_key = new_storage_key;
9736    media.content_hash = new_hash;
9737    media.mime = new_mime;
9738    media.size = bytes.len() as i64;
9739    media.width = new_w;
9740    media.height = new_h;
9741    media.save_pool(tenant.pool()).await?;
9742
9743    // Best-effort cleanup of the old file on disk. Only remove when
9744    // the storage_key actually changed — content-addressed naming
9745    // means an identical replacement reuses the same path.
9746    if old_storage_key != media.storage_key {
9747        crate::media_storage::disk_for(&tenant.org.slug)
9748            .delete(&crate::media_storage::key(
9749                &tenant.org.slug,
9750                &old_storage_key,
9751            ))
9752            .await
9753            .log_warn("stored file not deleted; the blob is orphaned");
9754    }
9755
9756    // Purge renditions for the old content_hash so the next request
9757    // regenerates from the replacement bytes.
9758    if old_hash != media.content_hash {
9759        for r in crate::rendition::MediaRendition::objects()
9760            .where_(crate::rendition::MediaRendition::content_hash.eq(old_hash))
9761            .fetch(tenant.pool())
9762            .await?
9763        {
9764            crate::media_storage::disk_for(&tenant.org.slug)
9765                .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
9766                .await
9767                .log_warn("stored file not deleted; the blob is orphaned");
9768            r.delete_pool(tenant.pool()).await?;
9769        }
9770    }
9771
9772    redirect_named_with_params_and_message(
9773        "rcms-admin:media:edit",
9774        &[("id", id.to_string())],
9775        MsgLevel::Success,
9776        "Replaced. Old renditions purged; every page referencing this image now serves the new bytes.",
9777        &headers,
9778    )
9779}
9780
9781// =====================================================================
9782// Image focal point (#4)
9783// =====================================================================
9784
9785/// GET /cms-admin/media/{id}/edit — image detail page with the
9786/// focal-point picker. Image-only; other kinds return 404.
9787/// Locate every page that references `media_id`. Returns
9788/// `(page_id, page_title, url_path, status)` rows. Scan reuses the
9789/// `harvest_media_ids` helper that powers `media_unused_report`,
9790/// inverted so we collect per-page hits instead of building a
9791/// tenant-wide used-set.
9792async fn pages_referencing_media(
9793    pool: &rustango::sql::Pool,
9794    media_id: i64,
9795) -> Result<Vec<(i64, String, String, String)>, rustango::sql::ExecError> {
9796    let pages: Vec<Page> = Page::objects().fetch(pool).await?;
9797    let mut hits: Vec<(i64, String, String, String)> = Vec::new();
9798    for p in &pages {
9799        let page_id = p.id.get().copied().unwrap_or_default();
9800        if page_id == 0 {
9801            continue;
9802        }
9803        let mut ids = std::collections::BTreeSet::new();
9804        // Walk the canonical page JSON first (defensive).
9805        if let Ok(v) = serde_json::to_value(p) {
9806            harvest_media_ids(&v, &mut ids);
9807        }
9808        // Walk the page-type extension JSON (hero_media_id +
9809        // stream-block image refs).
9810        if let Ok(pts) = PageType::objects()
9811            .where_(PageType::id.eq(p.page_type_id))
9812            .fetch(pool)
9813            .await
9814        {
9815            if let Some(pt_row) = pts.into_iter().next() {
9816                if let Some(handler) = crate::page_type::find_handler(&pt_row.type_name) {
9817                    if let Ok(ext) = handler.load_extension(pool, page_id).await {
9818                        harvest_media_ids(&ext, &mut ids);
9819                    }
9820                }
9821            }
9822        }
9823        if ids.contains(&media_id) {
9824            hits.push((
9825                page_id,
9826                p.title.clone(),
9827                p.url_path.clone(),
9828                p.status.clone(),
9829            ));
9830        }
9831    }
9832    Ok(hits)
9833}
9834
9835pub async fn media_edit_form(
9836    State(state): State<super::AdminState>,
9837    tenant: Tenant,
9838    headers: HeaderMap,
9839    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
9840    Path(id): Path<i64>,
9841) -> Result<Response, AdminError> {
9842    let media = Media::objects()
9843        .where_(Media::id.eq(id))
9844        .first(tenant.pool())
9845        .await?
9846        .ok_or(AdminError::NotFound(id))?;
9847    if media.kind != "image" {
9848        return Err(AdminError::NotFound(id));
9849    }
9850    // #100 — per-image usage report.
9851    let usages = pages_referencing_media(tenant.pool(), id)
9852        .await
9853        .unwrap_or_default();
9854    let usage_rows: Vec<serde_json::Value> = usages
9855        .iter()
9856        .map(|(pid, title, url_path, status)| {
9857            serde_json::json!({
9858                "id": pid,
9859                "title": title,
9860                "url_path": url_path,
9861                "status": status,
9862            })
9863        })
9864        .collect();
9865    let mut ctx = Context::new();
9866    add_chrome(&mut ctx, &tenant, "media", session_user.as_ref()).await;
9867    add_admin_theme(&mut ctx, tenant.pool()).await;
9868    ctx.insert(
9869        "media",
9870        &serde_json::json!({
9871            "id": media.id.get().copied(),
9872            "title": media.title,
9873            "filename": media.filename,
9874            "alt_text": media.alt_text,
9875            "description": media.description,
9876            "mime": media.mime,
9877            "size": media.size,
9878            "width": media.width,
9879            "height": media.height,
9880            "focal_point_x": media.focal_point_x,
9881            "focal_point_y": media.focal_point_y,
9882            "uploaded_at": media.uploaded_at.get().copied(),
9883            // Cache-buster for the `rcms_image_url(..., v=media.content_hash)`
9884            // call in the template — without this the focal-point
9885            // preview never picks up an in-place re-crop.
9886            "content_hash": media.content_hash,
9887        }),
9888    );
9889    ctx.insert("usages", &usage_rows);
9890    ctx.insert("usage_count", &(usage_rows.len() as i64));
9891    render_with_csrf(&state, &headers, "rcms_admin/media_edit.html", &mut ctx)
9892}
9893
9894/// Form payload for the focal-point editor. All four fields
9895/// arrive as strings from the HTML form; we parse + validate
9896/// server-side. A submission with empty x/y clears the focal point.
9897#[derive(Debug, Deserialize)]
9898pub struct MediaEditForm {
9899    pub title: String,
9900    pub alt_text: String,
9901    #[serde(default)]
9902    pub description: String,
9903    #[serde(default)]
9904    pub focal_point_x: Option<String>,
9905    #[serde(default)]
9906    pub focal_point_y: Option<String>,
9907}
9908
9909/// POST /cms-admin/media/{id}/edit — save title / alt + focal point.
9910/// When the focal point changes, every cached rendition for this
9911/// media row is purged so subsequent requests regenerate around the
9912/// new center.
9913pub async fn media_edit_submit(
9914    State(_state): State<super::AdminState>,
9915    tenant: Tenant,
9916    headers: HeaderMap,
9917    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
9918    Path(id): Path<i64>,
9919    Form(form): Form<MediaEditForm>,
9920) -> Result<Response, AdminError> {
9921    let mut media = Media::objects()
9922        .where_(Media::id.eq(id))
9923        .first(tenant.pool())
9924        .await?
9925        .ok_or(AdminError::NotFound(id))?;
9926    if media.kind != "image" {
9927        return Err(AdminError::NotFound(id));
9928    }
9929    media.title = form.title.trim().to_owned();
9930    media.alt_text = form.alt_text.trim().to_owned();
9931    media.description = form.description.trim().to_owned();
9932
9933    let parse_fraction = |raw: Option<&str>| -> Option<f32> {
9934        raw.map(str::trim)
9935            .filter(|s| !s.is_empty())
9936            .and_then(|s| s.parse::<f32>().ok())
9937            .map(|f| f.clamp(0.0, 1.0))
9938    };
9939    let new_x = parse_fraction(form.focal_point_x.as_deref());
9940    let new_y = parse_fraction(form.focal_point_y.as_deref());
9941    let focal_changed = media.focal_point_x != new_x || media.focal_point_y != new_y;
9942    media.focal_point_x = new_x;
9943    media.focal_point_y = new_y;
9944    media.save_pool(tenant.pool()).await?;
9945
9946    // Invalidate rendition cache rows + delete their on-disk bytes
9947    // so subsequent requests regenerate with the new focal point.
9948    if focal_changed {
9949        let renditions: Vec<crate::rendition::MediaRendition> =
9950            crate::rendition::MediaRendition::objects()
9951                .where_(
9952                    crate::rendition::MediaRendition::content_hash.eq(media.content_hash.clone()),
9953                )
9954                .fetch(tenant.pool())
9955                .await?;
9956        for r in renditions {
9957            // Best-effort delete of the on-disk bytes; the DB row
9958            // delete is what counts (next render miss regenerates).
9959            crate::media_storage::disk_for(&tenant.org.slug)
9960                .delete(&crate::media_storage::key(&tenant.org.slug, &r.storage_key))
9961                .await
9962                .log_warn("stored file not deleted; the blob is orphaned");
9963            r.delete_pool(tenant.pool()).await?;
9964        }
9965    }
9966    redirect_named_with_params_and_message(
9967        "rcms-admin:media:edit",
9968        &[("id", id.to_string())],
9969        MsgLevel::Success,
9970        if focal_changed {
9971            "Saved. Renditions purged — next request regenerates with the new focal point."
9972        } else {
9973            "Saved."
9974        },
9975        &headers,
9976    )
9977}
9978
9979/// Recursively scan a JSON value for any string that contains
9980/// `needle` (already lowercased). Used by admin search to
9981/// broaden recall into page-type extension fields without listing
9982/// every key on the handler trait.
9983fn json_contains_needle(value: &serde_json::Value, needle: &str) -> bool {
9984    match value {
9985        serde_json::Value::String(s) => {
9986            if s.to_lowercase().contains(needle) {
9987                return true;
9988            }
9989            // Stream-block extension columns sometimes hold a JSON
9990            // array as a string — peek through if it looks like one.
9991            let trimmed = s.trim_start();
9992            if trimmed.starts_with('[') || trimmed.starts_with('{') {
9993                if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(s) {
9994                    return json_contains_needle(&parsed, needle);
9995                }
9996            }
9997            false
9998        }
9999        serde_json::Value::Array(arr) => arr.iter().any(|v| json_contains_needle(v, needle)),
10000        serde_json::Value::Object(map) => map.values().any(|v| json_contains_needle(v, needle)),
10001        _ => false,
10002    }
10003}
10004
10005/// Recursively walk `value` (the JSON shape of a page's extension
10006/// row, plus any nested stream-block JSON we find as string values)
10007/// and collect every `media_id` reference. Catches:
10008///
10009/// - Direct `media_id` / `hero_media_id` / `*_media_id` fields on
10010///   the extension table (any object key matching `media_id` or
10011///   ending in `_media_id`).
10012/// - Stream-block image references: extension rows store the
10013///   `body_stream` column as a JSON string; we detect string values
10014///   that look like JSON and recurse into the parsed array.
10015/// - IDs stored as numbers OR strings — HTML forms submit text, so
10016///   stream-block `media_id` values land as strings in the JSON.
10017fn harvest_media_ids(value: &serde_json::Value, out: &mut std::collections::BTreeSet<i64>) {
10018    use serde_json::Value;
10019    match value {
10020        Value::Object(map) => {
10021            for (key, child) in map {
10022                let is_media_key = key == "media_id" || key.ends_with("_media_id");
10023                if is_media_key {
10024                    match child {
10025                        Value::Number(n) => {
10026                            if let Some(id) = n.as_i64() {
10027                                if id > 0 {
10028                                    out.insert(id);
10029                                }
10030                            }
10031                        }
10032                        Value::String(s) => {
10033                            if let Ok(id) = s.parse::<i64>() {
10034                                if id > 0 {
10035                                    out.insert(id);
10036                                }
10037                            }
10038                        }
10039                        _ => harvest_media_ids(child, out),
10040                    }
10041                } else {
10042                    harvest_media_ids(child, out);
10043                }
10044            }
10045        }
10046        Value::Array(arr) => {
10047            for item in arr {
10048                harvest_media_ids(item, out);
10049            }
10050        }
10051        Value::String(s) => {
10052            let trimmed = s.trim_start();
10053            if trimmed.starts_with('[') || trimmed.starts_with('{') {
10054                if let Ok(parsed) = serde_json::from_str::<Value>(s) {
10055                    harvest_media_ids(&parsed, out);
10056                }
10057            }
10058        }
10059        _ => {}
10060    }
10061}
10062
10063/// GET /cms-admin/media/unused — list `cms_media` rows that no page
10064/// references. Builds a reverse index by walking every page's
10065/// extension JSON for `media_id` keys, then diffs against the full
10066/// media table. Used by editors to garbage-collect stale uploads.
10067pub async fn media_unused_report(
10068    State(state): State<super::AdminState>,
10069    tenant: Tenant,
10070    headers: HeaderMap,
10071    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10072) -> Result<Response, AdminError> {
10073    let all_media: Vec<Media> = Media::objects()
10074        .order_by(&[("uploaded_at", true)])
10075        .fetch(tenant.pool())
10076        .await?;
10077    let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
10078
10079    let mut used: std::collections::BTreeSet<i64> = std::collections::BTreeSet::new();
10080
10081    // 1) Page rows themselves carry no media_id columns today, but
10082    //    we walk the JSON-serialized page anyway for defense-in-depth
10083    //    — a future column would auto-surface.
10084    for p in &pages {
10085        if let Ok(v) = serde_json::to_value(p) {
10086            harvest_media_ids(&v, &mut used);
10087        }
10088    }
10089
10090    // 2) Extension rows: every PageType handler loads its own
10091    //    extension row. The default impl returns Value::Null for
10092    //    unit-struct types; ours returns the row as JSON (including
10093    //    body_stream as a string we recurse into).
10094    for p in &pages {
10095        let page_id = p.id.get().copied().unwrap_or_default();
10096        // Resolve the PageType row → type_name → handler.
10097        // page_type lookup is cheap; tenants have a handful of types.
10098        let pt: Vec<crate::page_type_model::PageType> = crate::page_type_model::PageType::objects()
10099            .where_(crate::page_type_model::PageType::id.eq(p.page_type_id))
10100            .fetch(tenant.pool())
10101            .await?;
10102        let Some(pt_row) = pt.into_iter().next() else {
10103            continue;
10104        };
10105        let Some(handler) = crate::page_type::find_handler(&pt_row.type_name) else {
10106            continue;
10107        };
10108        if let Ok(ext_value) = handler.load_extension(tenant.pool(), page_id).await {
10109            harvest_media_ids(&ext_value, &mut used);
10110        }
10111    }
10112
10113    // 3) Diff: media rows whose ID isn't in the used set are unused.
10114    let unused: Vec<&Media> = all_media
10115        .iter()
10116        .filter(|m| m.id.get().copied().is_some_and(|id| !used.contains(&id)))
10117        .collect();
10118
10119    let unused_view: Vec<serde_json::Value> = unused
10120        .iter()
10121        .map(|m| {
10122            serde_json::json!({
10123                "id": m.id.get().copied(),
10124                "title": m.title,
10125                "filename": m.filename,
10126                "kind": m.kind,
10127                "mime": m.mime,
10128                "size": m.size,
10129                "uploaded_at": m.uploaded_at.get().copied(),
10130                "uploaded_by": m.uploaded_by,
10131            })
10132        })
10133        .collect();
10134
10135    let mut ctx = Context::new();
10136    add_chrome(&mut ctx, &tenant, "media-unused", session_user.as_ref()).await;
10137    add_admin_theme(&mut ctx, tenant.pool()).await;
10138    ctx.insert("unused", &unused_view);
10139    ctx.insert("total_media", &all_media.len());
10140    ctx.insert("used_count", &used.len());
10141    render_with_csrf(&state, &headers, "rcms_admin/media_unused.html", &mut ctx)
10142}
10143
10144/// POST /cms-admin/media/unused/delete — bulk-delete the chosen
10145/// media rows. Receives a list of `id=N` form fields and deletes
10146/// each in sequence. The handler does NOT re-verify "unused" status
10147/// — that's the editor's job — but it stays well-behaved because
10148/// the form template only renders rows that ARE currently unused.
10149pub async fn media_unused_bulk_delete(
10150    State(_state): State<super::AdminState>,
10151    tenant: Tenant,
10152    headers: HeaderMap,
10153    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
10154    Form(form): Form<Vec<(String, String)>>,
10155) -> Result<Response, AdminError> {
10156    use rustango::sql::Auto;
10157    let ids: Vec<i64> = form
10158        .iter()
10159        .filter(|(k, _)| k == "id" || k == "ids")
10160        .filter_map(|(_, v)| v.parse::<i64>().ok())
10161        .collect();
10162    let mut deleted = 0usize;
10163    for id in ids {
10164        let row = Media::objects()
10165            .where_(Media::id.eq(id))
10166            .first(tenant.pool())
10167            .await?;
10168        if let Some(m) = row {
10169            // Use Model::delete_pool via the row instance.
10170            // The framework's Auto wrapper holds the id; deletion
10171            // through the row resolves it cleanly.
10172            let _ = Auto::Unset::<i64>; // silence unused-import lint
10173            m.delete_pool(tenant.pool()).await?;
10174            deleted += 1;
10175        }
10176    }
10177    redirect_named_with_message_plural(
10178        "rcms-admin:media:unused",
10179        MsgLevel::Success,
10180        "Deleted {count} unused media item(s).",
10181        deleted as i64,
10182        &[("count", &deleted.to_string())],
10183        &headers,
10184    )
10185}
10186
10187/// GET /cms-admin/media — list `cms_media` rows where `kind = 'image'`.
10188pub async fn media_list(
10189    State(state): State<super::AdminState>,
10190    tenant: Tenant,
10191    headers: HeaderMap,
10192    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10193    Query(q): Query<MediaListQuery>,
10194    axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
10195) -> Result<Response, AdminError> {
10196    // #142 — opportunistic scratch-upload sweep. Roughly 2% of
10197    // media-list visits trigger a stale-row GC so dead scratch uploads
10198    // don't accumulate. Best-effort: file unlink errors log + continue.
10199    if rand::random::<u8>() < 5 {
10200        if let Ok(unlinked) = crate::uploaded_file::gc_stale(tenant.pool()).await {
10201            for key in unlinked {
10202                crate::media_storage::disk_for(&tenant.org.slug)
10203                    .delete(&crate::media_storage::key(&tenant.org.slug, &key))
10204                    .await
10205                    .log_warn("stored file not deleted; the blob is orphaned");
10206            }
10207        }
10208    }
10209    render_media_list(
10210        &state,
10211        &tenant,
10212        &headers,
10213        session_user.as_ref(),
10214        "image",
10215        q,
10216        raw_query,
10217    )
10218    .await
10219}
10220
10221/// GET /cms-admin/documents — same view filtered to non-image kinds.
10222pub async fn documents_list(
10223    State(state): State<super::AdminState>,
10224    tenant: Tenant,
10225    headers: HeaderMap,
10226    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10227    Query(q): Query<MediaListQuery>,
10228    axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
10229) -> Result<Response, AdminError> {
10230    render_media_list(
10231        &state,
10232        &tenant,
10233        &headers,
10234        session_user.as_ref(),
10235        "document",
10236        q,
10237        raw_query,
10238    )
10239    .await
10240}
10241
10242/// Shared list renderer for the image / document views. `kind` is
10243/// the discriminator on `cms_media.kind` ("image" / "document").
10244async fn render_media_list(
10245    state: &super::AdminState,
10246    tenant: &Tenant,
10247    headers: &HeaderMap,
10248    session_user: Option<&rustango::tenancy::auth::User>,
10249    kind: &str,
10250    filters: MediaListQuery,
10251    raw_query: Option<String>,
10252) -> Result<Response, AdminError> {
10253    let collection_filter = filters.collection;
10254    let search = filters
10255        .q
10256        .as_deref()
10257        .map(str::trim)
10258        .filter(|s| !s.is_empty())
10259        .map(str::to_lowercase);
10260    let from_filter = parse_date_floor(filters.from.as_deref());
10261    let to_filter = parse_date_ceil(filters.to.as_deref());
10262    // Fetch every media row + every collection once. Collection
10263    // count is small (a handful per tenant); media count is bounded
10264    // by what fits comfortably in the admin list. Walk in Rust.
10265    let all: Vec<Media> = Media::objects()
10266        .order_by(&[("uploaded_at", true)])
10267        .fetch(tenant.pool())
10268        .await?;
10269    let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
10270        .order_by(&[("sort_order", false), ("name", false)])
10271        .fetch(tenant.pool())
10272        .await?;
10273
10274    let items: Vec<&Media> = all
10275        .iter()
10276        .filter(|m| {
10277            let kind_match = if kind == "image" {
10278                m.kind == "image"
10279            } else {
10280                m.kind != "image"
10281            };
10282            let collection_match = match collection_filter {
10283                None => true,
10284                Some(cid) => m.collection_id == Some(cid),
10285            };
10286            let search_match = match &search {
10287                None => true,
10288                Some(needle) => {
10289                    m.title.to_lowercase().contains(needle)
10290                        || m.filename.to_lowercase().contains(needle)
10291                        || m.alt_text.to_lowercase().contains(needle)
10292                }
10293            };
10294            let date_match = m.uploaded_at.get().is_none_or(|when| {
10295                let after_from = from_filter.is_none_or(|floor| *when >= floor);
10296                let before_to = to_filter.is_none_or(|ceil| *when <= ceil);
10297                after_from && before_to
10298            });
10299            kind_match && collection_match && search_match && date_match
10300        })
10301        .collect();
10302
10303    // Paginate the filtered set, so a large library renders one page of
10304    // cards and thumbnails. The fetch above is still unbounded: filtering
10305    // happens in Rust so the case-insensitive search behaves the same on
10306    // SQLite, Postgres and MySQL (bare LIKE does not) — see #632.
10307    let per_page = crate::admin::pagination::clamp_per_page(filters.per_page);
10308    let requested_page = filters.page.unwrap_or(1);
10309    let total_items = items.len();
10310    let pagination = crate::admin::pagination::context(requested_page, per_page, total_items);
10311    let current_page = pagination["page"].as_i64().unwrap_or(1);
10312    let skip = crate::admin::pagination::offset(current_page, per_page) as usize;
10313    let items: Vec<&Media> = items.into_iter().skip(skip).take(per_page).collect();
10314
10315    // Count per collection so the sidebar shows "(N)" beside each
10316    // name. We count for the CURRENT kind only so the badges line
10317    // up with the filtered view the editor is looking at.
10318    let mut counts: std::collections::HashMap<Option<i64>, i64> = std::collections::HashMap::new();
10319    for m in &all {
10320        let in_kind = if kind == "image" {
10321            m.kind == "image"
10322        } else {
10323            m.kind != "image"
10324        };
10325        if in_kind {
10326            *counts.entry(m.collection_id).or_insert(0) += 1;
10327        }
10328    }
10329
10330    let collections_view: Vec<serde_json::Value> = collections
10331        .iter()
10332        .map(|c| {
10333            let id = c.id.get().copied();
10334            serde_json::json!({
10335                "id": id,
10336                "name": c.name,
10337                "parent_id": c.parent_id,
10338                "count": id.and_then(|i| counts.get(&Some(i)).copied()).unwrap_or(0),
10339            })
10340        })
10341        .collect();
10342    let uncategorized_count = counts.get(&None).copied().unwrap_or(0);
10343
10344    let mut ctx = Context::new();
10345    let active_tab = if kind == "image" {
10346        "media"
10347    } else {
10348        "documents"
10349    };
10350    add_chrome(&mut ctx, tenant, active_tab, session_user).await;
10351    add_admin_theme(&mut ctx, tenant.pool()).await;
10352    ctx.insert("items", &items);
10353    ctx.insert("collections", &collections_view);
10354    ctx.insert("collection_filter", &collection_filter);
10355    ctx.insert("uncategorized_count", &uncategorized_count);
10356    ctx.insert("search_q", &filters.q);
10357    ctx.insert("date_from", &filters.from);
10358    ctx.insert("date_to", &filters.to);
10359    ctx.insert(
10360        "is_filtered",
10361        &(collection_filter.is_some()
10362            || search.is_some()
10363            || from_filter.is_some()
10364            || to_filter.is_some()),
10365    );
10366    // The full match count, not the size of the visible page.
10367    ctx.insert("filtered_count", &total_items);
10368    ctx.insert("pagination", &pagination);
10369    ctx.insert(
10370        "kind_label",
10371        if kind == "image" {
10372            "Media (images)"
10373        } else {
10374            "Documents"
10375        },
10376    );
10377    ctx.insert(
10378        "upload_kind",
10379        if kind == "image" { "image" } else { "document" },
10380    );
10381    ctx.insert(
10382        "self_url",
10383        if kind == "image" {
10384            "/cms-admin/media"
10385        } else {
10386            "/cms-admin/documents"
10387        },
10388    );
10389    // #316 — raw query string for the `| querystring(collection=…)` rail
10390    // links: they preserve the q / from / to filters and just set or
10391    // clear `collection` (media has no page param). `qs_none` is a null
10392    // sentinel — Tera has no `null` literal, so `querystring(k=qs_none)`
10393    // is how the template drops a key.
10394    ctx.insert("query_string", &raw_query.unwrap_or_default());
10395    ctx.insert("qs_none", &serde_json::Value::Null);
10396    render_with_csrf(state, headers, "rcms_admin/media_list.html", &mut ctx)
10397}
10398
10399/// GET /cms-admin/media/upload — upload form.
10400pub async fn media_upload_form(
10401    State(state): State<super::AdminState>,
10402    tenant: Tenant,
10403    headers: HeaderMap,
10404    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10405    Query(q): Query<UploadFormQuery>,
10406) -> Result<Response, AdminError> {
10407    let kind_label = if q.kind.as_deref() == Some("document") {
10408        "Documents"
10409    } else {
10410        "Media (images)"
10411    };
10412    let mut ctx = Context::new();
10413    add_chrome(
10414        &mut ctx,
10415        &tenant,
10416        if q.kind.as_deref() == Some("document") {
10417            "documents"
10418        } else {
10419            "media"
10420        },
10421        session_user.as_ref(),
10422    )
10423    .await;
10424    // Collections picker (#188) — pass into ctx so each queue row
10425    // can render a per-file dropdown without a follow-up fetch.
10426    let collections: Vec<crate::media::MediaCollection> = crate::media::MediaCollection::objects()
10427        .order_by(&[("sort_order", false), ("name", false)])
10428        .fetch(tenant.pool())
10429        .await?;
10430    let collections_view: Vec<serde_json::Value> = collections
10431        .iter()
10432        .map(|c| {
10433            serde_json::json!({
10434                "id": c.id.get().copied(),
10435                "name": c.name,
10436            })
10437        })
10438        .collect();
10439    ctx.insert("collections", &collections_view);
10440    ctx.insert("kind_label", kind_label);
10441    ctx.insert("upload_kind", &q.kind.as_deref().unwrap_or("image"));
10442    render_with_csrf(&state, &headers, "rcms_admin/media_upload.html", &mut ctx)
10443}
10444
10445#[derive(Debug, Deserialize)]
10446pub struct UploadFormQuery {
10447    #[serde(default)]
10448    pub kind: Option<String>,
10449}
10450
10451/// POST /cms-admin/media/upload — accept a multipart upload, hash
10452/// the bytes, drop them through the tenant `Storage` backend, and
10453/// stamp a `cms_media` row.
10454/// POST /cms-admin/media/upload-staged — write bytes to scratch
10455/// storage + return JSON `{id, filename, mime, size}`.
10456/// Returned `id` is the [`crate::uploaded_file::UploadedFile`]
10457/// row to commit / cancel later.
10458///
10459/// Coexists with the existing single-step `media_upload_submit` — that
10460/// path keeps working unchanged. Use this endpoint for future
10461/// drag-drop / multi-file UIs where bytes need to land before
10462/// metadata is collected.
10463pub async fn media_upload_staged(
10464    State(_state): State<super::AdminState>,
10465    tenant: Tenant,
10466    headers: HeaderMap,
10467    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10468    mut multipart: axum::extract::Multipart,
10469) -> Result<Response, AdminError> {
10470    use sha2::{Digest, Sha256};
10471    let Some(viewer) = session_user.as_ref() else {
10472        // #285 — XHR/fetch clients (the multi-file upload UI) used to
10473        // get the raw HTML page injected into a toast on session
10474        // expiry. Pass the request headers so the responder returns
10475        // JSON when the client sent `Accept: application/json` or
10476        // `X-Requested-With: XMLHttpRequest`.
10477        return Ok(unauthorized_no_session_for(Some(&headers)));
10478    };
10479    let viewer_id = viewer.id.get().copied().unwrap_or_default();
10480    let mut filename = String::new();
10481    let mut bytes: Vec<u8> = Vec::new();
10482    while let Some(field) = multipart
10483        .next_field()
10484        .await
10485        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
10486    {
10487        if field.name().unwrap_or("") == "file" {
10488            if let Some(fname) = field.file_name() {
10489                filename = sanitize_filename(fname);
10490            }
10491            bytes = field
10492                .bytes()
10493                .await
10494                .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
10495                .to_vec();
10496        } else {
10497            let _ = field.bytes().await;
10498        }
10499    }
10500    if filename.is_empty() || bytes.is_empty() {
10501        return Err(AdminError::Upload("no file submitted".into()));
10502    }
10503    let mut hasher = Sha256::new();
10504    hasher.update(&bytes);
10505    let digest = hasher.finalize();
10506    let hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
10507        use std::fmt::Write as _;
10508        let _ = write!(acc, "{b:02x}");
10509        acc
10510    });
10511    let mime = mime_guess::from_path(&filename)
10512        .first_or_octet_stream()
10513        .essence_str()
10514        .to_owned();
10515    refuse_active_upload(&mime)?;
10516    // #284 — dedup by content hash. If this tenant already has a
10517    // cms_media row whose `content_hash` matches the bytes the
10518    // editor just uploaded, skip writing to scratch + creating a
10519    // new UploadedFile row. The client treats the response as a
10520    // "skipped" outcome and surfaces it as a toast linking back to
10521    // the existing media row. Per-tenant query — the
10522    // `tenant.pool()` is the tenant-scoped pool, so a hash that
10523    // collides across tenants doesn't dedup across the boundary.
10524    {
10525        use rustango::core::Column as _;
10526        use rustango::sql::FetcherPool as _;
10527        let existing: Vec<crate::media::Media> = crate::media::Media::objects()
10528            .where_(crate::media::Media::content_hash.eq(hash.clone()))
10529            .fetch(tenant.pool())
10530            .await
10531            .unwrap_or_default();
10532        if let Some(existing_media) = existing.into_iter().next() {
10533            let existing_id = existing_media.id.get().copied().unwrap_or_default();
10534            let payload = serde_json::json!({
10535                "id": null,
10536                "duplicate_of": existing_id,
10537                "duplicate_title": existing_media.title,
10538                "duplicate_filename": existing_media.filename,
10539                "filename": filename,
10540                "mime": existing_media.mime,
10541                "size": existing_media.size,
10542            });
10543            return Ok((
10544                [(axum::http::header::CONTENT_TYPE, "application/json")],
10545                serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
10546            )
10547                .into_response());
10548        }
10549    }
10550    let storage_key = format!("scratch/{}-{filename}", &hash[..16]);
10551    crate::media_storage::disk_for(&tenant.org.slug)
10552        .save(
10553            &crate::media_storage::key(&tenant.org.slug, &storage_key),
10554            &bytes,
10555        )
10556        .await
10557        .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
10558    let size = bytes.len() as i64;
10559    let row = crate::uploaded_file::create(
10560        tenant.pool(),
10561        viewer_id,
10562        storage_key,
10563        filename,
10564        mime,
10565        size,
10566        hash,
10567    )
10568    .await?;
10569    let payload = serde_json::json!({
10570        "id": row.id.get().copied().unwrap_or_default(),
10571        "filename": row.original_filename,
10572        "mime": row.mime,
10573        "size": row.size,
10574    });
10575    Ok((
10576        [(axum::http::header::CONTENT_TYPE, "application/json")],
10577        serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
10578    )
10579        .into_response())
10580}
10581
10582/// One entry in the [`StagedCommitPayload`] commit grid.
10583#[derive(Debug, Deserialize)]
10584pub struct StagedCommitItem {
10585    pub uploaded_file_id: i64,
10586    #[serde(default)]
10587    pub title: String,
10588    #[serde(default)]
10589    pub alt_text: String,
10590    #[serde(default)]
10591    pub collection_id: Option<i64>,
10592}
10593
10594/// Body of `POST /cms-admin/media/upload-staged/commit`. The
10595/// editor uploaded N files into scratch storage; now this payload
10596/// names each scratch row + its editorial metadata in one
10597/// transaction-equivalent call.
10598#[derive(Debug, Deserialize)]
10599pub struct StagedCommitPayload {
10600    pub items: Vec<StagedCommitItem>,
10601}
10602
10603/// POST /cms-admin/media/upload-staged/commit — promote staged rows
10604/// to `cms_media` with per-file metadata. Each item:
10605///
10606/// 1. Loads the scratch row.
10607/// 2. Re-reads bytes from the scratch path; EXIF-strips images.
10608/// 3. Moves the file out of `scratch/` to the canonical
10609///    `<hash>-<filename>` storage_key.
10610/// 4. Inserts a `cms_media` row.
10611/// 5. Deletes the scratch DB row + (best-effort) the scratch file.
10612///
10613/// On a per-item failure, that scratch row is left in place so the
10614/// editor can retry; successful items still commit. The response is
10615/// JSON `{ committed: [media_id...], failed: [{id, error}...] }`.
10616pub async fn media_upload_staged_commit(
10617    State(_state): State<super::AdminState>,
10618    tenant: Tenant,
10619    headers: HeaderMap,
10620    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10621    Json(payload): Json<StagedCommitPayload>,
10622) -> Result<Response, AdminError> {
10623    use rustango::sql::Auto;
10624    let Some(viewer) = session_user.as_ref() else {
10625        // #285 — JSON-aware 401 for fetch clients.
10626        return Ok(unauthorized_no_session_for(Some(&headers)));
10627    };
10628    let viewer_id = viewer.id.get().copied().unwrap_or_default();
10629    let media_slug = tenant.org.slug.clone();
10630
10631    let mut committed: Vec<i64> = Vec::new();
10632    let mut failed: Vec<serde_json::Value> = Vec::new();
10633
10634    for item in payload.items {
10635        let result: Result<i64, String> = async {
10636            let row = crate::uploaded_file::get(tenant.pool(), item.uploaded_file_id)
10637                .await
10638                .map_err(|e| format!("lookup: {e}"))?
10639                .ok_or_else(|| "scratch row missing".to_owned())?;
10640            if row.user_id != viewer_id && !viewer.is_superuser {
10641                return Err("not your upload".to_owned());
10642            }
10643
10644            let scratch_key = crate::media_storage::key(&media_slug, &row.storage_key);
10645            let mut bytes = crate::media_storage::disk_for(&media_slug)
10646                .load(&scratch_key)
10647                .await
10648                .map_err(|e| format!("read scratch: {e}"))?;
10649
10650            // EXIF-strip + decode for pixel dims. Mirrors upload path.
10651            let (stored, decoded_dims) =
10652                crate::rendition::strip_exif_off_runtime(bytes, row.mime.clone()).await;
10653            bytes = stored;
10654
10655            // Canonical storage_key under the tenant's media dir —
10656            // content-addressed prefix so renditions can find bytes
10657            // by hash without hitting the DB.
10658            let final_key = format!(
10659                "{}-{}",
10660                &row.content_hash[..16.min(row.content_hash.len())],
10661                row.original_filename
10662            );
10663            crate::media_storage::disk_for(&media_slug)
10664                .save(&crate::media_storage::key(&media_slug, &final_key), &bytes)
10665                .await
10666                .map_err(|e| format!("write final: {e}"))?;
10667
10668            let kind = Media::classify_mime(&row.mime).to_owned();
10669            let (width, height): (Option<i32>, Option<i32>) = decoded_dims
10670                .map(|(w, h)| (Some(w as i32), Some(h as i32)))
10671                .unwrap_or((None, None));
10672
10673            let title = if item.title.trim().is_empty() {
10674                row.original_filename
10675                    .rsplit_once('.')
10676                    .map(|(stem, _)| stem.to_owned())
10677                    .unwrap_or_else(|| row.original_filename.clone())
10678            } else {
10679                item.title.trim().to_owned()
10680            };
10681
10682            let mut media_row = Media {
10683                id: Auto::Unset,
10684                filename: row.original_filename.clone(),
10685                content_hash: row.content_hash.clone(),
10686                mime: row.mime.clone(),
10687                size: bytes.len() as i64,
10688                kind,
10689                width,
10690                height,
10691                storage_key: final_key,
10692                title,
10693                alt_text: item.alt_text.trim().to_owned(),
10694                description: String::new(),
10695                uploaded_by: Some(viewer_id),
10696                collection_id: item.collection_id,
10697                focal_point_x: None,
10698                focal_point_y: None,
10699                uploaded_at: Auto::Unset,
10700            };
10701            media_row
10702                .insert_pool(tenant.pool())
10703                .await
10704                .map_err(|e| format!("insert media: {e}"))?;
10705            let new_id = media_row.id.get().copied().unwrap_or_default();
10706
10707            // Best-effort scratch cleanup. Scratch file is a separate
10708            // path from the final storage_key (final lives outside
10709            // `scratch/`), so removing it is safe even when the bytes
10710            // are byte-identical.
10711            crate::media_storage::disk_for(&media_slug)
10712                .delete(&scratch_key)
10713                .await
10714                .log_warn("stored file not deleted; the blob is orphaned");
10715            crate::uploaded_file::delete(tenant.pool(), item.uploaded_file_id)
10716                .await
10717                .map_err(|e| format!("delete scratch: {e}"))?;
10718            Ok(new_id)
10719        }
10720        .await;
10721
10722        match result {
10723            Ok(id) => committed.push(id),
10724            Err(e) => {
10725                failed.push(serde_json::json!({
10726                    "uploaded_file_id": item.uploaded_file_id,
10727                    "error": e,
10728                }));
10729            }
10730        }
10731    }
10732
10733    let body = serde_json::json!({
10734        "committed": committed,
10735        "failed": failed,
10736    });
10737    Ok((
10738        [(axum::http::header::CONTENT_TYPE, "application/json")],
10739        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
10740    )
10741        .into_response())
10742}
10743
10744/// POST /cms-admin/media/upload-staged/{id}/cancel — drop scratch row
10745/// + unlink the file. Returns 204.
10746pub async fn media_upload_staged_cancel(
10747    State(_state): State<super::AdminState>,
10748    tenant: Tenant,
10749    headers: HeaderMap,
10750    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
10751    Path(id): Path<i64>,
10752) -> Result<Response, AdminError> {
10753    let Some(viewer) = session_user.as_ref() else {
10754        // #285 — JSON-aware 401 for fetch clients.
10755        return Ok(unauthorized_no_session_for(Some(&headers)));
10756    };
10757    let viewer_id = viewer.id.get().copied().unwrap_or_default();
10758    let Some(row) = crate::uploaded_file::get(tenant.pool(), id).await? else {
10759        return Ok((axum::http::StatusCode::NOT_FOUND, "not found").into_response());
10760    };
10761    if row.user_id != viewer_id && !viewer.is_superuser {
10762        return Ok((axum::http::StatusCode::FORBIDDEN, "not your upload").into_response());
10763    }
10764    crate::media_storage::disk_for(&tenant.org.slug)
10765        .delete(&crate::media_storage::key(
10766            &tenant.org.slug,
10767            &row.storage_key,
10768        ))
10769        .await
10770        .log_warn("stored file not deleted; the blob is orphaned");
10771    crate::uploaded_file::delete(tenant.pool(), id).await?;
10772    Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
10773}
10774
10775/// Refuse a file a browser would run as a page: HTML, XHTML,
10776/// JavaScript and XML (which can carry script through XSLT or an XHTML
10777/// namespace). Serving neutralises every type already; this keeps such
10778/// files out of the library in the first place. SVG stays allowed — it is
10779/// served under a no-script CSP.
10780fn refuse_active_upload(mime: &str) -> Result<(), AdminError> {
10781    let active = matches!(
10782        mime,
10783        "text/html"
10784            | "application/xhtml+xml"
10785            | "text/javascript"
10786            | "application/javascript"
10787            | "application/ecmascript"
10788            | "text/xml"
10789            | "application/xml"
10790            | "text/xsl"
10791            | "application/xslt+xml"
10792    );
10793    if active {
10794        return Err(AdminError::Upload(format!(
10795            "files of type {mime} can't be uploaded: a browser would run them as a page"
10796        )));
10797    }
10798    Ok(())
10799}
10800
10801/// Store one media file: sanitize the name, detect + classify the mime,
10802/// strip EXIF from images, hash, write
10803/// storage key `<org_slug>/<hash16>-<name>`, and insert the `cms_media`
10804/// row. The single canonical write path — the browser upload handlers and
10805/// the MCP `upload_media` tool all funnel through here.
10806///
10807/// `dedupe = true` short-circuits on an existing row with the same
10808/// content hash (returns it instead of storing a byte-identical copy) —
10809/// the same behavior the staged-upload flow gives the browser.
10810#[allow(clippy::too_many_arguments)]
10811pub(crate) async fn store_media(
10812    pool: &rustango::sql::Pool,
10813    org_slug: &str,
10814    mut bytes: Vec<u8>,
10815    raw_filename: &str,
10816    title: Option<&str>,
10817    alt_text: &str,
10818    collection_id: Option<i64>,
10819    uploaded_by: Option<i64>,
10820    dedupe: bool,
10821) -> Result<Media, AdminError> {
10822    use rustango::sql::Auto;
10823    use sha2::{Digest, Sha256};
10824
10825    let filename = sanitize_filename(raw_filename);
10826    if filename.is_empty() || bytes.is_empty() {
10827        return Err(AdminError::Upload("no file submitted".into()));
10828    }
10829
10830    let mime = mime_guess::from_path(&filename)
10831        .first_or_octet_stream()
10832        .essence_str()
10833        .to_owned();
10834    refuse_active_upload(&mime)?;
10835    let kind = Media::classify_mime(&mime).to_owned();
10836
10837    // #184 — strip EXIF on image upload, BEFORE hashing so the hash
10838    // reflects the stored bytes. See `media_upload_submit` for the why.
10839    let (stored, decoded_dims) = crate::rendition::strip_exif_off_runtime(bytes, mime.clone()).await;
10840    bytes = stored;
10841
10842    let mut hasher = Sha256::new();
10843    hasher.update(&bytes);
10844    let digest = hasher.finalize();
10845    let hash = digest.iter().fold(String::with_capacity(64), |mut acc, b| {
10846        use std::fmt::Write as _;
10847        let _ = write!(acc, "{b:02x}");
10848        acc
10849    });
10850
10851    if dedupe {
10852        if let Some(existing) = Media::objects()
10853            .where_(Media::content_hash.eq(hash.clone()))
10854            .first(pool)
10855            .await?
10856        {
10857            return Ok(existing);
10858        }
10859    }
10860
10861    // Routed through the pluggable storage backend (Slice 8.x).
10862    let storage_key = format!("{}-{}", &hash[..16], filename);
10863    crate::media_storage::disk_for(&org_slug)
10864        .save(&crate::media_storage::key(org_slug, &storage_key), &bytes)
10865        .await
10866        .map_err(|e| AdminError::Upload(format!("write: {e}")))?;
10867
10868    let title = match title {
10869        Some(t) if !t.is_empty() => t.to_owned(),
10870        _ => filename
10871            .rsplit_once('.')
10872            .map(|(stem, _)| stem.to_owned())
10873            .unwrap_or_else(|| filename.clone()),
10874    };
10875
10876    // Pixel dimensions fall out of the EXIF-strip decode; non-images /
10877    // broken decodes get `None`.
10878    let (width, height): (Option<i32>, Option<i32>) = decoded_dims
10879        .map(|(w, h)| (Some(w as i32), Some(h as i32)))
10880        .unwrap_or((None, None));
10881
10882    let mut row = Media {
10883        id: Auto::Unset,
10884        filename,
10885        content_hash: hash,
10886        mime,
10887        size: bytes.len() as i64,
10888        kind,
10889        width,
10890        height,
10891        storage_key,
10892        title,
10893        alt_text: alt_text.to_owned(),
10894        description: String::new(),
10895        uploaded_by,
10896        collection_id,
10897        focal_point_x: None,
10898        focal_point_y: None,
10899        uploaded_at: Auto::Unset,
10900    };
10901    row.insert_pool(pool).await?;
10902    Ok(row)
10903}
10904
10905pub async fn media_upload_submit(
10906    State(_state): State<super::AdminState>,
10907    tenant: Tenant,
10908    mut multipart: axum::extract::Multipart,
10909) -> Result<Response, AdminError> {
10910    let mut filename = String::new();
10911    let mut bytes: Vec<u8> = Vec::new();
10912    let mut title = String::new();
10913    let mut alt_text = String::new();
10914    // #24 V2 — upload-time crop. When the client submits all four
10915    // crop coords (source-image pixel space), we decode + crop the
10916    // bytes before storing so the on-disk canonical file matches the
10917    // editor's intent. Absence of any of the four = no crop.
10918    let mut crop_x: Option<u32> = None;
10919    let mut crop_y: Option<u32> = None;
10920    let mut crop_w: Option<u32> = None;
10921    let mut crop_h: Option<u32> = None;
10922
10923    while let Some(field) = multipart
10924        .next_field()
10925        .await
10926        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
10927    {
10928        let name = field.name().unwrap_or("").to_owned();
10929        match name.as_str() {
10930            "file" => {
10931                if let Some(fname) = field.file_name() {
10932                    filename = sanitize_filename(fname);
10933                }
10934                bytes = field
10935                    .bytes()
10936                    .await
10937                    .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
10938                    .to_vec();
10939            }
10940            "title" => {
10941                title = field
10942                    .text()
10943                    .await
10944                    .map_err(|e| AdminError::Upload(format!("read title: {e}")))?;
10945            }
10946            "alt_text" => {
10947                alt_text = field
10948                    .text()
10949                    .await
10950                    .map_err(|e| AdminError::Upload(format!("read alt_text: {e}")))?;
10951            }
10952            "crop_x" | "crop_y" | "crop_w" | "crop_h" => {
10953                let value = field
10954                    .text()
10955                    .await
10956                    .map_err(|e| AdminError::Upload(format!("read {name}: {e}")))?;
10957                let parsed: Option<u32> = value.trim().parse().ok();
10958                match name.as_str() {
10959                    "crop_x" => crop_x = parsed,
10960                    "crop_y" => crop_y = parsed,
10961                    "crop_w" => crop_w = parsed,
10962                    "crop_h" => crop_h = parsed,
10963                    _ => {}
10964                }
10965            }
10966            _ => {
10967                let _ = field.bytes().await;
10968            }
10969        }
10970    }
10971
10972    if filename.is_empty() || bytes.is_empty() {
10973        return Err(AdminError::Upload("no file submitted".into()));
10974    }
10975
10976    // Apply crop if all four coords arrived. Image-only — vector
10977    // sources can't be raster-cropped (mirrors the edit-time rule
10978    // in the V1 crop handler).
10979    if let (Some(x), Some(y), Some(w), Some(h)) = (crop_x, crop_y, crop_w, crop_h) {
10980        if w > 0 && h > 0 {
10981            let detected_mime = mime_guess::from_path(&filename)
10982                .first_or_octet_stream()
10983                .essence_str()
10984                .to_owned();
10985            refuse_active_upload(&detected_mime)?;
10986            if detected_mime == "image/svg+xml" {
10987                return Err(AdminError::Validation(
10988                    "Cropping SVG sources isn't supported; upload uncropped, then edit the markup."
10989                        .to_owned(),
10990                ));
10991            }
10992            if detected_mime.starts_with("image/") {
10993                let (cropped, _out_mime) = crate::rendition::crop_image_off_runtime(
10994                    bytes,
10995                    detected_mime.clone(),
10996                    (x, y, w, h),
10997                )
10998                .await
10999                .map_err(AdminError::Validation)?;
11000                bytes = cropped;
11001            }
11002        }
11003    }
11004
11005    // This legacy single-file path ignores any collection choice (the
11006    // per-file picker lives on the staged upload flow): rows land in
11007    // "uncategorized" (NULL) under the root collection.
11008    let row = store_media(
11009        tenant.pool(),
11010        &tenant.org.slug,
11011        bytes,
11012        &filename,
11013        (!title.is_empty()).then_some(title.as_str()),
11014        &alt_text,
11015        None,
11016        None,
11017        false,
11018    )
11019    .await?;
11020
11021    let redirect = if row.kind == "image" {
11022        "/cms-admin/media"
11023    } else {
11024        "/cms-admin/documents"
11025    };
11026    Ok(Redirect::to(redirect).into_response())
11027}
11028
11029/// POST /cms-admin/media/{id}/delete — drop a media row.
11030pub async fn media_delete_submit(
11031    State(_state): State<super::AdminState>,
11032    tenant: Tenant,
11033    Path(id): Path<i64>,
11034) -> Result<Response, AdminError> {
11035    let row = Media::objects()
11036        .where_(Media::id.eq(id))
11037        .first(tenant.pool())
11038        .await?
11039        .ok_or(AdminError::NotFound(id))?;
11040    // Best-effort storage cleanup — a missing object is not fatal.
11041    crate::media_storage::disk_for(&tenant.org.slug)
11042        .delete(&crate::media_storage::key(
11043            &tenant.org.slug,
11044            &row.storage_key,
11045        ))
11046        .await
11047        .log_warn("stored file not deleted; the blob is orphaned");
11048    let redirect = if row.kind == "image" {
11049        "/cms-admin/media"
11050    } else {
11051        "/cms-admin/documents"
11052    };
11053    row.delete_pool(tenant.pool()).await?;
11054    Ok(Redirect::to(redirect).into_response())
11055}
11056
11057fn sanitize_filename(raw: &str) -> String {
11058    raw.chars()
11059        .map(|c| {
11060            if c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_') {
11061                c
11062            } else {
11063                '_'
11064            }
11065        })
11066        .collect()
11067}
11068
11069// =====================================================================
11070// Locales tab
11071// =====================================================================
11072
11073/// GET /cms-admin/locales — list every locale.
11074/// GET /cms-admin/model/{slug} — generic read-only index for a
11075/// model registered via `register_model_admin!`: columns come from the
11076/// model's `admin(list_display = …)`, rows from its type-erased
11077/// list-rows thunk, all inside the CMS admin chrome. 404s an unknown
11078/// slug.
11079pub async fn model_admin_list(
11080    State(state): State<super::AdminState>,
11081    tenant: Tenant,
11082    headers: HeaderMap,
11083    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11084    Path(slug): Path<String>,
11085) -> Result<Response, AdminError> {
11086    let Some(ma) = super::model_admin::find(&slug) else {
11087        return Ok((axum::http::StatusCode::NOT_FOUND, "unknown model admin").into_response());
11088    };
11089    let rows_json = (ma.list_rows)(tenant.pool().clone()).await;
11090    let columns = super::model_admin::list_columns(ma.schema);
11091    let header_labels: Vec<&str> = columns.iter().map(|(_, l)| l.as_str()).collect();
11092    let body_rows: Vec<Vec<String>> = rows_json
11093        .iter()
11094        .map(|r| {
11095            columns
11096                .iter()
11097                .map(|(name, _)| super::model_admin::row_cell(r, name))
11098                .collect()
11099        })
11100        .collect();
11101    let mut ctx = Context::new();
11102    add_chrome(&mut ctx, &tenant, "model-admin", session_user.as_ref()).await;
11103    add_admin_theme(&mut ctx, tenant.pool()).await;
11104    ctx.insert("model_label", ma.label);
11105    ctx.insert("model_slug", &slug);
11106    ctx.insert("columns", &header_labels);
11107    ctx.insert("rows", &body_rows);
11108    ctx.insert("total", &body_rows.len());
11109    render_with_csrf(
11110        &state,
11111        &headers,
11112        "rcms_admin/model_admin_list.html",
11113        &mut ctx,
11114    )
11115}
11116
11117/// `?format=csv` selector for [`report_view`].
11118#[derive(serde::Deserialize, Default)]
11119pub struct ReportQuery {
11120    pub format: Option<String>,
11121}
11122
11123/// Render any registered report through the shared chrome'd
11124/// table, or export it as CSV with `?format=csv`. `active_tab` is
11125/// `report:<slug>` so `_base.html` highlights the matching sidebar link.
11126pub async fn report_view(
11127    State(state): State<super::AdminState>,
11128    tenant: Tenant,
11129    headers: HeaderMap,
11130    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11131    Path(slug): Path<String>,
11132    Query(q): Query<ReportQuery>,
11133) -> Result<Response, AdminError> {
11134    let Some(report) = super::report::find_report(&slug) else {
11135        return Ok((axum::http::StatusCode::NOT_FOUND, "unknown report").into_response());
11136    };
11137    let user_id = session_user.as_ref().and_then(|u| u.id.get().copied());
11138    let columns = report.columns();
11139    let rows = report.rows(tenant.pool(), user_id).await;
11140
11141    // CSV export — same rows, flattened to column order.
11142    if q.format.as_deref() == Some("csv") {
11143        let mut out = String::with_capacity(128 + rows.len() * 64);
11144        let header: Vec<String> = columns.iter().map(|c| csv_escape(c.label)).collect();
11145        out.push_str(&header.join(","));
11146        out.push('\n');
11147        for row in &rows {
11148            let line: Vec<String> = columns
11149                .iter()
11150                .map(|c| csv_escape(&report_cell_string(row.get(c.key))))
11151                .collect();
11152            out.push_str(&line.join(","));
11153            out.push('\n');
11154        }
11155        return Ok(csv_response(&slug, &out));
11156    }
11157
11158    let header_labels: Vec<&str> = columns.iter().map(|c| c.label).collect();
11159    let view_rows: Vec<serde_json::Value> = rows
11160        .iter()
11161        .map(|row| {
11162            let cells: Vec<serde_json::Value> = columns
11163                .iter()
11164                .map(|c| {
11165                    serde_json::json!({
11166                        "kind": c.kind.as_str(),
11167                        "value": report_cell_string(row.get(c.key)),
11168                    })
11169                })
11170                .collect();
11171            serde_json::json!({
11172                "edit_url": row.get("edit_url").and_then(|v| v.as_str()),
11173                "cells": cells,
11174            })
11175        })
11176        .collect();
11177
11178    let mut ctx = Context::new();
11179    add_chrome(
11180        &mut ctx,
11181        &tenant,
11182        &format!("report:{slug}"),
11183        session_user.as_ref(),
11184    )
11185    .await;
11186    add_admin_theme(&mut ctx, tenant.pool()).await;
11187    ctx.insert("report_title", report.title());
11188    ctx.insert("report_slug", &slug);
11189    ctx.insert("report_description", &report.description());
11190    ctx.insert("columns", &header_labels);
11191    ctx.insert("rows", &view_rows);
11192    ctx.insert("total", &view_rows.len());
11193    render_with_csrf(&state, &headers, "rcms_admin/report.html", &mut ctx)
11194}
11195
11196// ===================================================================== Form builder (#533)
11197
11198/// GET `/cms-admin/forms` — dedicated Forms list: every form snippet with its
11199/// per-form submission count and last-submission time, linking straight into
11200/// the builder and the submission history. This exists because the generic
11201/// library table can't surface submissions (`LibraryTypeHandler::render_cell`
11202/// is sync and pool-less), which left "Forms" dead-ending on a Library view
11203/// with no way to see what a form collected.
11204pub async fn forms_list(
11205    State(state): State<super::AdminState>,
11206    tenant: Tenant,
11207    headers: HeaderMap,
11208    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11209) -> Result<Response, AdminError> {
11210    let pool = tenant.pool();
11211    let rows = forms_list_rows(pool).await?;
11212
11213    let mut ctx = Context::new();
11214    add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11215    add_admin_theme(&mut ctx, pool).await;
11216    ctx.insert("rows", &rows);
11217    ctx.insert("total", &rows.len());
11218    render_with_csrf(&state, &headers, "rcms_admin/forms_list.html", &mut ctx)
11219}
11220
11221/// Core of [`forms_list`] — the row model (per-form field count, submission
11222/// count, latest submission, action URLs), split out so unit tests can drive
11223/// it with an in-memory pool.
11224pub(crate) async fn forms_list_rows(
11225    pool: &rustango::sql::Pool,
11226) -> Result<Vec<serde_json::Value>, AdminError> {
11227    let mut forms: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
11228        .where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
11229        .fetch(pool)
11230        .await?;
11231    // Newest-edited first.
11232    forms.sort_by(|a, b| {
11233        b.updated_at
11234            .get()
11235            .cloned()
11236            .cmp(&a.updated_at.get().cloned())
11237    });
11238
11239    // Per-form submission count + latest submission, grouped in Rust — the
11240    // tri-dialect pattern used by `counts_by_type` / the pages `child_counts`
11241    // (no SQL GROUP BY helper in the codebase).
11242    let entries: Vec<crate::forms::submit::FormEntry> = crate::forms::submit::FormEntry::objects()
11243        .fetch(pool)
11244        .await?;
11245    let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
11246    let mut last_at: std::collections::HashMap<i64, String> = std::collections::HashMap::new();
11247    for e in &entries {
11248        *counts.entry(e.form_snippet_id).or_default() += 1;
11249        if let Some(at) = e.submitted_at.get() {
11250            let s = at.format("%Y-%m-%d %H:%M").to_string();
11251            let slot = last_at.entry(e.form_snippet_id).or_default();
11252            if s > *slot {
11253                *slot = s;
11254            }
11255        }
11256    }
11257
11258    let rows: Vec<serde_json::Value> = forms
11259        .iter()
11260        .map(|s| {
11261            let id = s.id.get().copied().unwrap_or_default();
11262            let parsed = crate::forms::schema::parse(&s.data).unwrap_or_default();
11263            serde_json::json!({
11264                "id": id,
11265                "title": s.title,
11266                "slug": s.slug,
11267                "fields": parsed.field_count(),
11268                "submissions": counts.get(&id).copied().unwrap_or(0),
11269                "last_submission": last_at.get(&id).cloned().unwrap_or_default(),
11270                "updated_at": s.updated_at.get().map(|d| d.format("%Y-%m-%d").to_string()).unwrap_or_default(),
11271                "build_url": format!("/cms-admin/forms/{id}/build"),
11272                "submissions_url": format!("/cms-admin/forms/{id}/submissions"),
11273                "delete_url": format!("/cms-admin/library/{id}/delete"),
11274            })
11275        })
11276        .collect();
11277    Ok(rows)
11278}
11279
11280/// GET `/cms-admin/forms/{id}/build` — the visual form builder editor.
11281/// Loads the form snippet's schema JSON into the page; the
11282/// `form_builder.js` engine renders the editor from it.
11283pub async fn form_build_form(
11284    State(state): State<super::AdminState>,
11285    tenant: Tenant,
11286    headers: HeaderMap,
11287    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11288    Path(id): Path<i64>,
11289    Query(q): Query<EditQuery>,
11290) -> Result<Response, AdminError> {
11291    let snippet = crate::snippet::Snippet::objects()
11292        .where_(crate::snippet::Snippet::id.eq(id))
11293        .first(tenant.pool())
11294        .await?
11295        .ok_or(AdminError::NotFound(id))?;
11296    if snippet.type_name != "form" {
11297        return Err(AdminError::NotFound(id));
11298    }
11299    let mut ctx = Context::new();
11300    add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11301    add_admin_theme(&mut ctx, tenant.pool()).await;
11302    ctx.insert("title", &snippet.title);
11303    ctx.insert("form_id", &id);
11304    ctx.insert("build_url", &format!("/cms-admin/forms/{id}/build"));
11305
11306    // #550 FB-17 — active non-default locales for the Translate picker.
11307    let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
11308        .where_(crate::locale::Locale::active.eq(true))
11309        .where_(crate::locale::Locale::is_default.eq(false))
11310        .fetch(tenant.pool())
11311        .await
11312        .unwrap_or_default();
11313    ctx.insert(
11314        "locales",
11315        &locales
11316            .iter()
11317            .map(|l| serde_json::json!({"code": l.code, "name": l.name}))
11318            .collect::<Vec<_>>(),
11319    );
11320
11321    // Translate mode: ?locale=<code> renders a focused per-leaf editor that
11322    // posts to the existing snippet-translate endpoint.
11323    if let Some(code) = q.locale.as_deref().filter(|c| !c.is_empty()) {
11324        if let Some(loc) = locales.iter().find(|l| l.code == code) {
11325            let lid = loc.id.get().copied().unwrap_or(0);
11326            let form = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11327            let leaves = crate::forms::schema::translatable_leaves(&form);
11328            let existing = crate::snippet_translation::fetch_for(tenant.pool(), id, lid)
11329                .await
11330                .unwrap_or_default();
11331            // Consecutive leaves of one field form a group, like the
11332            // block groups of the page editor.
11333            let mut groups: Vec<serde_json::Value> = Vec::new();
11334            for l in &leaves {
11335                let row = serde_json::json!({
11336                    "path": l.path,
11337                    "part": l.part,
11338                    "n": l.n.to_string(),
11339                    "canonical": l.text,
11340                    "value": existing.get(&l.path).cloned().unwrap_or_default(),
11341                });
11342                let same = groups
11343                    .last()
11344                    .is_some_and(|g| g["name"].as_str() == Some(l.group.as_str()));
11345                if same {
11346                    if let Some(arr) = groups
11347                        .last_mut()
11348                        .and_then(|g| g.get_mut("leaves"))
11349                        .and_then(|v| v.as_array_mut())
11350                    {
11351                        arr.push(row);
11352                    }
11353                } else {
11354                    groups.push(serde_json::json!({ "name": l.group, "leaves": [row] }));
11355                }
11356            }
11357            ctx.insert("editing_locale", &loc.name);
11358            ctx.insert("editing_code", &code);
11359            ctx.insert("trans_groups", &groups);
11360            ctx.insert(
11361                "translate_url",
11362                &format!("/cms-admin/library/{id}/translate"),
11363            );
11364            return render_with_csrf(&state, &headers, "rcms_admin/form_translate.html", &mut ctx);
11365        }
11366    }
11367
11368    // The builder's back button says "Forms", so it has to land on the
11369    // Forms list. Pointing it at the generic Library view dropped editors
11370    // onto a different listing of the same rows — its own search, its own
11371    // column picker, no Submissions column — which read as a second,
11372    // older Forms screen. Every other builder points at its own list.
11373    ctx.insert("list_url", "/cms-admin/forms");
11374    // FB-15 — the builder edits the DRAFT; Publish promotes it to live.
11375    ctx.insert("publish_url", &format!("/cms-admin/forms/{id}/publish"));
11376    ctx.insert(
11377        "has_unpublished",
11378        &crate::forms::schema::has_unpublished_changes(&snippet.data),
11379    );
11380    let mut draft = crate::forms::schema::parse_draft(&snippet.data);
11381    draft.sanitize_rich_text();
11382    let schema_json = serde_json::to_string(&crate::forms::schema::to_value(&draft))
11383        .unwrap_or_else(|_| "{}".to_owned());
11384    ctx.insert("schema_json", &schema_json);
11385    render_with_csrf(&state, &headers, "rcms_admin/form_builder.html", &mut ctx)
11386}
11387
11388#[derive(Debug, Deserialize)]
11389pub struct FormBuildSubmit {
11390    pub schema: String,
11391}
11392
11393/// Create-a-page-type submit. `type_name` is slugified server-side.
11394#[derive(Debug, Deserialize)]
11395pub struct FormPageTypeCreate {
11396    #[serde(default)]
11397    pub verbose_name: String,
11398    #[serde(default)]
11399    pub type_name: String,
11400    #[serde(default)]
11401    pub allowed_parents: String,
11402    #[serde(default)]
11403    pub allowed_children: String,
11404    /// `"auto" | "html" | "api"` — see [`crate::page_view::PageViewMode`].
11405    /// Offered only for UI types: a code type's mode is re-seeded from
11406    /// its handler on every boot, so an admin edit would silently revert.
11407    #[serde(default)]
11408    pub view_mode: String,
11409    /// Workflow name, or empty to publish directly.
11410    #[serde(default)]
11411    pub workflow: String,
11412}
11413
11414/// Component builder submit: builder `schema` (a `{nodes:[…]}` blob)
11415/// plus the component metadata fields.
11416#[derive(Debug, Deserialize)]
11417pub struct FormComponentSubmit {
11418    #[serde(default)]
11419    pub slug: String,
11420    #[serde(default)]
11421    pub label: String,
11422    #[serde(default)]
11423    pub icon: String,
11424    #[serde(default)]
11425    pub description: String,
11426    #[serde(default)]
11427    pub schema: String,
11428}
11429
11430/// POST `/cms-admin/forms/{id}/build` — persist the builder's schema into
11431/// GET|POST /cms-admin/forms/{id}/preview — render this form the way a
11432/// visitor sees it, for the editor's sidebar preview.
11433///
11434/// GET renders the saved draft; POST renders the schema in the request
11435/// body, which is how the builder shows unsaved edits — the same
11436/// saved-vs-unsaved split the page preview uses.
11437///
11438/// Crucially this calls [`crate::forms::render::render_form_html`] — the
11439/// one the public site calls. The builder used to draw its own preview in
11440/// JavaScript, rebuilding the layout a second time in a second language;
11441/// the two could only agree by coincidence, and every renderer change had
11442/// to be made twice or the preview quietly started lying.
11443pub async fn form_preview(
11444    tenant: Tenant,
11445    Path(id): Path<i64>,
11446    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11447) -> Result<Response, AdminError> {
11448    let snippet = load_form_snippet(&tenant, id).await?;
11449    let form = crate::forms::schema::parse_draft(&snippet.data);
11450    Ok(render_form_preview(id, &form))
11451}
11452
11453/// POST /cms-admin/forms/{id}/preview — render the schema in the body, so
11454/// the builder previews edits that have not been saved. Mirrors
11455/// `page_preview_draft`.
11456pub async fn form_preview_draft(
11457    tenant: Tenant,
11458    Path(id): Path<i64>,
11459    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11460    Form(body): Form<FormBuildSubmit>,
11461) -> Result<Response, AdminError> {
11462    let snippet = load_form_snippet(&tenant, id).await?;
11463    // A schema that does not parse is the normal state mid-edit, not an
11464    // error worth blanking the pane for: fall back to the saved draft and
11465    // let the editor keep typing.
11466    let form = crate::forms::schema::parse_str(&body.schema)
11467        .unwrap_or_else(|_| crate::forms::schema::parse_draft(&snippet.data));
11468    Ok(render_form_preview(id, &form))
11469}
11470
11471/// The snippet behind a form id, refusing anything that is not a form.
11472async fn load_form_snippet(
11473    tenant: &Tenant,
11474    id: i64,
11475) -> Result<crate::snippet::Snippet, AdminError> {
11476    let snippet = crate::snippet::Snippet::objects()
11477        .where_(crate::snippet::Snippet::id.eq(id))
11478        .first(tenant.pool())
11479        .await?
11480        .ok_or(AdminError::NotFound(id))?;
11481    if snippet.type_name != "form" {
11482        return Err(AdminError::NotFound(id));
11483    }
11484    Ok(snippet)
11485}
11486
11487fn render_form_preview(id: i64, form: &crate::forms::schema::Form) -> Response {
11488    // `embed_id` is empty: this is the standalone render, with no page
11489    // embedding it and so no per-embed override to resolve.
11490    let inner = crate::forms::render::render_form_html(form, id, "");
11491    let html = format!(
11492        "<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\">\
11493         <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\
11494         <title>Form preview</title>\
11495         <style>body{{margin:0;padding:24px;font:14px/1.5 system-ui,sans-serif;}}</style>\
11496         </head><body>{inner}</body></html>"
11497    );
11498    stamp_no_cache(
11499        (
11500            [(
11501                axum::http::header::CONTENT_TYPE,
11502                axum::http::HeaderValue::from_static("text/html; charset=utf-8"),
11503            )],
11504            html,
11505        )
11506            .into_response(),
11507    )
11508}
11509
11510/// the snippet's `data` column + capture a revision.
11511pub async fn form_build_submit(
11512    State(_state): State<super::AdminState>,
11513    tenant: Tenant,
11514    headers: HeaderMap,
11515    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11516    Path(id): Path<i64>,
11517    Form(form): Form<FormBuildSubmit>,
11518) -> Result<Response, AdminError> {
11519    let mut snippet = crate::snippet::Snippet::objects()
11520        .where_(crate::snippet::Snippet::id.eq(id))
11521        .first(tenant.pool())
11522        .await?
11523        .ok_or(AdminError::NotFound(id))?;
11524    if snippet.type_name != "form" {
11525        return Err(AdminError::NotFound(id));
11526    }
11527    let mut parsed = crate::forms::schema::parse_str(&form.schema)
11528        .map_err(|e| AdminError::Validation(format!("invalid form schema: {e}")))?;
11529    parsed.sanitize_rich_text();
11530    let mut warnings = crate::forms::schema::validate(&parsed);
11531    // FB-15 — saving stores a DRAFT; the published (public) form is untouched
11532    // until Publish.
11533    snippet.data = crate::forms::schema::save_draft_value(&snippet.data, &parsed);
11534    snippet.save_pool(tenant.pool()).await?;
11535    // Keep the notification target in step with the recipients typed into
11536    // form settings, so the two cannot disagree about who gets told.
11537    if let Err(e) = crate::notify::targets::sync_form_email(
11538        tenant.pool(),
11539        id,
11540        &snippet.title,
11541        &parsed.settings.notify_emails,
11542    )
11543    .await
11544    {
11545        tracing::warn!(
11546            target: "rustango_cms::notify",
11547            error = %e, form_id = id,
11548            "could not sync the form's email notification target"
11549        );
11550        warnings.push(format!("Email notifications are off: {e}."));
11551    }
11552    let (level, msg) = if warnings.is_empty() {
11553        (MsgLevel::Success, "Draft saved.".to_owned())
11554    } else {
11555        (
11556            MsgLevel::Warning,
11557            format!("Draft saved with warnings: {}", warnings.join(" ")),
11558        )
11559    };
11560    redirect_named_with_params_and_message(
11561        "rcms-admin:forms:build",
11562        &[("id", id.to_string())],
11563        level,
11564        &msg,
11565        &headers,
11566    )
11567}
11568
11569/// POST `/cms-admin/forms/{id}/publish` — publish the submitted schema: it
11570/// becomes the live (public) form + the draft, and a revision is captured.
11571pub async fn form_publish_submit(
11572    State(_state): State<super::AdminState>,
11573    tenant: Tenant,
11574    headers: HeaderMap,
11575    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11576    Path(id): Path<i64>,
11577    Form(form): Form<FormBuildSubmit>,
11578) -> Result<Response, AdminError> {
11579    let mut snippet = crate::snippet::Snippet::objects()
11580        .where_(crate::snippet::Snippet::id.eq(id))
11581        .first(tenant.pool())
11582        .await?
11583        .ok_or(AdminError::NotFound(id))?;
11584    if snippet.type_name != "form" {
11585        return Err(AdminError::NotFound(id));
11586    }
11587    let mut parsed = crate::forms::schema::parse_str(&form.schema)
11588        .map_err(|e| AdminError::Validation(format!("invalid form schema: {e}")))?;
11589    parsed.sanitize_rich_text();
11590    snippet.data = crate::forms::schema::publish_value(&parsed);
11591    snippet.save_pool(tenant.pool()).await?;
11592    if let Some(h) = crate::library::find_handler(&snippet.type_name) {
11593        if h.revisions_enabled() {
11594            let uid = session_user.as_ref().and_then(|u| u.id.get().copied());
11595            crate::snippet::capture_revision(tenant.pool(), &snippet, uid)
11596                .await
11597                .log_warn("revision not captured; the history has a gap");
11598        }
11599    }
11600    redirect_named_with_params_and_message(
11601        "rcms-admin:forms:build",
11602        &[("id", id.to_string())],
11603        MsgLevel::Success,
11604        "Form published — the live form is now up to date.",
11605        &headers,
11606    )
11607}
11608
11609/// Shared loader for the submissions views: the form
11610/// snippet, its parsed schema's value-columns, the entries, and a
11611/// source-page-id → url_path map for provenance links.
11612async fn load_form_submissions(
11613    pool: &rustango::sql::Pool,
11614    form_id: i64,
11615) -> Result<
11616    (
11617        crate::snippet::Snippet,
11618        Vec<(String, String)>,
11619        Vec<crate::forms::submit::FormEntry>,
11620        std::collections::HashMap<i64, String>,
11621    ),
11622    AdminError,
11623> {
11624    let snippet = crate::snippet::Snippet::objects()
11625        .where_(crate::snippet::Snippet::id.eq(form_id))
11626        .where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
11627        .first(pool)
11628        .await?
11629        .ok_or(AdminError::NotFound(form_id))?;
11630    let form = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11631    let columns: Vec<(String, String)> = form
11632        .fields()
11633        .filter(|f| f.field_type.collects_value() && !f.key.is_empty())
11634        .map(|f| {
11635            (
11636                f.key.clone(),
11637                if f.label.is_empty() {
11638                    f.key.clone()
11639                } else {
11640                    f.label.clone()
11641                },
11642            )
11643        })
11644        .collect();
11645    let entries: Vec<crate::forms::submit::FormEntry> = crate::forms::submit::FormEntry::objects()
11646        .where_(crate::forms::submit::FormEntry::form_snippet_id.eq(form_id))
11647        .order_by(&[("submitted_at", true)])
11648        .fetch(pool)
11649        .await?;
11650    // Resolve source pages for provenance links.
11651    let mut page_urls = std::collections::HashMap::new();
11652    let ids: Vec<i64> = entries
11653        .iter()
11654        .map(|e| e.source_page_id)
11655        .filter(|i| *i != 0)
11656        .collect();
11657    if !ids.is_empty() {
11658        if let Ok(pages) = crate::page::Page::objects().fetch(pool).await {
11659            for p in pages {
11660                if let Some(pid) = p.id.get().copied() {
11661                    if ids.contains(&pid) {
11662                        page_urls.insert(pid, p.url_path.clone());
11663                    }
11664                }
11665            }
11666        }
11667    }
11668    Ok((snippet, columns, entries, page_urls))
11669}
11670
11671/// Render one submission answer cell from the `data_json` value.
11672fn submission_cell(data: &serde_json::Value, key: &str) -> String {
11673    match data.get(key) {
11674        Some(serde_json::Value::Array(items)) => items
11675            .iter()
11676            .filter_map(|v| v.as_str().map(str::to_owned))
11677            .collect::<Vec<_>>()
11678            .join("; "),
11679        Some(serde_json::Value::String(s)) => s.clone(),
11680        Some(other) => other.to_string(),
11681        None => String::new(),
11682    }
11683}
11684
11685/// GET `/cms-admin/forms/{id}/submissions` — the per-form submission
11686/// history with a Source-page column.
11687pub async fn form_submissions_list(
11688    State(state): State<super::AdminState>,
11689    tenant: Tenant,
11690    headers: HeaderMap,
11691    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11692    Path(id): Path<i64>,
11693) -> Result<Response, AdminError> {
11694    let (snippet, columns, entries, page_urls) = load_form_submissions(tenant.pool(), id).await?;
11695    // Which columns are file uploads → render those cells as download links.
11696    let parsed = crate::forms::schema::parse(&snippet.data).unwrap_or_default();
11697    let file_keys: std::collections::HashSet<String> = parsed
11698        .fields()
11699        .filter(|f| matches!(f.field_type, crate::forms::schema::FieldType::File))
11700        .map(|f| f.key.clone())
11701        .collect();
11702    let rows: Vec<serde_json::Value> = entries
11703        .iter()
11704        .map(|e| {
11705            let cells: Vec<serde_json::Value> = columns
11706                .iter()
11707                .map(|(k, _)| {
11708                    let v = submission_cell(&e.data_json, k);
11709                    if file_keys.contains(k) && !v.is_empty() {
11710                        // value is the storage key; display the filename part.
11711                        let name = v.splitn(2, '-').nth(1).unwrap_or(&v).to_owned();
11712                        serde_json::json!({
11713                            "value": name,
11714                            "url": format!("/cms-admin/forms/{id}/submissions/file/{v}"),
11715                        })
11716                    } else {
11717                        serde_json::json!({ "value": v })
11718                    }
11719                })
11720                .collect();
11721            serde_json::json!({
11722                // RFC 3339, for the admin's `<time data-utc>` localizer; the
11723                // minute-precision text is what shows without JavaScript.
11724                "submitted_at": e
11725                    .submitted_at
11726                    .get()
11727                    .map(|t| t.to_rfc3339_opts(chrono::SecondsFormat::Secs, true))
11728                    .unwrap_or_default(),
11729                "submitted_at_text": e
11730                    .submitted_at
11731                    .get()
11732                    .map(|t| t.format("%Y-%m-%d %H:%M UTC").to_string())
11733                    .unwrap_or_default(),
11734                "ip": e.ip,
11735                "source_page": if e.source_page_id == 0 {
11736                    serde_json::Value::Null
11737                } else {
11738                    serde_json::json!({
11739                        "id": e.source_page_id,
11740                        "url": page_urls.get(&e.source_page_id).cloned().unwrap_or_default(),
11741                    })
11742                },
11743                "cells": cells,
11744            })
11745        })
11746        .collect();
11747    let mut ctx = Context::new();
11748    add_chrome(&mut ctx, &tenant, "forms", session_user.as_ref()).await;
11749    add_admin_theme(&mut ctx, tenant.pool()).await;
11750    ctx.insert("form_title", &snippet.title);
11751    ctx.insert("form_id", &id);
11752    ctx.insert("build_url", &format!("/cms-admin/forms/{id}/build"));
11753    ctx.insert(
11754        "csv_url",
11755        &format!("/cms-admin/forms/{id}/submissions/export.csv"),
11756    );
11757    ctx.insert(
11758        "columns",
11759        &columns.iter().map(|(_, l)| l).collect::<Vec<_>>(),
11760    );
11761    ctx.insert("rows", &rows);
11762    ctx.insert("total", &entries.len());
11763    render_with_csrf(
11764        &state,
11765        &headers,
11766        "rcms_admin/form_submissions.html",
11767        &mut ctx,
11768    )
11769}
11770
11771/// GET `/cms-admin/forms/{id}/submissions/export.csv`.
11772pub async fn form_submissions_csv(
11773    State(_state): State<super::AdminState>,
11774    tenant: Tenant,
11775    Path(id): Path<i64>,
11776) -> Result<Response, AdminError> {
11777    let (snippet, columns, entries, page_urls) = load_form_submissions(tenant.pool(), id).await?;
11778    let mut out = String::new();
11779    out.push_str("submitted_at,source_page,ip");
11780    for (_, label) in &columns {
11781        out.push(',');
11782        out.push_str(&csv_escape(label));
11783    }
11784    out.push('\n');
11785    for e in &entries {
11786        let when = e
11787            .submitted_at
11788            .get()
11789            .map(ToString::to_string)
11790            .unwrap_or_default();
11791        let src = if e.source_page_id == 0 {
11792            String::new()
11793        } else {
11794            page_urls
11795                .get(&e.source_page_id)
11796                .cloned()
11797                .unwrap_or_default()
11798        };
11799        out.push_str(&csv_escape(&when));
11800        out.push(',');
11801        out.push_str(&csv_escape(&src));
11802        out.push(',');
11803        out.push_str(&csv_escape(&e.ip));
11804        for (k, _) in &columns {
11805            out.push(',');
11806            out.push_str(&csv_escape(&submission_cell(&e.data_json, k)));
11807        }
11808        out.push('\n');
11809    }
11810    let filename = format!("submissions-{}.csv", snippet.slug);
11811    Ok(csv_response(&filename, &out))
11812}
11813
11814/// GET `/cms-admin/forms/{id}/submissions/file/{key}` — download a file
11815/// uploaded through a form submission (admin-gated). Streams from
11816/// `./var/form-uploads/<tenant>/<key>`; rejects path traversal.
11817pub async fn form_submission_file(
11818    State(_state): State<super::AdminState>,
11819    tenant: Tenant,
11820    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
11821    Path((_id, key)): Path<(i64, String)>,
11822) -> Result<Response, AdminError> {
11823    if key.contains('/') || key.contains('\\') || key.contains("..") || key.is_empty() {
11824        return Err(AdminError::NotFound(0));
11825    }
11826    let path = std::path::PathBuf::from("./var/form-uploads")
11827        .join(&tenant.org.slug)
11828        .join(&key);
11829    let bytes = std::fs::read(&path).map_err(|_| AdminError::NotFound(0))?;
11830    let mime = mime_guess::from_path(&key)
11831        .first_or_octet_stream()
11832        .essence_str()
11833        .to_owned();
11834    let download = key.splitn(2, '-').nth(1).unwrap_or(&key).to_owned();
11835    Ok((
11836        [
11837            (header::CONTENT_TYPE, mime),
11838            (
11839                header::CONTENT_DISPOSITION,
11840                format!("attachment; filename=\"{download}\""),
11841            ),
11842        ],
11843        bytes,
11844    )
11845        .into_response())
11846}
11847
11848#[derive(Debug, Deserialize)]
11849pub struct SetLangQuery {
11850    pub lang: String,
11851}
11852
11853/// POST `/cms-admin/set-language` (`lang=<code>`) — persist the sticky
11854/// admin-UI language cookie and the user's durable preference, then
11855/// redirect back to the Referer. POST so a cross-site link can't
11856/// rewrite a signed-in user's preference: it goes through the CSRF check
11857/// like every other admin write.
11858pub async fn admin_set_language(
11859    tenant: Tenant,
11860    headers: HeaderMap,
11861    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11862    Form(q): Form<SetLangQuery>,
11863) -> Response {
11864    let lang = if super::i18n::is_ui_locale(&q.lang) {
11865        q.lang
11866    } else {
11867        "en".to_owned()
11868    };
11869    // #526 — persist to the user's durable pref too, so the switcher choice
11870    // follows them across devices (not just this browser's cookie). Best-effort:
11871    // a save failure still sets the cookie below.
11872    if let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) {
11873        persist_user_admin_lang(tenant.pool(), uid, &lang)
11874            .await
11875            .log_warn("admin language preference not saved");
11876    }
11877    // The Referer's path, if it is a local one, else the admin root. The
11878    // path of `https://evil.test//evil.test/x` is `//evil.test/x`, so it
11879    // goes through safe_next like any other redirect target (#728).
11880    let back = headers
11881        .get(header::REFERER)
11882        .and_then(|v| v.to_str().ok())
11883        .and_then(|r| match r.split_once("://") {
11884            Some((_, rest)) => rest.find('/').map(|i| &rest[i..]),
11885            None => Some(r),
11886        })
11887        .and_then(rustango::auth_decorators::safe_next)
11888        .unwrap_or_else(|| "/cms-admin/".to_owned());
11889    let cookie = format!(
11890        "{}={lang}; Path=/; SameSite=Lax; Max-Age=31536000",
11891        super::i18n::ADMIN_LANG_COOKIE
11892    );
11893    let mut resp = axum::response::Redirect::to(&back).into_response();
11894    if let Ok(v) = HeaderValue::from_str(&cookie) {
11895        resp.headers_mut().append(header::SET_COOKIE, v);
11896    }
11897    resp
11898}
11899
11900/// RFC-4180 CSV field escaping: quote when the value contains a comma,
11901/// quote, or newline, doubling any embedded quotes. Shared by every
11902/// admin CSV export (reports, audit log, pages, redirects, …).
11903fn csv_escape(s: &str) -> String {
11904    if s.contains(',') || s.contains('"') || s.contains('\n') || s.contains('\r') {
11905        let mut out = String::with_capacity(s.len() + 2);
11906        out.push('"');
11907        for c in s.chars() {
11908            if c == '"' {
11909                out.push('"');
11910            }
11911            out.push(c);
11912        }
11913        out.push('"');
11914        out
11915    } else {
11916        s.to_owned()
11917    }
11918}
11919
11920/// Stringify a report cell value for display / CSV: strings pass
11921/// through; null / missing → empty; numbers + bools → their literal.
11922fn report_cell_string(v: Option<&serde_json::Value>) -> String {
11923    match v {
11924        Some(serde_json::Value::String(s)) => s.clone(),
11925        None | Some(serde_json::Value::Null) => String::new(),
11926        Some(other) => other.to_string(),
11927    }
11928}
11929
11930pub async fn locale_list(
11931    State(state): State<super::AdminState>,
11932    tenant: Tenant,
11933    headers: HeaderMap,
11934    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11935) -> Result<Response, AdminError> {
11936    let items: Vec<Locale> = Locale::objects()
11937        .order_by(&[("sort_order", false), ("code", false)])
11938        .fetch(tenant.pool())
11939        .await?;
11940    // Enrich each row with core's static support level so the list can warn
11941    // where a content locale outruns the framework (no admin-UI catalog, no
11942    // language-specific plural rule, unknown to core). Serialize the row then
11943    // attach `support` — keeps every existing template field working.
11944    let rows: Vec<serde_json::Value> = items
11945        .iter()
11946        .map(|l| {
11947            let info = rustango::i18n::locale_info(&l.code);
11948            let ui = super::i18n::is_ui_locale(&l.code);
11949            let mut v = serde_json::to_value(l).unwrap_or_default();
11950            v["support"] = serde_json::json!({
11951                "ui_translated": ui,
11952                "known": info.known,
11953                "display_name": info.display_name,
11954                "has_plural_rules": info.has_plural_rules,
11955                "is_rtl": info.is_rtl,
11956                "content_only": !ui,
11957            });
11958            v
11959        })
11960        .collect();
11961    let mut ctx = Context::new();
11962    add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
11963    add_admin_theme(&mut ctx, tenant.pool()).await;
11964    ctx.insert("items", &rows);
11965    render_with_csrf(&state, &headers, "rcms_admin/locale_list.html", &mut ctx)
11966}
11967
11968/// Inject core's known-locale roster into a locale-form context: a
11969/// `known_locales` list (`code`, `name`) for the code datalist, and a
11970/// `known_locales_meta` map (`code → {ui, is_rtl, has_plural_rules}`) the
11971/// form JS reads to show a live support hint. Free-text codes stay valid;
11972/// this is guidance, not a whitelist.
11973fn insert_known_locales(ctx: &mut Context) {
11974    let known: Vec<serde_json::Value> = rustango::i18n::known_locales()
11975        .map(|(code, name)| serde_json::json!({ "code": code, "name": name }))
11976        .collect();
11977    let meta: serde_json::Map<String, serde_json::Value> = rustango::i18n::known_locales()
11978        .map(|(code, _)| {
11979            let info = rustango::i18n::locale_info(code);
11980            (
11981                code.to_owned(),
11982                serde_json::json!({
11983                    "ui": super::i18n::is_ui_locale(code),
11984                    "is_rtl": info.is_rtl,
11985                    "has_plural_rules": info.has_plural_rules,
11986                }),
11987            )
11988        })
11989        .collect();
11990    ctx.insert("known_locales", &known);
11991    ctx.insert("known_locales_meta", &serde_json::Value::Object(meta));
11992}
11993
11994pub async fn locale_new_form(
11995    State(state): State<super::AdminState>,
11996    tenant: Tenant,
11997    headers: HeaderMap,
11998    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
11999) -> Result<Response, AdminError> {
12000    let mut ctx = Context::new();
12001    add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
12002    add_admin_theme(&mut ctx, tenant.pool()).await;
12003    insert_known_locales(&mut ctx);
12004    ctx.insert("mode", "new");
12005    ctx.insert(
12006        "locale",
12007        &serde_json::json!({
12008            "code": "",
12009            "name": "",
12010            "is_default": false,
12011            "active": true,
12012            "sort_order": 100,
12013        }),
12014    );
12015    render_with_csrf(&state, &headers, "rcms_admin/locale_form.html", &mut ctx)
12016}
12017
12018#[derive(Debug, Deserialize)]
12019pub struct LocaleForm {
12020    pub code: String,
12021    pub name: String,
12022    #[serde(default)]
12023    pub is_default: Option<String>,
12024    #[serde(default)]
12025    pub active: Option<String>,
12026    #[serde(default)]
12027    pub sort_order: Option<i32>,
12028}
12029
12030impl LocaleForm {
12031    fn parsed_default(&self) -> bool {
12032        self.is_default.is_some()
12033    }
12034    fn parsed_active(&self) -> bool {
12035        self.active.is_some()
12036    }
12037    fn parsed_sort_order(&self) -> i32 {
12038        self.sort_order.unwrap_or(100)
12039    }
12040}
12041
12042pub async fn locale_new_submit(
12043    State(_state): State<super::AdminState>,
12044    tenant: Tenant,
12045    headers: HeaderMap,
12046    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12047    Form(form): Form<LocaleForm>,
12048) -> Result<Response, AdminError> {
12049    use rustango::sql::Auto;
12050    let name = form.name.trim().to_owned();
12051    if name.is_empty() {
12052        return Err(AdminError::Validation(
12053            "Display name is required.".to_owned(),
12054        ));
12055    }
12056    let mut row = Locale {
12057        id: Auto::Unset,
12058        code: crate::locale::validate_code(&form.code).map_err(AdminError::Validation)?,
12059        name,
12060        is_default: form.parsed_default(),
12061        active: form.parsed_active(),
12062        sort_order: form.parsed_sort_order(),
12063        created_at: Auto::Unset,
12064    };
12065    if row.is_default {
12066        clear_default_flag(&tenant, None).await?;
12067    }
12068    row.insert_pool(tenant.pool()).await?;
12069    redirect_named_with_message_args(
12070        "rcms-admin:locales:list",
12071        MsgLevel::Success,
12072        "Added locale {name} ({code}).",
12073        &[("name", row.name.as_str()), ("code", row.code.as_str())],
12074        &headers,
12075    )
12076}
12077
12078pub async fn locale_edit_form(
12079    State(state): State<super::AdminState>,
12080    tenant: Tenant,
12081    headers: HeaderMap,
12082    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12083    Path(id): Path<i64>,
12084) -> Result<Response, AdminError> {
12085    let row = Locale::objects()
12086        .where_(Locale::id.eq(id))
12087        .first(tenant.pool())
12088        .await?
12089        .ok_or(AdminError::NotFound(id))?;
12090    let mut ctx = Context::new();
12091    add_chrome(&mut ctx, &tenant, "locales", session_user.as_ref()).await;
12092    add_admin_theme(&mut ctx, tenant.pool()).await;
12093    insert_known_locales(&mut ctx);
12094    ctx.insert("mode", "edit");
12095    ctx.insert("locale", &row);
12096    render_with_csrf(&state, &headers, "rcms_admin/locale_form.html", &mut ctx)
12097}
12098
12099pub async fn locale_edit_submit(
12100    State(_state): State<super::AdminState>,
12101    tenant: Tenant,
12102    headers: HeaderMap,
12103    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12104    Path(id): Path<i64>,
12105    Form(form): Form<LocaleForm>,
12106) -> Result<Response, AdminError> {
12107    let mut row = Locale::objects()
12108        .where_(Locale::id.eq(id))
12109        .first(tenant.pool())
12110        .await?
12111        .ok_or(AdminError::NotFound(id))?;
12112    let name = form.name.trim().to_owned();
12113    if name.is_empty() {
12114        return Err(AdminError::Validation(
12115            "Display name is required.".to_owned(),
12116        ));
12117    }
12118    row.code = crate::locale::validate_code(&form.code).map_err(AdminError::Validation)?;
12119    row.name = name;
12120    row.is_default = form.parsed_default();
12121    row.active = form.parsed_active();
12122    row.sort_order = form.parsed_sort_order();
12123    if row.is_default {
12124        clear_default_flag(&tenant, Some(id)).await?;
12125    }
12126    row.save_pool(tenant.pool()).await?;
12127    redirect_named_with_message_args(
12128        "rcms-admin:locales:list",
12129        MsgLevel::Success,
12130        "Saved locale {name} ({code}).",
12131        &[("name", row.name.as_str()), ("code", row.code.as_str())],
12132        &headers,
12133    )
12134}
12135
12136pub async fn locale_delete_submit(
12137    State(_state): State<super::AdminState>,
12138    tenant: Tenant,
12139    headers: HeaderMap,
12140    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12141    Path(id): Path<i64>,
12142) -> Result<Response, AdminError> {
12143    let row = Locale::objects()
12144        .where_(Locale::id.eq(id))
12145        .first(tenant.pool())
12146        .await?
12147        .ok_or(AdminError::NotFound(id))?;
12148    if row.is_default {
12149        return redirect_named_with_message(
12150            "rcms-admin:locales:list",
12151            MsgLevel::Error,
12152            "Cannot delete the default locale — promote another locale to default first.",
12153            &headers,
12154        );
12155    }
12156    let label = format!("{} ({})", row.name, row.code);
12157    // Translations reference the locale; they go with it, in one step,
12158    // or the foreign keys refuse the delete.
12159    let pages = crate::translation::Translation::objects()
12160        .where_(crate::translation::Translation::locale_id.eq(id))
12161        .compile_delete()
12162        .map_err(rustango::sql::ExecError::from)?;
12163    let snippets = crate::snippet_translation::SnippetTranslation::objects()
12164        .where_(crate::snippet_translation::SnippetTranslation::locale_id.eq(id))
12165        .compile_delete()
12166        .map_err(rustango::sql::ExecError::from)?;
12167    let menus = crate::menu_item_translation::MenuItemTranslation::objects()
12168        .where_(crate::menu_item_translation::MenuItemTranslation::locale_id.eq(id))
12169        .compile_delete()
12170        .map_err(rustango::sql::ExecError::from)?;
12171    let categories = crate::category_translation::CategoryTranslation::objects()
12172        .where_(crate::category_translation::CategoryTranslation::locale_id.eq(id))
12173        .compile_delete()
12174        .map_err(rustango::sql::ExecError::from)?;
12175    rustango::atomic!(tenant.pool(), |tx| {
12176        let mut guard = tx.lock().await?;
12177        let tx = &mut *guard;
12178        for q in [&pages, &snippets, &menus, &categories] {
12179            rustango::sql::delete_tx(tx, q).await?;
12180        }
12181        row.delete_tx(tx).await?;
12182        Ok::<_, rustango::sql::ExecError>(())
12183    })
12184    .await?;
12185    redirect_named_with_message_args(
12186        "rcms-admin:locales:list",
12187        MsgLevel::Success,
12188        "Deleted locale {label}.",
12189        &[("label", label.as_str())],
12190        &headers,
12191    )
12192}
12193
12194// ============================================================ SSO Providers
12195//
12196// Admin-managed, DB-backed multi-provider SSO (the framework's
12197// `rustango::admin::SsoProvider`, one row per configurable OIDC/social
12198// provider). Each enabled row becomes a "Sign in with …" button on the
12199// login page (`/login/sso/{slug}`). This is the UI that replaces hand-
12200// editing `rustango_sso_providers` — mirrors the Locales CRUD.
12201
12202/// Built-in provider presets offered in the `kind` dropdown, plus generic
12203/// `oidc` (needs an issuer URL). Free-text isn't allowed — the framework
12204/// only knows these preset keys + `oidc`.
12205const SSO_KINDS: &[(&str, &str)] = &[
12206    ("google", "Google"),
12207    ("microsoft", "Microsoft"),
12208    ("github", "GitHub"),
12209    ("gitlab", "GitLab"),
12210    ("discord", "Discord"),
12211    ("oidc", "Generic OpenID Connect"),
12212];
12213
12214/// Serialize a `SsoProvider` row to JSON for the templates. The framework
12215/// model isn't `Serialize`, so map the fields by hand.
12216fn sso_provider_json(p: &rustango::admin::SsoProvider) -> serde_json::Value {
12217    serde_json::json!({
12218        "id": p.id.get().copied().unwrap_or_default(),
12219        "slug": p.slug,
12220        "label": p.label,
12221        "kind": p.kind,
12222        "issuer_url": p.issuer_url,
12223        "client_id": p.client_id,
12224        // Never surface the secret itself — just whether one is set (for the
12225        // edit form's "leave blank to keep" hint).
12226        "has_secret": !p.client_secret.is_empty(),
12227        "enabled": p.enabled,
12228        "sort_order": p.sort_order,
12229        "scopes": p.scopes,
12230    })
12231}
12232
12233pub async fn sso_provider_list(
12234    State(state): State<super::AdminState>,
12235    tenant: Tenant,
12236    headers: HeaderMap,
12237    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12238) -> Result<Response, AdminError> {
12239    // Identity administration is superuser-only (#672).
12240    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12241        return Ok(redirect);
12242    }
12243    use rustango::sql::FetcherPool as _;
12244    let mut items: Vec<rustango::admin::SsoProvider> = rustango::admin::SsoProvider::objects()
12245        .fetch(tenant.pool())
12246        .await
12247        .unwrap_or_default();
12248    items.sort_by(|a, b| a.sort_order.cmp(&b.sort_order).then(a.slug.cmp(&b.slug)));
12249    let rows: Vec<serde_json::Value> = items.iter().map(sso_provider_json).collect();
12250    let mut ctx = Context::new();
12251    add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12252    add_admin_theme(&mut ctx, tenant.pool()).await;
12253    ctx.insert("items", &rows);
12254    render_with_csrf(
12255        &state,
12256        &headers,
12257        "rcms_admin/sso_provider_list.html",
12258        &mut ctx,
12259    )
12260}
12261
12262#[derive(Deserialize)]
12263pub struct SsoProviderForm {
12264    pub slug: String,
12265    pub label: String,
12266    pub kind: String,
12267    #[serde(default)]
12268    pub issuer_url: String,
12269    pub client_id: String,
12270    /// The raw OAuth client secret. On edit, blank means "keep the current one"
12271    /// (the field is never pre-filled — it's write-only).
12272    #[serde(default)]
12273    pub client_secret: String,
12274    #[serde(default)]
12275    pub scopes: String,
12276    #[serde(default)]
12277    pub enabled: Option<String>,
12278    #[serde(default)]
12279    pub sort_order: Option<i32>,
12280}
12281
12282impl SsoProviderForm {
12283    /// Validate + normalize the form into field values, or an error message.
12284    fn validated(&self) -> Result<ValidatedProvider, String> {
12285        let slug = self.slug.trim().to_lowercase();
12286        if slug.is_empty()
12287            || !slug
12288                .chars()
12289                .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
12290        {
12291            return Err(
12292                "Slug is required and may only contain letters, numbers, - and _.".to_owned(),
12293            );
12294        }
12295        let label = self.label.trim().to_owned();
12296        if label.is_empty() {
12297            return Err("Button label is required.".to_owned());
12298        }
12299        let kind = self.kind.trim().to_lowercase();
12300        if !SSO_KINDS.iter().any(|(k, _)| *k == kind) {
12301            return Err("Pick a provider type.".to_owned());
12302        }
12303        let client_id = self.client_id.trim().to_owned();
12304        if client_id.is_empty() {
12305            return Err("Client ID is required.".to_owned());
12306        }
12307        let issuer = self.issuer_url.trim().to_owned();
12308        if kind == "oidc" && issuer.is_empty() {
12309            return Err("A generic OpenID Connect provider needs an issuer URL.".to_owned());
12310        }
12311        let scopes = self.scopes.trim().to_owned();
12312        Ok(ValidatedProvider {
12313            slug,
12314            label,
12315            kind,
12316            issuer_url: (!issuer.is_empty()).then_some(issuer),
12317            client_id,
12318            scopes: (!scopes.is_empty()).then_some(scopes),
12319            enabled: self.enabled.is_some(),
12320            sort_order: self.sort_order.unwrap_or(0),
12321        })
12322    }
12323}
12324
12325struct ValidatedProvider {
12326    slug: String,
12327    label: String,
12328    kind: String,
12329    issuer_url: Option<String>,
12330    client_id: String,
12331    scopes: Option<String>,
12332    enabled: bool,
12333    sort_order: i32,
12334}
12335
12336fn render_sso_provider_form(ctx: &mut Context, mode: &str, provider: serde_json::Value) {
12337    let kinds: Vec<serde_json::Value> = SSO_KINDS
12338        .iter()
12339        .map(|(k, name)| serde_json::json!({ "key": k, "name": name }))
12340        .collect();
12341    ctx.insert("mode", mode);
12342    ctx.insert("kinds", &kinds);
12343    ctx.insert("provider", &provider);
12344}
12345
12346pub async fn sso_provider_new_form(
12347    State(state): State<super::AdminState>,
12348    tenant: Tenant,
12349    headers: HeaderMap,
12350    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12351) -> Result<Response, AdminError> {
12352    // Identity administration is superuser-only (#672).
12353    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12354        return Ok(redirect);
12355    }
12356    let mut ctx = Context::new();
12357    add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12358    add_admin_theme(&mut ctx, tenant.pool()).await;
12359    render_sso_provider_form(
12360        &mut ctx,
12361        "new",
12362        serde_json::json!({
12363            "slug": "", "label": "", "kind": "google", "issuer_url": null,
12364            "client_id": "", "has_secret": false, "scopes": null,
12365            "enabled": true, "sort_order": 0,
12366        }),
12367    );
12368    render_with_csrf(
12369        &state,
12370        &headers,
12371        "rcms_admin/sso_provider_form.html",
12372        &mut ctx,
12373    )
12374}
12375
12376async fn find_sso_provider(
12377    tenant: &Tenant,
12378    id: i64,
12379) -> Result<rustango::admin::SsoProvider, AdminError> {
12380    use rustango::sql::FetcherPool as _;
12381    rustango::admin::SsoProvider::objects()
12382        .filter("id", id)
12383        .fetch(tenant.pool())
12384        .await
12385        .map_err(|e| AdminError::Validation(format!("db: {e}")))?
12386        .into_iter()
12387        .next()
12388        .ok_or(AdminError::NotFound(id))
12389}
12390
12391pub async fn sso_provider_edit_form(
12392    State(state): State<super::AdminState>,
12393    tenant: Tenant,
12394    headers: HeaderMap,
12395    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12396    Path(id): Path<i64>,
12397) -> Result<Response, AdminError> {
12398    // Identity administration is superuser-only (#672).
12399    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12400        return Ok(redirect);
12401    }
12402    let row = find_sso_provider(&tenant, id).await?;
12403    let mut ctx = Context::new();
12404    add_chrome(&mut ctx, &tenant, "sso-providers", session_user.as_ref()).await;
12405    add_admin_theme(&mut ctx, tenant.pool()).await;
12406    render_sso_provider_form(&mut ctx, "edit", sso_provider_json(&row));
12407    render_with_csrf(
12408        &state,
12409        &headers,
12410        "rcms_admin/sso_provider_form.html",
12411        &mut ctx,
12412    )
12413}
12414
12415pub async fn sso_provider_new_submit(
12416    State(_state): State<super::AdminState>,
12417    tenant: Tenant,
12418    headers: HeaderMap,
12419    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12420    Form(form): Form<SsoProviderForm>,
12421) -> Result<Response, AdminError> {
12422    // Identity administration is superuser-only (#672).
12423    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12424        return Ok(redirect);
12425    }
12426    let v = form.validated().map_err(AdminError::Validation)?;
12427    let secret = form.client_secret.trim().to_owned();
12428    if secret.is_empty() {
12429        return Err(AdminError::Validation(
12430            "Client secret is required.".to_owned(),
12431        ));
12432    }
12433    let mut row = rustango::admin::SsoProvider {
12434        id: rustango::sql::Auto::Unset,
12435        slug: v.slug,
12436        label: v.label,
12437        kind: v.kind,
12438        issuer_url: v.issuer_url,
12439        client_id: v.client_id,
12440        client_secret: rustango::casts::Cast::new(secret),
12441        enabled: v.enabled,
12442        sort_order: v.sort_order,
12443        scopes: v.scopes,
12444        allow_email_link: false,
12445        created_at: rustango::sql::Auto::Unset,
12446        updated_at: rustango::sql::Auto::Unset,
12447    };
12448    row.insert_pool(tenant.pool()).await?;
12449    redirect_named_with_message_args(
12450        "rcms-admin:sso-providers:list",
12451        MsgLevel::Success,
12452        "Added SSO provider {label}.",
12453        &[("label", row.label.as_str())],
12454        &headers,
12455    )
12456}
12457
12458pub async fn sso_provider_edit_submit(
12459    State(_state): State<super::AdminState>,
12460    tenant: Tenant,
12461    headers: HeaderMap,
12462    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12463    Path(id): Path<i64>,
12464    Form(form): Form<SsoProviderForm>,
12465) -> Result<Response, AdminError> {
12466    // Identity administration is superuser-only (#672).
12467    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12468        return Ok(redirect);
12469    }
12470    let mut row = find_sso_provider(&tenant, id).await?;
12471    let v = form.validated().map_err(AdminError::Validation)?;
12472    row.slug = v.slug;
12473    row.label = v.label;
12474    row.kind = v.kind;
12475    row.issuer_url = v.issuer_url;
12476    row.client_id = v.client_id;
12477    // Write-only secret: only replace it when a new one was typed; a blank
12478    // field keeps the stored (encrypted) value.
12479    let new_secret = form.client_secret.trim();
12480    if !new_secret.is_empty() {
12481        row.client_secret = rustango::casts::Cast::new(new_secret.to_owned());
12482    }
12483    row.enabled = v.enabled;
12484    row.sort_order = v.sort_order;
12485    row.scopes = v.scopes;
12486    row.save_pool(tenant.pool()).await?;
12487    redirect_named_with_message_args(
12488        "rcms-admin:sso-providers:list",
12489        MsgLevel::Success,
12490        "Saved SSO provider {label}.",
12491        &[("label", row.label.as_str())],
12492        &headers,
12493    )
12494}
12495
12496pub async fn sso_provider_delete_submit(
12497    State(_state): State<super::AdminState>,
12498    tenant: Tenant,
12499    headers: HeaderMap,
12500    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12501    Path(id): Path<i64>,
12502) -> Result<Response, AdminError> {
12503    // Identity administration is superuser-only (#672).
12504    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
12505        return Ok(redirect);
12506    }
12507    let row = find_sso_provider(&tenant, id).await?;
12508    let label = row.label.clone();
12509    row.delete_pool(tenant.pool()).await?;
12510    redirect_named_with_message_args(
12511        "rcms-admin:sso-providers:list",
12512        MsgLevel::Success,
12513        "Deleted SSO provider {label}.",
12514        &[("label", label.as_str())],
12515        &headers,
12516    )
12517}
12518
12519/// Clear `is_default = true` on every other row so the new default
12520/// row owns the flag uniquely. Optionally exclude an id when
12521/// editing the same row.
12522async fn clear_default_flag(tenant: &Tenant, except: Option<i64>) -> Result<(), AdminError> {
12523    let rows: Vec<Locale> = Locale::objects()
12524        .where_(Locale::is_default.eq(true))
12525        .fetch(tenant.pool())
12526        .await?;
12527    for mut r in rows {
12528        if let (Some(skip), Some(id)) = (except, r.id.get().copied()) {
12529            if skip == id {
12530                continue;
12531            }
12532        }
12533        r.is_default = false;
12534        r.save_pool(tenant.pool()).await?;
12535    }
12536    Ok(())
12537}
12538
12539// =====================================================================
12540// Workflows — multi-step approval CRUD (#73 PR 1)
12541// =====================================================================
12542
12543pub async fn workflows_list(
12544    State(state): State<super::AdminState>,
12545    tenant: Tenant,
12546    headers: HeaderMap,
12547    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12548) -> Result<Response, AdminError> {
12549    let items: Vec<crate::workflow::Workflow> = crate::workflow::Workflow::objects()
12550        .order_by(&[("name", false)])
12551        .fetch(tenant.pool())
12552        .await?;
12553    // Task counts per workflow — surfaced in the list as a quick
12554    // indicator. One query for all tasks; bucket client-side.
12555    let all_tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12556        .fetch(tenant.pool())
12557        .await?;
12558    let mut task_counts: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
12559    for t in &all_tasks {
12560        *task_counts.entry(t.workflow_id).or_insert(0) += 1;
12561    }
12562    let rows: Vec<serde_json::Value> = items
12563        .iter()
12564        .map(|w| {
12565            let id = w.id.get().copied().unwrap_or_default();
12566            serde_json::json!({
12567                "id": id,
12568                "name": w.name,
12569                "description": w.description,
12570                "active": w.active,
12571                "require_reapproval_on_edit": w.require_reapproval_on_edit,
12572                "task_count": task_counts.get(&id).copied().unwrap_or(0),
12573                "created_at": w.created_at.get().copied(),
12574            })
12575        })
12576        .collect();
12577    let mut ctx = Context::new();
12578    add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12579    add_admin_theme(&mut ctx, tenant.pool()).await;
12580    ctx.insert("items", &rows);
12581    render_with_csrf(&state, &headers, "rcms_admin/workflow_list.html", &mut ctx)
12582}
12583
12584pub async fn workflow_new_form(
12585    State(state): State<super::AdminState>,
12586    tenant: Tenant,
12587    headers: HeaderMap,
12588    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12589) -> Result<Response, AdminError> {
12590    let mut ctx = Context::new();
12591    add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12592    add_admin_theme(&mut ctx, tenant.pool()).await;
12593    ctx.insert("mode", "new");
12594    ctx.insert(
12595        "workflow",
12596        &serde_json::json!({
12597            "name": "",
12598            "description": "",
12599            "active": true,
12600            "require_reapproval_on_edit": false,
12601        }),
12602    );
12603    ctx.insert("tasks", &Vec::<serde_json::Value>::new());
12604    ctx.insert("roles", &Vec::<serde_json::Value>::new());
12605    render_with_csrf(&state, &headers, "rcms_admin/workflow_form.html", &mut ctx)
12606}
12607
12608#[derive(Debug, Deserialize)]
12609pub struct WorkflowForm {
12610    pub name: String,
12611    #[serde(default)]
12612    pub description: String,
12613    #[serde(default)]
12614    pub active: Option<String>,
12615    #[serde(default)]
12616    pub require_reapproval_on_edit: Option<String>,
12617}
12618
12619impl WorkflowForm {
12620    fn parsed_active(&self) -> bool {
12621        self.active.is_some()
12622    }
12623    fn parsed_reapproval(&self) -> bool {
12624        self.require_reapproval_on_edit.is_some()
12625    }
12626}
12627
12628pub async fn workflow_new_submit(
12629    State(_state): State<super::AdminState>,
12630    tenant: Tenant,
12631    headers: HeaderMap,
12632    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12633    Form(form): Form<WorkflowForm>,
12634) -> Result<Response, AdminError> {
12635    use rustango::sql::Auto;
12636    let name = form.name.trim().to_owned();
12637    if name.is_empty() {
12638        return redirect_named_with_message(
12639            "rcms-admin:workflows:list",
12640            MsgLevel::Error,
12641            "Workflow name is required.",
12642            &headers,
12643        );
12644    }
12645    let mut row = crate::workflow::Workflow {
12646        id: Auto::Unset,
12647        name: name.clone(),
12648        description: form.description.trim().to_owned(),
12649        active: form.parsed_active(),
12650        require_reapproval_on_edit: form.parsed_reapproval(),
12651        created_at: Auto::Unset,
12652        updated_at: Auto::Unset,
12653    };
12654    row.insert_pool(tenant.pool()).await?;
12655    let id = row.id.get().copied().unwrap_or_default();
12656    redirect_named_with_params_and_message_args(
12657        "rcms-admin:workflows:edit",
12658        &[("id", id.to_string())],
12659        MsgLevel::Success,
12660        "Created workflow “{name}”. Add review steps below.",
12661        &[("name", name.as_str())],
12662        &headers,
12663    )
12664}
12665
12666pub async fn workflow_edit_form(
12667    State(state): State<super::AdminState>,
12668    tenant: Tenant,
12669    headers: HeaderMap,
12670    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
12671    Path(id): Path<i64>,
12672) -> Result<Response, AdminError> {
12673    let row = crate::workflow::Workflow::objects()
12674        .where_(crate::workflow::Workflow::id.eq(id))
12675        .first(tenant.pool())
12676        .await?
12677        .ok_or(AdminError::NotFound(id))?;
12678    let tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12679        .where_(crate::workflow::WorkflowTask::workflow_id.eq(id))
12680        .order_by(&[("sort_order", false), ("id", false)])
12681        .fetch(tenant.pool())
12682        .await?;
12683    // Role picker — every tenant role is a valid assignee for a
12684    // task. Sort alphabetically for predictable ordering.
12685    let roles: Vec<rustango::tenancy::permissions::Role> =
12686        rustango::tenancy::permissions::Role::objects()
12687            .order_by(&[("name", false)])
12688            .fetch(tenant.pool())
12689            .await?;
12690    let role_rows: Vec<serde_json::Value> = roles
12691        .iter()
12692        .map(|r| {
12693            serde_json::json!({
12694                "id": r.id.get().copied(),
12695                "name": r.name,
12696            })
12697        })
12698        .collect();
12699    let role_by_id: std::collections::HashMap<i64, String> = roles
12700        .iter()
12701        .filter_map(|r| r.id.get().copied().map(|id| (id, r.name.clone())))
12702        .collect();
12703    let task_rows: Vec<serde_json::Value> = tasks
12704        .iter()
12705        .map(|t| {
12706            serde_json::json!({
12707                "id": t.id.get().copied(),
12708                "name": t.name,
12709                "role_id": t.role_id,
12710                "role_name": role_by_id.get(&t.role_id).cloned().unwrap_or_default(),
12711                "sort_order": t.sort_order,
12712                "kind": t.kind,
12713                "webhook_url": t.webhook_url,
12714            })
12715        })
12716        .collect();
12717    // #191 — every registered task kind, surfaced to the template
12718    // so the Add-step form can offer the kind picker.
12719    // A person's approval first: it's what a review step normally is,
12720    // and the pre-selected kind.
12721    let mut task_kinds: Vec<serde_json::Value> = crate::task_kind::registered_kinds()
12722        .iter()
12723        .map(|k| {
12724            serde_json::json!({
12725                "name": k.kind_name(),
12726                "verbose_name": k.verbose_name(),
12727            })
12728        })
12729        .collect();
12730    task_kinds.sort_by_key(|k| k["name"] != "group_approval");
12731    let kind_label = |name: &str| {
12732        crate::task_kind::registered_kinds()
12733            .iter()
12734            .find(|k| k.kind_name() == name)
12735            .map_or_else(|| name.to_owned(), |k| k.verbose_name().to_owned())
12736    };
12737    let task_rows: Vec<serde_json::Value> = task_rows
12738        .into_iter()
12739        .map(|mut t| {
12740            let label = kind_label(t["kind"].as_str().unwrap_or_default());
12741            t["kind_label"] = serde_json::Value::String(label);
12742            t
12743        })
12744        .collect();
12745    let mut ctx = Context::new();
12746    add_chrome(&mut ctx, &tenant, "workflows", session_user.as_ref()).await;
12747    add_admin_theme(&mut ctx, tenant.pool()).await;
12748    ctx.insert("mode", "edit");
12749    ctx.insert("workflow", &row);
12750    ctx.insert("tasks", &task_rows);
12751    ctx.insert("roles", &role_rows);
12752    ctx.insert("task_kinds", &task_kinds);
12753    render_with_csrf(&state, &headers, "rcms_admin/workflow_form.html", &mut ctx)
12754}
12755
12756pub async fn workflow_edit_submit(
12757    State(_state): State<super::AdminState>,
12758    tenant: Tenant,
12759    headers: HeaderMap,
12760    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12761    Path(id): Path<i64>,
12762    Form(form): Form<WorkflowForm>,
12763) -> Result<Response, AdminError> {
12764    let mut row = crate::workflow::Workflow::objects()
12765        .where_(crate::workflow::Workflow::id.eq(id))
12766        .first(tenant.pool())
12767        .await?
12768        .ok_or(AdminError::NotFound(id))?;
12769    let old_name = row.name.clone();
12770    row.name = form.name.trim().to_owned();
12771    row.description = form.description.trim().to_owned();
12772    row.active = form.parsed_active();
12773    row.require_reapproval_on_edit = form.parsed_reapproval();
12774    row.save_pool(tenant.pool()).await?;
12775    // Page types name their workflow; a rename must move them along, or
12776    // their pages would silently publish without review.
12777    if old_name != row.name {
12778        crate::workflow::rebind_page_types(tenant.pool(), &old_name, &row.name).await?;
12779    }
12780    redirect_named_with_params_and_message_args(
12781        "rcms-admin:workflows:edit",
12782        &[("id", id.to_string())],
12783        MsgLevel::Success,
12784        "Saved workflow “{name}”.",
12785        &[("name", row.name.as_str())],
12786        &headers,
12787    )
12788}
12789
12790pub async fn workflow_delete_submit(
12791    State(_state): State<super::AdminState>,
12792    tenant: Tenant,
12793    headers: HeaderMap,
12794    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12795    Path(id): Path<i64>,
12796) -> Result<Response, AdminError> {
12797    let row = crate::workflow::Workflow::objects()
12798        .where_(crate::workflow::Workflow::id.eq(id))
12799        .first(tenant.pool())
12800        .await?
12801        .ok_or(AdminError::NotFound(id))?;
12802    // Page types that use it would quietly stop requiring review.
12803    let users: Vec<String> = crate::workflow::page_types_using(tenant.pool(), &row.name)
12804        .await?
12805        .into_iter()
12806        .map(|pt| pt.verbose_name)
12807        .collect();
12808    if !users.is_empty() {
12809        let types = users.join(", ");
12810        return redirect_named_with_message_args(
12811            "rcms-admin:workflows:list",
12812            MsgLevel::Error,
12813            "Can't delete “{title}” — the page types {types} use it. Choose another workflow for them first.",
12814            &[("title", row.name.as_str()), ("types", types.as_str())],
12815            &headers,
12816        );
12817    }
12818    // Reject when any WorkflowState references this workflow — the
12819    // audit trail would otherwise lose its parent FK. Editors should
12820    // toggle `active = false` instead.
12821    let in_use: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
12822        .where_(crate::workflow::WorkflowState::workflow_id.eq(id))
12823        .fetch(tenant.pool())
12824        .await?;
12825    if !in_use.is_empty() {
12826        let count = in_use.len().to_string();
12827        return redirect_named_with_message_plural(
12828            "rcms-admin:workflows:list",
12829            MsgLevel::Error,
12830            "Can't delete “{title}” — {count} page(s) have history under it. Toggle Active off instead.",
12831            in_use.len() as i64,
12832            &[("title", row.name.as_str()), ("count", count.as_str())],
12833            &headers,
12834        );
12835    }
12836    // Cascade the task rows by hand (FK isn't ON DELETE CASCADE).
12837    let tasks: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12838        .where_(crate::workflow::WorkflowTask::workflow_id.eq(id))
12839        .fetch(tenant.pool())
12840        .await?;
12841    for t in tasks {
12842        t.delete_pool(tenant.pool()).await?;
12843    }
12844    let name = row.name.clone();
12845    row.delete_pool(tenant.pool()).await?;
12846    redirect_named_with_message_args(
12847        "rcms-admin:workflows:list",
12848        MsgLevel::Success,
12849        "Deleted workflow “{name}”.",
12850        &[("name", name.as_str())],
12851        &headers,
12852    )
12853}
12854
12855#[derive(Debug, Deserialize)]
12856pub struct WorkflowTaskForm {
12857    pub name: String,
12858    pub role_id: i64,
12859    /// Task kind discriminator. Defaults to `group_approval`
12860    /// when the form input is missing or empty so the existing
12861    /// human-approval flow stays the default behavior.
12862    #[serde(default)]
12863    pub kind: Option<String>,
12864    #[serde(default)]
12865    pub webhook_url: Option<String>,
12866}
12867
12868pub async fn workflow_task_add(
12869    State(_state): State<super::AdminState>,
12870    tenant: Tenant,
12871    headers: HeaderMap,
12872    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12873    Path(workflow_id): Path<i64>,
12874    Form(form): Form<WorkflowTaskForm>,
12875) -> Result<Response, AdminError> {
12876    use rustango::sql::Auto;
12877    let name = form.name.trim().to_owned();
12878    if name.is_empty() {
12879        return redirect_named_with_params_and_message(
12880            "rcms-admin:workflows:edit",
12881            &[("id", workflow_id.to_string())],
12882            MsgLevel::Error,
12883            "Step name is required.",
12884            &headers,
12885        );
12886    }
12887    let existing: Vec<crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
12888        .where_(crate::workflow::WorkflowTask::workflow_id.eq(workflow_id))
12889        .order_by(&[("sort_order", true)]) // desc
12890        .fetch(tenant.pool())
12891        .await?;
12892    let next_order = existing.first().map_or(10, |t| t.sort_order + 10);
12893    let kind = form
12894        .kind
12895        .as_deref()
12896        .map(str::trim)
12897        .filter(|s| !s.is_empty())
12898        .filter(|s| crate::task_kind::find(s).is_some())
12899        .unwrap_or("group_approval")
12900        .to_owned();
12901    let webhook_url = form
12902        .webhook_url
12903        .as_deref()
12904        .map(str::trim)
12905        .unwrap_or("")
12906        .to_owned();
12907    let mut row = crate::workflow::WorkflowTask {
12908        id: Auto::Unset,
12909        workflow_id,
12910        name: name.clone(),
12911        role_id: form.role_id,
12912        sort_order: next_order,
12913        kind,
12914        webhook_url,
12915    };
12916    row.insert_pool(tenant.pool()).await?;
12917    redirect_named_with_params_and_message_args(
12918        "rcms-admin:workflows:edit",
12919        &[("id", workflow_id.to_string())],
12920        MsgLevel::Success,
12921        "Added step “{name}”.",
12922        &[("name", name.as_str())],
12923        &headers,
12924    )
12925}
12926
12927pub async fn workflow_task_delete(
12928    State(_state): State<super::AdminState>,
12929    tenant: Tenant,
12930    headers: HeaderMap,
12931    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
12932    Path((workflow_id, task_id)): Path<(i64, i64)>,
12933) -> Result<Response, AdminError> {
12934    let row = crate::workflow::WorkflowTask::objects()
12935        .where_(crate::workflow::WorkflowTask::id.eq(task_id))
12936        .where_(crate::workflow::WorkflowTask::workflow_id.eq(workflow_id))
12937        .first(tenant.pool())
12938        .await?
12939        .ok_or(AdminError::NotFound(task_id))?;
12940    let name = row.name.clone();
12941    row.delete_pool(tenant.pool()).await?;
12942    redirect_named_with_params_and_message_args(
12943        "rcms-admin:workflows:edit",
12944        &[("id", workflow_id.to_string())],
12945        MsgLevel::Success,
12946        "Removed step “{name}”.",
12947        &[("name", name.as_str())],
12948        &headers,
12949    )
12950}
12951
12952// ---------------------------------------------------------------
12953// Per-page workflow actions (#73 PR 2): submit / approve / reject /
12954// cancel. Permission rules:
12955//   - submit: any logged-in user (page-Edit perm already gated the
12956//     editor URL).
12957//   - approve / reject: viewer must be a member of the role bound
12958//     to the current task. Tenant superusers bypass.
12959//   - cancel: any logged-in user (audit captures who).
12960// ---------------------------------------------------------------
12961
12962#[derive(Debug, Deserialize)]
12963pub struct WorkflowDecisionForm {
12964    #[serde(default)]
12965    pub comment: String,
12966    /// The step the reviewer was looking at. A decision posted
12967    /// for a step that is no longer current is refused, not applied to
12968    /// whichever step is current now.
12969    #[serde(default)]
12970    pub task_id: Option<i64>,
12971}
12972
12973/// The decision the reviewer posted is for a step that is no
12974/// longer the current one, or another request decided it first.
12975fn step_already_decided(page_id: i64, headers: &HeaderMap) -> Result<Response, AdminError> {
12976    redirect_named_with_params_and_message(
12977        "rcms-admin:pages:edit",
12978        &[("id", page_id.to_string())],
12979        MsgLevel::Error,
12980        "That review step was already decided — check the page's current step before deciding again.",
12981        headers,
12982    )
12983}
12984
12985async fn user_is_in_role(
12986    pool: &rustango::sql::Pool,
12987    user_id: i64,
12988    role_id: i64,
12989) -> Result<bool, rustango::sql::ExecError> {
12990    use rustango::core::Column as _;
12991    use rustango::sql::FetcherPool as _;
12992    let rows: Vec<rustango::tenancy::permissions::UserRole> =
12993        rustango::tenancy::permissions::UserRole::objects()
12994            .where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
12995            .where_(rustango::tenancy::permissions::UserRole::role_id.eq(role_id))
12996            .fetch(pool)
12997            .await?;
12998    Ok(!rows.is_empty())
12999}
13000
13001pub async fn page_workflow_submit(
13002    State(_state): State<super::AdminState>,
13003    tenant: Tenant,
13004    headers: HeaderMap,
13005    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13006    Path(id): Path<i64>,
13007) -> Result<Response, AdminError> {
13008    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
13009        return Ok(unauthorized_no_session());
13010    };
13011    let page = Page::objects()
13012        .where_(Page::id.eq(id))
13013        .first(tenant.pool())
13014        .await?
13015        .ok_or(AdminError::NotFound(id))?;
13016    // Resolve the page-type → workflow slug.
13017    let pts: Vec<PageType> = PageType::objects()
13018        .where_(PageType::id.eq(page.page_type_id))
13019        .fetch(tenant.pool())
13020        .await?;
13021    let Some(pt) = pts.into_iter().next() else {
13022        return redirect_named_with_params_and_message(
13023            "rcms-admin:pages:edit",
13024            &[("id", id.to_string())],
13025            MsgLevel::Error,
13026            "Page type row not found.",
13027            &headers,
13028        );
13029    };
13030    let Some(slug) = pt.workflow_name() else {
13031        return redirect_named_with_params_and_message(
13032            "rcms-admin:pages:edit",
13033            &[("id", id.to_string())],
13034            MsgLevel::Error,
13035            "This page type isn't bound to a workflow — nothing to submit.",
13036            &headers,
13037        );
13038    };
13039    let Some(workflow) = crate::workflow::find_by_name(tenant.pool(), &slug).await? else {
13040        return redirect_named_with_params_and_message_args(
13041            "rcms-admin:pages:edit",
13042            &[("id", id.to_string())],
13043            MsgLevel::Error,
13044            "Workflow `{slug}` not found or inactive — ask an admin to enable it.",
13045            &[("slug", slug.as_str())],
13046            &headers,
13047        );
13048    };
13049    let tasks = crate::workflow::tasks_for(
13050        tenant.pool(),
13051        workflow.id.get().copied().unwrap_or_default(),
13052    )
13053    .await?;
13054    if tasks.is_empty() {
13055        return redirect_named_with_params_and_message(
13056            "rcms-admin:pages:edit",
13057            &[("id", id.to_string())],
13058            MsgLevel::Error,
13059            "Workflow has no review steps yet — ask an admin to add at least one step.",
13060            &headers,
13061        );
13062    }
13063    // Only block when an in-progress review already exists. A
13064    // `needs_changes` row means the prior cycle was rejected; the
13065    // author is allowed to resubmit, which leaves the rejected row
13066    // as audit history and starts a fresh cycle.
13067    if let Some(active) = crate::workflow::active_state_for_page(tenant.pool(), id).await? {
13068        if active.status == crate::workflow::WorkflowStatus::InProgress.as_str() {
13069            return redirect_named_with_params_and_message(
13070                "rcms-admin:pages:edit",
13071                &[("id", id.to_string())],
13072                MsgLevel::Warning,
13073                "This page is already under review.",
13074                &headers,
13075            );
13076        }
13077    }
13078    crate::workflow::submit_for_review(tenant.pool(), id, &workflow, &tasks, viewer_id).await?;
13079    // The submitter waits for the verdict now; their edit lock would
13080    // only stop the reviewer from editing.
13081    crate::lock::release(tenant.pool(), id, viewer_id)
13082        .await
13083        .log_warn("editor lock not released on submit");
13084
13085    // #192 — audit log the workflow submission.
13086    crate::page_log::record_or_warn(
13087        tenant.pool(),
13088        id,
13089        crate::page_log::ACTION_WORKFLOW_SUBMIT,
13090        Some(viewer_id),
13091        format!(
13092            "Submitted for review — workflow “{}”, first step “{}”.",
13093            workflow.name, tasks[0].name
13094        ),
13095        Some(serde_json::json!({
13096            "workflow_id": workflow.id.get().copied(),
13097            "workflow_name": workflow.name,
13098            "first_task": tasks[0].name,
13099        })),
13100    )
13101    .await;
13102
13103    // #85 — notify the first task's reviewers that a review is
13104    // waiting. No-op when no mailer is wired into AdminState.
13105    notify_workflow(
13106        _state.mailer.as_deref(),
13107        &_state.mailer_from,
13108        tenant.pool(),
13109        &tenant.org.slug,
13110        "submit",
13111        &workflow.name,
13112        &page.title,
13113        id,
13114        Some(&tasks[0].name),
13115        session_user.as_ref().map(|u| u.username.as_str()),
13116        None,
13117        WorkflowRecipients::Role(tasks[0].role_id),
13118    )
13119    .await;
13120
13121    redirect_named_with_params_and_message_args(
13122        "rcms-admin:pages:edit",
13123        &[("id", id.to_string())],
13124        MsgLevel::Success,
13125        "Submitted for review — first step: “{name}”.",
13126        &[("name", tasks[0].name.as_str())],
13127        &headers,
13128    )
13129}
13130
13131/// Recipient selector for [`notify_workflow`].
13132enum WorkflowRecipients {
13133    /// Members of a single role (reviewers on the active task).
13134    Role(i64),
13135    /// A single user — used to notify the original submitter on
13136    /// approve-finish / reject / cancel.
13137    User(i64),
13138}
13139
13140/// Helper invoked by the workflow handlers to dispatch the right
13141/// notification per event. Resolves recipients, composes subject +
13142/// body, and hands off to the framework's `Mailer`. No-op if the
13143/// AdminState has no mailer attached.
13144#[allow(clippy::too_many_arguments)]
13145async fn notify_workflow(
13146    mailer: Option<&dyn rustango::email::Mailer>,
13147    from: &str,
13148    pool: &rustango::sql::Pool,
13149    tenant_slug: &str,
13150    event: &str,
13151    workflow_name: &str,
13152    page_title: &str,
13153    page_id: i64,
13154    task_name: Option<&str>,
13155    actor_username: Option<&str>,
13156    comment: Option<&str>,
13157    recipients: WorkflowRecipients,
13158) {
13159    let Some(mailer) = mailer else {
13160        return;
13161    };
13162    // #197 — resolve recipients to user_ids first so we can filter
13163    // out users who have muted this event class before composing
13164    // email bodies.
13165    let kind = crate::notification_pref::pref_kind_for_workflow_event(event);
13166    let candidate_user_ids: Vec<i64> = match recipients {
13167        WorkflowRecipients::Role(role_id) => {
13168            crate::workflow_mail::role_member_user_ids(pool, role_id)
13169                .await
13170                .unwrap_or_default()
13171        }
13172        WorkflowRecipients::User(user_id) => vec![user_id],
13173    };
13174    let allowed_ids = crate::notification_pref::filter_enabled(pool, &candidate_user_ids, kind)
13175        .await
13176        .unwrap_or(candidate_user_ids);
13177    let mut pairs: Vec<(String, String)> = Vec::with_capacity(allowed_ids.len());
13178    for uid in allowed_ids {
13179        if let Ok(Some(pair)) = crate::workflow_mail::user_email(pool, uid, tenant_slug).await {
13180            pairs.push(pair);
13181        }
13182    }
13183    if pairs.is_empty() {
13184        return;
13185    }
13186    let (subject, body) = crate::workflow_mail::render_notification(
13187        event,
13188        workflow_name,
13189        page_title,
13190        page_id,
13191        task_name,
13192        actor_username,
13193        comment,
13194    );
13195    crate::workflow_mail::notify_many(mailer, from, &pairs, &subject, &body).await;
13196}
13197
13198pub async fn page_workflow_approve(
13199    State(_state): State<super::AdminState>,
13200    tenant: Tenant,
13201    headers: HeaderMap,
13202    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13203    Path(id): Path<i64>,
13204    Form(form): Form<WorkflowDecisionForm>,
13205) -> Result<Response, AdminError> {
13206    let Some(viewer) = session_user.as_ref() else {
13207        return Ok(unauthorized_no_session());
13208    };
13209    let viewer_id = viewer.id.get().copied().unwrap_or_default();
13210    let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13211        return redirect_named_with_params_and_message(
13212            "rcms-admin:pages:edit",
13213            &[("id", id.to_string())],
13214            MsgLevel::Error,
13215            "No active workflow on this page.",
13216            &headers,
13217        );
13218    };
13219    let tasks = crate::workflow::tasks_for(tenant.pool(), state.workflow_id).await?;
13220    let Some(current_task) = state
13221        .current_task_id
13222        .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
13223    else {
13224        return redirect_named_with_params_and_message(
13225            "rcms-admin:pages:edit",
13226            &[("id", id.to_string())],
13227            MsgLevel::Error,
13228            "Workflow has no current task — refresh the page.",
13229            &headers,
13230        );
13231    };
13232    if !viewer.is_superuser
13233        && !user_is_in_role(tenant.pool(), viewer_id, current_task.role_id).await?
13234    {
13235        return redirect_named_with_params_and_message_args(
13236            "rcms-admin:pages:edit",
13237            &[("id", id.to_string())],
13238            MsgLevel::Error,
13239            "Only members of the task's role can approve “{name}”.",
13240            &[("name", current_task.name.as_str())],
13241            &headers,
13242        );
13243    }
13244    if form.task_id.is_some_and(|t| current_task.id.get().copied() != Some(t)) {
13245        return step_already_decided(id, &headers);
13246    }
13247    // Capture submitter_id + page title BEFORE the transition so we
13248    // can route the notification on Finished.
13249    let submitter_id = state.requested_by;
13250    let page_title: String = Page::objects()
13251        .where_(Page::id.eq(id))
13252        .fetch(tenant.pool())
13253        .await
13254        .ok()
13255        .and_then(|v| v.into_iter().next())
13256        .map(|p| p.title)
13257        .unwrap_or_else(|| format!("page #{id}"));
13258    let workflow_name: String = crate::workflow::Workflow::objects()
13259        .where_(crate::workflow::Workflow::id.eq(state.workflow_id))
13260        .fetch(tenant.pool())
13261        .await
13262        .ok()
13263        .and_then(|v| v.into_iter().next())
13264        .map(|w| w.name)
13265        .unwrap_or_else(|| "Workflow".to_owned());
13266    let outcome = crate::workflow::approve_current(
13267        tenant.pool(),
13268        &mut state,
13269        &tasks,
13270        viewer_id,
13271        &form.comment,
13272    )
13273    .await?;
13274    let msg = match outcome {
13275        crate::workflow::ApproveOutcome::AlreadyDecided => {
13276            return step_already_decided(id, &headers);
13277        }
13278        crate::workflow::ApproveOutcome::Advanced { next_task_id } => {
13279            let next = tasks
13280                .iter()
13281                .find(|t| t.id.get().copied() == Some(next_task_id));
13282            let next_name = next.map(|t| t.name.as_str()).unwrap_or("next step");
13283            // #85 — notify reviewers of the new current step.
13284            if let Some(nt) = next {
13285                notify_workflow(
13286                    _state.mailer.as_deref(),
13287                    &_state.mailer_from,
13288                    tenant.pool(),
13289                    &tenant.org.slug,
13290                    "approve_advance",
13291                    &workflow_name,
13292                    &page_title,
13293                    id,
13294                    Some(&nt.name),
13295                    Some(&viewer.username),
13296                    Some(&form.comment),
13297                    WorkflowRecipients::Role(nt.role_id),
13298                )
13299                .await;
13300            }
13301            // #192 — audit log the approve-advance.
13302            crate::page_log::record_or_warn(
13303                tenant.pool(),
13304                id,
13305                crate::page_log::ACTION_WORKFLOW_APPROVE,
13306                Some(viewer_id),
13307                format!(
13308                    "Approved “{}” — advanced to “{next_name}”.",
13309                    current_task.name
13310                ),
13311                Some(serde_json::json!({
13312                    "outcome": "advanced",
13313                    "task_name": current_task.name,
13314                    "next_task_name": next_name,
13315                    "comment": form.comment,
13316                })),
13317            )
13318            .await;
13319            format!("Approved “{}” — moved to “{next_name}”.", current_task.name)
13320        }
13321        crate::workflow::ApproveOutcome::Finished => {
13322            // Changes to the live page held for this review go live now,
13323            // through the normal save path.
13324            if let Some(pending) = crate::pending_change::for_page(tenant.pool(), id).await? {
13325                match apply_page_edit(
13326                    tenant.pool(),
13327                    &tenant.org.slug,
13328                    &_state.cache_invalidator,
13329                    _state.mailer.as_deref(),
13330                    &_state.mailer_from,
13331                    false,
13332                    id,
13333                    &pending.form_map(),
13334                    None,
13335                )
13336                .await
13337                {
13338                    Ok(Ok(_)) => crate::pending_change::discard(tenant.pool(), id).await?,
13339                    Ok(Err(_)) | Err(_) => {
13340                        tracing::warn!(page_id = id, "held change could not be applied on approval");
13341                    }
13342                }
13343            }
13344            // Auto-publish on workflow completion.
13345            if let Some(mut page) = Page::objects()
13346                .where_(Page::id.eq(id))
13347                .first(tenant.pool())
13348                .await?
13349            {
13350                page.status = crate::page::PageStatus::Published.as_str().to_owned();
13351                let now = chrono::Utc::now();
13352                if page.published_at.is_none() {
13353                    page.published_at = Some(now);
13354                }
13355                // #251 — workflow-finish publish bumps last-publish.
13356                page.last_published_at = Some(now);
13357                page.save_pool(tenant.pool()).await?;
13358                // #692 — the same go-live effects as any other publish
13359                // (search index + after_publish_page hooks), and the page's
13360                // cached URL goes too: it used to keep serving the old copy.
13361                crate::page::went_live_effects(&tenant.org.slug, &page).await;
13362                crate::task_queue::purge_urls(
13363                    _state.cache_invalidator.clone(),
13364                    tenant.org.slug.clone(),
13365                    vec![page.url_path.clone()],
13366                )
13367                .await;
13368                // #115 — notify-on-publish subscribers.
13369                crate::page_subscription::notify_publish(
13370                    _state.mailer.as_deref(),
13371                    &_state.mailer_from,
13372                    tenant.pool(),
13373                    &tenant.org.slug,
13374                    id,
13375                    &page.title,
13376                    &page.url_path,
13377                    Some(&viewer.username),
13378                )
13379                .await;
13380            }
13381            // #85 — notify the submitter that their submission shipped.
13382            notify_workflow(
13383                _state.mailer.as_deref(),
13384                &_state.mailer_from,
13385                tenant.pool(),
13386                &tenant.org.slug,
13387                "approve_finish",
13388                &workflow_name,
13389                &page_title,
13390                id,
13391                Some(&current_task.name),
13392                Some(&viewer.username),
13393                Some(&form.comment),
13394                WorkflowRecipients::User(submitter_id),
13395            )
13396            .await;
13397            // #192 — audit log the workflow-finish approval + the
13398            // auto-publish it triggered.
13399            crate::page_log::record_or_warn(
13400                tenant.pool(),
13401                id,
13402                crate::page_log::ACTION_WORKFLOW_APPROVE,
13403                Some(viewer_id),
13404                format!(
13405                    "Approved “{}” — workflow complete; page auto-published.",
13406                    current_task.name
13407                ),
13408                Some(serde_json::json!({
13409                    "outcome": "finished",
13410                    "task_name": current_task.name,
13411                    "comment": form.comment,
13412                })),
13413            )
13414            .await;
13415            crate::page_log::record_or_warn(
13416                tenant.pool(),
13417                id,
13418                crate::page_log::ACTION_PUBLISH,
13419                Some(viewer_id),
13420                "Published via workflow approval.",
13421                Some(serde_json::json!({ "via": "workflow" })),
13422            )
13423            .await;
13424            format!(
13425                "Approved “{}” — workflow complete, page published.",
13426                current_task.name
13427            )
13428        }
13429    };
13430    redirect_named_with_params_and_message(
13431        "rcms-admin:pages:edit",
13432        &[("id", id.to_string())],
13433        MsgLevel::Success,
13434        &msg,
13435        &headers,
13436    )
13437}
13438
13439pub async fn page_workflow_reject(
13440    State(_state): State<super::AdminState>,
13441    tenant: Tenant,
13442    headers: HeaderMap,
13443    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13444    Path(id): Path<i64>,
13445    Form(form): Form<WorkflowDecisionForm>,
13446) -> Result<Response, AdminError> {
13447    let Some(viewer) = session_user.as_ref() else {
13448        return Ok(unauthorized_no_session());
13449    };
13450    let viewer_id = viewer.id.get().copied().unwrap_or_default();
13451    let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13452        return redirect_named_with_params_and_message(
13453            "rcms-admin:pages:edit",
13454            &[("id", id.to_string())],
13455            MsgLevel::Error,
13456            "No active workflow on this page.",
13457            &headers,
13458        );
13459    };
13460    let tasks = crate::workflow::tasks_for(tenant.pool(), state.workflow_id).await?;
13461    let Some(current_task) = state
13462        .current_task_id
13463        .and_then(|tid| tasks.iter().find(|t| t.id.get().copied() == Some(tid)))
13464    else {
13465        return redirect_named_with_params_and_message(
13466            "rcms-admin:pages:edit",
13467            &[("id", id.to_string())],
13468            MsgLevel::Error,
13469            "Workflow has no current task — refresh the page.",
13470            &headers,
13471        );
13472    };
13473    if !viewer.is_superuser
13474        && !user_is_in_role(tenant.pool(), viewer_id, current_task.role_id).await?
13475    {
13476        return redirect_named_with_params_and_message_args(
13477            "rcms-admin:pages:edit",
13478            &[("id", id.to_string())],
13479            MsgLevel::Error,
13480            "Only members of the task's role can reject “{name}”.",
13481            &[("name", current_task.name.as_str())],
13482            &headers,
13483        );
13484    }
13485    if form.task_id.is_some_and(|t| current_task.id.get().copied() != Some(t)) {
13486        return step_already_decided(id, &headers);
13487    }
13488    if form.comment.trim().is_empty() {
13489        return redirect_named_with_params_and_message(
13490            "rcms-admin:pages:edit",
13491            &[("id", id.to_string())],
13492            MsgLevel::Error,
13493            "Say what should change — the author sees it in the review history.",
13494            &headers,
13495        );
13496    }
13497    let submitter_id = state.requested_by;
13498    let workflow_id = state.workflow_id;
13499    if !crate::workflow::reject_current(tenant.pool(), &mut state, viewer_id, &form.comment).await? {
13500        return step_already_decided(id, &headers);
13501    }
13502    // #192 — audit log the rejection.
13503    crate::page_log::record_or_warn(
13504        tenant.pool(),
13505        id,
13506        crate::page_log::ACTION_WORKFLOW_REJECT,
13507        Some(viewer_id),
13508        format!("Rejected “{}” — changes requested.", current_task.name),
13509        Some(serde_json::json!({
13510            "task_name": current_task.name,
13511            "comment": form.comment,
13512        })),
13513    )
13514    .await;
13515    // #85 — notify the submitter that changes are requested.
13516    let workflow_name: String = crate::workflow::Workflow::objects()
13517        .where_(crate::workflow::Workflow::id.eq(workflow_id))
13518        .fetch(tenant.pool())
13519        .await
13520        .ok()
13521        .and_then(|v| v.into_iter().next())
13522        .map(|w| w.name)
13523        .unwrap_or_else(|| "Workflow".to_owned());
13524    let page_title: String = Page::objects()
13525        .where_(Page::id.eq(id))
13526        .fetch(tenant.pool())
13527        .await
13528        .ok()
13529        .and_then(|v| v.into_iter().next())
13530        .map(|p| p.title)
13531        .unwrap_or_else(|| format!("page #{id}"));
13532    notify_workflow(
13533        _state.mailer.as_deref(),
13534        &_state.mailer_from,
13535        tenant.pool(),
13536        &tenant.org.slug,
13537        "reject",
13538        &workflow_name,
13539        &page_title,
13540        id,
13541        Some(&current_task.name),
13542        Some(&viewer.username),
13543        Some(&form.comment),
13544        WorkflowRecipients::User(submitter_id),
13545    )
13546    .await;
13547    redirect_named_with_params_and_message_args(
13548        "rcms-admin:pages:edit",
13549        &[("id", id.to_string())],
13550        MsgLevel::Success,
13551        "Rejected “{name}” — page returned to author for changes.",
13552        &[("name", current_task.name.as_str())],
13553        &headers,
13554    )
13555}
13556
13557pub async fn page_workflow_cancel(
13558    State(_state): State<super::AdminState>,
13559    tenant: Tenant,
13560    headers: HeaderMap,
13561    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13562    Path(id): Path<i64>,
13563) -> Result<Response, AdminError> {
13564    let Some(viewer_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
13565        return Ok(unauthorized_no_session());
13566    };
13567    let Some(mut state) = crate::workflow::active_state_for_page(tenant.pool(), id).await? else {
13568        return redirect_named_with_params_and_message(
13569            "rcms-admin:pages:edit",
13570            &[("id", id.to_string())],
13571            MsgLevel::Warning,
13572            "This page isn't currently under review.",
13573            &headers,
13574        );
13575    };
13576    let submitter_id = state.requested_by;
13577    let workflow_id = state.workflow_id;
13578    crate::workflow::cancel(tenant.pool(), &mut state, viewer_id).await?;
13579    // #192 — audit log the cancellation.
13580    crate::page_log::record_or_warn(
13581        tenant.pool(),
13582        id,
13583        crate::page_log::ACTION_WORKFLOW_CANCEL,
13584        Some(viewer_id),
13585        "Workflow cancelled.",
13586        Some(serde_json::json!({ "workflow_id": workflow_id })),
13587    )
13588    .await;
13589    // #85 — notify the submitter the review was cancelled. No-op
13590    // when the submitter is the canceller themselves (the mailer
13591    // still sends but the user's inbox is the audit trail).
13592    let workflow_name: String = crate::workflow::Workflow::objects()
13593        .where_(crate::workflow::Workflow::id.eq(workflow_id))
13594        .fetch(tenant.pool())
13595        .await
13596        .ok()
13597        .and_then(|v| v.into_iter().next())
13598        .map(|w| w.name)
13599        .unwrap_or_else(|| "Workflow".to_owned());
13600    let page_title: String = Page::objects()
13601        .where_(Page::id.eq(id))
13602        .fetch(tenant.pool())
13603        .await
13604        .ok()
13605        .and_then(|v| v.into_iter().next())
13606        .map(|p| p.title)
13607        .unwrap_or_else(|| format!("page #{id}"));
13608    let actor_username = session_user.as_ref().map(|u| u.username.as_str());
13609    notify_workflow(
13610        _state.mailer.as_deref(),
13611        &_state.mailer_from,
13612        tenant.pool(),
13613        &tenant.org.slug,
13614        "cancel",
13615        &workflow_name,
13616        &page_title,
13617        id,
13618        None,
13619        actor_username,
13620        None,
13621        WorkflowRecipients::User(submitter_id),
13622    )
13623    .await;
13624    redirect_named_with_params_and_message(
13625        "rcms-admin:pages:edit",
13626        &[("id", id.to_string())],
13627        MsgLevel::Success,
13628        "Workflow cancelled.",
13629        &headers,
13630    )
13631}
13632
13633// =====================================================================
13634// Per-page audit log CSV export (#192)
13635// =====================================================================
13636
13637/// GET /cms-admin/pages/{id}/log.csv — every audit-log entry for the
13638/// page, newest first, as CSV. Columns: timestamp, action, actor_id,
13639/// actor_username, message, data_json. The full log (no row cap)
13640/// emits — the editor explicitly clicked Download.
13641pub async fn page_log_csv(
13642    State(_state): State<super::AdminState>,
13643    tenant: Tenant,
13644    Path(id): Path<i64>,
13645) -> Result<Response, AdminError> {
13646    let entries = crate::page_log::for_page(tenant.pool(), id, None).await?;
13647    let user_ids: std::collections::BTreeSet<i64> =
13648        entries.iter().filter_map(|e| e.actor_id).collect();
13649    let users: std::collections::HashMap<i64, String> = if user_ids.is_empty() {
13650        std::collections::HashMap::new()
13651    } else {
13652        rustango::tenancy::auth::User::objects()
13653            .where_(
13654                rustango::tenancy::auth::User::id.is_in(user_ids.into_iter().collect::<Vec<_>>()),
13655            )
13656            .fetch(tenant.pool())
13657            .await?
13658            .into_iter()
13659            .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
13660            .collect()
13661    };
13662
13663    let mut out = String::with_capacity(4096);
13664    out.push_str("timestamp,action,actor_id,actor_username,message,data_json\n");
13665    for e in entries {
13666        let ts = e
13667            .created_at
13668            .get()
13669            .map(|t| t.to_rfc3339())
13670            .unwrap_or_default();
13671        let actor_id = e.actor_id.map(|i| i.to_string()).unwrap_or_default();
13672        let actor_username = e
13673            .actor_id
13674            .and_then(|uid| users.get(&uid).cloned())
13675            .unwrap_or_default();
13676        out.push_str(&csv_escape(&ts));
13677        out.push(',');
13678        out.push_str(&csv_escape(&e.action));
13679        out.push(',');
13680        out.push_str(&csv_escape(&actor_id));
13681        out.push(',');
13682        out.push_str(&csv_escape(&actor_username));
13683        out.push(',');
13684        out.push_str(&csv_escape(&e.message));
13685        out.push(',');
13686        out.push_str(&csv_escape(&e.data_json));
13687        out.push('\n');
13688    }
13689
13690    let filename = format!("page-{id}-audit-log.csv");
13691    Ok((
13692        [
13693            (
13694                axum::http::header::CONTENT_TYPE,
13695                "text/csv; charset=utf-8".to_owned(),
13696            ),
13697            (
13698                axum::http::header::CONTENT_DISPOSITION,
13699                format!("attachment; filename=\"{filename}\""),
13700            ),
13701        ],
13702        out,
13703    )
13704        .into_response())
13705}
13706
13707// =====================================================================
13708// History — tenant-wide revision audit log (#17)
13709// =====================================================================
13710
13711/// Query string for the history view. All filters optional; pagination
13712/// via `page` (1-indexed, defaults to 1 — `limit` is fixed at 50 to
13713/// keep the URL state simple).
13714#[derive(Debug, Deserialize)]
13715pub struct HistoryQuery {
13716    #[serde(default)]
13717    pub page_id: Option<i64>,
13718    #[serde(default)]
13719    pub user_id: Option<i64>,
13720    #[serde(default)]
13721    pub page: Option<u32>,
13722    /// Rows per page.
13723    #[serde(default)]
13724    pub per_page: Option<usize>,
13725}
13726
13727/// GET /cms-admin/history — tenant-wide cross-page audit log built
13728/// from `cms_revision`. Each row joins to the page (for title +
13729/// current URL) and the editor (for username). One Rust-side stitch
13730/// pass instead of a SQL JOIN since the ORM doesn't expose joins
13731/// fluently yet.
13732pub async fn history_page(
13733    State(state): State<super::AdminState>,
13734    tenant: Tenant,
13735    headers: HeaderMap,
13736    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13737    Query(q): Query<HistoryQuery>,
13738    axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
13739) -> Result<Response, AdminError> {
13740    let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
13741
13742    // Build the base query with optional filters. The ORM's
13743    // `.where_()` is additive (AND); we apply each filter only when
13744    // present so the SQL stays minimal.
13745    let mut revisions_query =
13746        crate::revision::Revision::objects().order_by(&[("created_at", true)]); // desc — newest first
13747    if let Some(pid) = q.page_id {
13748        revisions_query = revisions_query.where_(crate::revision::Revision::page_id.eq(pid));
13749    }
13750    if let Some(uid) = q.user_id {
13751        revisions_query =
13752            revisions_query.where_(crate::revision::Revision::created_by.eq(Some(uid)));
13753    }
13754
13755    // The ORM builder has no server-side limit/offset yet, so we fetch
13756    // all matching rows then page in memory via
13757    // `rustango::pagination::Paginator` (matches the snippet list).
13758    // `get_page()` clamps out-of-range numbers to the last page, so the
13759    // prev/next links never dangle. Acceptable on the 50-row scale.
13760    let all: Vec<crate::revision::Revision> = revisions_query.fetch(tenant.pool()).await?;
13761    let total = all.len();
13762    let paginator = rustango::pagination::Paginator::new(total, page_size);
13763    let page_obj = paginator.get_page(q.page.unwrap_or(1).max(1) as i64);
13764    let current_page = page_obj.number as u32;
13765    let has_next = page_obj.has_next();
13766    let has_prev = page_obj.has_previous();
13767    let revisions: Vec<crate::revision::Revision> = if total == 0 {
13768        Vec::new()
13769    } else {
13770        all[page_obj.start_index().saturating_sub(1)..page_obj.end_index()].to_vec()
13771    };
13772
13773    // Batch-fetch every distinct page + user referenced by this slice.
13774    let page_ids: std::collections::BTreeSet<i64> = revisions.iter().map(|r| r.page_id).collect();
13775    let user_ids: std::collections::BTreeSet<i64> =
13776        revisions.iter().filter_map(|r| r.created_by).collect();
13777
13778    let pages: Vec<Page> = if page_ids.is_empty() {
13779        Vec::new()
13780    } else {
13781        Page::objects()
13782            .where_(Page::id.is_in(page_ids.iter().copied()))
13783            .fetch(tenant.pool())
13784            .await?
13785    };
13786    let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
13787        Vec::new()
13788    } else {
13789        rustango::tenancy::auth::User::objects()
13790            .where_(rustango::tenancy::auth::User::id.is_in(user_ids.iter().copied()))
13791            .fetch(tenant.pool())
13792            .await?
13793    };
13794
13795    let pages_by_id: std::collections::HashMap<i64, &Page> = pages
13796        .iter()
13797        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
13798        .collect();
13799    let users_by_id: std::collections::HashMap<i64, &rustango::tenancy::auth::User> = users
13800        .iter()
13801        .filter_map(|u| u.id.get().copied().map(|id| (id, u)))
13802        .collect();
13803
13804    // Build a list of view-model dicts for the template — each row
13805    // carries everything Tera needs (no further lookups inside the
13806    // template loop). `is_latest` flags the most-recent revision for
13807    // each page so the UI can disable revert on the current state.
13808    let mut latest_seq_by_page: std::collections::HashMap<i64, i32> =
13809        std::collections::HashMap::new();
13810    for r in &all {
13811        let cur = latest_seq_by_page.entry(r.page_id).or_insert(r.sequence);
13812        if r.sequence > *cur {
13813            *cur = r.sequence;
13814        }
13815    }
13816    // #74 — surface the prior revision's id + sequence per row so
13817    // the history list's Compare button can deep-link to the diff
13818    // view. "Prior" = next-lower sequence on the same page. Built
13819    // from `all` (not the page slice) so a row at the slice boundary
13820    // still knows its predecessor.
13821    let mut by_page: std::collections::HashMap<i64, Vec<&crate::revision::Revision>> =
13822        std::collections::HashMap::new();
13823    for r in &all {
13824        by_page.entry(r.page_id).or_default().push(r);
13825    }
13826    let mut prev_by_id: std::collections::HashMap<i64, (i64, i32)> =
13827        std::collections::HashMap::new();
13828    for (_pid, mut list) in by_page {
13829        list.sort_by_key(|r| r.sequence);
13830        for window in list.windows(2) {
13831            let earlier = window[0];
13832            let later = window[1];
13833            if let (Some(later_id), Some(earlier_id)) =
13834                (later.id.get().copied(), earlier.id.get().copied())
13835            {
13836                prev_by_id.insert(later_id, (earlier_id, earlier.sequence));
13837            }
13838        }
13839    }
13840
13841    let rows: Vec<serde_json::Value> = revisions
13842        .iter()
13843        .map(|r| {
13844            let page = pages_by_id.get(&r.page_id);
13845            let user = r.created_by.and_then(|uid| users_by_id.get(&uid));
13846            let created_at = r.created_at.get().copied();
13847            let (prev_id, prev_sequence) =
13848                r.id.get()
13849                    .copied()
13850                    .and_then(|id| prev_by_id.get(&id).copied())
13851                    .map(|(a, b)| (Some(a), Some(b)))
13852                    .unwrap_or((None, None));
13853            let is_latest = latest_seq_by_page
13854                .get(&r.page_id)
13855                .is_some_and(|s| *s == r.sequence);
13856            serde_json::json!({
13857                "id": r.id.get().copied(),
13858                "page_id": r.page_id,
13859                "sequence": r.sequence,
13860                "created_at": created_at,
13861                "page_title": page.map(|p| p.title.clone()),
13862                "page_url_path": page.map(|p| p.url_path.clone()),
13863                "page_status": page.map(|p| p.status.as_str()),
13864                "username": user.map(|u| u.username.clone()),
13865                "system_user": r.created_by.is_none(),
13866                "is_latest": is_latest,
13867                "prev_id": prev_id,
13868                "prev_sequence": prev_sequence,
13869            })
13870        })
13871        .collect();
13872
13873    let mut ctx = Context::new();
13874    add_chrome(&mut ctx, &tenant, "history", session_user.as_ref()).await;
13875    add_admin_theme(&mut ctx, tenant.pool()).await;
13876    ctx.insert("rows", &rows);
13877    ctx.insert("filter_page_id", &q.page_id);
13878    ctx.insert("filter_user_id", &q.user_id);
13879    // #316 — raw query string for the `| querystring(page=…)` pagination
13880    // links (preserves the page_id / user_id filters + sets page).
13881    ctx.insert("query_string", &raw_query.unwrap_or_default());
13882    ctx.insert("current_page", &current_page);
13883    ctx.insert("has_next", &has_next);
13884    ctx.insert("has_prev", &has_prev);
13885    ctx.insert("total", &total);
13886    ctx.insert("page_size", &page_size);
13887    ctx.insert(
13888        "pagination",
13889        &crate::admin::pagination::context(current_page as i64, page_size, total),
13890    );
13891    render_with_csrf(&state, &headers, "rcms_admin/history.html", &mut ctx)
13892}
13893
13894/// Query string for the diff view: required `a` + `b` revision ids.
13895/// `only_changes` (default true) hides unchanged fields when the
13896/// template renders.
13897#[derive(Debug, Deserialize)]
13898pub struct HistoryDiffQuery {
13899    pub a: i64,
13900    pub b: i64,
13901    #[serde(default)]
13902    pub all: Option<String>,
13903}
13904
13905/// GET /cms-admin/pages/{id}/history/diff?a=<rev_id>&b=<rev_id>.
13906/// Side-by-side comparison of two revisions on the same
13907/// page. v1 surfaces a flat field-level diff; rich-text +
13908/// StreamField-aware diff is a follow-up.
13909pub async fn history_diff(
13910    State(state): State<super::AdminState>,
13911    tenant: Tenant,
13912    headers: HeaderMap,
13913    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
13914    Path(page_id): Path<i64>,
13915    Query(q): Query<HistoryDiffQuery>,
13916) -> Result<Response, AdminError> {
13917    let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
13918        .where_(crate::revision::Revision::page_id.eq(page_id))
13919        .where_(crate::revision::Revision::id.is_in([q.a, q.b]))
13920        .fetch(tenant.pool())
13921        .await?;
13922    let a_row = revisions
13923        .iter()
13924        .find(|r| r.id.get().copied() == Some(q.a))
13925        .cloned()
13926        .ok_or(AdminError::NotFound(q.a))?;
13927    let b_row = revisions
13928        .iter()
13929        .find(|r| r.id.get().copied() == Some(q.b))
13930        .cloned()
13931        .ok_or(AdminError::NotFound(q.b))?;
13932
13933    let page = Page::objects()
13934        .where_(Page::id.eq(page_id))
13935        .first(tenant.pool())
13936        .await?
13937        .ok_or(AdminError::NotFound(page_id))?;
13938
13939    // Reviewer name lookup for the header.
13940    let user_ids: Vec<i64> = [a_row.created_by, b_row.created_by]
13941        .into_iter()
13942        .flatten()
13943        .collect();
13944    let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
13945        Vec::new()
13946    } else {
13947        rustango::tenancy::auth::User::objects()
13948            .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
13949            .fetch(tenant.pool())
13950            .await?
13951    };
13952    let username_for = |uid: Option<i64>| -> Option<String> {
13953        uid.and_then(|id| {
13954            users
13955                .iter()
13956                .find(|u| u.id.get().copied() == Some(id))
13957                .map(|u| u.username.clone())
13958        })
13959    };
13960
13961    let diffs = crate::revision::diff_snapshots(&a_row.snapshot, &b_row.snapshot);
13962    let changed_count = diffs.iter().filter(|d| d.is_change()).count();
13963    let only_changes = q.all.is_none();
13964
13965    let mut ctx = Context::new();
13966    add_chrome(&mut ctx, &tenant, "history", session_user.as_ref()).await;
13967    add_admin_theme(&mut ctx, tenant.pool()).await;
13968    ctx.insert("page", &page);
13969    ctx.insert(
13970        "rev_a",
13971        &serde_json::json!({
13972            "id": a_row.id.get().copied(),
13973            "sequence": a_row.sequence,
13974            "created_at": a_row.created_at.get().copied(),
13975            "username": username_for(a_row.created_by),
13976        }),
13977    );
13978    ctx.insert(
13979        "rev_b",
13980        &serde_json::json!({
13981            "id": b_row.id.get().copied(),
13982            "sequence": b_row.sequence,
13983            "created_at": b_row.created_at.get().copied(),
13984            "username": username_for(b_row.created_by),
13985        }),
13986    );
13987    ctx.insert("diffs", &diffs);
13988    ctx.insert("changed_count", &changed_count);
13989    ctx.insert("only_changes", &only_changes);
13990    render_with_csrf(&state, &headers, "rcms_admin/history_diff.html", &mut ctx)
13991}
13992
13993// =====================================================================
13994// Aging-pages report (#101)
13995// =====================================================================
13996
13997#[derive(Debug, Deserialize)]
13998pub struct AnalyticsQuery {
13999    /// Window in days back from now — defaults to 30, clamped 1..=365.
14000    #[serde(default)]
14001    pub days: Option<i64>,
14002}
14003
14004/// GET /cms-admin/analytics — the default first-party analytics
14005/// dashboard: unique visitors, pageviews, bounce, avg time, top pages /
14006/// referrers / countries / devices, a per-day series, and "active now".
14007pub async fn analytics_dashboard(
14008    State(state): State<super::AdminState>,
14009    tenant: Tenant,
14010    headers: HeaderMap,
14011    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14012    Query(q): Query<AnalyticsQuery>,
14013) -> Result<Response, AdminError> {
14014    let days = q.days.unwrap_or(30).clamp(1, 365);
14015    let to = chrono::Utc::now();
14016    let from = to - chrono::Duration::days(days);
14017    let metrics = crate::analytics::query::compute(tenant.pool(), from, to).await?;
14018    let host = headers
14019        .get(header::HOST)
14020        .and_then(|v| v.to_str().ok())
14021        .unwrap_or("");
14022    let active_now = crate::analytics::presence_count(host);
14023    // Max pageviews across the series → the 100%-height reference for the
14024    // bar chart (min 1 to avoid divide-by-zero).
14025    let series_max = metrics
14026        .series
14027        .iter()
14028        .map(|p| p.pageviews)
14029        .max()
14030        .unwrap_or(0)
14031        .max(1);
14032
14033    let mut ctx = Context::new();
14034    add_chrome(&mut ctx, &tenant, "analytics", session_user.as_ref()).await;
14035    add_admin_theme(&mut ctx, tenant.pool()).await;
14036    ctx.insert("metrics", &metrics);
14037    ctx.insert("active_now", &active_now);
14038    ctx.insert("series_max", &series_max);
14039    ctx.insert("days", &days);
14040    render_with_csrf(&state, &headers, "rcms_admin/analytics.html", &mut ctx)
14041}
14042
14043#[derive(Debug, Deserialize)]
14044pub struct AgingQuery {
14045    /// Minimum days stale — defaults to 90.
14046    #[serde(default)]
14047    pub min_days: Option<i64>,
14048    /// Status filter — defaults to "published". Pass `all` to skip.
14049    #[serde(default)]
14050    pub status: Option<String>,
14051    /// 1-indexed page number.
14052    #[serde(default)]
14053    pub page: Option<u32>,
14054    /// Rows per page.
14055    #[serde(default)]
14056    pub per_page: Option<usize>,
14057}
14058
14059/// GET /cms-admin/reports/aging — table of pages sorted by
14060/// `updated_at` ascending (oldest first). Editors use this to spot
14061/// pages that have gone stale.
14062pub async fn aging_pages_report(
14063    State(state): State<super::AdminState>,
14064    tenant: Tenant,
14065    headers: HeaderMap,
14066    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14067    Query(q): Query<AgingQuery>,
14068    axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
14069) -> Result<Response, AdminError> {
14070    let page_size = crate::admin::pagination::clamp_per_page(q.per_page);
14071    let min_days = q.min_days.unwrap_or(90).max(0);
14072    let status_filter = q
14073        .status
14074        .as_deref()
14075        .map(str::trim)
14076        .filter(|s| !s.is_empty() && *s != "all")
14077        .map(str::to_owned)
14078        .unwrap_or_else(|| "published".to_owned());
14079
14080    let now = chrono::Utc::now();
14081    let mut q_pages = Page::objects().order_by(&[("updated_at", false)]); // asc
14082    if status_filter != "all" {
14083        q_pages = q_pages.where_(Page::status.eq(status_filter.clone()));
14084    }
14085    let all: Vec<Page> = q_pages.fetch(tenant.pool()).await?;
14086
14087    // Filter by min-days-stale.
14088    let stale: Vec<&Page> = all
14089        .iter()
14090        .filter(|p| match p.updated_at.get().copied() {
14091            Some(ts) => {
14092                let delta = now.signed_duration_since(ts).num_days();
14093                delta >= min_days
14094            }
14095            None => false,
14096        })
14097        .collect();
14098    let total = stale.len();
14099    // Page in memory via `rustango::pagination::Paginator` (matches the
14100    // snippet list); `get_page()` clamps out-of-range numbers to the
14101    // last page so prev/next links never dangle.
14102    let paginator = rustango::pagination::Paginator::new(total, page_size);
14103    let page_obj = paginator.get_page(q.page.unwrap_or(1).max(1) as i64);
14104    let current_page = page_obj.number as u32;
14105    let has_next = page_obj.has_next();
14106    let has_prev = page_obj.has_previous();
14107    let slice: Vec<&&Page> = if total == 0 {
14108        Vec::new()
14109    } else {
14110        stale[page_obj.start_index().saturating_sub(1)..page_obj.end_index()]
14111            .iter()
14112            .collect()
14113    };
14114
14115    // Per-row last editor — pulled from the latest revision per
14116    // page in one batched query.
14117    let page_ids: Vec<i64> = slice.iter().filter_map(|p| p.id.get().copied()).collect();
14118    let revisions: Vec<crate::revision::Revision> = if page_ids.is_empty() {
14119        Vec::new()
14120    } else {
14121        crate::revision::Revision::objects()
14122            .where_(crate::revision::Revision::page_id.is_in(page_ids.iter().copied()))
14123            .order_by(&[("sequence", true)]) // desc, so newest sequence per page first
14124            .fetch(tenant.pool())
14125            .await
14126            .unwrap_or_default()
14127    };
14128    let mut last_editor_by_page: std::collections::HashMap<i64, Option<i64>> =
14129        std::collections::HashMap::new();
14130    for r in &revisions {
14131        // First insertion wins for each page_id since we ordered
14132        // desc by sequence — that's the most-recent revision.
14133        last_editor_by_page.entry(r.page_id).or_insert(r.created_by);
14134    }
14135    let user_ids: Vec<i64> = last_editor_by_page
14136        .values()
14137        .filter_map(|opt| *opt)
14138        .collect();
14139    let users: Vec<rustango::tenancy::auth::User> = if user_ids.is_empty() {
14140        Vec::new()
14141    } else {
14142        rustango::tenancy::auth::User::objects()
14143            .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
14144            .fetch(tenant.pool())
14145            .await
14146            .unwrap_or_default()
14147    };
14148    let username_by_id: std::collections::HashMap<i64, String> = users
14149        .into_iter()
14150        .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
14151        .collect();
14152
14153    let rows: Vec<serde_json::Value> = slice
14154        .iter()
14155        .map(|p| {
14156            let pid = p.id.get().copied().unwrap_or_default();
14157            let updated = p.updated_at.get().copied();
14158            let days_stale = updated.map(|ts| now.signed_duration_since(ts).num_days());
14159            let editor = last_editor_by_page
14160                .get(&pid)
14161                .and_then(|v| *v)
14162                .and_then(|uid| username_by_id.get(&uid).cloned());
14163            serde_json::json!({
14164                "id": pid,
14165                "title": p.title,
14166                "url_path": p.url_path,
14167                "status": p.status,
14168                "updated_at": updated,
14169                "days_stale": days_stale,
14170                "last_editor": editor,
14171            })
14172        })
14173        .collect();
14174
14175    let mut ctx = Context::new();
14176    add_chrome(&mut ctx, &tenant, "reports", session_user.as_ref()).await;
14177    add_admin_theme(&mut ctx, tenant.pool()).await;
14178    ctx.insert("rows", &rows);
14179    ctx.insert("min_days", &min_days);
14180    ctx.insert("status_filter", &status_filter);
14181    // #316 — raw query string for the `| querystring(page=…)` pagination
14182    // links (preserves min_days / status + sets page).
14183    ctx.insert("query_string", &raw_query.unwrap_or_default());
14184    ctx.insert("current_page", &current_page);
14185    ctx.insert("has_next", &has_next);
14186    ctx.insert("has_prev", &has_prev);
14187    ctx.insert("total", &total);
14188    ctx.insert("page_size", &page_size);
14189    ctx.insert(
14190        "pagination",
14191        &crate::admin::pagination::context(current_page as i64, page_size, total),
14192    );
14193    render_with_csrf(&state, &headers, "rcms_admin/aging_pages.html", &mut ctx)
14194}
14195
14196/// GET /cms-admin/reports/aging.csv — same data as the HTML view
14197/// but streamed as RFC 4180 CSV. Honors the same `min_days` +
14198/// `status` filters.
14199pub async fn aging_pages_csv(
14200    State(_state): State<super::AdminState>,
14201    tenant: Tenant,
14202    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14203    Query(q): Query<AgingQuery>,
14204) -> Result<Response, AdminError> {
14205    let min_days = q.min_days.unwrap_or(90).max(0);
14206    let status_filter = q
14207        .status
14208        .as_deref()
14209        .map(str::trim)
14210        .filter(|s| !s.is_empty() && *s != "all")
14211        .map(str::to_owned)
14212        .unwrap_or_else(|| "published".to_owned());
14213    let now = chrono::Utc::now();
14214    let mut q_pages = Page::objects().order_by(&[("updated_at", false)]);
14215    if status_filter != "all" {
14216        q_pages = q_pages.where_(Page::status.eq(status_filter.clone()));
14217    }
14218    let all: Vec<Page> = q_pages.fetch(tenant.pool()).await?;
14219    let stale: Vec<&Page> = all
14220        .iter()
14221        .filter(|p| match p.updated_at.get().copied() {
14222            Some(ts) => now.signed_duration_since(ts).num_days() >= min_days,
14223            None => false,
14224        })
14225        .collect();
14226
14227    let mut out = String::with_capacity(256 + stale.len() * 96);
14228    out.push_str("page_id,title,url_path,status,updated_at,days_stale\n");
14229    for p in stale {
14230        let pid = p.id.get().copied().unwrap_or_default();
14231        let updated = p.updated_at.get().copied();
14232        let days = updated
14233            .map(|ts| now.signed_duration_since(ts).num_days())
14234            .unwrap_or_default();
14235        let when = updated.map(|t| t.to_rfc3339()).unwrap_or_default();
14236        out.push_str(&format!(
14237            "{},{},{},{},{},{}\n",
14238            pid,
14239            csv_escape(&p.title),
14240            csv_escape(&p.url_path),
14241            csv_escape(&p.status),
14242            csv_escape(&when),
14243            days
14244        ));
14245    }
14246    Ok(csv_response("aging-pages", &out))
14247}
14248
14249/// Helper — attach CSV content-type + a date-stamped Content-Disposition.
14250fn csv_response(name: &str, body: &str) -> Response {
14251    let filename = format!("{name}-{}.csv", chrono::Utc::now().format("%Y%m%d"));
14252    let mut response = (
14253        [(header::CONTENT_TYPE, "text/csv; charset=utf-8")],
14254        body.to_owned(),
14255    )
14256        .into_response();
14257    if let Ok(v) = HeaderValue::from_str(&format!("attachment; filename=\"{filename}\"")) {
14258        response
14259            .headers_mut()
14260            .insert(header::CONTENT_DISPOSITION, v);
14261    }
14262    response
14263}
14264
14265// =====================================================================
14266// Site settings (#108)
14267// =====================================================================
14268
14269pub async fn site_settings_list(
14270    State(state): State<super::AdminState>,
14271    tenant: Tenant,
14272    headers: HeaderMap,
14273    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14274) -> Result<Response, AdminError> {
14275    let rows = crate::site_setting::list_all(tenant.pool())
14276        .await
14277        .unwrap_or_default();
14278    let by_scope: std::collections::HashMap<&str, &crate::site_setting::SiteSetting> =
14279        rows.iter().map(|r| (r.scope.as_str(), r)).collect();
14280    // #406 — registered typed schemas come first and are always listed
14281    // (configured or not); then any
14282    // ad-hoc free-form JSON scopes that aren't backed by a schema.
14283    let mut view: Vec<serde_json::Value> = Vec::new();
14284    for schema in crate::site_setting::registered_schemas() {
14285        let row = by_scope.get(schema.scope).copied();
14286        view.push(serde_json::json!({
14287            "scope": schema.scope,
14288            "label": schema.label,
14289            "typed": true,
14290            "configured": row.is_some(),
14291            "preview": row
14292                .map(|r| serde_json::to_string(&r.value_json).unwrap_or_default())
14293                .unwrap_or_default(),
14294            "updated_at": row.and_then(|r| r.updated_at.get().copied()),
14295        }));
14296    }
14297    for s in &rows {
14298        if crate::site_setting::schema_for(&s.scope).is_some() {
14299            continue;
14300        }
14301        view.push(serde_json::json!({
14302            "scope": s.scope,
14303            "label": s.scope,
14304            "typed": false,
14305            "configured": true,
14306            "preview": serde_json::to_string(&s.value_json).unwrap_or_default(),
14307            "updated_at": s.updated_at.get().copied(),
14308        }));
14309    }
14310    let mut ctx = Context::new();
14311    add_chrome(&mut ctx, &tenant, "site-settings", session_user.as_ref()).await;
14312    add_admin_theme(&mut ctx, tenant.pool()).await;
14313    ctx.insert("rows", &view);
14314    render_with_csrf(
14315        &state,
14316        &headers,
14317        "rcms_admin/site_settings_list.html",
14318        &mut ctx,
14319    )
14320}
14321
14322pub async fn site_setting_edit_form(
14323    State(state): State<super::AdminState>,
14324    tenant: Tenant,
14325    headers: HeaderMap,
14326    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14327    Path(scope): Path<String>,
14328    Query(q): Query<EditQuery>,
14329) -> Result<Response, AdminError> {
14330    let row = crate::site_setting::get(tenant.pool(), &scope)
14331        .await
14332        .unwrap_or(None);
14333    let stored = row
14334        .as_ref()
14335        .map(|s| s.value_json.clone())
14336        .unwrap_or_else(|| serde_json::json!({}));
14337    let mut ctx = Context::new();
14338    add_chrome(&mut ctx, &tenant, "site-settings", session_user.as_ref()).await;
14339    add_admin_theme(&mut ctx, tenant.pool()).await;
14340    ctx.insert("scope", &scope);
14341    ctx.insert("is_new", &row.is_none());
14342    // #406 — a registered schema renders a typed form; otherwise the
14343    // free-form JSON textarea covers ad-hoc scopes.
14344    if let Some(schema) = crate::site_setting::schema_for(&scope) {
14345        let widgets = crate::site_setting::prefill_widgets((schema.fields)(), &stored);
14346        ctx.insert("typed", &true);
14347        ctx.insert("schema_label", schema.label);
14348        // Other languages: the text fields, translated side by side.
14349        let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
14350            .where_(crate::locale::Locale::active.eq(true))
14351            .order_by(&[("sort_order", false), ("code", false)])
14352            .fetch(tenant.pool())
14353            .await?;
14354        let editing = q
14355            .locale
14356            .as_deref()
14357            .and_then(|c| locales.iter().find(|l| l.code == c && !l.is_default).cloned());
14358        if let (Some(loc), false) = (&editing, row.is_none()) {
14359            let tr = crate::site_setting::translations(&stored, &loc.code);
14360            let rows: Vec<serde_json::Value> = widgets
14361                .iter()
14362                .filter(|w| site_setting_translatable(w))
14363                .map(|w| {
14364                    serde_json::json!({
14365                        "name": w.name,
14366                        "label": w.label,
14367                        "canonical": w.value,
14368                        "multiline": !matches!(w.kind, crate::widget::WidgetKind::Text),
14369                        "value": tr.get(&w.name).and_then(|v| v.as_str()).unwrap_or(""),
14370                    })
14371                })
14372                .collect();
14373            ctx.insert("translation_mode", &true);
14374            ctx.insert("editing_locale", loc);
14375            ctx.insert("tr_rows", &rows);
14376        }
14377        ctx.insert("locales", &locales);
14378        ctx.insert("widgets", &widgets);
14379    } else {
14380        ctx.insert("typed", &false);
14381        let body = serde_json::to_string_pretty(&stored).unwrap_or_else(|_| "{}".to_owned());
14382        ctx.insert("value_pretty", &body);
14383    }
14384    render_with_csrf(
14385        &state,
14386        &headers,
14387        "rcms_admin/site_setting_form.html",
14388        &mut ctx,
14389    )
14390}
14391
14392pub async fn site_setting_edit_submit(
14393    State(_state): State<super::AdminState>,
14394    tenant: Tenant,
14395    headers: HeaderMap,
14396    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14397    Path(scope): Path<String>,
14398    Form(form): Form<std::collections::HashMap<String, String>>,
14399) -> Result<Response, AdminError> {
14400    // #406 — typed scopes coerce each declared field by widget kind;
14401    // unregistered scopes keep the raw-JSON textarea contract.
14402    let parsed: serde_json::Value = if let Some(schema) = crate::site_setting::schema_for(&scope) {
14403        let fields = (schema.fields)();
14404        let missing = crate::site_setting::missing_required(&fields, &form);
14405        if !missing.is_empty() {
14406            return Err(AdminError::Validation(format!(
14407                "These required fields are empty: {}.",
14408                missing.join(", ")
14409            )));
14410        }
14411        let mut value = crate::site_setting::value_json_from_form(&fields, &form);
14412        if let Ok(Some(old)) = crate::site_setting::get(tenant.pool(), &scope).await {
14413            crate::site_setting::keep_translations(&old.value_json, &mut value);
14414        }
14415        value
14416    } else {
14417        let raw = form.get("value_json").map_or("", |s| s.trim());
14418        if raw.is_empty() {
14419            serde_json::json!({})
14420        } else {
14421            serde_json::from_str(raw)
14422                .map_err(|e| AdminError::Validation(format!("value_json isn't valid JSON: {e}")))?
14423        }
14424    };
14425    crate::site_setting::upsert(tenant.pool(), &scope, parsed).await?;
14426    redirect_named_with_message_args(
14427        "rcms-admin:site-settings:list",
14428        MsgLevel::Success,
14429        "Saved site setting “{scope}”.",
14430        &[("scope", scope.as_str())],
14431        &headers,
14432    )
14433}
14434
14435/// A typed setting field worth translating: free text.
14436fn site_setting_translatable(w: &crate::widget::Widget) -> bool {
14437    use crate::widget::WidgetKind as K;
14438    matches!(w.kind, K::Text | K::Textarea | K::Markdown | K::RichText)
14439}
14440
14441/// POST /cms-admin/site-settings/{scope}/translate?locale=<code> — store
14442/// the text fields' translations in the setting's `_i18n` bag.
14443pub async fn site_setting_translate_submit(
14444    State(_state): State<super::AdminState>,
14445    tenant: Tenant,
14446    headers: HeaderMap,
14447    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14448    Path(scope): Path<String>,
14449    Query(q): Query<EditQuery>,
14450    Form(form): Form<std::collections::HashMap<String, String>>,
14451) -> Result<Response, AdminError> {
14452    let locale = translate_locale(&tenant, q.locale.as_deref()).await?;
14453    let schema = crate::site_setting::schema_for(&scope)
14454        .ok_or_else(|| AdminError::Validation(format!("`{scope}` has no typed fields to translate")))?;
14455    let row = crate::site_setting::get(tenant.pool(), &scope)
14456        .await?
14457        .ok_or_else(|| AdminError::Validation(format!("save `{scope}` before translating it")))?;
14458    let fields: serde_json::Map<String, serde_json::Value> = (schema.fields)()
14459        .iter()
14460        .filter(|w| site_setting_translatable(w))
14461        .filter_map(|w| {
14462            form.get(&format!("tr__{}", w.name))
14463                .map(|v| (w.name.clone(), serde_json::Value::String(v.trim().to_owned())))
14464        })
14465        .collect();
14466    let mut value = row.value_json;
14467    crate::site_setting::set_translations(&mut value, &locale.code, fields);
14468    crate::site_setting::upsert(tenant.pool(), &scope, value).await?;
14469    Ok(rustango::messages::redirect_with_message(
14470        messages_secret(),
14471        &headers,
14472        MsgLevel::Success,
14473        &super::i18n::tr(&headers, "Translations saved.", &[]),
14474        &format!("/cms-admin/site-settings/{scope}/edit?locale={}", locale.code),
14475    ))
14476}
14477
14478pub async fn site_setting_delete_submit(
14479    State(_state): State<super::AdminState>,
14480    tenant: Tenant,
14481    headers: HeaderMap,
14482    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14483    Path(scope): Path<String>,
14484) -> Result<Response, AdminError> {
14485    if let Some(row) = crate::site_setting::get(tenant.pool(), &scope)
14486        .await
14487        .unwrap_or(None)
14488    {
14489        row.delete_pool(tenant.pool()).await?;
14490    }
14491    redirect_named_with_message_args(
14492        "rcms-admin:site-settings:list",
14493        MsgLevel::Success,
14494        "Deleted site setting “{scope}”.",
14495        &[("scope", scope.as_str())],
14496        &headers,
14497    )
14498}
14499
14500// =====================================================================
14501// Locked-pages report (#109)
14502// =====================================================================
14503
14504// ----- #143 — search promotions report ---------
14505
14506/// GET /cms-admin/reports/search — top queries by hit count with
14507/// counts of pinned promotions per query.
14508pub async fn search_promotions_report(
14509    State(state): State<super::AdminState>,
14510    tenant: Tenant,
14511    headers: HeaderMap,
14512    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14513) -> Result<Response, AdminError> {
14514    let top = crate::search_promotion::top_queries(tenant.pool(), 100)
14515        .await
14516        .unwrap_or_default();
14517    // Annotate each query with its promotion count.
14518    let mut rows: Vec<serde_json::Value> = Vec::with_capacity(top.len());
14519    for q in top {
14520        let qid = q.id.get().copied().unwrap_or_default();
14521        let promos = crate::search_promotion::promotions_for_query(tenant.pool(), qid)
14522            .await
14523            .unwrap_or_default();
14524        rows.push(serde_json::json!({
14525            "id": qid,
14526            "raw": q.raw,
14527            "normalized": q.normalized,
14528            "hits": q.hits,
14529            "last_seen_at": q.last_seen_at.get().copied(),
14530            "promotion_count": promos.len(),
14531        }));
14532    }
14533    let mut ctx = Context::new();
14534    add_chrome(&mut ctx, &tenant, "reports-search", session_user.as_ref()).await;
14535    add_admin_theme(&mut ctx, tenant.pool()).await;
14536    ctx.insert("rows", &rows);
14537    render_with_csrf(
14538        &state,
14539        &headers,
14540        "rcms_admin/search_promotions_report.html",
14541        &mut ctx,
14542    )
14543}
14544
14545/// GET /cms-admin/reports/search/{id}/edit — edit pinned pages for
14546/// one query.
14547pub async fn search_promotion_edit_form(
14548    State(state): State<super::AdminState>,
14549    tenant: Tenant,
14550    headers: HeaderMap,
14551    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14552    Path(query_id): Path<i64>,
14553) -> Result<Response, AdminError> {
14554    use rustango::core::Column as _;
14555    use rustango::sql::FetcherPool as _;
14556    let queries: Vec<crate::search_promotion::SearchQuery> =
14557        crate::search_promotion::SearchQuery::objects()
14558            .where_(crate::search_promotion::SearchQuery::id.eq(query_id))
14559            .fetch(tenant.pool())
14560            .await?;
14561    let Some(query) = queries.into_iter().next() else {
14562        return Err(AdminError::NotFound(query_id));
14563    };
14564    let promotions = crate::search_promotion::promotions_for_query(tenant.pool(), query_id)
14565        .await
14566        .unwrap_or_default();
14567    let pages: Vec<Page> = Page::objects()
14568        .where_(Page::status.eq("published".to_owned()))
14569        .order_by(&[("title", false)])
14570        .fetch(tenant.pool())
14571        .await
14572        .unwrap_or_default();
14573    let mut ctx = Context::new();
14574    add_chrome(&mut ctx, &tenant, "reports-search", session_user.as_ref()).await;
14575    add_admin_theme(&mut ctx, tenant.pool()).await;
14576    ctx.insert("query", &query);
14577    ctx.insert("promotions", &promotions);
14578    ctx.insert("pages", &pages);
14579    render_with_csrf(
14580        &state,
14581        &headers,
14582        "rcms_admin/search_promotion_edit.html",
14583        &mut ctx,
14584    )
14585}
14586
14587#[derive(Debug, Deserialize)]
14588pub struct SearchPromotionForm {
14589    /// Comma-separated page ids in pin order.
14590    #[serde(default)]
14591    pub page_ids: String,
14592    #[serde(default)]
14593    pub descriptions: String,
14594}
14595
14596/// POST /cms-admin/reports/search/{id}/edit — replace the pinned
14597/// list with the posted ordered page ids.
14598pub async fn search_promotion_edit_submit(
14599    State(_state): State<super::AdminState>,
14600    tenant: Tenant,
14601    headers: HeaderMap,
14602    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14603    Path(query_id): Path<i64>,
14604    Form(form): Form<SearchPromotionForm>,
14605) -> Result<Response, AdminError> {
14606    use rustango::core::Column as _;
14607    use rustango::sql::Auto;
14608    use rustango::sql::FetcherPool as _;
14609    // Drop existing promotions then re-insert fresh — simpler than
14610    // diffing.
14611    let existing: Vec<crate::search_promotion::SearchPromotion> =
14612        crate::search_promotion::SearchPromotion::objects()
14613            .where_(crate::search_promotion::SearchPromotion::query_id.eq(query_id))
14614            .fetch(tenant.pool())
14615            .await?;
14616    for row in existing {
14617        row.delete_pool(tenant.pool()).await.log_warn("old search promotion not deleted");
14618    }
14619    let ids: Vec<i64> = form
14620        .page_ids
14621        .split(',')
14622        .map(str::trim)
14623        .filter(|s| !s.is_empty())
14624        .filter_map(|s| s.parse::<i64>().ok())
14625        .collect();
14626    let descriptions: Vec<String> = form
14627        .descriptions
14628        .split('\n')
14629        .map(|s| s.trim().to_owned())
14630        .collect();
14631    for (idx, page_id) in ids.iter().enumerate() {
14632        let mut row = crate::search_promotion::SearchPromotion {
14633            id: Auto::Unset,
14634            query_id,
14635            page_id: *page_id,
14636            sort_order: idx as i32,
14637            description: descriptions.get(idx).cloned().unwrap_or_default(),
14638            created_at: Auto::Unset,
14639        };
14640        row.insert_pool(tenant.pool()).await.log_warn("search promotion not saved");
14641    }
14642    redirect_named_with_message_plural(
14643        "rcms-admin:reports:search",
14644        MsgLevel::Success,
14645        "Saved {count} pinned result(s).",
14646        ids.len() as i64,
14647        &[("count", &ids.len().to_string())],
14648        &headers,
14649    )
14650}
14651
14652// ----- #141 — scheduled-publish report ---------
14653
14654/// Derive the effective lifecycle state from `go_live_at`.
14655/// Any row carrying a future
14656/// `go_live_at` is treated as `scheduled` regardless of the editor's
14657/// literal status pick (draft / published) so the sweep job +
14658/// scheduled-report query pick it up. Clearing `go_live_at` on a
14659/// previously-scheduled row falls back to `draft` so the row stops
14660/// claiming a schedule it no longer has.
14661///
14662/// `archived` is preserved either way — archive is an explicit
14663/// lifecycle terminus and an editor un-archives via a different
14664/// path. A scheduled row whose `go_live_at` has already passed is
14665/// left alone too; the sweep is the one that flips it to `published`,
14666/// and stepping in here would steal that transition.
14667pub(crate) fn derive_scheduled_status(
14668    current: &str,
14669    go_live_at: Option<chrono::DateTime<chrono::Utc>>,
14670) -> String {
14671    let archived = crate::page::PageStatus::Archived.as_str();
14672    if current == archived {
14673        return current.to_owned();
14674    }
14675    let now = chrono::Utc::now();
14676    let future = go_live_at.is_some_and(|t| t > now);
14677    let scheduled = crate::page::PageStatus::Scheduled.as_str();
14678    let draft = crate::page::PageStatus::Draft.as_str();
14679    match (current, future, go_live_at) {
14680        (_, true, _) => scheduled.to_owned(),
14681        (s, false, None) if s == scheduled => draft.to_owned(),
14682        _ => current.to_owned(),
14683    }
14684}
14685
14686#[cfg(test)]
14687mod scheduled_status_tests {
14688    use super::derive_scheduled_status;
14689    use chrono::{Duration, Utc};
14690
14691    #[test]
14692    fn future_go_live_promotes_draft_to_scheduled() {
14693        let go = Utc::now() + Duration::hours(1);
14694        assert_eq!(derive_scheduled_status("draft", Some(go)), "scheduled");
14695    }
14696
14697    #[test]
14698    fn future_go_live_also_promotes_published() {
14699        // Editor picked "published" + a future go-live. The row
14700        // defers to the sweep — surface as scheduled.
14701        let go = Utc::now() + Duration::hours(2);
14702        assert_eq!(derive_scheduled_status("published", Some(go)), "scheduled");
14703    }
14704
14705    #[test]
14706    fn cleared_go_live_demotes_scheduled_to_draft() {
14707        assert_eq!(derive_scheduled_status("scheduled", None), "draft");
14708    }
14709
14710    #[test]
14711    fn past_go_live_on_scheduled_left_alone_for_sweep() {
14712        let past = Utc::now() - Duration::hours(1);
14713        assert_eq!(
14714            derive_scheduled_status("scheduled", Some(past)),
14715            "scheduled",
14716        );
14717    }
14718
14719    #[test]
14720    fn archived_preserved_regardless_of_go_live() {
14721        let go = Utc::now() + Duration::hours(1);
14722        assert_eq!(derive_scheduled_status("archived", Some(go)), "archived");
14723        assert_eq!(derive_scheduled_status("archived", None), "archived");
14724    }
14725
14726    #[test]
14727    fn draft_with_no_go_live_unchanged() {
14728        assert_eq!(derive_scheduled_status("draft", None), "draft");
14729    }
14730
14731    #[test]
14732    fn published_with_no_go_live_unchanged() {
14733        assert_eq!(derive_scheduled_status("published", None), "published");
14734    }
14735}
14736
14737/// Build the dataset for the scheduled-publish report: every page
14738/// with a future `go_live_at` plus every published page with a
14739/// future `expire_at`. Rows sorted by go_live_at ascending (soonest
14740/// first), with expirations interleaved by their expire_at.
14741async fn scheduled_pages_rows(
14742    pool: &rustango::sql::Pool,
14743) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
14744    use rustango::sql::FetcherPool as _;
14745    let pages: Vec<Page> = Page::objects().fetch(pool).await?;
14746    let now = chrono::Utc::now();
14747    let mut rows: Vec<serde_json::Value> = Vec::new();
14748    for p in &pages {
14749        let pid = p.id.get().copied().unwrap_or_default();
14750        if let Some(go) = p.go_live_at {
14751            // #264 — surface any page with a future `go_live_at`,
14752            // even if its status hasn't been coerced to "scheduled"
14753            // yet (the save handler now does the coercion, but legacy
14754            // rows or out-of-band edits may have `go_live_at` set on
14755            // a draft/published row — the editor still wants to see
14756            // the upcoming flip). Archived / expired rows are excluded
14757            // because both are explicit lifecycle termini.
14758            if go > now
14759                && p.status != crate::page::PageStatus::Archived.as_str()
14760                && p.status != crate::page::PageStatus::Expired.as_str()
14761            {
14762                let countdown = (go - now).num_seconds();
14763                rows.push(serde_json::json!({
14764                    "kind": "publish",
14765                    "when": go,
14766                    "countdown_secs": countdown,
14767                    "page_id": pid,
14768                    "title": p.title,
14769                    "url_path": p.url_path,
14770                    "status": p.status,
14771                }));
14772            }
14773        }
14774        if let Some(exp) = p.expire_at {
14775            // A scheduled page with both dates comes down too: list it.
14776            if exp > now
14777                && (p.status == crate::page::PageStatus::Published.as_str()
14778                    || p.status == crate::page::PageStatus::Scheduled.as_str())
14779            {
14780                let countdown = (exp - now).num_seconds();
14781                rows.push(serde_json::json!({
14782                    "kind": "expire",
14783                    "when": exp,
14784                    "countdown_secs": countdown,
14785                    "page_id": pid,
14786                    "title": p.title,
14787                    "url_path": p.url_path,
14788                    "status": p.status,
14789                }));
14790            }
14791        }
14792    }
14793    rows.sort_by_key(|r| {
14794        r.get("countdown_secs")
14795            .and_then(|v| v.as_i64())
14796            .unwrap_or(i64::MAX)
14797    });
14798    Ok(rows)
14799}
14800
14801pub async fn scheduled_report(
14802    State(state): State<super::AdminState>,
14803    tenant: Tenant,
14804    headers: HeaderMap,
14805    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14806) -> Result<Response, AdminError> {
14807    let rows = scheduled_pages_rows(tenant.pool())
14808        .await
14809        .unwrap_or_default();
14810    let mut ctx = Context::new();
14811    add_chrome(
14812        &mut ctx,
14813        &tenant,
14814        "reports-scheduled",
14815        session_user.as_ref(),
14816    )
14817    .await;
14818    add_admin_theme(&mut ctx, tenant.pool()).await;
14819    ctx.insert("rows", &rows);
14820    render_with_csrf(
14821        &state,
14822        &headers,
14823        "rcms_admin/scheduled_report.html",
14824        &mut ctx,
14825    )
14826}
14827
14828pub async fn scheduled_report_csv(
14829    State(_state): State<super::AdminState>,
14830    tenant: Tenant,
14831    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14832) -> Result<Response, AdminError> {
14833    let rows = scheduled_pages_rows(tenant.pool())
14834        .await
14835        .unwrap_or_default();
14836    let mut out = String::with_capacity(256 + rows.len() * 160);
14837    out.push_str("kind,page_id,title,url_path,status,when,countdown_secs\n");
14838    for r in &rows {
14839        out.push_str(&format!(
14840            "{},{},{},{},{},{},{}\n",
14841            csv_escape(r.get("kind").and_then(|v| v.as_str()).unwrap_or_default()),
14842            r.get("page_id")
14843                .and_then(|v| v.as_i64())
14844                .unwrap_or_default(),
14845            csv_escape(r.get("title").and_then(|v| v.as_str()).unwrap_or_default()),
14846            csv_escape(
14847                r.get("url_path")
14848                    .and_then(|v| v.as_str())
14849                    .unwrap_or_default()
14850            ),
14851            csv_escape(r.get("status").and_then(|v| v.as_str()).unwrap_or_default()),
14852            csv_escape(&r.get("when").map(ToString::to_string).unwrap_or_default()),
14853            r.get("countdown_secs")
14854                .and_then(|v| v.as_i64())
14855                .unwrap_or_default(),
14856        ));
14857    }
14858    Ok(csv_response("scheduled-pages", &out))
14859}
14860
14861/// Build the locked-pages dataset: every live PageLock joined with
14862/// its page + holder username. Returns rows sorted by acquired_at
14863/// desc (newest holds first). Excludes stale locks past their TTL.
14864async fn locked_pages_rows(
14865    pool: &rustango::sql::Pool,
14866) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
14867    use rustango::sql::FetcherPool as _;
14868    let locks: Vec<crate::lock::PageLock> = crate::lock::PageLock::objects()
14869        .order_by(&[("acquired_at", true)]) // desc
14870        .fetch(pool)
14871        .await?;
14872    let now = chrono::Utc::now();
14873    let live: Vec<&crate::lock::PageLock> = locks.iter().filter(|l| !l.is_stale(now)).collect();
14874    if live.is_empty() {
14875        return Ok(Vec::new());
14876    }
14877    let page_ids: Vec<i64> = live.iter().map(|l| l.page_id).collect();
14878    let user_ids: Vec<i64> = live.iter().map(|l| l.user_id).collect();
14879    let pages: Vec<Page> = Page::objects()
14880        .where_(Page::id.is_in(page_ids))
14881        .fetch(pool)
14882        .await
14883        .unwrap_or_default();
14884    let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
14885        .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
14886        .fetch(pool)
14887        .await
14888        .unwrap_or_default();
14889    let page_by_id: std::collections::HashMap<i64, &Page> = pages
14890        .iter()
14891        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
14892        .collect();
14893    let user_by_id: std::collections::HashMap<i64, String> = users
14894        .into_iter()
14895        .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
14896        .collect();
14897    Ok(live
14898        .into_iter()
14899        .map(|l| {
14900            let title = page_by_id
14901                .get(&l.page_id)
14902                .map(|p| p.title.clone())
14903                .unwrap_or_else(|| format!("page #{}", l.page_id));
14904            let url_path = page_by_id
14905                .get(&l.page_id)
14906                .map(|p| p.url_path.clone())
14907                .unwrap_or_default();
14908            let username = user_by_id
14909                .get(&l.user_id)
14910                .cloned()
14911                .unwrap_or_else(|| format!("user#{}", l.user_id));
14912            let ttl_remaining = (l.expires_at - now).num_seconds();
14913            serde_json::json!({
14914                "page_id": l.page_id,
14915                "title": title,
14916                "url_path": url_path,
14917                "user_id": l.user_id,
14918                "username": username,
14919                "acquired_at": l.acquired_at.get().copied(),
14920                "expires_at": l.expires_at,
14921                "ttl_remaining_secs": ttl_remaining,
14922            })
14923        })
14924        .collect())
14925}
14926
14927pub async fn locked_pages_report(
14928    State(state): State<super::AdminState>,
14929    tenant: Tenant,
14930    headers: HeaderMap,
14931    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
14932) -> Result<Response, AdminError> {
14933    let rows = locked_pages_rows(tenant.pool()).await.unwrap_or_default();
14934    let mut ctx = Context::new();
14935    add_chrome(&mut ctx, &tenant, "reports-locked", session_user.as_ref()).await;
14936    add_admin_theme(&mut ctx, tenant.pool()).await;
14937    ctx.insert("rows", &rows);
14938    render_with_csrf(&state, &headers, "rcms_admin/locked_pages.html", &mut ctx)
14939}
14940
14941pub async fn locked_pages_csv(
14942    State(_state): State<super::AdminState>,
14943    tenant: Tenant,
14944    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
14945) -> Result<Response, AdminError> {
14946    let rows = locked_pages_rows(tenant.pool()).await.unwrap_or_default();
14947    let mut out = String::with_capacity(256 + rows.len() * 128);
14948    out.push_str("page_id,title,url_path,username,acquired_at,expires_at\n");
14949    for r in &rows {
14950        out.push_str(&format!(
14951            "{},{},{},{},{},{}\n",
14952            r.get("page_id")
14953                .and_then(|v| v.as_i64())
14954                .unwrap_or_default(),
14955            csv_escape(r.get("title").and_then(|v| v.as_str()).unwrap_or_default()),
14956            csv_escape(
14957                r.get("url_path")
14958                    .and_then(|v| v.as_str())
14959                    .unwrap_or_default()
14960            ),
14961            csv_escape(
14962                r.get("username")
14963                    .and_then(|v| v.as_str())
14964                    .unwrap_or_default()
14965            ),
14966            csv_escape(
14967                r.get("acquired_at")
14968                    .and_then(|v| v.as_str())
14969                    .unwrap_or_default()
14970            ),
14971            csv_escape(
14972                r.get("expires_at")
14973                    .and_then(|v| v.as_str())
14974                    .unwrap_or_default()
14975            ),
14976        ));
14977    }
14978    Ok(csv_response("locked-pages", &out))
14979}
14980
14981// =====================================================================
14982// Workflows report (#109)
14983// =====================================================================
14984
14985async fn workflows_report_rows(
14986    pool: &rustango::sql::Pool,
14987) -> Result<Vec<serde_json::Value>, rustango::sql::ExecError> {
14988    use rustango::sql::FetcherPool as _;
14989    let states: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
14990        .order_by(&[("requested_at", true)]) // desc
14991        .fetch(pool)
14992        .await?;
14993    if states.is_empty() {
14994        return Ok(Vec::new());
14995    }
14996    let workflow_ids: Vec<i64> = states.iter().map(|s| s.workflow_id).collect();
14997    let page_ids: Vec<i64> = states.iter().map(|s| s.page_id).collect();
14998    let user_ids: Vec<i64> = states.iter().map(|s| s.requested_by).collect();
14999    let workflows: Vec<crate::workflow::Workflow> = crate::workflow::Workflow::objects()
15000        .where_(crate::workflow::Workflow::id.is_in(workflow_ids))
15001        .fetch(pool)
15002        .await
15003        .unwrap_or_default();
15004    let pages: Vec<Page> = Page::objects()
15005        .where_(Page::id.is_in(page_ids))
15006        .fetch(pool)
15007        .await
15008        .unwrap_or_default();
15009    let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
15010        .where_(rustango::tenancy::auth::User::id.is_in(user_ids))
15011        .fetch(pool)
15012        .await
15013        .unwrap_or_default();
15014    let task_ids: Vec<i64> = states.iter().filter_map(|s| s.current_task_id).collect();
15015    let tasks: Vec<crate::workflow::WorkflowTask> = if task_ids.is_empty() {
15016        Vec::new()
15017    } else {
15018        crate::workflow::WorkflowTask::objects()
15019            .where_(crate::workflow::WorkflowTask::id.is_in(task_ids))
15020            .fetch(pool)
15021            .await
15022            .unwrap_or_default()
15023    };
15024    let workflow_by_id: std::collections::HashMap<i64, String> = workflows
15025        .into_iter()
15026        .filter_map(|w| w.id.get().copied().map(|id| (id, w.name)))
15027        .collect();
15028    let page_by_id: std::collections::HashMap<i64, &Page> = pages
15029        .iter()
15030        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
15031        .collect();
15032    let user_by_id: std::collections::HashMap<i64, String> = users
15033        .into_iter()
15034        .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
15035        .collect();
15036    let task_by_id: std::collections::HashMap<i64, String> = tasks
15037        .into_iter()
15038        .filter_map(|t| t.id.get().copied().map(|id| (id, t.name)))
15039        .collect();
15040    Ok(states
15041        .iter()
15042        .map(|s| {
15043            serde_json::json!({
15044                "id": s.id.get().copied(),
15045                "workflow_name": workflow_by_id.get(&s.workflow_id).cloned().unwrap_or_else(|| format!("workflow #{}", s.workflow_id)),
15046                "page_id": s.page_id,
15047                "page_title": page_by_id.get(&s.page_id).map(|p| p.title.clone()).unwrap_or_else(|| format!("page #{}", s.page_id)),
15048                "page_url_path": page_by_id.get(&s.page_id).map(|p| p.url_path.clone()).unwrap_or_default(),
15049                "status": s.status,
15050                "current_task_name": s.current_task_id.and_then(|tid| task_by_id.get(&tid).cloned()),
15051                "requested_by_username": user_by_id.get(&s.requested_by).cloned(),
15052                "requested_at": s.requested_at.get().copied(),
15053                "finished_at": s.finished_at,
15054            })
15055        })
15056        .collect())
15057}
15058
15059pub async fn workflows_report(
15060    State(state): State<super::AdminState>,
15061    tenant: Tenant,
15062    headers: HeaderMap,
15063    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15064) -> Result<Response, AdminError> {
15065    let rows = workflows_report_rows(tenant.pool())
15066        .await
15067        .unwrap_or_default();
15068    let mut ctx = Context::new();
15069    add_chrome(
15070        &mut ctx,
15071        &tenant,
15072        "reports-workflows",
15073        session_user.as_ref(),
15074    )
15075    .await;
15076    add_admin_theme(&mut ctx, tenant.pool()).await;
15077    ctx.insert("rows", &rows);
15078    render_with_csrf(
15079        &state,
15080        &headers,
15081        "rcms_admin/workflow_report.html",
15082        &mut ctx,
15083    )
15084}
15085
15086// =====================================================================
15087// #122 — revision storage report + manual prune.
15088// =====================================================================
15089
15090/// GET /cms-admin/reports/revisions — list pages ordered by revision
15091/// count so editors can see which ones accumulate history fastest.
15092/// Surface a "Prune now" form scoped to the whole tenant.
15093pub async fn revisions_report(
15094    State(state): State<super::AdminState>,
15095    tenant: Tenant,
15096    headers: HeaderMap,
15097    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15098) -> Result<Response, AdminError> {
15099    use rustango::sql::FetcherPool as _;
15100    let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
15101    let revisions: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
15102        .fetch(tenant.pool())
15103        .await
15104        .unwrap_or_default();
15105    let mut count_by_page: std::collections::HashMap<i64, usize> = std::collections::HashMap::new();
15106    for r in &revisions {
15107        *count_by_page.entry(r.page_id).or_default() += 1;
15108    }
15109    let mut rows: Vec<serde_json::Value> = pages
15110        .into_iter()
15111        .filter_map(|p| {
15112            let pid = p.id.get().copied()?;
15113            let count = count_by_page.get(&pid).copied().unwrap_or(0);
15114            if count == 0 {
15115                return None;
15116            }
15117            Some(serde_json::json!({
15118                "page_id": pid,
15119                "title": p.title,
15120                "url_path": p.url_path,
15121                "status": p.status,
15122                "revision_count": count,
15123            }))
15124        })
15125        .collect();
15126    rows.sort_by(|a, b| {
15127        let ac = a
15128            .get("revision_count")
15129            .and_then(|v| v.as_u64())
15130            .unwrap_or(0);
15131        let bc = b
15132            .get("revision_count")
15133            .and_then(|v| v.as_u64())
15134            .unwrap_or(0);
15135        bc.cmp(&ac)
15136    });
15137    let total_revisions = revisions.len();
15138    let mut ctx = Context::new();
15139    add_chrome(
15140        &mut ctx,
15141        &tenant,
15142        "reports-revisions",
15143        session_user.as_ref(),
15144    )
15145    .await;
15146    add_admin_theme(&mut ctx, tenant.pool()).await;
15147    ctx.insert("rows", &rows);
15148    ctx.insert("total_revisions", &total_revisions);
15149    ctx.insert("default_keep_latest", &crate::revision::DEFAULT_KEEP_LATEST);
15150    render_with_csrf(
15151        &state,
15152        &headers,
15153        "rcms_admin/revisions_report.html",
15154        &mut ctx,
15155    )
15156}
15157
15158/// Form posted from the revisions report's "Prune now" button.
15159#[derive(Debug, Deserialize)]
15160pub struct RevisionsPruneForm {
15161    #[serde(default)]
15162    pub keep_latest: Option<usize>,
15163    #[serde(default)]
15164    pub include_published: Option<String>,
15165}
15166
15167/// POST /cms-admin/reports/revisions/prune — manual prune. Honours
15168/// the same `(keep_latest, keep_published)` knobs as the library
15169/// helper. Redirects back to the report with a count flash.
15170pub async fn revisions_report_prune(
15171    State(_state): State<super::AdminState>,
15172    tenant: Tenant,
15173    headers: HeaderMap,
15174    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
15175    Form(form): Form<RevisionsPruneForm>,
15176) -> Result<Response, AdminError> {
15177    let keep_latest = form
15178        .keep_latest
15179        .unwrap_or(crate::revision::DEFAULT_KEEP_LATEST)
15180        .max(1);
15181    // The form check sends "1" when the box is ticked → keep
15182    // published-status revisions. Unchecked = include them in the
15183    // sweep (more aggressive).
15184    let keep_published = form.include_published.as_deref() != Some("1");
15185    let (pages_scanned, rows_deleted) =
15186        crate::revision::prune_all_pages(tenant.pool(), keep_latest, keep_published)
15187            .await
15188            .unwrap_or((0, 0));
15189    let revisions = super::i18n::tr_plural(
15190        &headers,
15191        "{count} revision(s)",
15192        rows_deleted as i64,
15193        &[("count", &rows_deleted.to_string())],
15194    );
15195    let pages_ph = super::i18n::tr_plural(
15196        &headers,
15197        "{count} page(s)",
15198        pages_scanned as i64,
15199        &[("count", &pages_scanned.to_string())],
15200    );
15201    let kl = keep_latest.to_string();
15202    let kp = keep_published.to_string();
15203    redirect_named_with_message_args(
15204        "rcms-admin:reports:revisions",
15205        MsgLevel::Success,
15206        "Pruned {revisions} across {pages} (keep_latest={keep_latest}, keep_published={keep_published}).",
15207        &[
15208            ("revisions", revisions.as_str()),
15209            ("pages", pages_ph.as_str()),
15210            ("keep_latest", kl.as_str()),
15211            ("keep_published", kp.as_str()),
15212        ],
15213        &headers,
15214    )
15215}
15216
15217pub async fn workflows_report_csv(
15218    State(_state): State<super::AdminState>,
15219    tenant: Tenant,
15220    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
15221) -> Result<Response, AdminError> {
15222    let rows = workflows_report_rows(tenant.pool())
15223        .await
15224        .unwrap_or_default();
15225    let mut out = String::with_capacity(256 + rows.len() * 192);
15226    out.push_str("workflow,page_id,page_title,page_url,status,current_task,requested_by,requested_at,finished_at\n");
15227    for r in &rows {
15228        out.push_str(&format!(
15229            "{},{},{},{},{},{},{},{},{}\n",
15230            csv_escape(
15231                r.get("workflow_name")
15232                    .and_then(|v| v.as_str())
15233                    .unwrap_or_default()
15234            ),
15235            r.get("page_id")
15236                .and_then(|v| v.as_i64())
15237                .unwrap_or_default(),
15238            csv_escape(
15239                r.get("page_title")
15240                    .and_then(|v| v.as_str())
15241                    .unwrap_or_default()
15242            ),
15243            csv_escape(
15244                r.get("page_url_path")
15245                    .and_then(|v| v.as_str())
15246                    .unwrap_or_default()
15247            ),
15248            csv_escape(r.get("status").and_then(|v| v.as_str()).unwrap_or_default()),
15249            csv_escape(
15250                r.get("current_task_name")
15251                    .and_then(|v| v.as_str())
15252                    .unwrap_or_default()
15253            ),
15254            csv_escape(
15255                r.get("requested_by_username")
15256                    .and_then(|v| v.as_str())
15257                    .unwrap_or_default()
15258            ),
15259            csv_escape(
15260                r.get("requested_at")
15261                    .and_then(|v| v.as_str())
15262                    .unwrap_or_default()
15263            ),
15264            csv_escape(
15265                r.get("finished_at")
15266                    .and_then(|v| v.as_str())
15267                    .unwrap_or_default()
15268            ),
15269        ));
15270    }
15271    Ok(csv_response("workflow-report", &out))
15272}
15273
15274// =====================================================================
15275// Global admin search (#77 — stage 0)
15276// =====================================================================
15277
15278/// Query for the global search. `q` is the search needle; when
15279/// `autocomplete=1` is set the handler returns a JSON shape suited
15280/// to the topbar dropdown (no surrounding chrome).
15281#[derive(Debug, Deserialize)]
15282pub struct AdminSearchQuery {
15283    #[serde(default)]
15284    pub q: Option<String>,
15285    #[serde(default)]
15286    pub autocomplete: Option<String>,
15287}
15288
15289/// Query string for `GET /cms-admin/__page-chooser`.
15290#[derive(Debug, Deserialize)]
15291pub struct PageChooserQuery {
15292    #[serde(default)]
15293    pub q: Option<String>,
15294}
15295
15296/// Query string for the generic `GET /cms-admin/__chooser/{slug}`.
15297#[derive(Debug, Default, Deserialize)]
15298pub struct ChooserSearchQuery {
15299    #[serde(default)]
15300    pub q: Option<String>,
15301}
15302
15303/// GET `/cms-admin/__chooser/{slug}?q=<needle>` — JSON endpoint
15304/// backing any `register_chooser!`ed model, generalising the three
15305/// bespoke choosers. Returns `{ "items": [ { id, title, sub, … } ] }`,
15306/// the shape the shared overlay (`cms-ux.js`) renders. Unknown slug → 404.
15307pub async fn chooser_search_json(
15308    State(_state): State<super::AdminState>,
15309    tenant: Tenant,
15310    Path(slug): Path<String>,
15311    Query(q): Query<ChooserSearchQuery>,
15312) -> Result<Response, AdminError> {
15313    let Some(cvs) = super::chooser::find(&slug) else {
15314        return Ok((axum::http::StatusCode::NOT_FOUND, "unknown chooser").into_response());
15315    };
15316    let items = (cvs.search_rows)(tenant.pool().clone(), q.q.unwrap_or_default()).await;
15317    let body = serde_json::json!({ "items": items });
15318    Ok((
15319        [(header::CONTENT_TYPE, "application/json")],
15320        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15321    )
15322        .into_response())
15323}
15324
15325/// Query string for `GET /cms-admin/__media-picker`.
15326#[derive(Debug, Default, Deserialize)]
15327pub struct MediaPickerQuery {
15328    #[serde(default)]
15329    pub q: Option<String>,
15330    /// Collection filter: omitted = all collections, `0` = uncategorized
15331    /// (NULL collection_id), any other value = that exact collection.
15332    #[serde(default)]
15333    pub collection: Option<i64>,
15334    /// `"image"` (default) | `"document"` | `"other"` | `"any"`.
15335    #[serde(default)]
15336    pub kind: Option<String>,
15337    /// Comma-separated media ids — resolve exactly these rows (any kind
15338    /// unless `kind` is set explicitly). Used by the widget-label
15339    /// hydration pass to turn a server-rendered `#42` into the title.
15340    #[serde(default)]
15341    pub ids: Option<String>,
15342    #[serde(default)]
15343    pub limit: Option<usize>,
15344    #[serde(default)]
15345    pub offset: Option<usize>,
15346}
15347
15348/// GET `/cms-admin/__media-picker` — the media picker's data endpoint.
15349///
15350/// Richer than the generic `/cms-admin/__chooser/media` (which stays for
15351/// back-compat): collection + kind filters, offset pagination, and
15352/// server-computed `thumb_url`/`preview_url` rendition URLs. The URLs are
15353/// built here (not in JS) because renditions can be signature-gated
15354/// and only the server can sign a spec.
15355///
15356/// Filtering is in-Rust over a full fetch — the crate's tri-dialect
15357/// convention (see `render_media_list`); no SQL LIKE.
15358pub async fn media_picker_json(
15359    State(_state): State<super::AdminState>,
15360    tenant: Tenant,
15361    Query(q): Query<MediaPickerQuery>,
15362) -> Result<Response, AdminError> {
15363    let body = media_picker_payload(tenant.pool(), &q).await?;
15364    Ok((
15365        [(header::CONTENT_TYPE, "application/json")],
15366        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15367    )
15368        .into_response())
15369}
15370
15371/// Core of [`media_picker_json`], split out so unit tests can drive it with
15372/// an in-memory pool (the handler's `Tenant`/`State` extractors need a full
15373/// admin app).
15374pub(crate) async fn media_picker_payload(
15375    pool: &rustango::sql::Pool,
15376    q: &MediaPickerQuery,
15377) -> Result<serde_json::Value, AdminError> {
15378    let mut rows: Vec<Media> = Media::objects()
15379        .order_by(&[("uploaded_at", true)])
15380        .fetch(pool)
15381        .await?;
15382
15383    // Explicit-id lookup (label hydration): keep exactly those rows, and
15384    // default the kind filter OFF — a video/document id must resolve too.
15385    let id_set: Option<std::collections::HashSet<i64>> = q.ids.as_deref().map(|s| {
15386        s.split(',')
15387            .filter_map(|t| t.trim().parse::<i64>().ok())
15388            .collect()
15389    });
15390    if let Some(ids) = &id_set {
15391        rows.retain(|m| m.id.get().copied().is_some_and(|id| ids.contains(&id)));
15392    }
15393    // Kind filter — the picker is image-first ("Choose an image…");
15394    // documents have their own chooser kind. `any` opts out.
15395    let kind = q
15396        .kind
15397        .as_deref()
15398        .unwrap_or(if id_set.is_some() { "any" } else { "image" });
15399    if kind != "any" {
15400        rows.retain(|m| m.kind == kind);
15401    }
15402    // Per-collection counts for the dropdown, computed over the kind-filtered
15403    // set (before collection/search narrow it) so the numbers answer
15404    // "how many would this filter show?".
15405    let mut collection_counts: std::collections::HashMap<i64, i64> =
15406        std::collections::HashMap::new();
15407    let mut uncategorized_count: i64 = 0;
15408    for m in &rows {
15409        match m.collection_id {
15410            Some(cid) => *collection_counts.entry(cid).or_default() += 1,
15411            None => uncategorized_count += 1,
15412        }
15413    }
15414    match q.collection {
15415        Some(0) => rows.retain(|m| m.collection_id.is_none()),
15416        Some(cid) => rows.retain(|m| m.collection_id == Some(cid)),
15417        None => {}
15418    }
15419    if let Some(needle) = q.q.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
15420        let needle = needle.to_lowercase();
15421        rows.retain(|m| {
15422            m.title.to_lowercase().contains(&needle)
15423                || m.filename.to_lowercase().contains(&needle)
15424                || m.alt_text.to_lowercase().contains(&needle)
15425                || m.description.to_lowercase().contains(&needle)
15426        });
15427    }
15428
15429    let total = rows.len();
15430    let limit = q.limit.unwrap_or(60).min(200);
15431    let offset = q.offset.unwrap_or(0).min(total);
15432    let has_more = offset + limit < total;
15433    let page: Vec<serde_json::Value> = rows[offset..(offset + limit).min(total)]
15434        .iter()
15435        .map(|m| {
15436            let id = m.id.get().copied().unwrap_or_default();
15437            let is_image = m.kind == "image";
15438            let thumb_url = is_image
15439                .then(|| {
15440                    crate::rendition::rendition_url_for(
15441                        id,
15442                        "fill-320x320|format-webp|quality-70",
15443                        Some(m.content_hash.as_str()),
15444                    )
15445                })
15446                .flatten();
15447            let preview_url = is_image
15448                .then(|| {
15449                    crate::rendition::rendition_url_for(
15450                        id,
15451                        "max-640x480|format-webp|quality-80",
15452                        Some(m.content_hash.as_str()),
15453                    )
15454                })
15455                .flatten();
15456            serde_json::json!({
15457                "id": id,
15458                "title": if m.title.is_empty() { m.filename.clone() } else { m.title.clone() },
15459                "filename": m.filename,
15460                "kind": m.kind,
15461                "mime": m.mime,
15462                "size": m.size,
15463                "width": m.width,
15464                "height": m.height,
15465                "collection_id": m.collection_id,
15466                "alt_text": m.alt_text,
15467                "uploaded_at": m.uploaded_at,
15468                "thumb_url": thumb_url,
15469                "preview_url": preview_url,
15470            })
15471        })
15472        .collect();
15473
15474    // Collections in DFS order so the dropdown nests visually
15475    // ("— Child" under its parent). A visited set guards against
15476    // accidental parent cycles.
15477    let cols: Vec<crate::media::MediaCollection> =
15478        crate::media::MediaCollection::objects().fetch(pool).await?;
15479    let mut children: std::collections::HashMap<Option<i64>, Vec<&crate::media::MediaCollection>> =
15480        std::collections::HashMap::new();
15481    for c in &cols {
15482        children.entry(c.parent_id).or_default().push(c);
15483    }
15484    for v in children.values_mut() {
15485        v.sort_by(|a, b| a.sort_order.cmp(&b.sort_order).then(a.name.cmp(&b.name)));
15486    }
15487    let mut ordered: Vec<serde_json::Value> = Vec::with_capacity(cols.len());
15488    let mut visited: std::collections::HashSet<i64> = std::collections::HashSet::new();
15489    let mut stack: Vec<(i64, usize)> = children
15490        .get(&None)
15491        .map(|roots| {
15492            roots
15493                .iter()
15494                .rev()
15495                .filter_map(|c| c.id.get().copied())
15496                .map(|id| (id, 0))
15497                .collect()
15498        })
15499        .unwrap_or_default();
15500    let by_id: std::collections::HashMap<i64, &crate::media::MediaCollection> = cols
15501        .iter()
15502        .filter_map(|c| c.id.get().copied().map(|id| (id, c)))
15503        .collect();
15504    while let Some((id, depth)) = stack.pop() {
15505        if !visited.insert(id) {
15506            continue;
15507        }
15508        if let Some(c) = by_id.get(&id) {
15509            ordered.push(serde_json::json!({
15510                "id": id,
15511                "name": c.name,
15512                "depth": depth,
15513                "count": collection_counts.get(&id).copied().unwrap_or(0),
15514            }));
15515            if let Some(kids) = children.get(&Some(id)) {
15516                for k in kids.iter().rev() {
15517                    if let Some(kid) = k.id.get().copied() {
15518                        stack.push((kid, depth + 1));
15519                    }
15520                }
15521            }
15522        }
15523    }
15524
15525    Ok(serde_json::json!({
15526        "items": page,
15527        "collections": ordered,
15528        "uncategorized_count": uncategorized_count,
15529        "total": total,
15530        "has_more": has_more,
15531    }))
15532}
15533
15534/// GET /cms-admin/__page-chooser?q=<needle> — JSON endpoint backing
15535/// the PageChooser widget. Returns the top-N matching
15536/// pages by title / slug / url_path (LIKE, lowercased), bounded at 50.
15537/// Empty `q` returns the most recently updated pages so the chooser
15538/// has something useful to show on first open.
15539pub async fn page_chooser_json(
15540    State(_state): State<super::AdminState>,
15541    tenant: Tenant,
15542    Query(q): Query<PageChooserQuery>,
15543) -> Result<Response, AdminError> {
15544    let needle =
15545        q.q.as_deref()
15546            .map(str::trim)
15547            .filter(|s| !s.is_empty())
15548            .map(str::to_lowercase);
15549
15550    let mut pages: Vec<Page> = Page::objects()
15551        .order_by(&[("updated_at", true)])
15552        .fetch(tenant.pool())
15553        .await
15554        .unwrap_or_default();
15555
15556    if let Some(n) = needle.as_ref() {
15557        pages.retain(|p| {
15558            p.title.to_lowercase().contains(n)
15559                || p.slug.to_lowercase().contains(n)
15560                || p.url_path.to_lowercase().contains(n)
15561        });
15562    }
15563
15564    let items: Vec<serde_json::Value> = pages
15565        .iter()
15566        .take(50)
15567        .map(|p| {
15568            serde_json::json!({
15569                "id": p.id.get().copied(),
15570                "title": p.title,
15571                "slug": p.slug,
15572                "url_path": p.url_path,
15573                "depth": p.depth,
15574                "parent_id": p.parent_id,
15575                "status": p.status,
15576            })
15577        })
15578        .collect();
15579
15580    let body = serde_json::json!({ "items": items });
15581    Ok((
15582        [(header::CONTENT_TYPE, "application/json")],
15583        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15584    )
15585        .into_response())
15586}
15587
15588/// Query string for `GET /cms-admin/__snippet-chooser`. Optional
15589/// `type_name` narrows to one snippet kind — the `data-chooser-filter`
15590/// attribute on the widget threads through.
15591#[derive(Debug, Deserialize)]
15592pub struct SnippetChooserQuery {
15593    #[serde(default)]
15594    pub q: Option<String>,
15595    #[serde(default)]
15596    pub type_name: Option<String>,
15597    /// Comma-separated snippet ids — resolve exactly these rows. Used by
15598    /// the widget-label hydration pass (a server-rendered value only has
15599    /// the raw id).
15600    #[serde(default)]
15601    pub ids: Option<String>,
15602}
15603
15604/// GET /cms-admin/__snippet-chooser?q=…&type_name=… — JSON endpoint
15605/// backing the SnippetChooser widget. Returns the
15606/// top-50 matching snippets by title / slug; optionally filtered
15607/// to a single `type_name`.
15608pub async fn snippet_chooser_json(
15609    State(_state): State<super::AdminState>,
15610    tenant: Tenant,
15611    Query(q): Query<SnippetChooserQuery>,
15612) -> Result<Response, AdminError> {
15613    let needle =
15614        q.q.as_deref()
15615            .map(str::trim)
15616            .filter(|s| !s.is_empty())
15617            .map(str::to_lowercase);
15618    let type_filter = q
15619        .type_name
15620        .as_deref()
15621        .map(str::trim)
15622        .filter(|s| !s.is_empty())
15623        .map(str::to_owned);
15624
15625    let mut snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
15626        .order_by(&[("updated_at", true)])
15627        .fetch(tenant.pool())
15628        .await
15629        .unwrap_or_default();
15630
15631    if let Some(ids) = q.ids.as_deref() {
15632        let id_set: std::collections::HashSet<i64> = ids
15633            .split(',')
15634            .filter_map(|t| t.trim().parse::<i64>().ok())
15635            .collect();
15636        snippets.retain(|s| s.id.get().copied().is_some_and(|id| id_set.contains(&id)));
15637    }
15638    if let Some(tn) = type_filter.as_ref() {
15639        snippets.retain(|s| &s.type_name == tn);
15640    }
15641    if let Some(n) = needle.as_ref() {
15642        snippets
15643            .retain(|s| s.title.to_lowercase().contains(n) || s.slug.to_lowercase().contains(n));
15644    }
15645
15646    let items: Vec<serde_json::Value> = snippets
15647        .iter()
15648        .take(50)
15649        .map(|s| {
15650            serde_json::json!({
15651                "id": s.id.get().copied(),
15652                "title": s.title,
15653                "slug": s.slug,
15654                "type_name": s.type_name,
15655            })
15656        })
15657        .collect();
15658
15659    let body = serde_json::json!({ "items": items });
15660    Ok((
15661        [(header::CONTENT_TYPE, "application/json")],
15662        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15663    )
15664        .into_response())
15665}
15666
15667/// Query string for `GET /cms-admin/__document-chooser`.
15668#[derive(Debug, Deserialize)]
15669pub struct DocumentChooserQuery {
15670    #[serde(default)]
15671    pub q: Option<String>,
15672}
15673
15674/// GET /cms-admin/__document-chooser?q=… — JSON endpoint backing
15675/// the DocumentChooser widget. Returns top-50 media
15676/// rows where `kind = "document"` (i.e. non-images), filtered by
15677/// title / filename.
15678pub async fn document_chooser_json(
15679    State(_state): State<super::AdminState>,
15680    tenant: Tenant,
15681    Query(q): Query<DocumentChooserQuery>,
15682) -> Result<Response, AdminError> {
15683    let needle =
15684        q.q.as_deref()
15685            .map(str::trim)
15686            .filter(|s| !s.is_empty())
15687            .map(str::to_lowercase);
15688
15689    let mut rows: Vec<Media> = Media::objects()
15690        .where_(Media::kind.eq("document".to_owned()))
15691        .order_by(&[("uploaded_at", true)])
15692        .fetch(tenant.pool())
15693        .await
15694        .unwrap_or_default();
15695
15696    if let Some(n) = needle.as_ref() {
15697        rows.retain(|m| {
15698            m.title.to_lowercase().contains(n) || m.filename.to_lowercase().contains(n)
15699        });
15700    }
15701
15702    let items: Vec<serde_json::Value> = rows
15703        .iter()
15704        .take(50)
15705        .map(|m| {
15706            serde_json::json!({
15707                "id": m.id.get().copied(),
15708                "title": m.title,
15709                "filename": m.filename,
15710                "kind": m.kind,
15711                "mime": m.mime,
15712            })
15713        })
15714        .collect();
15715
15716    let body = serde_json::json!({ "items": items });
15717    Ok((
15718        [(header::CONTENT_TYPE, "application/json")],
15719        serde_json::to_string(&body).unwrap_or_else(|_| "{}".to_owned()),
15720    )
15721        .into_response())
15722}
15723
15724/// GET /cms-admin/search?q=<needle>[&autocomplete=1] — unified search
15725/// across pages, snippets, and media. In-memory case-insensitive
15726/// substring match only; the ranked `crate::search` backend is not
15727/// wired into this handler.
15728pub async fn admin_search(
15729    State(state): State<super::AdminState>,
15730    tenant: Tenant,
15731    headers: HeaderMap,
15732    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15733    Query(q): Query<AdminSearchQuery>,
15734) -> Result<Response, AdminError> {
15735    let needle =
15736        q.q.as_deref()
15737            .map(str::trim)
15738            .filter(|s| !s.is_empty())
15739            .map(str::to_lowercase);
15740    let autocomplete = q.autocomplete.as_deref() == Some("1");
15741
15742    // #143 — log every non-empty query. Best-effort; never blocks
15743    // the response. Skip autocomplete pings so the analytics surface
15744    // tracks user-intent queries, not keystroke-level ones.
15745    if !autocomplete {
15746        if let Some(raw) = q.q.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
15747            if let Err(e) = crate::search_promotion::log_query(tenant.pool(), raw).await {
15748                tracing::debug!(
15749                    target: "rustango_cms::search",
15750                    error = %e,
15751                    "search query log failed (best-effort)",
15752                );
15753            }
15754        }
15755    }
15756
15757    let mut pages_out: Vec<serde_json::Value> = Vec::new();
15758    let mut snippets_out: Vec<serde_json::Value> = Vec::new();
15759    let mut media_out: Vec<serde_json::Value> = Vec::new();
15760
15761    if let Some(needle) = needle.as_ref() {
15762        // Pages. #204 — recall extends from title/slug/url to also
15763        // include seo_title, seo_description, og_title, og_description
15764        // and (best-effort) the page-type extension's `load_extension`
15765        // JSON. Title hits float to the top — they're more relevant
15766        // than a stray match in a body paragraph.
15767        let all_pages: Vec<Page> = Page::objects()
15768            .order_by(&[("updated_at", true)])
15769            .fetch(tenant.pool())
15770            .await
15771            .unwrap_or_default();
15772        let page_types: Vec<PageType> = PageType::objects()
15773            .fetch(tenant.pool())
15774            .await
15775            .unwrap_or_default();
15776        let page_type_by_id: std::collections::HashMap<i64, String> = page_types
15777            .into_iter()
15778            .filter_map(|pt| pt.id.get().copied().map(|id| (id, pt.type_name)))
15779            .collect();
15780        let mut title_hits: Vec<serde_json::Value> = Vec::new();
15781        let mut body_hits: Vec<serde_json::Value> = Vec::new();
15782        for p in all_pages {
15783            if title_hits.len() + body_hits.len() >= 20 {
15784                break;
15785            }
15786            let title = p.title.to_lowercase();
15787            let slug = p.slug.to_lowercase();
15788            let url_path = p.url_path.to_lowercase();
15789            let primary_hit =
15790                title.contains(needle) || slug.contains(needle) || url_path.contains(needle);
15791
15792            // Wider body search — SEO/OG fields + extension JSON.
15793            let mut body_match = false;
15794            if !primary_hit {
15795                if p.seo_title.to_lowercase().contains(needle)
15796                    || p.seo_description.to_lowercase().contains(needle)
15797                    || p.og_title.to_lowercase().contains(needle)
15798                    || p.og_description.to_lowercase().contains(needle)
15799                {
15800                    body_match = true;
15801                }
15802                if !body_match {
15803                    if let Some(type_name) = page_type_by_id.get(&p.page_type_id) {
15804                        if let Some(handler) = crate::page_type::find_handler(type_name) {
15805                            let page_id = p.id.get().copied().unwrap_or_default();
15806                            if let Ok(ext) = handler.load_extension(tenant.pool(), page_id).await {
15807                                body_match = json_contains_needle(&ext, needle);
15808                            }
15809                        }
15810                    }
15811                }
15812            }
15813
15814            if primary_hit || body_match {
15815                let row = serde_json::json!({
15816                    "id": p.id.get().copied(),
15817                    "title": p.title,
15818                    "slug": p.slug,
15819                    "url_path": p.url_path,
15820                    "status": p.status,
15821                });
15822                if primary_hit {
15823                    title_hits.push(row);
15824                } else {
15825                    body_hits.push(row);
15826                }
15827            }
15828        }
15829        // Title-first ordering — primary hits float above body hits.
15830        pages_out.extend(title_hits);
15831        pages_out.extend(body_hits);
15832        if pages_out.len() > 20 {
15833            pages_out.truncate(20);
15834        }
15835
15836        // Snippets.
15837        let all_snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
15838            .order_by(&[("updated_at", true)])
15839            .fetch(tenant.pool())
15840            .await
15841            .unwrap_or_default();
15842        for s in all_snippets {
15843            if snippets_out.len() >= 20 {
15844                break;
15845            }
15846            let title = s.title.to_lowercase();
15847            let slug = s.slug.to_lowercase();
15848            if title.contains(needle) || slug.contains(needle) {
15849                snippets_out.push(serde_json::json!({
15850                    "id": s.id.get().copied(),
15851                    "title": s.title,
15852                    "slug": s.slug,
15853                    "type_name": s.type_name,
15854                }));
15855            }
15856        }
15857
15858        // Media.
15859        let all_media: Vec<crate::media::Media> = crate::media::Media::objects()
15860            .order_by(&[("created_at", true)])
15861            .fetch(tenant.pool())
15862            .await
15863            .unwrap_or_default();
15864        for m in all_media {
15865            if media_out.len() >= 20 {
15866                break;
15867            }
15868            let title = m.title.to_lowercase();
15869            let filename = m.filename.to_lowercase();
15870            let alt = m.alt_text.to_lowercase();
15871            if title.contains(needle) || filename.contains(needle) || alt.contains(needle) {
15872                media_out.push(serde_json::json!({
15873                    "id": m.id.get().copied(),
15874                    "title": m.title,
15875                    "filename": m.filename,
15876                    "alt_text": m.alt_text,
15877                    "kind": m.kind,
15878                }));
15879            }
15880        }
15881    }
15882
15883    // #107 — plugin-contributed search sources
15884    // (`register_admin_search_area!`). Each area returns its own
15885    // hit list keyed by area label. Empty when no query.
15886    let plugin_areas: Vec<serde_json::Value> = if let Some(query) = q.q.as_deref() {
15887        let trimmed = query.trim();
15888        if trimmed.is_empty() {
15889            Vec::new()
15890        } else {
15891            crate::hooks::run_admin_search_areas(trimmed)
15892                .into_iter()
15893                .map(|(label, hits)| {
15894                    serde_json::json!({
15895                        "label": label,
15896                        "hits": hits,
15897                    })
15898                })
15899                .collect()
15900        }
15901    } else {
15902        Vec::new()
15903    };
15904
15905    if autocomplete {
15906        // Compact JSON shape for the topbar dropdown.
15907        let payload = serde_json::json!({
15908            "q": q.q,
15909            "pages": pages_out.iter().take(5).collect::<Vec<_>>(),
15910            "snippets": snippets_out.iter().take(5).collect::<Vec<_>>(),
15911            "media": media_out.iter().take(5).collect::<Vec<_>>(),
15912            "plugin_areas": plugin_areas,
15913        });
15914        return Ok((
15915            [(header::CONTENT_TYPE, "application/json")],
15916            serde_json::to_string(&payload).unwrap_or_else(|_| "{}".to_owned()),
15917        )
15918            .into_response());
15919    }
15920
15921    let mut ctx = Context::new();
15922    add_chrome(&mut ctx, &tenant, "search", session_user.as_ref()).await;
15923    add_admin_theme(&mut ctx, tenant.pool()).await;
15924    ctx.insert("query", &q.q.unwrap_or_default());
15925    ctx.insert("pages", &pages_out);
15926    ctx.insert("snippets", &snippets_out);
15927    ctx.insert("media", &media_out);
15928    let plugin_hit_count: usize = plugin_areas
15929        .iter()
15930        .filter_map(|a| a.get("hits").and_then(|h| h.as_array()).map(Vec::len))
15931        .sum();
15932    ctx.insert("plugin_search_areas", &plugin_areas);
15933    ctx.insert(
15934        "total_hits",
15935        &(pages_out.len() + snippets_out.len() + media_out.len() + plugin_hit_count),
15936    );
15937    render_with_csrf(&state, &headers, "rcms_admin/admin_search.html", &mut ctx)
15938}
15939
15940// =====================================================================
15941// Navigation menus (#22)
15942// =====================================================================
15943
15944/// GET /cms-admin/navigation — list every menu.
15945pub async fn navigation_list(
15946    State(state): State<super::AdminState>,
15947    tenant: Tenant,
15948    headers: HeaderMap,
15949    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
15950) -> Result<Response, AdminError> {
15951    let menus: Vec<crate::navigation::Menu> = crate::navigation::Menu::objects()
15952        .order_by(&[("name", false)])
15953        .fetch(tenant.pool())
15954        .await?;
15955    // Per-menu item count so the list view shows "(N items)".
15956    let all_items: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
15957        .fetch(tenant.pool())
15958        .await?;
15959    let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
15960    for it in &all_items {
15961        *counts.entry(it.menu_id).or_insert(0) += 1;
15962    }
15963    let rows: Vec<serde_json::Value> = menus
15964        .iter()
15965        .map(|m| {
15966            let id = m.id.get().copied().unwrap_or_default();
15967            serde_json::json!({
15968                "id": id,
15969                "slug": m.slug,
15970                "name": m.name,
15971                "item_count": counts.get(&id).copied().unwrap_or(0),
15972                "created_at": m.created_at.get().copied(),
15973            })
15974        })
15975        .collect();
15976
15977    let mut ctx = Context::new();
15978    add_chrome(&mut ctx, &tenant, "navigation", session_user.as_ref()).await;
15979    add_admin_theme(&mut ctx, tenant.pool()).await;
15980    ctx.insert("menus", &rows);
15981    render_with_csrf(
15982        &state,
15983        &headers,
15984        "rcms_admin/navigation_list.html",
15985        &mut ctx,
15986    )
15987}
15988
15989/// Form payload for create / rename of a menu.
15990#[derive(Debug, Deserialize)]
15991pub struct MenuForm {
15992    pub slug: String,
15993    pub name: String,
15994}
15995
15996/// POST /cms-admin/navigation/new — create a new menu.
15997pub async fn navigation_create_submit(
15998    State(_state): State<super::AdminState>,
15999    tenant: Tenant,
16000    headers: HeaderMap,
16001    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16002    Form(form): Form<MenuForm>,
16003) -> Result<Response, AdminError> {
16004    let slug = form.slug.trim().to_lowercase();
16005    let name = form.name.trim().to_owned();
16006    if slug.is_empty() || name.is_empty() {
16007        return redirect_named_with_message(
16008            "rcms-admin:navigation:list",
16009            MsgLevel::Warning,
16010            "Menu slug + name are both required.",
16011            &headers,
16012        );
16013    }
16014    let mut row = crate::navigation::Menu {
16015        id: rustango::sql::Auto::Unset,
16016        slug: slug.clone(),
16017        name,
16018        created_at: rustango::sql::Auto::Unset,
16019    };
16020    row.insert_pool(tenant.pool()).await?;
16021    redirect_named_with_message_args(
16022        "rcms-admin:navigation:list",
16023        MsgLevel::Success,
16024        "Menu “{slug}” created.",
16025        &[("slug", slug.as_str())],
16026        &headers,
16027    )
16028}
16029
16030/// POST /cms-admin/navigation/{id}/delete — delete a menu (cascade
16031/// deletes its items via the schema FK).
16032pub async fn navigation_delete_submit(
16033    State(_state): State<super::AdminState>,
16034    tenant: Tenant,
16035    headers: HeaderMap,
16036    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16037    Path(id): Path<i64>,
16038) -> Result<Response, AdminError> {
16039    let menu = crate::navigation::Menu::objects()
16040        .where_(crate::navigation::Menu::id.eq(id))
16041        .first(tenant.pool())
16042        .await?
16043        .ok_or(AdminError::NotFound(id))?;
16044    // Items, their translations, then the menu — all in one transaction.
16045    // This used to delete items in fetch order with pool-level writes, so
16046    // a nested menu tripped the self-FK partway through and left the menu
16047    // half-deleted, and a translated item made it fail every time.
16048    let items: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16049        .where_(crate::navigation::MenuItem::menu_id.eq(id))
16050        .fetch(tenant.pool())
16051        .await?;
16052    rustango::atomic!(tenant.pool(), |tx| {
16053        let mut guard = tx.lock().await?;
16054        let tx = &mut *guard;
16055        delete_menu_items_tx(tx, items).await?;
16056        menu.delete_tx(tx).await?;
16057        Ok::<_, rustango::sql::ExecError>(())
16058    })
16059    .await?;
16060    redirect_named_with_message(
16061        "rcms-admin:navigation:list",
16062        MsgLevel::Success,
16063        "Menu deleted.",
16064        &headers,
16065    )
16066}
16067
16068/// POST /cms-admin/navigation/{id}/clone — duplicate a menu + all
16069/// its items. The new menu inherits the same item tree
16070/// (parent_id pointers remapped to the new MenuItem ids); page links
16071/// stay pointed at the same pages (no page duplication). Slug gets a
16072/// "-copy" suffix, then "-copy-2" / "-copy-3" / … to dodge the
16073/// unique constraint on `Menu.slug`. Name gets " (copy)" appended.
16074pub async fn navigation_clone_submit(
16075    State(_state): State<super::AdminState>,
16076    tenant: Tenant,
16077    headers: HeaderMap,
16078    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16079    Path(id): Path<i64>,
16080) -> Result<Response, AdminError> {
16081    let source = crate::navigation::Menu::objects()
16082        .where_(crate::navigation::Menu::id.eq(id))
16083        .first(tenant.pool())
16084        .await?
16085        .ok_or(AdminError::NotFound(id))?;
16086
16087    // Pick a unique slug. Menu.slug is unique across the tenant.
16088    let base = source.slug.trim_matches('-').to_owned();
16089    let desired = format!("{base}-copy");
16090    let existing_slugs: std::collections::HashSet<String> = crate::navigation::Menu::objects()
16091        .fetch(tenant.pool())
16092        .await?
16093        .into_iter()
16094        .map(|m| m.slug)
16095        .collect();
16096    let slug = if !existing_slugs.contains(&desired) {
16097        desired
16098    } else {
16099        let mut chosen = None;
16100        for n in 2..=100 {
16101            let candidate = format!("{desired}-{n}");
16102            if !existing_slugs.contains(&candidate) {
16103                chosen = Some(candidate);
16104                break;
16105            }
16106        }
16107        chosen.ok_or_else(|| {
16108            AdminError::Validation(
16109                "Could not allocate a unique slug for the cloned menu.".to_owned(),
16110            )
16111        })?
16112    };
16113
16114    let mut clone_menu = crate::navigation::Menu {
16115        id: rustango::sql::Auto::Unset,
16116        slug,
16117        name: format!("{} (copy)", source.name),
16118        created_at: rustango::sql::Auto::Unset,
16119    };
16120    // Clone items. `parent_id` needs remapping from source ids to the
16121    // freshly-inserted clone ids, so a parent must be inserted before its
16122    // children. `(parent_id.is_some(), sort_order, id)` is NOT that
16123    // order: it puts every non-root in one bucket sorted by `sort_order`,
16124    // which says nothing about depth. `seed_from_pages` numbers
16125    // `sort_order` per sibling bucket, so a grandchild routinely sorts
16126    // ahead of its parent — cloning a three-level menu then failed
16127    // partway and, with no transaction, left a junk `*-copy` behind.
16128    // Pre-order is the guarantee we actually need.
16129    let items = crate::navigation::order_pre_order(
16130        crate::navigation::MenuItem::objects()
16131            .where_(crate::navigation::MenuItem::menu_id.eq(id))
16132            .order_by(&[("sort_order", false), ("id", false)])
16133            .fetch(tenant.pool())
16134            .await?,
16135    );
16136    let count = items.len().to_string();
16137
16138    // Menu row and items together: a failure halfway through used to
16139    // leave the tenant with an empty, half-built `*-copy` menu.
16140    let new_menu_id = rustango::atomic!(tenant.pool(), |tx| {
16141        let mut guard = tx.lock().await?;
16142        let tx = &mut *guard;
16143        clone_menu.save_tx(tx).await?;
16144        let new_menu_id = clone_menu.id.get().copied().unwrap_or_default();
16145
16146        let mut id_map: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
16147        for item in &items {
16148            let old_id = item.id.get().copied().unwrap_or_default();
16149            // Pre-order guarantees the parent is mapped. An unreachable
16150            // item (orphan or cycle) is appended by `order_pre_order`
16151            // and re-parents to the root rather than aborting the clone
16152            // — losing the nesting of already-broken data beats refusing
16153            // to copy the menu at all.
16154            let new_parent = item.parent_id.and_then(|p| id_map.get(&p).copied());
16155            let mut clone_item = crate::navigation::MenuItem {
16156                id: rustango::sql::Auto::Unset,
16157                menu_id: new_menu_id,
16158                parent_id: new_parent,
16159                sort_order: item.sort_order,
16160                label: item.label.clone(),
16161                page_id: item.page_id,
16162                external_url: item.external_url.clone(),
16163                open_in_new_tab: item.open_in_new_tab,
16164            };
16165            clone_item.save_tx(tx).await?;
16166            id_map.insert(old_id, clone_item.id.get().copied().unwrap_or_default());
16167        }
16168        Ok::<_, rustango::sql::ExecError>(new_menu_id)
16169    })
16170    .await?;
16171
16172    redirect_named_with_params_and_message_args(
16173        "rcms-admin:navigation:edit",
16174        &[("id", new_menu_id.to_string())],
16175        MsgLevel::Success,
16176        "Cloned “{name}” with {count} items.",
16177        &[("name", source.name.as_str()), ("count", count.as_str())],
16178        &headers,
16179    )
16180}
16181
16182/// POST /cms-admin/navigation/{id}/seed-from-pages — Option B.
16183/// Replaces this menu's items with a tree
16184/// seeded from every published page that has `show_in_menus = true`.
16185/// The page tree's structure is preserved: a child MenuItem points
16186/// at its parent MenuItem when both pages are in the menu set; if a
16187/// page's parent is NOT in the menu set, the menu item lands at
16188/// the top level.
16189///
16190/// Idempotent — running it twice rebuilds the same tree (page ids
16191/// stay constant, so the second pass produces identical items).
16192/// Drops the existing menu items first; failure rolls back via
16193/// the per-row delete loop (matches the save-tree handler's
16194/// drop-and-rebuild approach).
16195pub async fn navigation_seed_from_pages_submit(
16196    State(_state): State<super::AdminState>,
16197    tenant: Tenant,
16198    headers: HeaderMap,
16199    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16200    Path(id): Path<i64>,
16201) -> Result<Response, AdminError> {
16202    use rustango::core::Column as _;
16203    use rustango::sql::FetcherPool as _;
16204
16205    let menu = crate::navigation::Menu::objects()
16206        .where_(crate::navigation::Menu::id.eq(id))
16207        .first(tenant.pool())
16208        .await?
16209        .ok_or(AdminError::NotFound(id))?;
16210
16211    // Step 1: collect what is there now. Deleted inside the transaction
16212    // below, not here — this used to delete row by row on the pool, in
16213    // fetch order, so re-seeding a nested menu tripped the self-FK
16214    // partway through and left the menu wiped with nothing re-inserted.
16215    // A second click on an "idempotent" button was straight data loss.
16216    let existing: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16217        .where_(crate::navigation::MenuItem::menu_id.eq(id))
16218        .fetch(tenant.pool())
16219        .await?;
16220
16221    // Step 2: fetch every menu-eligible page in materialized-path
16222    // order (tree-pre-order: a parent always appears before its
16223    // children, so the parent's new MenuItem id is mapped by the
16224    // time the child's row is processed).
16225    let mut pages: Vec<crate::page::Page> = crate::page::Page::objects()
16226        .where_(crate::page::Page::show_in_menus.eq(true))
16227        .where_(crate::page::Page::status.eq("published".to_owned()))
16228        .order_by(&[("path", false), ("id", false)])
16229        .fetch(tenant.pool())
16230        .await?;
16231    // Error pages are routing furniture, not navigation — excluded here
16232    // as `auto_menu`, `sitemap` and the tree endpoint all exclude them.
16233    // A 404 handler marked "Show in menus" used to land in the navbar.
16234    let error_tid = crate::error_pages::error_page_type_id(tenant.pool()).await;
16235    pages.retain(|p| error_tid.is_none_or(|tid| p.page_type_id != tid));
16236
16237    // Step 3: insert one MenuItem per page, mapping page.parent_id →
16238    // the freshly-inserted MenuItem id of that parent (if the parent
16239    // is also in the menu set). sort_order mirrors the sibling-
16240    // relative order in the page tree.
16241    let mut page_to_item: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
16242    let mut sibling_counter: std::collections::HashMap<Option<i64>, i32> =
16243        std::collections::HashMap::new();
16244    // One item per eligible page, so the count is known before the write
16245    // — and reading a counter mutated inside the transaction closure
16246    // would always have returned 0 anyway.
16247    let inserted = pages.len();
16248    rustango::atomic!(tenant.pool(), |tx| {
16249        let mut guard = tx.lock().await?;
16250        let tx = &mut *guard;
16251    delete_menu_items_tx(tx, existing).await?;
16252    for page in &pages {
16253        let page_id = page.id.get().copied().unwrap_or_default();
16254        let parent_menu_item_id: Option<i64> = page
16255            .parent_id
16256            .and_then(|pid| page_to_item.get(&pid).copied());
16257        // Sort order: monotonically increasing within each
16258        // parent-bucket so the menu builder shows pages in the same
16259        // sibling order the page tree has.
16260        let bucket = parent_menu_item_id;
16261        let sort_order = *sibling_counter
16262            .entry(bucket)
16263            .and_modify(|n| *n += 1)
16264            .or_insert(0);
16265        let mut item = crate::navigation::MenuItem {
16266            id: rustango::sql::Auto::Unset,
16267            menu_id: id,
16268            parent_id: parent_menu_item_id,
16269            sort_order,
16270            label: page.title.clone(),
16271            page_id: Some(page_id),
16272            external_url: None,
16273            open_in_new_tab: false,
16274        };
16275        item.save_tx(tx).await?;
16276        let new_item_id = item.id.get().copied().unwrap_or_default();
16277        page_to_item.insert(page_id, new_item_id);
16278    }
16279    Ok::<_, rustango::sql::ExecError>(())
16280    })
16281    .await?;
16282
16283    redirect_named_with_params_and_message_plural(
16284        "rcms-admin:navigation:edit",
16285        &[("id", id.to_string())],
16286        MsgLevel::Success,
16287        "Seeded “{name}” with {count} item(s) from pages marked Show in menus.",
16288        inserted as i64,
16289        &[
16290            ("name", menu.name.as_str()),
16291            ("count", &inserted.to_string()),
16292        ],
16293        &headers,
16294    )
16295}
16296
16297/// Delete menu items and their translations inside a transaction.
16298///
16299/// `cms_menu_item_translation.item_id` and `cms_menu_item.parent_id` are
16300/// both FKs with no `ON DELETE`, so the order is forced: translations
16301/// first, then items deepest-first. Three handlers got this wrong in
16302/// three different ways before it lived in one place — the menu delete
16303/// ignored translations entirely, the re-seed deleted in fetch order, and
16304/// save-tree sorted on `parent_id.is_none()`, which ties every non-root.
16305async fn delete_menu_items_tx(
16306    tx: &mut rustango::sql::PoolTx<'_>,
16307    items: Vec<crate::navigation::MenuItem>,
16308) -> Result<(), rustango::sql::ExecError> {
16309    use crate::menu_item_translation::MenuItemTranslation;
16310    if items.is_empty() {
16311        return Ok(());
16312    }
16313    let ids: Vec<i64> = items.iter().filter_map(|it| it.id.get().copied()).collect();
16314    if !ids.is_empty() {
16315        let orphans: Vec<MenuItemTranslation> = MenuItemTranslation::objects()
16316            .where_(MenuItemTranslation::item_id.is_in(ids))
16317            .fetch_tx(tx)
16318            .await?;
16319        for row in orphans {
16320            row.delete_tx(tx).await?;
16321        }
16322    }
16323    for it in crate::navigation::order_deepest_first(items) {
16324        it.delete_tx(tx).await?;
16325    }
16326    Ok(())
16327}
16328
16329/// POST /cms-admin/navigation/{id}/save-tree — WP-style menu builder
16330/// save. Accepts a JSON array of items in display order; each
16331/// entry's `local_id` is its position in the array (0-indexed) and
16332/// `parent_local_id` references the array index of the parent (null
16333/// for top-level). The handler:
16334///
16335///   1. Validates that the tree is acyclic + every parent_local_id
16336///      < the child's local_id (insert-order invariant).
16337///   2. Updates rows the payload still carries an `id` for, **in
16338///      place**, and inserts the rest.
16339///   3. Deletes the rows the payload dropped, children before parents.
16340///
16341/// It used to delete every row and re-insert, which meant a menu item's
16342/// id changed on every save. That was survivable while nothing
16343/// referenced those ids — and stopped being survivable the moment
16344/// `cms_menu_item_translation` keyed translations on `item_id`, since a
16345/// reorder would silently discard every translated label. Ids are now
16346/// stable across a save.
16347///
16348/// Failure rolls back; no half-saved state.
16349#[derive(Debug, Deserialize)]
16350pub struct SaveTreeItem {
16351    /// Existing `cms_menu_item.id`. `None` for items added in this
16352    /// session, in which case the handler inserts a new row. An id that
16353    /// doesn't belong to this menu is treated the same way, so a stale
16354    /// or forged id can't reassign another menu's item.
16355    #[serde(default)]
16356    pub id: Option<i64>,
16357    /// 0-indexed position in the submitted array.
16358    pub local_id: i32,
16359    /// Array index of the parent, or `None` for top-level.
16360    #[serde(default)]
16361    pub parent_local_id: Option<i32>,
16362    pub label: String,
16363    #[serde(default)]
16364    pub page_id: Option<i64>,
16365    #[serde(default)]
16366    pub external_url: Option<String>,
16367    #[serde(default)]
16368    pub open_in_new_tab: bool,
16369}
16370
16371#[derive(Debug, Deserialize)]
16372pub struct SaveTreePayload {
16373    pub items: Vec<SaveTreeItem>,
16374}
16375
16376pub async fn navigation_save_tree_submit(
16377    State(_state): State<super::AdminState>,
16378    tenant: Tenant,
16379    Path(id): Path<i64>,
16380    axum::Json(payload): axum::Json<SaveTreePayload>,
16381) -> Result<Response, AdminError> {
16382    // Validate tree shape: every parent_local_id must reference an
16383    // earlier index (so we can insert in order without two passes).
16384    for (i, item) in payload.items.iter().enumerate() {
16385        if item.local_id as usize != i {
16386            return Err(AdminError::Validation(format!(
16387                "items[{i}].local_id must equal its array index"
16388            )));
16389        }
16390        if let Some(p) = item.parent_local_id {
16391            if (p as usize) >= i {
16392                return Err(AdminError::Validation(format!(
16393                    "items[{i}].parent_local_id {p} must reference an earlier item"
16394                )));
16395            }
16396        }
16397    }
16398
16399    // Exactly one link target, and lengths the columns can hold. The
16400    // form handler enforced this and `save-tree` did not, so the builder
16401    // could store an item with both (`page_id` silently wins, and
16402    // unpublishing that page drops an item carrying a perfectly good
16403    // external fallback) or with neither (rendered as a link to `/`,
16404    // indistinguishable from a grouping header). An over-long label
16405    // reached the driver as a raw error and surfaced as a 500.
16406    for (i, item) in payload.items.iter().enumerate() {
16407        let external = item
16408            .external_url
16409            .as_deref()
16410            .map(str::trim)
16411            .filter(|s| !s.is_empty());
16412        match (item.page_id, external) {
16413            (Some(_), Some(_)) => {
16414                return Err(AdminError::Validation(format!(
16415                    "items[{i}] sets both a page and an external URL — pick one"
16416                )))
16417            }
16418            (None, None) => {
16419                return Err(AdminError::Validation(format!(
16420                    "items[{i}] has no link target — set a page or an external URL"
16421                )))
16422            }
16423            _ => {}
16424        }
16425        if item.label.chars().count() > 200 {
16426            return Err(AdminError::Validation(format!(
16427                "items[{i}].label is too long (max 200 characters)"
16428            )));
16429        }
16430        if external.is_some_and(|u| u.chars().count() > 500) {
16431            return Err(AdminError::Validation(format!(
16432                "items[{i}].external_url is too long (max 500 characters)"
16433            )));
16434        }
16435    }
16436
16437    // An id may appear at most once. The upsert below claims each kept row
16438    // out of `existing_by_id`, so a repeat would find the row already
16439    // taken — previously an `.expect` that panicked mid-transaction.
16440    let mut seen: std::collections::HashSet<i64> = std::collections::HashSet::new();
16441    for (i, item) in payload.items.iter().enumerate() {
16442        if let Some(iid) = item.id {
16443            if !seen.insert(iid) {
16444                return Err(AdminError::Validation(format!(
16445                    "items[{i}].id {iid} appears more than once"
16446                )));
16447            }
16448        }
16449    }
16450
16451    // Every sibling handler verifies the menu first; this one went
16452    // straight to inserting rows with `menu_id: id`, so a stale or
16453    // mistyped id surfaced as a raw FK violation (a 500) instead of a
16454    // 404.
16455    if crate::navigation::Menu::objects()
16456        .where_(crate::navigation::Menu::id.eq(id))
16457        .first(tenant.pool())
16458        .await?
16459        .is_none()
16460    {
16461        return Err(AdminError::NotFound(id));
16462    }
16463
16464    let existing: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16465        .where_(crate::navigation::MenuItem::menu_id.eq(id))
16466        .fetch(tenant.pool())
16467        .await?;
16468    let mut existing_by_id: std::collections::HashMap<i64, crate::navigation::MenuItem> = existing
16469        .into_iter()
16470        .filter_map(|it| it.id.get().copied().map(|iid| (iid, it)))
16471        .collect();
16472
16473    // Claim each payload entry's existing row up front, so the write loop
16474    // below has no fallible lookup left to make. `Some(row)` updates in
16475    // place (keeping the id, and with it the item's translations);
16476    // `None` inserts. An id from another menu, or one that isn't in this
16477    // menu at all, resolves to `None` rather than stealing that row.
16478    let plan: Vec<Option<crate::navigation::MenuItem>> = payload
16479        .items
16480        .iter()
16481        .map(|it| it.id.and_then(|iid| existing_by_id.remove(&iid)))
16482        .collect();
16483
16484    let items_saved = payload.items.len();
16485    rustango::atomic!(tenant.pool(), |tx| {
16486        let mut guard = tx.lock().await?;
16487        let tx = &mut *guard;
16488        // Upsert in array order, resolving each item's parent from the
16489        // slot its `local_id` indexes. The validation above pins
16490        // `local_id` to the array index and requires
16491        // `parent_local_id < local_id`, so a parent's slot is always
16492        // filled before a child reads it — no fallible lookup here, and
16493        // no way to express one.
16494        let mut resolved: Vec<i64> = Vec::with_capacity(payload.items.len());
16495        for ((i, item), claimed) in payload.items.iter().enumerate().zip(plan) {
16496            let parent_id = item.parent_local_id.map(|p| resolved[p as usize]);
16497            let external_url = item
16498                .external_url
16499                .as_ref()
16500                .filter(|s| !s.trim().is_empty())
16501                .cloned();
16502            let sort_order = (i as i32) * 10;
16503
16504            let new_id = match claimed {
16505                Some(mut row) => {
16506                    // Update in place — this is what keeps the id, and
16507                    // therefore the item's translations, alive.
16508                    let iid = row.id.get().copied().unwrap_or_default();
16509                    row.parent_id = parent_id;
16510                    row.sort_order = sort_order;
16511                    row.label = item.label.clone();
16512                    row.page_id = item.page_id;
16513                    row.external_url = external_url;
16514                    row.open_in_new_tab = item.open_in_new_tab;
16515                    row.save_tx(tx).await?;
16516                    iid
16517                }
16518                None => {
16519                    let mut row = crate::navigation::MenuItem {
16520                        id: rustango::sql::Auto::Unset,
16521                        menu_id: id,
16522                        parent_id,
16523                        sort_order,
16524                        label: item.label.clone(),
16525                        page_id: item.page_id,
16526                        external_url,
16527                        open_in_new_tab: item.open_in_new_tab,
16528                    };
16529                    row.save_tx(tx).await?;
16530                    row.id.get().copied().unwrap_or_default()
16531                }
16532            };
16533            resolved.push(new_id);
16534        }
16535
16536        // Whatever the payload dropped. Every surviving row has already
16537        // been repointed above, so nothing still references these — but
16538        // they may reference each other, and `MenuItem.parent_id` is an
16539        // FK to `cms_menu_item.id` with no `ON DELETE`, so a parent can
16540        // only go once its children are gone.
16541        delete_menu_items_tx(tx, existing_by_id.into_values().collect()).await?;
16542        Ok::<_, rustango::sql::ExecError>(())
16543    })
16544    .await?;
16545
16546    Ok(axum::Json(serde_json::json!({
16547        "ok": true,
16548        "items_saved": items_saved,
16549    }))
16550    .into_response())
16551}
16552
16553/// GET /cms-admin/navigation/{id}/edit — item editor for one menu.
16554pub async fn navigation_edit_form(
16555    State(state): State<super::AdminState>,
16556    tenant: Tenant,
16557    headers: HeaderMap,
16558    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
16559    Path(id): Path<i64>,
16560    Query(q): Query<EditQuery>,
16561) -> Result<Response, AdminError> {
16562    let menu = crate::navigation::Menu::objects()
16563        .where_(crate::navigation::Menu::id.eq(id))
16564        .first(tenant.pool())
16565        .await?
16566        .ok_or(AdminError::NotFound(id))?;
16567    // Pre-order, not `ORDER BY parent_id`. The builder derives each
16568    // item's parent from DOM adjacency on save, so the DOM has to start
16569    // in pre-order or merely opening a menu and pressing Save rewrites
16570    // its nesting — see `navigation::order_pre_order`.
16571    let items = crate::navigation::order_pre_order(
16572        crate::navigation::MenuItem::objects()
16573            .where_(crate::navigation::MenuItem::menu_id.eq(id))
16574            .order_by(&[("sort_order", false), ("id", false)])
16575            .fetch(tenant.pool())
16576            .await?,
16577    );
16578    // Pages flagged `show_in_menus = true` are the suggested-picker
16579    // entries; fall back to "every page" if no editor has opted any
16580    // pages in yet.
16581    let suggested: Vec<Page> = Page::objects()
16582        .where_(Page::show_in_menus.eq(true))
16583        .order_by(&[("title", false)])
16584        .fetch(tenant.pool())
16585        .await?;
16586    // WP-style builder (#44): the picker always shows every page so
16587    // editors can drop any of them in. The legacy curated flag stays
16588    // available for downstream theme rendering but no longer hides
16589    // pages from the admin picker.
16590    let all_pages: Vec<Page> = Page::objects()
16591        .order_by(&[("title", false)])
16592        .fetch(tenant.pool())
16593        .await?;
16594
16595    // Resolve item rows into a render-friendly shape (label, url,
16596    // page title for the dropdown when set).
16597    let by_page_id: std::collections::HashMap<i64, &Page> = all_pages
16598        .iter()
16599        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
16600        .collect();
16601    // ?locale=<non-default> switches the editor into translation mode:
16602    // the tree builder still edits canonical structure, and a second
16603    // panel edits this locale's label overrides. Same shape as the page
16604    // and snippet editors, so the locale switcher behaves identically
16605    // wherever an editor meets one.
16606    let locales: Vec<Locale> = Locale::objects()
16607        .where_(Locale::active.eq(true))
16608        .order_by(&[("is_default", true), ("code", false)])
16609        .fetch(tenant.pool())
16610        .await?;
16611    let editing_locale: Option<Locale> = match q.locale.as_deref().filter(|c| !c.is_empty()) {
16612        Some(code) => locales.iter().find(|l| l.code == code).cloned(),
16613        None => None,
16614    };
16615    let translation_mode = editing_locale.as_ref().is_some_and(|l| !l.is_default);
16616    let item_translations = match editing_locale.as_ref().filter(|l| !l.is_default) {
16617        Some(loc) => {
16618            let lid = loc.id.get().copied().unwrap_or_default();
16619            let ids: Vec<i64> = items.iter().filter_map(|it| it.id.get().copied()).collect();
16620            crate::menu_item_translation::fetch_for_items(tenant.pool(), &ids, lid).await?
16621        }
16622        None => std::collections::HashMap::new(),
16623    };
16624
16625    let item_rows: Vec<serde_json::Value> = items
16626        .iter()
16627        .map(|it| {
16628            let resolved_label = if it.label.trim().is_empty() {
16629                it.page_id
16630                    .and_then(|pid| by_page_id.get(&pid).map(|p| p.title.clone()))
16631                    .unwrap_or_default()
16632            } else {
16633                it.label.clone()
16634            };
16635            let resolved_url = match (it.page_id, it.external_url.clone()) {
16636                (Some(pid), _) => by_page_id
16637                    .get(&pid)
16638                    .map(|p| p.url_path.clone())
16639                    .unwrap_or_else(|| "—".to_owned()),
16640                (None, Some(url)) => url,
16641                _ => "—".to_owned(),
16642            };
16643            let tr = it
16644                .id
16645                .get()
16646                .and_then(|iid| item_translations.get(iid));
16647            serde_json::json!({
16648                "id": it.id.get().copied(),
16649                "label": it.label,
16650                "resolved_label": resolved_label,
16651                "page_id": it.page_id,
16652                "external_url": it.external_url,
16653                "parent_id": it.parent_id,
16654                "sort_order": it.sort_order,
16655                "open_in_new_tab": it.open_in_new_tab,
16656                "resolved_url": resolved_url,
16657                "tr_label": tr.and_then(|m| m.get("label")).cloned().unwrap_or_default(),
16658                "tr_external_url": tr
16659                    .and_then(|m| m.get("external_url"))
16660                    .cloned()
16661                    .unwrap_or_default(),
16662            })
16663        })
16664        .collect();
16665
16666    // Error pages are served for a status code; a menu never links one.
16667    let error_tid = crate::error_pages::error_page_type_id(tenant.pool()).await;
16668    let linkable = |p: &&Page| error_tid.map_or(true, |tid| p.page_type_id != tid);
16669    let picker_pages: Vec<serde_json::Value> = all_pages
16670        .iter()
16671        .filter(linkable)
16672        .map(|p| {
16673            serde_json::json!({
16674                "id": p.id.get().copied(),
16675                "title": p.title,
16676                "url_path": p.url_path,
16677            })
16678        })
16679        .collect();
16680
16681    // #49c — recent-pages tab. 20 most-recently-updated pages so
16682    // editors who just published something can drop it into the menu
16683    // without scrolling the full picker. Fetched via a separate
16684    // updated_at-desc query so the existing alphabetical picker
16685    // stays unchanged.
16686    let recent_pages_raw: Vec<Page> = Page::objects()
16687        .order_by(&[("updated_at", true)])
16688        .fetch(tenant.pool())
16689        .await?;
16690    let picker_recent: Vec<serde_json::Value> = recent_pages_raw
16691        .iter()
16692        .filter(linkable)
16693        .take(20)
16694        .map(|p| {
16695            serde_json::json!({
16696                "id": p.id.get().copied(),
16697                "title": p.title,
16698                "url_path": p.url_path,
16699                "updated_at": p.updated_at,
16700            })
16701        })
16702        .collect();
16703
16704    // #49d — Library tab. Each registered `LibraryTypeHandler` opts
16705    // in via `menu_picker_entries(pool)`; we flatten the result
16706    // across every handler and tag each entry with the contributing
16707    // type's verbose_name so editors can tell where an entry came
16708    // from. Failure in any handler short-circuits the response so
16709    // bugs surface loudly instead of silently hiding entries.
16710    let mut picker_library: Vec<serde_json::Value> = Vec::new();
16711    for handler in crate::library::registered_handlers() {
16712        let entries = handler
16713            .menu_picker_entries(tenant.pool())
16714            .await
16715            .map_err(|e| {
16716                AdminError::Validation(format!(
16717                    "library `{}::menu_picker_entries` failed: {e}",
16718                    handler.type_name()
16719                ))
16720            })?;
16721        for entry in entries {
16722            picker_library.push(serde_json::json!({
16723                "label": entry.label,
16724                "url": entry.url,
16725                "kind_hint": entry.kind_hint,
16726                "library_type": handler.verbose_name(),
16727            }));
16728        }
16729    }
16730
16731    let mut ctx = Context::new();
16732    add_chrome(&mut ctx, &tenant, "navigation", session_user.as_ref()).await;
16733    add_admin_theme(&mut ctx, tenant.pool()).await;
16734    ctx.insert("menu_id", &menu.id.get().copied());
16735    ctx.insert("menu_slug", &menu.slug);
16736    ctx.insert("menu_name", &menu.name);
16737    ctx.insert("items", &item_rows);
16738    ctx.insert("picker_pages", &picker_pages);
16739    ctx.insert("picker_recent", &picker_recent);
16740    ctx.insert("picker_library", &picker_library);
16741    ctx.insert("has_library_picker", &!picker_library.is_empty());
16742    ctx.insert("has_curated_picker", &!suggested.is_empty());
16743    ctx.insert("locales", &locales);
16744    ctx.insert("editing_locale", &editing_locale);
16745    ctx.insert("translation_mode", &translation_mode);
16746    render_with_csrf(
16747        &state,
16748        &headers,
16749        "rcms_admin/navigation_edit.html",
16750        &mut ctx,
16751    )
16752}
16753
16754/// POST /cms-admin/navigation/{id}/translate?locale=<code> — save this
16755/// locale's label overrides for a menu's items.
16756///
16757/// Separate from the tree save on purpose. The builder posts JSON and
16758/// owns *structure*; this posts a form and owns *text*, so an editor
16759/// translating labels cannot accidentally reshape the menu, and a
16760/// reorder cannot drop a translation.
16761///
16762/// Field names are `tr__<item id>__<field>`. An empty value deletes the
16763/// override rather than storing a blank, which is what makes the
16764/// canonical label show through again.
16765pub async fn navigation_translate_submit(
16766    State(_state): State<super::AdminState>,
16767    tenant: Tenant,
16768    Path(id): Path<i64>,
16769    Query(q): Query<EditQuery>,
16770    Form(form): Form<std::collections::HashMap<String, String>>,
16771) -> Result<Response, AdminError> {
16772    use crate::menu_item_translation::MenuItemTranslation;
16773
16774    let code = q
16775        .locale
16776        .as_deref()
16777        .filter(|c| !c.is_empty())
16778        .ok_or_else(|| AdminError::Validation("translate requires ?locale=".to_owned()))?;
16779    let locale = Locale::objects()
16780        .where_(Locale::code.eq(code.to_owned()))
16781        .where_(Locale::active.eq(true))
16782        .first(tenant.pool())
16783        .await?
16784        .ok_or_else(|| AdminError::Validation(format!("unknown locale `{code}`")))?;
16785    if locale.is_default {
16786        return Ok((
16787            axum::http::StatusCode::BAD_REQUEST,
16788            "cannot translate INTO the default locale; canonical labels live on cms_menu_item",
16789        )
16790            .into_response());
16791    }
16792    let locale_id = locale
16793        .id
16794        .get()
16795        .copied()
16796        .ok_or_else(|| AdminError::Validation("locale row missing id".to_owned()))?;
16797
16798    // Only this menu's items are editable here — the field names carry
16799    // item ids, and without this check a crafted post could write
16800    // translations for another menu's items.
16801    let own_items: std::collections::HashSet<i64> = crate::navigation::MenuItem::objects()
16802        .where_(crate::navigation::MenuItem::menu_id.eq(id))
16803        .fetch(tenant.pool())
16804        .await?
16805        .iter()
16806        .filter_map(|it| it.id.get().copied())
16807        .collect();
16808
16809    let mut updates: Vec<(i64, String, String)> = Vec::new();
16810    for (k, v) in &form {
16811        let Some(rest) = k.strip_prefix("tr__") else {
16812            continue;
16813        };
16814        let Some((raw_id, raw_field)) = rest.split_once("__") else {
16815            continue;
16816        };
16817        let Ok(item_id) = raw_id.parse::<i64>() else {
16818            continue;
16819        };
16820        if !own_items.contains(&item_id) {
16821            continue;
16822        }
16823        // A malformed field is skipped rather than 400-ing the batch, so
16824        // one bad input doesn't discard an editor's other edits.
16825        if let Ok(field) = crate::menu_item_translation::validate_field_path(raw_field) {
16826            updates.push((item_id, field, v.trim().to_owned()));
16827        }
16828    }
16829
16830    rustango::atomic!(tenant.pool(), |tx| {
16831        let mut guard = tx.lock().await?;
16832        let tx = &mut *guard;
16833        for (item_id, field, value) in updates {
16834            let existing: Vec<MenuItemTranslation> = MenuItemTranslation::objects()
16835                .where_(MenuItemTranslation::item_id.eq(item_id))
16836                .where_(MenuItemTranslation::locale_id.eq(locale_id))
16837                .where_(MenuItemTranslation::field_path.eq(field.clone()))
16838                .fetch_tx(tx)
16839                .await?;
16840            if value.is_empty() {
16841                for row in existing {
16842                    row.delete_tx(tx).await?;
16843                }
16844            } else if let Some(mut row) = existing.into_iter().next() {
16845                row.value = value;
16846                row.save_tx(tx).await?;
16847            } else {
16848                let mut row = MenuItemTranslation {
16849                    id: rustango::sql::Auto::Unset,
16850                    item_id,
16851                    locale_id,
16852                    field_path: field,
16853                    value,
16854                    updated_at: rustango::sql::Auto::Unset,
16855                };
16856                row.save_tx(tx).await?;
16857            }
16858        }
16859        Ok::<_, rustango::sql::ExecError>(())
16860    })
16861    .await?;
16862
16863    Ok(Redirect::to(&format!(
16864        "/cms-admin/navigation/{id}/edit?locale={code}"
16865    ))
16866    .into_response())
16867}
16868
16869/// Form payload for adding / updating a menu item. Empty strings on
16870/// `page_id` and `external_url` map to None; the validator enforces
16871/// "exactly one of the two".
16872#[derive(Debug, Deserialize)]
16873pub struct MenuItemForm {
16874    pub label: String,
16875    #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
16876    pub page_id: Option<i64>,
16877    #[serde(default)]
16878    pub external_url: Option<String>,
16879    #[serde(default, deserialize_with = "super::deserialize_optional_i64")]
16880    pub parent_id: Option<i64>,
16881    #[serde(default)]
16882    pub sort_order: Option<i32>,
16883    #[serde(default)]
16884    pub open_in_new_tab: Option<String>,
16885}
16886
16887/// Reject a `parent_id` that does not belong to `menu_id`.
16888///
16889/// The form took the value straight from the request, so an item could be
16890/// parented into another menu — leaving it invisible in *both* (each
16891/// resolver buckets by its own `menu_id`, so the child is unreachable in
16892/// one and filtered out of the other) and making the other menu
16893/// permanently undeletable, because its item is now referenced by a row
16894/// the delete never sees.
16895async fn validate_menu_parent(
16896    tenant: &Tenant,
16897    menu_id: i64,
16898    parent_id: Option<i64>,
16899) -> Result<(), AdminError> {
16900    let Some(pid) = parent_id else {
16901        return Ok(());
16902    };
16903    let parent = crate::navigation::MenuItem::objects()
16904        .where_(crate::navigation::MenuItem::id.eq(pid))
16905        .first(tenant.pool())
16906        .await?;
16907    match parent {
16908        Some(p) if p.menu_id == menu_id => Ok(()),
16909        Some(_) => Err(AdminError::Validation(
16910            "That parent item belongs to a different menu.".to_owned(),
16911        )),
16912        None => Err(AdminError::Validation(
16913            "That parent item no longer exists.".to_owned(),
16914        )),
16915    }
16916}
16917
16918impl MenuItemForm {
16919    fn parsed_external_url(&self) -> Option<String> {
16920        self.external_url
16921            .as_deref()
16922            .map(str::trim)
16923            .filter(|s| !s.is_empty())
16924            .map(str::to_owned)
16925    }
16926}
16927
16928/// POST /cms-admin/navigation/{id}/items — create a new menu item.
16929pub async fn navigation_item_create(
16930    State(_state): State<super::AdminState>,
16931    tenant: Tenant,
16932    headers: HeaderMap,
16933    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16934    Path(menu_id): Path<i64>,
16935    Form(form): Form<MenuItemForm>,
16936) -> Result<Response, AdminError> {
16937    let external = form.parsed_external_url();
16938    // "Exactly one of page_id / external_url" — fail soft to the
16939    // edit page with a warning message.
16940    if form.page_id.is_some() == external.is_some() {
16941        return redirect_named_with_params_and_message(
16942            "rcms-admin:navigation:edit",
16943            &[("id", menu_id.to_string())],
16944            MsgLevel::Warning,
16945            "Pick exactly one of: a page link, or a custom URL.",
16946            &headers,
16947        );
16948    }
16949    // The parent must live in this menu — see `validate_menu_parent`.
16950    validate_menu_parent(&tenant, menu_id, form.parent_id).await?;
16951    let mut row = crate::navigation::MenuItem {
16952        id: rustango::sql::Auto::Unset,
16953        menu_id,
16954        parent_id: form.parent_id,
16955        sort_order: form.sort_order.unwrap_or(100),
16956        label: form.label.trim().to_owned(),
16957        page_id: form.page_id,
16958        external_url: external,
16959        open_in_new_tab: form.open_in_new_tab.is_some(),
16960    };
16961    row.insert_pool(tenant.pool()).await?;
16962    redirect_named_with_params_and_message(
16963        "rcms-admin:navigation:edit",
16964        &[("id", menu_id.to_string())],
16965        MsgLevel::Success,
16966        "Item added.",
16967        &headers,
16968    )
16969}
16970
16971/// POST /cms-admin/navigation/{menu_id}/items/{id}/delete.
16972pub async fn navigation_item_delete(
16973    State(_state): State<super::AdminState>,
16974    tenant: Tenant,
16975    headers: HeaderMap,
16976    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
16977    Path((menu_id, id)): Path<(i64, i64)>,
16978) -> Result<Response, AdminError> {
16979    let row = crate::navigation::MenuItem::objects()
16980        .where_(crate::navigation::MenuItem::id.eq(id))
16981        .where_(crate::navigation::MenuItem::menu_id.eq(menu_id))
16982        .first(tenant.pool())
16983        .await?
16984        .ok_or(AdminError::NotFound(id))?;
16985    // Re-parent any children to the deleted item's parent so the
16986    // tree doesn't orphan a whole subtree.
16987    let children: Vec<crate::navigation::MenuItem> = crate::navigation::MenuItem::objects()
16988        .where_(crate::navigation::MenuItem::parent_id.eq(Some(id)))
16989        .fetch(tenant.pool())
16990        .await?;
16991    for mut c in children {
16992        c.parent_id = row.parent_id;
16993        c.save_pool(tenant.pool()).await?;
16994    }
16995    row.delete_pool(tenant.pool()).await?;
16996    redirect_named_with_params_and_message(
16997        "rcms-admin:navigation:edit",
16998        &[("id", menu_id.to_string())],
16999        MsgLevel::Success,
17000        "Item deleted.",
17001        &headers,
17002    )
17003}
17004
17005// =====================================================================
17006// Page types — usage dashboard (#16)
17007// =====================================================================
17008
17009/// GET /cms-admin/page-types — registry of every page type the host
17010/// has compiled in, with how many pages of each currently exist + the
17011/// most-recent one. Useful before deprecating a type or refactoring
17012/// its declared fields.
17013pub async fn page_types_dashboard(
17014    State(state): State<super::AdminState>,
17015    tenant: Tenant,
17016    headers: HeaderMap,
17017    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17018) -> Result<Response, AdminError> {
17019    // Pull every Page row once and bucket by `page_type_id` in Rust;
17020    // sites have N pages but only a handful of types, so one fetch +
17021    // a HashMap aggregate beats a per-type COUNT round-trip.
17022    let pages: Vec<Page> = Page::objects().fetch(tenant.pool()).await?;
17023    let page_types: Vec<PageType> = PageType::objects().fetch(tenant.pool()).await?;
17024
17025    let mut counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17026    let mut latest: std::collections::HashMap<i64, chrono::DateTime<chrono::Utc>> =
17027        std::collections::HashMap::new();
17028    for p in &pages {
17029        *counts.entry(p.page_type_id).or_insert(0) += 1;
17030        if let Some(when) = p.published_at.or_else(|| p.created_at.get().copied()) {
17031            latest
17032                .entry(p.page_type_id)
17033                .and_modify(|cur| {
17034                    if when > *cur {
17035                        *cur = when;
17036                    }
17037                })
17038                .or_insert(when);
17039        }
17040    }
17041
17042    let type_id_by_name: std::collections::HashMap<&str, i64> = page_types
17043        .iter()
17044        .filter_map(|t| t.id.get().copied().map(|id| (t.type_name.as_str(), id)))
17045        .collect();
17046
17047    // Cross-reference the in-process handler registry with the DB
17048    // `cms_page_type` rows so unregistered + un-seeded types both
17049    // surface (handler-only = "compiled in but never used"; row-only
17050    // = "DB drift from an old build").
17051    let mut handler_names = std::collections::BTreeSet::new();
17052    let mut rows: Vec<serde_json::Value> = Vec::new();
17053    for handler in crate::page_type::registered_handlers() {
17054        let name = handler.type_name().to_owned();
17055        handler_names.insert(name.clone());
17056        let row_id = type_id_by_name.get(name.as_str()).copied();
17057        let count = row_id.and_then(|id| counts.get(&id).copied()).unwrap_or(0);
17058        let last = row_id.and_then(|id| latest.get(&id).copied());
17059        rows.push(serde_json::json!({
17060            "type_name": name,
17061            "verbose_name": handler.verbose_name(),
17062            "app_label": handler.app_label(),
17063            "icon": handler.icon(),
17064            "description": handler.description(),
17065            "default_template": handler.default_template(),
17066            "feed_kind": handler.feed_kind(),
17067            "allowed_parents": handler.allowed_parent_types(),
17068            "allowed_children": handler.allowed_child_types(),
17069            "is_creatable": handler.is_creatable(),
17070            "count": count,
17071            "latest": last,
17072            "registered": true,
17073            "row_id": row_id,
17074        }));
17075    }
17076
17077    // DB-only types — appear in `cms_page_type` but no handler is
17078    // compiled in. Two flavours: UI-created types (#566,
17079    // `app_label = "cms_ui"`, first-class — creatable + deletable) and
17080    // build drift (a stale row from an old binary — surfaced so editors
17081    // notice). Only UI types get a delete affordance, and only while no
17082    // pages use them; code types are never deletable from the UI.
17083    for t in &page_types {
17084        if !handler_names.contains(&t.type_name) {
17085            let id = t.id.get().copied().unwrap_or_default();
17086            let count = counts.get(&id).copied().unwrap_or(0);
17087            let ui_type = t.app_label == "cms_ui";
17088            rows.push(serde_json::json!({
17089                "type_name": t.type_name,
17090                "verbose_name": t.verbose_name,
17091                "app_label": t.app_label,
17092                "icon": if ui_type { serde_json::Value::String("dashboard_customize".to_owned()) } else { serde_json::Value::Null },
17093                "description": serde_json::Value::Null,
17094                "default_template": t.default_template,
17095                "feed_kind": serde_json::Value::Null,
17096                "allowed_parents": t.allowed_parent_types.clone(),
17097                "allowed_children": t.allowed_child_types.clone(),
17098                "is_creatable": ui_type && t.is_creatable,
17099                "count": count,
17100                "latest": latest.get(&id).copied(),
17101                "registered": false,
17102                "row_id": id,
17103                "ui_type": ui_type,
17104                "deletable": ui_type && count == 0,
17105            }));
17106        }
17107    }
17108    // Sort: most-used first; ties break by verbose_name.
17109    rows.sort_by(|a, b| {
17110        let ac = a.get("count").and_then(|v| v.as_i64()).unwrap_or(0);
17111        let bc = b.get("count").and_then(|v| v.as_i64()).unwrap_or(0);
17112        bc.cmp(&ac).then_with(|| {
17113            a.get("verbose_name")
17114                .and_then(|v| v.as_str())
17115                .unwrap_or("")
17116                .cmp(b.get("verbose_name").and_then(|v| v.as_str()).unwrap_or(""))
17117        })
17118    });
17119
17120    let mut ctx = Context::new();
17121    add_chrome(&mut ctx, &tenant, "page-types", session_user.as_ref()).await;
17122    add_admin_theme(&mut ctx, tenant.pool()).await;
17123    ctx.insert("rows", &rows);
17124    ctx.insert("total_pages", &pages.len());
17125    ctx.insert("total_types", &rows.len());
17126    // #566 — the New-page-type affordance is Developer-gated (same
17127    // codename as the field builder). The template also checks the flag.
17128    let can_build = session_user.as_ref().is_some_and(|u| u.is_superuser)
17129        || crate::permissions::user_codenames(
17130            tenant.pool(),
17131            session_user
17132                .as_ref()
17133                .and_then(|u| u.id.get().copied())
17134                .unwrap_or_default(),
17135        )
17136        .await
17137        .unwrap_or_default()
17138        .contains("cms_page_type.build");
17139    ctx.insert("can_build_types", &can_build);
17140    ctx.insert("new_type_url", "/cms-admin/page-types/new");
17141    render_with_csrf(&state, &headers, "rcms_admin/page_types.html", &mut ctx)
17142}
17143
17144// =====================================================================
17145// Users / Roles — native CMS surface (#9). Replaces the prior
17146// `Redirect::to("/admin/rustango_users")` stub.
17147// =====================================================================
17148
17149/// User management is a **superuser-only** operation.
17150///
17151/// The create/edit handlers set `is_superuser`, `active`, and role
17152/// memberships straight from the submitted form, and the handlers
17153/// themselves previously performed no authorization at all — so any user
17154/// whose request reached the admin router could mint a superuser or
17155/// assign themselves a privileged role. Because *every* one of those
17156/// fields is a privilege the caller might not hold, the safe invariant
17157/// is to restrict the whole user-management surface to superusers rather
17158/// than try to police individual field grants. (Delegated, codename-
17159/// scoped user management that forbids privilege escalation can be added
17160/// later as a deliberate feature.)
17161///
17162/// The same gate covers roles and SSO providers, which decide who
17163/// a user *is* as much as the user rows do: a role editor could grant its
17164/// own role every codename, and an SSO-provider editor could point an
17165/// issuer at an IdP it controls and sign in as any user by email.
17166///
17167/// Returns `Some(redirect)` when denied — anonymous → login, an
17168/// authenticated non-superuser → the no-access page — and `None` when
17169/// the caller is a superuser and may proceed.
17170fn require_superuser_for_user_admin(
17171    user: Option<&rustango::tenancy::auth::User>,
17172) -> Option<Response> {
17173    use axum::response::{IntoResponse, Redirect};
17174    user_admin_denial_target(user.map(|u| u.is_superuser))
17175        .map(|path| Redirect::to(path).into_response())
17176}
17177
17178/// The redirect target for a user-management request, or `None` when the
17179/// caller (identified only by their superuser status: `None` = anonymous,
17180/// `Some(false)` = signed-in non-superuser, `Some(true)` = superuser) may
17181/// proceed. Split out from [`require_superuser_for_user_admin`] so the
17182/// deny/allow decision is unit-testable without constructing a framework
17183/// `User` (which has no `Default`).
17184fn user_admin_denial_target(is_superuser: Option<bool>) -> Option<&'static str> {
17185    match is_superuser {
17186        Some(true) => None,
17187        Some(false) => Some("/cms-admin/no-access"),
17188        None => Some("/login"),
17189    }
17190}
17191
17192/// GET /cms-admin/users — every tenant user with their assigned
17193/// roles + a delta-since indicator on the last password rotation.
17194pub async fn users_list(
17195    State(state): State<super::AdminState>,
17196    tenant: Tenant,
17197    headers: HeaderMap,
17198    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17199) -> Result<Response, AdminError> {
17200    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17201        return Ok(redirect);
17202    }
17203    let users: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
17204        .order_by(&[("username", false)])
17205        .fetch(tenant.pool())
17206        .await?;
17207    let roles: Vec<rustango::tenancy::permissions::Role> =
17208        rustango::tenancy::permissions::Role::objects()
17209            .fetch(tenant.pool())
17210            .await?;
17211    let user_roles: Vec<rustango::tenancy::permissions::UserRole> =
17212        rustango::tenancy::permissions::UserRole::objects()
17213            .fetch(tenant.pool())
17214            .await?;
17215
17216    let roles_by_id: std::collections::HashMap<i64, &rustango::tenancy::permissions::Role> = roles
17217        .iter()
17218        .filter_map(|r| r.id.get().copied().map(|id| (id, r)))
17219        .collect();
17220    let mut roles_by_user: std::collections::HashMap<i64, Vec<String>> =
17221        std::collections::HashMap::new();
17222    for ur in &user_roles {
17223        if let Some(role) = roles_by_id.get(&ur.role_id) {
17224            roles_by_user
17225                .entry(ur.user_id)
17226                .or_default()
17227                .push(role.name.clone());
17228        }
17229    }
17230
17231    let rows: Vec<serde_json::Value> = users
17232        .iter()
17233        .map(|u| {
17234            let id = u.id.get().copied();
17235            serde_json::json!({
17236                "id": id,
17237                "username": u.username,
17238                "email": user_email(u),
17239                "is_superuser": u.is_superuser,
17240                "active": u.active,
17241                "created_at": u.created_at,
17242                "password_changed_at": u.password_changed_at,
17243                "roles": id.and_then(|i| roles_by_user.get(&i).cloned()).unwrap_or_default(),
17244            })
17245        })
17246        .collect();
17247
17248    let mut ctx = Context::new();
17249    add_chrome(&mut ctx, &tenant, "users", session_user.as_ref()).await;
17250    add_admin_theme(&mut ctx, tenant.pool()).await;
17251    ctx.insert("users", &rows);
17252    ctx.insert("total_users", &users.len());
17253    ctx.insert("active_users", &users.iter().filter(|u| u.active).count());
17254    render_with_csrf(&state, &headers, "rcms_admin/users_list.html", &mut ctx)
17255}
17256
17257/// GET /cms-admin/roles — list every role with its permission count
17258/// and member count.
17259pub async fn roles_list(
17260    State(state): State<super::AdminState>,
17261    tenant: Tenant,
17262    headers: HeaderMap,
17263    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17264) -> Result<Response, AdminError> {
17265    // Identity administration is superuser-only (#672).
17266    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17267        return Ok(redirect);
17268    }
17269    let roles: Vec<rustango::tenancy::permissions::Role> =
17270        rustango::tenancy::permissions::Role::objects()
17271            .order_by(&[("name", false)])
17272            .fetch(tenant.pool())
17273            .await?;
17274    let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17275        rustango::tenancy::permissions::RolePermission::objects()
17276            .fetch(tenant.pool())
17277            .await?;
17278    let user_roles: Vec<rustango::tenancy::permissions::UserRole> =
17279        rustango::tenancy::permissions::UserRole::objects()
17280            .fetch(tenant.pool())
17281            .await?;
17282
17283    let mut perm_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17284    for p in &perms {
17285        *perm_counts.entry(p.role_id).or_insert(0) += 1;
17286    }
17287    let mut member_counts: std::collections::HashMap<i64, i64> = std::collections::HashMap::new();
17288    for ur in &user_roles {
17289        *member_counts.entry(ur.role_id).or_insert(0) += 1;
17290    }
17291
17292    let rows: Vec<serde_json::Value> = roles
17293        .iter()
17294        .map(|r| {
17295            let id = r.id.get().copied().unwrap_or_default();
17296            serde_json::json!({
17297                "id": id,
17298                "name": r.name,
17299                "description": r.description,
17300                "perm_count": perm_counts.get(&id).copied().unwrap_or(0),
17301                "member_count": member_counts.get(&id).copied().unwrap_or(0),
17302            })
17303        })
17304        .collect();
17305    let mut ctx = Context::new();
17306    add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17307    add_admin_theme(&mut ctx, tenant.pool()).await;
17308    ctx.insert("roles", &rows);
17309    render_with_csrf(&state, &headers, "rcms_admin/roles_list.html", &mut ctx)
17310}
17311
17312/// GET `/cms-admin/permissions` — tenant-wide permission
17313/// overview matrix. The role editor matrix shows one role at a time;
17314/// this is the read-only birds-eye: every resource (grouped by section)
17315/// × every role, each cell listing the granted actions. Answers "who
17316/// can publish pages?" / "what can this role touch?" at a glance.
17317pub async fn permissions_overview(
17318    State(state): State<super::AdminState>,
17319    tenant: Tenant,
17320    headers: HeaderMap,
17321    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17322) -> Result<Response, AdminError> {
17323    let roles: Vec<rustango::tenancy::permissions::Role> =
17324        rustango::tenancy::permissions::Role::objects()
17325            .order_by(&[("name", false)])
17326            .fetch(tenant.pool())
17327            .await?;
17328    let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17329        rustango::tenancy::permissions::RolePermission::objects()
17330            .fetch(tenant.pool())
17331            .await?;
17332    let granted: std::collections::HashSet<(i64, String)> = perms
17333        .iter()
17334        .map(|p| (p.role_id, p.codename.clone()))
17335        .collect();
17336
17337    let role_headers: Vec<serde_json::Value> = roles
17338        .iter()
17339        .map(|r| {
17340            serde_json::json!({
17341                "id": r.id.get().copied().unwrap_or_default(),
17342                "name": r.name,
17343            })
17344        })
17345        .collect();
17346
17347    // sections → resource rows → one cell per role (granted action codes).
17348    let sections: Vec<serde_json::Value> = super::resources::grouped()
17349        .into_iter()
17350        .map(|(section, resources)| {
17351            let rows: Vec<serde_json::Value> = resources
17352                .iter()
17353                .map(|res| {
17354                    let cells: Vec<serde_json::Value> = roles
17355                        .iter()
17356                        .map(|r| {
17357                            let rid = r.id.get().copied().unwrap_or_default();
17358                            let actions = super::resources::granted_actions(res, rid, &granted);
17359                            serde_json::json!({
17360                                "actions": actions,
17361                                "any": !actions.is_empty(),
17362                            })
17363                        })
17364                        .collect();
17365                    serde_json::json!({
17366                        "label": res.label,
17367                        "key": res.key,
17368                        "cells": cells,
17369                    })
17370                })
17371                .collect();
17372            serde_json::json!({
17373                "label": section.label(),
17374                "rows": rows,
17375            })
17376        })
17377        .collect();
17378
17379    let mut ctx = Context::new();
17380    add_chrome(&mut ctx, &tenant, "permissions", session_user.as_ref()).await;
17381    add_admin_theme(&mut ctx, tenant.pool()).await;
17382    ctx.insert("roles", &role_headers);
17383    ctx.insert("sections", &sections);
17384    ctx.insert("role_count", &role_headers.len());
17385    render_with_csrf(
17386        &state,
17387        &headers,
17388        "rcms_admin/permissions_overview.html",
17389        &mut ctx,
17390    )
17391}
17392
17393/// GET /cms-admin/roles/new — create form.
17394pub async fn roles_new_form(
17395    State(state): State<super::AdminState>,
17396    tenant: Tenant,
17397    headers: HeaderMap,
17398    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17399) -> Result<Response, AdminError> {
17400    // Identity administration is superuser-only (#672).
17401    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17402        return Ok(redirect);
17403    }
17404    let mut ctx = Context::new();
17405    add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17406    add_admin_theme(&mut ctx, tenant.pool()).await;
17407    ctx.insert("mode", "new");
17408    ctx.insert(
17409        "role",
17410        &serde_json::json!({ "id": serde_json::Value::Null, "name": "", "description": "", "permissions": [] }),
17411    );
17412    ctx.insert("matrix", &build_permission_matrix(&[]));
17413    ctx.insert("legacy_codenames", &Vec::<String>::new());
17414    render_with_csrf(&state, &headers, "rcms_admin/role_form.html", &mut ctx)
17415}
17416
17417/// GET /cms-admin/roles/{id}/edit — edit form with permission
17418/// codenames pre-populated.
17419pub async fn roles_edit_form(
17420    State(state): State<super::AdminState>,
17421    tenant: Tenant,
17422    headers: HeaderMap,
17423    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17424    Path(id): Path<i64>,
17425) -> Result<Response, AdminError> {
17426    // Identity administration is superuser-only (#672).
17427    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17428        return Ok(redirect);
17429    }
17430    let role = rustango::tenancy::permissions::Role::objects()
17431        .where_(rustango::tenancy::permissions::Role::id.eq(id))
17432        .first(tenant.pool())
17433        .await?
17434        .ok_or(AdminError::NotFound(id))?;
17435    let perms: Vec<rustango::tenancy::permissions::RolePermission> =
17436        rustango::tenancy::permissions::RolePermission::objects()
17437            .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17438            .order_by(&[("codename", false)])
17439            .fetch(tenant.pool())
17440            .await?;
17441    let codenames: Vec<String> = perms.iter().map(|p| p.codename.clone()).collect();
17442    let (_matched, legacy) = split_matrix_codenames(&codenames);
17443    let mut ctx = Context::new();
17444    add_chrome(&mut ctx, &tenant, "roles", session_user.as_ref()).await;
17445    add_admin_theme(&mut ctx, tenant.pool()).await;
17446    ctx.insert("mode", "edit");
17447    ctx.insert(
17448        "role",
17449        &serde_json::json!({
17450            "id": role.id.get().copied(),
17451            "name": role.name,
17452            "description": role.description,
17453            "permissions": codenames,
17454        }),
17455    );
17456    ctx.insert("matrix", &build_permission_matrix(&codenames));
17457    ctx.insert("legacy_codenames", &legacy);
17458    render_with_csrf(&state, &headers, "rcms_admin/role_form.html", &mut ctx)
17459}
17460
17461/// Build the matrix structure consumed by `role_form.html`.
17462/// Returns one JSON object per [`super::resources::ResourceSection`]
17463/// with its rows pre-populated against the granted codename set so
17464/// the template can render checkboxes pre-checked.
17465///
17466/// The matrix is keyed by *resource key* (e.g. `pages`,
17467/// `library_item:author`) rather than codename so the same template
17468/// works regardless of which library types / custom admin pages a
17469/// downstream crate registers.
17470fn build_permission_matrix(granted: &[String]) -> serde_json::Value {
17471    use super::resources::{codename, grouped};
17472    use crate::permissions::Action;
17473
17474    let granted_set: std::collections::HashSet<&str> = granted.iter().map(String::as_str).collect();
17475
17476    let mut sections = Vec::new();
17477    for (section, rows) in grouped() {
17478        let rows_json: Vec<serde_json::Value> = rows
17479            .iter()
17480            .map(|r| {
17481                let applicable: Vec<&str> = r.actions.iter().map(|a| a.as_str()).collect();
17482                let granted_actions: Vec<&str> = [
17483                    Action::Access,
17484                    Action::AccessAdmin,
17485                    Action::View,
17486                    Action::Add,
17487                    Action::Edit,
17488                    Action::Publish,
17489                    Action::Delete,
17490                ]
17491                .iter()
17492                .copied()
17493                .filter(|action| {
17494                    r.actions.contains(action)
17495                        && granted_set.contains(codename(r, *action).as_str())
17496                })
17497                .map(|a| a.as_str())
17498                .collect();
17499                serde_json::json!({
17500                    "key": r.key,
17501                    "label": r.label,
17502                    "applicable": applicable,
17503                    "granted": granted_actions,
17504                })
17505            })
17506            .collect();
17507        sections.push(serde_json::json!({
17508            "section_label": section.label(),
17509            "rows": rows_json,
17510        }));
17511    }
17512    serde_json::Value::Array(sections)
17513}
17514
17515/// Split the supplied codename list into:
17516/// 1. The codenames represented in the matrix (`matched`) — these
17517///    get fully re-computed from the form submission.
17518/// 2. Everything else (`legacy`) — preserved across saves so
17519///    out-of-matrix grants (third-party codenames, ad-hoc strings
17520///    from before the matrix existed) survive a role edit.
17521fn split_matrix_codenames(granted: &[String]) -> (Vec<String>, Vec<String>) {
17522    use super::resources::{all_resources, codename};
17523    use crate::permissions::Action;
17524
17525    let known: std::collections::HashSet<String> = all_resources()
17526        .iter()
17527        .flat_map(|r| {
17528            r.actions
17529                .iter()
17530                .copied()
17531                .filter(|a| {
17532                    // Mirror the matrix — only actions in `r.actions`
17533                    // can be toggled, so only those codenames are
17534                    // "matrix-owned".
17535                    matches!(
17536                        a,
17537                        Action::View
17538                            | Action::Add
17539                            | Action::Edit
17540                            | Action::Publish
17541                            | Action::Delete
17542                            | Action::Access
17543                            | Action::AccessAdmin
17544                    )
17545                })
17546                .map(|a| codename(r, a))
17547                .collect::<Vec<_>>()
17548        })
17549        .collect();
17550    let (matched, legacy): (Vec<String>, Vec<String>) =
17551        granted.iter().cloned().partition(|c| known.contains(c));
17552    (matched, legacy)
17553}
17554
17555/// Parse the matrix POST shape (`perm[<key>][<action>]=1`) into a
17556/// codename list. Unknown keys / actions are silently dropped — the
17557/// matrix is authoritative for the resources it represents.
17558fn parse_matrix_form(form: &std::collections::HashMap<String, String>) -> Vec<String> {
17559    use super::resources::{all_resources, codename};
17560    use crate::permissions::Action;
17561
17562    let resources = all_resources();
17563    let resource_by_key: std::collections::HashMap<&str, &super::resources::AdminResource> =
17564        resources.iter().map(|r| (r.key.as_str(), r)).collect();
17565
17566    let mut out = Vec::new();
17567    for (raw_key, value) in form {
17568        // Form serializes `name="perm[<key>][<action>]"`. The bracket
17569        // shape stays intact in `serde_urlencoded` because it doesn't
17570        // try to descend nested keys — we parse manually.
17571        let Some(rest) = raw_key.strip_prefix("perm[") else {
17572            continue;
17573        };
17574        let Some((key, rest)) = rest.split_once("][") else {
17575            continue;
17576        };
17577        let Some(action_str) = rest.strip_suffix(']') else {
17578            continue;
17579        };
17580        // Checkbox semantics: present-and-truthy means granted;
17581        // absent means not granted. Browsers always send `1` for
17582        // checked boxes here.
17583        if value.is_empty() || value == "0" || value.eq_ignore_ascii_case("off") {
17584            continue;
17585        }
17586        let Some(resource) = resource_by_key.get(key) else {
17587            continue;
17588        };
17589        let action = match action_str {
17590            "view" => Action::View,
17591            "add" => Action::Add,
17592            "edit" => Action::Edit,
17593            "publish" => Action::Publish,
17594            "delete" => Action::Delete,
17595            "access" => Action::Access,
17596            "access_admin" => Action::AccessAdmin,
17597            _ => continue,
17598        };
17599        if !resource.actions.contains(&action) {
17600            continue;
17601        }
17602        out.push(codename(resource, action));
17603    }
17604    out.sort();
17605    out.dedup();
17606    out
17607}
17608
17609/// Shared helper: replace the codename set for a role with the
17610/// supplied list. Idempotent — added/removed deltas only.
17611async fn sync_role_codenames(
17612    pool: &rustango::sql::Pool,
17613    role_id: i64,
17614    new_codenames: &[String],
17615) -> Result<(), AdminError> {
17616    let existing: Vec<rustango::tenancy::permissions::RolePermission> =
17617        rustango::tenancy::permissions::RolePermission::objects()
17618            .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(role_id))
17619            .fetch(pool)
17620            .await?;
17621    let want: std::collections::BTreeSet<&str> = new_codenames.iter().map(String::as_str).collect();
17622    let have: std::collections::BTreeSet<&str> =
17623        existing.iter().map(|p| p.codename.as_str()).collect();
17624    // Drop the codenames that are no longer wanted.
17625    for p in &existing {
17626        if !want.contains(p.codename.as_str()) {
17627            p.clone().delete_pool(pool).await?;
17628        }
17629    }
17630    // Insert the codenames that aren't already there.
17631    for codename in new_codenames {
17632        if !have.contains(codename.as_str()) {
17633            let mut row = rustango::tenancy::permissions::RolePermission {
17634                id: rustango::sql::Auto::Unset,
17635                role_id,
17636                codename: codename.clone(),
17637            };
17638            row.insert_pool(pool).await?;
17639        }
17640    }
17641    Ok(())
17642}
17643
17644/// POST /cms-admin/roles/new — create a role + sync its codenames.
17645/// Body shape (matrix): `name=`, `description=`, plus one
17646/// `perm[<resource>][<action>]=1` per granted cell.
17647pub async fn roles_create_submit(
17648    State(_state): State<super::AdminState>,
17649    tenant: Tenant,
17650    headers: HeaderMap,
17651    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17652    Form(form): Form<std::collections::HashMap<String, String>>,
17653) -> Result<Response, AdminError> {
17654    // Identity administration is superuser-only (#672).
17655    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17656        return Ok(redirect);
17657    }
17658    let name = form.get("name").map(|s| s.trim()).unwrap_or("").to_owned();
17659    if name.is_empty() {
17660        return Err(AdminError::Validation("Role name is required.".to_owned()));
17661    }
17662    let description = form
17663        .get("description")
17664        .map(|s| s.trim())
17665        .unwrap_or("")
17666        .to_owned();
17667    let mut row = rustango::tenancy::permissions::Role {
17668        id: rustango::sql::Auto::Unset,
17669        name: name.clone(),
17670        description,
17671        data: serde_json::Value::Object(serde_json::Map::new()),
17672    };
17673    row.insert_pool(tenant.pool()).await?;
17674    let role_id = row.id.get().copied().unwrap_or_default();
17675    let codenames = parse_matrix_form(&form);
17676    sync_role_codenames(tenant.pool(), role_id, &codenames).await?;
17677    redirect_named_with_message_args(
17678        "rcms-admin:roles",
17679        MsgLevel::Success,
17680        "Role “{name}” created.",
17681        &[("name", name.as_str())],
17682        &headers,
17683    )
17684}
17685
17686/// POST /cms-admin/roles/{id}/edit — update name/description +
17687/// sync the codename set. Out-of-matrix legacy codenames are
17688/// preserved across saves.
17689pub async fn roles_edit_submit(
17690    State(_state): State<super::AdminState>,
17691    tenant: Tenant,
17692    headers: HeaderMap,
17693    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17694    Path(id): Path<i64>,
17695    Form(form): Form<std::collections::HashMap<String, String>>,
17696) -> Result<Response, AdminError> {
17697    // Identity administration is superuser-only (#672).
17698    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17699        return Ok(redirect);
17700    }
17701    let mut role = rustango::tenancy::permissions::Role::objects()
17702        .where_(rustango::tenancy::permissions::Role::id.eq(id))
17703        .first(tenant.pool())
17704        .await?
17705        .ok_or(AdminError::NotFound(id))?;
17706    let name = form.get("name").map(|s| s.trim()).unwrap_or("").to_owned();
17707    if name.is_empty() {
17708        return Err(AdminError::Validation("Role name is required.".to_owned()));
17709    }
17710    let description = form
17711        .get("description")
17712        .map(|s| s.trim())
17713        .unwrap_or("")
17714        .to_owned();
17715    role.name = name.clone();
17716    role.description = description;
17717    role.save_pool(tenant.pool()).await?;
17718    // Carry over codenames that live outside the matrix surface so
17719    // legacy / third-party codenames aren't silently dropped when
17720    // an admin saves the matrix-only form.
17721    let existing: Vec<rustango::tenancy::permissions::RolePermission> =
17722        rustango::tenancy::permissions::RolePermission::objects()
17723            .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17724            .fetch(tenant.pool())
17725            .await?;
17726    let existing_codenames: Vec<String> = existing.into_iter().map(|p| p.codename).collect();
17727    let (_old_matrix, legacy) = split_matrix_codenames(&existing_codenames);
17728    let mut codenames = parse_matrix_form(&form);
17729    codenames.extend(legacy);
17730    codenames.sort();
17731    codenames.dedup();
17732    sync_role_codenames(tenant.pool(), id, &codenames).await?;
17733    redirect_named_with_message_args(
17734        "rcms-admin:roles",
17735        MsgLevel::Success,
17736        "Role “{name}” saved.",
17737        &[("name", name.as_str())],
17738        &headers,
17739    )
17740}
17741
17742/// POST /cms-admin/roles/{id}/delete — delete the role + its
17743/// codenames + every UserRole row referencing it.
17744pub async fn roles_delete_submit(
17745    State(_state): State<super::AdminState>,
17746    tenant: Tenant,
17747    headers: HeaderMap,
17748    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17749    Path(id): Path<i64>,
17750) -> Result<Response, AdminError> {
17751    // Identity administration is superuser-only (#672).
17752    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17753        return Ok(redirect);
17754    }
17755    let role = rustango::tenancy::permissions::Role::objects()
17756        .where_(rustango::tenancy::permissions::Role::id.eq(id))
17757        .first(tenant.pool())
17758        .await?
17759        .ok_or(AdminError::NotFound(id))?;
17760    let name = role.name.clone();
17761    // Delete dependent rows manually — the schema FK isn't ON DELETE CASCADE.
17762    for p in rustango::tenancy::permissions::RolePermission::objects()
17763        .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(id))
17764        .fetch(tenant.pool())
17765        .await?
17766    {
17767        p.delete_pool(tenant.pool()).await?;
17768    }
17769    for ur in rustango::tenancy::permissions::UserRole::objects()
17770        .where_(rustango::tenancy::permissions::UserRole::role_id.eq(id))
17771        .fetch(tenant.pool())
17772        .await?
17773    {
17774        ur.delete_pool(tenant.pool()).await?;
17775    }
17776    role.delete_pool(tenant.pool()).await?;
17777    redirect_named_with_message_args(
17778        "rcms-admin:roles",
17779        MsgLevel::Success,
17780        "Role “{name}” deleted.",
17781        &[("name", name.as_str())],
17782        &headers,
17783    )
17784}
17785
17786/// GET /cms-admin/users/new — create form.
17787pub async fn users_new_form(
17788    State(state): State<super::AdminState>,
17789    tenant: Tenant,
17790    headers: HeaderMap,
17791    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17792) -> Result<Response, AdminError> {
17793    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17794        return Ok(redirect);
17795    }
17796    let mut ctx = Context::new();
17797    add_chrome(&mut ctx, &tenant, "users", session_user.as_ref()).await;
17798    add_admin_theme(&mut ctx, tenant.pool()).await;
17799    ctx.insert("mode", "new");
17800    ctx.insert(
17801        "user",
17802        &serde_json::json!({
17803            "id": serde_json::Value::Null,
17804            "username": "",
17805            "is_superuser": false,
17806            "active": true,
17807        }),
17808    );
17809    // Roles can be given right away, not only after a second visit.
17810    let role_choices: Vec<serde_json::Value> = rustango::tenancy::permissions::Role::objects()
17811        .order_by(&[("name", false)])
17812        .fetch(tenant.pool())
17813        .await?
17814        .iter()
17815        .map(|r| {
17816            serde_json::json!({
17817                "id": r.id.get().copied().unwrap_or_default(),
17818                "name": r.name,
17819                "description": r.description,
17820                "assigned": false,
17821            })
17822        })
17823        .collect();
17824    ctx.insert("role_choices", &role_choices);
17825    render_with_csrf(&state, &headers, "rcms_admin/user_form.html", &mut ctx)
17826}
17827
17828/// GET /cms-admin/users/{id}/edit — edit form. Password field stays
17829/// empty by default; leave blank to keep the existing password.
17830/// Includes a role-checkbox group so editors can grant / revoke
17831/// role memberships inline.
17832pub async fn users_edit_form(
17833    State(state): State<super::AdminState>,
17834    tenant: Tenant,
17835    headers: HeaderMap,
17836    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
17837    Path(id): Path<i64>,
17838) -> Result<Response, AdminError> {
17839    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
17840        return Ok(redirect);
17841    }
17842    render_user_edit_page(&state, &tenant, &headers, session_user.as_ref(), id, None).await
17843}
17844
17845async fn render_user_edit_page(
17846    state: &super::AdminState,
17847    tenant: &Tenant,
17848    headers: &HeaderMap,
17849    session_user: Option<&rustango::tenancy::auth::User>,
17850    id: i64,
17851    mcp_one_time: Option<serde_json::Value>,
17852) -> Result<Response, AdminError> {
17853    let user = rustango::tenancy::auth::User::objects()
17854        .where_(rustango::tenancy::auth::User::id.eq(id))
17855        .first(tenant.pool())
17856        .await?
17857        .ok_or(AdminError::NotFound(id))?;
17858    let roles: Vec<rustango::tenancy::permissions::Role> =
17859        rustango::tenancy::permissions::Role::objects()
17860            .order_by(&[("name", false)])
17861            .fetch(tenant.pool())
17862            .await?;
17863    let memberships: Vec<rustango::tenancy::permissions::UserRole> =
17864        rustango::tenancy::permissions::UserRole::objects()
17865            .where_(rustango::tenancy::permissions::UserRole::user_id.eq(id))
17866            .fetch(tenant.pool())
17867            .await?;
17868    let assigned: std::collections::BTreeSet<i64> = memberships.iter().map(|m| m.role_id).collect();
17869
17870    let role_choices: Vec<serde_json::Value> = roles
17871        .iter()
17872        .map(|r| {
17873            let rid = r.id.get().copied().unwrap_or_default();
17874            serde_json::json!({
17875                "id": rid,
17876                "name": r.name,
17877                "description": r.description,
17878                "assigned": assigned.contains(&rid),
17879            })
17880        })
17881        .collect();
17882
17883    // #13 V2 — per-user timezone stored in `User.data.timezone`.
17884    // No framework column change required; the existing JSON bag
17885    // holds the IANA name. Empty / missing = browser-detected
17886    // fallback (the no-flash JS already handles that case).
17887    let user_timezone = user
17888        .data
17889        .get("timezone")
17890        .and_then(serde_json::Value::as_str)
17891        .unwrap_or("")
17892        .to_owned();
17893    let user_email = user_email(&user);
17894
17895    let mut ctx = Context::new();
17896    add_chrome(&mut ctx, tenant, "users", session_user).await;
17897    add_admin_theme(&mut ctx, tenant.pool()).await;
17898    ctx.insert("mode", "edit");
17899    ctx.insert(
17900        "user",
17901        &serde_json::json!({
17902            "id": user.id.get().copied(),
17903            "username": user.username,
17904            "email": user_email,
17905            "is_superuser": user.is_superuser,
17906            "active": user.active,
17907            "timezone": user_timezone,
17908            "password_changed_at": user.password_changed_at,
17909            "created_at": user.created_at,
17910        }),
17911    );
17912    ctx.insert("role_choices", &role_choices);
17913    // #587 — the target user's MCP keys, for admin-managed minting
17914    // (the "register an agent user, give it a key" flow).
17915    let (keys, skills) = mcp_keys_ctx(tenant.pool(), id).await;
17916    ctx.insert("mcp_keys", &keys);
17917    ctx.insert("mcp_skills", &skills);
17918    if let Some(one_time) = &mcp_one_time {
17919        ctx.insert("mcp_one_time", one_time);
17920    }
17921    render_with_csrf(state, headers, "rcms_admin/user_form.html", &mut ctx)
17922}
17923
17924// ------------------------------------------------------------- MCP keys (#587)
17925
17926/// Parse a keys-create form: `label` (optional) + repeated `skill`
17927/// entries (optional scope — empty = the owner's full entitlement).
17928fn parse_mcp_key_form(pairs: &[(String, String)]) -> (String, Vec<String>) {
17929    let label = pairs
17930        .iter()
17931        .find(|(k, _)| k == "label")
17932        .map(|(_, v)| v.trim())
17933        .filter(|v| !v.is_empty())
17934        .unwrap_or("MCP key")
17935        .to_owned();
17936    let skills: Vec<String> = pairs
17937        .iter()
17938        .filter(|(k, v)| k == "skill" && !v.trim().is_empty())
17939        .map(|(_, v)| v.trim().to_owned())
17940        .collect();
17941    (label, skills)
17942}
17943
17944/// Best-effort audit trail for key lifecycle events — explicit source
17945/// because the CMS admin doesn't install `audit::with_source`.
17946async fn audit_mcp_key(
17947    pool: &rustango::sql::Pool,
17948    actor_id: i64,
17949    what: &str,
17950    detail: serde_json::Value,
17951) {
17952    let entry = rustango::audit::PendingEntry {
17953        entity_table: "rustango_agents",
17954        entity_pk: detail
17955            .get("key_id")
17956            .and_then(serde_json::Value::as_i64)
17957            .map(|i| i.to_string())
17958            .unwrap_or_default(),
17959        operation: rustango::audit::AuditOp::Action,
17960        source: rustango::audit::AuditSource::User {
17961            id: actor_id.to_string(),
17962        },
17963        changes: serde_json::json!({ "event": what, "detail": detail }),
17964    };
17965    if let Err(e) = rustango::audit::emit_one_pool(pool, &entry).await {
17966        tracing::warn!(error = %e, "mcp key audit emit failed");
17967    }
17968}
17969
17970/// Mint a user key for `owner_id`, mapping scope-validation failures to a
17971/// user-facing message. Returns the show-once payload for the dialog.
17972async fn mint_mcp_key(
17973    pool: &rustango::sql::Pool,
17974    actor_id: i64,
17975    owner_id: i64,
17976    label: &str,
17977    skills: &[String],
17978) -> Result<serde_json::Value, String> {
17979    match rustango::tenancy::create_user_key_pool(pool, owner_id, label, skills).await {
17980        Ok(issued) => {
17981            let key_id = issued.agent.id.get().copied().unwrap_or_default();
17982            audit_mcp_key(
17983                pool,
17984                actor_id,
17985                "created",
17986                serde_json::json!({ "key_id": key_id, "owner_id": owner_id, "label": label, "scope": skills }),
17987            )
17988            .await;
17989            Ok(serde_json::json!({ "token": issued.token, "label": label }))
17990        }
17991        Err(e) => Err(e.to_string()),
17992    }
17993}
17994
17995/// POST /cms-admin/me/mcp-keys — mint a key for the signed-in user.
17996/// Renders the account page directly with the show-once token (no PRG —
17997/// the token must never ride a redirect or a flash cookie).
17998pub async fn account_mcp_key_create(
17999    State(state): State<super::AdminState>,
18000    tenant: Tenant,
18001    headers: HeaderMap,
18002    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18003    Form(pairs): Form<Vec<(String, String)>>,
18004) -> Result<Response, AdminError> {
18005    let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18006        return Ok(unauthorized_no_session());
18007    };
18008    let (label, skills) = parse_mcp_key_form(&pairs);
18009    match mint_mcp_key(tenant.pool(), uid, uid, &label, &skills).await {
18010        Ok(one_time) => {
18011            render_account_page(
18012                &state,
18013                &tenant,
18014                &headers,
18015                session_user.as_ref(),
18016                Some(one_time),
18017            )
18018            .await
18019        }
18020        Err(msg) => redirect_named_with_message_args(
18021            "rcms-admin:account",
18022            MsgLevel::Error,
18023            "Couldn't create the key: {error}",
18024            &[("error", msg.as_str())],
18025            &headers,
18026        ),
18027    }
18028}
18029
18030/// POST /cms-admin/me/mcp-keys/{id}/revoke — revoke one of the signed-in
18031/// user's keys (ownership-verified in the framework call).
18032pub async fn account_mcp_key_revoke(
18033    State(_state): State<super::AdminState>,
18034    tenant: Tenant,
18035    headers: HeaderMap,
18036    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18037    Path(key_id): Path<i64>,
18038) -> Result<Response, AdminError> {
18039    let Some(uid) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18040        return Ok(unauthorized_no_session());
18041    };
18042    match rustango::tenancy::revoke_user_key_pool(tenant.pool(), uid, key_id).await {
18043        Ok(()) => {
18044            audit_mcp_key(
18045                tenant.pool(),
18046                uid,
18047                "revoked",
18048                serde_json::json!({ "key_id": key_id, "owner_id": uid }),
18049            )
18050            .await;
18051            redirect_named_with_message_args(
18052                "rcms-admin:account",
18053                MsgLevel::Success,
18054                "MCP key revoked.",
18055                &[],
18056                &headers,
18057            )
18058        }
18059        Err(e) => {
18060            let msg = e.to_string();
18061            redirect_named_with_message_args(
18062                "rcms-admin:account",
18063                MsgLevel::Error,
18064                "Couldn't revoke the key: {error}",
18065                &[("error", msg.as_str())],
18066                &headers,
18067            )
18068        }
18069    }
18070}
18071
18072/// POST /cms-admin/users/{id}/mcp-keys — an admin mints a key for another
18073/// user (the "register an agent user, give it a key" flow). Safe by
18074/// construction: the key's capabilities are bounded by the TARGET user's
18075/// entitlement at every token resolution, so this can't escalate beyond
18076/// what that user could already do.
18077pub async fn users_mcp_key_create(
18078    State(state): State<super::AdminState>,
18079    tenant: Tenant,
18080    headers: HeaderMap,
18081    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18082    Path(user_id): Path<i64>,
18083    Form(pairs): Form<Vec<(String, String)>>,
18084) -> Result<Response, AdminError> {
18085    // #646 — user-management is superuser-only. Without this the two
18086    // mcp-key handlers gated on "a session exists" only, so a non-superuser
18087    // staff account could mint a key bounded by ANY target user's (e.g. a
18088    // superuser's) entitlement — a privilege escalation the other seven
18089    // user-admin handlers already block. Mirror them.
18090    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18091        return Ok(redirect);
18092    }
18093    let Some(actor_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18094        return Ok(unauthorized_no_session());
18095    };
18096    let (label, skills) = parse_mcp_key_form(&pairs);
18097    match mint_mcp_key(tenant.pool(), actor_id, user_id, &label, &skills).await {
18098        Ok(one_time) => {
18099            render_user_edit_page(
18100                &state,
18101                &tenant,
18102                &headers,
18103                session_user.as_ref(),
18104                user_id,
18105                Some(one_time),
18106            )
18107            .await
18108        }
18109        Err(msg) => redirect_named_with_params_and_message_args(
18110            "rcms-admin:users:edit",
18111            &[("id", user_id.to_string())],
18112            MsgLevel::Error,
18113            "Couldn't create the key: {error}",
18114            &[("error", msg.as_str())],
18115            &headers,
18116        ),
18117    }
18118}
18119
18120/// POST /cms-admin/users/{id}/mcp-keys/{key_id}/revoke — admin revoke of
18121/// another user's key (ownership pinned to the target user).
18122pub async fn users_mcp_key_revoke(
18123    State(_state): State<super::AdminState>,
18124    tenant: Tenant,
18125    headers: HeaderMap,
18126    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18127    Path((user_id, key_id)): Path<(i64, i64)>,
18128) -> Result<Response, AdminError> {
18129    // #646 — user-management is superuser-only. Without this the two
18130    // mcp-key handlers gated on "a session exists" only, so a non-superuser
18131    // staff account could mint a key bounded by ANY target user's (e.g. a
18132    // superuser's) entitlement — a privilege escalation the other seven
18133    // user-admin handlers already block. Mirror them.
18134    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18135        return Ok(redirect);
18136    }
18137    let Some(actor_id) = session_user.as_ref().and_then(|u| u.id.get().copied()) else {
18138        return Ok(unauthorized_no_session());
18139    };
18140    match rustango::tenancy::revoke_user_key_pool(tenant.pool(), user_id, key_id).await {
18141        Ok(()) => {
18142            audit_mcp_key(
18143                tenant.pool(),
18144                actor_id,
18145                "revoked",
18146                serde_json::json!({ "key_id": key_id, "owner_id": user_id }),
18147            )
18148            .await;
18149            redirect_named_with_params_and_message_args(
18150                "rcms-admin:users:edit",
18151                &[("id", user_id.to_string())],
18152                MsgLevel::Success,
18153                "MCP key revoked.",
18154                &[],
18155                &headers,
18156            )
18157        }
18158        Err(e) => {
18159            let msg = e.to_string();
18160            redirect_named_with_params_and_message_args(
18161                "rcms-admin:users:edit",
18162                &[("id", user_id.to_string())],
18163                MsgLevel::Error,
18164                "Couldn't revoke the key: {error}",
18165                &[("error", msg.as_str())],
18166                &headers,
18167            )
18168        }
18169    }
18170}
18171
18172/// Form payload for create + edit. Password is optional on edit
18173/// (empty = "don't change"); required on create (rejected with a
18174/// 400 if missing).
18175#[derive(Deserialize)]
18176pub struct UserForm {
18177    pub username: String,
18178    #[serde(default)]
18179    pub email: Option<String>,
18180    #[serde(default)]
18181    pub password: Option<String>,
18182    #[serde(default)]
18183    pub is_superuser: Option<String>,
18184    #[serde(default)]
18185    pub active: Option<String>,
18186}
18187
18188/// Light email validation (presence of a single `@` with text
18189/// on both sides). Empty is allowed (email is optional). Returns the
18190/// trimmed value to store, or an error message.
18191fn validate_optional_email(raw: Option<&str>) -> Result<String, String> {
18192    let e = raw.map(str::trim).unwrap_or("");
18193    if e.is_empty() {
18194        return Ok(String::new());
18195    }
18196    let ok = e.split('@').count() == 2
18197        && e.split('@').all(|p| !p.is_empty())
18198        && !e.contains(char::is_whitespace);
18199    if ok {
18200        Ok(e.to_owned())
18201    } else {
18202        Err(format!("“{e}” is not a valid email address."))
18203    }
18204}
18205
18206/// POST /cms-admin/users/new — create a new user. Password is
18207/// required; we hash via the framework's argon2id helper.
18208pub async fn users_create_submit(
18209    State(_state): State<super::AdminState>,
18210    tenant: Tenant,
18211    headers: HeaderMap,
18212    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18213    Form(pairs): Form<Vec<(String, String)>>,
18214) -> Result<Response, AdminError> {
18215    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18216        return Ok(redirect);
18217    }
18218    use rustango::sql::Auto;
18219    // Pairs, not the typed struct: the roles are a multi-value field
18220    // (see `users_edit_submit`), granted at creation too.
18221    let single = |k: &str| pairs.iter().find(|(n, _)| n == k).map(|(_, v)| v.clone());
18222    let form = UserForm {
18223        username: single("username").unwrap_or_default(),
18224        email: single("email"),
18225        password: single("password"),
18226        is_superuser: single("is_superuser"),
18227        active: single("active"),
18228    };
18229    let role_ids: Vec<i64> = pairs
18230        .iter()
18231        .filter(|(k, _)| k == "role_id")
18232        .filter_map(|(_, v)| v.parse::<i64>().ok())
18233        .collect();
18234    let username = form.username.trim().to_owned();
18235    let password = form
18236        .password
18237        .as_deref()
18238        .map(str::trim)
18239        .filter(|s| !s.is_empty())
18240        .map(str::to_owned);
18241    if username.is_empty() || password.is_none() {
18242        return Err(AdminError::Validation(
18243            "Username and initial password are both required.".to_owned(),
18244        ));
18245    }
18246    let hash = crate::passwords::hash(password.as_deref().unwrap_or_default()).await
18247        .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
18248    let email = validate_optional_email(form.email.as_deref()).map_err(AdminError::Validation)?;
18249    // The framework's first-class `email` column is the SSO link target (the
18250    // admin-sso login matches the IdP's verified email against it). Set it here;
18251    // NULL when no email was given (that account simply can't sign in via SSO).
18252    let email_col = (!email.is_empty()).then(|| email.clone());
18253
18254    // #435 — also mirror into the User.data bag (legacy readers: users list +
18255    // edit form still read `data.email`).
18256    let mut data = serde_json::Map::new();
18257    if !email.is_empty() {
18258        data.insert("email".to_owned(), serde_json::Value::String(email));
18259    }
18260    let mut row = rustango::tenancy::auth::User {
18261        id: Auto::Unset,
18262        username: username.clone(),
18263        password_hash: hash,
18264        email: email_col,
18265        is_superuser: form.is_superuser.is_some(),
18266        active: form.active.is_some(),
18267        created_at: chrono::Utc::now(),
18268        data: serde_json::Value::Object(data),
18269        password_changed_at: Some(chrono::Utc::now()),
18270        sessions_revoked_at: None,
18271    };
18272    row.insert_pool(tenant.pool()).await?;
18273    if let Some(new_id) = row.id.get().copied() {
18274        sync_user_roles(tenant.pool(), new_id, &role_ids).await?;
18275    }
18276    redirect_named_with_message_args(
18277        "rcms-admin:users",
18278        MsgLevel::Success,
18279        "User “{username}” created.",
18280        &[("username", username.as_str())],
18281        &headers,
18282    )
18283}
18284
18285/// POST /cms-admin/users/{id}/edit — update flags + optionally
18286/// rotate the password (empty password field = no rotation) +
18287/// sync role memberships. Body parsed as `Vec<(String, String)>`
18288/// instead of the typed struct because role_id is a multi-value
18289/// form field — checkbox groups in HTML submit one entry per
18290/// checked box, and serde_urlencoded folds duplicates onto the
18291/// last write.
18292pub async fn users_edit_submit(
18293    State(_state): State<super::AdminState>,
18294    tenant: Tenant,
18295    headers: HeaderMap,
18296    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18297    Path(id): Path<i64>,
18298    Form(form): Form<Vec<(String, String)>>,
18299) -> Result<Response, AdminError> {
18300    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18301        return Ok(redirect);
18302    }
18303    // Pull each field out of the multi-pair vec. `find` honors the
18304    // first occurrence — fine for single-value fields.
18305    let single = |key: &str| -> Option<String> {
18306        form.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
18307    };
18308    let username_raw = single("username").unwrap_or_default();
18309    let username = username_raw.trim().to_owned();
18310    if username.is_empty() {
18311        return Err(AdminError::Validation(
18312            "Username cannot be empty.".to_owned(),
18313        ));
18314    }
18315    let password = single("password");
18316    let is_superuser = form.iter().any(|(k, _)| k == "is_superuser");
18317    let active = form.iter().any(|(k, _)| k == "active");
18318    let timezone_raw = single("timezone").unwrap_or_default();
18319    let timezone = timezone_raw.trim().to_owned();
18320    // #435 — optional email, validated + stored in User.data.
18321    let email =
18322        validate_optional_email(single("email").as_deref()).map_err(AdminError::Validation)?;
18323    let role_ids: Vec<i64> = form
18324        .iter()
18325        .filter(|(k, _)| k == "role_id")
18326        .filter_map(|(_, v)| v.parse::<i64>().ok())
18327        .collect();
18328
18329    let mut user = rustango::tenancy::auth::User::objects()
18330        .where_(rustango::tenancy::auth::User::id.eq(id))
18331        .first(tenant.pool())
18332        .await?
18333        .ok_or(AdminError::NotFound(id))?;
18334    user.username = username.clone();
18335    user.is_superuser = is_superuser;
18336    user.active = active;
18337    // #13 V2 — persist the chosen IANA timezone (or unset key
18338    // entirely when blank) on the User.data JSON bag.
18339    {
18340        let map = user.data.as_object_mut().ok_or_else(|| {
18341            AdminError::Validation(
18342                "User.data is not a JSON object — refusing to overwrite.".to_owned(),
18343            )
18344        })?;
18345        if timezone.is_empty() {
18346            map.remove("timezone");
18347        } else {
18348            map.insert(
18349                "timezone".to_owned(),
18350                serde_json::Value::String(timezone.clone()),
18351            );
18352        }
18353        if email.is_empty() {
18354            map.remove("email");
18355        } else {
18356            map.insert("email".to_owned(), serde_json::Value::String(email.clone()));
18357        }
18358    }
18359    // Keep the first-class `email` column (the admin-sso link target) in sync
18360    // with the edited address — NULL clears the SSO link for this user.
18361    user.email = (!email.is_empty()).then(|| email.clone());
18362
18363    let rotated = password.as_deref().map(str::trim).filter(|s| !s.is_empty());
18364    if let Some(new_pw) = rotated {
18365        let hash = crate::passwords::hash(new_pw).await
18366            .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
18367        user.password_hash = hash;
18368        user.password_changed_at = Some(chrono::Utc::now());
18369    }
18370    user.save_pool(tenant.pool()).await?;
18371    sync_user_roles(tenant.pool(), id, &role_ids).await?;
18372    if rotated.is_some() {
18373        redirect_named_with_message_args(
18374            "rcms-admin:users",
18375            MsgLevel::Success,
18376            "User “{username}” saved (password rotated).",
18377            &[("username", username.as_str())],
18378            &headers,
18379        )
18380    } else {
18381        redirect_named_with_message_args(
18382            "rcms-admin:users",
18383            MsgLevel::Success,
18384            "User “{username}” saved.",
18385            &[("username", username.as_str())],
18386            &headers,
18387        )
18388    }
18389}
18390
18391/// Shared helper — replace a user's role-membership set with the
18392/// supplied list. Idempotent; computes adds + drops via set diff.
18393async fn sync_user_roles(
18394    pool: &rustango::sql::Pool,
18395    user_id: i64,
18396    new_role_ids: &[i64],
18397) -> Result<(), AdminError> {
18398    let existing: Vec<rustango::tenancy::permissions::UserRole> =
18399        rustango::tenancy::permissions::UserRole::objects()
18400            .where_(rustango::tenancy::permissions::UserRole::user_id.eq(user_id))
18401            .fetch(pool)
18402            .await?;
18403    let want: std::collections::BTreeSet<i64> = new_role_ids.iter().copied().collect();
18404    let have: std::collections::BTreeSet<i64> = existing.iter().map(|m| m.role_id).collect();
18405    for m in &existing {
18406        if !want.contains(&m.role_id) {
18407            m.clone().delete_pool(pool).await?;
18408        }
18409    }
18410    for role_id in new_role_ids {
18411        if !have.contains(role_id) {
18412            let mut row = rustango::tenancy::permissions::UserRole {
18413                id: rustango::sql::Auto::Unset,
18414                user_id,
18415                role_id: *role_id,
18416            };
18417            row.insert_pool(pool).await?;
18418        }
18419    }
18420    Ok(())
18421}
18422
18423/// POST /cms-admin/users/{id}/deactivate — flip the `active` bit
18424/// off. Idempotent. Reversed via the edit form's checkbox.
18425pub async fn users_deactivate_submit(
18426    State(_state): State<super::AdminState>,
18427    tenant: Tenant,
18428    headers: HeaderMap,
18429    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18430    Path(id): Path<i64>,
18431) -> Result<Response, AdminError> {
18432    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18433        return Ok(redirect);
18434    }
18435    let mut user = rustango::tenancy::auth::User::objects()
18436        .where_(rustango::tenancy::auth::User::id.eq(id))
18437        .first(tenant.pool())
18438        .await?
18439        .ok_or(AdminError::NotFound(id))?;
18440    user.active = false;
18441    user.save_pool(tenant.pool()).await?;
18442    redirect_named_with_message_args(
18443        "rcms-admin:users",
18444        MsgLevel::Success,
18445        "User “{username}” deactivated.",
18446        &[("username", user.username.as_str())],
18447        &headers,
18448    )
18449}
18450
18451/// POST /cms-admin/users/bulk — enable or disable the selected users
18452/// (bulk actions). `user_id` repeats once per checked row;
18453/// `action` is the clicked button (`enable` | `disable`). Disabling
18454/// your own account is skipped so an admin can't lock themselves out.
18455pub async fn users_bulk_submit(
18456    State(_state): State<super::AdminState>,
18457    tenant: Tenant,
18458    headers: HeaderMap,
18459    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18460    Form(pairs): Form<Vec<(String, String)>>,
18461) -> Result<Response, AdminError> {
18462    if let Some(redirect) = require_superuser_for_user_admin(session_user.as_ref()) {
18463        return Ok(redirect);
18464    }
18465    let mut ids: Vec<i64> = Vec::new();
18466    let mut action = String::new();
18467    for (k, v) in &pairs {
18468        match k.as_str() {
18469            "user_id" => {
18470                if let Ok(id) = v.parse::<i64>() {
18471                    ids.push(id);
18472                }
18473            }
18474            "action" => action = v.clone(),
18475            _ => {}
18476        }
18477    }
18478    let target_active = match action.as_str() {
18479        "enable" => true,
18480        "disable" => false,
18481        _ => {
18482            return redirect_named_with_message(
18483                "rcms-admin:users",
18484                MsgLevel::Error,
18485                "Unknown bulk action.",
18486                &headers,
18487            );
18488        }
18489    };
18490    if ids.is_empty() {
18491        return redirect_named_with_message(
18492            "rcms-admin:users",
18493            MsgLevel::Info,
18494            "No users selected.",
18495            &headers,
18496        );
18497    }
18498    let me = session_user.as_ref().and_then(|u| u.id.get().copied());
18499    let mut changed = 0usize;
18500    let mut skipped_self = false;
18501    for id in ids {
18502        // Never disable the acting admin — that's a self-lockout.
18503        if !target_active && Some(id) == me {
18504            skipped_self = true;
18505            continue;
18506        }
18507        if let Some(mut user) = rustango::tenancy::auth::User::objects()
18508            .where_(rustango::tenancy::auth::User::id.eq(id))
18509            .first(tenant.pool())
18510            .await?
18511        {
18512            if user.active != target_active {
18513                user.active = target_active;
18514                user.save_pool(tenant.pool()).await?;
18515                changed += 1;
18516            }
18517        }
18518    }
18519    let verb = if target_active { "Enabled" } else { "Disabled" };
18520    let mut msg = format!("{verb} {changed} user(s).");
18521    if skipped_self {
18522        msg.push_str(" (Skipped your own account.)");
18523    }
18524    redirect_named_with_message("rcms-admin:users", MsgLevel::Success, &msg, &headers)
18525}
18526
18527// =====================================================================
18528// Settings tab
18529// =====================================================================
18530
18531pub async fn settings_page(
18532    State(state): State<super::AdminState>,
18533    tenant: Tenant,
18534    headers: HeaderMap,
18535    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18536) -> Result<Response, AdminError> {
18537    let locales: Vec<Locale> = Locale::objects()
18538        .order_by(&[("sort_order", false), ("code", false)])
18539        .fetch(tenant.pool())
18540        .await?;
18541    let media_count: Vec<Media> = Media::objects().fetch(tenant.pool()).await?;
18542    // #58 — themes available to the picker. We surface every row in
18543    // `cms_theme` plus its 4 marquee colors for a swatch preview.
18544    let themes: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
18545        .order_by(&[("name", false)])
18546        .fetch(tenant.pool())
18547        .await?;
18548    let theme_rows: Vec<serde_json::Value> = themes
18549        .iter()
18550        .map(|t| {
18551            serde_json::json!({
18552                "id": t.id.get().copied(),
18553                "name": t.name,
18554                "slug": t.slug,
18555                "is_admin_default": t.is_admin_default,
18556                "is_default": t.is_default,
18557                "color_bg": t.color_bg,
18558                "color_surface": t.color_surface,
18559                "color_text_primary": t.color_text_primary,
18560                "color_link": t.color_link,
18561            })
18562        })
18563        .collect();
18564    let mut ctx = Context::new();
18565    add_chrome(&mut ctx, &tenant, "settings", session_user.as_ref()).await;
18566    add_admin_theme(&mut ctx, tenant.pool()).await;
18567    ctx.insert("locales", &locales);
18568    ctx.insert("media_count", &media_count.len());
18569    ctx.insert("org_slug", &tenant.org.slug);
18570    ctx.insert("org_display_name", &tenant.org.display_name);
18571    ctx.insert("themes", &theme_rows);
18572
18573    // #199 — surface the current branding asset filenames + URLs
18574    // so the Branding form can render "Current logo: <filename>"
18575    // hints next to the upload inputs.
18576    if let Ok(Some(row)) = crate::site_setting::get(tenant.pool(), "branding").await {
18577        let logo_key = row
18578            .value_json
18579            .get("logo_storage_key")
18580            .and_then(|v| v.as_str())
18581            .unwrap_or("")
18582            .to_owned();
18583        let favicon_key = row
18584            .value_json
18585            .get("favicon_storage_key")
18586            .and_then(|v| v.as_str())
18587            .unwrap_or("")
18588            .to_owned();
18589        ctx.insert("branding_logo_filename", &logo_key);
18590        ctx.insert("branding_favicon_filename", &favicon_key);
18591        ctx.insert(
18592            "branding_site_name",
18593            row.value_json.get("site_name").and_then(|v| v.as_str()).unwrap_or(""),
18594        );
18595    }
18596
18597    render_with_csrf(&state, &headers, "rcms_admin/settings.html", &mut ctx)
18598}
18599
18600/// POST /cms-admin/__richtext-preview — sanitize a richtext-widget's
18601/// textarea source through the same `ammonia` allow-list the public
18602/// render uses, return the cleaned HTML body so the editor's
18603/// preview swap matches what visitors will see.
18604///
18605/// Accepts the source under a `body` form field. Other field names
18606/// fall through to the empty string. Output is `text/html` so the
18607/// client can drop it straight into `innerHTML` without re-parsing.
18608///
18609/// Session-gated like the rest of the admin POST surface — anonymous
18610/// requests get the friendly 401 page. CSRF is handled by the
18611/// framework's middleware (header-based for the fetch path the JS
18612/// uses).
18613pub async fn richtext_preview(
18614    State(_state): State<super::AdminState>,
18615    _tenant: Tenant,
18616    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
18617    Form(form): Form<std::collections::HashMap<String, String>>,
18618) -> Result<Response, AdminError> {
18619    if session_user.is_none() {
18620        return Ok(unauthorized_no_session());
18621    }
18622    let src = form.get("body").map(String::as_str).unwrap_or("");
18623    let html = crate::markdown::sanitize_html(src);
18624    Ok((
18625        axum::http::StatusCode::OK,
18626        [(axum::http::header::CONTENT_TYPE, "text/html; charset=utf-8")],
18627        html,
18628    )
18629        .into_response())
18630}
18631
18632/// POST /cms-admin/settings/branding — multipart upload of logo
18633/// and/or favicon. Files land in
18634/// storage key `<tenant>/branding/<name>` and the storage keys are
18635/// recorded in `cms_site_setting` under scope `branding`.
18636pub async fn settings_branding_submit(
18637    State(_state): State<super::AdminState>,
18638    tenant: Tenant,
18639    headers: HeaderMap,
18640    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
18641    mut multipart: axum::extract::Multipart,
18642) -> Result<Response, AdminError> {
18643    let mut logo_filename: Option<String> = None;
18644    let mut favicon_filename: Option<String> = None;
18645    let mut site_name: Option<String> = None;
18646
18647    while let Some(field) = multipart
18648        .next_field()
18649        .await
18650        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
18651    {
18652        let field_name = field.name().unwrap_or("").to_owned();
18653        let original = field.file_name().map(|s| s.to_owned());
18654        let bytes = field
18655            .bytes()
18656            .await
18657            .map_err(|e| AdminError::Upload(format!("read field {field_name}: {e}")))?;
18658        // A text field; empty clears it (back to the tenant's name).
18659        if field_name == "site_name" {
18660            site_name = Some(String::from_utf8_lossy(&bytes).trim().chars().take(120).collect());
18661            continue;
18662        }
18663        if bytes.is_empty() {
18664            continue;
18665        }
18666        let (slot, default_ext) = match field_name.as_str() {
18667            "logo" => (&mut logo_filename, "png"),
18668            "favicon" => (&mut favicon_filename, "ico"),
18669            _ => continue,
18670        };
18671        let safe_ext = original
18672            .as_deref()
18673            .and_then(|n| n.rsplit_once('.'))
18674            .map(|(_, ext)| ext)
18675            .filter(|ext| ext.len() <= 8 && ext.chars().all(|c| c.is_ascii_alphanumeric()))
18676            .map(str::to_ascii_lowercase)
18677            .unwrap_or_else(|| default_ext.to_owned());
18678        let storage_name = format!("{field_name}.{safe_ext}");
18679        crate::media_storage::disk_for(&tenant.org.slug)
18680            .save(
18681                &crate::media_storage::key(&tenant.org.slug, &format!("branding/{storage_name}")),
18682                &bytes,
18683            )
18684            .await
18685            .map_err(|e| AdminError::Upload(format!("write {field_name}: {e}")))?;
18686        *slot = Some(storage_name);
18687    }
18688
18689    // Merge into the existing row so an upload of just the favicon
18690    // doesn't clobber a previously-uploaded logo.
18691    let existing = crate::site_setting::get(tenant.pool(), "branding")
18692        .await
18693        .unwrap_or_default()
18694        .map(|r| r.value_json)
18695        .unwrap_or_else(|| serde_json::json!({}));
18696    let mut value = existing.as_object().cloned().unwrap_or_default();
18697    if let Some(name) = logo_filename {
18698        value.insert("logo_storage_key".to_owned(), serde_json::json!(name));
18699    }
18700    if let Some(name) = favicon_filename {
18701        value.insert("favicon_storage_key".to_owned(), serde_json::json!(name));
18702    }
18703    match site_name {
18704        Some(n) if n.is_empty() => {
18705            value.remove("site_name");
18706        }
18707        Some(n) => {
18708            value.insert("site_name".to_owned(), serde_json::json!(n));
18709        }
18710        None => {}
18711    }
18712    let _ =
18713        crate::site_setting::upsert(tenant.pool(), "branding", serde_json::Value::Object(value))
18714            .await?;
18715
18716    redirect_named_with_message(
18717        "rcms-admin:settings",
18718        MsgLevel::Success,
18719        "Branding saved. Reload to see the new logo / favicon.",
18720        &headers,
18721    )
18722}
18723
18724/// GET /__cms-branding/logo — streams the per-tenant logo bytes.
18725/// Anonymous-OK: this is admin chrome but the favicon especially
18726/// needs to be reachable before login.
18727pub async fn settings_branding_serve_logo(headers: HeaderMap, tenant: Tenant) -> Response {
18728    serve_branding_asset(&headers, &tenant, "logo_storage_key").await
18729}
18730
18731/// GET /__cms-branding/favicon — streams the per-tenant favicon.
18732pub async fn settings_branding_serve_favicon(headers: HeaderMap, tenant: Tenant) -> Response {
18733    serve_branding_asset(&headers, &tenant, "favicon_storage_key").await
18734}
18735
18736async fn serve_branding_asset(headers: &HeaderMap, tenant: &Tenant, slot: &str) -> Response {
18737    let setting = match crate::site_setting::get(tenant.pool(), "branding").await {
18738        Ok(Some(s)) => s,
18739        _ => {
18740            return (axum::http::StatusCode::NOT_FOUND, "no branding set").into_response();
18741        }
18742    };
18743    let storage_name = match setting.value_json.get(slot).and_then(|v| v.as_str()) {
18744        Some(s) if !s.is_empty() => s.to_owned(),
18745        _ => {
18746            return (axum::http::StatusCode::NOT_FOUND, "asset not set").into_response();
18747        }
18748    };
18749    // Reject path traversal — storage_name comes from a setting we
18750    // wrote ourselves, but never trust round-tripped JSON.
18751    if storage_name.contains('/') || storage_name.contains("..") {
18752        return (axum::http::StatusCode::BAD_REQUEST, "invalid storage name").into_response();
18753    }
18754    let bytes = match crate::media_storage::disk_for(&tenant.org.slug)
18755        .load(&crate::media_storage::key(
18756            &tenant.org.slug,
18757            &format!("branding/{storage_name}"),
18758        ))
18759        .await
18760    {
18761        Ok(b) => b,
18762        Err(_) => {
18763            return (axum::http::StatusCode::NOT_FOUND, "branding bytes missing").into_response();
18764        }
18765    };
18766    let mime = mime_guess::from_path(&storage_name)
18767        .first_or_octet_stream()
18768        .essence_str()
18769        .to_owned();
18770    // #199 fix — the URL is stable (`/__cms-branding/logo|favicon`) and
18771    // the storage key can stay the same across a re-upload, so the old
18772    // `public, max-age=3600` (no validator) left browsers showing the
18773    // OLD logo/favicon for up to an hour after a change (the reported
18774    // "upload didn't work"). Revalidate via a content ETag instead.
18775    revalidated_asset(headers, mime, bytes)
18776}
18777
18778/// Response for a small, mutable asset served from a STABLE URL
18779/// (branding logo/favicon, user avatar): a content-hash ETag plus
18780/// `Cache-Control: no-cache` (cache, but always revalidate) so a
18781/// re-upload is picked up immediately — no stale-for-an-hour window —
18782/// while unchanged bytes still `304` cheaply (`If-None-Match` honored).
18783fn revalidated_asset(headers: &HeaderMap, mime: String, bytes: Vec<u8>) -> Response {
18784    use sha2::{Digest, Sha256};
18785    let digest = Sha256::digest(&bytes);
18786    let mut etag = String::with_capacity(34);
18787    etag.push('"');
18788    for b in digest.iter().take(16) {
18789        use std::fmt::Write as _;
18790        let _ = write!(etag, "{b:02x}");
18791    }
18792    etag.push('"');
18793    let matches_etag = headers
18794        .get(axum::http::header::IF_NONE_MATCH)
18795        .and_then(|v| v.to_str().ok())
18796        .is_some_and(|inm| inm.split(',').any(|t| t.trim() == etag));
18797    if matches_etag {
18798        return (
18799            axum::http::StatusCode::NOT_MODIFIED,
18800            [
18801                (axum::http::header::ETAG, etag),
18802                (axum::http::header::CACHE_CONTROL, "no-cache".to_owned()),
18803            ],
18804        )
18805            .into_response();
18806    }
18807    (
18808        [
18809            (axum::http::header::CONTENT_TYPE, mime),
18810            (axum::http::header::CACHE_CONTROL, "no-cache".to_owned()),
18811            (axum::http::header::ETAG, etag),
18812        ],
18813        bytes,
18814    )
18815        .into_response()
18816}
18817
18818/// POST /cms-admin/settings/theme — flip either `is_admin_default`
18819/// or `is_default` to a new theme. Form fields:
18820///
18821/// - `surface`: either `admin` or `public` — picks which flag to toggle.
18822/// - `theme_id`: the row to set the flag on.
18823///
18824/// The flag is exclusive per surface (one row at a time carries it),
18825/// so we explicitly clear it from every other row in the same pass.
18826#[derive(Debug, Deserialize)]
18827pub struct ThemeSwitchForm {
18828    pub surface: String,
18829    pub theme_id: i64,
18830}
18831
18832pub async fn settings_theme_switch(
18833    State(_state): State<super::AdminState>,
18834    tenant: Tenant,
18835    headers: HeaderMap,
18836    Form(form): Form<ThemeSwitchForm>,
18837) -> Result<Response, AdminError> {
18838    // #174 — only `surface=admin` is reachable through the UI now.
18839    // The `public` value is still accepted at the API level so host
18840    // crates that drive public-page theming externally keep working,
18841    // but no editor surface posts it anymore.
18842    if form.surface != "admin" && form.surface != "public" {
18843        return Err(AdminError::Validation(format!(
18844            "Unknown surface `{}` — expected `admin` or `public`.",
18845            form.surface
18846        )));
18847    }
18848    let target = crate::theme::Theme::objects()
18849        .where_(crate::theme::Theme::id.eq(form.theme_id))
18850        .first(tenant.pool())
18851        .await?
18852        .ok_or(AdminError::NotFound(form.theme_id))?;
18853
18854    // Clear the exclusive flag everywhere else, then set it on the
18855    // picked row. Sequential ORM writes — atomicity isn't critical
18856    // here (worst case a transient request sees zero rows flagged
18857    // and falls through to the static default).
18858    let all_themes: Vec<crate::theme::Theme> =
18859        crate::theme::Theme::objects().fetch(tenant.pool()).await?;
18860    for mut t in all_themes {
18861        let target_id = target.id.get().copied().unwrap_or_default();
18862        let this_id = t.id.get().copied().unwrap_or_default();
18863        if form.surface == "admin" {
18864            t.is_admin_default = this_id == target_id;
18865        } else {
18866            t.is_default = this_id == target_id;
18867        }
18868        t.save_pool(tenant.pool()).await?;
18869    }
18870    // #274 — when the picker submits via fetch() (XHR), return JSON with
18871    // the freshly-rendered CSS + identifying bits so the client can swap
18872    // the `<style data-rcms-theme>` block in place. Detection: either an
18873    // explicit `Accept: application/json` (preferred — modern), or the
18874    // legacy `X-Requested-With: XMLHttpRequest` (kept so older host
18875    // crates that wrap the picker can still light it up). Plain form
18876    // submissions keep the redirect-with-flash behavior so the picker
18877    // degrades gracefully with JS off.
18878    if wants_json_response(&headers) && form.surface == "admin" {
18879        let target_id = target.id.get().copied().unwrap_or_default();
18880        let brand_colors: Vec<crate::theme::BrandColor> = crate::theme::BrandColor::objects()
18881            .where_(crate::theme::BrandColor::theme_id.eq(target_id))
18882            .order_by(&[("sort_order", false)])
18883            .fetch(tenant.pool())
18884            .await
18885            .unwrap_or_default();
18886        let css = crate::theme::emit_css(&target, &brand_colors);
18887        return Ok(Json(serde_json::json!({
18888            "ok": true,
18889            "id": target_id,
18890            "slug": target.slug,
18891            "name": target.name,
18892            "default_mode": target.default_mode,
18893            "css": css,
18894            "message": format!("Admin theme switched to “{}”.", target.name),
18895        }))
18896        .into_response());
18897    }
18898    // #174 — admin picker redirects back to Preferences (its new
18899    // home); the legacy `public` surface still redirects to Settings
18900    // so host integrations that POST manually keep their UX.
18901    let redirect_target = if form.surface == "admin" {
18902        "rcms-admin:account"
18903    } else {
18904        "rcms-admin:settings"
18905    };
18906    let theme_flash = if form.surface == "admin" {
18907        "Admin theme switched to “{name}”."
18908    } else {
18909        "Public theme switched to “{name}”."
18910    };
18911    redirect_named_with_message_args(
18912        redirect_target,
18913        MsgLevel::Success,
18914        theme_flash,
18915        &[("name", target.name.as_str())],
18916        &headers,
18917    )
18918}
18919
18920/// True when the request prefers a JSON response — either set
18921/// `Accept: application/json` (modern fetch with `Accept` header) or
18922/// the legacy `X-Requested-With: XMLHttpRequest` marker. Used by the
18923/// theme picker so it can opt into a live-swap JSON payload
18924/// without losing the no-JS redirect fallback.
18925fn wants_json_response(headers: &HeaderMap) -> bool {
18926    let accept = headers
18927        .get(header::ACCEPT)
18928        .and_then(|v| v.to_str().ok())
18929        .unwrap_or("");
18930    if accept.contains("application/json") {
18931        return true;
18932    }
18933    headers
18934        .get("x-requested-with")
18935        .and_then(|v| v.to_str().ok())
18936        .is_some_and(|v| v.eq_ignore_ascii_case("XMLHttpRequest"))
18937}
18938
18939// =====================================================================
18940// Redirects tab — editor-managed 301/302 maps. Backed by
18941// crate::redirect::Redirect; the public router consults this table
18942// when a slug lookup returns None (see crate::router).
18943// =====================================================================
18944
18945#[derive(Debug, Deserialize)]
18946pub struct RedirectForm {
18947    pub from_path: String,
18948    pub to_path: String,
18949    /// Checkbox — present when ticked, absent when not. `Some(_)` →
18950    /// 301 Moved Permanently. Default checked in the form template.
18951    #[serde(default)]
18952    pub is_permanent: Option<String>,
18953    #[serde(default)]
18954    pub note: Option<String>,
18955    /// Checkbox: serve even when a published page exists at
18956    /// `from_path`.
18957    #[serde(default)]
18958    pub overrides_live: Option<String>,
18959    /// Chooser hidden inputs; empty string when cleared.
18960    #[serde(default)]
18961    pub from_page_id: Option<String>,
18962    #[serde(default)]
18963    pub to_page_id: Option<String>,
18964}
18965
18966impl RedirectForm {
18967    fn parsed_permanent(&self) -> bool {
18968        self.is_permanent.is_some()
18969    }
18970    fn parsed_overrides_live(&self) -> bool {
18971        self.overrides_live.is_some()
18972    }
18973    fn parsed_page_id(raw: &Option<String>) -> Option<i64> {
18974        raw.as_deref()
18975            .and_then(|s| s.trim().parse::<i64>().ok())
18976            .filter(|id| *id > 0)
18977    }
18978    fn parsed_from_page_id(&self) -> Option<i64> {
18979        Self::parsed_page_id(&self.from_page_id)
18980    }
18981    fn parsed_to_page_id(&self) -> Option<i64> {
18982        Self::parsed_page_id(&self.to_page_id)
18983    }
18984}
18985
18986/// Resolve the effective from/to paths for a redirect form:
18987/// a picked source page snapshots its CURRENT `url_path` into
18988/// `from_path`; a picked destination page snapshots into `to_path`
18989/// (display/fallback — the serve path re-resolves it live). Returns
18990/// `(from_path, to_path)`; typed values pass through when no page is
18991/// picked.
18992async fn redirect_form_paths(
18993    pool: &rustango::sql::Pool,
18994    form: &RedirectForm,
18995) -> Result<(String, String), AdminError> {
18996    let mut from = form.from_path.trim().to_owned();
18997    let mut to = form.to_path.trim().to_owned();
18998    if let Some(pid) = form.parsed_from_page_id() {
18999        if let Some(p) = Page::objects().where_(Page::id.eq(pid)).first(pool).await? {
19000            from = p.url_path;
19001        }
19002    }
19003    if let Some(pid) = form.parsed_to_page_id() {
19004        if let Some(p) = Page::objects().where_(Page::id.eq(pid)).first(pool).await? {
19005            to = p.url_path;
19006        }
19007    }
19008    Ok((from, to))
19009}
19010
19011/// Save-time shadow check: a non-override rule whose
19012/// `from_path` matches a PUBLISHED page will never serve (live pages
19013/// win). Returns `true` when shadowed so the submit handlers can
19014/// flash a warning instead of a plain success.
19015async fn redirect_is_shadowed(tenant: &Tenant, from_path: &str, overrides_live: bool) -> bool {
19016    if overrides_live || crate::redirect::is_wildcard(from_path) {
19017        // Wildcards are meant to span subtrees (which may include live
19018        // pages); "shadow" only applies to exact non-override rules.
19019        return false;
19020    }
19021    matches!(
19022        crate::resolver::resolve_path(tenant, from_path).await,
19023        Ok(Some(_))
19024    )
19025}
19026
19027/// Reject a `from_path` with more than one `*`; a single glob
19028/// (typically `path/*` or `*/path`) is the supported shape. Also reject a
19029/// rule whose destination matches its own from-path.
19030fn redirect_pattern_error(from_path: &str, to_path: &str) -> Option<&'static str> {
19031    if from_path.matches('*').count() > 1 {
19032        Some("The from-path may contain at most one “*” wildcard (e.g. /old/* or */feed).")
19033    } else if crate::redirect::redirect_loops(from_path, to_path) {
19034        Some("That redirect points back at its own from-path, so visitors would loop.")
19035    } else {
19036        None
19037    }
19038}
19039
19040/// Query for the redirect list: free-text search, status filter chip,
19041/// sortable column + direction, and page number.
19042#[derive(Debug, Deserialize, Default)]
19043pub struct RedirectListQuery {
19044    #[serde(default)]
19045    pub q: Option<String>,
19046    /// `all` | `active` | `disabled` | `stale`.
19047    #[serde(default)]
19048    pub filter: Option<String>,
19049    /// `from` | `last_used` | `created` | `hits` | `staleness`.
19050    #[serde(default)]
19051    pub sort: Option<String>,
19052    /// `asc` | `desc`.
19053    #[serde(default)]
19054    pub dir: Option<String>,
19055    #[serde(default)]
19056    pub page: Option<i64>,
19057}
19058
19059const REDIRECTS_PER_PAGE: usize = 50;
19060
19061pub async fn redirect_list(
19062    State(state): State<super::AdminState>,
19063    tenant: Tenant,
19064    headers: HeaderMap,
19065    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19066    Query(q): Query<RedirectListQuery>,
19067) -> Result<Response, AdminError> {
19068    // The redirect table is small (editor-managed), so search / sort /
19069    // paginate happen in-memory over one fetch — same result as
19070    // SQL LIMIT/OFFSET without threading dialect-specific ordering.
19071    let mut all: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
19072        .fetch(tenant.pool())
19073        .await?;
19074    let now = chrono::Utc::now();
19075
19076    let needle = q.q.as_deref().unwrap_or("").trim().to_lowercase();
19077    if !needle.is_empty() {
19078        all.retain(|r| {
19079            r.from_path.to_lowercase().contains(&needle)
19080                || r.to_path.to_lowercase().contains(&needle)
19081                || r.note.to_lowercase().contains(&needle)
19082        });
19083    }
19084
19085    // Chip counts reflect the search-filtered set (before the status filter).
19086    let count_all = all.len();
19087    let count_active = all.iter().filter(|r| r.is_active).count();
19088    let count_disabled = all.iter().filter(|r| !r.is_active).count();
19089    let count_stale = all
19090        .iter()
19091        .filter(|r| matches!(crate::redirect::staleness(r, now), "stale" | "unused"))
19092        .count();
19093
19094    let filter = q.filter.as_deref().unwrap_or("all");
19095    all.retain(|r| match filter {
19096        "active" => r.is_active,
19097        "disabled" => !r.is_active,
19098        "stale" => matches!(crate::redirect::staleness(r, now), "stale" | "unused"),
19099        _ => true,
19100    });
19101
19102    let sort = q.sort.as_deref().unwrap_or("from");
19103    let desc = q.dir.as_deref() == Some("desc");
19104    all.sort_by(|a, b| {
19105        let o = match sort {
19106            "last_used" => a.last_hit_at.cmp(&b.last_hit_at),
19107            "created" => a.created_at.get().cmp(&b.created_at.get()),
19108            "hits" => a.hit_count.cmp(&b.hit_count),
19109            "staleness" => {
19110                let rank = |r: &crate::redirect::Redirect| match crate::redirect::staleness(r, now)
19111                {
19112                    "disabled" => 0u8,
19113                    "unused" => 1,
19114                    "stale" => 2,
19115                    _ => 3,
19116                };
19117                rank(a).cmp(&rank(b))
19118            }
19119            _ => a.from_path.cmp(&b.from_path),
19120        };
19121        if desc {
19122            o.reverse()
19123        } else {
19124            o
19125        }
19126    });
19127
19128    let total = all.len();
19129    let total_pages = total.div_ceil(REDIRECTS_PER_PAGE).max(1);
19130    let page = q.page.unwrap_or(1).clamp(1, total_pages as i64) as usize;
19131    let start = (page - 1) * REDIRECTS_PER_PAGE;
19132    let items: Vec<crate::redirect::Redirect> = all
19133        .into_iter()
19134        .skip(start)
19135        .take(REDIRECTS_PER_PAGE)
19136        .collect();
19137
19138    let mut ctx = Context::new();
19139    add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19140    add_admin_theme(&mut ctx, tenant.pool()).await;
19141    ctx.insert("items", &items);
19142    ctx.insert("q", &needle);
19143    ctx.insert("filter", filter);
19144    ctx.insert("sort", sort);
19145    ctx.insert("dir", if desc { "desc" } else { "asc" });
19146    ctx.insert("current_page", &page);
19147    ctx.insert("total_pages", &total_pages);
19148    ctx.insert("total", &total);
19149    ctx.insert("count_all", &count_all);
19150    ctx.insert("count_active", &count_active);
19151    ctx.insert("count_disabled", &count_disabled);
19152    ctx.insert("count_stale", &count_stale);
19153    render_with_csrf(&state, &headers, "rcms_admin/redirect_list.html", &mut ctx)
19154}
19155
19156pub async fn redirect_new_form(
19157    State(state): State<super::AdminState>,
19158    tenant: Tenant,
19159    headers: HeaderMap,
19160    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19161) -> Result<Response, AdminError> {
19162    let mut ctx = Context::new();
19163    add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19164    add_admin_theme(&mut ctx, tenant.pool()).await;
19165    ctx.insert("mode", "new");
19166    ctx.insert(
19167        "redirect",
19168        &serde_json::json!({
19169            "from_path": "",
19170            "to_path": "",
19171            "is_permanent": true,
19172            "note": "",
19173            "hit_count": 0,
19174            "overrides_live": false,
19175            "from_page_id": null,
19176            "to_page_id": null,
19177        }),
19178    );
19179    render_with_csrf(&state, &headers, "rcms_admin/redirect_form.html", &mut ctx)
19180}
19181
19182pub async fn redirect_new_submit(
19183    State(_state): State<super::AdminState>,
19184    tenant: Tenant,
19185    headers: HeaderMap,
19186    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19187    Form(form): Form<RedirectForm>,
19188) -> Result<Response, AdminError> {
19189    use rustango::sql::Auto;
19190    let (from, to) = redirect_form_paths(tenant.pool(), &form).await?;
19191    if from.is_empty() || to.is_empty() {
19192        return redirect_named_with_message(
19193            "rcms-admin:redirects:list",
19194            MsgLevel::Error,
19195            "From-path and to-path are both required.",
19196            &headers,
19197        );
19198    }
19199    if let Some(msg) = redirect_pattern_error(&from, &to) {
19200        return redirect_named_with_message(
19201            "rcms-admin:redirects:list",
19202            MsgLevel::Error,
19203            msg,
19204            &headers,
19205        );
19206    }
19207    let overrides_live = form.parsed_overrides_live();
19208    let is_permanent = form.parsed_permanent();
19209    let from_page_id = form.parsed_from_page_id();
19210    let to_page_id = form.parsed_to_page_id();
19211    let mut row = crate::redirect::Redirect {
19212        id: Auto::Unset,
19213        from_path: from,
19214        to_path: to,
19215        is_permanent,
19216        note: form.note.unwrap_or_default().trim().to_owned(),
19217        hit_count: 0,
19218        overrides_live,
19219        from_page_id,
19220        to_page_id,
19221        is_active: true,
19222        disabled_reason: String::new(),
19223        last_hit_at: None,
19224        created_at: Auto::Unset,
19225        updated_at: Auto::Unset,
19226    };
19227    row.insert_pool(tenant.pool()).await?;
19228    redirect_save_response(&tenant, &row, overrides_live, true, &headers).await
19229}
19230
19231/// Shared post-save flash for redirect create/edit: a strong warning
19232/// for a wildcard override (it can shadow many live pages), a warning
19233/// for an exact non-override rule shadowed by a live page, else
19234/// success. `is_new` picks the "Added…" vs "Saved…" wording so every
19235/// message stays a single fully-localizable sentence.
19236async fn redirect_save_response(
19237    tenant: &Tenant,
19238    row: &crate::redirect::Redirect,
19239    overrides_live: bool,
19240    is_new: bool,
19241    headers: &HeaderMap,
19242) -> Result<Response, AdminError> {
19243    let args = &[
19244        ("from", row.from_path.as_str()),
19245        ("to", row.to_path.as_str()),
19246    ];
19247    if overrides_live && crate::redirect::is_wildcard(&row.from_path) {
19248        let key = if is_new {
19249            "Added redirect {from} → {to} — heads up: a wildcard override can shadow many live pages under this pattern. Double-check the pattern."
19250        } else {
19251            "Saved redirect {from} → {to} — heads up: a wildcard override can shadow many live pages under this pattern. Double-check the pattern."
19252        };
19253        return redirect_named_with_message_args(
19254            "rcms-admin:redirects:list",
19255            MsgLevel::Warning,
19256            key,
19257            args,
19258            headers,
19259        );
19260    }
19261    if redirect_is_shadowed(tenant, &row.from_path, overrides_live).await {
19262        let key = if is_new {
19263            "Added redirect {from} → {to} — but a published page exists at {from}, so it won't serve until that page is unpublished (or tick “Apply even when a published page exists”)."
19264        } else {
19265            "Saved redirect {from} → {to} — but a published page exists at {from}, so it won't serve until that page is unpublished (or tick “Apply even when a published page exists”)."
19266        };
19267        return redirect_named_with_message_args(
19268            "rcms-admin:redirects:list",
19269            MsgLevel::Warning,
19270            key,
19271            args,
19272            headers,
19273        );
19274    }
19275    let key = if is_new {
19276        "Added redirect {from} → {to}."
19277    } else {
19278        "Saved redirect {from} → {to}."
19279    };
19280    redirect_named_with_message_args(
19281        "rcms-admin:redirects:list",
19282        MsgLevel::Success,
19283        key,
19284        args,
19285        headers,
19286    )
19287}
19288
19289// ----- #186 — snippet CSV import (bulk migration) ---
19290
19291/// One row from the snippet CSV / TSV. Mirrors the cms_snippet shape:
19292/// required slug + title, optional body_markdown + folder_path + a
19293/// flat `data` map (any extra column → data.<column_name>).
19294#[derive(Debug)]
19295struct SnippetImportRow {
19296    slug: String,
19297    title: String,
19298    body_markdown: String,
19299    folder_path: String,
19300    data: serde_json::Map<String, serde_json::Value>,
19301}
19302
19303fn parse_snippet_csv(text: &str) -> Vec<SnippetImportRow> {
19304    // Header is required (we need to know what column is what).
19305    // Auto-detect TSV when tabs are present.
19306    let delimiter = if text.contains('\t') { '\t' } else { ',' };
19307    let mut lines = text.lines();
19308    let header = match lines.next() {
19309        Some(h) => h,
19310        None => return Vec::new(),
19311    };
19312    let cols: Vec<String> = header
19313        .split(delimiter)
19314        .map(|s| s.trim().to_ascii_lowercase())
19315        .collect();
19316    // Need at least slug + title.
19317    let slug_idx = cols.iter().position(|c| c == "slug" || c == "key");
19318    let title_idx = cols.iter().position(|c| c == "title" || c == "name");
19319    let (Some(slug_idx), Some(title_idx)) = (slug_idx, title_idx) else {
19320        return Vec::new();
19321    };
19322    let body_idx = cols
19323        .iter()
19324        .position(|c| c == "body_markdown" || c == "body" || c == "content");
19325    let folder_idx = cols
19326        .iter()
19327        .position(|c| c == "folder_path" || c == "folder" || c == "path");
19328    let mut out = Vec::new();
19329    for raw in lines {
19330        let trimmed = raw.trim();
19331        if trimmed.is_empty() {
19332            continue;
19333        }
19334        let parts: Vec<&str> = trimmed.split(delimiter).map(str::trim).collect();
19335        let slug = parts.get(slug_idx).copied().unwrap_or("");
19336        let title = parts.get(title_idx).copied().unwrap_or("");
19337        if slug.is_empty() || title.is_empty() {
19338            continue;
19339        }
19340        let body_markdown = body_idx
19341            .and_then(|i| parts.get(i))
19342            .copied()
19343            .unwrap_or("")
19344            .to_owned();
19345        let folder_path = folder_idx
19346            .and_then(|i| parts.get(i))
19347            .copied()
19348            .unwrap_or("")
19349            .to_owned();
19350        // Every other column lands in `data`.
19351        let mut data = serde_json::Map::new();
19352        for (i, col) in cols.iter().enumerate() {
19353            if Some(i) == Some(slug_idx)
19354                || Some(i) == Some(title_idx)
19355                || Some(i) == body_idx
19356                || Some(i) == folder_idx
19357            {
19358                continue;
19359            }
19360            if col.is_empty() {
19361                continue;
19362            }
19363            let v = parts.get(i).copied().unwrap_or("");
19364            if !v.is_empty() {
19365                data.insert(col.clone(), serde_json::Value::String(v.to_owned()));
19366            }
19367        }
19368        out.push(SnippetImportRow {
19369            slug: slug.to_owned(),
19370            title: title.to_owned(),
19371            body_markdown,
19372            folder_path: crate::snippet::normalize_folder(&folder_path),
19373            data,
19374        });
19375    }
19376    out
19377}
19378
19379/// GET /cms-admin/library/{type_name}/import — show upload form.
19380pub async fn snippet_import_form(
19381    State(state): State<super::AdminState>,
19382    tenant: Tenant,
19383    headers: HeaderMap,
19384    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19385    Path(type_name): Path<String>,
19386) -> Result<Response, AdminError> {
19387    let mut ctx = Context::new();
19388    add_chrome(&mut ctx, &tenant, "library", session_user.as_ref()).await;
19389    add_admin_theme(&mut ctx, tenant.pool()).await;
19390    ctx.insert("type_name", &type_name);
19391    render_with_csrf(&state, &headers, "rcms_admin/snippet_import.html", &mut ctx)
19392}
19393
19394/// POST /cms-admin/library/{type_name}/import — bulk import snippets
19395/// for one library type from CSV / TSV.
19396pub async fn snippet_import_submit(
19397    State(_state): State<super::AdminState>,
19398    tenant: Tenant,
19399    headers: HeaderMap,
19400    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19401    Path(type_name): Path<String>,
19402    mut multipart: axum::extract::Multipart,
19403) -> Result<Response, AdminError> {
19404    use rustango::sql::Auto;
19405    let mut bytes: Vec<u8> = Vec::new();
19406    let mut filename = String::new();
19407    while let Some(field) = multipart
19408        .next_field()
19409        .await
19410        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
19411    {
19412        if field.name().unwrap_or("") == "file" {
19413            if let Some(name) = field.file_name() {
19414                filename = name.to_owned();
19415            }
19416            bytes = field
19417                .bytes()
19418                .await
19419                .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
19420                .to_vec();
19421        } else {
19422            let _ = field.bytes().await;
19423        }
19424    }
19425    if bytes.is_empty() {
19426        return redirect_named_with_message(
19427            "rcms-admin:library:list",
19428            MsgLevel::Error,
19429            "No file uploaded.",
19430            &headers,
19431        );
19432    }
19433    let text = String::from_utf8_lossy(&bytes);
19434    let rows = parse_snippet_csv(&text);
19435    let total = rows.len();
19436    if total == 0 {
19437        return redirect_named_with_message(
19438            "rcms-admin:library:list",
19439            MsgLevel::Error,
19440            "Imported 0 snippets — CSV must have a header row with `slug` + `title` columns.",
19441            &headers,
19442        );
19443    }
19444    let mut inserted = 0usize;
19445    let mut skipped = 0usize;
19446    let _ = filename; // captured for the note below
19447    for row in rows {
19448        let mut snippet = crate::snippet::Snippet {
19449            id: Auto::Unset,
19450            type_name: type_name.clone(),
19451            folder_path: row.folder_path,
19452            slug: row.slug,
19453            title: row.title,
19454            body_markdown: row.body_markdown,
19455            data: serde_json::Value::Object(row.data),
19456            created_at: Auto::Unset,
19457            updated_at: Auto::Unset,
19458        };
19459        match snippet.insert_pool(tenant.pool()).await {
19460            Ok(_) => inserted += 1,
19461            Err(_) => skipped += 1,
19462        }
19463    }
19464    let inserted_str = inserted.to_string();
19465    let total_str = total.to_string();
19466    let skipped_str = skipped.to_string();
19467    redirect_named_with_message_args(
19468        "rcms-admin:library:list",
19469        MsgLevel::Success,
19470        "Imported {inserted}/{total} snippets ({skipped} skipped — likely duplicate slugs).",
19471        &[
19472            ("inserted", inserted_str.as_str()),
19473            ("total", total_str.as_str()),
19474            ("skipped", skipped_str.as_str()),
19475        ],
19476        &headers,
19477    )
19478}
19479
19480/// GET /cms-admin/redirects/import — show the upload form.
19481pub async fn redirect_import_form(
19482    State(state): State<super::AdminState>,
19483    tenant: Tenant,
19484    headers: HeaderMap,
19485    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19486) -> Result<Response, AdminError> {
19487    let mut ctx = Context::new();
19488    add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19489    add_admin_theme(&mut ctx, tenant.pool()).await;
19490    render_with_csrf(
19491        &state,
19492        &headers,
19493        "rcms_admin/redirect_import.html",
19494        &mut ctx,
19495    )
19496}
19497
19498/// Parsed shape of one row from the CSV / TSV upload. Either two
19499/// or three fields per row: `old_path`, `new_path`, optional
19500/// `is_permanent` (`true` / `false`, or `301` / `302`).
19501#[derive(Debug)]
19502struct RedirectImportRow {
19503    from_path: String,
19504    to_path: String,
19505    is_permanent: bool,
19506}
19507
19508fn parse_redirect_csv(text: &str) -> Vec<RedirectImportRow> {
19509    // Best-effort CSV / TSV. Doesn't handle quoted commas inside
19510    // values (RFC-4180 strict) — redirects are URL paths, no
19511    // commas in them. TSV detection: if any line contains a tab,
19512    // use tab as the delimiter; otherwise comma.
19513    let delimiter = if text.contains('\t') { '\t' } else { ',' };
19514    let mut out = Vec::new();
19515    for (lineno, raw) in text.lines().enumerate() {
19516        let trimmed = raw.trim();
19517        if trimmed.is_empty() {
19518            continue;
19519        }
19520        let parts: Vec<&str> = trimmed.split(delimiter).map(str::trim).collect();
19521        // Header row: if the first row's first two cells are exactly
19522        // `from_path` / `to_path` (case-insensitive), skip.
19523        if lineno == 0 {
19524            let h0 = parts.first().copied().unwrap_or("").to_ascii_lowercase();
19525            if h0 == "from_path" || h0 == "from" || h0 == "old" || h0 == "source" {
19526                continue;
19527            }
19528        }
19529        if parts.len() < 2 {
19530            continue;
19531        }
19532        let from = parts[0];
19533        let to = parts[1];
19534        if from.is_empty() || to.is_empty() {
19535            continue;
19536        }
19537        let is_permanent = parts
19538            .get(2)
19539            .map(|s| {
19540                let v = s.to_ascii_lowercase();
19541                !matches!(v.as_str(), "false" | "0" | "302" | "no")
19542            })
19543            .unwrap_or(true);
19544        out.push(RedirectImportRow {
19545            from_path: from.to_owned(),
19546            to_path: to.to_owned(),
19547            is_permanent,
19548        });
19549    }
19550    out
19551}
19552
19553/// Serialize redirects to CSV: a header row + `from_path,to_path,
19554/// is_permanent`, with `is_permanent` rendered as `301`/`302` so the
19555/// importer ([`parse_redirect_csv`]) round-trips an export.
19556fn redirects_csv(items: &[crate::redirect::Redirect]) -> String {
19557    let mut out = String::from("from_path,to_path,is_permanent\n");
19558    for r in items {
19559        out.push_str(&csv_escape(&r.from_path));
19560        out.push(',');
19561        out.push_str(&csv_escape(&r.to_path));
19562        out.push(',');
19563        out.push_str(if r.is_permanent { "301" } else { "302" });
19564        out.push('\n');
19565    }
19566    out
19567}
19568
19569/// GET /cms-admin/redirects/export.csv — download all redirects as a
19570/// CSV the importer can round-trip.
19571pub async fn redirect_export_csv(
19572    State(_state): State<super::AdminState>,
19573    tenant: Tenant,
19574    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19575) -> Result<Response, AdminError> {
19576    let items: Vec<crate::redirect::Redirect> = crate::redirect::Redirect::objects()
19577        .order_by(&[("from_path", false)])
19578        .fetch(tenant.pool())
19579        .await?;
19580    let body = redirects_csv(&items);
19581    let filename = format!("redirects-{}.csv", chrono::Utc::now().format("%Y%m%d"));
19582    let mut response = ([(header::CONTENT_TYPE, "text/csv; charset=utf-8")], body).into_response();
19583    if let Ok(v) = HeaderValue::from_str(&format!("attachment; filename=\"{filename}\"")) {
19584        response
19585            .headers_mut()
19586            .insert(header::CONTENT_DISPOSITION, v);
19587    }
19588    Ok(response)
19589}
19590
19591#[cfg(test)]
19592mod user_email_column_tests {
19593    use super::user_email;
19594
19595    fn user(email: Option<&str>, data: serde_json::Value) -> rustango::tenancy::auth::User {
19596        rustango::tenancy::auth::User {
19597            id: rustango::sql::Auto::Set(1),
19598            username: "u".into(),
19599            password_hash: String::new(),
19600            email: email.map(ToOwned::to_owned),
19601            is_superuser: false,
19602            active: true,
19603            created_at: chrono::Utc::now(),
19604            data,
19605            password_changed_at: None,
19606            sessions_revoked_at: None,
19607        }
19608    }
19609
19610    #[test]
19611    fn column_first_then_legacy_data_bag() {
19612        // A member signed up on the site: the column only.
19613        assert_eq!(user_email(&user(Some("a@x.example"), serde_json::json!({}))), "a@x.example");
19614        // An admin-made user from before: the data bag only.
19615        assert_eq!(user_email(&user(None, serde_json::json!({"email": "b@x.example"}))), "b@x.example");
19616        assert_eq!(
19617            user_email(&user(Some("a@x.example"), serde_json::json!({"email": "old@x.example"}))),
19618            "a@x.example"
19619        );
19620        assert_eq!(user_email(&user(Some("  "), serde_json::json!({}))), "");
19621    }
19622}
19623
19624#[cfg(test)]
19625mod translation_canonical_html_tests {
19626    use super::translation_canonical_html;
19627
19628    #[test]
19629    fn rich_text_is_sanitized_html_other_kinds_empty() {
19630        let html = translation_canonical_html("richtext", "<p>A jar</p><script>x()</script>");
19631        assert_eq!(html, "<p>A jar</p>");
19632        assert_eq!(translation_canonical_html("richtext", "  "), "");
19633        assert_eq!(translation_canonical_html("textarea", "<p>A jar</p>"), "");
19634        assert_eq!(translation_canonical_html("text", "Moon jar"), "");
19635    }
19636}
19637
19638#[cfg(test)]
19639mod user_email_tests {
19640    use super::validate_optional_email;
19641
19642    #[test]
19643    fn accepts_valid_and_empty() {
19644        assert_eq!(validate_optional_email(Some("a@b.com")).unwrap(), "a@b.com");
19645        assert_eq!(
19646            validate_optional_email(Some("  a@b.com ")).unwrap(),
19647            "a@b.com"
19648        ); // trimmed
19649        assert_eq!(validate_optional_email(None).unwrap(), ""); // optional
19650        assert_eq!(validate_optional_email(Some("   ")).unwrap(), ""); // blank → empty
19651    }
19652
19653    #[test]
19654    fn rejects_malformed() {
19655        assert!(validate_optional_email(Some("nope")).is_err()); // no @
19656        assert!(validate_optional_email(Some("a@b@c")).is_err()); // two @
19657        assert!(validate_optional_email(Some("@b.com")).is_err()); // empty local
19658        assert!(validate_optional_email(Some("a@")).is_err()); // empty domain
19659        assert!(validate_optional_email(Some("a b@c.com")).is_err()); // whitespace
19660    }
19661}
19662
19663#[cfg(test)]
19664mod copy_to_locale_tests {
19665    use super::copy_translatable_fields;
19666
19667    #[test]
19668    fn selects_nonempty_canonical_fields() {
19669        let out = copy_translatable_fields("Home", "", "  Welcome  ");
19670        // `seo_title` empty → skipped; whitespace-only would be too.
19671        assert_eq!(
19672            out,
19673            vec![
19674                ("title", "Home".to_owned()),
19675                ("seo_description", "  Welcome  ".to_owned()),
19676            ]
19677        );
19678    }
19679
19680    #[test]
19681    fn all_empty_yields_nothing_to_seed() {
19682        assert!(copy_translatable_fields("", "   ", "").is_empty());
19683    }
19684}
19685
19686#[cfg(test)]
19687mod redirect_csv_tests {
19688    use super::*;
19689    use rustango::sql::Auto;
19690
19691    fn row(from: &str, to: &str, permanent: bool) -> crate::redirect::Redirect {
19692        crate::redirect::Redirect {
19693            id: Auto::Unset,
19694            from_path: from.to_owned(),
19695            to_path: to.to_owned(),
19696            is_permanent: permanent,
19697            note: String::new(),
19698            hit_count: 0,
19699            overrides_live: false,
19700            from_page_id: None,
19701            to_page_id: None,
19702            is_active: true,
19703            disabled_reason: String::new(),
19704            last_hit_at: None,
19705            created_at: Auto::Unset,
19706            updated_at: Auto::Unset,
19707        }
19708    }
19709
19710    #[test]
19711    fn redirects_csv_header_and_301_302_mapping() {
19712        let csv = redirects_csv(&[row("/old", "/new", true), row("/tmp", "/dst", false)]);
19713        let mut lines = csv.lines();
19714        assert_eq!(lines.next(), Some("from_path,to_path,is_permanent"));
19715        assert_eq!(lines.next(), Some("/old,/new,301"));
19716        assert_eq!(lines.next(), Some("/tmp,/dst,302"));
19717        assert_eq!(lines.next(), None);
19718    }
19719
19720    #[test]
19721    fn redirects_csv_empty_is_header_only() {
19722        assert_eq!(redirects_csv(&[]), "from_path,to_path,is_permanent\n");
19723    }
19724}
19725
19726/// POST /cms-admin/redirects/import — accepts a multipart upload of
19727/// CSV / TSV; bulk-inserts redirects.
19728pub async fn redirect_import_submit(
19729    State(_state): State<super::AdminState>,
19730    tenant: Tenant,
19731    headers: HeaderMap,
19732    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19733    mut multipart: axum::extract::Multipart,
19734) -> Result<Response, AdminError> {
19735    use rustango::sql::Auto;
19736    let mut bytes: Vec<u8> = Vec::new();
19737    let mut filename = String::new();
19738    while let Some(field) = multipart
19739        .next_field()
19740        .await
19741        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
19742    {
19743        if field.name().unwrap_or("") == "file" {
19744            if let Some(name) = field.file_name() {
19745                filename = name.to_owned();
19746            }
19747            bytes = field
19748                .bytes()
19749                .await
19750                .map_err(|e| AdminError::Upload(format!("read bytes: {e}")))?
19751                .to_vec();
19752        } else {
19753            let _ = field.bytes().await;
19754        }
19755    }
19756    if bytes.is_empty() {
19757        return redirect_named_with_message(
19758            "rcms-admin:redirects:list",
19759            MsgLevel::Error,
19760            "No file uploaded.",
19761            &headers,
19762        );
19763    }
19764    let text = String::from_utf8_lossy(&bytes);
19765    let rows = parse_redirect_csv(&text);
19766    let total = rows.len();
19767    let mut inserted = 0usize;
19768    let mut skipped = 0usize;
19769    for row in rows {
19770        if redirect_pattern_error(&row.from_path, &row.to_path).is_some() {
19771            skipped += 1;
19772            continue;
19773        }
19774        let mut redirect = crate::redirect::Redirect {
19775            id: Auto::Unset,
19776            from_path: row.from_path,
19777            to_path: row.to_path,
19778            is_permanent: row.is_permanent,
19779            note: format!("Imported from {filename}"),
19780            hit_count: 0,
19781            overrides_live: false,
19782            from_page_id: None,
19783            to_page_id: None,
19784            is_active: true,
19785            disabled_reason: String::new(),
19786            last_hit_at: None,
19787            created_at: Auto::Unset,
19788            updated_at: Auto::Unset,
19789        };
19790        match redirect.insert_pool(tenant.pool()).await {
19791            Ok(_) => inserted += 1,
19792            Err(_) => skipped += 1,
19793        }
19794    }
19795    let inserted_str = inserted.to_string();
19796    let total_str = total.to_string();
19797    let skipped_str = skipped.to_string();
19798    redirect_named_with_message_args(
19799        "rcms-admin:redirects:list",
19800        MsgLevel::Success,
19801        "Imported {inserted}/{total} redirects ({skipped} skipped — likely duplicates).",
19802        &[
19803            ("inserted", inserted_str.as_str()),
19804            ("total", total_str.as_str()),
19805            ("skipped", skipped_str.as_str()),
19806        ],
19807        &headers,
19808    )
19809}
19810
19811pub async fn redirect_edit_form(
19812    State(state): State<super::AdminState>,
19813    tenant: Tenant,
19814    headers: HeaderMap,
19815    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
19816    Path(id): Path<i64>,
19817) -> Result<Response, AdminError> {
19818    let row = crate::redirect::Redirect::objects()
19819        .where_(crate::redirect::Redirect::id.eq(id))
19820        .first(tenant.pool())
19821        .await?
19822        .ok_or(AdminError::NotFound(id))?;
19823    let mut ctx = Context::new();
19824    add_chrome(&mut ctx, &tenant, "redirects", session_user.as_ref()).await;
19825    add_admin_theme(&mut ctx, tenant.pool()).await;
19826    ctx.insert("mode", "edit");
19827    ctx.insert("redirect", &row);
19828    render_with_csrf(&state, &headers, "rcms_admin/redirect_form.html", &mut ctx)
19829}
19830
19831pub async fn redirect_edit_submit(
19832    State(_state): State<super::AdminState>,
19833    tenant: Tenant,
19834    headers: HeaderMap,
19835    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19836    Path(id): Path<i64>,
19837    Form(form): Form<RedirectForm>,
19838) -> Result<Response, AdminError> {
19839    let mut row = crate::redirect::Redirect::objects()
19840        .where_(crate::redirect::Redirect::id.eq(id))
19841        .first(tenant.pool())
19842        .await?
19843        .ok_or(AdminError::NotFound(id))?;
19844    let (from, to) = redirect_form_paths(tenant.pool(), &form).await?;
19845    if from.is_empty() || to.is_empty() {
19846        return redirect_named_with_message(
19847            "rcms-admin:redirects:list",
19848            MsgLevel::Error,
19849            "From-path and to-path are both required.",
19850            &headers,
19851        );
19852    }
19853    if let Some(msg) = redirect_pattern_error(&from, &to) {
19854        return redirect_named_with_message(
19855            "rcms-admin:redirects:list",
19856            MsgLevel::Error,
19857            msg,
19858            &headers,
19859        );
19860    }
19861    row.from_path = from;
19862    row.to_path = to;
19863    row.is_permanent = form.parsed_permanent();
19864    row.overrides_live = form.parsed_overrides_live();
19865    row.from_page_id = form.parsed_from_page_id();
19866    row.to_page_id = form.parsed_to_page_id();
19867    row.note = form.note.unwrap_or_default().trim().to_owned();
19868    row.save_pool(tenant.pool()).await?;
19869    let overrides_live = row.overrides_live;
19870    redirect_save_response(&tenant, &row, overrides_live, false, &headers).await
19871}
19872
19873/// POST /cms-admin/redirects/{id}/enable — re-enable a rule that was
19874/// auto-disabled when a linked page was deleted/unpublished.
19875pub async fn redirect_enable_submit(
19876    State(_state): State<super::AdminState>,
19877    tenant: Tenant,
19878    headers: HeaderMap,
19879    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19880    Path(id): Path<i64>,
19881) -> Result<Response, AdminError> {
19882    let mut row = crate::redirect::Redirect::objects()
19883        .where_(crate::redirect::Redirect::id.eq(id))
19884        .first(tenant.pool())
19885        .await?
19886        .ok_or(AdminError::NotFound(id))?;
19887    row.is_active = true;
19888    row.disabled_reason = String::new();
19889    row.save_pool(tenant.pool()).await?;
19890    redirect_named_with_message_args(
19891        "rcms-admin:redirects:list",
19892        MsgLevel::Success,
19893        "Re-enabled redirect {from} → {to}.",
19894        &[
19895            ("from", row.from_path.as_str()),
19896            ("to", row.to_path.as_str()),
19897        ],
19898        &headers,
19899    )
19900}
19901
19902pub async fn redirect_delete_submit(
19903    State(_state): State<super::AdminState>,
19904    tenant: Tenant,
19905    headers: HeaderMap,
19906    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
19907    Path(id): Path<i64>,
19908) -> Result<Response, AdminError> {
19909    let row = crate::redirect::Redirect::objects()
19910        .where_(crate::redirect::Redirect::id.eq(id))
19911        .first(tenant.pool())
19912        .await?
19913        .ok_or(AdminError::NotFound(id))?;
19914    let label = format!("{} → {}", row.from_path, row.to_path);
19915    row.delete_pool(tenant.pool()).await?;
19916    redirect_named_with_message_args(
19917        "rcms-admin:redirects:list",
19918        MsgLevel::Success,
19919        "Deleted redirect {label}.",
19920        &[("label", label.as_str())],
19921        &headers,
19922    )
19923}
19924
19925// =====================================================================
19926// Helpers (existing)
19927// =====================================================================
19928
19929// ---------- helpers ----------
19930
19931/// `PageType` rows whose handler reports `is_creatable() = true`.
19932/// Falls back to the row's `is_creatable` column when no handler is
19933/// registered (stale row from a removed type).
19934pub(crate) fn creatable_types(all: &[PageType]) -> Vec<PageType> {
19935    all.iter()
19936        .filter(|t| {
19937            find_handler(&t.type_name)
19938                .map(|h| h.is_creatable())
19939                .unwrap_or(t.is_creatable)
19940        })
19941        .cloned()
19942        .collect()
19943}
19944
19945/// `PageType` rows allowed at the ROOT of the tree (no parent).
19946///
19947/// A type that names `allowed_parent_types` is declaring it may only live
19948/// under those parents, so it cannot be a root. Without this the root picker
19949/// offered every creatable type and the save path accepted it, letting you
19950/// create e.g. an `ArticlePage` (parent-restricted to `HomePage`) at the root
19951/// — a tree the type rules forbid. The child case has always been
19952/// gated by [`allowed_children_for`]; this is the missing mirror.
19953pub(crate) fn allowed_root_types(all: &[PageType]) -> Vec<PageType> {
19954    creatable_types(all)
19955        .into_iter()
19956        .filter(|t| t.allowed_parents().is_empty())
19957        .collect()
19958}
19959
19960/// `PageType` rows allowed as direct children of `parent`. Consults
19961/// the parent's handler's `allowed_child_types` AND each candidate's
19962/// `allowed_parent_types`. Skip the check if either whitelist is
19963/// empty.
19964pub(crate) fn allowed_children_for(parent: &Page, all: &[PageType]) -> Vec<PageType> {
19965    let parent_row = all
19966        .iter()
19967        .find(|t| t.id.get().copied() == Some(parent.page_type_id));
19968    let parent_type_name = parent_row.map(|t| t.type_name.clone()).unwrap_or_default();
19969    // Rules come from the rows, so admin-made types count too (#843).
19970    let parent_allowed_children = parent_row.map(PageType::allowed_children).unwrap_or_default();
19971
19972    creatable_types(all)
19973        .into_iter()
19974        .filter(|cand| {
19975            // Parent-side gate: empty list = no restriction.
19976            if !parent_allowed_children.is_empty()
19977                && !parent_allowed_children.iter().any(|t| t == &cand.type_name)
19978            {
19979                return false;
19980            }
19981            // Child-side gate.
19982            let allowed_parents = cand.allowed_parents();
19983            allowed_parents.is_empty() || allowed_parents.iter().any(|p| *p == parent_type_name)
19984        })
19985        .collect()
19986}
19987
19988/// Empty values for a fresh create form — Tera doesn't auto-default
19989/// missing keys, so we pre-populate the field map.
19990fn empty_page_form_values() -> serde_json::Value {
19991    serde_json::json!({
19992        "title": "",
19993        "slug": "",
19994        "page_type_id": 0,
19995        "status": "draft",
19996        "seo_title": "",
19997        "seo_description": "",
19998        "robots_index": true,
19999        "sitemap_priority": 0.5,
20000        "show_in_menus": true,
20001        "go_live_at": serde_json::Value::Null,
20002        "expire_at": serde_json::Value::Null,
20003        "og_title": "",
20004        "og_description": "",
20005        "og_image_media_id": serde_json::Value::Null,
20006        "twitter_card": "summary_large_image",
20007    })
20008}
20009
20010// =====================================================================
20011// Password reset
20012// =====================================================================
20013//
20014// The four screens — request form (GET), request submit (POST),
20015// confirm form (GET, signed-token URL), confirm submit (POST). Mounted
20016// by `admin::public_router` so anonymous visitors can reach them.
20017//
20018// Token model: signed-URL only (no DB table). The signing secret lives
20019// in `AdminState::signing_secret`, loaded once at boot. `PasswordReset`
20020// (rustango::auth_flows) handles issue + verify.
20021//
20022// Email model: `ConsoleMailer` for v1 — the reset URL prints to stdout
20023// + `tracing::info!`. Production deployments swap in `SmtpMailer` by
20024// editing `send_reset_email` below.
20025//
20026// Account-existence non-leak: every reset-request returns the same
20027// "if that account exists, check your email" page regardless of
20028// whether a user was found.
20029
20030/// POST `/cms-admin/logout` — clear every session cookie the host
20031/// might have minted (bare-admin `rustango_admin_session`, tenant
20032/// `rustango_tenant_session`, operator `rustango_op_session`),
20033/// redirect to `/login`. Self-contained so the button works
20034/// regardless of which framework auth flow signed the user in —
20035/// avoids depending on the right cookie name being known here.
20036pub async fn cms_logout_submit() -> Response {
20037    let mut resp = Redirect::to("/login").into_response();
20038    // Reset all three cookies (`Max-Age=0` clears, the empty value
20039    // is a fallback for browsers that only honor expiry-by-value).
20040    // SameSite=Lax + HttpOnly match the framework's mint shape.
20041    let cookies = [
20042        "rustango_admin_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20043        "rustango_tenant_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20044        "rustango_op_session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
20045    ];
20046    for c in cookies {
20047        if let Ok(v) = HeaderValue::from_str(c) {
20048            resp.headers_mut().append(header::SET_COOKIE, v);
20049        }
20050    }
20051    resp
20052}
20053
20054/// GET `/login` — render the CMS-branded login form. Shadows the
20055/// framework's default `/login` GET (which is wired to its own
20056/// embedded Tera + `login.html`). POST `/login` continues to be
20057/// handled by the framework's auth code — its handler validates
20058/// `username`+`password` against `rustango_users` and sets the
20059/// tenant session cookie.
20060/// GET `/cms-admin/no-access` — destination for the `cms_admin.access`
20061/// gate. Reachable while signed in; doesn't require any
20062/// permission. The middleware adds an exception for this path so
20063/// the redirect doesn't loop.
20064pub async fn no_access_page(
20065    State(state): State<super::AdminState>,
20066    headers: HeaderMap,
20067    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
20068) -> Result<Response, AdminError> {
20069    let mut ctx = Context::new();
20070    ctx.insert("admin_title", &"CMS Admin");
20071    render_with_csrf(&state, &headers, "rcms_admin/no_access.html", &mut ctx)
20072}
20073
20074/// GET `/cms-admin/me` — per-user appearance / text-size / accessibility
20075/// preferences. Replaces the sidebar-footer toggles. The
20076/// preferences themselves persist in `localStorage` via the existing
20077/// no-flash boot script + the toggle JS in `_base.html`; this view
20078/// is purely the surface that hosts the same toggle widgets in a
20079/// dedicated page.
20080/// POST /cms-admin/dismissibles/{key} — record dismissal of the
20081/// banner identified by `key` for the current user. Returns 204 No Content on success.
20082pub async fn dismissible_submit(
20083    State(_state): State<super::AdminState>,
20084    tenant: Tenant,
20085    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20086    Path(key): Path<String>,
20087) -> Result<Response, AdminError> {
20088    let Some(viewer) = session_user.as_ref() else {
20089        return Ok(unauthorized_no_session());
20090    };
20091    let viewer_id = viewer.id.get().copied().unwrap_or_default();
20092    crate::dismissible::dismiss(tenant.pool(), viewer_id, &key).await?;
20093    Ok((axum::http::StatusCode::NO_CONTENT, "").into_response())
20094}
20095
20096/// GET /cms-admin/dashboard — editor home / at-a-glance screen.
20097/// Surfaces count widgets, recent edits,
20098/// items locked by the current user, and pages scheduled to publish
20099/// next.
20100pub async fn dashboard(
20101    State(state): State<super::AdminState>,
20102    tenant: Tenant,
20103    headers: HeaderMap,
20104    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20105) -> Result<Response, AdminError> {
20106    let pool = tenant.pool();
20107    let viewer_id = session_user.as_ref().and_then(|u| u.id.get().copied());
20108
20109    // ---- counts ----
20110    let all_pages: Vec<Page> = Page::objects().fetch(pool).await.unwrap_or_default();
20111    let mut count_drafts = 0usize;
20112    let mut count_published = 0usize;
20113    let mut count_scheduled = 0usize;
20114    let mut count_archived = 0usize;
20115    for p in &all_pages {
20116        match p.status.as_str() {
20117            "draft" => count_drafts += 1,
20118            "published" => count_published += 1,
20119            "scheduled" => count_scheduled += 1,
20120            "archived" => count_archived += 1,
20121            _ => {}
20122        }
20123    }
20124    let snippet_count: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
20125        .fetch(pool)
20126        .await
20127        .unwrap_or_default();
20128    let media_rows: Vec<Media> = Media::objects().fetch(pool).await.unwrap_or_default();
20129    let media_images = media_rows.iter().filter(|m| m.kind == "image").count();
20130    let media_docs = media_rows.len() - media_images;
20131
20132    // ---- recent edits (last 10 revisions across all pages) ----
20133    let revs: Vec<crate::revision::Revision> = crate::revision::Revision::objects()
20134        .order_by(&[("created_at", true)]) // desc
20135        .limit(10)
20136        .fetch(pool)
20137        .await
20138        .unwrap_or_default();
20139    // Who made them, by name (one query).
20140    let user_ids: std::collections::BTreeSet<i64> = revs.iter().filter_map(|r| r.created_by).collect();
20141    let usernames: std::collections::HashMap<i64, String> = if user_ids.is_empty() {
20142        std::collections::HashMap::new()
20143    } else {
20144        rustango::tenancy::auth::User::objects()
20145            .where_(rustango::tenancy::auth::User::id.is_in(user_ids.into_iter()))
20146            .fetch(pool)
20147            .await
20148            .unwrap_or_default()
20149            .into_iter()
20150            .filter_map(|u| u.id.get().copied().map(|id| (id, u.username)))
20151            .collect()
20152    };
20153    let page_by_id: std::collections::HashMap<i64, &Page> = all_pages
20154        .iter()
20155        .filter_map(|p| p.id.get().copied().map(|id| (id, p)))
20156        .collect();
20157    let recent_edits: Vec<serde_json::Value> = revs
20158        .iter()
20159        .filter_map(|r| {
20160            let p = page_by_id.get(&r.page_id)?;
20161            Some(serde_json::json!({
20162                "page_id": r.page_id,
20163                "title": p.title,
20164                "url_path": p.url_path,
20165                "sequence": r.sequence,
20166                "created_at": r.created_at.get().copied(),
20167                "created_by": r.created_by.and_then(|id| usernames.get(&id).cloned()),
20168            }))
20169        })
20170        .collect();
20171
20172    // ---- locked by me ----
20173    let locks: Vec<crate::lock::PageLock> = crate::lock::PageLock::objects()
20174        .fetch(pool)
20175        .await
20176        .unwrap_or_default();
20177    let now = chrono::Utc::now();
20178    let mine_locked: Vec<serde_json::Value> = locks
20179        .iter()
20180        .filter(|l| !l.is_stale(now))
20181        .filter(|l| Some(l.user_id) == viewer_id)
20182        .filter_map(|l| {
20183            let p = page_by_id.get(&l.page_id)?;
20184            Some(serde_json::json!({
20185                "page_id": l.page_id,
20186                "title": p.title,
20187                "url_path": p.url_path,
20188                "acquired_at": l.acquired_at.get().copied(),
20189            }))
20190        })
20191        .collect();
20192
20193    // ---- waiting for your review ----
20194    // Pages mid-review whose current step belongs to one of the viewer's
20195    // roles (a superuser decides every step). Without this the reviewer
20196    // had no way to know someone was waiting.
20197    let mut review_rows: Vec<serde_json::Value> = Vec::new();
20198    if let Some(viewer) = session_user.as_ref() {
20199        let states: Vec<crate::workflow::WorkflowState> = crate::workflow::WorkflowState::objects()
20200            .where_(crate::workflow::WorkflowState::status.eq(crate::workflow::WorkflowStatus::InProgress.as_str().to_owned()))
20201            .fetch(pool)
20202            .await
20203            .unwrap_or_default();
20204        if !states.is_empty() {
20205            let my_roles: std::collections::BTreeSet<i64> = rustango::tenancy::permissions::UserRole::objects()
20206                .where_(rustango::tenancy::permissions::UserRole::user_id.eq(viewer_id.unwrap_or_default()))
20207                .fetch(pool)
20208                .await
20209                .unwrap_or_default()
20210                .into_iter()
20211                .map(|m| m.role_id)
20212                .collect();
20213            let task_ids: Vec<i64> = states.iter().filter_map(|st| st.current_task_id).collect();
20214            let tasks: std::collections::HashMap<i64, crate::workflow::WorkflowTask> = crate::workflow::WorkflowTask::objects()
20215                .where_(crate::workflow::WorkflowTask::id.is_in(task_ids.into_iter()))
20216                .fetch(pool)
20217                .await
20218                .unwrap_or_default()
20219                .into_iter()
20220                .filter_map(|t| t.id.get().copied().map(|id| (id, t)))
20221                .collect();
20222            for st in &states {
20223                let Some(task) = st.current_task_id.and_then(|id| tasks.get(&id)) else { continue };
20224                if !viewer.is_superuser && !my_roles.contains(&task.role_id) {
20225                    continue;
20226                }
20227                let Some(p) = page_by_id.get(&st.page_id) else { continue };
20228                review_rows.push(serde_json::json!({
20229                    "page_id": st.page_id,
20230                    "title": p.title,
20231                    "url_path": p.url_path,
20232                    "step": task.name,
20233                    "requested_at": st.requested_at.get().copied(),
20234                }));
20235            }
20236        }
20237    }
20238
20239    // ---- scheduled next ----
20240    let mut scheduled: Vec<&Page> = all_pages
20241        .iter()
20242        .filter(|p| {
20243            p.status == "scheduled" && p.go_live_at.is_some() && p.go_live_at.unwrap() > now
20244        })
20245        .collect();
20246    scheduled.sort_by_key(|p| p.go_live_at);
20247    scheduled.truncate(5);
20248    let scheduled_rows: Vec<serde_json::Value> = scheduled
20249        .into_iter()
20250        .map(|p| {
20251            serde_json::json!({
20252                "page_id": p.id.get().copied().unwrap_or_default(),
20253                "title": p.title,
20254                "url_path": p.url_path,
20255                "go_live_at": p.go_live_at,
20256            })
20257        })
20258        .collect();
20259
20260    // ---- plugin widgets ----
20261    let plugin_widgets: Vec<serde_json::Value> = crate::hooks::dashboard_widgets()
20262        .into_iter()
20263        .map(|w| {
20264            serde_json::json!({
20265                "key": w.key,
20266                "label": w.label,
20267                "icon": w.icon,
20268                "html": w.html,
20269            })
20270        })
20271        .collect();
20272
20273    let mut ctx = Context::new();
20274    add_chrome(&mut ctx, &tenant, "dashboard", session_user.as_ref()).await;
20275    add_admin_theme(&mut ctx, tenant.pool()).await;
20276    ctx.insert("review_rows", &review_rows);
20277    ctx.insert("count_drafts", &count_drafts);
20278    ctx.insert("count_published", &count_published);
20279    ctx.insert("count_scheduled", &count_scheduled);
20280    ctx.insert("count_archived", &count_archived);
20281    ctx.insert("count_snippets", &snippet_count.len());
20282    ctx.insert("count_images", &media_images);
20283    ctx.insert("count_documents", &media_docs);
20284    ctx.insert("recent_edits", &recent_edits);
20285    ctx.insert("mine_locked", &mine_locked);
20286    ctx.insert("scheduled_rows", &scheduled_rows);
20287    ctx.insert("plugin_widgets", &plugin_widgets);
20288    render_with_csrf(&state, &headers, "rcms_admin/dashboard.html", &mut ctx)
20289}
20290
20291/// GET /cms-admin/styleguide — component gallery. Lists every registered block + every widget kind so
20292/// editors + reviewers can see the available palette at a glance.
20293pub async fn styleguide(
20294    State(state): State<super::AdminState>,
20295    tenant: Tenant,
20296    headers: HeaderMap,
20297    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20298) -> Result<Response, AdminError> {
20299    let mut ctx = Context::new();
20300    add_chrome(&mut ctx, &tenant, "styleguide", session_user.as_ref()).await;
20301    add_admin_theme(&mut ctx, tenant.pool()).await;
20302
20303    // Registered blocks — one row per registration. Author-curated
20304    // sample data lives in the template (the trait surface doesn't
20305    // require blocks to ship examples).
20306    let blocks: Vec<serde_json::Value> = crate::block::registered_blocks()
20307        .map(|b| {
20308            serde_json::json!({
20309                "type_name": b.type_name(),
20310                "verbose_name": b.verbose_name(),
20311                "icon": b.icon(),
20312                "group": b.group(),
20313                "field_count": b.fields().len(),
20314            })
20315        })
20316        .collect();
20317    ctx.insert("blocks", &blocks);
20318
20319    // Registered page types — second registry editors care about.
20320    let page_types: Vec<serde_json::Value> = crate::page_type::registered_handlers()
20321        .map(|h| {
20322            serde_json::json!({
20323                "type_name": h.type_name(),
20324                "verbose_name": h.verbose_name(),
20325                "icon": h.icon(),
20326                "description": h.description(),
20327            })
20328        })
20329        .collect();
20330    ctx.insert("page_types", &page_types);
20331
20332    // Library types.
20333    let library_types: Vec<serde_json::Value> = crate::library::registered_handlers()
20334        .map(|h| {
20335            serde_json::json!({
20336                "type_name": h.type_name(),
20337                "verbose_name": h.verbose_name(),
20338            })
20339        })
20340        .collect();
20341    ctx.insert("library_types", &library_types);
20342
20343    render_with_csrf(&state, &headers, "rcms_admin/styleguide.html", &mut ctx)
20344}
20345
20346pub async fn account_preferences(
20347    State(state): State<super::AdminState>,
20348    tenant: Tenant,
20349    headers: HeaderMap,
20350    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20351) -> Result<Response, AdminError> {
20352    render_account_page(&state, &tenant, &headers, session_user.as_ref(), None).await
20353}
20354
20355/// Serialize a user's MCP keys (+ per-key skill scope) and the tenant's
20356/// skill catalog for the key-management cards.
20357async fn mcp_keys_ctx(
20358    pool: &rustango::sql::Pool,
20359    owner_id: i64,
20360) -> (Vec<serde_json::Value>, Vec<serde_json::Value>) {
20361    use rustango::tenancy::{AgentGrant, AgentSkill};
20362
20363    let keys = rustango::tenancy::list_user_keys_pool(pool, owner_id)
20364        .await
20365        .unwrap_or_default();
20366    let skills: Vec<AgentSkill> = rustango::tenancy::list_skills_pool(pool)
20367        .await
20368        .unwrap_or_default();
20369    let skill_name = |sid: i64| -> Option<String> {
20370        skills
20371            .iter()
20372            .find(|s| s.id.get().copied() == Some(sid))
20373            .map(|s| s.codename.clone())
20374    };
20375    let mut rows = Vec::with_capacity(keys.len());
20376    for key in &keys {
20377        let key_id = key.id.get().copied().unwrap_or_default();
20378        let grants: Vec<AgentGrant> = AgentGrant::objects()
20379            .where_(AgentGrant::agent_id.eq(key_id))
20380            .fetch(pool)
20381            .await
20382            .unwrap_or_default();
20383        let scope: Vec<String> = grants
20384            .iter()
20385            .filter_map(|g| skill_name(g.skill_id))
20386            .collect();
20387        rows.push(serde_json::json!({
20388            "id": key_id,
20389            "label": key.data.get("label").and_then(|v| v.as_str()).unwrap_or(&key.name),
20390            "prefix": key.secret_prefix,
20391            "active": key.active,
20392            "created_at": key.created_at.get().map(|t| t.format("%Y-%m-%d %H:%M").to_string()),
20393            "scope": scope,
20394        }));
20395    }
20396    let skill_rows: Vec<serde_json::Value> = skills
20397        .iter()
20398        .map(|s| {
20399            serde_json::json!({
20400                "codename": s.codename,
20401                "name": s.name,
20402                "description": s.description,
20403            })
20404        })
20405        .collect();
20406    (rows, skill_rows)
20407}
20408
20409async fn render_account_page(
20410    state: &super::AdminState,
20411    tenant: &Tenant,
20412    headers: &HeaderMap,
20413    session_user: Option<&rustango::tenancy::auth::User>,
20414    mcp_one_time: Option<serde_json::Value>,
20415) -> Result<Response, AdminError> {
20416    // #202 — surface the current + pending email + mailer presence so
20417    // the Profile card can render the change-email form variant.
20418    let (current_email, pending_email, mailer_wired) = {
20419        let mailer = state.mailer.is_some();
20420        let user_data = session_user
20421            .map(|u| u.data.clone())
20422            .unwrap_or_else(|| serde_json::json!({}));
20423        let cur = session_user.map(user_email).unwrap_or_default();
20424        let pending = user_data
20425            .get("pending_email")
20426            .and_then(|v| v.as_str())
20427            .unwrap_or("")
20428            .to_owned();
20429        (cur, pending, mailer)
20430    };
20431    let mut ctx = Context::new();
20432    add_chrome(&mut ctx, tenant, "", session_user).await;
20433    add_admin_theme(&mut ctx, tenant.pool()).await;
20434    // #174 — admin theme picker lives in Preferences (was on
20435    // Settings). Surface every cms_theme row + its 4 marquee
20436    // colors for a swatch preview.
20437    let themes: Vec<crate::theme::Theme> = crate::theme::Theme::objects()
20438        .order_by(&[("name", false)])
20439        .fetch(tenant.pool())
20440        .await
20441        .unwrap_or_default();
20442    let theme_rows: Vec<serde_json::Value> = themes
20443        .iter()
20444        .map(|t| {
20445            serde_json::json!({
20446                "id": t.id.get().copied(),
20447                "name": t.name,
20448                "slug": t.slug,
20449                "is_admin_default": t.is_admin_default,
20450                "color_bg": t.color_bg,
20451                "color_surface": t.color_surface,
20452                "color_text_primary": t.color_text_primary,
20453                "color_link": t.color_link,
20454            })
20455        })
20456        .collect();
20457    ctx.insert("themes", &theme_rows);
20458    // #128 — plugin-contributed Account settings panels. Each panel is a pre-rendered HTML fragment hosts
20459    // contribute via `register_account_settings_panel!`.
20460    let account_panels: Vec<serde_json::Value> = crate::hooks::account_settings_panels()
20461        .into_iter()
20462        .map(|p| {
20463            serde_json::json!({
20464                "key": p.key,
20465                "label": p.label,
20466                "icon": p.icon,
20467                "html": p.html,
20468            })
20469        })
20470        .collect();
20471    ctx.insert("account_panels", &account_panels);
20472
20473    // #197 — per-user notification preferences. We pass every kind
20474    // through with its current toggle state so the template renders
20475    // checked/unchecked without a second fetch. Missing rows default
20476    // to true (opt-out semantics).
20477    let pref_map = session_user
20478        .and_then(|u| u.id.get().copied())
20479        .map(|uid| crate::notification_pref::map_for_user(tenant.pool(), uid))
20480        .map(|fut| async move { fut.await.unwrap_or_default() });
20481    let pref_lookup: std::collections::HashMap<String, bool> = match pref_map {
20482        Some(f) => f.await,
20483        None => std::collections::HashMap::new(),
20484    };
20485    let notification_rows: Vec<serde_json::Value> = crate::notification_pref::ALL_KINDS
20486        .iter()
20487        .map(|(label, kind, hint)| {
20488            let enabled = pref_lookup.get(*kind).copied().unwrap_or(true);
20489            serde_json::json!({
20490                "label": label,
20491                "kind": kind,
20492                "hint": hint,
20493                "enabled": enabled,
20494            })
20495        })
20496        .collect();
20497    ctx.insert("notification_prefs", &notification_rows);
20498
20499    ctx.insert("account_email", &current_email);
20500    ctx.insert("account_pending_email", &pending_email);
20501    ctx.insert("account_mailer_wired", &mailer_wired);
20502
20503    // #587 — MCP keys card: the viewer's keys + the skill catalog for
20504    // the optional-scope picker; `mcp_one_time` carries a just-minted
20505    // token for the show-once dialog.
20506    if let Some(uid) = session_user.and_then(|u| u.id.get().copied()) {
20507        let (keys, skills) = mcp_keys_ctx(tenant.pool(), uid).await;
20508        ctx.insert("mcp_keys", &keys);
20509        ctx.insert("mcp_skills", &skills);
20510    }
20511    if let Some(one_time) = &mcp_one_time {
20512        ctx.insert("mcp_one_time", one_time);
20513    }
20514
20515    render_with_csrf(
20516        state,
20517        headers,
20518        "rcms_admin/account_preferences.html",
20519        &mut ctx,
20520    )
20521}
20522
20523/// POST /cms-admin/me/notifications — save the on/off toggles for
20524/// every notification kind. The form posts a checkbox per kind;
20525/// absent inputs mean "off". Iterates every known kind so the user
20526/// can disable categories from a single submit.
20527pub async fn account_notifications_submit(
20528    State(_state): State<super::AdminState>,
20529    tenant: Tenant,
20530    headers: HeaderMap,
20531    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20532    Form(form): Form<std::collections::HashMap<String, String>>,
20533) -> Result<Response, AdminError> {
20534    let Some(viewer) = session_user.as_ref() else {
20535        return Ok(unauthorized_no_session());
20536    };
20537    let Some(uid) = viewer.id.get().copied() else {
20538        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20539    };
20540    for (_label, kind, _hint) in crate::notification_pref::ALL_KINDS {
20541        let key = format!("kind_{kind}");
20542        let enabled = form
20543            .get(&key)
20544            .map(|v| matches!(v.as_str(), "on" | "true" | "1" | "yes"))
20545            .unwrap_or(false);
20546        crate::notification_pref::set_enabled(tenant.pool(), uid, kind, enabled).await?;
20547    }
20548    redirect_named_with_params_and_message(
20549        "rcms-admin:account",
20550        &[],
20551        MsgLevel::Success,
20552        "Notification preferences saved.",
20553        &headers,
20554    )
20555}
20556
20557/// POST /cms-admin/me/profile — display name + avatar upload.
20558/// Multipart submit; absence of either field leaves the existing
20559/// value untouched. Avatar bytes land at
20560/// `./var/avatars/<tenant-slug>/<user_id>.<ext>` (slug-namespaced so
20561/// per-tenant user ids don't collide) and the filename is recorded in
20562/// `rustango_users.data.avatar_path`.
20563pub async fn account_profile_submit(
20564    State(_state): State<super::AdminState>,
20565    tenant: Tenant,
20566    headers: HeaderMap,
20567    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20568    mut multipart: axum::extract::Multipart,
20569) -> Result<Response, AdminError> {
20570    let Some(viewer) = session_user.as_ref() else {
20571        return Ok(unauthorized_no_session());
20572    };
20573    let Some(uid) = viewer.id.get().copied() else {
20574        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20575    };
20576
20577    let mut new_display_name: Option<String> = None;
20578    let mut new_avatar_path: Option<String> = None;
20579    // Namespace avatars by tenant slug. Per-tenant DBs each start user
20580    // ids at 1, so a flat `./var/avatars/{uid}.{ext}` collided across
20581    // tenants (tenant B's user #1 overwriting / exposing tenant A's).
20582    let avatar_dir = std::path::PathBuf::from("./var/avatars").join(&tenant.org.slug);
20583
20584    while let Some(field) = multipart
20585        .next_field()
20586        .await
20587        .map_err(|e| AdminError::Upload(format!("multipart parse: {e}")))?
20588    {
20589        let field_name = field.name().unwrap_or("").to_owned();
20590        match field_name.as_str() {
20591            "display_name" => {
20592                new_display_name = Some(
20593                    field
20594                        .text()
20595                        .await
20596                        .map_err(|e| AdminError::Upload(format!("read display_name: {e}")))?
20597                        .trim()
20598                        .to_owned(),
20599                );
20600            }
20601            "avatar" => {
20602                let original = field.file_name().map(|s| s.to_owned());
20603                let bytes = field
20604                    .bytes()
20605                    .await
20606                    .map_err(|e| AdminError::Upload(format!("read avatar: {e}")))?;
20607                if bytes.is_empty() {
20608                    continue;
20609                }
20610                let ext = original
20611                    .as_deref()
20612                    .and_then(|n| n.rsplit_once('.'))
20613                    .map(|(_, ext)| ext)
20614                    .filter(|ext| ext.len() <= 8 && ext.chars().all(|c| c.is_ascii_alphanumeric()))
20615                    .map(str::to_ascii_lowercase)
20616                    .unwrap_or_else(|| "png".to_owned());
20617                std::fs::create_dir_all(&avatar_dir)
20618                    .map_err(|e| AdminError::Upload(format!("create avatar dir: {e}")))?;
20619                let storage_name = format!("{uid}.{ext}");
20620                let path = avatar_dir.join(&storage_name);
20621                std::fs::write(&path, &bytes)
20622                    .map_err(|e| AdminError::Upload(format!("write avatar: {e}")))?;
20623                new_avatar_path = Some(storage_name);
20624            }
20625            _ => {
20626                let _ = field.bytes().await;
20627            }
20628        }
20629    }
20630
20631    // Reload the user row + merge changes into `.data`. Using the
20632    // pool fetch (rather than mutating the extracted `viewer`) keeps
20633    // the save isolated from any session-cache invariants.
20634    let mut user_rows: Vec<rustango::tenancy::auth::User> =
20635        rustango::tenancy::auth::User::objects()
20636            .where_(rustango::tenancy::auth::User::id.eq(uid))
20637            .fetch(tenant.pool())
20638            .await?;
20639    let Some(mut user) = user_rows.pop() else {
20640        return Ok((axum::http::StatusCode::NOT_FOUND, "user not found").into_response());
20641    };
20642
20643    let mut data = user.data.as_object().cloned().unwrap_or_default();
20644    if let Some(name) = new_display_name {
20645        if name.is_empty() {
20646            data.remove("display_name");
20647        } else {
20648            data.insert("display_name".to_owned(), serde_json::json!(name));
20649        }
20650    }
20651    if let Some(path) = new_avatar_path {
20652        data.insert("avatar_path".to_owned(), serde_json::json!(path));
20653    }
20654    user.data = serde_json::Value::Object(data);
20655    user.save_pool(tenant.pool()).await?;
20656
20657    redirect_named_with_message(
20658        "rcms-admin:account",
20659        MsgLevel::Success,
20660        "Profile saved.",
20661        &headers,
20662    )
20663}
20664
20665/// Persist an editor's preferred admin UI locale to
20666/// `rustango_users.data.admin_lang`. Shared by the account-prefs form and
20667/// the sidebar switcher so both keep the durable pref in sync with the cookie.
20668async fn persist_user_admin_lang(
20669    pool: &rustango::sql::Pool,
20670    uid: i64,
20671    lang: &str,
20672) -> Result<(), AdminError> {
20673    let mut rows: Vec<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
20674        .where_(rustango::tenancy::auth::User::id.eq(uid))
20675        .fetch(pool)
20676        .await?;
20677    if let Some(mut user) = rows.pop() {
20678        let mut data = user.data.as_object().cloned().unwrap_or_default();
20679        data.insert("admin_lang".to_owned(), serde_json::json!(lang));
20680        user.data = serde_json::Value::Object(data);
20681        user.save_pool(pool).await?;
20682    }
20683    Ok(())
20684}
20685
20686/// Form body for `POST /cms-admin/me/language`.
20687#[derive(Debug, Deserialize)]
20688pub struct AccountLanguageForm {
20689    pub lang: String,
20690}
20691
20692/// POST /cms-admin/me/language — set the editor's preferred admin UI locale.
20693/// Persists to `rustango_users.data.admin_lang` (durable + cross-device,
20694/// folded into negotiation by `add_user_chrome` → `render_with_csrf`) AND sets
20695/// the sticky `rcms_admin_lang` cookie so the change applies on the next render.
20696/// An unshipped code resets to English.
20697pub async fn account_language_submit(
20698    State(_state): State<super::AdminState>,
20699    tenant: Tenant,
20700    headers: HeaderMap,
20701    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20702    Form(form): Form<AccountLanguageForm>,
20703) -> Result<Response, AdminError> {
20704    let Some(viewer) = session_user.as_ref() else {
20705        return Ok(unauthorized_no_session());
20706    };
20707    let Some(uid) = viewer.id.get().copied() else {
20708        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20709    };
20710    let lang = if super::i18n::is_ui_locale(&form.lang) {
20711        form.lang.clone()
20712    } else {
20713        "en".to_owned()
20714    };
20715    persist_user_admin_lang(tenant.pool(), uid, &lang).await?;
20716
20717    let mut resp = redirect_named_with_message(
20718        "rcms-admin:account",
20719        MsgLevel::Success,
20720        "Language updated.",
20721        &headers,
20722    )?;
20723    let cookie = format!(
20724        "{}={lang}; Path=/; SameSite=Lax; Max-Age=31536000",
20725        super::i18n::ADMIN_LANG_COOKIE
20726    );
20727    if let Ok(v) = HeaderValue::from_str(&cookie) {
20728        resp.headers_mut().append(header::SET_COOKIE, v);
20729    }
20730    Ok(resp)
20731}
20732
20733/// Form body for `POST /cms-admin/me/email`.
20734#[derive(Debug, Deserialize)]
20735pub struct AccountEmailForm {
20736    pub new_email: String,
20737}
20738
20739/// POST /cms-admin/me/email — request an email change.
20740///
20741/// When a mailer is wired, the change goes through a confirmation
20742/// flow: a random 32-hex token is stashed on `user.data.pending_email_*`
20743/// and the new address receives a confirm link. Clicking the link
20744/// finalizes the change.
20745///
20746/// When no mailer is wired, the change applies immediately + a banner
20747/// explains no confirmation email was sent.
20748pub async fn account_email_submit(
20749    State(state): State<super::AdminState>,
20750    tenant: Tenant,
20751    headers: HeaderMap,
20752    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20753    Form(form): Form<AccountEmailForm>,
20754) -> Result<Response, AdminError> {
20755    let Some(viewer) = session_user.as_ref() else {
20756        return Ok(unauthorized_no_session());
20757    };
20758    let Some(uid) = viewer.id.get().copied() else {
20759        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20760    };
20761
20762    let new_email = form.new_email.trim().to_owned();
20763    if new_email.is_empty() || !new_email.contains('@') {
20764        return redirect_named_with_message(
20765            "rcms-admin:account",
20766            MsgLevel::Error,
20767            "Enter a valid email address.",
20768            &headers,
20769        );
20770    }
20771
20772    let mut user = rustango::tenancy::auth::User::objects()
20773        .where_(rustango::tenancy::auth::User::id.eq(uid))
20774        .first(tenant.pool())
20775        .await?
20776        .ok_or(AdminError::NotFound(uid))?;
20777    let mut data = user.data.as_object().cloned().unwrap_or_default();
20778
20779    if state.mailer.is_none() {
20780        // No mailer → write directly + banner.
20781        data.insert("email".to_owned(), serde_json::json!(new_email));
20782        user.email = Some(new_email.clone());
20783        // Clear any in-flight confirmation token from a previous attempt.
20784        data.remove("pending_email");
20785        user.data = serde_json::Value::Object(data);
20786        user.save_pool(tenant.pool()).await?;
20787        return redirect_named_with_message(
20788            "rcms-admin:account",
20789            MsgLevel::Warning,
20790            "Email updated. No confirmation email was sent — the host hasn't wired a mailer.",
20791            &headers,
20792        );
20793    }
20794
20795    // Stash the pending email so the editor sees a banner + the
20796    // confirm handler can replay-guard against a different change
20797    // having kicked off in the meantime. Drop legacy keys from the
20798    // previous hand-rolled token scheme so they don't shadow the
20799    // new flow.
20800    data.insert(
20801        "pending_email".to_owned(),
20802        serde_json::json!(new_email.clone()),
20803    );
20804    data.remove("pending_email_token");
20805    data.remove("pending_email_expires_at");
20806    user.data = serde_json::Value::Object(data);
20807    user.save_pool(tenant.pool()).await?;
20808
20809    // Send the confirmation. Best-effort. The signed URL carries
20810    // user_id + email + TTL — `EmailVerification::verify` on the
20811    // confirm endpoint replaces the hand-rolled (token, expires_at)
20812    // round-trip we used to stash in user.data.
20813    if let Some(mailer) = state.mailer.as_deref() {
20814        let link = rustango::auth_flows::EmailVerification::issue(
20815            "/cms-admin/me/email/confirm",
20816            uid,
20817            &new_email,
20818            state.signing_secret.as_slice(),
20819            std::time::Duration::from_secs(3600),
20820        );
20821        let subject = "Confirm your CMS email change";
20822        let body = format!(
20823            "Click the link below to confirm your CMS email change to {new_email}.\n\nLink: {link}\n\nThe link expires in one hour. If you didn't request this change, ignore this email.\n",
20824        );
20825        let email = rustango::email::Email::new()
20826            .from((*state.mailer_from).clone())
20827            .to(new_email.clone())
20828            .subject(subject.to_owned())
20829            .body(body);
20830        if let Err(e) = mailer.send(&email).await {
20831            tracing::warn!(
20832                target: "rustango_cms::admin::account",
20833                user_id = uid, error = %e,
20834                "email-change confirmation send failed (pending_email stashed; user can re-request)"
20835            );
20836        }
20837    }
20838
20839    redirect_named_with_message(
20840        "rcms-admin:account",
20841        MsgLevel::Success,
20842        "Confirmation link sent to the new email. Click it within an hour to finalize the change.",
20843        &headers,
20844    )
20845}
20846
20847/// GET /cms-admin/me/email/confirm — verify the signed URL from
20848/// [`account_email_submit`] (`EmailVerification::verify`) and apply
20849/// the pending email change. The URL itself carries user_id + new
20850/// email + TTL signature — we just check the click came from the
20851/// account that started the change and that the change is still
20852/// the one the user wants to apply.
20853pub async fn account_email_confirm(
20854    State(state): State<super::AdminState>,
20855    tenant: Tenant,
20856    headers: HeaderMap,
20857    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20858    axum::extract::OriginalUri(uri): axum::extract::OriginalUri,
20859) -> Result<Response, AdminError> {
20860    let Some(viewer) = session_user.as_ref() else {
20861        return Ok(unauthorized_no_session());
20862    };
20863    let Some(uid) = viewer.id.get().copied() else {
20864        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20865    };
20866
20867    let path_and_query = uri
20868        .path_and_query()
20869        .map(|p| p.as_str())
20870        .unwrap_or_default()
20871        .to_owned();
20872    let (token_uid, signed_email) = match rustango::auth_flows::EmailVerification::verify(
20873        &path_and_query,
20874        state.signing_secret.as_slice(),
20875    ) {
20876        Ok(pair) => pair,
20877        Err(_) => {
20878            return redirect_named_with_message(
20879                "rcms-admin:account",
20880                MsgLevel::Error,
20881                "Confirmation link is invalid or has expired. Request a new one.",
20882                &headers,
20883            );
20884        }
20885    };
20886    // Clicking your own confirm link from a different session is a
20887    // common case (verify from inbox on phone, signed in on
20888    // desktop). We require the session user to match the user_id
20889    // baked into the signed URL — anything else is a cross-account
20890    // hijack attempt.
20891    if token_uid != uid {
20892        return redirect_named_with_message(
20893            "rcms-admin:account",
20894            MsgLevel::Error,
20895            "Confirmation link belongs to a different account. Sign in as that account to confirm.",
20896            &headers,
20897        );
20898    }
20899
20900    let mut user = rustango::tenancy::auth::User::objects()
20901        .where_(rustango::tenancy::auth::User::id.eq(uid))
20902        .first(tenant.pool())
20903        .await?
20904        .ok_or(AdminError::NotFound(uid))?;
20905    let mut data = user.data.as_object().cloned().unwrap_or_default();
20906    // Stale-link guard: if the user kicked off a different change
20907    // since this link was minted (or none at all), reject — the
20908    // signed URL is still valid but no longer the one they want.
20909    let pending = data
20910        .get("pending_email")
20911        .and_then(|v| v.as_str())
20912        .unwrap_or("");
20913    if pending != signed_email {
20914        return redirect_named_with_message(
20915            "rcms-admin:account",
20916            MsgLevel::Error,
20917            "This link is for a different email change than the one currently pending. Request a fresh confirmation.",
20918            &headers,
20919        );
20920    }
20921
20922    data.insert("email".to_owned(), serde_json::json!(signed_email));
20923    user.email = Some(signed_email.clone());
20924    data.remove("pending_email");
20925    // Keys the earlier email-change flow stored — dropped on confirm so
20926    // old rows clean themselves up.
20927    data.remove("pending_email_token");
20928    data.remove("pending_email_expires_at");
20929    user.data = serde_json::Value::Object(data);
20930    user.save_pool(tenant.pool()).await?;
20931
20932    redirect_named_with_message(
20933        "rcms-admin:account",
20934        MsgLevel::Success,
20935        "Email confirmed. Notifications go to the new address from now on.",
20936        &headers,
20937    )
20938}
20939
20940/// Form body for `POST /cms-admin/me/password`.
20941#[derive(Deserialize)]
20942pub struct AccountPasswordForm {
20943    pub current_password: String,
20944    pub new_password: String,
20945    pub new_password_confirm: String,
20946}
20947
20948/// POST /cms-admin/me/password — verify current password, hash + write
20949/// the new one.
20950pub async fn account_password_submit(
20951    State(_state): State<super::AdminState>,
20952    tenant: Tenant,
20953    headers: HeaderMap,
20954    rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
20955    Form(form): Form<AccountPasswordForm>,
20956) -> Result<Response, AdminError> {
20957    let Some(viewer) = session_user.as_ref() else {
20958        return Ok(unauthorized_no_session());
20959    };
20960    let Some(uid) = viewer.id.get().copied() else {
20961        return Ok((axum::http::StatusCode::UNAUTHORIZED, "no user id").into_response());
20962    };
20963    if form.new_password.len() < 12 {
20964        return redirect_named_with_message(
20965            "rcms-admin:account",
20966            MsgLevel::Error,
20967            "New password must be at least 12 characters.",
20968            &headers,
20969        );
20970    }
20971    if form.new_password != form.new_password_confirm {
20972        return redirect_named_with_message(
20973            "rcms-admin:account",
20974            MsgLevel::Error,
20975            "New password and confirmation don't match.",
20976            &headers,
20977        );
20978    }
20979
20980    let mut user = rustango::tenancy::auth::User::objects()
20981        .where_(rustango::tenancy::auth::User::id.eq(uid))
20982        .first(tenant.pool())
20983        .await?
20984        .ok_or(AdminError::NotFound(uid))?;
20985
20986    let verified =
20987        crate::passwords::verify(&form.current_password, &user.password_hash).await.unwrap_or(false);
20988    if !verified {
20989        return redirect_named_with_message(
20990            "rcms-admin:account",
20991            MsgLevel::Error,
20992            "Current password is incorrect.",
20993            &headers,
20994        );
20995    }
20996    let hash = crate::passwords::hash(&form.new_password).await
20997        .map_err(|e| AdminError::Validation(format!("password hash failed: {e}")))?;
20998    user.password_hash = hash;
20999    user.password_changed_at = Some(chrono::Utc::now());
21000    user.save_pool(tenant.pool()).await?;
21001
21002    redirect_named_with_message(
21003        "rcms-admin:account",
21004        MsgLevel::Success,
21005        "Password changed. Old sessions on other devices will be signed out on next request.",
21006        &headers,
21007    )
21008}
21009
21010/// GET /__cms-avatar/{user_id} — stream the user's avatar bytes.
21011/// Anonymous-OK so the sidebar avatar shows on the dashboard
21012/// pre-login. Image not found → 404.
21013pub async fn account_avatar_serve(
21014    headers: HeaderMap,
21015    tenant: Tenant,
21016    Path(user_id): Path<i64>,
21017) -> Response {
21018    let user_rows: Vec<rustango::tenancy::auth::User> =
21019        match rustango::tenancy::auth::User::objects()
21020            .where_(rustango::tenancy::auth::User::id.eq(user_id))
21021            .fetch(tenant.pool())
21022            .await
21023        {
21024            Ok(v) => v,
21025            Err(_) => {
21026                return (
21027                    axum::http::StatusCode::INTERNAL_SERVER_ERROR,
21028                    "user lookup failed",
21029                )
21030                    .into_response();
21031            }
21032        };
21033    let Some(user) = user_rows.into_iter().next() else {
21034        return (axum::http::StatusCode::NOT_FOUND, "user not found").into_response();
21035    };
21036    let storage_name = match user.data.get("avatar_path").and_then(|v| v.as_str()) {
21037        Some(s) if !s.is_empty() => s.to_owned(),
21038        _ => return (axum::http::StatusCode::NOT_FOUND, "no avatar").into_response(),
21039    };
21040    if storage_name.contains('/') || storage_name.contains("..") {
21041        return (axum::http::StatusCode::BAD_REQUEST, "invalid storage name").into_response();
21042    }
21043    // Tenant-scoped path (matches the upload) — never read another
21044    // tenant's avatar dir.
21045    let path = std::path::PathBuf::from("./var/avatars")
21046        .join(&tenant.org.slug)
21047        .join(&storage_name);
21048    let bytes = match std::fs::read(&path) {
21049        Ok(b) => b,
21050        Err(_) => {
21051            return (axum::http::StatusCode::NOT_FOUND, "avatar bytes missing").into_response()
21052        }
21053    };
21054    let mime = mime_guess::from_path(&storage_name)
21055        .first_or_octet_stream()
21056        .essence_str()
21057        .to_owned();
21058    // Same stable-URL staleness fix as branding: revalidate via a
21059    // content ETag so a changed avatar is picked up immediately.
21060    revalidated_asset(&headers, mime, bytes)
21061}
21062
21063pub async fn cms_login_form(
21064    State(state): State<super::AdminState>,
21065    headers: HeaderMap,
21066    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21067    tenant: Tenant,
21068    Query(q): Query<std::collections::HashMap<String, String>>,
21069) -> Result<Response, AdminError> {
21070    let mut ctx = Context::new();
21071    // The framework's POST handler expects to receive the form at
21072    // `/login`. Set the action to a relative URL so the same shape
21073    // works under reverse proxies.
21074    ctx.insert("action", &"/login");
21075    ctx.insert("admin_title", &"CMS Admin");
21076    // #279 — make sure the CMS-branded login form always carries a
21077    // `next` destination so the framework's POST handler doesn't
21078    // fall back to `/` (the public homepage). Precedence:
21079    //   1. Explicit `?next=` (passed in by `with_login_required`
21080    //      when an anonymous request hit an admin URL).
21081    //   2. Default `/cms-admin/` when the user navigated to /login
21082    //      manually — they almost certainly want the admin, not
21083    //      the public site root.
21084    // The framework's `sanitize_next` rejects open-redirect-shaped
21085    // values (anything not starting with a single `/`, scheme-bearing,
21086    // or pointing back at /login itself), so we don't need to filter
21087    // here; the worst case is the framework strips ours and uses `/`.
21088    let next = q
21089        .get("next")
21090        .map(String::as_str)
21091        .filter(|s| !s.is_empty())
21092        .unwrap_or("/cms-admin/");
21093    ctx.insert("next", next);
21094    // Friendly error from a redirect (e.g. `?error=invalid_credentials`).
21095    if let Some(err) = q.get("error") {
21096        ctx.insert("error", err);
21097    }
21098    // SSO (admin-sso) — one "Sign in with <provider>" button per enabled
21099    // `SsoProvider` row (the DB-backed, admin-managed, multi-provider model
21100    // that replaced the flat `Org.sso_*` columns). The framework serves
21101    // `/login/sso/{slug}` + `/login/sso/{slug}/callback` (mints the same
21102    // rustango_tenant_session cookie password login does), so no auth code
21103    // lives here — just the buttons. Mirrors the framework's own login context.
21104    let sso_providers = rustango::admin::sso_provider::list_enabled(tenant.pool(), "/login").await;
21105    ctx.insert("sso_enabled", &!sso_providers.is_empty());
21106    ctx.insert("sso_providers", &sso_providers);
21107    // Surface the callback's failure reason (it redirects with `?sso_error=...`).
21108    if let Some(err) = q.get("sso_error") {
21109        ctx.insert("sso_error", err);
21110    }
21111    // #199 — show the tenant's uploaded logo/favicon in the login brand badge
21112    // (falls back to the default icon when none is set). Same source as the
21113    // authenticated sidebar; the `/__cms-branding/*` routes are pre-auth.
21114    add_branding_urls(&mut ctx, &tenant).await;
21115    render_with_csrf(&state, &headers, "login.html", &mut ctx)
21116}
21117
21118/// GET `/cms-admin/password-reset` — show the username form.
21119pub async fn password_reset_request_form(
21120    State(state): State<super::AdminState>,
21121    headers: HeaderMap,
21122    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21123) -> Result<Response, AdminError> {
21124    let mut ctx = Context::new();
21125    render_with_csrf(
21126        &state,
21127        &headers,
21128        "rcms_admin/password_reset_request.html",
21129        &mut ctx,
21130    )
21131}
21132
21133/// POST `/cms-admin/password-reset` — issue a token, email the link,
21134/// render the "check your email" page either way (so the form never
21135/// confirms or denies account existence).
21136/// The key a password-reset link is signed with: the process secret
21137/// narrowed to one tenant and one password.
21138///
21139/// Tenants number their users from 1, so a link signed with the process
21140/// secret alone — which names only `user_id` — resets the same id on every
21141/// tenant. Binding the tenant slug makes a link verify only where it was
21142/// issued; binding the current password hash makes it die the moment the
21143/// password changes, so it is single-use without any cache.
21144fn password_reset_key(secret: &[u8], tenant_slug: &str, password_hash: &str) -> Vec<u8> {
21145    let msg = format!("rcms-password-reset\0{tenant_slug}\0{password_hash}");
21146    crate::signing::hmac_sha256_hex(secret, msg.as_bytes()).into_bytes()
21147}
21148
21149/// The active user a reset link was issued for, in this request's tenant.
21150///
21151/// The `user_id` in the link is read before it is trusted only to find
21152/// whose key to verify against; the link is accepted solely when it
21153/// verifies under that user's tenant- and password-bound key.
21154async fn password_reset_user(
21155    tenant: &Tenant,
21156    secret: &[u8],
21157    signed_url: &str,
21158) -> Option<rustango::tenancy::auth::User> {
21159    let claimed: i64 = signed_url
21160        .split_once('?')?
21161        .1
21162        .split('&')
21163        .find_map(|kv| kv.strip_prefix("user_id="))?
21164        .parse()
21165        .ok()?;
21166    let user = rustango::tenancy::auth::User::objects()
21167        .where_(rustango::tenancy::auth::User::id.eq(claimed))
21168        .where_(rustango::tenancy::auth::User::active.eq(true))
21169        .first(tenant.pool())
21170        .await
21171        .ok()??;
21172    let key = password_reset_key(secret, &tenant.org.slug, &user.password_hash);
21173    match rustango::auth_flows::PasswordReset::verify(signed_url, &key) {
21174        Ok(uid) if uid == claimed => Some(user),
21175        _ => None,
21176    }
21177}
21178
21179pub async fn password_reset_request_submit(
21180    State(state): State<super::AdminState>,
21181    tenant: Tenant,
21182    headers: HeaderMap,
21183    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21184    Form(form): Form<std::collections::HashMap<String, String>>,
21185) -> Result<Response, AdminError> {
21186    let username = form.get("username").cloned().unwrap_or_default();
21187    if !username.trim().is_empty() {
21188        // Look up the rustango_users row by username. Active users
21189        // only; soft-disabled accounts get the same silent treatment
21190        // as missing ones.
21191        let user: Option<rustango::tenancy::auth::User> = rustango::tenancy::auth::User::objects()
21192            .where_(rustango::tenancy::auth::User::username.eq(username.clone()))
21193            .where_(rustango::tenancy::auth::User::active.eq(true))
21194            .fetch(tenant.pool())
21195            .await
21196            .unwrap_or_default()
21197            .into_iter()
21198            .next();
21199        if let Some(u) = user {
21200            let user_id = u.id.get().copied().unwrap_or(0);
21201            // #435 — the reset link goes to the user's real address.
21202            // No email on file → nothing to send; the response below
21203            // still renders "sent" so the form never confirms or
21204            // denies account existence.
21205            let to_email = Some(user_email(&u)).filter(|e| !e.is_empty());
21206            match to_email {
21207                Some(to) => {
21208                    // Sign a relative URL — the verify-side recomputes
21209                    // against the request path+query (no host involved).
21210                    let key = password_reset_key(
21211                        state.signing_secret.as_slice(),
21212                        &tenant.org.slug,
21213                        &u.password_hash,
21214                    );
21215                    let token_url = rustango::auth_flows::PasswordReset::issue(
21216                        "/cms-admin/password-reset/confirm",
21217                        user_id,
21218                        &key,
21219                        std::time::Duration::from_secs(3600),
21220                    );
21221                    send_reset_email(
21222                        state.mailer.as_deref(),
21223                        &state.mailer_from,
21224                        &to,
21225                        &u.username,
21226                        &token_url,
21227                    )
21228                    .await;
21229                }
21230                None => {
21231                    tracing::info!(
21232                        username = %u.username,
21233                        "password reset requested but the account has no email on file; nothing sent"
21234                    );
21235                }
21236            }
21237        }
21238    }
21239    let mut ctx = Context::new();
21240    render_with_csrf(
21241        &state,
21242        &headers,
21243        "rcms_admin/password_reset_sent.html",
21244        &mut ctx,
21245    )
21246}
21247
21248/// GET `/cms-admin/password-reset/confirm` — verify the signed token
21249/// in the URL, render the new-password form when valid. Invalid /
21250/// expired links land on a friendly error inside the same template.
21251pub async fn password_reset_confirm_form(
21252    State(state): State<super::AdminState>,
21253    tenant: Tenant,
21254    headers: HeaderMap,
21255    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21256    axum::extract::OriginalUri(uri): axum::extract::OriginalUri,
21257) -> Result<Response, AdminError> {
21258    let path_and_query = uri
21259        .path_and_query()
21260        .map(|p| p.as_str())
21261        .unwrap_or_default()
21262        .to_owned();
21263    let mut ctx = Context::new();
21264    match password_reset_user(&tenant, state.signing_secret.as_slice(), &path_and_query).await {
21265        Some(_) => {
21266            // Pass the signed URL through so the POST handler can
21267            // re-verify before writing the new password.
21268            ctx.insert("signed_token", &path_and_query);
21269            render_with_csrf(
21270                &state,
21271                &headers,
21272                "rcms_admin/password_reset_confirm.html",
21273                &mut ctx,
21274            )
21275        }
21276        None => {
21277            ctx.insert(
21278                "error",
21279                &"This reset link is invalid or has expired. Request a fresh one.",
21280            );
21281            render_with_csrf(
21282                &state,
21283                &headers,
21284                "rcms_admin/password_reset_request.html",
21285                &mut ctx,
21286            )
21287        }
21288    }
21289}
21290
21291/// POST `/cms-admin/password-reset/confirm` — verify the token + new
21292/// password fields, hash the password, write to `rustango_users`,
21293/// render the "all set" page.
21294pub async fn password_reset_confirm_submit(
21295    State(state): State<super::AdminState>,
21296    tenant: Tenant,
21297    headers: HeaderMap,
21298    rustango::extractors::SessionUser(_session_user): rustango::extractors::SessionUser,
21299    Form(form): Form<std::collections::HashMap<String, String>>,
21300) -> Result<Response, AdminError> {
21301    let token = form.get("token").cloned().unwrap_or_default();
21302    let password = form.get("password").cloned().unwrap_or_default();
21303    let password_confirm = form.get("password_confirm").cloned().unwrap_or_default();
21304
21305    let mut ctx = Context::new();
21306    let render_confirm_with_error = |state: &super::AdminState,
21307                                     headers: &HeaderMap,
21308                                     token: &str,
21309                                     msg: &str|
21310     -> Result<Response, AdminError> {
21311        let mut c = Context::new();
21312        c.insert("signed_token", &token);
21313        c.insert("error", &msg);
21314        render_with_csrf(
21315            state,
21316            headers,
21317            "rcms_admin/password_reset_confirm.html",
21318            &mut c,
21319        )
21320    };
21321
21322    if password.len() < 12 {
21323        return render_confirm_with_error(
21324            &state,
21325            &headers,
21326            &token,
21327            "Password must be at least 12 characters.",
21328        );
21329    }
21330    if password != password_confirm {
21331        return render_confirm_with_error(
21332            &state,
21333            &headers,
21334            &token,
21335            "Password confirmation didn't match.",
21336        );
21337    }
21338
21339    // Tenant- and password-bound (#673): a link from another tenant, or one
21340    // already used to change this password, does not verify.
21341    let Some(mut user) = password_reset_user(&tenant, state.signing_secret.as_slice(), &token).await
21342    else {
21343        ctx.insert(
21344            "error",
21345            &"This reset link is invalid or has expired. Request a fresh one.",
21346        );
21347        return render_with_csrf(
21348            &state,
21349            &headers,
21350            "rcms_admin/password_reset_request.html",
21351            &mut ctx,
21352        );
21353    };
21354    let new_hash = match crate::passwords::hash(&password).await {
21355        Ok(h) => h,
21356        Err(e) => {
21357            tracing::warn!(error = %e, "password hash failed");
21358            return render_confirm_with_error(
21359                &state,
21360                &headers,
21361                &token,
21362                "Could not save the new password. Try again.",
21363            );
21364        }
21365    };
21366    user.password_hash = new_hash;
21367    if user.save_pool(tenant.pool()).await.is_err() {
21368        return render_confirm_with_error(
21369            &state,
21370            &headers,
21371            &token,
21372            "Could not save the new password. Try again.",
21373        );
21374    }
21375
21376    render_with_csrf(
21377        &state,
21378        &headers,
21379        "rcms_admin/password_reset_done.html",
21380        &mut ctx,
21381    )
21382}
21383
21384/// Send the reset email via `ConsoleMailer`. Prints the URL to stdout
21385/// in dev; production deployments swap in `SmtpMailer` here.
21386///
21387/// The `rustango_users` table doesn't carry an email column, so the
21388/// "to" address is synthesized from the username for now. Replace
21389/// with `user.email` once the host extends the user model.
21390/// Deliver the reset link to the user's real address through
21391/// the host-configured mailer (`router_with_mailer`), falling back to
21392/// the console mailer in dev setups with no mailer wired.
21393async fn send_reset_email(
21394    mailer: Option<&dyn rustango::email::Mailer>,
21395    mailer_from: &str,
21396    to_email: &str,
21397    username: &str,
21398    reset_url: &str,
21399) {
21400    let from = if mailer_from.trim().is_empty() {
21401        "noreply@cms.local"
21402    } else {
21403        mailer_from
21404    };
21405    let email = rustango::email::Email::new()
21406        .to(to_email)
21407        .from(from)
21408        .subject("Reset your CMS password")
21409        .body(format!(
21410            "Hi {username},\n\n\
21411             We received a request to reset your CMS password.\n\
21412             Click the link below within the next hour to set a new one:\n\n\
21413             {reset_url}\n\n\
21414             If you didn't request this, you can safely ignore this email.\n"
21415        ));
21416    let result = match mailer {
21417        Some(m) => m.send(&email).await,
21418        None => {
21419            let console = rustango::email::ConsoleMailer;
21420            <rustango::email::ConsoleMailer as rustango::email::Mailer>::send(&console, &email)
21421                .await
21422        }
21423    };
21424    if let Err(e) = result {
21425        tracing::warn!(error = %e, username = %username, "password-reset mail send failed");
21426    }
21427    tracing::info!(username = %username, "issued password-reset link");
21428}
21429
21430#[cfg(test)]
21431mod tests {
21432    //! Role-permission matrix translation tests. Exercise the
21433    //! pure helpers — no DB, no Tera.
21434    use super::*;
21435
21436    #[test]
21437    fn parse_matrix_form_translates_brackets_to_codenames() {
21438        let mut form = std::collections::HashMap::new();
21439        form.insert("name".to_owned(), "Editor".to_owned());
21440        form.insert("perm[pages][view]".to_owned(), "1".to_owned());
21441        form.insert("perm[pages][add]".to_owned(), "1".to_owned());
21442        form.insert("perm[pages][edit]".to_owned(), "1".to_owned());
21443        // Unchecked → not present in the form. View-only.
21444        form.insert("perm[history][view]".to_owned(), "1".to_owned());
21445        // Inapplicable cell — `history` doesn't accept `edit`. Must be
21446        // dropped silently.
21447        form.insert("perm[history][edit]".to_owned(), "1".to_owned());
21448        // Off-state checkbox shouldn't produce a grant.
21449        form.insert("perm[redirects][delete]".to_owned(), "0".to_owned());
21450        // Unknown resource key — dropped.
21451        form.insert("perm[bogus][view]".to_owned(), "1".to_owned());
21452        // Malformed key — dropped.
21453        form.insert("perm[pages]".to_owned(), "1".to_owned());
21454
21455        let codenames = parse_matrix_form(&form);
21456        assert!(codenames.contains(&"cms_page.view".to_owned()));
21457        assert!(codenames.contains(&"cms_page.add".to_owned()));
21458        assert!(codenames.contains(&"cms_page.edit".to_owned()));
21459        assert!(codenames.contains(&"cms_history.view".to_owned()));
21460        assert!(!codenames.contains(&"cms_history.edit".to_owned()));
21461        assert!(!codenames.contains(&"cms_redirect.delete".to_owned()));
21462        // No bogus / malformed leakage.
21463        assert!(!codenames.iter().any(|c| c.contains("bogus")));
21464    }
21465
21466    #[test]
21467    fn split_matrix_codenames_isolates_legacy() {
21468        let granted = vec![
21469            "cms_page.view".to_owned(),
21470            "cms_page.edit".to_owned(),
21471            "rustango_roles.view".to_owned(),
21472            "acme_custom.do_thing".to_owned(),
21473            "free_form_string".to_owned(),
21474        ];
21475        let (matched, legacy) = split_matrix_codenames(&granted);
21476        assert!(matched.contains(&"cms_page.view".to_owned()));
21477        assert!(matched.contains(&"cms_page.edit".to_owned()));
21478        assert!(matched.contains(&"rustango_roles.view".to_owned()));
21479        assert!(legacy.contains(&"acme_custom.do_thing".to_owned()));
21480        assert!(legacy.contains(&"free_form_string".to_owned()));
21481    }
21482
21483    #[test]
21484    fn build_permission_matrix_marks_granted_cells() {
21485        let granted = vec![
21486            "cms_page.view".to_owned(),
21487            "cms_page.add".to_owned(),
21488            "cms_media.view".to_owned(),
21489        ];
21490        let matrix = build_permission_matrix(&granted);
21491        let arr = matrix.as_array().expect("matrix is an array of sections");
21492        // Find the Content section → Pages row → granted list.
21493        let pages_row = arr
21494            .iter()
21495            .flat_map(|s| s["rows"].as_array().unwrap().iter())
21496            .find(|r| r["key"] == "pages")
21497            .expect("pages row present");
21498        let granted_actions: Vec<&str> = pages_row["granted"]
21499            .as_array()
21500            .unwrap()
21501            .iter()
21502            .map(|v| v.as_str().unwrap())
21503            .collect();
21504        assert!(granted_actions.contains(&"view"));
21505        assert!(granted_actions.contains(&"add"));
21506        assert!(!granted_actions.contains(&"edit"));
21507        assert!(!granted_actions.contains(&"delete"));
21508    }
21509
21510    #[test]
21511    fn round_trip_form_to_codenames_to_matrix() {
21512        // Submit a matrix; reverse-render it; expect every checked cell
21513        // to come back as `granted`.
21514        let mut form = std::collections::HashMap::new();
21515        form.insert("perm[pages][view]".to_owned(), "1".to_owned());
21516        form.insert("perm[pages][publish]".to_owned(), "1".to_owned());
21517        form.insert("perm[media][view]".to_owned(), "1".to_owned());
21518        let codenames = parse_matrix_form(&form);
21519        let matrix = build_permission_matrix(&codenames);
21520
21521        let pages = matrix
21522            .as_array()
21523            .unwrap()
21524            .iter()
21525            .flat_map(|s| s["rows"].as_array().unwrap().iter())
21526            .find(|r| r["key"] == "pages")
21527            .unwrap();
21528        let granted: Vec<&str> = pages["granted"]
21529            .as_array()
21530            .unwrap()
21531            .iter()
21532            .map(|v| v.as_str().unwrap())
21533            .collect();
21534        assert_eq!(granted, vec!["view", "publish"]);
21535    }
21536
21537    // -------- #117 InlinePanel extractor --------
21538
21539    fn sample_spec() -> crate::page_type::InlinePanelSpec {
21540        crate::page_type::InlinePanelSpec::new(
21541            "team",
21542            "Team",
21543            vec![
21544                crate::page_type::ExtensionField {
21545                    name: "name".to_owned(),
21546                    label: "Name".to_owned(),
21547                    kind: crate::page_type::ExtensionFieldKind::Text,
21548                    value: String::new(),
21549                    help: String::new(),
21550                    max_length: None,
21551                },
21552                crate::page_type::ExtensionField {
21553                    name: "role".to_owned(),
21554                    label: "Role".to_owned(),
21555                    kind: crate::page_type::ExtensionFieldKind::Text,
21556                    value: String::new(),
21557                    help: String::new(),
21558                    max_length: None,
21559                },
21560            ],
21561        )
21562    }
21563
21564    #[test]
21565    fn inline_extractor_groups_by_row_index() {
21566        let spec = sample_spec();
21567        let mut form = std::collections::HashMap::new();
21568        form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21569        form.insert("inline__team__0__role".to_owned(), "Engineer".to_owned());
21570        form.insert("inline__team__1__name".to_owned(), "Bob".to_owned());
21571        form.insert("inline__team__1__role".to_owned(), "Designer".to_owned());
21572        let rows = extract_inline_panel_rows(&form, &spec);
21573        assert_eq!(rows.len(), 2);
21574        assert_eq!(rows[0]["name"], "Ada");
21575        assert_eq!(rows[1]["role"], "Designer");
21576    }
21577
21578    #[test]
21579    fn inline_extractor_drops_tombstoned_rows() {
21580        let spec = sample_spec();
21581        let mut form = std::collections::HashMap::new();
21582        form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21583        form.insert("inline__team__1__name".to_owned(), "Bob".to_owned());
21584        form.insert("inline__team__1____deleted".to_owned(), "1".to_owned());
21585        let rows = extract_inline_panel_rows(&form, &spec);
21586        assert_eq!(rows.len(), 1);
21587        assert_eq!(rows[0]["name"], "Ada");
21588    }
21589
21590    #[test]
21591    fn inline_extractor_ignores_unknown_field_names() {
21592        let spec = sample_spec();
21593        let mut form = std::collections::HashMap::new();
21594        form.insert("inline__team__0__name".to_owned(), "Ada".to_owned());
21595        form.insert("inline__team__0__bogus".to_owned(), "x".to_owned());
21596        let rows = extract_inline_panel_rows(&form, &spec);
21597        assert_eq!(rows.len(), 1);
21598        assert!(!rows[0].contains_key("bogus"));
21599    }
21600
21601    #[test]
21602    fn inline_extractor_ignores_unrelated_form_keys() {
21603        let spec = sample_spec();
21604        let mut form = std::collections::HashMap::new();
21605        form.insert("title".to_owned(), "irrelevant".to_owned());
21606        form.insert("inline__other_panel__0__name".to_owned(), "x".to_owned());
21607        let rows = extract_inline_panel_rows(&form, &spec);
21608        assert!(rows.is_empty());
21609    }
21610
21611    /// The page-edit submit handler funnels the raw posted
21612    /// form through an allow-list before re-deserializing as
21613    /// `PageForm`. The bug guarded here was that schedule fields
21614    /// (`go_live_at`, `expire_at`) and `show_in_menus` were missing
21615    /// from that allow-list, so any datetime the editor set on the
21616    /// Promote tab was silently dropped on save — and never made it
21617    /// to the scheduled-pages report. Lock these in so a future
21618    /// trim of the array can't reintroduce the regression.
21619    #[test]
21620    fn page_form_canonical_keys_include_schedule_and_menu_fields() {
21621        assert!(
21622            PAGE_FORM_CANONICAL_KEYS.contains(&"go_live_at"),
21623            "go_live_at must be in canonical keys — see #268"
21624        );
21625        assert!(
21626            PAGE_FORM_CANONICAL_KEYS.contains(&"expire_at"),
21627            "expire_at must be in canonical keys — see #268"
21628        );
21629        assert!(
21630            PAGE_FORM_CANONICAL_KEYS.contains(&"show_in_menus"),
21631            "show_in_menus must be in canonical keys — see #268"
21632        );
21633    }
21634}
21635
21636#[cfg(all(test, feature = "sqlite"))]
21637mod media_picker_tests {
21638    //! `media_picker_payload` filtering / pagination / collection-tree
21639    //! tests over an in-memory sqlite pool (mirrors redirect.rs's
21640    //! `mem_pool` pattern).
21641    use super::{media_picker_payload, MediaPickerQuery};
21642    use crate::media::{Media, MediaCollection};
21643    use rustango::core::Model as _;
21644    use rustango::sql::{Auto, FetcherPool as _, Pool};
21645
21646    async fn mem_pool() -> Pool {
21647        let pool = Pool::connect("sqlite::memory:")
21648            .await
21649            .expect("in-memory sqlite");
21650        for schema in [&Media::SCHEMA, &MediaCollection::SCHEMA] {
21651            let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
21652                pool.dialect(),
21653                schema,
21654            );
21655            for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
21656                rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
21657                    .await
21658                    .expect("ddl");
21659            }
21660        }
21661        pool
21662    }
21663
21664    async fn mk_collection(pool: &Pool, name: &str, parent_id: Option<i64>, sort: i32) -> i64 {
21665        MediaCollection {
21666            id: Auto::Unset,
21667            name: name.to_owned(),
21668            parent_id,
21669            sort_order: sort,
21670            created_at: Auto::Unset,
21671        }
21672        .insert_pool(pool)
21673        .await
21674        .expect("collection insert");
21675        MediaCollection::objects()
21676            .fetch(pool)
21677            .await
21678            .expect("fetch")
21679            .into_iter()
21680            .find(|c| c.name == name)
21681            .and_then(|c| c.id.get().copied())
21682            .expect("collection id")
21683    }
21684
21685    async fn mk_media(
21686        pool: &Pool,
21687        title: &str,
21688        filename: &str,
21689        kind: &str,
21690        collection_id: Option<i64>,
21691        alt: &str,
21692    ) {
21693        Media {
21694            id: Auto::Unset,
21695            filename: filename.to_owned(),
21696            content_hash: format!("{:0>64}", title.len()),
21697            mime: if kind == "image" {
21698                "image/png"
21699            } else {
21700                "application/pdf"
21701            }
21702            .to_owned(),
21703            size: 123,
21704            kind: kind.to_owned(),
21705            width: (kind == "image").then_some(100),
21706            height: (kind == "image").then_some(80),
21707            storage_key: format!("k-{filename}"),
21708            title: title.to_owned(),
21709            alt_text: alt.to_owned(),
21710            description: String::new(),
21711            uploaded_by: None,
21712            collection_id,
21713            focal_point_x: None,
21714            focal_point_y: None,
21715            uploaded_at: Auto::Unset,
21716        }
21717        .insert_pool(pool)
21718        .await
21719        .expect("media insert");
21720    }
21721
21722    #[tokio::test]
21723    async fn default_kind_excludes_documents() {
21724        let pool = mem_pool().await;
21725        mk_media(&pool, "Photo", "p.png", "image", None, "").await;
21726        mk_media(&pool, "Spec", "s.pdf", "document", None, "").await;
21727        let body = media_picker_payload(&pool, &MediaPickerQuery::default())
21728            .await
21729            .expect("payload");
21730        let items = body["items"].as_array().expect("items");
21731        assert_eq!(items.len(), 1);
21732        assert_eq!(items[0]["kind"], "image");
21733        // kind=any opts back in.
21734        let q = MediaPickerQuery {
21735            kind: Some("any".to_owned()),
21736            ..Default::default()
21737        };
21738        let body = media_picker_payload(&pool, &q).await.expect("payload");
21739        assert_eq!(body["items"].as_array().expect("items").len(), 2);
21740    }
21741
21742    #[tokio::test]
21743    async fn collection_zero_means_uncategorized_only() {
21744        let pool = mem_pool().await;
21745        let cid = mk_collection(&pool, "Root", None, 0).await;
21746        mk_media(&pool, "In", "in.png", "image", Some(cid), "").await;
21747        mk_media(&pool, "Loose", "loose.png", "image", None, "").await;
21748        let q = MediaPickerQuery {
21749            collection: Some(0),
21750            ..Default::default()
21751        };
21752        let body = media_picker_payload(&pool, &q).await.expect("payload");
21753        let items = body["items"].as_array().expect("items");
21754        assert_eq!(items.len(), 1);
21755        assert_eq!(items[0]["title"], "Loose");
21756        assert_eq!(body["uncategorized_count"], 1);
21757        // Exact collection id narrows to its members.
21758        let q = MediaPickerQuery {
21759            collection: Some(cid),
21760            ..Default::default()
21761        };
21762        let body = media_picker_payload(&pool, &q).await.expect("payload");
21763        assert_eq!(body["items"].as_array().expect("items").len(), 1);
21764        assert_eq!(body["items"][0]["title"], "In");
21765    }
21766
21767    #[tokio::test]
21768    async fn search_matches_alt_text() {
21769        let pool = mem_pool().await;
21770        mk_media(
21771            &pool,
21772            "IMG_0001",
21773            "a.png",
21774            "image",
21775            None,
21776            "sunset glow over harbour",
21777        )
21778        .await;
21779        mk_media(&pool, "IMG_0002", "b.png", "image", None, "office desk").await;
21780        let q = MediaPickerQuery {
21781            q: Some("Sunset".to_owned()),
21782            ..Default::default()
21783        };
21784        let body = media_picker_payload(&pool, &q).await.expect("payload");
21785        let items = body["items"].as_array().expect("items");
21786        assert_eq!(items.len(), 1);
21787        assert_eq!(items[0]["title"], "IMG_0001");
21788    }
21789
21790    #[tokio::test]
21791    async fn pagination_math_and_has_more() {
21792        let pool = mem_pool().await;
21793        for i in 0..5 {
21794            mk_media(
21795                &pool,
21796                &format!("M{i}"),
21797                &format!("m{i}.png"),
21798                "image",
21799                None,
21800                "",
21801            )
21802            .await;
21803        }
21804        let q = MediaPickerQuery {
21805            limit: Some(2),
21806            offset: Some(0),
21807            ..Default::default()
21808        };
21809        let body = media_picker_payload(&pool, &q).await.expect("payload");
21810        assert_eq!(body["items"].as_array().expect("items").len(), 2);
21811        assert_eq!(body["total"], 5);
21812        assert_eq!(body["has_more"], true);
21813        let q = MediaPickerQuery {
21814            limit: Some(2),
21815            offset: Some(4),
21816            ..Default::default()
21817        };
21818        let body = media_picker_payload(&pool, &q).await.expect("payload");
21819        assert_eq!(body["items"].as_array().expect("items").len(), 1);
21820        assert_eq!(body["has_more"], false);
21821        // Offset past the end is clamped, not a panic.
21822        let q = MediaPickerQuery {
21823            limit: Some(2),
21824            offset: Some(99),
21825            ..Default::default()
21826        };
21827        let body = media_picker_payload(&pool, &q).await.expect("payload");
21828        assert_eq!(body["items"].as_array().expect("items").len(), 0);
21829    }
21830
21831    #[tokio::test]
21832    async fn collections_come_back_in_dfs_order_with_depth() {
21833        let pool = mem_pool().await;
21834        let root_a = mk_collection(&pool, "Alpha", None, 0).await;
21835        let _sub = mk_collection(&pool, "Alpha Child", Some(root_a), 0).await;
21836        let _root_b = mk_collection(&pool, "Beta", None, 1).await;
21837        mk_media(&pool, "In A", "a.png", "image", Some(root_a), "").await;
21838        let body = media_picker_payload(&pool, &MediaPickerQuery::default())
21839            .await
21840            .expect("payload");
21841        let cols = body["collections"].as_array().expect("collections");
21842        let names: Vec<&str> = cols.iter().map(|c| c["name"].as_str().unwrap()).collect();
21843        assert_eq!(names, ["Alpha", "Alpha Child", "Beta"]);
21844        assert_eq!(cols[0]["depth"], 0);
21845        assert_eq!(cols[1]["depth"], 1);
21846        assert_eq!(cols[2]["depth"], 0);
21847        assert_eq!(cols[0]["count"], 1);
21848        assert_eq!(cols[2]["count"], 0);
21849    }
21850
21851    #[tokio::test]
21852    async fn ids_lookup_resolves_any_kind() {
21853        // The label-hydration pass resolves exact ids — including
21854        // non-image kinds, which the default filter would drop.
21855        let pool = mem_pool().await;
21856        mk_media(&pool, "Photo", "p.png", "image", None, "").await;
21857        mk_media(&pool, "Spec", "s.pdf", "document", None, "").await;
21858        let all = media_picker_payload(
21859            &pool,
21860            &MediaPickerQuery {
21861                kind: Some("any".to_owned()),
21862                ..Default::default()
21863            },
21864        )
21865        .await
21866        .expect("payload");
21867        let ids: Vec<i64> = all["items"]
21868            .as_array()
21869            .unwrap()
21870            .iter()
21871            .map(|i| i["id"].as_i64().unwrap())
21872            .collect();
21873        let q = MediaPickerQuery {
21874            ids: Some(
21875                ids.iter()
21876                    .map(|i| i.to_string())
21877                    .collect::<Vec<_>>()
21878                    .join(","),
21879            ),
21880            ..Default::default()
21881        };
21882        let body = media_picker_payload(&pool, &q).await.expect("payload");
21883        let items = body["items"].as_array().expect("items");
21884        assert_eq!(
21885            items.len(),
21886            2,
21887            "document resolves too when ids are explicit"
21888        );
21889        // Explicit kind still narrows an ids lookup.
21890        let q = MediaPickerQuery {
21891            ids: Some(
21892                ids.iter()
21893                    .map(|i| i.to_string())
21894                    .collect::<Vec<_>>()
21895                    .join(","),
21896            ),
21897            kind: Some("image".to_owned()),
21898            ..Default::default()
21899        };
21900        let body = media_picker_payload(&pool, &q).await.expect("payload");
21901        assert_eq!(body["items"].as_array().expect("items").len(), 1);
21902    }
21903
21904    #[tokio::test]
21905    async fn image_items_carry_rendition_thumb_urls() {
21906        let pool = mem_pool().await;
21907        mk_media(&pool, "Pic", "p.png", "image", None, "").await;
21908        let body = media_picker_payload(&pool, &MediaPickerQuery::default())
21909            .await
21910            .expect("payload");
21911        let item = &body["items"][0];
21912        let thumb = item["thumb_url"].as_str().expect("thumb_url");
21913        assert!(
21914            thumb.starts_with("/__media__/fill-320x320"),
21915            "spec-first URL: {thumb}"
21916        );
21917        assert!(thumb.contains("v="), "cache-buster present: {thumb}");
21918        let preview = item["preview_url"].as_str().expect("preview_url");
21919        assert!(preview.contains("max-640x480"), "{preview}");
21920    }
21921}
21922
21923#[cfg(all(test, feature = "sqlite"))]
21924mod forms_list_tests {
21925    //! `forms_list_rows` row-model tests over an in-memory sqlite pool.
21926    use super::forms_list_rows;
21927    use crate::forms::submit::FormEntry;
21928    use crate::snippet::Snippet;
21929    use rustango::core::Model as _;
21930    use rustango::sql::{Auto, FetcherPool as _, Pool};
21931
21932    async fn mem_pool() -> Pool {
21933        let pool = Pool::connect("sqlite::memory:")
21934            .await
21935            .expect("in-memory sqlite");
21936        for schema in [&Snippet::SCHEMA, &FormEntry::SCHEMA] {
21937            let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
21938                pool.dialect(),
21939                schema,
21940            );
21941            for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
21942                rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
21943                    .await
21944                    .expect("ddl");
21945            }
21946        }
21947        pool
21948    }
21949
21950    async fn mk_form(pool: &Pool, slug: &str, title: &str, fields: usize) -> i64 {
21951        let field_json: Vec<serde_json::Value> = (0..fields)
21952            .map(|i| serde_json::json!({"id": format!("f{i}"), "key": format!("k{i}"), "type": "text", "label": "F"}))
21953            .collect();
21954        Snippet {
21955            id: Auto::Unset,
21956            type_name: "form".to_owned(),
21957            folder_path: String::new(),
21958            slug: slug.to_owned(),
21959            title: title.to_owned(),
21960            body_markdown: String::new(),
21961            data: serde_json::json!({
21962                "settings": {},
21963                "pages": [{"id": "p1", "sections": [{"id": "s1", "rows": [{"id": "r1",
21964                    "columns": [{"id": "c1", "width": 12, "fields": field_json}]}]}]}]
21965            }),
21966            created_at: Auto::Unset,
21967            updated_at: Auto::Unset,
21968        }
21969        .insert_pool(pool)
21970        .await
21971        .expect("form insert");
21972        Snippet::objects()
21973            .fetch(pool)
21974            .await
21975            .expect("fetch")
21976            .into_iter()
21977            .find(|s| s.slug == slug)
21978            .and_then(|s| s.id.get().copied())
21979            .expect("form id")
21980    }
21981
21982    async fn mk_entry(pool: &Pool, form_id: i64) {
21983        FormEntry {
21984            id: Auto::Unset,
21985            form_snippet_id: form_id,
21986            form_version: 1,
21987            source_page_id: 0,
21988            source_url: "/contact".to_owned(),
21989            data_json: serde_json::json!({"k0": "hi"}),
21990            locale: "en".to_owned(),
21991            ip: String::new(),
21992            submitted_at: Auto::Unset,
21993        }
21994        .insert_pool(pool)
21995        .await
21996        .expect("entry insert");
21997    }
21998
21999    #[tokio::test]
22000    async fn rows_carry_field_and_submission_counts() {
22001        let pool = mem_pool().await;
22002        let a = mk_form(&pool, "contact", "Contact", 3).await;
22003        let b = mk_form(&pool, "rsvp", "RSVP", 1).await;
22004        mk_entry(&pool, a).await;
22005        mk_entry(&pool, a).await;
22006        let rows = forms_list_rows(&pool).await.expect("rows");
22007        assert_eq!(rows.len(), 2);
22008        let by_slug = |slug: &str| rows.iter().find(|r| r["slug"] == slug).expect("row");
22009        let ra = by_slug("contact");
22010        assert_eq!(ra["fields"], 3);
22011        assert_eq!(ra["submissions"], 2);
22012        assert!(
22013            ra["last_submission"].as_str().unwrap().len() >= 16,
22014            "has a timestamp"
22015        );
22016        assert_eq!(ra["build_url"], format!("/cms-admin/forms/{a}/build"));
22017        assert_eq!(
22018            ra["submissions_url"],
22019            format!("/cms-admin/forms/{a}/submissions")
22020        );
22021        let rb = by_slug("rsvp");
22022        assert_eq!(rb["fields"], 1);
22023        assert_eq!(rb["submissions"], 0);
22024        assert_eq!(rb["last_submission"], "");
22025        assert_eq!(rb["delete_url"], format!("/cms-admin/library/{b}/delete"));
22026    }
22027
22028    #[tokio::test]
22029    async fn only_form_snippets_appear() {
22030        let pool = mem_pool().await;
22031        mk_form(&pool, "contact", "Contact", 1).await;
22032        Snippet {
22033            id: Auto::Unset,
22034            type_name: "branding".to_owned(),
22035            folder_path: String::new(),
22036            slug: "site-branding".to_owned(),
22037            title: "Branding".to_owned(),
22038            body_markdown: String::new(),
22039            data: serde_json::json!({}),
22040            created_at: Auto::Unset,
22041            updated_at: Auto::Unset,
22042        }
22043        .insert_pool(&pool)
22044        .await
22045        .expect("snippet insert");
22046        let rows = forms_list_rows(&pool).await.expect("rows");
22047        assert_eq!(rows.len(), 1);
22048        assert_eq!(rows[0]["slug"], "contact");
22049    }
22050
22051    #[test]
22052    fn user_admin_is_superuser_only() {
22053        // #642 — user management sets is_superuser / active / roles from
22054        // the form, so the whole surface is restricted to superusers.
22055        // A superuser proceeds; a signed-in non-superuser is bounced to
22056        // no-access; an anonymous caller to login. A regression that drops
22057        // the guard (or lets a non-superuser through) fails here.
22058        assert_eq!(super::user_admin_denial_target(Some(true)), None);
22059        assert_eq!(
22060            super::user_admin_denial_target(Some(false)),
22061            Some("/cms-admin/no-access")
22062        );
22063        assert_eq!(super::user_admin_denial_target(None), Some("/login"));
22064    }
22065
22066    #[test]
22067    fn mcp_key_admin_handlers_enforce_the_superuser_gate() {
22068        // #646 — the two /cms-admin/users/{id}/mcp-keys handlers must carry
22069        // the same superuser gate as every other user-admin handler. They
22070        // once gated on "a session exists" only, so a non-superuser could
22071        // mint a key bounded by a superuser's entitlement. Pin the wiring so
22072        // a future edit can't silently drop it again (the gap that untested
22073        // wiring hid the first time). Runs in the default suite — no DB.
22074        let src = include_str!("handlers.rs");
22075        for name in ["users_mcp_key_create", "users_mcp_key_revoke"] {
22076            let start = src
22077                .find(&format!("pub async fn {name}("))
22078                .unwrap_or_else(|| panic!("handler {name} not found"));
22079            // Bound the scan to this fn's body: up to the next top-level fn.
22080            let rest = &src[start + 1..];
22081            let end = rest.find("\npub async fn ").unwrap_or(rest.len());
22082            assert!(
22083                rest[..end].contains("require_superuser_for_user_admin(session_user.as_ref())"),
22084                "{name} is missing the superuser gate (#646)"
22085            );
22086        }
22087    }
22088}
22089
22090#[cfg(test)]
22091mod password_reset_key_tests {
22092    use super::password_reset_key;
22093    use rustango::auth_flows::PasswordReset;
22094    use std::time::Duration;
22095
22096    const SECRET: &[u8] = b"process-wide-signing-secret";
22097    const BASE: &str = "/cms-admin/password-reset/confirm";
22098
22099    fn link(tenant: &str, hash: &str) -> String {
22100        PasswordReset::issue(BASE, 1, &password_reset_key(SECRET, tenant, hash), Duration::from_secs(3600))
22101    }
22102
22103    #[test]
22104    fn a_link_verifies_for_the_tenant_and_password_it_was_issued_for() {
22105        let url = link("acme", "$argon2id$v=19$old");
22106        let key = password_reset_key(SECRET, "acme", "$argon2id$v=19$old");
22107        assert_eq!(PasswordReset::verify(&url, &key).ok(), Some(1));
22108    }
22109
22110    #[test]
22111    fn a_link_issued_on_one_tenant_does_not_verify_on_another() {
22112        // User ids restart at 1 per tenant: this is the takeover in #673.
22113        let url = link("acme", "$argon2id$v=19$same");
22114        let other = password_reset_key(SECRET, "globex", "$argon2id$v=19$same");
22115        assert!(PasswordReset::verify(&url, &other).is_err());
22116    }
22117
22118    #[test]
22119    fn a_link_stops_verifying_once_the_password_changes() {
22120        let url = link("acme", "$argon2id$v=19$before");
22121        let after = password_reset_key(SECRET, "acme", "$argon2id$v=19$after");
22122        assert!(PasswordReset::verify(&url, &after).is_err());
22123    }
22124}
22125
22126#[cfg(all(test, feature = "sqlite"))]
22127mod publish_gate_tests {
22128    //! A save that puts a page live takes the publish right,
22129    //! judged on the status it lands on after go-live derivation.
22130    use super::{apply_page_edit, PageEditActor, PageEditRefusal};
22131    use crate::page::{Page, PageStatus};
22132    use crate::page_type_model::PageType;
22133    use rustango::core::Column as _;
22134    use rustango::sql::{Auto, Pool};
22135
22136    async fn mem_pool() -> Pool {
22137        let pool = Pool::connect("sqlite::memory:").await.expect("in-memory sqlite");
22138        for entry in inventory::iter::<rustango::core::ModelEntry> {
22139            if !entry.schema.managed {
22140                continue;
22141            }
22142            let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
22143                pool.dialect(),
22144                entry.schema,
22145            );
22146            for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
22147                rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
22148                    .await
22149                    .expect("ddl");
22150            }
22151        }
22152        pool
22153    }
22154
22155    async fn draft(pool: &Pool) -> Page {
22156        let mut pt = PageType {
22157            id: Auto::Unset,
22158            app_label: "cms".to_owned(),
22159            type_name: "TestPage".to_owned(),
22160            verbose_name: "Test page".to_owned(),
22161            default_template: "page.html".to_owned(),
22162            view_mode: "auto".to_owned(),
22163            is_creatable: true,
22164            allowed_parent_types: serde_json::json!([]),
22165            allowed_child_types: serde_json::json!([]),
22166            workflow: String::new(),
22167            created_at: Auto::Unset,
22168            updated_at: Auto::Unset,
22169        };
22170        pt.save_pool(pool).await.expect("page type");
22171        let mut p = draft_template(pt.id.get().copied().expect("type id"));
22172        p.save_pool(pool).await.expect("page");
22173        p
22174    }
22175
22176    fn draft_template(type_id: i64) -> Page {
22177        Page {
22178            id: Auto::Unset,
22179            page_type_id: type_id,
22180            title: "Draft".to_owned(),
22181            slug: "draft".to_owned(),
22182            path: "0001/".to_owned(),
22183            url_path: "/draft".to_owned(),
22184            preview_path: String::new(),
22185            template_override: String::new(),
22186            depth: 1,
22187            parent_id: None,
22188            locale_variant_of: None,
22189            alias_of: None,
22190            theme_id: None,
22191            sort_order: 0,
22192            status: PageStatus::Draft.as_str().to_owned(),
22193            published_at: None,
22194            last_published_at: None,
22195            go_live_at: None,
22196            expire_at: None,
22197            seo_title: String::new(),
22198            seo_description: String::new(),
22199            robots_index: true,
22200            sitemap_priority: 0.5,
22201            show_in_menus: true,
22202            og_title: String::new(),
22203            og_description: String::new(),
22204            og_image_media_id: None,
22205            twitter_card: "summary".to_owned(),
22206            notification_pre_published_sent: false,
22207            created_at: Auto::Unset,
22208            updated_at: Auto::Unset,
22209        }
22210    }
22211
22212    async fn save(
22213        pool: &Pool,
22214        page: &Page,
22215        status: &str,
22216        go_live_days: Option<i64>,
22217        superuser: bool,
22218    ) -> Result<String, &'static str> {
22219        let mut form = crate::page_form::prefill(pool, page).await;
22220        form.insert("status".into(), status.to_owned());
22221        match go_live_days {
22222            Some(d) => form.insert(
22223                "go_live_at".into(),
22224                (chrono::Utc::now() + chrono::Duration::days(d))
22225                    .format("%Y-%m-%dT%H:%M")
22226                    .to_string(),
22227            ),
22228            None => form.remove("go_live_at"),
22229        };
22230        // A user with no roles: edit reached the handler, publish is not held.
22231        let actor = PageEditActor { id: 999, username: "editor".to_owned(), is_superuser: superuser };
22232        let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
22233            std::sync::Arc::new(crate::cache_invalidate::Noop);
22234        let id = page.id.get().copied().expect("id");
22235        match apply_page_edit(pool, "t", &invalidator, None, "", false, id, &form, Some(&actor))
22236            .await
22237            .expect("save")
22238        {
22239            Ok(o) => Ok(o.page.status),
22240            Err(PageEditRefusal::PublishDenied) => Err("publish denied"),
22241            Err(PageEditRefusal::ReviewRequired { .. }) => Err("review required"),
22242            Err(_) => Err("other refusal"),
22243        }
22244    }
22245
22246    async fn stored_status(pool: &Pool, page: &Page) -> String {
22247        Page::objects()
22248            .where_(Page::id.eq(page.id.get().copied().expect("id")))
22249            .first(pool)
22250            .await
22251            .expect("query")
22252            .expect("page")
22253            .status
22254    }
22255
22256    #[tokio::test]
22257    async fn going_live_by_any_route_needs_the_publish_right() {
22258        let pool = mem_pool().await;
22259        let page = draft(&pool).await;
22260        for (status, go_live) in [
22261            ("archived", None),
22262            ("published", None),
22263            // Draft plus a future go-live is parked as scheduled.
22264            ("draft", Some(1)),
22265            // Scheduled with a go-live already past: the sweep publishes it.
22266            ("scheduled", Some(-1)),
22267        ] {
22268            assert_eq!(
22269                save(&pool, &page, status, go_live, false).await,
22270                Err("publish denied"),
22271                "{status} / {go_live:?}"
22272            );
22273            assert_eq!(stored_status(&pool, &page).await, "draft", "nothing written");
22274        }
22275        assert_eq!(
22276            save(&pool, &page, "scheduled", None, false).await,
22277            Ok("draft".to_owned()),
22278            "scheduled without a date is parked as a draft, so it is allowed"
22279        );
22280        assert_eq!(
22281            save(&pool, &page, "draft", Some(1), true).await,
22282            Ok("scheduled".to_owned()),
22283            "the publish right schedules"
22284        );
22285    }
22286
22287    /// A page type with a review workflow goes live only through it: a
22288    /// save straight to Published is refused for everyone but a
22289    /// superuser — the owner's review can't be skipped.
22290    /// Bind `type_id` to a one-step "Owner review" workflow.
22291    async fn bind_review(pool: &Pool, type_id: i64, reapproval: bool) -> crate::workflow::Workflow {
22292        let mut wf = crate::workflow::Workflow {
22293            id: Auto::Unset,
22294            name: "Owner review".to_owned(),
22295            description: String::new(),
22296            active: true,
22297            require_reapproval_on_edit: reapproval,
22298            created_at: Auto::Unset,
22299            updated_at: Auto::Unset,
22300        };
22301        wf.save_pool(pool).await.expect("workflow");
22302        rustango::sql::raw_execute_pool(pool, "INSERT INTO rustango_roles (id, name, description) VALUES (1, 'Owner', '')", Vec::new())
22303            .await
22304            .expect("role");
22305        let mut task = crate::workflow::WorkflowTask {
22306            id: Auto::Unset,
22307            workflow_id: wf.id.get().copied().expect("id"),
22308            name: "Owner checks".to_owned(),
22309            role_id: 1,
22310            sort_order: 10,
22311            kind: "group_approval".to_owned(),
22312            webhook_url: String::new(),
22313        };
22314        task.save_pool(pool).await.expect("task");
22315        let mut pt = PageType::objects()
22316            .where_(PageType::id.eq(type_id))
22317            .first(pool)
22318            .await
22319            .expect("q")
22320            .expect("type");
22321        pt.workflow = "Owner review".to_owned();
22322        pt.save_pool(pool).await.expect("bind");
22323        wf
22324    }
22325
22326    #[tokio::test]
22327    async fn a_review_workflow_cannot_be_published_around() {
22328        let pool = mem_pool().await;
22329        let page = draft(&pool).await;
22330        let mut wf = bind_review(&pool, page.page_type_id, false).await;
22331
22332        assert_eq!(save(&pool, &page, "published", None, false).await, Err("review required"));
22333        assert_eq!(save(&pool, &page, "draft", Some(1), false).await, Err("review required"), "nor scheduled");
22334        assert_eq!(stored_status(&pool, &page).await, "draft");
22335        assert_eq!(save(&pool, &page, "draft", None, false).await, Ok("draft".to_owned()), "drafts still save");
22336        assert_eq!(save(&pool, &page, "published", None, true).await, Ok("published".to_owned()), "the owner can");
22337
22338        // Renaming the workflow moves the page type along: still reviewed.
22339        let other = draft_named(&pool, page.page_type_id, "second").await;
22340        wf.name = "Studio review".to_owned();
22341        wf.save_pool(&pool).await.expect("rename");
22342        assert_eq!(crate::workflow::rebind_page_types(&pool, "Owner review", "Studio review").await.expect("rebind"), 1);
22343        assert_eq!(save(&pool, &other, "published", None, false).await, Err("review required"));
22344    }
22345
22346    /// Save `page` with a new title; `actor` None is the CMS's own save.
22347    async fn retitle(pool: &Pool, page: &Page, title: &str, actor: Option<&PageEditActor>) -> super::PageEditOutcome {
22348        let mut form = crate::page_form::prefill(pool, page).await;
22349        form.insert("title".into(), title.to_owned());
22350        let invalidator: std::sync::Arc<dyn crate::cache_invalidate::PageCacheInvalidator> =
22351            std::sync::Arc::new(crate::cache_invalidate::Noop);
22352        let id = page.id.get().copied().expect("id");
22353        match apply_page_edit(pool, "t", &invalidator, None, "", false, id, &form, actor).await.expect("save") {
22354            Ok(o) => o,
22355            Err(_) => panic!("refused"),
22356        }
22357    }
22358
22359    async fn stored_title(pool: &Pool, page: &Page) -> String {
22360        Page::objects()
22361            .where_(Page::id.eq(page.id.get().copied().expect("id")))
22362            .first(pool)
22363            .await
22364            .expect("query")
22365            .expect("page")
22366            .title
22367    }
22368
22369    /// With re-approval on, an editor's save of a live page waits for the
22370    /// review: visitors keep the live version until the approval applies
22371    /// it; cancelling the review drops it; a superuser's save supersedes it.
22372    #[tokio::test]
22373    async fn a_live_page_edit_waits_for_review() {
22374        let pool = mem_pool().await;
22375        let page = draft(&pool).await;
22376        bind_review(&pool, page.page_type_id, true).await;
22377        assert_eq!(save(&pool, &page, "published", None, true).await, Ok("published".to_owned()));
22378        let id = page.id.get().copied().expect("id");
22379        let mut mia = rustango::tenancy::auth::User {
22380            id: Auto::Unset,
22381            username: "mia".to_owned(),
22382            password_hash: String::new(),
22383            email: None,
22384            is_superuser: false,
22385            active: true,
22386            created_at: chrono::Utc::now(),
22387            data: serde_json::json!({}),
22388            password_changed_at: None,
22389            sessions_revoked_at: None,
22390        };
22391        mia.save_pool(&pool).await.expect("user");
22392        let editor = PageEditActor { id: mia.id.get().copied().expect("id"), username: "mia".to_owned(), is_superuser: false };
22393
22394        let out = retitle(&pool, &page, "Proposed", Some(&editor)).await;
22395        assert!(out.held_for_review && out.reapproval_kicked);
22396        assert_eq!(stored_title(&pool, &page).await, "Draft", "the live page is unchanged");
22397        let held = crate::pending_change::for_page(&pool, id).await.expect("q").expect("held");
22398        assert_eq!(held.form_map().get("title").map(String::as_str), Some("Proposed"));
22399        let mut state = crate::workflow::active_state_for_page(&pool, id).await.expect("q").expect("review started");
22400
22401        // The approval applies it through the normal save path.
22402        let tasks = crate::workflow::tasks_for(&pool, state.workflow_id).await.expect("tasks");
22403        crate::workflow::approve_current(&pool, &mut state, &tasks, editor.id, "").await.expect("approve");
22404        let applied = retitle(&pool, &page, "Proposed", None).await;
22405        assert!(!applied.held_for_review);
22406        assert_eq!(stored_title(&pool, &page).await, "Proposed");
22407
22408        // Cancelling the review drops a held change.
22409        retitle(&pool, &page, "Second try", Some(&editor)).await;
22410        let mut state = crate::workflow::active_state_for_page(&pool, id).await.expect("q").expect("review restarted");
22411        crate::workflow::cancel(&pool, &mut state, editor.id).await.expect("cancel");
22412        assert!(crate::pending_change::for_page(&pool, id).await.expect("q").is_none());
22413
22414        // A superuser's direct save supersedes one.
22415        retitle(&pool, &page, "Third try", Some(&editor)).await;
22416        let owner = PageEditActor { id: 1, username: "owner".to_owned(), is_superuser: true };
22417        assert!(!retitle(&pool, &page, "Owner's", Some(&owner)).await.held_for_review);
22418        assert_eq!(stored_title(&pool, &page).await, "Owner's");
22419        assert!(crate::pending_change::for_page(&pool, id).await.expect("q").is_none());
22420    }
22421
22422    async fn draft_named(pool: &Pool, type_id: i64, slug: &str) -> Page {
22423        let mut p = draft_template(type_id);
22424        slug.clone_into(&mut p.slug);
22425        p.path = "0002/".to_owned();
22426        p.url_path = format!("/{slug}");
22427        p.save_pool(pool).await.expect("page");
22428        p
22429    }
22430}
22431
22432#[cfg(test)]
22433mod active_upload_tests {
22434    use super::refuse_active_upload;
22435
22436    #[test]
22437    fn page_like_types_are_refused_and_media_is_not() {
22438        for bad in ["text/html", "application/xhtml+xml", "text/javascript", "application/xml"] {
22439            assert!(refuse_active_upload(bad).is_err(), "{bad}");
22440        }
22441        for ok in ["image/png", "image/svg+xml", "application/pdf", "text/plain", "video/mp4"] {
22442            assert!(refuse_active_upload(ok).is_ok(), "{ok}");
22443        }
22444    }
22445}