1use chrono::{DateTime, Utc};
11use rustango::sql::Auto;
12use rustango::Model;
13use serde::{Deserialize, Serialize};
14
15#[derive(Model, Debug, Clone, Serialize, Deserialize)]
16#[rustango(
17 table = "cms_page_tag",
18 app = "cms",
19 display = "name",
20 admin(
21 list_display = "page_id, name",
22 ordering = "name, page_id",
23 list_filter = "name",
24 )
25)]
26pub struct PageTag {
27 #[rustango(primary_key)]
28 pub id: Auto<i64>,
29
30 #[rustango(fk = "cms_page", on = "id", index)]
31 pub page_id: i64,
32
33 #[rustango(max_length = 64, index)]
37 pub name: String,
38
39 #[rustango(auto_now_add)]
40 pub created_at: Auto<DateTime<Utc>>,
41}
42
43#[must_use]
46pub fn normalize_name(raw: &str) -> String {
47 raw.split_whitespace()
48 .collect::<Vec<_>>()
49 .join("-")
50 .to_lowercase()
51}
52
53pub async fn tags_for_page(
58 pool: &rustango::sql::Pool,
59 page_id: i64,
60) -> Result<Vec<PageTag>, rustango::sql::ExecError> {
61 use rustango::core::Column as _;
62 use rustango::sql::FetcherPool as _;
63 PageTag::objects()
64 .where_(PageTag::page_id.eq(page_id))
65 .order_by(&[("name", false)])
66 .fetch(pool)
67 .await
68}
69
70pub async fn replace_tags(
76 pool: &rustango::sql::Pool,
77 page_id: i64,
78 names: &[String],
79) -> Result<(), rustango::sql::ExecError> {
80 use rustango::core::Column as _;
81 use rustango::sql::FetcherPool as _;
82 let existing: Vec<PageTag> = PageTag::objects()
83 .where_(PageTag::page_id.eq(page_id))
84 .fetch(pool)
85 .await?;
86 for row in existing {
87 row.delete_pool(pool).await?;
88 }
89 let mut seen = std::collections::HashSet::new();
90 for n in names {
91 let norm = normalize_name(n);
92 if norm.is_empty() || !seen.insert(norm.clone()) {
93 continue;
94 }
95 let mut row = PageTag {
96 id: Auto::Unset,
97 page_id,
98 name: norm,
99 created_at: Auto::Unset,
100 };
101 row.insert_pool(pool).await?;
102 }
103 Ok(())
104}
105
106pub async fn prefetch_for_pages(
117 pool: &rustango::sql::Pool,
118 page_ids: &[i64],
119) -> Result<std::collections::HashMap<i64, Vec<PageTag>>, rustango::sql::ExecError> {
120 use rustango::core::Column as _;
121 use rustango::sql::FetcherPool as _;
122 if page_ids.is_empty() {
123 return Ok(std::collections::HashMap::new());
124 }
125 let rows: Vec<PageTag> = PageTag::objects()
126 .where_(PageTag::page_id.is_in(page_ids.iter().copied()))
127 .order_by(&[("name", false)])
128 .fetch(pool)
129 .await?;
130 let mut by_page: std::collections::HashMap<i64, Vec<PageTag>> =
131 std::collections::HashMap::new();
132 for row in rows {
133 by_page.entry(row.page_id).or_default().push(row);
134 }
135 Ok(by_page)
136}
137
138pub async fn pages_with_tag(
143 pool: &rustango::sql::Pool,
144 name: &str,
145) -> Result<Vec<i64>, rustango::sql::ExecError> {
146 use rustango::core::Column as _;
147 use rustango::sql::FetcherPool as _;
148 let norm = normalize_name(name);
149 let rows: Vec<PageTag> = PageTag::objects()
150 .where_(PageTag::name.eq(norm))
151 .fetch(pool)
152 .await?;
153 Ok(rows.into_iter().map(|r| r.page_id).collect())
154}
155
156pub async fn all_tags(
162 pool: &rustango::sql::Pool,
163) -> Result<Vec<(String, usize)>, rustango::sql::ExecError> {
164 use rustango::sql::FetcherPool as _;
165 let rows: Vec<PageTag> = PageTag::objects().fetch(pool).await?;
166 let mut counts: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
167 for row in rows {
168 *counts.entry(row.name).or_default() += 1;
169 }
170 let mut out: Vec<(String, usize)> = counts.into_iter().collect();
171 out.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
172 Ok(out)
173}
174
175#[cfg(test)]
176mod tests {
177 use super::*;
178
179 #[test]
180 fn normalize_lowercases() {
181 assert_eq!(normalize_name("Hello"), "hello");
182 }
183
184 #[test]
185 fn normalize_collapses_whitespace_to_dash() {
186 assert_eq!(normalize_name(" Hello World "), "hello-world");
187 }
188
189 #[test]
190 fn normalize_empty_stays_empty() {
191 assert_eq!(normalize_name(" "), "");
192 }
193
194 #[test]
195 fn normalize_idempotent() {
196 let once = normalize_name("Foo Bar");
197 let twice = normalize_name(&once);
198 assert_eq!(once, twice);
199 }
200}