root
562 lines
20 KiB
Rust
562 lines
20 KiB
Rust
//! Plugin de impressão ESC/POS via USB para TM-T20 e compatíveis
|
||
|
||
use serde::{Deserialize, Serialize};
|
||
use std::sync::Mutex;
|
||
use thiserror::Error;
|
||
|
||
#[derive(Error, Debug)]
|
||
#[allow(dead_code)]
|
||
pub enum PrinterError {
|
||
#[error("Impressora não encontrada. Verifique se está conectada via USB e ligada.")]
|
||
NotFound,
|
||
#[error("Falha ao abrir impressora: {0}")]
|
||
OpenFailed(String),
|
||
#[error("Falha ao enviar dados: {0}")]
|
||
WriteFailed(String),
|
||
#[error("Configuração inválida: {0}")]
|
||
ConfigError(String),
|
||
}
|
||
|
||
impl serde::Serialize for PrinterError {
|
||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
||
where
|
||
S: serde::Serializer,
|
||
{
|
||
serializer.serialize_str(&self.to_string())
|
||
}
|
||
}
|
||
|
||
// ── Comandos ESC/POS via plugins::escpos ────────────────────────────────────
|
||
use crate::plugins::escpos;
|
||
|
||
// ── Struct de dados do recibo ────────────────────────────────────────────────
|
||
|
||
/// Linha de uma tabela no recibo (despesas, sangrias, vales, etc.)
|
||
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
|
||
pub struct ReciboLinha {
|
||
#[serde(default)]
|
||
pub desc: Option<String>,
|
||
#[serde(rename = "hora", default)]
|
||
pub hora: Option<String>,
|
||
#[serde(rename = "nome", default)]
|
||
pub nome: Option<String>,
|
||
#[serde(default)]
|
||
pub retirada: Option<f64>,
|
||
#[serde(default)]
|
||
pub valor: Option<f64>,
|
||
#[serde(default)]
|
||
pub obs: Option<String>,
|
||
#[serde(default)]
|
||
pub gerente: Option<String>,
|
||
#[serde(default)]
|
||
pub numero: Option<String>,
|
||
#[serde(default)]
|
||
pub motivo: Option<String>,
|
||
}
|
||
|
||
impl ReciboLinha {
|
||
fn fmt_v(&self) -> String {
|
||
let v = self.retirada.or(self.valor).unwrap_or(0.0);
|
||
format!("R$ {:.2}", v).replace('.', ",")
|
||
}
|
||
fn label(&self) -> String {
|
||
self.desc
|
||
.clone()
|
||
.or(self.nome.clone())
|
||
.or(self.hora.clone().map(|h| format!("{}h", h)))
|
||
.unwrap_or_default()
|
||
}
|
||
fn obs(&self) -> String {
|
||
self.gerente
|
||
.clone()
|
||
.or(self.obs.clone())
|
||
.or(self.motivo.clone())
|
||
.unwrap_or_default()
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||
pub struct ReciboData {
|
||
pub loja: String,
|
||
pub data: String,
|
||
pub operador: String,
|
||
pub turno: String,
|
||
pub saldo_troco: f64,
|
||
/// Valor contado no fechamento (dinheiro + cartões + receber)
|
||
pub fechamento: f64,
|
||
/// Saldo esperado = total operações − sangrias − despesas
|
||
pub saldo_esperado: f64,
|
||
/// Diferença = fechamento − saldo_esperado
|
||
pub diferenca: f64,
|
||
/// Total do sistema (troco + crédito + débito + alimentação + voucher + pixcnpj + vales + receber)
|
||
#[serde(default)]
|
||
pub sys_total: f64,
|
||
/// Soma de todas operações creditadas (crédito + débito + alimentação + voucher + pixcnpj) — usado no BLACK section como TOTAL
|
||
#[serde(default)]
|
||
pub total_operado: f64,
|
||
// Totais de cartões
|
||
pub credito: f64,
|
||
pub debito: f64,
|
||
pub alimentacao: f64,
|
||
pub voucher: f64,
|
||
// Totais diversos (mantidos para compatibilidade com JSON antigo)
|
||
#[serde(default)]
|
||
pub sangrias: f64,
|
||
#[serde(default)]
|
||
pub despesas: f64,
|
||
#[serde(default)]
|
||
pub vales: f64,
|
||
#[serde(default)]
|
||
pub areceber: f64,
|
||
#[serde(default)]
|
||
pub pixcnpj: f64,
|
||
#[serde(default)]
|
||
pub cancelamentos: f64,
|
||
// Arrays para linhas detalhadas (recebidos do frontend)
|
||
#[serde(default)]
|
||
pub sangrias_arr: Vec<ReciboLinha>,
|
||
#[serde(default)]
|
||
pub despesas_arr: Vec<ReciboLinha>,
|
||
#[serde(default)]
|
||
pub pixcnpj_arr: Vec<ReciboLinha>,
|
||
#[serde(default)]
|
||
pub vales_arr: Vec<ReciboLinha>,
|
||
#[serde(default)]
|
||
pub receber_arr: Vec<ReciboLinha>,
|
||
#[serde(default)]
|
||
pub cancelamentos_arr: Vec<ReciboLinha>,
|
||
#[serde(default)]
|
||
pub observacoes: Option<String>,
|
||
#[serde(default)]
|
||
pub clientes: i32,
|
||
#[serde(default)]
|
||
pub frango: i32,
|
||
}
|
||
|
||
impl ReciboData {
|
||
pub fn fmt_money(&self, v: f64) -> String {
|
||
format!("R$ {:.2}", v).replace('.', ",")
|
||
}
|
||
|
||
/// Gera todos os bytes ESC/POS do recibo 80mm
|
||
/// Layout: Header → SANGRIAS → DESPESAS → PIX CNPJ → VALES → A RECEBER → CANCELAMENTOS → CARTÕES → TROCO/Saldo Caixa → SALDO ESPERADO → DIFERENÇA
|
||
pub fn to_escpos(&self) -> Vec<u8> {
|
||
let mut out = Vec::new();
|
||
|
||
// Inicializa
|
||
out.extend(escpos::INIT);
|
||
|
||
// Cabeçalho
|
||
out.extend(escpos::blank_lines(1));
|
||
out.extend(escpos::title(&self.loja));
|
||
out.extend(escpos::line_center("Fechamento de Caixa"));
|
||
out.extend(escpos::blank_lines(1));
|
||
out.extend(escpos::divider());
|
||
|
||
// Info básica
|
||
out.extend(escpos::kv("Data:", &self.data));
|
||
out.extend(escpos::kv("Operador:", &self.operador));
|
||
out.extend(escpos::kv("Turno:", &self.turno));
|
||
out.extend(escpos::divider());
|
||
|
||
// ── SANGRIAS ──
|
||
if !self.sangrias_arr.is_empty() {
|
||
out.extend(escpos::line_bold("SANGRIAS"));
|
||
for linha in &self.sangrias_arr {
|
||
if linha.retirada.unwrap_or(0.0) > 0.0 || linha.valor.unwrap_or(0.0) > 0.0 {
|
||
let label = linha.label();
|
||
let obs = linha.obs();
|
||
out.extend(escpos::kv(&label, &linha.fmt_v()));
|
||
if !obs.is_empty() {
|
||
out.extend(escpos::line_center(&format!(" {}", obs)));
|
||
}
|
||
}
|
||
}
|
||
// Total sangrias
|
||
let total_sangrias: f64 = self.sangrias_arr.iter()
|
||
.map(|l| l.retirada.unwrap_or(0.0) + l.valor.unwrap_or(0.0))
|
||
.sum();
|
||
if total_sangrias > 0.0 {
|
||
out.extend(escpos::kv("Total:", &self.fmt_money(total_sangrias)));
|
||
}
|
||
out.extend(escpos::divider());
|
||
}
|
||
|
||
// ── DESPESAS ──
|
||
if !self.despesas_arr.is_empty() {
|
||
out.extend(escpos::line_bold("DESPESAS"));
|
||
for linha in &self.despesas_arr {
|
||
if linha.valor.unwrap_or(0.0) > 0.0 {
|
||
let label = linha.label();
|
||
let obs = linha.obs();
|
||
out.extend(escpos::kv(&label, &linha.fmt_v()));
|
||
if !obs.is_empty() {
|
||
out.extend(escpos::line_center(&format!(" {}", obs)));
|
||
}
|
||
}
|
||
}
|
||
// Total despesas
|
||
let total_despesas: f64 = self.despesas_arr.iter()
|
||
.map(|l| l.valor.unwrap_or(0.0))
|
||
.sum();
|
||
out.extend(escpos::kv("Total:", &self.fmt_money(total_despesas)));
|
||
out.extend(escpos::divider());
|
||
}
|
||
|
||
// ── PIX CNPJ ──
|
||
if !self.pixcnpj_arr.is_empty() {
|
||
out.extend(escpos::line_bold("PIX CNPJ"));
|
||
for linha in &self.pixcnpj_arr {
|
||
if linha.valor.unwrap_or(0.0) > 0.0 {
|
||
let label = linha.nome.clone().unwrap_or_else(|| "PIX CNPJ".to_string());
|
||
out.extend(escpos::kv(&label, &linha.fmt_v()));
|
||
}
|
||
}
|
||
// Total PIX CNPJ
|
||
let total_pixcnpj: f64 = self.pixcnpj_arr.iter()
|
||
.map(|l| l.valor.unwrap_or(0.0))
|
||
.sum();
|
||
if total_pixcnpj > 0.0 {
|
||
out.extend(escpos::kv("Total:", &self.fmt_money(total_pixcnpj)));
|
||
}
|
||
out.extend(escpos::divider());
|
||
}
|
||
|
||
// ── VALES ──
|
||
if !self.vales_arr.is_empty() {
|
||
out.extend(escpos::line_bold("VALES"));
|
||
for linha in &self.vales_arr {
|
||
if linha.valor.unwrap_or(0.0) > 0.0 {
|
||
let label = linha.label();
|
||
let obs = linha.obs();
|
||
out.extend(escpos::kv(&label, &linha.fmt_v()));
|
||
if !obs.is_empty() {
|
||
out.extend(escpos::line_center(&format!(" {}", obs)));
|
||
}
|
||
}
|
||
}
|
||
// Total vales
|
||
let total_vales: f64 = self.vales_arr.iter()
|
||
.map(|l| l.valor.unwrap_or(0.0))
|
||
.sum();
|
||
if total_vales > 0.0 {
|
||
out.extend(escpos::kv("Total:", &self.fmt_money(total_vales)));
|
||
}
|
||
out.extend(escpos::divider());
|
||
}
|
||
|
||
// ── A RECEBER ──
|
||
if !self.receber_arr.is_empty() {
|
||
out.extend(escpos::line_bold("A RECEBER"));
|
||
for linha in &self.receber_arr {
|
||
if linha.valor.unwrap_or(0.0) > 0.0 {
|
||
let label = linha.label();
|
||
out.extend(escpos::kv(&label, &linha.fmt_v()));
|
||
}
|
||
}
|
||
// Total a receber
|
||
let total_receber: f64 = self.receber_arr.iter()
|
||
.map(|l| l.valor.unwrap_or(0.0))
|
||
.sum();
|
||
if total_receber > 0.0 {
|
||
out.extend(escpos::kv("Total:", &self.fmt_money(total_receber)));
|
||
}
|
||
out.extend(escpos::divider());
|
||
}
|
||
|
||
// ── CANCELAMENTOS ──
|
||
if !self.cancelamentos_arr.is_empty() {
|
||
out.extend(escpos::line_bold("CANCELAMENTOS"));
|
||
for linha in &self.cancelamentos_arr {
|
||
if linha.numero.is_some() || linha.valor.unwrap_or(0.0) > 0.0 {
|
||
let num = linha.numero.clone().unwrap_or_default();
|
||
out.extend(escpos::kv(&num, &linha.fmt_v()));
|
||
if let Some(ref m) = linha.motivo {
|
||
if !m.is_empty() {
|
||
out.extend(escpos::line_center(&format!(" {}", m)));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Total cancelamentos
|
||
let total_cancel: f64 = self.cancelamentos_arr.iter()
|
||
.map(|l| l.valor.unwrap_or(0.0))
|
||
.sum();
|
||
if total_cancel > 0.0 {
|
||
out.extend(escpos::kv("Total:", &self.fmt_money(total_cancel)));
|
||
}
|
||
out.extend(escpos::divider());
|
||
}
|
||
|
||
// ── CARTÕES ──
|
||
out.extend(escpos::line_bold("CARTOES"));
|
||
out.extend(escpos::kv("Credito:", &self.fmt_money(self.credito)));
|
||
out.extend(escpos::kv("Debito:", &self.fmt_money(self.debito)));
|
||
out.extend(escpos::kv("Alimentacao:", &self.fmt_money(self.alimentacao)));
|
||
out.extend(escpos::kv("PIX Cartao:", &self.fmt_money(self.voucher)));
|
||
out.extend(escpos::kv("Cancelamentos:", &self.fmt_money(self.cancelamentos)));
|
||
out.extend(escpos::divider());
|
||
|
||
// ── TROCO / SALDO DE CAIXA ──
|
||
out.extend(escpos::line_bold("SALDO DE CAIXA"));
|
||
out.extend(escpos::kv("Troco (+):", &self.fmt_money(self.saldo_troco)));
|
||
out.extend(escpos::kv("Credito (+):", &self.fmt_money(self.credito)));
|
||
out.extend(escpos::kv("Debito (+):", &self.fmt_money(self.debito)));
|
||
out.extend(escpos::kv("Alimentacao (+):", &self.fmt_money(self.alimentacao)));
|
||
out.extend(escpos::kv("PIX Cartao (+):", &self.fmt_money(self.voucher)));
|
||
out.extend(escpos::kv("Vales (+):", &self.fmt_money(self.vales)));
|
||
out.extend(escpos::kv("A Receber (+):", &self.fmt_money(self.areceber)));
|
||
out.extend(escpos::kv("PIX CNPJ (+):", &self.fmt_money(self.pixcnpj)));
|
||
out.extend(escpos::divider());
|
||
|
||
// ── TOTAL ──
|
||
if self.sys_total > 0.0 {
|
||
out.extend(escpos::line_bold("TOTAL"));
|
||
out.extend(escpos::kv("Total:", &self.fmt_money(self.sys_total)));
|
||
out.extend(escpos::divider());
|
||
}
|
||
|
||
// ── SALDO ESPERADO ──
|
||
out.extend(escpos::line_bold("SALDO ESPERADO"));
|
||
out.extend(escpos::kv("Esperado:", &self.fmt_money(self.saldo_esperado)));
|
||
out.extend(escpos::divider());
|
||
|
||
// ── DIFERENÇA ──
|
||
// Diferença = total_fechamento - saldo_esperado - cancelamentos
|
||
out.extend(escpos::line_bold("DIFERENCA"));
|
||
let diff = self.fechamento - self.saldo_esperado - self.cancelamentos;
|
||
let diff_str = if diff >= 0.0 {
|
||
format!("+{}", self.fmt_money(diff))
|
||
} else {
|
||
self.fmt_money(diff)
|
||
};
|
||
out.extend(escpos::title(&diff_str));
|
||
|
||
// ── CONTADORES ──
|
||
out.extend(escpos::line_bold("CONTADORES"));
|
||
out.extend(escpos::kv("Clientes:", &self.clientes.to_string()));
|
||
out.extend(escpos::kv("Frango Assado:", &self.frango.to_string()));
|
||
out.extend(escpos::divider());
|
||
|
||
// ── OBSERVAÇÕES ──
|
||
if let Some(ref obs) = self.observacoes {
|
||
if !obs.trim().is_empty() {
|
||
out.extend(escpos::line_bold("OBSERVACOES"));
|
||
out.extend(escpos::line_center(obs.trim()));
|
||
out.extend(escpos::divider());
|
||
}
|
||
}
|
||
|
||
// Rodapé
|
||
out.extend(escpos::divider());
|
||
out.extend(escpos::line_center(
|
||
&chrono::Local::now().format("%d/%m/%Y %H:%M").to_string(),
|
||
));
|
||
out.extend(escpos::line_center("Obrigado!"));
|
||
out.extend(escpos::blank_lines(4));
|
||
|
||
// Corta papel
|
||
out.extend(escpos::FEED_CUT);
|
||
out.extend(escpos::CUT);
|
||
|
||
out
|
||
}
|
||
}
|
||
|
||
// ── Printer Manager ─────────────────────────────────────────────────────────
|
||
|
||
pub struct PrinterManager {
|
||
device_path: Mutex<Option<String>>,
|
||
/// Modo teste: grava bytes num arquivo ao invés de enviar pra USB
|
||
test_mode: Mutex<bool>,
|
||
}
|
||
|
||
impl Default for PrinterManager {
|
||
fn default() -> Self {
|
||
Self {
|
||
device_path: Mutex::new(None),
|
||
test_mode: Mutex::new(false),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl PrinterManager {
|
||
/// Detecta impressora USB conectada
|
||
pub fn detectar(&self) -> Result<String, String> {
|
||
#[cfg(windows)]
|
||
{
|
||
// Tenta encontrar porta USB virtual via WMI/registry
|
||
// Common TM-T20 USB port names on Windows
|
||
let candidates = [
|
||
r"\\.\USB001", // TM-T20 USB Printing Support
|
||
r"\\.\USB002",
|
||
r"\\.\GPR1",
|
||
r"\\.\COM3",
|
||
r"\\.\COM4",
|
||
];
|
||
for port in &candidates {
|
||
if std::path::Path::new(port).exists() || self.test_device(port) {
|
||
*self.device_path.lock().unwrap() = Some(port.to_string());
|
||
return Ok(port.to_string());
|
||
}
|
||
}
|
||
Err("Nenhuma impressora USB encontrada. Verifique o cabo e se a impressora está ligada.".into())
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
Err("Deteccao USB s-para apenas no Windows.".into())
|
||
}
|
||
}
|
||
|
||
#[cfg(windows)]
|
||
fn test_device(&self, path: &str) -> bool {
|
||
use std::process::Command;
|
||
let out = Command::new("cmd")
|
||
.args(["/C", &format!("type {} < nul 2>&1", path)])
|
||
.output();
|
||
out.map(|o| o.status.success()).unwrap_or(false)
|
||
}
|
||
|
||
pub fn configurar(&self, path: String) -> Result<(), String> {
|
||
if path.is_empty() {
|
||
return Err("Caminho vazio".into());
|
||
}
|
||
*self.device_path.lock().unwrap() = Some(path.clone());
|
||
log::info!("Impressora configurada: {}", path);
|
||
Ok(())
|
||
}
|
||
|
||
/// Ativa modo teste: grava os bytes ESC/POS num arquivo em vez de imprimir
|
||
pub fn set_test_mode(&self, enabled: bool) {
|
||
*self.test_mode.lock().unwrap() = enabled;
|
||
log::info!("Printer test mode: {}", enabled);
|
||
}
|
||
|
||
pub fn imprimir_bytes(&self, data: &[u8]) -> Result<usize, String> {
|
||
// Modo teste: grava arquivo
|
||
if *self.test_mode.lock().unwrap() {
|
||
let test_file = std::env::temp_dir().join("fechamento_recibo_escpos.bin");
|
||
std::fs::write(&test_file, data)
|
||
.map_err(|e| format!("Falha ao gravar arquivo de teste: {}", e))?;
|
||
log::info!("Bytes ESC/POS gravados em: {:?}", test_file);
|
||
return Ok(data.len());
|
||
}
|
||
|
||
let path = self
|
||
.device_path
|
||
.lock()
|
||
.unwrap()
|
||
.clone()
|
||
.ok_or_else(|| "Impressora nao configurada. Use o botao de detectar ou configure manualmente.".to_string())?;
|
||
|
||
#[cfg(windows)]
|
||
{
|
||
self.windows_write(&path, data)
|
||
}
|
||
#[cfg(not(windows))]
|
||
{
|
||
let _ = data;
|
||
Err("Impressao USB disponivel apenas no Windows.".into())
|
||
}
|
||
}
|
||
|
||
#[cfg(windows)]
|
||
fn windows_write(&self, path: &str, data: &[u8]) -> Result<usize, String> {
|
||
use std::io::Write;
|
||
|
||
// Tenta via File primeiro (mais simples)
|
||
{
|
||
let file = std::fs::OpenOptions::new()
|
||
.write(true)
|
||
.create(false)
|
||
.open(path);
|
||
if let Ok(mut f) = file {
|
||
let r = f.write_all(data);
|
||
let _ = f.flush();
|
||
if r.is_ok() {
|
||
return Ok(data.len());
|
||
}
|
||
}
|
||
}
|
||
|
||
// Fallback: usa API Windows direta via std::process::Command + > arquivo
|
||
// Isso绕过 problemas de locking do OpenOptions
|
||
let tmp = std::env::temp_dir().join("escpos_tmp.bin");
|
||
std::fs::write(&tmp, data)
|
||
.map_err(|e| format!("Falha ao criar arquivo temporario: {}", e))?;
|
||
|
||
let status = std::process::Command::new("cmd")
|
||
.args(["/C", &format!("copy /B {} {} /Y > nul 2>&1", tmp.display(), path)])
|
||
.status();
|
||
|
||
let _ = std::fs::remove_file(&tmp);
|
||
|
||
if status.map(|s| s.success()).unwrap_or(false) {
|
||
log::info!("Escritos {} bytes para {}", data.len(), path);
|
||
Ok(data.len())
|
||
} else {
|
||
Err(format!(
|
||
"Falha ao enviar dados para {}. Verifique se a impressora USB está \
|
||
conectada e ligada. Tente configurar manualmente em Config > Impressora.",
|
||
path
|
||
))
|
||
}
|
||
}
|
||
}
|
||
|
||
// ── Tauri Commands ───────────────────────────────────────────────────────────
|
||
|
||
static PRINTER: PrinterManager = PrinterManager {
|
||
device_path: Mutex::new(None),
|
||
test_mode: Mutex::new(false),
|
||
};
|
||
|
||
#[tauri::command]
|
||
pub fn detectar_impressora() -> Result<String, String> {
|
||
PRINTER.detectar()
|
||
}
|
||
|
||
#[tauri::command]
|
||
pub fn configurar_impressora(path: String) -> Result<(), String> {
|
||
PRINTER.configurar(path)
|
||
}
|
||
|
||
#[tauri::command]
|
||
pub fn caminho_impressora() -> Option<String> {
|
||
PRINTER.device_path.lock().unwrap().clone()
|
||
}
|
||
|
||
#[tauri::command]
|
||
pub fn imprimir_recibo(data: String) -> Result<usize, String> {
|
||
let r: ReciboData =
|
||
serde_json::from_str(&data).map_err(|e| format!("Erro ao analisar dados: {}", e))?;
|
||
let bytes = r.to_escpos();
|
||
log::info!("Imprimindo recibo: {} bytes ESC/POS", bytes.len());
|
||
PRINTER.imprimir_bytes(&bytes)
|
||
}
|
||
|
||
#[tauri::command]
|
||
pub fn teste_impressora() -> Result<usize, String> {
|
||
let mut test = Vec::new();
|
||
test.extend(escpos::INIT);
|
||
test.extend(escpos::blank_lines(1));
|
||
test.extend(escpos::title("TESTE DE IMPRESSORA"));
|
||
test.extend(escpos::line_center("O Frangao"));
|
||
test.extend(escpos::line_center(&chrono::Local::now().format("%d/%m/%Y %H:%M").to_string()));
|
||
test.extend(escpos::blank_lines(2));
|
||
test.extend(escpos::FEED_CUT);
|
||
test.extend(escpos::CUT);
|
||
log::info!("Teste impressora: {} bytes", test.len());
|
||
PRINTER.imprimir_bytes(&test)
|
||
}
|
||
|
||
#[tauri::command]
|
||
pub fn ativar_modo_teste_impressao() {
|
||
PRINTER.set_test_mode(true);
|
||
}
|
||
|
||
/// Called by Tauri on plugin init (no-op for this plugin)
|
||
pub fn init() {
|
||
log::info!("Printer plugin ready. Use detectar_impressora() ou configure manualmente.");
|
||
}
|