use crate::api::query::{Path, Query};
use axum::response::{IntoResponse, Response};
use axum::Json;
use rustango::core::Column as _;
use rustango::extractors::{SessionUser, Tenant};
use rustango::sql::FetcherPool as _;
use rustango::tenancy::member_auth::CurrentMember;
use serde::Deserialize;
use crate::navigation::{Menu, MenuOptions};
#[derive(Debug, Default, Deserialize)]
pub struct MenuQuery {
#[serde(default, deserialize_with = "crate::api::query::empty_string_as_none")]
pub locale: Option<String>,
#[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
pub current: Option<i64>,
#[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
pub limit: Option<usize>,
#[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
pub offset: Option<usize>,
}
pub async fn list(tenant: Tenant, Query(q): Query<MenuQuery>) -> Response {
match list_inner(tenant.pool(), &q).await {
Ok(resp) => resp,
Err(e) => {
tracing::error!(target: "rustango_cms::api", error = %e, "menus list failed");
crate::api::error::ApiError::internal().into_response()
}
}
}
pub async fn list_inner(
pool: &rustango::sql::Pool,
q: &MenuQuery,
) -> Result<Response, rustango::sql::ExecError> {
let mut menus: Vec<Menu> = Menu::objects().fetch(pool).await?;
menus.sort_by(|a, b| a.slug.cmp(&b.slug));
let total_count = menus.len();
let limit = crate::api::query::clamp_limit(q.limit);
let offset = q.offset.unwrap_or(0);
let items: Vec<serde_json::Value> = menus
.iter()
.skip(offset)
.take(limit)
.map(|m| {
serde_json::json!({
"slug": m.slug,
"name": m.name,
"detail_url": format!("/api/v2/menus/{}/", encode_slug(&m.slug)),
})
})
.collect();
let meta = crate::api::query::ListMeta::paged(total_count, limit, offset);
Ok(Json(crate::api::query::ListEnvelope { meta, items }).into_response())
}
pub async fn detail(
tenant: Tenant,
SessionUser(session_user): SessionUser,
CurrentMember(member): CurrentMember,
crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
Path(slug): Path<String>,
Query(q): Query<MenuQuery>,
) -> Response {
let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
match detail_inner(tenant.pool(), viewer, &slug, &q).await {
Ok(resp) => resp,
Err(e) => {
tracing::error!(target: "rustango_cms::api", error = %e, slug = %slug, "menu detail failed");
crate::api::error::ApiError::internal().into_response()
}
}
}
pub async fn detail_inner(
pool: &rustango::sql::Pool,
viewer: Option<&rustango::tenancy::auth::User>,
slug: &str,
q: &MenuQuery,
) -> Result<Response, rustango::sql::ExecError> {
let locale = crate::translation::resolve_locale(pool, q.locale.as_deref()).await?;
let current = match q.current {
Some(id) => {
let found = crate::page::Page::objects()
.where_(crate::page::Page::id.eq(id))
.where_(crate::page::Page::status.is_in([
crate::page::PageStatus::Published.as_str().to_owned(),
crate::page::PageStatus::Archived.as_str().to_owned(),
]))
.first(pool)
.await?;
match found {
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;
(!denied.contains(&pid)).then_some(p)
}
None => None,
}
}
None => None,
};
let opts = MenuOptions {
viewer,
locale: locale.as_ref(),
current: current.as_ref(),
};
let Some(menu) = crate::navigation::resolve_menu_with(pool, slug, opts).await? else {
return Ok(crate::api::error::ApiError::not_found("menu").into_response());
};
Ok(Json(serde_json::json!({
"meta": {
"slug": menu.slug,
"name": menu.name,
"locale": locale.as_ref().map(|l| l.code.clone()),
"current": current.as_ref().and_then(|p| p.id.get().copied()),
"total_count": count_items(&menu.items),
},
"items": menu.items,
}))
.into_response())
}
fn encode_slug(slug: &str) -> String {
let mut out = String::with_capacity(slug.len());
for b in slug.bytes() {
if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'~') {
out.push(char::from(b));
} else {
out.push_str(&format!("%{b:02X}"));
}
}
out
}
fn count_items(items: &[crate::navigation::ResolvedMenuItem]) -> usize {
items.len() + items.iter().map(|i| count_items(&i.children)).sum::<usize>()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::navigation::ResolvedMenuItem;
fn item(children: Vec<ResolvedMenuItem>) -> ResolvedMenuItem {
ResolvedMenuItem {
id: None,
label: String::new(),
url: Some("/".to_owned()),
is_page: false,
page_id: None,
open_in_new_tab: false,
is_active: false,
in_active_trail: false,
children,
}
}
#[test]
fn a_slug_with_a_slash_is_encoded_into_one_segment() {
assert_eq!(encode_slug("a/b"), "a%2Fb");
assert_eq!(encode_slug("my menu"), "my%20menu");
}
#[test]
fn an_ordinary_slug_is_left_alone() {
assert_eq!(encode_slug("main-nav_2.0~x"), "main-nav_2.0~x");
}
#[test]
fn count_items_counts_the_whole_tree() {
let tree = vec![item(vec![item(vec![]), item(vec![])]), item(vec![])];
assert_eq!(count_items(&tree), 4);
}
#[test]
fn count_items_on_an_empty_menu_is_zero() {
assert_eq!(count_items(&[]), 0);
}
}