1use crate::api::query::{Path, Query};
18use axum::response::{IntoResponse, Response};
19use axum::Json;
20use rustango::core::Column as _;
21use rustango::extractors::{SessionUser, Tenant};
22use rustango::sql::FetcherPool as _;
23use rustango::tenancy::member_auth::CurrentMember;
24use serde::Deserialize;
25
26use crate::navigation::{Menu, MenuOptions};
27
28#[derive(Debug, Default, Deserialize)]
30pub struct MenuQuery {
31 #[serde(default, deserialize_with = "crate::api::query::empty_string_as_none")]
39 pub locale: Option<String>,
40 #[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
44 pub current: Option<i64>,
45 #[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
50 pub limit: Option<usize>,
51 #[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
52 pub offset: Option<usize>,
53}
54
55pub async fn list(tenant: Tenant, Query(q): Query<MenuQuery>) -> Response {
61 match list_inner(tenant.pool(), &q).await {
62 Ok(resp) => resp,
63 Err(e) => {
64 tracing::error!(target: "rustango_cms::api", error = %e, "menus list failed");
65 crate::api::error::ApiError::internal().into_response()
66 }
67 }
68}
69
70pub async fn list_inner(
71 pool: &rustango::sql::Pool,
72 q: &MenuQuery,
73) -> Result<Response, rustango::sql::ExecError> {
74 let mut menus: Vec<Menu> = Menu::objects().fetch(pool).await?;
75 menus.sort_by(|a, b| a.slug.cmp(&b.slug));
76
77 let total_count = menus.len();
78 let limit = crate::api::query::clamp_limit(q.limit);
79 let offset = q.offset.unwrap_or(0);
80
81 let items: Vec<serde_json::Value> = menus
82 .iter()
83 .skip(offset)
84 .take(limit)
85 .map(|m| {
86 serde_json::json!({
87 "slug": m.slug,
88 "name": m.name,
89 "detail_url": format!("/api/v2/menus/{}/", encode_slug(&m.slug)),
93 })
94 })
95 .collect();
96
97 let meta = crate::api::query::ListMeta::paged(total_count, limit, offset);
104 Ok(Json(crate::api::query::ListEnvelope { meta, items }).into_response())
105}
106
107pub async fn detail(
110 tenant: Tenant,
111 SessionUser(session_user): SessionUser,
112 CurrentMember(member): CurrentMember,
113 crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
114 Path(slug): Path<String>,
115 Query(q): Query<MenuQuery>,
116) -> Response {
117 let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
118 match detail_inner(tenant.pool(), viewer, &slug, &q).await {
119 Ok(resp) => resp,
120 Err(e) => {
121 tracing::error!(target: "rustango_cms::api", error = %e, slug = %slug, "menu detail failed");
122 crate::api::error::ApiError::internal().into_response()
123 }
124 }
125}
126
127pub async fn detail_inner(
130 pool: &rustango::sql::Pool,
131 viewer: Option<&rustango::tenancy::auth::User>,
132 slug: &str,
133 q: &MenuQuery,
134) -> Result<Response, rustango::sql::ExecError> {
135 let locale = crate::translation::resolve_locale(pool, q.locale.as_deref()).await?;
136
137 let current = match q.current {
147 Some(id) => {
148 let found = crate::page::Page::objects()
149 .where_(crate::page::Page::id.eq(id))
150 .where_(crate::page::Page::status.is_in([
151 crate::page::PageStatus::Published.as_str().to_owned(),
152 crate::page::PageStatus::Archived.as_str().to_owned(),
153 ]))
154 .first(pool)
155 .await?;
156 match found {
157 Some(p) => {
158 let pid = p.id.get().copied().unwrap_or_default();
159 let denied = crate::view_restriction::denied_page_ids(
160 pool,
161 viewer,
162 &[(pid, p.path.clone(), p.page_type_id)],
163 )
164 .await;
165 (!denied.contains(&pid)).then_some(p)
166 }
167 None => None,
168 }
169 }
170 None => None,
171 };
172
173 let opts = MenuOptions {
174 viewer,
175 locale: locale.as_ref(),
176 current: current.as_ref(),
177 };
178 let Some(menu) = crate::navigation::resolve_menu_with(pool, slug, opts).await? else {
179 return Ok(crate::api::error::ApiError::not_found("menu").into_response());
180 };
181
182 Ok(Json(serde_json::json!({
185 "meta": {
186 "slug": menu.slug,
187 "name": menu.name,
188 "locale": locale.as_ref().map(|l| l.code.clone()),
189 "current": current.as_ref().and_then(|p| p.id.get().copied()),
190 "total_count": count_items(&menu.items),
191 },
192 "items": menu.items,
193 }))
194 .into_response())
195}
196
197fn encode_slug(slug: &str) -> String {
204 let mut out = String::with_capacity(slug.len());
205 for b in slug.bytes() {
206 if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'~') {
207 out.push(char::from(b));
208 } else {
209 out.push_str(&format!("%{b:02X}"));
210 }
211 }
212 out
213}
214
215fn count_items(items: &[crate::navigation::ResolvedMenuItem]) -> usize {
218 items.len() + items.iter().map(|i| count_items(&i.children)).sum::<usize>()
219}
220
221#[cfg(test)]
222mod tests {
223 use super::*;
224 use crate::navigation::ResolvedMenuItem;
225
226 fn item(children: Vec<ResolvedMenuItem>) -> ResolvedMenuItem {
227 ResolvedMenuItem {
228 id: None,
229 label: String::new(),
230 url: Some("/".to_owned()),
231 is_page: false,
232 page_id: None,
233 open_in_new_tab: false,
234 is_active: false,
235 in_active_trail: false,
236 children,
237 }
238 }
239
240 #[test]
241 fn a_slug_with_a_slash_is_encoded_into_one_segment() {
242 assert_eq!(encode_slug("a/b"), "a%2Fb");
244 assert_eq!(encode_slug("my menu"), "my%20menu");
245 }
246
247 #[test]
248 fn an_ordinary_slug_is_left_alone() {
249 assert_eq!(encode_slug("main-nav_2.0~x"), "main-nav_2.0~x");
250 }
251
252 #[test]
253 fn count_items_counts_the_whole_tree() {
254 let tree = vec![item(vec![item(vec![]), item(vec![])]), item(vec![])];
256 assert_eq!(count_items(&tree), 4);
257 }
258
259 #[test]
260 fn count_items_on_an_empty_menu_is_zero() {
261 assert_eq!(count_items(&[]), 0);
262 }
263}