prep-step/README.md

# PrepStep - Cevolani

App Windows Forms (.NET 10, progetto `PrepStep`) per indicizzare, cercare e
recuperare i file CAD Pro-ENGINEER/Creo di un disco/share di rete, e per trasformare
l'estrazione "Distinta Base" del gestionale (file `.xls`/`.xml`) in un CSV con il
percorso CAD di ogni componente, fino a raccogliere in `raw/` tutto il necessario per
l'esportazione STEP con **Creo Distributed Batch**: è un pre-processo per quel
passaggio, non lo sostituisce.

## Funzionalità

1. **Indice CAD** — all'avvio carica automaticamente `cad_index.db` dalla
   cartella di installazione (`%LOCALAPPDATA%\Programs\PrepStep`). Se manca, lo si
   crea con **Aggiorna indice**, oppure si apre un altro DB per la sola sessione
   con **Apri DB...**. **Aggiorna indice** scansiona il disco (di default `X:\`,
   tutte le cartelle di primo livello che trova) e indicizza tutti i file. La
   **cartella di lavoro** (dove finiscono il CSV e la cartella `raw/`; gli STEP
   esportati con Creo vanno in `step/`, dentro la stessa cartella) è di default la
   cartella di installazione, modificabile in qualunque momento da **File → Scegli
   cartella di lavoro...** (la scelta viene ricordata). Dal menu **File** si
   ripuliscono anche `raw/`/`step/` e i CSV accumulati.
2. **Importa Distinta Base** — trascina (o scegli da file) l'estrazione
   `.xls`/`.xml` del gestionale (foglio "Distinta Base", colonne
   Componente/Descrizione): viene generato un CSV nella cartella di lavoro, con
   anteprima in griglia. Se il file segue la convenzione di nome
   `DBP_<codice>_<timestamp>` del gestionale, l'assieme generale dell'estrazione
   viene aggiunto come riga in più nel CSV (il foglio elenca solo i componenti
   sotto l'assieme, non l'assieme stesso). Il bottone **Verifica presenza**
   (compare solo dopo un import riuscito) cerca i componenti nel database — è
   questo passo, non il solo import, a sbloccare la fase successiva.
3. **Crea cartella raw** — cerca nell'indice il percorso CAD di ogni
   componente importato (assieme generale incluso) e copia i file trovati
   in una cartella `raw/` dentro la cartella di lavoro.
4. **Trova componenti referenziati** — legge i metadati dei file `.asm` in
   `raw/` per trovare ricorsivamente i sotto-assiemi/parti che li
   compongono, copiandoli a loro volta in `raw/` (passo opzionale se la
   distinta contiene solo parti singole).
5. **Verifica completezza** — mostra i file `.asm` della distinta già in `raw/`,
   trascinabili su Creo Distributed Batch per l'esportazione STEP (passo
   manuale, fuori da quest'app): scrive in `step/`, dentro la cartella di
   lavoro.

Guida utente passo-passo completa in [`docs/guida-utente.md`](docs/guida-utente.md)
(stessa sintesi anche in-app da **Aiuto → Guida**, F1).

## Requisiti

- Windows
- [.NET 10 SDK](https://dotnet.microsoft.com/download) (per build/run da sorgente)
- Accesso alla share di rete con i file CAD (`X:\` di default) per
  l'indicizzazione

## Build

```powershell
cd PrepStep
dotnet build -c Release
```

## Avvio

Da sorgente:

```powershell
cd PrepStep
dotnet run -c Release
```

Oppure l'eseguibile già compilato:

```powershell
cd PrepStep\bin\Release\net10.0-windows
.\PrepStep.exe
```

## Pubblicazione (eseguibile standalone)

Genera un `.exe` self-contained per Windows x64, senza bisogno del runtime
.NET installato sulla macchina di destinazione:

```powershell
cd PrepStep
dotnet publish -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true -o publish
```

L'eseguibile risultante è in `PrepStep\publish\PrepStep.exe` — un unico
file, si copia e si lancia su un'altra macchina Windows senza bisogno di .NET
installato.

## Setup di installazione

Per distribuire l'app agli utenti si genera un setup con
[Inno Setup 6](https://jrsoftware.org/isinfo.php).

Una volta sola, per installare Inno Setup (per l'utente corrente, senza admin):

```powershell
winget install --id JRSoftware.InnoSetup -e --scope user
```

A ogni release, dalla root del repo:

```powershell
# 1. aggiorna <Version> in PrepStep\PrepStep.csproj e la voce in CHANGELOG.md
# 2. chiudi l'app se è aperta (l'exe in uso blocca la build)
dotnet publish PrepStep -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true -o PrepStep\publish
& "$env:LOCALAPPDATA\Programs\Inno Setup 6\ISCC.exe" installer\PrepStep.iss
```

Produce `installer\Output\PrepStep-Setup-<versione>.exe` (versione letta dall'exe, cioè
`<Version>` del csproj): è l'unico file da distribuire. Per provarlo sul proprio PC basta
lanciarlo (`.\installer\Output\PrepStep-Setup-<versione>.exe`). Il setup:

- installa **solo per l'utente corrente**, in `%LOCALAPPDATA%\Programs\PrepStep`, senza
  chiedere i diritti di amministratore;
- crea nel menu Start i collegamenti al programma e al disinstallatore (quello sul desktop
  è facoltativo);
- compare in "Impostazioni → App installate", da cui si disinstalla.

Se l'app è già installata, il setup chiede prima cosa fare: **Sì** aggiorna/reinstalla (DB e
impostazioni restano), **No** disinstalla, **Annulla** esce. Installazione silenziosa (aggiorna
senza chiedere) — es. per distribuirla da script:
`PrepStep-Setup-<versione>.exe /VERYSILENT /SUPPRESSMSGBOXES`.

## Struttura del progetto

Il codice dell'app è tutto in `PrepStep/` (GUI e indicizzazione integrate); accanto ci sono
il progetto di test `PrepStep.Tests/`, gli script standalone `scripts/` e lo script del setup
`installer/`. Mappa file-per-file completa in [`docs/architettura.md`](docs/architettura.md).

- `Program.cs` — entry point.
- `Form1.cs` — finestra principale, wizard a 5 fasi e menu; UI costruita interamente in
  codice (`Form1.Designer.cs` è solo lo scheletro del template).
- `Indexer.cs` — scansione del disco e scrittura/aggiornamento del DB SQLite.
- `DistintaBaseImporter.cs` — parsing del file Distinta Base (SpreadsheetML
  XML o Excel binario/OpenXML tramite ExcelDataReader) e generazione CSV.
- `AsmRecordReader.cs` — lettura esatta dei record dei `.asm` (fase 4).
- `AssemblyComponentScanner.cs` — euristica testuale di fallback per i `.asm` fuori formato.
- `ProgressForm.cs`, `ProgressoComponentiForm.cs` — avanzamento di scansione e fase 4.
- `PrtMancantiForm.cs` — esito di "Trova componenti referenziati".
- `GuidaForm.cs` — guida in-app (Aiuto → Guida, F1).
- `UiStile.cs` — stile condiviso di bottoni, card e barre.

Il database generato (`cad_index.db`), i file Excel/CSV della distinta
trascinati nella root e le cartelle `raw/`/`step/` sono rigenerabili e non
sono tracciati in git (vedi `.gitignore`).

## Test

`PrepStep.Tests/` (xUnit) contiene unit test (lettore esatto e euristica di
estrazione dei componenti dai `.asm`, parsing del nome file Pro-E, import della
distinta) e integration test (scansione su disco, schema/vista SQL reale con focus
sui bug di case-sensitivity/duplicati già risolti, pipeline end-to-end). Da
eseguire:

```powershell
cd PrepStep.Tests
dotnet test
```

## Licenza

Software proprietario, © 2026 Davide Grilli, tutti i diritti riservati: vedi
[`LICENSE`](LICENSE).