reports-web 1.0.0

Reports.Web for Rust: build PREPEJ print data from .prepdj report definitions and render PDF with the Reports.Web engine (C++ WebAssembly). Japanese business forms: invoices, estimates, labels. Trial build.
Documentation
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";

/// Framework-independent builder for the shared PREPEJ print-document format.
/// One instance belongs to one report/request; input definitions and output are cloned.
#[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)
    }

    // 型省略APIでは当該ページの定義を使う。明示型を受けるAPIは変えない。
    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());
    }
}