use anyhow::{Context, Result, bail};
use serde_json::{Map, Value, json};
use std::{any::Any, fs, path::Path};
pub const FORMAT: &str = "Reports.net PrintData";
pub const VERSION: &str = "1.0";
#[derive(Default)]
pub struct PrintData {
definition: Option<Value>,
pages: Vec<Value>,
page: Option<Value>,
}
impl PrintData {
pub fn new() -> Self {
Self::default()
}
pub fn set_definition(&mut self, definition: &Value) -> Result<&mut Self> {
if self.page.is_some() {
bail!("Cannot change the definition inside a page")
}
assert_definition(definition)?;
if let Some(previous) = &self.definition {
for page in &mut self.pages {
if page["Definition"].is_null() {
page["Definition"] = previous.clone();
}
}
}
self.definition = Some(definition.clone());
Ok(self)
}
pub fn page_start(&mut self) -> Result<&mut Self> {
self.page_start_with(None)
}
pub fn page_start_with(&mut self, definition: Option<&Value>) -> Result<&mut Self> {
if self.page.is_some() {
bail!("Call page_end before starting another page")
}
if let Some(value) = definition {
assert_definition(value)?;
}
if definition.is_none() && self.definition.is_none() {
bail!("Set a definition first")
}
self.page = Some(json!({
"Index": self.pages.len() + 1,
"Definition": definition.cloned().unwrap_or(Value::Null),
"Values": [],
"DynamicAttributes": []
}));
Ok(self)
}
pub fn set_value<T: Into<Value> + 'static>(&mut self, name: &str, value: T) -> Result<&mut Self> {
self.set_value_at(name, value, 0, true)
}
pub fn set_value_at(
&mut self,
name: &str,
value: impl Into<Value> + 'static,
index: usize,
drawing: bool,
) -> Result<&mut Self> {
let kind = self.inferred_type(name)?;
self.add_value(name, &kind, input_value(value)?, index, None, drawing)
}
pub fn set_repeated_value(
&mut self,
name: &str,
value: impl Into<Value> + 'static,
x: usize,
y: usize,
drawing: bool,
) -> Result<&mut Self> {
let kind = self.inferred_type(name)?;
self.add_value(name, &kind, input_value(value)?, 0, Some((x, y)), drawing)
}
pub fn set_typed_value(
&mut self,
name: &str,
kind: &str,
value: impl Into<Value> + 'static,
index: usize,
drawing: bool,
) -> Result<&mut Self> {
self.add_value(name, kind, input_value(value)?, index, None, drawing)
}
pub fn set_image(&mut self, name: &str, source: impl Into<Value> + 'static) -> Result<&mut Self> {
self.set_typed_value(name, "DynamicImage", source, 0, true)
}
pub fn set_barcode(&mut self, name: &str, code: impl Into<Value> + 'static) -> Result<&mut Self> {
self.set_typed_value(name, "DynamicBarcode", code, 0, true)
}
pub fn draw_object(&mut self, name: &str, index: usize, kind: &str) -> Result<&mut Self> {
self.add_value(name, kind, Value::Null, index, None, true)
}
pub fn change_attributes(
&mut self,
name: &str,
values: Value,
index: usize,
) -> Result<&mut Self> {
let kind = self.inferred_type(name)?;
self.change_repeated_attributes(name, values, index, None, &kind)
}
pub fn change_repeated_attributes(
&mut self,
name: &str,
values: Value,
index: usize,
repeat: Option<(usize, usize)>,
kind: &str,
) -> Result<&mut Self> {
let normalized = normalize_attributes(values)?;
let mut item = json!({"Name": required(name)?, "Type": required(kind)?, "Index": index, "Values": normalized});
if let Some((x, y)) = repeat {
item["IndexX"] = json!(x);
item["IndexY"] = json!(y);
}
self.page_mut()?["DynamicAttributes"]
.as_array_mut()
.unwrap()
.push(item);
Ok(self)
}
pub fn page_end(&mut self) -> Result<&mut Self> {
let page = self.page.take().context("Call page_start first")?;
self.pages.push(page);
Ok(self)
}
pub fn to_value(&self) -> Result<Value> {
if self.page.is_some() {
bail!("An unfinished page exists")
}
let definition = self
.definition
.as_ref()
.context("A definition is required")?;
if self.pages.is_empty() {
bail!("At least one completed page is required")
}
Ok(
json!({"Format": FORMAT, "Version": VERSION, "Definition": definition, "Pages": self.pages}),
)
}
pub fn to_json(&self, pretty: bool) -> Result<String> {
let mut text = if pretty {
serde_json::to_string_pretty(&self.to_value()?)?
} else {
serde_json::to_string(&self.to_value()?)?
};
text.push('\n');
Ok(text)
}
pub fn save(&self, path: &Path) -> Result<()> {
let parent = path.parent().context("Destination has no parent")?;
let mut temp = tempfile_path(
parent,
path.file_name()
.and_then(|v| v.to_str())
.unwrap_or("print.prepej"),
);
while temp.exists() {
temp = tempfile_path(parent, "print.prepej");
}
fs::write(&temp, self.to_json(true)?)?;
fs::rename(&temp, path).or_else(|_| {
fs::copy(&temp, path)?;
fs::remove_file(&temp)
})?;
Ok(())
}
fn add_value(
&mut self,
name: &str,
kind: &str,
value: Value,
index: usize,
repeat: Option<(usize, usize)>,
drawing: bool,
) -> Result<&mut Self> {
let mut item = json!({"Name": required(name)?, "Type": required(kind)?, "Index": index, "Drawing": drawing, "Value": scalar(value)?});
if let Some((x, y)) = repeat {
item["IndexX"] = json!(x);
item["IndexY"] = json!(y);
}
self.page_mut()?["Values"]
.as_array_mut()
.unwrap()
.push(item);
Ok(self)
}
fn inferred_type(&self, name: &str) -> Result<String> {
let page = self.page.as_ref().context("Call page_start first")?;
let d = if page["Definition"].is_null() { self.definition.as_ref().context("Set a definition first")? } else { &page["Definition"] };
let mut objects: Vec<&Value> = d["Objects"].as_array().map(|v| v.iter().collect()).unwrap_or_default();
if let Some(pages) = d["pages"].as_array() {
for p in pages { if let Some(items) = p["objects"].as_array() { objects.extend(items); } }
}
let kinds = ["Text", "Line", "Square", "Circle", "Image", "Barcode"];
for o in objects {
if o.get("Name").or_else(|| o.get("name")).and_then(Value::as_str) != Some(required(name)?) { continue; }
let k = o["Kind"].as_u64().or_else(|| o["Kind"].as_str().and_then(|s| s.parse::<u64>().ok()));
if let Some(k) = k.filter(|k| *k < 6) { return Ok(format!("Dynamic{}", kinds[k as usize])); }
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 };
if let Some(k) = k { return Ok(format!("Dynamic{k}")); }
}
Ok("DynamicText".into())
}
fn page_mut(&mut self) -> Result<&mut Value> {
self.page.as_mut().context("Call page_start first")
}
}
fn tempfile_path(parent: &Path, name: &str) -> std::path::PathBuf {
parent.join(format!(
".{name}.{}.tmp",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
))
}
fn required(value: &str) -> Result<&str> {
let value = value.trim();
if value.is_empty() {
bail!("A name is required")
} else {
Ok(value)
}
}
fn scalar(value: Value) -> Result<Value> {
match value {
Value::Null => Ok(Value::Null),
Value::String(value) => Ok(Value::String(value)),
Value::Bool(value) => Ok(Value::String(value.to_string())),
Value::Number(value) => Ok(Value::String(value.to_string())),
_ => bail!("Values must be scalar"),
}
}
fn input_value<T: Into<Value> + 'static>(value: T) -> Result<Value> {
let input = &value as &dyn Any;
if input.downcast_ref::<f64>().is_some_and(|v| !v.is_finite())
|| input.downcast_ref::<f32>().is_some_and(|v| !v.is_finite())
{
bail!("Numbers must be finite")
}
Ok(value.into())
}
fn normalize_attributes(value: Value) -> Result<Value> {
let Value::Object(values) = value else {
bail!("Attributes must be an object")
};
let mut result = Map::new();
for (key, value) in values {
if value.is_null() {
bail!("Attribute values cannot be null")
}
result.insert(key, scalar(value)?);
}
Ok(Value::Object(result))
}
pub fn assert_definition(value: &Value) -> Result<()> {
let portable = value.get("Version").is_some_and(|v| !v.is_null())
&& value.get("Objects").is_some_and(Value::is_array)
&& matches!(
value
.get("CoordinateUnit")
.and_then(Value::as_str)
.unwrap_or("mm")
.to_ascii_lowercase()
.as_str(),
"mm" | "px"
);
let web = value.get("format").and_then(Value::as_str) == Some("pao-reports-web")
&& value.get("version").and_then(Value::as_i64) == Some(1)
&& value
.get("pages")
.and_then(Value::as_array)
.is_some_and(|v| !v.is_empty());
if portable || web {
Ok(())
} else {
bail!("Invalid report definition")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn inferred_types_and_page_override() {
let kinds=["Text","Line","Square","Circle","Image","Barcode"];
let objects:Vec<Value>=kinds.iter().enumerate().map(|(k,n)|json!({"Name":n,"Kind":k})).collect();
let mut p=PrintData::new();p.set_definition(&json!({"Version":"1","Objects":objects})).unwrap().page_start().unwrap();
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();}
p.set_typed_value("Image","DynamicText","explicit",0,true).unwrap().page_end().unwrap();
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();
let v=p.to_value().unwrap();let pages=&v["Pages"];
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}"));}
assert_eq!(pages[0]["Values"][12]["Type"],"DynamicText");assert_eq!(pages[1]["Values"][0]["Type"],"DynamicLine");
}
fn definition() -> Value {
json!({"Version":"1", "CoordinateUnit":"mm", "Objects":[]})
}
#[test]
fn creates_canonical_values_repeats_and_attributes() {
let mut data = PrintData::new();
data.set_definition(&definition())
.unwrap()
.page_start()
.unwrap()
.set_value(" text ", 12.5)
.unwrap()
.set_repeated_value("row", true, 2, 3, false)
.unwrap()
.change_repeated_attributes(
"row",
json!({"x":1.25,"bold":true}),
0,
Some((2, 3)),
"DynamicText",
)
.unwrap()
.page_end()
.unwrap();
let value = data.to_value().unwrap();
assert_eq!(value["Pages"][0]["Values"][0]["Name"], "text");
assert_eq!(value["Pages"][0]["Values"][0]["Value"], "12.5");
assert_eq!(value["Pages"][0]["Values"][1]["Value"], "true");
assert_eq!(
value["Pages"][0]["DynamicAttributes"][0]["Values"]["x"],
"1.25"
);
}
#[test]
fn rejects_invalid_lifecycle_and_non_scalar_values() {
assert!(PrintData::new().page_start().is_err());
let mut data = PrintData::new();
data.set_definition(&definition())
.unwrap()
.page_start()
.unwrap();
assert!(data.set_value("x", json!({"bad":1})).is_err());
assert!(data.set_value("x", f64::INFINITY).is_err());
assert!(data.to_value().is_err());
}
}