davideandClaude Sonnet 5
a7e0df0247
The bare root code of an assembly (e.g. 9284208188, without a _D... suffix) is always referenced inside its own suffixed sub-assemblies as a genuine placement pointing back to the general assembly. Following it during recursive resolution pulled in the entire product tree instead of just the requested sub-assembly (598 components collected instead of ~65 on 9284208188_D600). Fixed by seeding the visited-codes set with each starting assembly's root code, in both scripts/ExtractCreoStrings.cs and the two BFS call sites in Form1.cs (RisolviAlberoComponenti, AssiemeCompleto). Also closes two recall gaps found by comparing against a real Creo BOM report: some real placements only show up as the code repeated twice separated by a NUL byte rather than the usual "Componente ID N (...)" text, and family-table bearing codes (CUSCI_...) use the same <...> bracket convention as UNI hardware but weren't recognized. docs/formato-asm.md documents all three findings. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
1139 lines
45 KiB
C#
1139 lines
45 KiB
C#
using System.Diagnostics;
|
|
using Microsoft.Data.Sqlite;
|
|
|
|
namespace CadSearchGui;
|
|
|
|
public partial class Form1 : Form
|
|
{
|
|
private readonly Button _btnApriDb = new();
|
|
private readonly Button _btnAggiorna = new();
|
|
private readonly Button _btnCreaRaw = new();
|
|
private readonly Button _btnTrovaPrt = new();
|
|
private readonly Button _btnReport = new();
|
|
private readonly Button _btnVerifica = new();
|
|
private readonly Button _btnCompletezza = new();
|
|
private readonly Button _btnPulisci = new();
|
|
private readonly Label _lblStatus = new();
|
|
private readonly Label _lblDb = new();
|
|
private readonly Label _lblUltimoAggiornamento = new();
|
|
private readonly DataGridView _gridImport = new();
|
|
private readonly DataGridView _gridRaw = new();
|
|
private readonly Label _lblImportStatus = new();
|
|
private readonly ToolTip _tipImportStatus = new();
|
|
|
|
// Wizard: una fase alla volta occupa tutta la finestra, si avanza solo quando quella
|
|
// corrente è "pronta" (vedi AvantiConsentito). NomiFasi/_panelFasi sono paralleli per indice.
|
|
private static readonly string[] NomiFasi =
|
|
{
|
|
"1. Database",
|
|
"2. Importa Distinta Base",
|
|
"3. Crea cartella raw",
|
|
"4. Trova componenti referenziati",
|
|
"5. Verifica completezza e STEP",
|
|
};
|
|
private readonly Panel[] _panelFasi = new Panel[NomiFasi.Length];
|
|
private readonly Panel _faseContainer = new() { Dock = DockStyle.Fill };
|
|
private readonly Label _lblFase = new();
|
|
private readonly Button _btnIndietro = new();
|
|
private readonly Button _btnAvanti = new();
|
|
private int _faseAttuale;
|
|
|
|
private static readonly string[] TipiPredefiniti = { "prt", "asm" };
|
|
private const string RadiceDiscoDefault = @"X:\";
|
|
|
|
private string? _dbPath;
|
|
private string? _percorsoInputCorrente;
|
|
private List<(string Componente, string Descrizione)>? _righeCorrenti;
|
|
private Dictionary<string, List<string>>? _ultimaVerifica;
|
|
private string? _ultimaCartellaRaw;
|
|
|
|
public Form1()
|
|
{
|
|
InitializeComponent();
|
|
BuildUi();
|
|
Load += (_, _) => InizializzaDatabase();
|
|
}
|
|
|
|
// Palette: blu primario per l'azione principale del flusso ("Crea cartella raw"),
|
|
// il resto resta ai colori di sistema per restare coerente col tema Windows dell'utente.
|
|
private static readonly Color ColorePrimario = Color.FromArgb(0, 99, 177);
|
|
|
|
private void BuildUi()
|
|
{
|
|
AllowDrop = true;
|
|
Text = "Distinta Base -> CSV con percorsi CAD";
|
|
MinimumSize = new Size(760, 480);
|
|
Font = new Font("Segoe UI", 9.5f);
|
|
|
|
var headerPanel = new Panel { Dock = DockStyle.Top, Height = 40, BackColor = SystemColors.ControlLight };
|
|
_lblFase.Dock = DockStyle.Fill;
|
|
_lblFase.TextAlign = ContentAlignment.MiddleLeft;
|
|
_lblFase.Padding = new Padding(12, 0, 0, 0);
|
|
_lblFase.Font = new Font(Font, FontStyle.Bold);
|
|
headerPanel.Controls.Add(_lblFase);
|
|
|
|
var navPanel = new FlowLayoutPanel
|
|
{
|
|
Dock = DockStyle.Bottom,
|
|
Height = 48,
|
|
FlowDirection = FlowDirection.RightToLeft,
|
|
Padding = new Padding(12, 8, 12, 8),
|
|
};
|
|
_btnAvanti.Text = "Avanti >";
|
|
_btnAvanti.Size = new Size(110, 32);
|
|
_btnAvanti.FlatStyle = FlatStyle.Flat;
|
|
_btnAvanti.FlatAppearance.BorderSize = 0;
|
|
_btnAvanti.BackColor = ColorePrimario;
|
|
_btnAvanti.ForeColor = Color.White;
|
|
_btnAvanti.Font = new Font(Font, FontStyle.Bold);
|
|
_btnAvanti.Click += (_, _) => VaiAllaFase(_faseAttuale + 1);
|
|
navPanel.Controls.Add(_btnAvanti);
|
|
|
|
_btnIndietro.Text = "< Indietro";
|
|
_btnIndietro.Size = new Size(110, 32);
|
|
_btnIndietro.Margin = new Padding(8, 0, 0, 0);
|
|
_btnIndietro.Click += (_, _) => VaiAllaFase(_faseAttuale - 1);
|
|
navPanel.Controls.Add(_btnIndietro);
|
|
|
|
var statusPanel = new Panel { Dock = DockStyle.Bottom, Height = 28, BackColor = SystemColors.ControlLight };
|
|
_lblStatus.Dock = DockStyle.Fill;
|
|
_lblStatus.TextAlign = ContentAlignment.MiddleLeft;
|
|
_lblStatus.Padding = new Padding(12, 0, 0, 0);
|
|
_lblStatus.Text = "Pronto.";
|
|
statusPanel.Controls.Add(_lblStatus);
|
|
|
|
_panelFasi[0] = BuildFaseDatabase();
|
|
_panelFasi[1] = BuildFaseImporta();
|
|
_panelFasi[2] = BuildFaseCreaRaw();
|
|
_panelFasi[3] = BuildFaseTrovaComponenti();
|
|
_panelFasi[4] = BuildFaseVerifica();
|
|
foreach (var panel in _panelFasi)
|
|
{
|
|
panel.Dock = DockStyle.Fill;
|
|
panel.Visible = false;
|
|
_faseContainer.Controls.Add(panel);
|
|
}
|
|
|
|
Controls.Add(_faseContainer);
|
|
Controls.Add(navPanel);
|
|
Controls.Add(statusPanel);
|
|
Controls.Add(headerPanel);
|
|
|
|
DragEnter += (_, e) =>
|
|
e.Effect = e.Data?.GetDataPresent(DataFormats.FileDrop) == true
|
|
? DragDropEffects.Copy
|
|
: DragDropEffects.None;
|
|
DragDrop += (_, e) =>
|
|
{
|
|
if (e.Data?.GetData(DataFormats.FileDrop) is string[] { Length: > 0 } file)
|
|
ImportaDistinta(file[0]);
|
|
};
|
|
|
|
VaiAllaFase(0);
|
|
}
|
|
|
|
/// <summary>Nasconde la fase corrente e mostra quella richiesta (se nei limiti e se la fase
|
|
/// corrente permette di avanzare); aggiorna titolo e stato dei pulsanti Indietro/Avanti.</summary>
|
|
private void VaiAllaFase(int fase)
|
|
{
|
|
if (fase < 0 || fase >= NomiFasi.Length)
|
|
return;
|
|
if (fase > _faseAttuale && !AvantiConsentito(_faseAttuale))
|
|
return;
|
|
|
|
_panelFasi[_faseAttuale].Visible = false;
|
|
_faseAttuale = fase;
|
|
_panelFasi[_faseAttuale].Visible = true;
|
|
|
|
_lblFase.Text = NomiFasi[_faseAttuale];
|
|
_btnIndietro.Visible = _faseAttuale > 0;
|
|
_btnAvanti.Visible = _faseAttuale < NomiFasi.Length - 1;
|
|
AggiornaStatoAvanti();
|
|
}
|
|
|
|
/// <summary>Condizione per cui la fase indicata è "conclusa" e si può passare alla successiva.</summary>
|
|
private bool AvantiConsentito(int fase) => fase switch
|
|
{
|
|
0 => _dbPath is not null,
|
|
1 => _righeCorrenti is { Count: > 0 },
|
|
2 => _ultimaCartellaRaw is not null,
|
|
3 => true, // risoluzione ricorsiva opzionale: non tutti gli assiemi hanno sotto-componenti
|
|
_ => true,
|
|
};
|
|
|
|
private void AggiornaStatoAvanti() => _btnAvanti.Enabled = AvantiConsentito(_faseAttuale);
|
|
|
|
private Panel BuildFaseDatabase()
|
|
{
|
|
var contenuto = new TableLayoutPanel
|
|
{
|
|
Dock = DockStyle.Top,
|
|
AutoSize = true,
|
|
AutoSizeMode = AutoSizeMode.GrowAndShrink,
|
|
ColumnCount = 1,
|
|
Padding = new Padding(16),
|
|
};
|
|
|
|
var lblIstruzioni = new Label
|
|
{
|
|
AutoSize = true,
|
|
ForeColor = SystemColors.GrayText,
|
|
Margin = new Padding(0, 0, 0, 12),
|
|
Text = "L'indice CAD viene caricato automaticamente all'avvio, se già presente. "
|
|
+ "Usa 'Apri DB...' per selezionarne un altro, oppure 'Aggiorna indice' per "
|
|
+ "scansionare di nuovo il disco (X:\\).",
|
|
};
|
|
contenuto.Controls.Add(lblIstruzioni);
|
|
|
|
_lblDb.AutoSize = true;
|
|
_lblDb.AutoEllipsis = true;
|
|
_lblDb.MaximumSize = new Size(900, 0);
|
|
_lblDb.ForeColor = SystemColors.GrayText;
|
|
_lblDb.Margin = new Padding(0, 0, 0, 4);
|
|
contenuto.Controls.Add(_lblDb);
|
|
|
|
_lblUltimoAggiornamento.AutoSize = true;
|
|
_lblUltimoAggiornamento.ForeColor = SystemColors.GrayText;
|
|
_lblUltimoAggiornamento.Margin = new Padding(0, 0, 0, 12);
|
|
contenuto.Controls.Add(_lblUltimoAggiornamento);
|
|
|
|
var bottoni = new FlowLayoutPanel { AutoSize = true, FlowDirection = FlowDirection.LeftToRight };
|
|
|
|
_btnApriDb.Text = "Apri DB...";
|
|
_btnApriDb.Size = new Size(120, 32);
|
|
_btnApriDb.Margin = new Padding(0, 0, 8, 0);
|
|
_btnApriDb.Click += (_, _) => ScegliDatabase();
|
|
bottoni.Controls.Add(_btnApriDb);
|
|
|
|
_btnAggiorna.Text = "Aggiorna indice";
|
|
_btnAggiorna.Size = new Size(120, 32);
|
|
_btnAggiorna.Click += (_, _) => AggiornaIndice();
|
|
bottoni.Controls.Add(_btnAggiorna);
|
|
|
|
contenuto.Controls.Add(bottoni);
|
|
|
|
var lblManutenzione = new Label
|
|
{
|
|
AutoSize = true,
|
|
ForeColor = SystemColors.GrayText,
|
|
Margin = new Padding(0, 20, 0, 8),
|
|
Text = "Manutenzione: svuota le cartelle 'raw' e 'step' nella root prima di un "
|
|
+ "nuovo giro (non tocca l'indice, solo le copie locali).",
|
|
};
|
|
contenuto.Controls.Add(lblManutenzione);
|
|
|
|
_btnPulisci.Text = "Pulisci raw e step";
|
|
_btnPulisci.Size = new Size(200, 30);
|
|
_btnPulisci.Click += (_, _) => PulisciRawEStep();
|
|
contenuto.Controls.Add(_btnPulisci);
|
|
|
|
var panel = new Panel();
|
|
panel.Controls.Add(contenuto);
|
|
return panel;
|
|
}
|
|
|
|
private Panel BuildFaseImporta()
|
|
{
|
|
var contenuto = new TableLayoutPanel
|
|
{
|
|
Dock = DockStyle.Top,
|
|
AutoSize = true,
|
|
AutoSizeMode = AutoSizeMode.GrowAndShrink,
|
|
ColumnCount = 1,
|
|
Padding = new Padding(16),
|
|
};
|
|
|
|
var lblIstruzioni = new Label
|
|
{
|
|
AutoSize = true,
|
|
ForeColor = SystemColors.GrayText,
|
|
Margin = new Padding(0, 0, 0, 8),
|
|
Text = "Trascina qui il file .xls/.xml esportato dal gestionale (foglio 'Distinta "
|
|
+ "Base'), oppure scegli il file col pulsante sotto: genera un CSV con Componente "
|
|
+ "e Descrizione, in anteprima nella griglia.",
|
|
};
|
|
contenuto.Controls.Add(lblIstruzioni);
|
|
|
|
var btnSfoglia = new Button
|
|
{
|
|
Text = "Scegli file distinta...",
|
|
Size = new Size(220, 32),
|
|
Margin = new Padding(0, 0, 0, 8),
|
|
};
|
|
btnSfoglia.Click += (_, _) => ScegliFileDistinta();
|
|
contenuto.Controls.Add(btnSfoglia);
|
|
|
|
_btnVerifica.Text = "Verifica presenza nel DB";
|
|
_btnVerifica.Size = new Size(220, 32);
|
|
_btnVerifica.Margin = new Padding(0, 0, 0, 8);
|
|
_btnVerifica.Click += (_, _) => VerificaCodiciNelDb();
|
|
contenuto.Controls.Add(_btnVerifica);
|
|
|
|
_lblImportStatus.AutoSize = false;
|
|
_lblImportStatus.AutoEllipsis = true;
|
|
_lblImportStatus.Height = 24;
|
|
_lblImportStatus.Width = 900;
|
|
_lblImportStatus.ForeColor = SystemColors.GrayText;
|
|
contenuto.Controls.Add(_lblImportStatus);
|
|
|
|
_gridImport.Dock = DockStyle.Fill;
|
|
_gridImport.ReadOnly = true;
|
|
_gridImport.BorderStyle = BorderStyle.None;
|
|
_gridImport.BackgroundColor = SystemColors.Window;
|
|
_gridImport.RowHeadersVisible = false;
|
|
_gridImport.AllowUserToAddRows = false;
|
|
_gridImport.AllowUserToDeleteRows = false;
|
|
_gridImport.AllowUserToResizeRows = false;
|
|
_gridImport.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
|
|
_gridImport.MultiSelect = false;
|
|
_gridImport.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
|
|
_gridImport.ColumnHeadersHeight = 32;
|
|
_gridImport.ColumnHeadersDefaultCellStyle.Font = new Font(Font, FontStyle.Bold);
|
|
_gridImport.ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
|
|
_gridImport.RowTemplate.Height = 26;
|
|
_gridImport.AlternatingRowsDefaultCellStyle.BackColor = Color.FromArgb(245, 247, 250);
|
|
_gridImport.DefaultCellStyle.SelectionBackColor = ColorePrimario;
|
|
_gridImport.DefaultCellStyle.Padding = new Padding(4, 0, 4, 0);
|
|
_gridImport.Columns.Add("componente", "Componente");
|
|
_gridImport.Columns.Add("descrizione", "Descrizione");
|
|
_gridImport.Columns["componente"]!.FillWeight = 30;
|
|
_gridImport.Columns["descrizione"]!.FillWeight = 70;
|
|
|
|
var panel = new Panel();
|
|
panel.Controls.Add(_gridImport);
|
|
panel.Controls.Add(contenuto);
|
|
return panel;
|
|
}
|
|
|
|
private Panel BuildFaseCreaRaw()
|
|
{
|
|
var contenuto = new TableLayoutPanel
|
|
{
|
|
Dock = DockStyle.Top,
|
|
AutoSize = true,
|
|
AutoSizeMode = AutoSizeMode.GrowAndShrink,
|
|
ColumnCount = 1,
|
|
Padding = new Padding(16),
|
|
};
|
|
|
|
var lblIstruzioni = new Label
|
|
{
|
|
AutoSize = true,
|
|
ForeColor = SystemColors.GrayText,
|
|
Margin = new Padding(0, 0, 0, 8),
|
|
Text = "Cerca nell'indice il percorso CAD di ogni componente importato e copia i "
|
|
+ "file trovati in una cartella 'raw' accanto al file di distinta originale.",
|
|
};
|
|
contenuto.Controls.Add(lblIstruzioni);
|
|
|
|
_btnCreaRaw.Text = "Crea cartella raw";
|
|
_btnCreaRaw.Size = new Size(220, 36);
|
|
_btnCreaRaw.Margin = new Padding(0, 0, 0, 12);
|
|
_btnCreaRaw.FlatStyle = FlatStyle.Flat;
|
|
_btnCreaRaw.FlatAppearance.BorderSize = 0;
|
|
_btnCreaRaw.BackColor = ColorePrimario;
|
|
_btnCreaRaw.ForeColor = Color.White;
|
|
_btnCreaRaw.Font = new Font(Font, FontStyle.Bold);
|
|
_btnCreaRaw.Click += (_, _) => CreaCartellaRaw();
|
|
contenuto.Controls.Add(_btnCreaRaw);
|
|
|
|
_gridRaw.Dock = DockStyle.Fill;
|
|
_gridRaw.ReadOnly = true;
|
|
_gridRaw.BorderStyle = BorderStyle.None;
|
|
_gridRaw.BackgroundColor = SystemColors.Window;
|
|
_gridRaw.RowHeadersVisible = false;
|
|
_gridRaw.AllowUserToAddRows = false;
|
|
_gridRaw.AllowUserToDeleteRows = false;
|
|
_gridRaw.AllowUserToResizeRows = false;
|
|
_gridRaw.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
|
|
_gridRaw.MultiSelect = false;
|
|
_gridRaw.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
|
|
_gridRaw.ColumnHeadersHeight = 32;
|
|
_gridRaw.ColumnHeadersDefaultCellStyle.Font = new Font(Font, FontStyle.Bold);
|
|
_gridRaw.RowTemplate.Height = 26;
|
|
_gridRaw.AlternatingRowsDefaultCellStyle.BackColor = Color.FromArgb(245, 247, 250);
|
|
_gridRaw.DefaultCellStyle.SelectionBackColor = ColorePrimario;
|
|
_gridRaw.DefaultCellStyle.Padding = new Padding(4, 0, 4, 0);
|
|
_gridRaw.Columns.Add("componente", "Componente");
|
|
_gridRaw.Columns.Add("percorso", "Percorso CAD");
|
|
_gridRaw.Columns["componente"]!.FillWeight = 25;
|
|
_gridRaw.Columns["percorso"]!.FillWeight = 75;
|
|
_gridRaw.CellDoubleClick += (_, _) => ApriCartellaFileSelezionato();
|
|
|
|
var panel = new Panel();
|
|
panel.Controls.Add(_gridRaw);
|
|
panel.Controls.Add(contenuto);
|
|
return panel;
|
|
}
|
|
|
|
private Panel BuildFaseTrovaComponenti()
|
|
{
|
|
var contenuto = new TableLayoutPanel
|
|
{
|
|
Dock = DockStyle.Top,
|
|
AutoSize = true,
|
|
AutoSizeMode = AutoSizeMode.GrowAndShrink,
|
|
ColumnCount = 1,
|
|
Padding = new Padding(16),
|
|
};
|
|
|
|
var lblIstruzioni = new Label
|
|
{
|
|
AutoSize = true,
|
|
ForeColor = SystemColors.GrayText,
|
|
Margin = new Padding(0, 0, 0, 12),
|
|
Text = "Gli assiemi referenziano altri PRT e sotto-assiemi al loro interno: premi "
|
|
+ "qui per risolvere l'albero componenti (ricorsivamente) e copiare tutto ciò che "
|
|
+ "viene trovato nell'indice dentro 'raw'. Passo opzionale: se la distinta contiene "
|
|
+ "solo parti singole puoi anche passare direttamente alla fase successiva.",
|
|
};
|
|
contenuto.Controls.Add(lblIstruzioni);
|
|
|
|
_btnTrovaPrt.Text = "Trova componenti referenziati";
|
|
_btnTrovaPrt.Size = new Size(220, 32);
|
|
_btnTrovaPrt.Click += (_, _) => TrovaPrtReferenziati();
|
|
contenuto.Controls.Add(_btnTrovaPrt);
|
|
|
|
var panel = new Panel();
|
|
panel.Controls.Add(contenuto);
|
|
return panel;
|
|
}
|
|
|
|
private Panel BuildFaseVerifica()
|
|
{
|
|
var contenuto = new TableLayoutPanel
|
|
{
|
|
Dock = DockStyle.Top,
|
|
AutoSize = true,
|
|
AutoSizeMode = AutoSizeMode.GrowAndShrink,
|
|
ColumnCount = 1,
|
|
Padding = new Padding(16),
|
|
};
|
|
|
|
var lblIstruzioniCompletezza = new Label
|
|
{
|
|
AutoSize = true,
|
|
ForeColor = SystemColors.GrayText,
|
|
Margin = new Padding(0, 0, 0, 8),
|
|
Text = "Per ogni assieme della distinta, verifica se tutti i suoi componenti "
|
|
+ "(ricorsivamente fino ai PRT) sono nell'indice. Nota: la scansione dei .asm "
|
|
+ "è euristica, quindi qualche falso 'incompleto' è possibile.",
|
|
};
|
|
contenuto.Controls.Add(lblIstruzioniCompletezza);
|
|
|
|
_btnCompletezza.Text = "Verifica completezza assiemi";
|
|
_btnCompletezza.Size = new Size(220, 32);
|
|
_btnCompletezza.Margin = new Padding(0, 0, 0, 20);
|
|
_btnCompletezza.Click += (_, _) => VerificaCompletezzaAssiemi();
|
|
contenuto.Controls.Add(_btnCompletezza);
|
|
|
|
var lblIstruzioniStep = new Label
|
|
{
|
|
AutoSize = true,
|
|
ForeColor = SystemColors.GrayText,
|
|
Margin = new Padding(0, 0, 0, 8),
|
|
Text = "Dopo aver esportato gli STEP con Creo, premi qui per confrontare i componenti "
|
|
+ "della distinta (e i sotto-componenti trovati in fase 4) con i file .stp presenti "
|
|
+ "in 'step', copiare quelli trovati in 'step_finali' e vedere quali mancano ancora.",
|
|
};
|
|
contenuto.Controls.Add(lblIstruzioniStep);
|
|
|
|
_btnReport.Text = "Crea cartella step_finali";
|
|
_btnReport.Size = new Size(220, 32);
|
|
_btnReport.Click += (_, _) => GeneraReportStep();
|
|
contenuto.Controls.Add(_btnReport);
|
|
|
|
var panel = new Panel();
|
|
panel.Controls.Add(contenuto);
|
|
return panel;
|
|
}
|
|
|
|
private void ScegliFileDistinta()
|
|
{
|
|
using var dialog = new OpenFileDialog
|
|
{
|
|
Filter = "File distinta base (*.xls;*.xml)|*.xls;*.xml|Tutti i file|*.*",
|
|
Title = "Seleziona il file Distinta Base",
|
|
};
|
|
if (dialog.ShowDialog(this) == DialogResult.OK)
|
|
ImportaDistinta(dialog.FileName);
|
|
}
|
|
|
|
private void ImportaDistinta(string percorso)
|
|
{
|
|
try
|
|
{
|
|
var (csv, righe) = DistintaBaseImporter.ConvertiInCsv(percorso);
|
|
_percorsoInputCorrente = percorso;
|
|
_righeCorrenti = righe;
|
|
|
|
_gridImport.Rows.Clear();
|
|
foreach (var (componente, descrizione) in righe)
|
|
{
|
|
_gridImport.Rows.Add(componente, descrizione);
|
|
}
|
|
_gridRaw.Rows.Clear();
|
|
_ultimaCartellaRaw = null;
|
|
_ultimaVerifica = null;
|
|
|
|
ImpostaStatoImport($"CSV generato ({righe.Count} righe): {csv}", Color.DarkGreen);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_percorsoInputCorrente = null;
|
|
_righeCorrenti = null;
|
|
_gridImport.Rows.Clear();
|
|
ImpostaStatoImport($"Errore durante la conversione: {ex.Message}", Color.DarkRed);
|
|
}
|
|
AggiornaStatoAvanti();
|
|
}
|
|
|
|
/// <summary>Imposta testo/colore dello stato import e il tooltip con il testo completo
|
|
/// (la label tronca con "..." quando il percorso non ci sta in una riga).</summary>
|
|
private void ImpostaStatoImport(string testo, Color colore)
|
|
{
|
|
_lblImportStatus.ForeColor = colore;
|
|
_lblImportStatus.Text = testo;
|
|
_tipImportStatus.SetToolTip(_lblImportStatus, testo);
|
|
}
|
|
|
|
private void VerificaCodiciNelDb()
|
|
{
|
|
if (_righeCorrenti is null)
|
|
return;
|
|
|
|
var trovati = TrovaPercorsiCad(_righeCorrenti.Select(r => r.Componente));
|
|
_ultimaVerifica = trovati;
|
|
foreach (DataGridViewRow riga in _gridImport.Rows)
|
|
{
|
|
string componente = (string)riga.Cells["componente"].Value!;
|
|
riga.DefaultCellStyle.BackColor = trovati.ContainsKey(componente)
|
|
? Color.FromArgb(198, 239, 206)
|
|
: Color.FromArgb(255, 199, 206);
|
|
}
|
|
}
|
|
|
|
private void CreaCartellaRaw()
|
|
{
|
|
if (_percorsoInputCorrente is null || _righeCorrenti is null)
|
|
return;
|
|
|
|
// L'assieme generale è già una riga di _righeCorrenti (aggiunta da
|
|
// DistintaBaseImporter.ConvertiInCsv leggendo il nome del file distinta), quindi viene
|
|
// trovato e copiato in raw come qualsiasi altro componente, senza bisogno di un caso speciale.
|
|
var percorsiTrovati = _ultimaVerifica ?? TrovaPercorsiCad(_righeCorrenti.Select(r => r.Componente));
|
|
|
|
_gridRaw.Rows.Clear();
|
|
foreach (var (componente, _) in _righeCorrenti)
|
|
{
|
|
string percorsoCad = percorsiTrovati.TryGetValue(componente, out var lista)
|
|
? string.Join("; ", lista)
|
|
: "";
|
|
_gridRaw.Rows.Add(componente, percorsoCad);
|
|
}
|
|
|
|
var cartellaRaw = Path.Combine(Path.GetDirectoryName(Path.GetFullPath(_percorsoInputCorrente))!, "raw");
|
|
int copiati = CopiaFileTrovati(percorsiTrovati.Values.SelectMany(p => p).Distinct(), cartellaRaw);
|
|
_ultimaCartellaRaw = cartellaRaw;
|
|
|
|
ImpostaStatoImport(
|
|
$"{percorsiTrovati.Count} componenti con percorso CAD trovato su {_righeCorrenti.Count}. "
|
|
+ $"{copiati} file copiati in {cartellaRaw}",
|
|
Color.DarkGreen);
|
|
AggiornaStatoAvanti();
|
|
}
|
|
|
|
/// <summary>Confronta i componenti della distinta importata con i file .stp presenti nella
|
|
/// cartella "step" (esportati manualmente con Creo Distributed Batch), per dire quali sono
|
|
/// già stati realizzati e quali mancano ancora.</summary>
|
|
private void GeneraReportStep()
|
|
{
|
|
if (_percorsoInputCorrente is null || _righeCorrenti is null)
|
|
return;
|
|
|
|
string radice = Path.GetDirectoryName(Path.GetFullPath(_percorsoInputCorrente))!;
|
|
var cartellaStep = Path.Combine(radice, "step");
|
|
if (!Directory.Exists(cartellaStep))
|
|
{
|
|
ImpostaStatoImport($"Cartella 'step' non trovata in {cartellaStep}.", Color.DarkRed);
|
|
return;
|
|
}
|
|
|
|
var descrizioni = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (var r in _righeCorrenti)
|
|
descrizioni[r.Componente] = r.Descrizione;
|
|
|
|
// Solo i componenti della distinta importata dal CSV: i sotto-componenti trovati in
|
|
// fase 4 (_componentiRisolti) servono a completare "raw", non entrano nello STEP finale.
|
|
var tuttiICodici = _righeCorrenti.Select(r => r.Componente)
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
.ToList();
|
|
|
|
// Per i codici senza STEP, distingue "il CAD c'è ma lo STEP non è stato esportato" da
|
|
// "il componente non è nemmeno nell'indice CAD" (riusa la verifica già fatta in fase 2/3
|
|
// se disponibile, altrimenti la rifà).
|
|
var cadTrovati = _ultimaVerifica ?? TrovaPercorsiCad(tuttiICodici);
|
|
|
|
var cartellaStepFinali = Path.Combine(radice, "step_finali");
|
|
Directory.CreateDirectory(cartellaStepFinali);
|
|
|
|
var righeReport = new List<(string Componente, string Descrizione, EsitoStep Esito)>();
|
|
foreach (var codice in tuttiICodici)
|
|
{
|
|
var percorsoStp = Path.Combine(cartellaStep, codice + ".stp");
|
|
EsitoStep esito;
|
|
if (File.Exists(percorsoStp))
|
|
{
|
|
File.Copy(percorsoStp, Path.Combine(cartellaStepFinali, codice + ".stp"), overwrite: true);
|
|
esito = EsitoStep.Creato;
|
|
}
|
|
else
|
|
{
|
|
esito = cadTrovati.ContainsKey(codice) ? EsitoStep.StepMancante : EsitoStep.ComponenteNonTrovato;
|
|
}
|
|
righeReport.Add((codice, descrizioni.GetValueOrDefault(codice, ""), esito));
|
|
}
|
|
int creati = righeReport.Count(r => r.Esito == EsitoStep.Creato);
|
|
int stepMancanti = righeReport.Count(r => r.Esito == EsitoStep.StepMancante);
|
|
int nonTrovati = righeReport.Count(r => r.Esito == EsitoStep.ComponenteNonTrovato);
|
|
|
|
ImpostaStatoImport(
|
|
$"STEP finali: {creati} copiati, {stepMancanti} da esportare (CAD presente), "
|
|
+ $"{nonTrovati} componenti non nell'indice, su {righeReport.Count} totali. "
|
|
+ $"Cartella: {cartellaStepFinali}.",
|
|
Color.DarkGreen);
|
|
|
|
using var dialog = new ReportStepForm(righeReport, cartellaStepFinali);
|
|
dialog.ShowDialog(this);
|
|
}
|
|
|
|
/// <summary>Svuota in un colpo solo le cartelle "raw", "step" e "step_finali" nella root
|
|
/// (stessa cartella base del file distinta importato), previa un'unica conferma. Non tocca
|
|
/// l'indice CAD: solo le copie locali generate dalla pipeline.</summary>
|
|
private void PulisciRawEStep()
|
|
{
|
|
string radice;
|
|
if (_ultimaCartellaRaw is not null)
|
|
{
|
|
radice = Path.GetDirectoryName(_ultimaCartellaRaw)!;
|
|
}
|
|
else
|
|
{
|
|
// Non abbiamo ancora una cartella nota in questa sessione (es. app appena riaperta):
|
|
// si chiede all'utente di indicare la root invece di tenere il pulsante disabilitato.
|
|
using var dialog = new FolderBrowserDialog { Description = "Seleziona la cartella root (contiene 'raw' e 'step')" };
|
|
if (dialog.ShowDialog(this) != DialogResult.OK)
|
|
return;
|
|
radice = dialog.SelectedPath;
|
|
}
|
|
|
|
var cartelle = new[] { Path.Combine(radice, "raw"), Path.Combine(radice, "step"), Path.Combine(radice, "step_finali") }
|
|
.Where(Directory.Exists)
|
|
.ToList();
|
|
if (cartelle.Count == 0)
|
|
{
|
|
ImpostaStatoImport($"Nessuna cartella 'raw', 'step' o 'step_finali' trovata in {radice}.", Color.DarkRed);
|
|
return;
|
|
}
|
|
|
|
var conferma = MessageBox.Show(this,
|
|
$"Eliminare tutti i file in:\n{string.Join("\n", cartelle)}\n\nL'operazione non è reversibile.",
|
|
"Pulisci raw e step", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
|
|
if (conferma != DialogResult.Yes)
|
|
return;
|
|
|
|
int eliminati = 0;
|
|
foreach (var cartella in cartelle)
|
|
{
|
|
foreach (var file in Directory.GetFiles(cartella))
|
|
{
|
|
try
|
|
{
|
|
File.Delete(file);
|
|
eliminati++;
|
|
}
|
|
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
|
{
|
|
// ponytail: file in uso (es. aperto in Creo) -> si salta, non blocca gli altri
|
|
}
|
|
}
|
|
}
|
|
|
|
ImpostaStatoImport($"{eliminati} file eliminati da {string.Join(" e ", cartelle)}.", Color.DarkGreen);
|
|
}
|
|
|
|
/// <summary>Risolve ricorsivamente l'albero dei componenti a partire dai file .asm indicati
|
|
/// (già copiati in "raw"): per ogni assieme legge i codici referenziati al suo interno, li
|
|
/// cerca nell'indice, copia in "raw" quelli trovati e, se sono a loro volta assiemi, li
|
|
/// accoda per essere scansionati finché non restano solo PRT (foglie) o codici non presenti
|
|
/// nell'indice. Usata dal bottone "Trova componenti referenziati".</summary>
|
|
private (List<(string Codice, string Tipo, string Percorso)> Trovati, List<string> NonTrovati) RisolviAlberoComponenti(
|
|
IEnumerable<string> asmIniziali, IProgress<(int Fatti, int Totale)>? progress = null)
|
|
{
|
|
var daScansionare = new Queue<string>(asmIniziali);
|
|
var codiciIniziali = daScansionare.Select(f => Path.GetFileName(f).Split('.')[0]);
|
|
var codiciVisti = new HashSet<string>(
|
|
codiciIniziali.Concat(codiciIniziali.Select(AssemblyComponentScanner.CodiceRadice)),
|
|
StringComparer.OrdinalIgnoreCase);
|
|
|
|
var trovati = new List<(string Codice, string Tipo, string Percorso)>();
|
|
var codiciNonTrovati = new List<string>();
|
|
if (daScansionare.Count == 0 || _dbPath is null)
|
|
return (trovati, codiciNonTrovati);
|
|
|
|
using var connection = new SqliteConnection($"Data Source={_dbPath};Mode=ReadOnly");
|
|
connection.Open();
|
|
using var command = connection.CreateCommand();
|
|
command.CommandText = "SELECT tipo_file, percorso_completo FROM files_ultima_versione "
|
|
+ "WHERE LOWER(codice) = LOWER(@codice) AND LOWER(tipo_file) IN ('prt', 'asm') "
|
|
+ "ORDER BY tipo_file, data_modifica DESC";
|
|
var pCodice = command.Parameters.Add("@codice", Microsoft.Data.Sqlite.SqliteType.Text);
|
|
|
|
int processati = 0;
|
|
while (daScansionare.Count > 0)
|
|
{
|
|
var asm = daScansionare.Dequeue();
|
|
processati++;
|
|
foreach (var codice in AssemblyComponentScanner.EstraiCodiciReferenziati(asm))
|
|
{
|
|
if (!codiciVisti.Add(codice))
|
|
continue;
|
|
|
|
pCodice.Value = codice;
|
|
// Lo stesso codice+tipo può esistere in più cartelle radice (duplicati sulla
|
|
// share): ordinato per data_modifica DESC, si tiene solo il più recente per tipo.
|
|
var componenti = new List<(string Tipo, string Percorso)>();
|
|
var tipiVisti = new HashSet<string>();
|
|
using (var reader = command.ExecuteReader())
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
string tipoLower = reader.GetString(0).ToLowerInvariant();
|
|
if (tipiVisti.Add(tipoLower))
|
|
{
|
|
componenti.Add((tipoLower, reader.GetString(1)));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (componenti.Count == 0)
|
|
{
|
|
codiciNonTrovati.Add(codice);
|
|
continue;
|
|
}
|
|
|
|
foreach (var (tipo, percorso) in componenti)
|
|
{
|
|
CopiaFileTrovati(new[] { percorso }, _ultimaCartellaRaw!);
|
|
trovati.Add((codice, tipo, percorso));
|
|
if (tipo == "asm")
|
|
{
|
|
daScansionare.Enqueue(Path.Combine(_ultimaCartellaRaw!, Path.GetFileName(percorso)));
|
|
}
|
|
}
|
|
}
|
|
progress?.Report((processati, processati + daScansionare.Count));
|
|
}
|
|
|
|
return (trovati, codiciNonTrovati);
|
|
}
|
|
|
|
private async void TrovaPrtReferenziati()
|
|
{
|
|
if (_ultimaCartellaRaw is null || !Directory.Exists(_ultimaCartellaRaw))
|
|
return;
|
|
|
|
if (_dbPath is null)
|
|
{
|
|
ImpostaStatoImport("Nessun database caricato: impossibile risolvere i componenti referenziati.", Color.DarkRed);
|
|
return;
|
|
}
|
|
|
|
// L'assieme generale è già in raw come qualsiasi altro assieme importato (vedi
|
|
// CreaCartellaRaw), quindi rientra qui senza bisogno di un caso speciale.
|
|
var asmIniziali = Directory.GetFiles(_ultimaCartellaRaw).Where(f => Path.GetFileName(f).Contains(".asm.")).ToList();
|
|
|
|
using var progressForm = new ProgressoComponentiForm();
|
|
var progress = new Progress<(int Fatti, int Totale)>(p => progressForm.Aggiorna(p.Fatti, p.Totale));
|
|
var task = Task.Run(() => RisolviAlberoComponenti(asmIniziali, progress));
|
|
progressForm.Shown += async (_, _) =>
|
|
{
|
|
await task;
|
|
progressForm.Close();
|
|
};
|
|
progressForm.ShowDialog(this);
|
|
|
|
var (trovati, codiciNonTrovati) = await task;
|
|
|
|
int numPrt = trovati.Count(r => r.Tipo == "prt");
|
|
int numAsm = trovati.Count(r => r.Tipo == "asm");
|
|
ImpostaStatoImport(
|
|
$"Componenti referenziati: {numPrt} PRT e {numAsm} sotto-assiemi trovati e copiati in raw, "
|
|
+ $"{codiciNonTrovati.Count} codici referenziati non trovati nell'indice.",
|
|
Color.DarkGreen);
|
|
|
|
using var dialog = new PrtMancantiForm(trovati, codiciNonTrovati, _ultimaCartellaRaw);
|
|
dialog.ShowDialog(this);
|
|
}
|
|
|
|
/// <summary>Per ogni assieme della distinta, verifica ricorsivamente (leggendo i .asm dai
|
|
/// percorsi originali sulla share) se tutti i componenti fino ai PRT sono nell'indice.
|
|
/// I risultati di ogni file/codice vengono in cache e condivisi tra gli assiemi controllati
|
|
/// nella stessa passata, per non rileggere più volte gli stessi sotto-componenti.</summary>
|
|
private void VerificaCompletezzaAssiemi()
|
|
{
|
|
if (_righeCorrenti is null)
|
|
return;
|
|
if (_dbPath is null)
|
|
{
|
|
ImpostaStatoImport("Nessun database caricato: impossibile verificare la completezza.", Color.DarkRed);
|
|
return;
|
|
}
|
|
|
|
using var connection = new SqliteConnection($"Data Source={_dbPath};Mode=ReadOnly");
|
|
connection.Open();
|
|
using var command = connection.CreateCommand();
|
|
command.CommandText = "SELECT tipo_file, percorso_completo FROM files_ultima_versione "
|
|
+ "WHERE LOWER(codice) = LOWER(@codice) AND LOWER(tipo_file) IN ('prt', 'asm') "
|
|
+ "ORDER BY tipo_file, data_modifica DESC";
|
|
var pCodice = command.Parameters.Add("@codice", Microsoft.Data.Sqlite.SqliteType.Text);
|
|
|
|
var cacheComponenti = new Dictionary<string, List<(string Tipo, string Percorso)>>();
|
|
var cacheCodiciFile = new Dictionary<string, HashSet<string>>();
|
|
|
|
List<(string Tipo, string Percorso)> CercaComponenti(string codice)
|
|
{
|
|
if (cacheComponenti.TryGetValue(codice, out var giaTrovati))
|
|
return giaTrovati;
|
|
|
|
pCodice.Value = codice;
|
|
var risultato = new List<(string Tipo, string Percorso)>();
|
|
var tipiVisti = new HashSet<string>();
|
|
using (var reader = command.ExecuteReader())
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
string tipo = reader.GetString(0).ToLowerInvariant();
|
|
if (tipiVisti.Add(tipo))
|
|
{
|
|
risultato.Add((tipo, reader.GetString(1)));
|
|
}
|
|
}
|
|
}
|
|
cacheComponenti[codice] = risultato;
|
|
return risultato;
|
|
}
|
|
|
|
bool AssiemeCompleto(string percorsoAsmIniziale)
|
|
{
|
|
var daVisitare = new Queue<string>();
|
|
daVisitare.Enqueue(percorsoAsmIniziale);
|
|
var fileVisitati = new HashSet<string> { percorsoAsmIniziale };
|
|
var codiceIniziale = Path.GetFileName(percorsoAsmIniziale).Split('.')[0];
|
|
var codiciVisti = new HashSet<string>
|
|
{
|
|
codiceIniziale,
|
|
AssemblyComponentScanner.CodiceRadice(codiceIniziale),
|
|
};
|
|
|
|
while (daVisitare.Count > 0)
|
|
{
|
|
var file = daVisitare.Dequeue();
|
|
if (!cacheCodiciFile.TryGetValue(file, out var codiciReferenziati))
|
|
{
|
|
try
|
|
{
|
|
codiciReferenziati = AssemblyComponentScanner.EstraiCodiciReferenziati(file);
|
|
}
|
|
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
|
{
|
|
return false; // file irraggiungibile (share offline) -> non verificabile, per prudenza "incompleto"
|
|
}
|
|
cacheCodiciFile[file] = codiciReferenziati;
|
|
}
|
|
|
|
foreach (var codice in codiciReferenziati)
|
|
{
|
|
if (!codiciVisti.Add(codice))
|
|
continue;
|
|
|
|
var componenti = CercaComponenti(codice);
|
|
if (componenti.Count == 0)
|
|
return false;
|
|
|
|
foreach (var (tipo, percorso) in componenti)
|
|
{
|
|
if (tipo == "asm" && fileVisitati.Add(percorso))
|
|
{
|
|
daVisitare.Enqueue(percorso);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// L'assieme generale è già una riga di _righeCorrenti (vedi DistintaBaseImporter), quindi
|
|
// la sua completezza viene verificata insieme a quella di tutti gli altri componenti.
|
|
var righeReport = new List<(string Componente, string Descrizione, bool? Completo)>();
|
|
foreach (var (componente, descrizione) in _righeCorrenti)
|
|
{
|
|
var componenti = CercaComponenti(componente);
|
|
string? percorsoAsm = componenti.Where(c => c.Tipo == "asm").Select(c => c.Percorso).FirstOrDefault();
|
|
|
|
bool? completo = componenti.Count == 0 ? null
|
|
: percorsoAsm is null ? true // solo prt trovato: nessuna sotto-struttura da verificare
|
|
: AssiemeCompleto(percorsoAsm);
|
|
|
|
righeReport.Add((componente, descrizione, completo));
|
|
}
|
|
|
|
int completi = righeReport.Count(r => r.Completo == true);
|
|
int incompleti = righeReport.Count(r => r.Completo == false);
|
|
int nonTrovati = righeReport.Count(r => r.Completo is null);
|
|
ImpostaStatoImport(
|
|
$"Completezza assiemi: {completi} completi, {incompleti} incompleti, "
|
|
+ $"{nonTrovati} non trovati nell'indice.",
|
|
Color.DarkGreen);
|
|
|
|
using var dialogCompletezza = new ReportCompletezzaForm(righeReport);
|
|
dialogCompletezza.ShowDialog(this);
|
|
}
|
|
|
|
/// <summary>Copia i file trovati nella cartella "raw" indicata, creandola se necessario.
|
|
/// Ritorna il numero di file copiati con successo.</summary>
|
|
internal static int CopiaFileTrovati(IEnumerable<string> percorsi, string cartellaRaw)
|
|
{
|
|
int copiati = 0;
|
|
foreach (var percorso in percorsi)
|
|
{
|
|
try
|
|
{
|
|
Directory.CreateDirectory(cartellaRaw);
|
|
File.Copy(percorso, Path.Combine(cartellaRaw, Path.GetFileName(percorso)), overwrite: true);
|
|
copiati++;
|
|
}
|
|
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
|
{
|
|
// ponytail: file non raggiungibile (share offline, permessi) -> lo si salta, non blocca gli altri
|
|
}
|
|
}
|
|
return copiati;
|
|
}
|
|
|
|
/// <summary>Cerca, per ogni codice componente, i percorsi dei file CAD (ultima versione,
|
|
/// solo prt/asm) corrispondenti nell'indice.</summary>
|
|
private Dictionary<string, List<string>> TrovaPercorsiCad(IEnumerable<string> codici)
|
|
{
|
|
var risultato = new Dictionary<string, List<string>>();
|
|
if (_dbPath is null)
|
|
return risultato;
|
|
|
|
using var connection = new SqliteConnection($"Data Source={_dbPath};Mode=ReadOnly");
|
|
connection.Open();
|
|
|
|
var nomiParametri = TipiPredefiniti.Select((_, i) => $"@tipo{i}");
|
|
using var command = connection.CreateCommand();
|
|
command.CommandText = $"""
|
|
SELECT tipo_file, percorso_completo FROM files_ultima_versione
|
|
WHERE LOWER(codice) = LOWER(@codice) AND LOWER(tipo_file) IN ({string.Join(",", nomiParametri)})
|
|
ORDER BY tipo_file, data_modifica DESC
|
|
""";
|
|
var pCodice = command.Parameters.Add("@codice", Microsoft.Data.Sqlite.SqliteType.Text);
|
|
for (int i = 0; i < TipiPredefiniti.Length; i++)
|
|
{
|
|
command.Parameters.AddWithValue($"@tipo{i}", TipiPredefiniti[i]);
|
|
}
|
|
|
|
foreach (var codice in codici.Distinct())
|
|
{
|
|
pCodice.Value = codice;
|
|
using var reader = command.ExecuteReader();
|
|
var percorsi = new List<string>();
|
|
// Lo stesso codice+tipo può esistere in più cartelle radice (duplicati sulla share):
|
|
// essendo ordinato per data_modifica DESC, il primo per tipo è il più recente, gli altri si scartano.
|
|
var tipiVisti = new HashSet<string>();
|
|
while (reader.Read())
|
|
{
|
|
if (tipiVisti.Add(reader.GetString(0).ToLowerInvariant()))
|
|
{
|
|
percorsi.Add(reader.GetString(1));
|
|
}
|
|
}
|
|
if (percorsi.Count > 0)
|
|
risultato[codice] = percorsi;
|
|
}
|
|
|
|
return risultato;
|
|
}
|
|
|
|
private static readonly string PercorsoImpostazioni = Path.Combine(
|
|
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "CadSearchGui", "ultimo_db.txt");
|
|
|
|
private void InizializzaDatabase()
|
|
{
|
|
var candidati = new[]
|
|
{
|
|
LeggiUltimoDbUsato(),
|
|
Path.Combine(AppContext.BaseDirectory, "cad_index.db"),
|
|
Path.Combine(Directory.GetCurrentDirectory(), "cad_index.db"),
|
|
};
|
|
_dbPath = candidati.FirstOrDefault(p => p is not null && File.Exists(p));
|
|
|
|
if (_dbPath is null)
|
|
{
|
|
_lblStatus.Text = "Database non trovato. Usa 'Apri DB...' per selezionarlo oppure 'Aggiorna indice' per crearlo.";
|
|
_lblDb.Text = "Nessun database caricato. Premi 'Aggiorna indice' per crearlo da X:\\, oppure 'Apri DB...' se ne hai gi\u00e0 uno.";
|
|
_lblUltimoAggiornamento.Text = "";
|
|
AggiornaStatoAvanti();
|
|
return;
|
|
}
|
|
|
|
CaricaDatabase(_dbPath);
|
|
}
|
|
|
|
private void ScegliDatabase()
|
|
{
|
|
using var dialog = new OpenFileDialog
|
|
{
|
|
Filter = "Database SQLite (*.db)|*.db|Tutti i file (*.*)|*.*",
|
|
Title = "Seleziona cad_index.db",
|
|
};
|
|
if (dialog.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
CaricaDatabase(dialog.FileName);
|
|
}
|
|
}
|
|
|
|
private void CaricaDatabase(string path)
|
|
{
|
|
try
|
|
{
|
|
using var connection = new SqliteConnection($"Data Source={path};Mode=ReadOnly");
|
|
connection.Open();
|
|
|
|
long totale = (long)(new SqliteCommand("SELECT COUNT(*) FROM files", connection).ExecuteScalar() ?? 0L);
|
|
object? ultimaScansioneRaw = new SqliteCommand("SELECT MAX(scansionato_il) FROM files", connection).ExecuteScalar();
|
|
|
|
_dbPath = path;
|
|
_lblDb.Text = $"Database: {path} ({totale:N0} file indicizzati)";
|
|
_lblUltimoAggiornamento.Text = ultimaScansioneRaw is string testoData
|
|
&& DateTime.TryParse(testoData, out var ultimaScansione)
|
|
? $"Ultimo aggiornamento indice: {ultimaScansione.ToLocalTime():dd/MM/yyyy HH:mm}"
|
|
: "Ultimo aggiornamento indice: sconosciuto";
|
|
_lblStatus.Text = "Pronto.";
|
|
SalvaUltimoDbUsato(path);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(this, $"Impossibile aprire il database:\n{ex.Message}", "Errore",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
AggiornaStatoAvanti();
|
|
}
|
|
|
|
/// <summary>Ricorda l'ultimo DB caricato con successo, così al prossimo avvio si
|
|
/// ricarica automaticamente anche se l'eseguibile gira da una cartella diversa.</summary>
|
|
private static string? LeggiUltimoDbUsato()
|
|
{
|
|
try
|
|
{
|
|
return File.Exists(PercorsoImpostazioni) ? File.ReadAllText(PercorsoImpostazioni).Trim() : null;
|
|
}
|
|
catch (IOException)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static void SalvaUltimoDbUsato(string path)
|
|
{
|
|
try
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(PercorsoImpostazioni)!);
|
|
File.WriteAllText(PercorsoImpostazioni, path);
|
|
}
|
|
catch (IOException)
|
|
{
|
|
// ponytail: non critico se non si riesce a salvare, si torna a chiedere "Apri DB..." la prossima volta
|
|
}
|
|
}
|
|
|
|
private async void AggiornaIndice()
|
|
{
|
|
string dbPath = _dbPath ?? Path.Combine(AppContext.BaseDirectory, "cad_index.db");
|
|
|
|
if (!Directory.Exists(RadiceDiscoDefault))
|
|
{
|
|
MessageBox.Show(this, $"Disco non raggiungibile: {RadiceDiscoDefault}", "Errore",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
|
|
_btnAggiorna.Enabled = false;
|
|
_lblStatus.Text = "Aggiornamento indice in corso...";
|
|
|
|
using var cts = new CancellationTokenSource();
|
|
using var dialog = new ProgressForm();
|
|
var progress = new Progress<ScanProgress>(dialog.Aggiorna);
|
|
dialog.Annullato += (_, _) => cts.Cancel();
|
|
|
|
var scanTask = Indexer.ScanAsync(RadiceDiscoDefault, dbPath, progress, cts.Token);
|
|
|
|
// Chiude automaticamente il dialog quando lo scan termina (successo, errore o annullamento)
|
|
_ = scanTask.ContinueWith(_ =>
|
|
{
|
|
if (dialog.Visible)
|
|
{
|
|
dialog.BeginInvoke(dialog.Close);
|
|
}
|
|
}, TaskScheduler.Default);
|
|
|
|
dialog.ShowDialog(this);
|
|
|
|
try
|
|
{
|
|
await scanTask;
|
|
_lblStatus.Text = "Indice aggiornato.";
|
|
CaricaDatabase(dbPath);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
_lblStatus.Text = "Aggiornamento annullato.";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(this, $"Errore durante l'aggiornamento dell'indice:\n{ex.Message}", "Errore",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
_lblStatus.Text = "Aggiornamento fallito.";
|
|
}
|
|
finally
|
|
{
|
|
_btnAggiorna.Enabled = true;
|
|
}
|
|
}
|
|
|
|
private void ApriCartellaFileSelezionato()
|
|
{
|
|
if (_gridRaw.CurrentRow is null)
|
|
{
|
|
return;
|
|
}
|
|
string? percorsi = _gridRaw.CurrentRow.Cells[1].Value as string;
|
|
if (string.IsNullOrEmpty(percorsi))
|
|
{
|
|
return;
|
|
}
|
|
string primoPercorso = percorsi.Split("; ", 2)[0];
|
|
try
|
|
{
|
|
Process.Start("explorer.exe", $"/select,\"{primoPercorso}\"");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(this, $"Impossibile aprire Esplora risorse:\n{ex.Message}", "Errore",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
}
|