1use crate::api::query::{Path, Query};
11use axum::response::{IntoResponse, Response};
12use axum::Json;
13use rustango::core::Column as _;
14use rustango::extractors::{SessionUser, Tenant};
15use rustango::sql::FetcherPool as _;
16use serde::Deserialize;
17
18use super::images::{compare_media, MEDIA_ORDER_FIELDS};
19use super::query as q;
20use crate::media::Media;
21
22#[derive(Debug, Default, Deserialize)]
23pub struct DocumentListQuery {
24 #[serde(flatten)]
25 pub list: q::ListQuery,
26 #[serde(default, deserialize_with = "crate::api::query::empty_as_none")]
27 pub collection: Option<i64>,
28}
29
30pub async fn list(
32 tenant: Tenant,
33 SessionUser(session_user): SessionUser,
34 rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
35 crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
36 Query(qs): Query<DocumentListQuery>,
37) -> Response {
38 let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
39 match list_inner(&tenant, viewer, &qs).await {
40 Ok(resp) => resp,
41 Err(e) => {
42 tracing::error!(target: "rustango_cms::api", error = %e, "documents list failed");
43 crate::api::error::ApiError::internal().into_response()
44 }
45 }
46}
47
48async fn list_inner(
49 tenant: &Tenant,
50 viewer: Option<&rustango::tenancy::auth::User>,
51 qs: &DocumentListQuery,
52) -> Result<Response, rustango::sql::ExecError> {
53 let pool = tenant.pool();
54 let (limit, offset) = q::paginate(&qs.list);
55 let fields = q::field_set(&qs.list);
56 let orderings = match q::parse_order_in(&qs.list, &MEDIA_ORDER_FIELDS) {
57 Ok(v) => v,
58 Err(msg) => return Ok(crate::api::error::ApiError::bad_request(msg).into_response()),
59 };
60
61 let mut rows: Vec<Media> = Media::objects()
64 .fetch(pool)
65 .await?
66 .into_iter()
67 .filter(|m| m.kind != "image")
68 .collect();
69
70 let collection_ids: Vec<i64> = rows.iter().filter_map(|m| m.collection_id).collect();
75 let denied_collections = crate::collection_view_restriction::denied_collection_ids(
76 tenant.pool(),
77 viewer,
78 &collection_ids,
79 )
80 .await;
81 if !denied_collections.is_empty() {
82 rows.retain(|m| {
83 m.collection_id
84 .is_none_or(|c| !denied_collections.contains(&c))
85 });
86 }
87
88 if let Some(col_id) = qs.collection {
89 rows.retain(|m| m.collection_id == Some(col_id));
90 }
91
92 if let Some(needle) = qs.list.search.as_deref().filter(|s| !s.trim().is_empty()) {
93 let n = crate::api::search::fold(needle);
94 rows.retain(|m| {
95 crate::api::search::contains_folded(&m.title, &n)
96 || crate::api::search::contains_folded(&m.filename, &n)
97 });
98 }
99
100 if orderings.iter().any(|o| o.random) {
101 use rand::seq::SliceRandom as _;
102 rows.shuffle(&mut rand::rng());
103 } else if !orderings.is_empty() {
104 rows.sort_by(|a, b| compare_media(a, b, &orderings));
105 } else {
106 rows.sort_by(|a, b| b.uploaded_at.get().cmp(&a.uploaded_at.get()));
107 }
108
109 let updated_since = match crate::api::query::parse_updated_since(&qs.list) {
112 Ok(v) => v,
113 Err(msg) => return Ok(crate::api::error::ApiError::bad_request(msg).into_response()),
114 };
115 if let Some(since) = updated_since {
116 rows.retain(|r| r.uploaded_at.get().copied().is_some_and(|t| t >= since));
117 }
118
119 let total_count = rows.len();
120 let window: Vec<&Media> = rows.iter().skip(offset).take(limit).collect();
121
122 let mut items = Vec::with_capacity(window.len());
123 for m in window {
124 let mut obj = serialize_document(m);
125 if let Err(msg) = q::validate_fields(fields.as_ref(), &obj) {
128 return Ok(crate::api::error::ApiError::bad_request(msg).into_response());
129 }
130 q::apply_fields(&mut obj, fields.as_ref());
131 items.push(serde_json::Value::Object(obj));
132 }
133
134 Ok(Json(q::ListEnvelope {
135 meta: q::ListMeta::paged(total_count, limit, offset),
136 items,
137 })
138 .into_response())
139}
140
141pub async fn detail(
143 tenant: Tenant,
144 SessionUser(session_user): SessionUser,
145 rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
146 crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
147 Path(id): Path<i64>,
148 Query(q): Query<crate::api::query::DetailFields>,
149) -> Response {
150 let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
151 match detail_inner(&tenant, viewer, id, &q).await {
152 Ok(resp) => resp,
153 Err(e) => {
154 tracing::error!(target: "rustango_cms::api", error = %e, "document detail failed");
155 crate::api::error::ApiError::internal().into_response()
156 }
157 }
158}
159
160async fn detail_inner(
161 tenant: &Tenant,
162 viewer: Option<&rustango::tenancy::auth::User>,
163 id: i64,
164 q: &crate::api::query::DetailFields,
165) -> Result<Response, rustango::sql::ExecError> {
166 let row: Option<Media> = Media::objects()
167 .where_(Media::id.eq(id))
168 .fetch(tenant.pool())
169 .await?
170 .into_iter()
171 .find(|m| m.kind != "image");
172 match row {
173 Some(m) if !gated_for(tenant, viewer, &m).await => {
177 let mut obj = serialize_document(&m);
178 crate::api::query::apply_fields(&mut obj, q.keep().as_ref());
179 Ok(Json(serde_json::Value::Object(obj)).into_response())
180 }
181 _ => Ok(crate::api::error::ApiError::not_found("document").into_response()),
182 }
183}
184
185async fn gated_for(
187 tenant: &Tenant,
188 viewer: Option<&rustango::tenancy::auth::User>,
189 media: &Media,
190) -> bool {
191 let Some(cid) = media.collection_id else {
192 return false;
193 };
194 !crate::collection_view_restriction::denied_collection_ids(tenant.pool(), viewer, &[cid])
195 .await
196 .is_empty()
197}
198
199fn serialize_document(m: &Media) -> serde_json::Map<String, serde_json::Value> {
200 let id = m.id.get().copied().unwrap_or_default();
201 let mut obj = serde_json::Map::new();
202 obj.insert("id".to_owned(), serde_json::json!(id));
203 obj.insert(
204 "meta".to_owned(),
205 serde_json::json!({
206 "type": "cms.Document",
207 "detail_url": format!("/api/v2/documents/{id}/"),
208 "storage_key": m.storage_key,
209 "content_hash": m.content_hash,
210 }),
211 );
212 obj.insert("title".to_owned(), serde_json::json!(m.title));
213 obj.insert("filename".to_owned(), serde_json::json!(m.filename));
214 obj.insert("mime".to_owned(), serde_json::json!(m.mime));
215 obj.insert("size".to_owned(), serde_json::json!(m.size));
216 obj.insert("kind".to_owned(), serde_json::json!(m.kind));
217 obj.insert(
218 "collection_id".to_owned(),
219 serde_json::json!(m.collection_id),
220 );
221 obj.insert(
222 "uploaded_at".to_owned(),
223 serde_json::json!(m.uploaded_at.get().copied()),
224 );
225 obj
226}