1use rustango::core::Column as _;
11use rustango::sql::{Auto, FetcherPool as _, Pool};
12use serde::Deserialize;
13use serde_json::{json, Value};
14
15use super::{with_block_ids, StarterError, UI_APP_LABEL};
16use crate::error_pages::{self as ep, ErrorPageExt};
17use crate::page::{Page, PageStatus};
18use crate::page_type_model::PageType;
19use crate::tree_ops::{NewPage, TreeError};
20
21#[derive(Debug, Deserialize)]
23#[serde(deny_unknown_fields)]
24pub struct ErrorPageSeed {
25 pub status: u16,
27 pub title: String,
28 #[serde(default)]
30 pub slug: String,
31 #[serde(default)]
34 pub body: Value,
35}
36
37impl ErrorPageSeed {
38 fn slug(&self) -> String {
39 if self.slug.is_empty() {
40 format!("error-{}", self.status)
41 } else {
42 self.slug.clone()
43 }
44 }
45}
46
47pub(super) fn problems(seeds: &[ErrorPageSeed], home_slugs: &[&str]) -> Vec<String> {
51 let mut problems = Vec::new();
52 let mut seen = Vec::new();
53 for seed in seeds {
54 let status = seed.status;
55 if !ep::STATUSES.contains(&status) {
56 problems.push(format!("error page {status}: status must be one of 404, 403, 500, 503"));
57 }
58 if seen.contains(&status) {
59 problems.push(format!("error page {status} is listed twice"));
60 }
61 seen.push(status);
62 if home_slugs.contains(&seed.slug().as_str()) {
63 problems.push(format!("error page {status}: slug `{}` is taken by another page", seed.slug()));
64 }
65 match &seed.body {
66 Value::Null => {}
67 Value::Array(entries) => {
68 for entry in entries {
69 let kind = entry["type"].as_str().unwrap_or_default();
70 if !ep::BODY_BLOCKS.contains(&kind) {
71 problems.push(format!(
72 "error page {status}: block `{kind}` is not allowed (use {})",
73 ep::BODY_BLOCKS.join(", ")
74 ));
75 }
76 }
77 }
78 _ => problems.push(format!("error page {status}: `body` must be a list of blocks")),
79 }
80 }
81 problems
82}
83
84pub(super) async fn create(pool: &Pool, home: &Page, seeds: &[ErrorPageSeed]) -> Result<usize, StarterError> {
86 add(pool, home, seeds, false).await
87}
88
89pub(super) async fn add_missing(pool: &Pool, home: &Page, seeds: &[ErrorPageSeed]) -> Result<usize, StarterError> {
94 add(pool, home, seeds, true).await
95}
96
97async fn add(pool: &Pool, home: &Page, seeds: &[ErrorPageSeed], only_missing: bool) -> Result<usize, StarterError> {
98 if seeds.is_empty() {
99 return Ok(0);
100 }
101 let type_id = error_page_type(pool).await?;
102 allow_under(pool, home.page_type_id).await?;
103 let home_id = *home.id.get().ok_or(TreeError::MissingId)?;
104 let mut added = 0;
105 for seed in seeds {
106 let slug = seed.slug();
107 if only_missing {
108 let slug_taken = Page::objects()
109 .where_(Page::parent_id.eq(home_id))
110 .where_(Page::slug.eq(slug.clone()))
111 .first(pool)
112 .await?
113 .is_some();
114 if slug_taken || ep::find_for_status(pool, seed.status).await?.is_some() {
115 continue;
116 }
117 }
118 let new = NewPage::new(type_id, &seed.title, &slug).with_status(PageStatus::Published);
119 let mut page = match Page::create_child_pool(pool, home, new).await {
120 Ok(page) => page,
121 Err(TreeError::DisallowedChildType { .. } | TreeError::DisallowedParentType { .. }) if only_missing => {
122 return Ok(added);
123 }
124 Err(e) => return Err(e.into()),
125 };
126 page.robots_index = false;
127 page.show_in_menus = false;
128 page.save(pool).await?;
129 let page_id = *page.id.get().ok_or(TreeError::MissingId)?;
130 let body = match &seed.body {
131 Value::Null => None,
132 body => {
133 let keyed = with_block_ids(&json!({ "body": body }), &format!("error-{}", seed.status));
134 Some(keyed["body"].to_string())
135 }
136 };
137 let mut row = ErrorPageExt {
138 id: Auto::Unset,
139 page_id,
140 status_code: seed.status.to_string(),
141 body,
142 };
143 row.insert(pool).await?;
144 crate::revision::capture(pool, &page, None).await?;
145 added += 1;
146 }
147 Ok(added)
148}
149
150async fn error_page_type(pool: &Pool) -> Result<i64, StarterError> {
153 if let Some(id) = ep::error_page_type_id(pool).await {
154 return Ok(id);
155 }
156 let handler = crate::page_type::find_handler(ep::TYPE_NAME)
157 .ok_or_else(|| StarterError::Invalid("the Error page type is not registered".into()))?;
158 crate::seed::upsert_page_type(pool, handler.as_ref()).await?;
159 ep::error_page_type_id(pool)
160 .await
161 .ok_or_else(|| StarterError::Invalid("the Error page type could not be set up".into()))
162}
163
164async fn allow_under(pool: &Pool, type_id: i64) -> Result<(), StarterError> {
167 let Some(mut row) = PageType::objects().where_(PageType::id.eq(type_id)).first(pool).await? else {
168 return Ok(());
169 };
170 let mut children = row.allowed_children();
171 if row.app_label != UI_APP_LABEL || children.is_empty() || children.iter().any(|t| t == ep::TYPE_NAME) {
172 return Ok(());
173 }
174 children.push(ep::TYPE_NAME.to_owned());
175 row.allowed_child_types = json!(children);
176 row.save(pool).await?;
177 Ok(())
178}
179
180pub(super) async fn export(pool: &Pool, home: &Page) -> Result<Vec<Value>, StarterError> {
184 let Some(type_id) = ep::error_page_type_id(pool).await else {
185 return Ok(Vec::new());
186 };
187 let Some(home_id) = home.id.get().copied() else {
188 return Ok(Vec::new());
189 };
190 let pages: Vec<Page> = Page::objects()
191 .where_(Page::parent_id.eq(home_id))
192 .where_(Page::page_type_id.eq(type_id))
193 .order_by(&[("sort_order", false), ("id", false)])
194 .fetch(pool)
195 .await?;
196 let mut out: Vec<Value> = Vec::new();
197 for page in pages {
198 let Some(page_id) = page.id.get().copied() else { continue };
199 let Some(ext) = ErrorPageExt::objects()
200 .where_(ErrorPageExt::page_id.eq(page_id))
201 .first(pool)
202 .await?
203 else {
204 continue;
205 };
206 let Ok(status) = ext.status_code.parse::<u16>() else { continue };
207 if out.iter().any(|e| e["status"] == json!(status)) {
208 continue;
209 }
210 let mut blocks: Vec<Value> = ext
211 .body
212 .as_deref()
213 .and_then(|b| serde_json::from_str::<Value>(b).ok())
214 .and_then(|b| b.as_array().cloned())
215 .unwrap_or_default();
216 blocks.retain(|b| b["type"] != "image");
217 for b in &mut blocks {
218 if let Value::Object(fields) = b {
219 fields.remove("id");
220 }
221 }
222 out.push(json!({ "status": status, "title": page.title, "slug": page.slug, "body": blocks }));
223 }
224 Ok(out)
225}
226
227#[cfg(test)]
228mod tests {
229 use super::*;
230
231 fn seed(status: u16, slug: &str, body: Value) -> ErrorPageSeed {
232 ErrorPageSeed { status, title: "T".into(), slug: slug.into(), body }
233 }
234
235 #[test]
236 fn entries_are_checked_before_anything_is_written() {
237 let ok = [
238 seed(404, "", json!([{ "type": "paragraph", "value": { "body": "x" } }])),
239 seed(500, "oops", Value::Null),
240 ];
241 assert!(problems(&ok, &["about"]).is_empty());
242
243 let bad = [
244 seed(418, "", Value::Null),
245 seed(404, "about", json!([{ "type": "gallery", "value": {} }])),
246 seed(404, "", json!("text")),
247 ];
248 let found = problems(&bad, &["about"]).join("; ");
249 for expected in [
250 "status must be one of",
251 "slug `about` is taken",
252 "block `gallery` is not allowed",
253 "listed twice",
254 "must be a list of blocks",
255 ] {
256 assert!(found.contains(expected), "{expected}: {found}");
257 }
258 }
259
260 #[test]
261 fn the_slug_defaults_to_the_status() {
262 assert_eq!(seed(503, "", Value::Null).slug(), "error-503");
263 assert_eq!(seed(404, "page-not-found", Value::Null).slug(), "page-not-found");
264 }
265}