use crate::api::query::{Path, Query};
use axum::http::{HeaderMap, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::Json;
use rustango::core::Column as _;
use rustango::extractors::{SessionUser, Tenant};
use rustango::sql::FetcherPool as _;
use serde::Deserialize;
use super::query as q;
use crate::page::{Page, PageStatus};
use crate::page_type::{find_handler, PageTypeHandler};
use crate::page_type_model::PageType;
#[derive(Debug, Default, Deserialize)]
pub struct PageFilters {
#[serde(default, deserialize_with = "q::empty_string_as_none")]
pub r#type: Option<String>,
#[serde(default, deserialize_with = "q::empty_as_none")]
pub child_of: Option<i64>,
#[serde(default, deserialize_with = "q::empty_as_none")]
pub descendant_of: Option<i64>,
#[serde(default, deserialize_with = "q::empty_as_none")]
pub ancestor_of: Option<i64>,
#[serde(default, deserialize_with = "q::empty_as_none")]
pub translation_of: Option<i64>,
#[serde(default, deserialize_with = "q::empty_string_as_none")]
pub locale: Option<String>,
#[serde(default, deserialize_with = "q::empty_string_as_none")]
pub tag: Option<String>,
#[serde(default, deserialize_with = "q::empty_string_as_none")]
pub id_in: Option<String>,
}
#[derive(Debug, Default, Deserialize)]
pub struct PageListQuery {
#[serde(flatten)]
pub list: q::ListQuery,
#[serde(flatten)]
pub filters: PageFilters,
}
#[derive(Debug, Default, Deserialize)]
pub struct FindQuery {
#[serde(default, deserialize_with = "q::empty_string_as_none")]
pub html_path: Option<String>,
}
#[derive(Default, Deserialize)]
pub struct DetailQuery {
#[serde(default, deserialize_with = "q::empty_string_as_none")]
pub preview_token: Option<String>,
#[serde(default, deserialize_with = "q::empty_string_as_none")]
pub locale: Option<String>,
#[serde(default, deserialize_with = "q::empty_string_as_none")]
pub fields: Option<String>,
}
pub async fn list(
tenant: Tenant,
SessionUser(session_user): SessionUser,
rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
Query(qs): Query<PageListQuery>,
) -> Response {
let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
match list_inner(&tenant, viewer, &qs).await {
Ok(resp) => resp,
Err(e) => {
tracing::error!(target: "rustango_cms::api", error = %e, "pages list failed");
crate::api::error::ApiError::internal().into_response()
}
}
}
async fn list_inner(
tenant: &Tenant,
viewer: Option<&rustango::tenancy::auth::User>,
qs: &PageListQuery,
) -> Result<Response, rustango::sql::ExecError> {
let pool = tenant.pool();
let (limit, offset) = q::paginate(&qs.list);
let fields = q::field_set(&qs.list);
let orderings = match q::parse_order_in(&qs.list, &PAGE_ORDER_FIELDS) {
Ok(v) => v,
Err(msg) => return Ok(crate::api::error::ApiError::bad_request(msg).into_response()),
};
let mut pages: Vec<Page> = Page::objects()
.where_(Page::status.is_in([
PageStatus::Published.as_str().to_owned(),
PageStatus::Archived.as_str().to_owned(),
]))
.order_by(&[("id", false)])
.fetch(pool)
.await?;
if qs.filters.translation_of.is_none() {
pages.retain(|p| p.locale_variant_of.is_none());
}
let triples: Vec<(i64, String, i64)> = pages
.iter()
.map(|p| {
(
p.id.get().copied().unwrap_or_default(),
p.path.clone(),
p.page_type_id,
)
})
.collect();
let denied = crate::view_restriction::denied_page_ids(pool, viewer, &triples).await;
if !denied.is_empty() {
pages.retain(|p| !denied.contains(&p.id.get().copied().unwrap_or_default()));
}
if let Some(type_name) = qs.filters.r#type.as_deref().filter(|s| !s.is_empty()) {
let bare = type_name.rsplit('.').next().unwrap_or(type_name);
if let Some(pt) = lookup_page_type(pool, bare).await? {
let pt_id = pt.id.get().copied().unwrap_or_default();
pages.retain(|p| p.page_type_id == pt_id);
} else {
pages.clear();
}
}
let updated_since = match crate::api::query::parse_updated_since(&qs.list) {
Ok(v) => v,
Err(msg) => return Ok(crate::api::error::ApiError::bad_request(msg).into_response()),
};
if let Some(since) = updated_since {
pages.retain(|p| p.updated_at.get().copied().is_some_and(|t| t >= since));
}
if let Some(raw) = qs.filters.id_in.as_deref() {
let mut wanted = std::collections::HashSet::new();
for seg in raw.split(',').map(str::trim).filter(|s| !s.is_empty()) {
match seg.parse::<i64>() {
Ok(id) => {
wanted.insert(id);
}
Err(_) => {
return Ok(crate::api::error::ApiError::bad_request(format!(
"`id_in` expects comma-separated integers; `{seg}` is not one",
))
.into_response())
}
}
}
pages.retain(|p| p.id.get().copied().is_some_and(|id| wanted.contains(&id)));
}
if let Some(parent_id) = qs.filters.child_of {
pages.retain(|p| p.parent_id == Some(parent_id));
}
if let Some(root_id) = qs.filters.descendant_of {
if let Some(prefix) = visible_path(&pages, root_id) {
pages.retain(|p| p.path != prefix && p.path.starts_with(&prefix));
} else {
pages.clear();
}
}
if let Some(leaf_id) = qs.filters.ancestor_of {
if let Some(path) = visible_path(&pages, leaf_id) {
let ancestor_paths: std::collections::HashSet<String> = ancestor_paths_of(&path);
pages.retain(|p| ancestor_paths.contains(&p.path));
} else {
pages.clear();
}
}
if let Some(canon_id) = qs.filters.translation_of {
pages.retain(|p| p.locale_variant_of == Some(canon_id));
}
if let Some(code) = qs.filters.locale.as_deref().filter(|s| !s.is_empty()) {
let locale = crate::translation::resolve_locale(pool, Some(code)).await?;
if let Some(loc) = locale {
let loc_id = loc.id.get().copied().unwrap_or_default();
if loc.is_default {
} else {
pages.retain(|p| {
p.locale_variant_of.is_some() && {
let _ = loc_id;
true
}
});
}
}
}
if let Some(raw) = qs.filters.tag.as_deref().filter(|s| !s.is_empty()) {
let tagged: std::collections::HashSet<i64> = crate::page_tag::pages_with_tag(pool, raw)
.await?
.into_iter()
.collect();
pages.retain(|p| p.id.get().copied().is_some_and(|id| tagged.contains(&id)));
}
let search_needle = qs.list.search.as_deref().filter(|s| !s.trim().is_empty());
let mut fts_ordered = false;
if let Some(needle) = search_needle {
crate::search_promotion::log_public_query(pool, needle, offset);
let ranked =
crate::search::ranked_public_page_ids(pool, &tenant.org.slug, needle, 1000).await;
let rank: Option<std::collections::HashMap<i64, usize>> =
ranked.map(|r| r.iter().enumerate().map(|(i, id)| (*id, i)).collect());
let n = crate::api::search::fold(needle);
pages.retain(|p| {
rank.as_ref()
.is_some_and(|r| p.id.get().copied().is_some_and(|id| r.contains_key(&id)))
|| crate::api::search::contains_folded(&p.title, &n)
|| crate::api::search::contains_folded(&p.slug, &n)
|| crate::api::search::contains_folded(&p.url_path, &n)
});
if let Some(rank) = &rank {
pages.sort_by_key(|p| {
p.id.get()
.copied()
.and_then(|id| rank.get(&id).copied())
.unwrap_or(usize::MAX)
});
fts_ordered = true;
}
}
if orderings.iter().any(|o| o.random) && offset > 0 {
return Ok(crate::api::error::ApiError::bad_request(
"`order=random` cannot be paged — omit `offset`, or order by a field",
)
.into_response());
}
if fts_ordered && orderings.is_empty() {
} else if orderings.iter().any(|o| o.random) {
use rand::seq::SliceRandom as _;
pages.shuffle(&mut rand::rng());
} else if !orderings.is_empty() {
pages.sort_by(|a, b| compare_pages(a, b, &orderings));
} else {
pages.sort_by(|a, b| {
b.published_at
.cmp(&a.published_at)
.then_with(|| a.title.cmp(&b.title))
.then_with(|| a.id.get().cmp(&b.id.get()))
});
}
if let Some(needle) = search_needle {
if let Ok(Some(q)) = crate::search_promotion::find_by_query(pool, needle).await {
let query_id = q.id.get().copied().unwrap_or_default();
if query_id != 0 {
if let Ok(promos) =
crate::search_promotion::promotions_for_query(pool, query_id).await
{
let mut pinned: Vec<Page> = Vec::with_capacity(promos.len());
for p in &promos {
if let Some(pos) = pages
.iter()
.position(|page| page.id.get().copied() == Some(p.page_id))
{
pinned.push(pages.remove(pos));
}
}
for (i, page) in pinned.into_iter().enumerate() {
pages.insert(i, page);
}
}
}
}
}
let total_count = pages.len();
let window: Vec<&Page> = pages.iter().skip(offset).take(limit).collect();
let did_you_mean = match (fts_ordered, total_count, search_needle) {
(true, 0, Some(needle)) => match crate::search::did_you_mean(pool, needle, 0.3).await {
Some(title) => visible_title(pool, viewer, &title).await,
None => None,
},
_ => None,
};
let type_names = page_type_names(pool).await?;
let mut items = Vec::with_capacity(window.len());
for p in window {
let mut obj = serialize_summary(p, &type_names);
if let Err(msg) = q::validate_fields(fields.as_ref(), &obj) {
return Ok(crate::api::error::ApiError::bad_request(msg).into_response());
}
q::apply_fields(&mut obj, fields.as_ref());
items.push(serde_json::Value::Object(obj));
}
let envelope = q::ListEnvelope {
meta: q::ListMeta {
did_you_mean,
..q::ListMeta::paged(total_count, limit, offset)
},
items,
};
Ok(Json(envelope).into_response())
}
pub async fn detail(
tenant: Tenant,
SessionUser(session_user): SessionUser,
rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
headers: HeaderMap,
Path(id): Path<i64>,
Query(qs): Query<DetailQuery>,
) -> Response {
let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
let allow_draft = qs
.preview_token
.as_deref()
.and_then(|t| crate::preview_token::verify(&tenant.org.slug, t, chrono::Utc::now().timestamp()))
== Some(id);
match detail_inner(
&tenant,
viewer,
&headers,
id,
allow_draft,
qs.locale.as_deref(),
qs.fields.as_deref(),
)
.await
{
Ok(resp) => resp,
Err(e) => {
tracing::error!(target: "rustango_cms::api", error = %e, "page detail failed");
crate::api::error::ApiError::internal().into_response()
}
}
}
pub async fn find(
tenant: Tenant,
SessionUser(session_user): SessionUser,
rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
axum::extract::RawQuery(raw_query): axum::extract::RawQuery,
Query(qs): Query<FindQuery>,
) -> Response {
let Some(html_path) = qs.html_path.filter(|p| !p.is_empty()) else {
return crate::api::error::ApiError::bad_request("missing `html_path` query parameter")
.into_response();
};
let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
let carry = carried_query(raw_query.as_deref());
match find_inner(&tenant, viewer, &html_path, &carry).await {
Ok(resp) => resp,
Err(e) => {
tracing::error!(target: "rustango_cms::api", error = %e, "page find failed");
crate::api::error::ApiError::internal().into_response()
}
}
}
fn carried_query(raw: Option<&str>) -> String {
let Some(raw) = raw.filter(|r| !r.is_empty()) else {
return String::new();
};
let kept: Vec<&str> = raw
.split('&')
.filter(|pair| !pair.is_empty())
.filter(|pair| {
let name = pair.split('=').next().unwrap_or("");
name != "html_path"
})
.collect();
if kept.is_empty() {
String::new()
} else {
format!("?{}", kept.join("&"))
}
}
async fn find_inner(
tenant: &Tenant,
viewer: Option<&rustango::tenancy::auth::User>,
html_path: &str,
carry: &str,
) -> Result<Response, rustango::sql::ExecError> {
let pool = tenant.pool();
let mut rows: Vec<Page> = Page::objects()
.where_(Page::url_path.eq(html_path))
.fetch(pool)
.await?;
if rows.is_empty() {
let alt = if let Some(stripped) = html_path.strip_suffix('/') {
stripped.to_owned()
} else {
format!("{html_path}/")
};
rows = Page::objects()
.where_(Page::url_path.eq(alt))
.fetch(pool)
.await?;
}
let hit = rows
.into_iter()
.find(|p| PageStatus::str_is_public(&p.status));
let id = match hit {
Some(p) => {
let pid = p.id.get().copied().unwrap_or_default();
let denied = crate::view_restriction::denied_page_ids(
pool,
viewer,
&[(pid, p.path.clone(), p.page_type_id)],
)
.await;
if denied.contains(&pid) {
None
} else {
Some(pid)
}
}
None => None,
};
match id {
Some(id) => Ok((
StatusCode::FOUND,
[(
axum::http::header::LOCATION,
format!("/api/v2/pages/{id}/{carry}"),
)],
)
.into_response()),
None => Ok(crate::api::error::ApiError::not_found("page").into_response()),
}
}
async fn detail_inner(
tenant: &Tenant,
viewer: Option<&rustango::tenancy::auth::User>,
headers: &HeaderMap,
id: i64,
allow_draft: bool,
locale_code: Option<&str>,
fields: Option<&str>,
) -> Result<Response, rustango::sql::ExecError> {
let pool = tenant.pool();
let Some(page) = lookup_page(pool, id).await? else {
return Ok(crate::api::error::ApiError::not_found("page").into_response());
};
let is_public = PageStatus::str_is_public(&page.status);
if !is_public && !allow_draft {
return Ok(crate::api::error::ApiError::not_found("page").into_response());
}
if let Some(denial) =
crate::view_restriction_guard::decide(tenant, &page, viewer, headers).await
{
use crate::view_restriction_guard::Denial;
return Ok(match denial {
Denial::NeedsLogin => crate::api::error::ApiError::unauthenticated(),
Denial::Forbidden => crate::api::error::ApiError::forbidden(),
Denial::NeedsPassword { .. } => crate::api::error::ApiError::password_required(),
}
.into_response());
}
let mut alias_owned = None;
if let Some(source_id) = page.alias_of {
match lookup_page(pool, source_id).await? {
Some(src) => alias_owned = Some(crate::page::alias_hybrid(&page, &src)),
None => tracing::warn!(
target: "rustango_cms::api",
alias_id = ?page.id.get().copied(),
source_id,
"alias source missing — serving the alias row verbatim",
),
}
}
let page = alias_owned.as_ref().unwrap_or(&page);
let type_name = page_type_names(pool)
.await?
.get(&page.page_type_id)
.cloned()
.unwrap_or_default();
let locale = crate::translation::resolve_locale(pool, locale_code)
.await
.ok()
.flatten();
let locale_id = locale
.as_ref()
.filter(|l| !l.is_default)
.and_then(|l| l.id.get().copied());
let mut obj =
detail_object_with_type(pool, page, &type_name, None, None, locale_id, viewer).await;
echo_locale(&mut obj, locale.as_ref());
let keep = fields.map(|raw| -> std::collections::HashSet<String> {
raw.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_owned)
.collect()
});
q::apply_fields(&mut obj, keep.as_ref());
Ok(Json(serde_json::Value::Object(obj)).into_response())
}
async fn visible_title(
pool: &rustango::sql::Pool,
viewer: Option<&rustango::tenancy::auth::User>,
title: &str,
) -> Option<String> {
let matches: Vec<Page> = Page::objects()
.where_(Page::title.eq(title.to_owned()))
.where_(Page::status.eq(PageStatus::Published.as_str().to_owned()))
.fetch(pool)
.await
.ok()?;
if matches.is_empty() {
return None;
}
let triples: Vec<(i64, String, i64)> = matches
.iter()
.map(|p| {
(
p.id.get().copied().unwrap_or_default(),
p.path.clone(),
p.page_type_id,
)
})
.collect();
let denied = crate::view_restriction::denied_page_ids(pool, viewer, &triples).await;
triples
.iter()
.any(|(id, _, _)| !denied.contains(id))
.then(|| title.to_owned())
}
fn visible_path(pages: &[Page], id: i64) -> Option<String> {
pages
.iter()
.find(|p| p.id.get().copied() == Some(id))
.map(|p| p.path.clone())
}
pub(crate) fn echo_locale(
obj: &mut serde_json::Map<String, serde_json::Value>,
locale: Option<&crate::locale::Locale>,
) {
if let Some(meta) = obj.get_mut("meta").and_then(|m| m.as_object_mut()) {
meta.insert(
"locale".to_owned(),
locale.map_or(serde_json::Value::Null, |l| serde_json::Value::String(l.code.clone())),
);
}
}
pub async fn detail_object_with_type(
pool: &rustango::sql::Pool,
page: &Page,
type_name: &str,
extension_override: Option<serde_json::Value>,
builder_override: Option<serde_json::Value>,
locale_id: Option<i64>,
viewer: Option<&rustango::tenancy::auth::User>,
) -> serde_json::Map<String, serde_json::Value> {
let id = page.id.get().copied().unwrap_or_default();
let content_id = page.alias_of.unwrap_or(id);
let mut type_names = std::collections::HashMap::new();
type_names.insert(page.page_type_id, type_name.to_owned());
let mut obj = serialize_summary(page, &type_names);
let handler: Option<Box<dyn PageTypeHandler>> = find_handler(type_name);
if let Some(h) = handler {
let routes = h.routes();
if !routes.is_empty() {
let arr: Vec<serde_json::Value> = routes
.iter()
.map(|r| serde_json::json!({ "name": r.name, "pattern": r.pattern.as_str() }))
.collect();
obj.insert("routes".to_owned(), serde_json::Value::Array(arr));
}
let streams = stream_field_names(h.as_ref(), pool, content_id).await;
match extension_override {
Some(mut ext) => {
if !ext.is_null() {
decode_stream_fields(&mut ext, &streams);
obj.insert("extension".to_owned(), ext);
}
}
None => match h.load_extension(pool, content_id).await {
Ok(mut ext) if !ext.is_null() => {
decode_stream_fields(&mut ext, &streams);
obj.insert("extension".to_owned(), ext);
}
Ok(_) => {}
Err(e) => {
tracing::warn!(
target: "rustango_cms::api",
page_id = id,
error = %e,
"load_extension failed in api detail",
);
}
},
}
}
let mut compiled_schema = None;
match builder_override {
Some(values) => {
obj.insert("builder".to_owned(), values);
if locale_id.is_some() {
compiled_schema = crate::page_builder::values::values_for(
pool,
content_id,
page.page_type_id,
None,
)
.await
.map(|(_, c)| c);
}
}
None => {
if let Some((values, compiled)) =
crate::page_builder::values::values_for(pool, content_id, page.page_type_id, None)
.await
{
obj.insert("builder".to_owned(), values);
compiled_schema = Some(compiled);
}
}
}
if let Some(lid) = locale_id {
localize_detail_object(pool, id, type_name, lid, &mut obj, compiled_schema.as_ref()).await;
}
obj.insert(
"children".to_owned(),
serde_json::Value::Array(child_summaries(pool, page, viewer, locale_id).await),
);
obj
}
pub const MAX_CHILDREN: usize = 100;
async fn child_summaries(
pool: &rustango::sql::Pool,
page: &Page,
viewer: Option<&rustango::tenancy::auth::User>,
locale_id: Option<i64>,
) -> Vec<serde_json::Value> {
let Some(&parent_id) = page.id.get() else {
return Vec::new();
};
if page.path.is_empty() {
return Vec::new();
}
let statuses = [
PageStatus::Published.as_str().to_owned(),
PageStatus::Archived.as_str().to_owned(),
];
let mut rows: Vec<Page> = match Page::objects()
.where_(Page::path.like(crate::tree::descendants_like(&page.path)))
.where_(Page::depth.is_in([page.depth + 1, page.depth + 2]))
.where_(Page::status.is_in(statuses))
.order_by(&[("path", false)])
.fetch(pool)
.await
{
Ok(rows) => rows,
Err(e) => {
tracing::warn!(
target: "rustango_cms::api",
page_id = parent_id,
error = %e,
"child summaries lookup failed",
);
return Vec::new();
}
};
let error_tid = crate::error_pages::error_page_type_id(pool).await;
rows.retain(|p| error_tid.is_none_or(|tid| p.page_type_id != tid));
let triples: Vec<(i64, String, i64)> = rows
.iter()
.map(|p| {
(
p.id.get().copied().unwrap_or_default(),
p.path.clone(),
p.page_type_id,
)
})
.collect();
let denied = crate::view_restriction::denied_page_ids(pool, viewer, &triples).await;
let visible: Vec<&Page> = rows
.iter()
.filter(|p| !denied.contains(&p.id.get().copied().unwrap_or_default()))
.filter(|p| p.locale_variant_of.is_none())
.collect();
let mut grandchildren: std::collections::HashSet<i64> = std::collections::HashSet::new();
for p in visible.iter().filter(|p| p.depth == page.depth + 2) {
if let Some(pid) = p.parent_id {
grandchildren.insert(pid);
}
}
let mut children: Vec<&&Page> = visible
.iter()
.filter(|p| p.depth == page.depth + 1)
.collect();
children.sort_by_key(|p| (p.sort_order, p.id.get().copied().unwrap_or_default()));
if children.is_empty() {
return Vec::new();
}
let translations = match locale_id {
Some(lid) => {
let ids: Vec<i64> = children.iter().filter_map(|p| p.id.get().copied()).collect();
crate::translation::fetch_for_pages(pool, &ids, lid)
.await
.unwrap_or_default()
}
None => std::collections::HashMap::new(),
};
children
.into_iter()
.take(MAX_CHILDREN)
.map(|p| {
let id = p.id.get().copied().unwrap_or_default();
let title = translations
.get(&id)
.and_then(|m| m.get("title"))
.filter(|s| !s.is_empty())
.cloned()
.unwrap_or_else(|| p.title.clone());
serde_json::json!({
"id": id,
"title": title,
"slug": p.slug,
"url": if p.url_path.is_empty() { "/" } else { p.url_path.as_str() },
"has_children": grandchildren.contains(&id),
"detail_url": format!("/api/v2/pages/{id}/"),
})
})
.collect()
}
async fn stream_field_names(
h: &dyn PageTypeHandler,
pool: &rustango::sql::Pool,
page_id: i64,
) -> Vec<String> {
h.widgets(pool, page_id)
.await
.unwrap_or_default()
.into_iter()
.filter(|w| w.kind == crate::widget::WidgetKind::Stream)
.map(|w| w.name)
.collect()
}
fn decode_stream_fields(ext: &mut serde_json::Value, names: &[String]) {
let Some(map) = ext.as_object_mut() else {
return;
};
for name in names {
let Some(serde_json::Value::String(raw)) = map.get(name) else {
continue;
};
let decoded = if raw.trim().is_empty() {
serde_json::Value::Array(Vec::new())
} else {
match serde_json::from_str::<serde_json::Value>(raw) {
Ok(v @ serde_json::Value::Array(_)) => v,
_ => continue,
}
};
map.insert(name.clone(), decoded);
}
}
async fn localize_detail_object(
pool: &rustango::sql::Pool,
page_id: i64,
type_name: &str,
locale_id: i64,
obj: &mut serde_json::Map<String, serde_json::Value>,
compiled: Option<&crate::page_builder::compile::CompiledSchema>,
) {
let by_page = crate::translation::fetch_for_pages(pool, &[page_id], locale_id)
.await
.unwrap_or_default();
let Some(here) = by_page.get(&page_id) else {
return; };
let mut value = serde_json::Value::Object(std::mem::take(obj));
crate::translation::overlay_translations(&mut value, &by_page);
if let Some(h) = find_handler(type_name) {
let stream_fields = stream_field_names(h.as_ref(), pool, page_id).await;
if let Some(ext) = value.get_mut("extension") {
decode_stream_fields(ext, &stream_fields);
for name in stream_fields {
if let Some(raw) = ext.get(&name).cloned() {
let localized =
crate::block::translate::apply_translatable_overrides(&name, &raw, here);
if let Some(m) = ext.as_object_mut() {
m.insert(name, localized);
}
}
}
}
}
if let (Some(compiled), Some(builder)) = (compiled, value.get_mut("builder")) {
if let Some(map) = builder.as_object_mut() {
crate::page_builder::values::apply_builder_translations(compiled, map, here);
}
}
if let serde_json::Value::Object(m) = value {
*obj = m;
}
}
async fn lookup_page(
pool: &rustango::sql::Pool,
id: i64,
) -> Result<Option<Page>, rustango::sql::ExecError> {
let mut rows: Vec<Page> = Page::objects().where_(Page::id.eq(id)).fetch(pool).await?;
Ok(rows.pop())
}
async fn lookup_page_type(
pool: &rustango::sql::Pool,
type_name: &str,
) -> Result<Option<PageType>, rustango::sql::ExecError> {
let mut rows: Vec<PageType> = PageType::objects()
.where_(PageType::type_name.eq(type_name.to_owned()))
.fetch(pool)
.await?;
Ok(rows.pop())
}
pub(crate) async fn page_type_names(
pool: &rustango::sql::Pool,
) -> Result<std::collections::HashMap<i64, String>, rustango::sql::ExecError> {
let rows: Vec<PageType> = PageType::objects().fetch(pool).await?;
Ok(rows
.into_iter()
.filter_map(|pt| pt.id.get().copied().map(|id| (id, pt.type_name)))
.collect())
}
fn serialize_summary(
p: &Page,
type_names: &std::collections::HashMap<i64, String>,
) -> serde_json::Map<String, serde_json::Value> {
let id = p.id.get().copied().unwrap_or_default();
let type_name = type_names.get(&p.page_type_id).cloned().unwrap_or_default();
let mut obj = serde_json::Map::new();
obj.insert("id".to_owned(), serde_json::json!(id));
obj.insert(
"meta".to_owned(),
serde_json::json!({
"type": type_name,
"detail_url": format!("/api/v2/pages/{id}/"),
"html_url": p.url_path,
"slug": p.slug,
"depth": p.depth,
"parent_id": p.parent_id,
"alias_of": p.alias_of,
"first_published_at": p.published_at,
"updated_at": p.updated_at.get().copied(),
}),
);
obj.insert("title".to_owned(), serde_json::json!(p.title));
obj.insert(
"url".to_owned(),
serde_json::json!(if p.url_path.is_empty() {
"/"
} else {
p.url_path.as_str()
}),
);
obj.insert("seo_title".to_owned(), serde_json::json!(p.seo_title));
obj.insert(
"seo_description".to_owned(),
serde_json::json!(p.seo_description),
);
obj.insert("robots_index".to_owned(), serde_json::json!(p.robots_index));
obj.insert(
"sitemap_priority".to_owned(),
serde_json::json!(p.sitemap_priority),
);
obj.insert(
"show_in_menus".to_owned(),
serde_json::json!(p.show_in_menus),
);
obj
}
fn ancestor_paths_of(path: &str) -> std::collections::HashSet<String> {
let mut out = std::collections::HashSet::new();
let mut acc = String::new();
for seg in path.split('/').filter(|s| !s.is_empty()) {
acc.push_str(seg);
acc.push('/');
if acc != path {
out.insert(acc.clone());
}
}
out
}
const PAGE_ORDER_FIELDS: [&str; 8] = [
"title",
"slug",
"url_path",
"depth",
"sort_order",
"published_at",
"updated_at",
"created_at",
];
fn compare_pages(a: &Page, b: &Page, specs: &[q::OrderSpec]) -> std::cmp::Ordering {
for spec in specs {
let ord = match spec.field.as_str() {
"title" => a.title.cmp(&b.title),
"slug" => a.slug.cmp(&b.slug),
"url_path" => a.url_path.cmp(&b.url_path),
"depth" => a.depth.cmp(&b.depth),
"sort_order" => a.sort_order.cmp(&b.sort_order),
"published_at" => a.published_at.cmp(&b.published_at),
"updated_at" => a.updated_at.get().cmp(&b.updated_at.get()),
"created_at" => a.created_at.get().cmp(&b.created_at.get()),
_ => continue,
};
if ord != std::cmp::Ordering::Equal {
return if spec.descending { ord.reverse() } else { ord };
}
}
a.id.get().cmp(&b.id.get())
}
#[cfg(test)]
mod tests {
use super::carried_query;
#[test]
fn the_resolved_path_is_not_carried_onto_the_detail_url() {
assert_eq!(carried_query(Some("html_path=%2Fabout")), "");
assert_eq!(carried_query(None), "");
assert_eq!(carried_query(Some("")), "");
}
#[test]
fn everything_else_survives_the_redirect() {
assert_eq!(carried_query(Some("html_path=%2F&locale=fr")), "?locale=fr");
assert_eq!(
carried_query(Some("locale=fr&html_path=%2F&fields=title")),
"?locale=fr&fields=title",
);
}
#[test]
fn a_parameter_this_endpoint_never_heard_of_is_still_forwarded() {
assert_eq!(carried_query(Some("html_path=%2F&whatever=1")), "?whatever=1");
}
#[test]
fn values_are_forwarded_verbatim_not_re_encoded() {
assert_eq!(
carried_query(Some("html_path=%2Fx&preview_token=7.123.ab%2Fcd")),
"?preview_token=7.123.ab%2Fcd",
);
}
}