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::query as q;
19use crate::media::Media;
20
21#[derive(Debug, Default, Deserialize)]
22pub struct ImageListQuery {
23 #[serde(flatten)]
24 pub list: q::ListQuery,
25 #[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<ImageListQuery>,
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, "images 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: &ImageListQuery,
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()
62 .where_(Media::kind.eq("image".to_owned()))
63 .fetch(pool)
64 .await?;
65
66 let collection_ids: Vec<i64> = rows.iter().filter_map(|m| m.collection_id).collect();
71 let denied_collections = crate::collection_view_restriction::denied_collection_ids(
72 tenant.pool(),
73 viewer,
74 &collection_ids,
75 )
76 .await;
77 if !denied_collections.is_empty() {
78 rows.retain(|m| {
79 m.collection_id
80 .is_none_or(|c| !denied_collections.contains(&c))
81 });
82 }
83
84 if let Some(col_id) = qs.collection {
85 rows.retain(|m| m.collection_id == Some(col_id));
86 }
87
88 if let Some(needle) = qs.list.search.as_deref().filter(|s| !s.trim().is_empty()) {
89 let n = crate::api::search::fold(needle);
90 rows.retain(|m| {
91 crate::api::search::contains_folded(&m.title, &n)
92 || crate::api::search::contains_folded(&m.filename, &n)
93 || crate::api::search::contains_folded(&m.alt_text, &n)
94 });
95 }
96
97 if orderings.iter().any(|o| o.random) {
98 use rand::seq::SliceRandom as _;
99 rows.shuffle(&mut rand::rng());
100 } else if !orderings.is_empty() {
101 rows.sort_by(|a, b| compare_media(a, b, &orderings));
102 } else {
103 rows.sort_by(|a, b| b.uploaded_at.get().cmp(&a.uploaded_at.get()));
104 }
105
106 let updated_since = match crate::api::query::parse_updated_since(&qs.list) {
109 Ok(v) => v,
110 Err(msg) => return Ok(crate::api::error::ApiError::bad_request(msg).into_response()),
111 };
112 if let Some(since) = updated_since {
113 rows.retain(|r| r.uploaded_at.get().copied().is_some_and(|t| t >= since));
114 }
115
116 let total_count = rows.len();
117 let window: Vec<&Media> = rows.iter().skip(offset).take(limit).collect();
118
119 let mut items = Vec::with_capacity(window.len());
120 for m in window {
121 let mut obj = serialize_image(m);
122 if let Err(msg) = q::validate_fields(fields.as_ref(), &obj) {
125 return Ok(crate::api::error::ApiError::bad_request(msg).into_response());
126 }
127 q::apply_fields(&mut obj, fields.as_ref());
128 items.push(serde_json::Value::Object(obj));
129 }
130
131 Ok(Json(q::ListEnvelope {
132 meta: q::ListMeta::paged(total_count, limit, offset),
133 items,
134 })
135 .into_response())
136}
137
138pub async fn detail(
140 tenant: Tenant,
141 SessionUser(session_user): SessionUser,
142 rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
143 crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
144 Path(id): Path<i64>,
145 Query(q): Query<crate::api::query::DetailFields>,
146) -> Response {
147 let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
148 match detail_inner(&tenant, viewer, id, &q).await {
149 Ok(resp) => resp,
150 Err(e) => {
151 tracing::error!(target: "rustango_cms::api", error = %e, "image detail failed");
152 crate::api::error::ApiError::internal().into_response()
153 }
154 }
155}
156
157async fn detail_inner(
158 tenant: &Tenant,
159 viewer: Option<&rustango::tenancy::auth::User>,
160 id: i64,
161 q: &crate::api::query::DetailFields,
162) -> Result<Response, rustango::sql::ExecError> {
163 let row: Option<Media> = Media::objects()
164 .where_(Media::id.eq(id))
165 .where_(Media::kind.eq("image".to_owned()))
166 .first(tenant.pool())
167 .await?;
168 match row {
169 Some(m) if !gated_for(tenant, viewer, &m).await => {
173 let mut obj = serialize_image(&m);
174 crate::api::query::apply_fields(&mut obj, q.keep().as_ref());
175 Ok(Json(serde_json::Value::Object(obj)).into_response())
176 }
177 _ => Ok(crate::api::error::ApiError::not_found("image").into_response()),
178 }
179}
180
181async fn gated_for(
183 tenant: &Tenant,
184 viewer: Option<&rustango::tenancy::auth::User>,
185 media: &Media,
186) -> bool {
187 let Some(cid) = media.collection_id else {
188 return false;
189 };
190 !crate::collection_view_restriction::denied_collection_ids(tenant.pool(), viewer, &[cid])
191 .await
192 .is_empty()
193}
194
195pub(super) fn serialize_image(m: &Media) -> serde_json::Map<String, serde_json::Value> {
196 let id = m.id.get().copied().unwrap_or_default();
197 let hash_v: String = m.content_hash.chars().take(12).collect();
198 let mut obj = serde_json::Map::new();
199 obj.insert("id".to_owned(), serde_json::json!(id));
200 obj.insert(
201 "meta".to_owned(),
202 serde_json::json!({
203 "type": "cms.Image",
204 "detail_url": format!("/api/v2/images/{id}/"),
205 "download_url_template": format!(
206 "/__media__/{{filter_spec}}/{id}?v={hash_v}"
207 ),
208 }),
209 );
210 let hash = m.content_hash.as_str();
215 obj.insert(
216 "renditions".to_owned(),
217 serde_json::json!({
218 "thumbnail": crate::rendition::rendition_url_for(id, "fill-100x100", Some(hash)),
219 "medium": crate::rendition::rendition_url_for(id, "width-800", Some(hash)),
220 "large": crate::rendition::rendition_url_for(id, "width-1600", Some(hash)),
221 }),
222 );
223 obj.insert("title".to_owned(), serde_json::json!(m.title));
224 obj.insert("filename".to_owned(), serde_json::json!(m.filename));
225 obj.insert("alt_text".to_owned(), serde_json::json!(m.alt_text));
226 obj.insert("description".to_owned(), serde_json::json!(m.description));
227 obj.insert("mime".to_owned(), serde_json::json!(m.mime));
228 obj.insert("size".to_owned(), serde_json::json!(m.size));
229 obj.insert("width".to_owned(), serde_json::json!(m.width));
230 obj.insert("height".to_owned(), serde_json::json!(m.height));
231 obj.insert(
232 "focal_point_x".to_owned(),
233 serde_json::json!(m.focal_point_x),
234 );
235 obj.insert(
236 "focal_point_y".to_owned(),
237 serde_json::json!(m.focal_point_y),
238 );
239 obj.insert(
240 "collection_id".to_owned(),
241 serde_json::json!(m.collection_id),
242 );
243 obj.insert(
244 "uploaded_at".to_owned(),
245 serde_json::json!(m.uploaded_at.get().copied()),
246 );
247 obj
248}
249
250pub(super) const MEDIA_ORDER_FIELDS: [&str; 4] = ["title", "filename", "size", "uploaded_at"];
255
256pub(super) fn compare_media(a: &Media, b: &Media, specs: &[q::OrderSpec]) -> std::cmp::Ordering {
257 for spec in specs {
258 let ord = match spec.field.as_str() {
259 "title" => a.title.cmp(&b.title),
260 "filename" => a.filename.cmp(&b.filename),
261 "size" => a.size.cmp(&b.size),
262 "uploaded_at" => a.uploaded_at.get().cmp(&b.uploaded_at.get()),
263 _ => continue,
264 };
265 if ord != std::cmp::Ordering::Equal {
266 return if spec.descending { ord.reverse() } else { ord };
267 }
268 }
269 std::cmp::Ordering::Equal
270}