use std::collections::HashMap; use std::path::Path; use crate::dsl::{parse, Document}; use crate::escpos::{EscPosEncoder, EscPosError}; use crate::io::{LoadError, PosFile}; use crate::params::{ collect_parameters, invalid_bool_parameters, substitute_document, ParamKind, }; use crate::label_format::{LabelFormat, LabelFormatStore}; use crate::print::{open_printer_by_name, print_bytes, PrintError, PrinterTarget}; use crate::protocol::{Detection, PrinterProtocol}; use crate::tspl::{self, TsplOptions}; #[derive(Debug)] pub enum PipelineError { Load(LoadError), Parse(crate::dsl::ParseError), MissingParams(Vec), InvalidBoolParams(Vec), Encode(EscPosError), Print(PrintError), /// TSPL label printer without a saved label format (model key). LabelFormatMissing(String), } impl std::fmt::Display for PipelineError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::Load(e) => write!(f, "{e:?}"), Self::Parse(e) => write!(f, "{e}"), Self::MissingParams(names) => { write!(f, "missing parameters: {}", names.join(", ")) } Self::InvalidBoolParams(names) => write!( f, "invalid boolean for {}: use true/false (or 1/0, yes/no)", names.join(", ") ), Self::Encode(e) => write!(f, "{e:?}"), Self::Print(e) => write!(f, "{e:?}"), Self::LabelFormatMissing(model) => { write!(f, "{}", crate::i18n::trf("label.err.missing_cli", model)) } } } } impl std::error::Error for PipelineError {} pub fn missing_parameters(document: &Document, params: &HashMap) -> Vec { collect_parameters(document) .into_iter() .filter(|p| match p.kind { ParamKind::Text => params .get(&p.name) .map(|v| v.is_empty()) .unwrap_or(true), ParamKind::Bool => !params.contains_key(&p.name), }) .map(|p| p.name) .collect() } pub fn encode_pos_file( file: &PosFile, base_dir: Option<&Path>, params: &HashMap, ) -> Result, PipelineError> { let doc = parse(&file.body).map_err(PipelineError::Parse)?; let missing = missing_parameters(&doc, params); if !missing.is_empty() { return Err(PipelineError::MissingParams(missing)); } let invalid_bool = invalid_bool_parameters(&doc, params); if !invalid_bool.is_empty() { return Err(PipelineError::InvalidBoolParams(invalid_bool)); } let sub = substitute_document(&doc, params); let mut encoder = EscPosEncoder::new(file.metadata.clone()); if let Some(dir) = base_dir { encoder = encoder.with_base_dir(dir); } let bytes = encoder .encode_document(&sub) .map_err(PipelineError::Encode)?; Ok(bytes.to_vec()) } /// Encode for a TSPL label printer: the unchanged ESC/POS encoding is rendered /// to a bitmap and sent as TSPL `BITMAP` labels (see [`crate::tspl`]). pub fn encode_pos_file_tspl( file: &PosFile, base_dir: Option<&Path>, params: &HashMap, format: &LabelFormat, opts: TsplOptions, ) -> Result, PipelineError> { let escpos = encode_pos_file(file, base_dir, params)?; Ok(tspl::escpos_to_tspl( &escpos, file.metadata.printable_dots() as u32, format, opts, )) } /// Resolve a printer name like `open_printer_by_name` does and detect its protocol. pub fn detect_by_name(name: &str) -> Option<(PrinterTarget, Detection)> { let name = name.trim(); if name.is_empty() { return None; } let printers = crate::print::list_printers().ok()?; let matched = crate::print::find_matching_printer(&printers, name)?; let d = crate::print::detect_printer(&matched.target); Some((matched.target.clone(), d)) } /// Suggested label format for a TSPL printer: model defaults, refined with /// values the printer reports itself (GETSETTING$, bidirectional USB only). /// Returns `(format, read_from_printer)`. pub fn suggest_label_format(target: &PrinterTarget, detection: &Detection) -> (LabelFormat, bool) { let mut f = LabelFormat::suggested_for_model(detection.model_name.as_deref()); let ask = |q: &str| { crate::print::query_printer(target, q.as_bytes()) .map(|r| String::from_utf8_lossy(&r).to_string()) }; let Some(dpi_reply) = ask(tspl::QUERY_DPI) else { return (f, false); }; let mut from_printer = false; if let Some(dpi) = tspl::parse_dpi(&dpi_reply) { f.dpi = dpi; from_printer = true; } let dpmm = Some(f.dots_per_mm()); if let Some(w) = ask(tspl::QUERY_PAPER_WIDTH).and_then(|r| tspl::parse_length_mm(&r, dpmm)) { f.width_mm = (w * 10.0).round() / 10.0; from_printer = true; } if let Some(h) = ask(tspl::QUERY_PAPER_SIZE).and_then(|r| tspl::parse_length_mm(&r, dpmm)) { f.height_mm = (h * 10.0).round() / 10.0; from_printer = true; } if let Some(g) = ask(tspl::QUERY_GAP_SIZE).and_then(|r| tspl::parse_length_mm(&r, dpmm)) { f.gap_mm = (g * 10.0).round() / 10.0; from_printer = true; } if f.validate().is_err() { return (LabelFormat::suggested_for_model(detection.model_name.as_deref()), false); } (f, from_printer) } /// TSPL `!?` status (manual p.82); `None` when unknown or ready. pub fn tspl_status_problem(target: &PrinterTarget) -> Option { let reply = crate::print::query_printer(target, tspl::STATUS_QUERY)?; tspl::status_problem(*reply.first()?) } pub fn print_pos_file( path: &Path, printer_port: &str, params: &HashMap, ) -> Result<(), PipelineError> { let file = PosFile::load_from_path(path).map_err(PipelineError::Load)?; let base_dir = path.parent(); let bytes = match detect_by_name(printer_port) { Some((_, d)) if d.protocol == PrinterProtocol::Tspl => { let store = LabelFormatStore::load(); let format = store .get(&d.model_key) .cloned() .ok_or_else(|| PipelineError::LabelFormatMissing(d.model_key.clone()))?; encode_pos_file_tspl(&file, base_dir, params, &format, TsplOptions::default())? } _ => encode_pos_file(&file, base_dir, params)?, }; let mut transport = open_printer_by_name(printer_port).map_err(PipelineError::Print)?; print_bytes(&mut transport, &bytes).map_err(PipelineError::Print) } #[cfg(test)] mod tests { use super::*; #[test] fn detects_missing_parameters() { let file = PosFile::new("Hello ${A} ${B}"); let doc = parse(&file.body).unwrap(); let mut params = HashMap::new(); params.insert("A".into(), "1".into()); assert_eq!(missing_parameters(&doc, ¶ms), vec!["B".to_string()]); } #[test] fn encodes_raster_code128_with_substituted_data() { let file = PosFile::new("Testing\n@barcode RASTER CODE128 ${Data}\n\nLast line\n"); let mut params = HashMap::new(); params.insert("Data".into(), "Testcode".into()); let bytes = encode_pos_file(&file, None, ¶ms).unwrap(); assert!(bytes.windows(4).any(|w| w == [0x1D, b'v', 0x30, 0x00])); } #[test] fn tspl_encoding_reuses_escpos_layout() { let file = PosFile::new("Hi ${Name}\n@cut\n"); let mut params = HashMap::new(); params.insert("Name".into(), "Ada".into()); let f = LabelFormat { dpi: 300, width_mm: 50.0, height_mm: 30.0, ..Default::default() }; let job = encode_pos_file_tspl(&file, None, ¶ms, &f, TsplOptions::default()).unwrap(); assert!(job.starts_with(b"SIZE 50 mm,30 mm\r\nGAP 3 mm,0 mm\r\n")); assert!(job.ends_with(b"\r\nPRINT 1,1\r\n")); // Missing params still fail like ESC/POS. let err = encode_pos_file_tspl(&file, None, &HashMap::new(), &f, TsplOptions::default()); assert!(matches!(err, Err(PipelineError::MissingParams(_)))); } #[test] fn encodes_when_all_params_present() { let file = PosFile::new("Hi ${Name}"); let mut params = HashMap::new(); params.insert("Name".into(), "Ada".into()); let bytes = encode_pos_file(&file, None, ¶ms).unwrap(); assert!(bytes.windows(2).any(|w| w == b"Hi")); } }