Skip to main content

reports_web/
printdata.rs

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/// Framework-independent builder for the shared PREPEJ print-document format.
9/// One instance belongs to one report/request; input definitions and output are cloned.
10#[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    // 型省略APIでは当該ページの定義を使う。明示型を受けるAPIは変えない。
215    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}