1use anyhow::{Context, Result, bail};
2use serde_json::{Map, Value, json};
3use std::{any::Any, fs, path::Path};
4
5pub const FORMAT: &str = "Reports.net PrintData";
6pub const VERSION: &str = "1.0";
7
8#[derive(Default)]
11pub struct PrintData {
12 definition: Option<Value>,
13 pages: Vec<Value>,
14 page: Option<Value>,
15}
16
17impl PrintData {
18 pub fn new() -> Self {
19 Self::default()
20 }
21
22 pub fn set_definition(&mut self, definition: &Value) -> Result<&mut Self> {
23 if self.page.is_some() {
24 bail!("Cannot change the definition inside a page")
25 }
26 assert_definition(definition)?;
27 if let Some(previous) = &self.definition {
28 for page in &mut self.pages {
29 if page["Definition"].is_null() {
30 page["Definition"] = previous.clone();
31 }
32 }
33 }
34 self.definition = Some(definition.clone());
35 Ok(self)
36 }
37
38 pub fn page_start(&mut self) -> Result<&mut Self> {
39 self.page_start_with(None)
40 }
41
42 pub fn page_start_with(&mut self, definition: Option<&Value>) -> Result<&mut Self> {
43 if self.page.is_some() {
44 bail!("Call page_end before starting another page")
45 }
46 if let Some(value) = definition {
47 assert_definition(value)?;
48 }
49 if definition.is_none() && self.definition.is_none() {
50 bail!("Set a definition first")
51 }
52 self.page = Some(json!({
53 "Index": self.pages.len() + 1,
54 "Definition": definition.cloned().unwrap_or(Value::Null),
55 "Values": [],
56 "DynamicAttributes": []
57 }));
58 Ok(self)
59 }
60
61 pub fn set_value<T: Into<Value> + 'static>(&mut self, name: &str, value: T) -> Result<&mut Self> {
62 self.set_value_at(name, value, 0, true)
63 }
64
65 pub fn set_value_at(
66 &mut self,
67 name: &str,
68 value: impl Into<Value> + 'static,
69 index: usize,
70 drawing: bool,
71 ) -> Result<&mut Self> {
72 let kind = self.inferred_type(name)?;
73 self.add_value(name, &kind, input_value(value)?, index, None, drawing)
74 }
75
76 pub fn set_repeated_value(
77 &mut self,
78 name: &str,
79 value: impl Into<Value> + 'static,
80 x: usize,
81 y: usize,
82 drawing: bool,
83 ) -> Result<&mut Self> {
84 let kind = self.inferred_type(name)?;
85 self.add_value(name, &kind, input_value(value)?, 0, Some((x, y)), drawing)
86 }
87
88 pub fn set_typed_value(
89 &mut self,
90 name: &str,
91 kind: &str,
92 value: impl Into<Value> + 'static,
93 index: usize,
94 drawing: bool,
95 ) -> Result<&mut Self> {
96 self.add_value(name, kind, input_value(value)?, index, None, drawing)
97 }
98
99 pub fn set_image(&mut self, name: &str, source: impl Into<Value> + 'static) -> Result<&mut Self> {
100 self.set_typed_value(name, "DynamicImage", source, 0, true)
101 }
102
103 pub fn set_barcode(&mut self, name: &str, code: impl Into<Value> + 'static) -> Result<&mut Self> {
104 self.set_typed_value(name, "DynamicBarcode", code, 0, true)
105 }
106
107 pub fn draw_object(&mut self, name: &str, index: usize, kind: &str) -> Result<&mut Self> {
108 self.add_value(name, kind, Value::Null, index, None, true)
109 }
110
111 pub fn change_attributes(
112 &mut self,
113 name: &str,
114 values: Value,
115 index: usize,
116 ) -> Result<&mut Self> {
117 let kind = self.inferred_type(name)?;
118 self.change_repeated_attributes(name, values, index, None, &kind)
119 }
120
121 pub fn change_repeated_attributes(
122 &mut self,
123 name: &str,
124 values: Value,
125 index: usize,
126 repeat: Option<(usize, usize)>,
127 kind: &str,
128 ) -> Result<&mut Self> {
129 let normalized = normalize_attributes(values)?;
130 let mut item = json!({"Name": required(name)?, "Type": required(kind)?, "Index": index, "Values": normalized});
131 if let Some((x, y)) = repeat {
132 item["IndexX"] = json!(x);
133 item["IndexY"] = json!(y);
134 }
135 self.page_mut()?["DynamicAttributes"]
136 .as_array_mut()
137 .unwrap()
138 .push(item);
139 Ok(self)
140 }
141
142 pub fn page_end(&mut self) -> Result<&mut Self> {
143 let page = self.page.take().context("Call page_start first")?;
144 self.pages.push(page);
145 Ok(self)
146 }
147
148 pub fn to_value(&self) -> Result<Value> {
149 if self.page.is_some() {
150 bail!("An unfinished page exists")
151 }
152 let definition = self
153 .definition
154 .as_ref()
155 .context("A definition is required")?;
156 if self.pages.is_empty() {
157 bail!("At least one completed page is required")
158 }
159 Ok(
160 json!({"Format": FORMAT, "Version": VERSION, "Definition": definition, "Pages": self.pages}),
161 )
162 }
163
164 pub fn to_json(&self, pretty: bool) -> Result<String> {
165 let mut text = if pretty {
166 serde_json::to_string_pretty(&self.to_value()?)?
167 } else {
168 serde_json::to_string(&self.to_value()?)?
169 };
170 text.push('\n');
171 Ok(text)
172 }
173
174 pub fn save(&self, path: &Path) -> Result<()> {
175 let parent = path.parent().context("Destination has no parent")?;
176 let mut temp = tempfile_path(
177 parent,
178 path.file_name()
179 .and_then(|v| v.to_str())
180 .unwrap_or("print.prepej"),
181 );
182 while temp.exists() {
183 temp = tempfile_path(parent, "print.prepej");
184 }
185 fs::write(&temp, self.to_json(true)?)?;
186 fs::rename(&temp, path).or_else(|_| {
187 fs::copy(&temp, path)?;
188 fs::remove_file(&temp)
189 })?;
190 Ok(())
191 }
192
193 fn add_value(
194 &mut self,
195 name: &str,
196 kind: &str,
197 value: Value,
198 index: usize,
199 repeat: Option<(usize, usize)>,
200 drawing: bool,
201 ) -> Result<&mut Self> {
202 let mut item = json!({"Name": required(name)?, "Type": required(kind)?, "Index": index, "Drawing": drawing, "Value": scalar(value)?});
203 if let Some((x, y)) = repeat {
204 item["IndexX"] = json!(x);
205 item["IndexY"] = json!(y);
206 }
207 self.page_mut()?["Values"]
208 .as_array_mut()
209 .unwrap()
210 .push(item);
211 Ok(self)
212 }
213
214 fn inferred_type(&self, name: &str) -> Result<String> {
216 let page = self.page.as_ref().context("Call page_start first")?;
217 let d = if page["Definition"].is_null() { self.definition.as_ref().context("Set a definition first")? } else { &page["Definition"] };
218 let mut objects: Vec<&Value> = d["Objects"].as_array().map(|v| v.iter().collect()).unwrap_or_default();
219 if let Some(pages) = d["pages"].as_array() {
220 for p in pages { if let Some(items) = p["objects"].as_array() { objects.extend(items); } }
221 }
222 let kinds = ["Text", "Line", "Square", "Circle", "Image", "Barcode"];
223 for o in objects {
224 if o.get("Name").or_else(|| o.get("name")).and_then(Value::as_str) != Some(required(name)?) { continue; }
225 let k = o["Kind"].as_u64().or_else(|| o["Kind"].as_str().and_then(|s| s.parse::<u64>().ok()));
226 if let Some(k) = k.filter(|k| *k < 6) { return Ok(format!("Dynamic{}", kinds[k as usize])); }
227 let k = match o["kind"].as_str() { Some("text")=>Some("Text"), Some("line")=>Some("Line"), Some("rectangle")=>Some("Square"), Some("ellipse")=>Some("Circle"), Some("image")=>Some("Image"), Some("barcode")=>Some("Barcode"), _=>None };
228 if let Some(k) = k { return Ok(format!("Dynamic{k}")); }
229 }
230 Ok("DynamicText".into())
231 }
232 fn page_mut(&mut self) -> Result<&mut Value> {
233 self.page.as_mut().context("Call page_start first")
234 }
235}
236
237fn tempfile_path(parent: &Path, name: &str) -> std::path::PathBuf {
238 parent.join(format!(
239 ".{name}.{}.tmp",
240 std::time::SystemTime::now()
241 .duration_since(std::time::UNIX_EPOCH)
242 .unwrap()
243 .as_nanos()
244 ))
245}
246
247fn required(value: &str) -> Result<&str> {
248 let value = value.trim();
249 if value.is_empty() {
250 bail!("A name is required")
251 } else {
252 Ok(value)
253 }
254}
255
256fn scalar(value: Value) -> Result<Value> {
257 match value {
258 Value::Null => Ok(Value::Null),
259 Value::String(value) => Ok(Value::String(value)),
260 Value::Bool(value) => Ok(Value::String(value.to_string())),
261 Value::Number(value) => Ok(Value::String(value.to_string())),
262 _ => bail!("Values must be scalar"),
263 }
264}
265
266fn input_value<T: Into<Value> + 'static>(value: T) -> Result<Value> {
267 let input = &value as &dyn Any;
268 if input.downcast_ref::<f64>().is_some_and(|v| !v.is_finite())
269 || input.downcast_ref::<f32>().is_some_and(|v| !v.is_finite())
270 {
271 bail!("Numbers must be finite")
272 }
273 Ok(value.into())
274}
275
276fn normalize_attributes(value: Value) -> Result<Value> {
277 let Value::Object(values) = value else {
278 bail!("Attributes must be an object")
279 };
280 let mut result = Map::new();
281 for (key, value) in values {
282 if value.is_null() {
283 bail!("Attribute values cannot be null")
284 }
285 result.insert(key, scalar(value)?);
286 }
287 Ok(Value::Object(result))
288}
289
290pub fn assert_definition(value: &Value) -> Result<()> {
291 let portable = value.get("Version").is_some_and(|v| !v.is_null())
292 && value.get("Objects").is_some_and(Value::is_array)
293 && matches!(
294 value
295 .get("CoordinateUnit")
296 .and_then(Value::as_str)
297 .unwrap_or("mm")
298 .to_ascii_lowercase()
299 .as_str(),
300 "mm" | "px"
301 );
302 let web = value.get("format").and_then(Value::as_str) == Some("pao-reports-web")
303 && value.get("version").and_then(Value::as_i64) == Some(1)
304 && value
305 .get("pages")
306 .and_then(Value::as_array)
307 .is_some_and(|v| !v.is_empty());
308 if portable || web {
309 Ok(())
310 } else {
311 bail!("Invalid report definition")
312 }
313}
314
315#[cfg(test)]
316mod tests {
317 use super::*;
318 #[test]
319 fn inferred_types_and_page_override() {
320 let kinds=["Text","Line","Square","Circle","Image","Barcode"];
321 let objects:Vec<Value>=kinds.iter().enumerate().map(|(k,n)|json!({"Name":n,"Kind":k})).collect();
322 let mut p=PrintData::new();p.set_definition(&json!({"Version":"1","Objects":objects})).unwrap().page_start().unwrap();
323 for kind in kinds {p.set_value_at(kind,"",2,true).unwrap().set_repeated_value(kind,"",1,2,true).unwrap().change_attributes(kind,json!({"X":12}),2).unwrap();}
324 p.set_typed_value("Image","DynamicText","explicit",0,true).unwrap().page_end().unwrap();
325 p.page_start_with(Some(&json!({"format":"pao-reports-web","version":1,"pages":[{"objects":[{"name":"Image","kind":"line"}]}]}))).unwrap().set_value("Image","").unwrap().page_end().unwrap();
326 let v=p.to_value().unwrap();let pages=&v["Pages"];
327 for (k,kind) in kinds.iter().enumerate() {assert_eq!(pages[0]["Values"][k*2]["Type"],format!("Dynamic{kind}"));assert_eq!(pages[0]["Values"][k*2+1]["Type"],format!("Dynamic{kind}"));assert_eq!(pages[0]["DynamicAttributes"][k]["Type"],format!("Dynamic{kind}"));}
328 assert_eq!(pages[0]["Values"][12]["Type"],"DynamicText");assert_eq!(pages[1]["Values"][0]["Type"],"DynamicLine");
329 }
330 fn definition() -> Value {
331 json!({"Version":"1", "CoordinateUnit":"mm", "Objects":[]})
332 }
333
334 #[test]
335 fn creates_canonical_values_repeats_and_attributes() {
336 let mut data = PrintData::new();
337 data.set_definition(&definition())
338 .unwrap()
339 .page_start()
340 .unwrap()
341 .set_value(" text ", 12.5)
342 .unwrap()
343 .set_repeated_value("row", true, 2, 3, false)
344 .unwrap()
345 .change_repeated_attributes(
346 "row",
347 json!({"x":1.25,"bold":true}),
348 0,
349 Some((2, 3)),
350 "DynamicText",
351 )
352 .unwrap()
353 .page_end()
354 .unwrap();
355 let value = data.to_value().unwrap();
356 assert_eq!(value["Pages"][0]["Values"][0]["Name"], "text");
357 assert_eq!(value["Pages"][0]["Values"][0]["Value"], "12.5");
358 assert_eq!(value["Pages"][0]["Values"][1]["Value"], "true");
359 assert_eq!(
360 value["Pages"][0]["DynamicAttributes"][0]["Values"]["x"],
361 "1.25"
362 );
363 }
364
365 #[test]
366 fn rejects_invalid_lifecycle_and_non_scalar_values() {
367 assert!(PrintData::new().page_start().is_err());
368 let mut data = PrintData::new();
369 data.set_definition(&definition())
370 .unwrap()
371 .page_start()
372 .unwrap();
373 assert!(data.set_value("x", json!({"bad":1})).is_err());
374 assert!(data.set_value("x", f64::INFINITY).is_err());
375 assert!(data.to_value().is_err());
376 }
377}