442 lines
15 KiB
Rust
442 lines
15 KiB
Rust
use crate::application::usecases::importar_arquivo::{importar_csv, importar_xlsx};
|
|
use crate::application::usecases::executar_analise::{
|
|
expandir_analise, pre_analisar, series_com_intervalo_excessivo,
|
|
};
|
|
use crate::domain::entities::layout::{Layout, TipoArquivo};
|
|
use crate::ui::app::{App, EstadoApp, ResultadoPendente};
|
|
use egui::{Context, Ui};
|
|
|
|
/// Renderiza a tela de configuração de colunas.
|
|
pub fn renderizar(ui: &mut Ui, ctx: &Context, app: &mut App) {
|
|
ui.heading("Configuração de Colunas");
|
|
ui.add_space(8.0);
|
|
|
|
if let Some(caminho) = &app.caminho_arquivo.clone() {
|
|
ui.label(format!("Arquivo: {}", caminho.display()));
|
|
}
|
|
|
|
ui.add_space(8.0);
|
|
|
|
// Seletor de layout
|
|
let tipo_atual = app.tipo_arquivo_atual.clone();
|
|
let opcoes_layout: Vec<(i64, String)> = app
|
|
.layouts_salvos
|
|
.iter()
|
|
.filter(|l| l.tipo() == tipo_atual)
|
|
.filter_map(|l| l.id().map(|id| (id, l.nome().to_string())))
|
|
.collect();
|
|
let nome_layout_atual = app.nome_layout_atual.clone();
|
|
|
|
ui.horizontal(|ui| {
|
|
ui.label("Layout:");
|
|
egui::ComboBox::from_id_salt("combo_layouts_config")
|
|
.selected_text(if nome_layout_atual.is_empty() {
|
|
"— Selecionar layout —"
|
|
} else {
|
|
&nome_layout_atual
|
|
})
|
|
.show_ui(ui, |ui| {
|
|
for (id, nome) in &opcoes_layout {
|
|
if ui
|
|
.selectable_label(nome_layout_atual == *nome, nome.as_str())
|
|
.clicked()
|
|
{
|
|
app.nome_layout_atual = nome.clone();
|
|
if let Some(layout) =
|
|
app.layouts_salvos.iter().find(|l| l.id() == Some(*id))
|
|
{
|
|
let layout = layout.clone();
|
|
match &layout {
|
|
Layout::Csv { config, .. } => {
|
|
app.layout_csv_atual = config.clone();
|
|
}
|
|
Layout::Xlsx { config, .. } => {
|
|
app.layout_xlsx_atual = config.clone();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
ui.add_space(12.0);
|
|
|
|
match app.tipo_arquivo_atual.clone() {
|
|
TipoArquivo::Csv => renderizar_csv(ui, app),
|
|
TipoArquivo::Xlsx => renderizar_xlsx(ui, app),
|
|
}
|
|
|
|
// Pré-visualização do arquivo
|
|
if let Some(preview) = &app.preview_arquivo.clone() {
|
|
ui.add_space(8.0);
|
|
ui.separator();
|
|
ui.add_space(4.0);
|
|
crate::ui::screens::renderizar_tabela_preview(ui, preview);
|
|
}
|
|
|
|
ui.add_space(16.0);
|
|
ui.separator();
|
|
ui.add_space(8.0);
|
|
|
|
// Validação e botões de ação
|
|
let (valido, erros) = validar_config(app);
|
|
|
|
if !erros.is_empty() {
|
|
for erro in &erros {
|
|
ui.colored_label(egui::Color32::RED, format!("⚠ {}", erro));
|
|
}
|
|
ui.add_space(8.0);
|
|
}
|
|
|
|
ui.horizontal(|ui| {
|
|
if ui.button("< Voltar").clicked() {
|
|
app.estado = EstadoApp::Importando;
|
|
}
|
|
|
|
ui.add_enabled_ui(valido && app.caminho_arquivo.is_some(), |ui| {
|
|
if ui.button("▶ Importar e Analisar").clicked() {
|
|
executar_importacao(app, ctx);
|
|
}
|
|
});
|
|
|
|
if valido && !app.notas_importadas.is_empty() {
|
|
if ui
|
|
.button("🔄 Reanalisar")
|
|
.on_hover_text("Reanalisa as notas já importadas sem reimportar o arquivo")
|
|
.clicked()
|
|
{
|
|
app.executar_analise();
|
|
}
|
|
}
|
|
|
|
if ui.button("💾 Salvar como layout...").clicked() {
|
|
app.exibir_modal_salvar_layout();
|
|
}
|
|
});
|
|
}
|
|
|
|
fn renderizar_csv(ui: &mut Ui, app: &mut App) {
|
|
ui.group(|ui| {
|
|
ui.label("Configurações CSV");
|
|
ui.add_space(4.0);
|
|
|
|
// Delimitador
|
|
ui.horizontal(|ui| {
|
|
ui.label("Delimitador:");
|
|
let delim_str = match app.layout_csv_atual.delimitador {
|
|
',' => "Vírgula (,)",
|
|
';' => "Ponto e vírgula (;)",
|
|
'\t' => "Tabulação (Tab)",
|
|
_ => "Outro",
|
|
};
|
|
let mut delim_mudou = false;
|
|
egui::ComboBox::from_id_salt("combo_delimitador")
|
|
.selected_text(delim_str)
|
|
.show_ui(ui, |ui| {
|
|
if ui
|
|
.selectable_label(app.layout_csv_atual.delimitador == ',', "Vírgula (,)")
|
|
.clicked()
|
|
{
|
|
app.layout_csv_atual.delimitador = ',';
|
|
delim_mudou = true;
|
|
}
|
|
if ui
|
|
.selectable_label(
|
|
app.layout_csv_atual.delimitador == ';',
|
|
"Ponto e vírgula (;)",
|
|
)
|
|
.clicked()
|
|
{
|
|
app.layout_csv_atual.delimitador = ';';
|
|
delim_mudou = true;
|
|
}
|
|
if ui
|
|
.selectable_label(
|
|
app.layout_csv_atual.delimitador == '\t',
|
|
"Tabulação (Tab)",
|
|
)
|
|
.clicked()
|
|
{
|
|
app.layout_csv_atual.delimitador = '\t';
|
|
delim_mudou = true;
|
|
}
|
|
});
|
|
if delim_mudou {
|
|
if let Some(caminho) = &app.caminho_arquivo.clone() {
|
|
app.preview_arquivo = crate::infrastructure::csv_reader::preview_csv(
|
|
caminho,
|
|
app.layout_csv_atual.delimitador as u8,
|
|
&app.layout_csv_atual.encoding.clone(),
|
|
5,
|
|
).ok();
|
|
}
|
|
}
|
|
});
|
|
|
|
// Encoding
|
|
ui.horizontal(|ui| {
|
|
ui.label("Encoding:");
|
|
egui::ComboBox::from_id_salt("combo_encoding")
|
|
.selected_text(&app.layout_csv_atual.encoding)
|
|
.show_ui(ui, |ui| {
|
|
if ui
|
|
.selectable_label(app.layout_csv_atual.encoding == "utf-8", "UTF-8")
|
|
.clicked()
|
|
{
|
|
app.layout_csv_atual.encoding = "utf-8".to_string();
|
|
}
|
|
if ui
|
|
.selectable_label(
|
|
app.layout_csv_atual.encoding == "windows-1252",
|
|
"Windows-1252 (Latin-1)",
|
|
)
|
|
.clicked()
|
|
{
|
|
app.layout_csv_atual.encoding = "windows-1252".to_string();
|
|
}
|
|
});
|
|
});
|
|
|
|
// Linha cabeçalho
|
|
ui.horizontal(|ui| {
|
|
ui.label("Linha do cabeçalho (0 = sem cabeçalho):");
|
|
let mut val = app.layout_csv_atual.linha_cabecalho;
|
|
ui.add(egui::DragValue::new(&mut val).range(0..=100));
|
|
app.layout_csv_atual.linha_cabecalho = val;
|
|
});
|
|
});
|
|
|
|
ui.add_space(8.0);
|
|
ui.group(|ui| {
|
|
ui.label("Mapeamento de Colunas (índice base 0)");
|
|
ui.add_space(4.0);
|
|
|
|
campo_indice(
|
|
ui,
|
|
"Número (obrigatório):",
|
|
&mut app.layout_csv_atual.indice_numero,
|
|
);
|
|
campo_indice(
|
|
ui,
|
|
"Série (obrigatório):",
|
|
&mut app.layout_csv_atual.indice_serie,
|
|
);
|
|
|
|
campo_indice_opcional(
|
|
ui,
|
|
"Valor (opcional):",
|
|
&mut app.layout_csv_atual.indice_valor,
|
|
);
|
|
campo_indice_opcional(
|
|
ui,
|
|
"Data (opcional):",
|
|
&mut app.layout_csv_atual.indice_data,
|
|
);
|
|
});
|
|
}
|
|
|
|
fn renderizar_xlsx(ui: &mut Ui, app: &mut App) {
|
|
ui.group(|ui| {
|
|
ui.label("Configurações XLSX");
|
|
ui.add_space(4.0);
|
|
|
|
ui.horizontal(|ui| {
|
|
ui.label("Aba:");
|
|
if app.abas_xlsx.is_empty() {
|
|
ui.text_edit_singleline(&mut app.layout_xlsx_atual.aba);
|
|
} else {
|
|
let aba_atual = app.layout_xlsx_atual.aba.clone();
|
|
egui::ComboBox::from_id_salt("combo_aba")
|
|
.selected_text(&aba_atual)
|
|
.show_ui(ui, |ui| {
|
|
for aba in &app.abas_xlsx.clone() {
|
|
if ui.selectable_label(aba_atual == *aba, aba).clicked() {
|
|
app.layout_xlsx_atual.aba = aba.clone();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
ui.add_space(8.0);
|
|
ui.group(|ui| {
|
|
ui.label("Mapeamento de Colunas (formato LetraLinha, ex: B3)");
|
|
ui.add_space(4.0);
|
|
|
|
campo_letra_linha(
|
|
ui,
|
|
"Número (obrigatório):",
|
|
&mut app.layout_xlsx_atual.pos_numero,
|
|
);
|
|
campo_letra_linha(
|
|
ui,
|
|
"Série (obrigatório):",
|
|
&mut app.layout_xlsx_atual.pos_serie,
|
|
);
|
|
campo_letra_linha_opcional(
|
|
ui,
|
|
"Valor (opcional):",
|
|
&mut app.layout_xlsx_atual.pos_valor,
|
|
);
|
|
campo_letra_linha_opcional(ui, "Data (opcional):", &mut app.layout_xlsx_atual.pos_data);
|
|
});
|
|
}
|
|
|
|
fn campo_indice(ui: &mut Ui, label: &str, valor: &mut usize) {
|
|
ui.horizontal(|ui| {
|
|
ui.label(label);
|
|
ui.add(egui::DragValue::new(valor).range(0..=999usize));
|
|
});
|
|
}
|
|
|
|
fn campo_indice_opcional(ui: &mut Ui, label: &str, valor: &mut Option<usize>) {
|
|
ui.horizontal(|ui| {
|
|
let mut ativo = valor.is_some();
|
|
if ui.checkbox(&mut ativo, label).changed() {
|
|
*valor = if ativo { Some(0) } else { None };
|
|
}
|
|
if let Some(v) = valor {
|
|
ui.add(egui::DragValue::new(v).range(0..=999usize));
|
|
}
|
|
});
|
|
}
|
|
|
|
fn campo_letra_linha(ui: &mut Ui, label: &str, valor: &mut String) {
|
|
ui.horizontal(|ui| {
|
|
ui.label(label);
|
|
ui.text_edit_singleline(valor);
|
|
});
|
|
}
|
|
|
|
fn campo_letra_linha_opcional(ui: &mut Ui, label: &str, valor: &mut Option<String>) {
|
|
ui.horizontal(|ui| {
|
|
let mut ativo = valor.is_some();
|
|
if ui.checkbox(&mut ativo, label).changed() {
|
|
*valor = if ativo { Some(String::new()) } else { None };
|
|
}
|
|
if let Some(v) = valor {
|
|
ui.text_edit_singleline(v);
|
|
}
|
|
});
|
|
}
|
|
|
|
/// Valida a configuração atual. Retorna (é_válido, lista_de_erros).
|
|
fn validar_config(app: &App) -> (bool, Vec<String>) {
|
|
let mut erros = Vec::new();
|
|
|
|
match &app.tipo_arquivo_atual {
|
|
TipoArquivo::Csv => {
|
|
let c = &app.layout_csv_atual;
|
|
// Verificar índices duplicados
|
|
let mut indices: Vec<(String, usize)> = vec![
|
|
("Numero".to_string(), c.indice_numero),
|
|
("Serie".to_string(), c.indice_serie),
|
|
];
|
|
if let Some(v) = c.indice_valor {
|
|
indices.push(("Valor".to_string(), v));
|
|
}
|
|
if let Some(d) = c.indice_data {
|
|
indices.push(("Data".to_string(), d));
|
|
}
|
|
verificar_duplicados(&indices, &mut erros);
|
|
}
|
|
TipoArquivo::Xlsx => {
|
|
let c = &app.layout_xlsx_atual;
|
|
if c.aba.trim().is_empty() {
|
|
erros.push("Selecione uma aba".to_string());
|
|
}
|
|
if c.pos_numero.trim().is_empty() {
|
|
erros.push("Posição do campo Numero é obrigatória".to_string());
|
|
} else if crate::infrastructure::xlsx_reader::parsear_letra_linha(&c.pos_numero)
|
|
.is_none()
|
|
{
|
|
erros.push(format!("Posição Numero inválida: '{}'", c.pos_numero));
|
|
}
|
|
if c.pos_serie.trim().is_empty() {
|
|
erros.push("Posição do campo Serie é obrigatória".to_string());
|
|
} else if crate::infrastructure::xlsx_reader::parsear_letra_linha(&c.pos_serie)
|
|
.is_none()
|
|
{
|
|
erros.push(format!("Posição Serie inválida: '{}'", c.pos_serie));
|
|
}
|
|
}
|
|
}
|
|
|
|
let valido = erros.is_empty();
|
|
(valido, erros)
|
|
}
|
|
|
|
fn verificar_duplicados(indices: &[(String, usize)], erros: &mut Vec<String>) {
|
|
for i in 0..indices.len() {
|
|
for j in (i + 1)..indices.len() {
|
|
if indices[i].1 == indices[j].1 {
|
|
erros.push(format!(
|
|
"Campos '{}' e '{}' mapeados para o mesmo índice {}",
|
|
indices[i].0, indices[j].0, indices[i].1
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn executar_importacao(app: &mut App, ctx: &egui::Context) {
|
|
let caminho = match &app.caminho_arquivo {
|
|
Some(p) => p.clone(),
|
|
None => return,
|
|
};
|
|
|
|
let tipo = app.tipo_arquivo_atual.clone();
|
|
let layout_csv = app.layout_csv_atual.clone();
|
|
let layout_xlsx = app.layout_xlsx_atual.clone();
|
|
|
|
let (tx, rx) = std::sync::mpsc::channel();
|
|
app.resultado_pendente = Some(rx);
|
|
app.estado = EstadoApp::Analisando;
|
|
ctx.request_repaint();
|
|
|
|
std::thread::spawn(move || {
|
|
// 1. Importar arquivo
|
|
let res_importacao = match tipo {
|
|
TipoArquivo::Csv => importar_csv(&caminho, &layout_csv).map_err(|e| e.to_string()),
|
|
TipoArquivo::Xlsx => importar_xlsx(&caminho, &layout_xlsx).map_err(|e| e.to_string()),
|
|
};
|
|
|
|
let res = match res_importacao {
|
|
Err(e) => ResultadoPendente::Erro(e),
|
|
Ok(importado) => {
|
|
if importado.notas.is_empty() {
|
|
ResultadoPendente::Vazio
|
|
} else {
|
|
let avisos = importado.avisos.clone();
|
|
let notas = importado.notas;
|
|
|
|
// 2. Pré-análise
|
|
let pre = pre_analisar(¬as);
|
|
let excessivos = series_com_intervalo_excessivo(&pre);
|
|
|
|
if !excessivos.is_empty() {
|
|
ResultadoPendente::AguardandoConfirmacao {
|
|
pre,
|
|
series_excessivas: excessivos,
|
|
avisos,
|
|
notas,
|
|
}
|
|
} else {
|
|
// 3. Expandir faltantes
|
|
let resultado = expandir_analise(pre, ¬as);
|
|
ResultadoPendente::Concluido {
|
|
resultado,
|
|
avisos: Some(avisos),
|
|
notas: Some(notas),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
let _ = tx.send(res);
|
|
});
|
|
}
|