use chrono::{DateTime, Utc};
use rustango::sql::Auto;
use rustango::Model;
use serde::{Deserialize, Serialize};
#[derive(Model, Debug, Clone, Serialize, Deserialize)]
#[rustango(
table = "cms_page_snippet_m2m",
app = "cms",
display = "id",
admin(
list_display = "page_id, snippet_id, relation_name, sort_order",
ordering = "page_id, relation_name, sort_order, id",
list_filter = "relation_name",
)
)]
pub struct PageSnippetM2M {
#[rustango(primary_key)]
pub id: Auto<i64>,
#[rustango(fk = "cms_page", on = "id", index)]
pub page_id: i64,
#[rustango(fk = "cms_snippet", on = "id", index)]
pub snippet_id: i64,
#[rustango(max_length = 64, index)]
pub relation_name: String,
pub sort_order: i32,
#[rustango(auto_now_add)]
pub created_at: Auto<DateTime<Utc>>,
}
pub async fn rows_for_relation(
pool: &rustango::sql::Pool,
page_id: i64,
relation_name: &str,
) -> Result<Vec<PageSnippetM2M>, rustango::sql::ExecError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let mut rows: Vec<PageSnippetM2M> = PageSnippetM2M::objects()
.where_(PageSnippetM2M::page_id.eq(page_id))
.where_(PageSnippetM2M::relation_name.eq(relation_name.to_owned()))
.fetch(pool)
.await?;
rows.sort_by(|a, b| {
a.sort_order
.cmp(&b.sort_order)
.then_with(|| a.id.get().cmp(&b.id.get()))
});
Ok(rows)
}
pub async fn related_snippets(
pool: &rustango::sql::Pool,
page_id: i64,
relation_name: &str,
) -> Result<Vec<crate::snippet::Snippet>, rustango::sql::ExecError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let m2m = rows_for_relation(pool, page_id, relation_name).await?;
if m2m.is_empty() {
return Ok(Vec::new());
}
let ids: Vec<i64> = m2m.iter().map(|r| r.snippet_id).collect();
let snippets: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::id.is_in(ids.iter().copied()))
.fetch(pool)
.await?;
let by_id: std::collections::HashMap<i64, crate::snippet::Snippet> = snippets
.into_iter()
.filter_map(|s| s.id.get().copied().map(|i| (i, s)))
.collect();
let mut out = Vec::with_capacity(m2m.len());
for row in m2m {
if let Some(s) = by_id.get(&row.snippet_id) {
out.push(s.clone());
}
}
Ok(out)
}
pub async fn relate(
pool: &rustango::sql::Pool,
page_id: i64,
snippet_id: i64,
relation_name: &str,
) -> Result<PageSnippetM2M, rustango::sql::ExecError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let existing: Vec<PageSnippetM2M> = PageSnippetM2M::objects()
.where_(PageSnippetM2M::page_id.eq(page_id))
.where_(PageSnippetM2M::snippet_id.eq(snippet_id))
.where_(PageSnippetM2M::relation_name.eq(relation_name.to_owned()))
.fetch(pool)
.await?;
if let Some(row) = existing.into_iter().next() {
return Ok(row);
}
let siblings = rows_for_relation(pool, page_id, relation_name).await?;
let next_sort = siblings
.iter()
.map(|r| r.sort_order)
.max()
.map(|n| n + 1)
.unwrap_or(0);
let mut row = PageSnippetM2M {
id: Auto::Unset,
page_id,
snippet_id,
relation_name: relation_name.to_owned(),
sort_order: next_sort,
created_at: Auto::Unset,
};
row.insert_pool(pool).await?;
Ok(row)
}
pub async fn unrelate(
pool: &rustango::sql::Pool,
page_id: i64,
snippet_id: i64,
relation_name: &str,
) -> Result<(), rustango::sql::ExecError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let existing: Vec<PageSnippetM2M> = PageSnippetM2M::objects()
.where_(PageSnippetM2M::page_id.eq(page_id))
.where_(PageSnippetM2M::snippet_id.eq(snippet_id))
.where_(PageSnippetM2M::relation_name.eq(relation_name.to_owned()))
.fetch(pool)
.await?;
for row in existing {
row.delete_pool(pool).await?;
}
Ok(())
}
pub async fn replace_all(
pool: &rustango::sql::Pool,
page_id: i64,
relation_name: &str,
snippet_ids: &[i64],
) -> Result<(), rustango::sql::ExecError> {
let current = rows_for_relation(pool, page_id, relation_name).await?;
let desired: std::collections::HashSet<i64> = snippet_ids.iter().copied().collect();
for row in ¤t {
if !desired.contains(&row.snippet_id) {
row.clone().delete_pool(pool).await?;
}
}
let kept: std::collections::HashMap<i64, PageSnippetM2M> = current
.into_iter()
.filter(|r| desired.contains(&r.snippet_id))
.map(|r| (r.snippet_id, r))
.collect();
for (i, &snippet_id) in snippet_ids.iter().enumerate() {
let target_sort = i as i32;
if let Some(mut row) = kept.get(&snippet_id).cloned() {
if row.sort_order != target_sort {
row.sort_order = target_sort;
row.save_pool(pool).await?;
}
} else {
let mut row = PageSnippetM2M {
id: Auto::Unset,
page_id,
snippet_id,
relation_name: relation_name.to_owned(),
sort_order: target_sort,
created_at: Auto::Unset,
};
row.insert_pool(pool).await?;
}
}
Ok(())
}
pub async fn rows_for_snippet(
pool: &rustango::sql::Pool,
snippet_id: i64,
) -> Result<Vec<PageSnippetM2M>, rustango::sql::ExecError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
PageSnippetM2M::objects()
.where_(PageSnippetM2M::snippet_id.eq(snippet_id))
.fetch(pool)
.await
}