From a5f8943c72636aef1632f30f286e760b10648a7f Mon Sep 17 00:00:00 2001 From: Alessio Dal Santo Date: Sun, 25 Jan 2026 12:45:32 +0100 Subject: [PATCH] [Feature] Implementata schedulazione completa per file CSV/Excel MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Aggiunta validazione percorsi file prima del salvataggio profili - Implementati metodi di lettura file CSV e Excel per schedulazioni - Supporto doppia modalità: caricamento browser (preview) e percorso manuale (schedulazione) - Gestione completa deletion sync anche per file CSV/Excel - Rilevamento automatico separatori CSV (virgola, punto e virgola, tab, pipe) - Supporto formati Excel legacy (.xls) e moderni (.xlsx) - Abilitati profili file nella UI di schedulazione - Logging dettagliato per troubleshooting - Documentazione completa in CSV_SCHEDULING_IMPLEMENTATION.md - Aggiornati README.md e copilot-instructions.md con nuove feature - Rimosso testo 'TEST' dalla pagina di login --- .github/copilot-instructions.md | 44 +- CSV_SCHEDULING_IMPLEMENTATION.md | 410 ++++++++++++++++++ .../Services/ProfileScheduleService.cs | 3 + .../BackgroundServices/ScheduledJobService.cs | 3 +- Data_Coupler/Pages/DataCoupler.razor | 49 ++- Data_Coupler/Pages/DataCoupler.razor.cs | 250 ++++++++++- Data_Coupler/Pages/Login.razor | 2 +- Data_Coupler/Pages/Scheduling.razor | 7 +- Data_Coupler/Pages/Scheduling.razor.cs | 6 +- Data_Coupler/Services/DataTransferService.cs | 19 +- .../ScheduledProfileExecutionService.cs | 249 ++++++++++- README.md | 38 ++ 12 files changed, 1040 insertions(+), 40 deletions(-) create mode 100644 CSV_SCHEDULING_IMPLEMENTATION.md diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md index 52b98a0..07b08b1 100644 --- a/.github/copilot-instructions.md +++ b/.github/copilot-instructions.md @@ -146,6 +146,8 @@ - **Pausa/Riprendi**: Controllo dinamico schedulazioni - **Override Database**: Possibilità di sovrascrivere sorgente/destinazione - **Deletion Sync Configurabile**: Opzione per abilitare sincronizzazione eliminazioni (disabilitata di default) +- **Supporto File CSV/Excel**: Schedulazione completa per profili con file come sorgente +- **Validazione File**: Verifica esistenza e leggibilità file prima dell'esecuzione #### File Chiave: - `CredentialManager/Models/ProfileSchedule.cs` @@ -249,7 +251,38 @@ - **Dark/Light Mode**: Temi personalizzabili - **Mobile Responsive**: Ottimizzato per dispositivi mobili -### 10. Health Checks e Monitoraggio +### 10. Gestione File per Schedulazioni + +#### Caratteristiche: +- **Doppia Modalità Caricamento**: Browser (preview) + percorso manuale (schedulazione) +- **Validazione Percorsi**: Verifica esistenza e permessi lettura file +- **Supporto CSV**: Rilevamento automatico separatori, gestione quote e escape +- **Supporto Excel**: Formati .xlsx e .xls, lettura automatica primo foglio +- **Schedulazione Completa**: File CSV/Excel utilizzabili in schedulazioni automatiche +- **Logging Dettagliato**: Tracciamento lettura file e parsing + +#### Modalità Operative: + +**Caricamento Browser (Preview)**: +- Carica file tramite InputFile component +- Processato in memoria per anteprima +- Non salvato sul server +- Utilizzato solo per configurazione mapping + +**Percorso Manuale (Schedulazione)**: +- Campo "Percorso File sul Server" obbligatorio +- Validazione esistenza e leggibilità +- Percorso salvato in `SourceFilePath` del profilo +- Utilizzato per esecuzioni schedulate +- Esempi: `C:\Data\products.csv`, `/data/customers.xlsx` + +#### File Chiave: +- `Data_Coupler/Pages/DataCoupler.razor` (UI caricamento file) +- `Data_Coupler/Pages/DataCoupler.razor.cs` (validazione file) +- `Data_Coupler/Services/ScheduledProfileExecutionService.cs` (lettura file schedulazioni) +- `CSV_SCHEDULING_IMPLEMENTATION.md` (documentazione completa) + +### 11. Health Checks e Monitoraggio #### Caratteristiche: - **Health Checks**: Endpoint per monitoraggio stato applicazione @@ -408,6 +441,7 @@ - **SALESFORCE_BATCH_EXTRACTION_IMPROVEMENTS.md**: Batch extraction Salesforce - **PRE_DISCOVERY_SYSTEM.md**: Sistema pre-discovery associazioni - **DELETION_SYNC_IMPLEMENTATION.md**: Sincronizzazione eliminazioni +- **CSV_SCHEDULING_IMPLEMENTATION.md**: Schedulazione file CSV/Excel (NUOVO) - **DOCKER_DEPLOYMENT.md**: Guida deployment Docker - **WINDOWS_SERVICE_DEPLOYMENT.md**: Deploy come Windows Service - **.gitea/workflows/README.md**: Configurazione Gitea Actions @@ -443,7 +477,7 @@ ## 🚀 Roadmap Futura ### Feature in Pianificazione: -- [ ] Supporto file Excel/CSV avanzato +- [x] Supporto file Excel/CSV avanzato (Completato - Gennaio 2026) - [ ] Sistema di notifiche (email, webhook) - [ ] Dashboard analytics avanzato - [ ] Multi-tenant support @@ -451,6 +485,8 @@ - [ ] Plugin system per connectors custom - [ ] Machine learning per mapping suggeriti - [ ] Real-time data sync +- [ ] Lettura fogli Excel multipli +- [ ] Supporto file remoti (HTTP, FTP, Azure Blob) ### Miglioramenti Tecnici: - [ ] Migrazione a .NET 10 (quando disponibile) @@ -461,8 +497,8 @@ --- -**Versione**: 2.0 -**Ultimo Aggiornamento**: 22 Gennaio 2026 +**Versione**: 2.1 +**Ultimo Aggiornamento**: 25 Gennaio 2026 **Framework**: .NET 9.0 **Sviluppatore**: Alessio Dalsanto **Repository**: https://github.com/AlessioDalsi/Data-Coupler diff --git a/CSV_SCHEDULING_IMPLEMENTATION.md b/CSV_SCHEDULING_IMPLEMENTATION.md new file mode 100644 index 0000000..07b95db --- /dev/null +++ b/CSV_SCHEDULING_IMPLEMENTATION.md @@ -0,0 +1,410 @@ +# Implementazione Schedulazione File CSV/Excel + +## Data +24 Gennaio 2026 + +## Panoramica +Implementata la funzionalità completa di schedulazione per profili che utilizzano file CSV o Excel come sorgente dati. Precedentemente questa funzionalità era disattivata per motivi di sicurezza, ora è completamente funzionale con validazioni appropriate. + +## Modifiche Implementate + +### 1. Validazione File CSV nel Salvataggio Profilo +**File**: `Data_Coupler/Pages/DataCoupler.razor.cs` + +**Modifica**: Aggiunta validazione nel metodo `OnProfileSaved` per verificare che: +- Il file CSV/Excel specificato esista nel filesystem +- Il file sia leggibile dall'applicazione + +**Implementazione**: +```csharp +// Validazione specifica per file CSV +if (profile.SourceType == "file" && !string.IsNullOrEmpty(profile.SourceFilePath)) +{ + // Verifica esistenza + if (!System.IO.File.Exists(profile.SourceFilePath)) + { + await JSRuntime.InvokeVoidAsync("alert", + "Errore: Il file non esiste o non è accessibile."); + return; + } + + // Verifica leggibilità + try + { + using var fs = System.IO.File.OpenRead(profile.SourceFilePath); + fs.Close(); + } + catch (Exception fileEx) + { + await JSRuntime.InvokeVoidAsync("alert", + $"Errore: Il file non può essere letto. Dettagli: {fileEx.Message}"); + return; + } +} +``` + +**Benefici**: +- Previene errori durante l'esecuzione schedulata +- Fornisce feedback immediato all'utente in fase di configurazione +- Verifica i permessi di lettura del file + +--- + +### 2. Implementazione Lettura File per Schedulazioni +**File**: `Data_Coupler/Services/ScheduledProfileExecutionService.cs` + +**Modifica**: Implementati i seguenti metodi per la lettura di file CSV e Excel: + +#### Metodi Implementati: + +1. **`GetAllRecordsFromFileAsync`** - Metodo principale + - Determina il tipo di file (CSV, XLSX, XLS) + - Verifica esistenza del file + - Delega alla funzione appropriata + +2. **`ReadCsvFileAsync`** - Lettura file CSV + - Rilevamento automatico del separatore (`,`, `;`, `\t`, `|`) + - Parsing corretto con gestione virgolette + - Supporto per file di grandi dimensioni + +3. **`ReadExcelFileAsync`** - Lettura file Excel + - Supporto per formati `.xlsx` e `.xls` + - Utilizzo di `ExcelDataReader` library + - Registrazione encoding provider (`System.Text.CodePagesEncodingProvider`) + - Lettura del primo foglio Excel + +4. **Helper Methods**: + - `DetectCsvSeparator`: Rilevamento automatico separatore CSV + - `ParseCsvLine`: Parsing linea CSV con gestione quote e escape + +**Esempio di utilizzo**: +```csharp +private async Task>> GetAllRecordsFromSourceAsync( + DataCouplerProfile profile, IDatabaseManager? databaseManager) +{ + if (profile.SourceType.ToLower() == "file") + { + return await GetAllRecordsFromFileAsync(profile); + } + // ... altri tipi +} +``` + +**Caratteristiche**: +- Supporto completo per CSV con separatori multipli +- Gestione corretta di campi con virgolette e caratteri speciali +- Parsing robusto con logging dettagliato +- Compatibilità con file Excel legacy (.xls) e moderni (.xlsx) + +--- + +### 3. Abilitazione Profili File nella Schedulazione +**File**: `Data_Coupler/Pages/Scheduling.razor` + +**Modifica**: Rimosso il filtro `Where(p => p.SourceType != "file")` che escludeva i profili file dalla lista di schedulazione. + +**Prima**: +```csharp +@foreach (var profile in availableProfiles.Where(p => p.SourceType != "file")) +{ + +} +``` + +**Dopo**: +```csharp +@foreach (var profile in availableProfiles) +{ + +} +``` + +**Miglioramenti UI**: +- Etichetta `(File)` per identificare profili con file +- Messaggio informativo aggiornato: + > ℹ️ I profili con file CSV/Excel come sorgente sono ora supportati per le schedulazioni. + > Il file specificato nel profilo verrà letto ad ogni esecuzione. + +--- + +### 4. Gestione Cancellazioni per File CSV +**Implementazione**: La gestione delle cancellazioni opzionali funziona automaticamente anche per i profili file grazie all'architettura esistente. + +**Flusso**: +1. I record vengono letti dal file CSV/Excel +2. Vengono trasformati in `Dictionary` come i record database +3. Il sistema di associazioni (`KeyAssociationService`) traccia i record +4. Se abilitato, il `DeletionSyncService` sincronizza le eliminazioni + +**Compatibilità**: +- ✅ Supporto completo per `EnableDeletionSync` flag +- ✅ Tracking chiavi sorgente (`SourceKeyField`) +- ✅ Sistema di associazioni record +- ✅ Pre-discovery di record esistenti + +--- + +## Gestione File per Schedulazioni + +### Due Modalità di Caricamento + +#### 1. **Caricamento Browser** (per Preview) +- **Scopo**: Configurare mapping e vedere anteprima dati +- **Funzionamento**: + - File caricato tramite browser (InputFile component) + - Processato in memoria + - **Non salvato sul server** +- **Uso**: Solo per configurazione iniziale del profilo + +#### 2. **Percorso Manuale** (per Schedulazione) ⭐ +- **Scopo**: Specificare posizione file per schedulazioni +- **Funzionamento**: + - Utente inserisce percorso completo (es: `C:\Data\products.csv`) + - Sistema valida esistenza e leggibilità + - Percorso salvato nel profilo +- **Uso**: **Obbligatorio** per profili che devono essere schedulati + +### Esempi di Percorsi Validi + +**Windows**: +``` +C:\Data\products.csv +\\server\share\customers.xlsx +D:\ImportFiles\orders.csv +``` + +**Linux/Container**: +``` +/data/products.csv +/mnt/share/customers.xlsx +/app/import/orders.csv +``` + +### Workflow Completo + +1. **Configurazione Iniziale**: + - Carica file da browser per preview + - Configura mapping campi vedendo i dati reali + - **Importante**: Questo file è solo temporaneo + +2. **Preparazione Schedulazione**: + - Posiziona il file nella location definitiva sul server + - Inserisci il percorso completo nel campo "Percorso File sul Server" + - Clicca "Valida e Carica" per verificare + - Salva il profilo + +3. **Esecuzione Schedulata**: + - Il sistema legge il file dal percorso salvato + - Il file deve esistere e essere accessibile + - Aggiornamenti al file vengono letti automaticamente + +### Considerazioni Importanti + +**Sicurezza**: +- Il file deve essere accessibile dal processo dell'applicazione +- Verificare permessi di lettura sulla directory +- Per ambienti multi-utente, considerare ACL appropriati + +**Percorsi Relativi vs Assoluti**: +- **Consigliato**: Percorsi assoluti per chiarezza +- Se si usano percorsi relativi, sono relativi alla working directory dell'applicazione + +**Aggiornamento File**: +- Il sistema legge sempre il file corrente dal percorso +- Per aggiornare i dati, basta sovrascrivere il file nella stessa posizione +- Non serve modificare il profilo se il percorso rimane invariato + +**Deployment Container**: +- Montare volumi per directory contenenti i file +- Esempio docker-compose: + ```yaml + volumes: + - /host/data:/data # Monta directory host in /data nel container + ``` +- Nel profilo usare: `/data/products.csv` + +**Best Practices**: +- ✅ Usare una directory dedicata per file di import (es: `/data/imports/`) +- ✅ Nominare i file in modo descrittivo +- ✅ Implementare rotazione/backup dei file +- ✅ Monitorare spazio disco +- ❌ Non usare directory temporanee che vengono pulite +- ❌ Non usare percorsi di rete senza verifica connessione + +--- + +## Funzionamento Completo + +### Creazione Profilo con File CSV +1. L'utente seleziona "File" come tipo sorgente +2. **Opzione A - Caricamento Browser (per preview)**: + - Carica un file CSV/Excel tramite browser + - Il file viene processato in memoria per preview + - Permette di configurare il mapping vedendo i dati reali + - **Non viene salvato sul server** - solo per anteprima + +3. **Opzione B - Percorso Manuale (richiesto per schedulazione)**: + - Inserisce il percorso completo del file sul server (es: `C:\Data\products.csv`) + - Clicca "Valida e Carica" per: + - Verificare che il file esista + - Verificare che sia leggibile + - Caricare preview per configurare mapping + - Il percorso viene salvato nel profilo + +4. L'utente configura il mapping campi +5. **Salvataggio**: Il sistema valida che il file sia accessibile e leggibile +6. Il **percorso completo originale** del file viene salvato in `SourceFilePath` + +**Nota Importante**: Per le schedulazioni è **necessario** specificare il percorso file manualmente. Il file deve essere accessibile dal server nella posizione specificata. + +### Schedulazione Profilo File +1. L'utente crea una nuova schedulazione +2. Seleziona un profilo con `SourceType = "file"` +3. Configura la frequenza (giornaliera, settimanale, intervallo, ecc.) +4. Abilita opzionalmente `EnableDeletionSync` per sincronizzare eliminazioni + +### Esecuzione Schedulata +1. Il background service avvia l'esecuzione alla schedulazione prevista +2. `ScheduledProfileExecutionService.ExecuteProfileAsync` viene chiamato +3. Il servizio legge il file dal percorso salvato usando `GetAllRecordsFromFileAsync` +4. I record vengono trasformati e inviati alla destinazione REST +5. Il sistema di associazioni traccia i record per evitare duplicati +6. Se configurato, vengono sincronizzate le eliminazioni + +--- + +## Sicurezza e Validazioni + +### Validazioni Implementate: +- ✅ Verifica esistenza file prima del salvataggio profilo +- ✅ Verifica permessi di lettura file +- ✅ Gestione eccezioni durante la lettura file +- ✅ Logging dettagliato per troubleshooting +- ✅ Validazione formato file (CSV, XLSX, XLS) + +### Considerazioni di Sicurezza: +- Il file deve essere accessibile dal processo dell'applicazione +- Percorsi assoluti sono salvati nel database +- Per ambienti containerizzati, montare volumi con i file +- Permessi filesystem devono consentire lettura + +--- + +## Formati File Supportati + +### CSV +- **Separatori**: `,` (virgola), `;` (punto e virgola), `\t` (tab), `|` (pipe) +- **Rilevamento automatico**: Sì +- **Gestione quote**: Supporto completo per campi tra virgolette +- **Escape caratteri**: Supporto per `""` (double quote escape) +- **Dimensione massima**: 50 MB (configurabile) + +### Excel +- **Formati**: `.xlsx` (Office Open XML), `.xls` (Binary Format) +- **Fogli multipli**: Legge il primo foglio per default +- **Header**: Prima riga utilizzata come intestazione +- **Dimensione massima**: 50 MB (configurabile) + +--- + +## Esempi di Utilizzo + +### Esempio 1: Schedulazione Giornaliera CSV +``` +Profilo: "Import Prodotti da CSV" +- Sorgente: File CSV (products.csv) +- Destinazione: REST API (Salesforce) +- SourceKeyField: "ProductCode" +- UseRecordAssociations: true + +Schedulazione: "Import Prodotti Quotidiano" +- Tipo: Daily (Giornaliera) +- Ora: 08:00 +- EnableDeletionSync: false +``` + +**Comportamento**: Ogni giorno alle 08:00, il sistema legge `products.csv`, trasforma i dati secondo il mapping configurato, e li invia a Salesforce. I record esistenti vengono aggiornati, i nuovi creati. + +### Esempio 2: Sincronizzazione con Eliminazioni +``` +Profilo: "Sincronizza Clienti Excel" +- Sorgente: File Excel (customers.xlsx) +- Destinazione: REST API (SAP Business One) +- SourceKeyField: "CustomerID" +- UseRecordAssociations: true + +Schedulazione: "Sync Clienti Settimanale" +- Tipo: Weekly (Settimanale) +- Giorno: Lunedì +- Ora: 06:00 +- EnableDeletionSync: true +``` + +**Comportamento**: Ogni lunedì alle 06:00, il sistema: +1. Legge `customers.xlsx` +2. Sincronizza i clienti con SAP Business One +3. Identifica clienti eliminati dal file +4. Elimina i corrispondenti record in SAP B1 + +--- + +## Testing e Validazione + +### Test Consigliati: +1. **Test file CSV con separatori diversi** + - Comma-separated + - Semicolon-separated + - Tab-separated + +2. **Test file Excel** + - Formato .xlsx moderno + - Formato .xls legacy + - Fogli con molte colonne/righe + +3. **Test errori** + - File non esistente + - File senza permessi di lettura + - File corrotto + - File troppo grande + +4. **Test schedulazione** + - Esecuzione immediata manuale + - Esecuzione automatica schedulata + - Verifica storico esecuzioni + - Test con `EnableDeletionSync` attivo + +--- + +## Limitazioni Note + +1. **Fogli Excel**: Attualmente viene letto solo il primo foglio del file Excel +2. **Dimensione file**: Limite di 50 MB per sicurezza (configurabile in codice) +3. **Percorsi assoluti**: I file devono essere accessibili tramite percorso assoluto +4. **Encoding**: Supporto per encoding standard (UTF-8, Windows-1252) + +--- + +## Prossimi Sviluppi Potenziali + +- [ ] Supporto per lettura di fogli Excel multipli +- [ ] Configurazione dinamica del foglio Excel da leggere +- [ ] Supporto per file remoti (HTTP, FTP, Azure Blob) +- [ ] Cache intelligente per file grandi non modificati +- [ ] Validazione schema file prima dell'esecuzione +- [ ] Notifiche in caso di file non trovato durante schedulazione + +--- + +## Conclusioni + +L'implementazione della schedulazione per file CSV/Excel è ora completa e robusta. La funzionalità include: + +✅ Validazione completa del file in fase di configurazione +✅ Lettura affidabile di CSV con separatori multipli +✅ Supporto per file Excel moderni e legacy +✅ Integrazione completa con sistema di associazioni +✅ Supporto per sincronizzazione eliminazioni opzionale +✅ Logging dettagliato per troubleshooting +✅ Error handling robusto + +Gli utenti possono ora schedulare trasferimenti dati da file CSV/Excel esattamente come farebbero con sorgenti database, con le stesse funzionalità avanzate di tracking record e sincronizzazione. diff --git a/CredentialManager/Services/ProfileScheduleService.cs b/CredentialManager/Services/ProfileScheduleService.cs index 9aaa6b3..af7aaee 100644 --- a/CredentialManager/Services/ProfileScheduleService.cs +++ b/CredentialManager/Services/ProfileScheduleService.cs @@ -93,6 +93,9 @@ public class ProfileScheduleService : IProfileScheduleService existingSchedule.IntervalValue = schedule.IntervalValue; existingSchedule.IntervalUnit = schedule.IntervalUnit; existingSchedule.IsActive = schedule.IsActive; + existingSchedule.EnableDeletionSync = schedule.EnableDeletionSync; + existingSchedule.SourceDatabaseOverride = schedule.SourceDatabaseOverride; + existingSchedule.DestinationDatabaseOverride = schedule.DestinationDatabaseOverride; existingSchedule.UpdatedAt = DateTime.UtcNow; // Ricalcola la prossima esecuzione diff --git a/Data_Coupler/BackgroundServices/ScheduledJobService.cs b/Data_Coupler/BackgroundServices/ScheduledJobService.cs index c87eb7a..0068600 100644 --- a/Data_Coupler/BackgroundServices/ScheduledJobService.cs +++ b/Data_Coupler/BackgroundServices/ScheduledJobService.cs @@ -232,7 +232,8 @@ public class ScheduledJobService : BackgroundService var result = await dataTransferService.ExecuteProfileAsync( schedule.Profile, schedule.SourceDatabaseOverride, - schedule.DestinationDatabaseOverride); + schedule.DestinationDatabaseOverride, + schedule.EnableDeletionSync); // Aggiorna lo storico con il risultato executionHistory.EndTime = DateTime.Now; diff --git a/Data_Coupler/Pages/DataCoupler.razor b/Data_Coupler/Pages/DataCoupler.razor index 2f78d7d..1d4633d 100644 --- a/Data_Coupler/Pages/DataCoupler.razor +++ b/Data_Coupler/Pages/DataCoupler.razor @@ -294,13 +294,56 @@ @if (selectedSourceType == "file") { + + +
- + @if (!string.IsNullOrEmpty(selectedFileName)) { - File selezionato: @selectedFileName + File caricato: @selectedFileName } + + Carica un file per vedere preview e configurare il mapping. Questo file non verrà salvato. + +
+ + +
+ +
+ + +
+ @if (!string.IsNullOrEmpty(uploadedFilePath) && uploadedFilePath == manualFilePath) + { + + File validato e caricato con successo! + + } + + Inserisci il percorso completo del file. Il file deve essere accessibile dal server. +
@if (isProcessingFile) @@ -1016,7 +1059,7 @@ SourceSchema="@GetCurrentDatabaseSchema()" SourceTable="@(useCustomQuery ? "custom_query" : selectedTable)" SourceCustomQuery="@(useCustomQuery ? customQuery : null)" - SourceFilePath="@selectedFileName" + SourceFilePath="@uploadedFilePath" DestinationType="rest" DestinationCredentialId="@(GetCurrentDestinationCredentialIdAsync().Result)" DestinationCredentialName="@selectedRestCredential" diff --git a/Data_Coupler/Pages/DataCoupler.razor.cs b/Data_Coupler/Pages/DataCoupler.razor.cs index ff532e7..6ba5493 100644 --- a/Data_Coupler/Pages/DataCoupler.razor.cs +++ b/Data_Coupler/Pages/DataCoupler.razor.cs @@ -36,6 +36,8 @@ public partial class DataCoupler : ComponentBase // File handling private string selectedFileName = ""; + private string manualFilePath = ""; // Percorso inserito manualmente dall'utente + private string uploadedFilePath = ""; // Percorso completo del file validato private bool isProcessingFile = false; private string fileErrorMessage = ""; private Dictionary> fileSheets = new(); // SheetName -> Columns @@ -250,8 +252,10 @@ public partial class DataCoupler : ComponentBase // Per i file, non possiamo ricreare il file caricato, ma possiamo impostare le informazioni if (!string.IsNullOrEmpty(profile.SourceFilePath)) { + uploadedFilePath = profile.SourceFilePath; selectedFileName = Path.GetFileName(profile.SourceFilePath); - Logger.LogInformation("Informazioni file impostate: {FileName}", selectedFileName); + Logger.LogInformation("Informazioni file impostate - Nome: {FileName}, Percorso: {FilePath}", + selectedFileName, uploadedFilePath); } } } @@ -401,6 +405,37 @@ public partial class DataCoupler : ComponentBase var profileService = new DataCouplerProfileService(null!); // Usa il service di conversione var profile = profileService.FromDto(profileDto, "System"); // TODO: Usa utente corrente + // Validazione specifica per file CSV + if (profile.SourceType == "file" && !string.IsNullOrEmpty(profile.SourceFilePath)) + { + Logger.LogInformation("Validazione file CSV: {FilePath}", profile.SourceFilePath); + + // Verifica che il file esista + if (!System.IO.File.Exists(profile.SourceFilePath)) + { + await JSRuntime.InvokeVoidAsync("alert", + $"Errore: Il file '{profile.SourceFilePath}' non esiste o non è accessibile. " + + "Verifica il percorso del file prima di salvare il profilo."); + return; + } + + // Verifica che il file sia leggibile + try + { + using var fs = new System.IO.FileStream(profile.SourceFilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite); + fs.Close(); + Logger.LogInformation("File CSV validato con successo: {FilePath}", profile.SourceFilePath); + } + catch (Exception fileEx) + { + Logger.LogError(fileEx, "Errore nella lettura del file CSV: {FilePath}", profile.SourceFilePath); + await JSRuntime.InvokeVoidAsync("alert", + $"Errore: Il file '{profile.SourceFilePath}' non può essere letto. " + + $"Dettagli: {fileEx.Message}"); + return; + } + } + // Controlla se esiste già un profilo con lo stesso nome (inclusi quelli inattivi) Logger.LogInformation("Controllo esistenza profilo con nome: {ProfileName}", profileDto.Name); var existingProfile = await ProfileService.GetProfileByNameIncludingInactiveAsync(profileDto.Name); @@ -685,6 +720,8 @@ public partial class DataCoupler : ComponentBase // Reset file state selectedFileName = ""; + manualFilePath = ""; + uploadedFilePath = ""; isProcessingFile = false; fileErrorMessage = ""; fileSheets.Clear(); @@ -698,6 +735,213 @@ public partial class DataCoupler : ComponentBase ClearAllMappings(); } + /// + /// Valida e carica un file dal percorso specificato manualmente + /// + private async Task ValidateAndLoadFileFromPath() + { + try + { + isProcessingFile = true; + fileErrorMessage = ""; + fileSheets.Clear(); + fileData.Clear(); + selectedSheet = ""; + uploadedFilePath = ""; + + if (string.IsNullOrWhiteSpace(manualFilePath)) + { + fileErrorMessage = "Inserire il percorso del file"; + return; + } + + // Valida che il file esista + if (!System.IO.File.Exists(manualFilePath)) + { + fileErrorMessage = $"Il file '{manualFilePath}' non esiste o non è accessibile"; + Logger.LogWarning("File non trovato: {FilePath}", manualFilePath); + return; + } + + // Valida estensione + var extension = Path.GetExtension(manualFilePath).ToLowerInvariant(); + if (extension != ".xlsx" && extension != ".xls" && extension != ".csv") + { + fileErrorMessage = "Formato file non supportato. Utilizzare Excel (.xlsx, .xls) o CSV (.csv)"; + return; + } + + // Verifica che il file sia leggibile + try + { + using var testStream = new System.IO.FileStream(manualFilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite); + testStream.Close(); + } + catch (Exception readEx) + { + fileErrorMessage = $"Il file non può essere letto: {readEx.Message}"; + Logger.LogError(readEx, "Errore nella lettura del file: {FilePath}", manualFilePath); + return; + } + + Logger.LogInformation("Validazione file completata: {FilePath}", manualFilePath); + + // Carica il file dal percorso per preview + selectedFileName = Path.GetFileName(manualFilePath); + + if (extension == ".csv") + { + await ProcessCsvFileFromPath(manualFilePath); + } + else + { + await ProcessExcelFileFromPath(manualFilePath); + } + + // Se tutto è andato bene, salva il percorso validato + uploadedFilePath = manualFilePath; + Logger.LogInformation("File caricato con successo dal percorso: {FilePath}", uploadedFilePath); + } + catch (Exception ex) + { + Logger.LogError(ex, "Errore nella validazione/caricamento del file dal percorso: {FilePath}", manualFilePath); + fileErrorMessage = $"Errore: {ex.Message}"; + uploadedFilePath = ""; + } + finally + { + isProcessingFile = false; + StateHasChanged(); + } + } + + /// + /// Processa un file CSV dal percorso specificato + /// + private async Task ProcessCsvFileFromPath(string filePath) + { + using var stream = new System.IO.FileStream(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite); + using var reader = new StreamReader(stream); + + var firstLine = await reader.ReadLineAsync(); + if (string.IsNullOrEmpty(firstLine)) + { + fileErrorMessage = "Il file CSV è vuoto"; + return; + } + + var separator = DetectCsvSeparator(firstLine); + var headers = ParseCsvLine(firstLine, separator); + + var sheetName = Path.GetFileNameWithoutExtension(filePath); + fileSheets[sheetName] = headers; + + var dataRows = new List>(); + string? line; + while ((line = await reader.ReadLineAsync()) != null) + { + if (string.IsNullOrWhiteSpace(line)) continue; + + var values = ParseCsvLine(line, separator); + var row = new Dictionary(); + for (int i = 0; i < headers.Count; i++) + { + var value = i < values.Count ? values[i] : ""; + row[headers[i]] = string.IsNullOrEmpty(value) ? "" : value; + } + dataRows.Add(row); + } + + fileData[sheetName] = dataRows; + selectedSheet = sheetName; + + Logger.LogInformation("File CSV processato: {FilePath}, Headers: {HeaderCount}, Rows: {RowCount}", + filePath, headers.Count, dataRows.Count); + } + + /// + /// Processa un file Excel dal percorso specificato + /// + private async Task ProcessExcelFileFromPath(string filePath) + { + try + { + System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance); + + using var stream = new System.IO.FileStream(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite); + var extension = Path.GetExtension(filePath).ToLowerInvariant(); + + IExcelDataReader reader; + if (extension == ".xlsx") + { + reader = ExcelReaderFactory.CreateOpenXmlReader(stream); + } + else if (extension == ".xls") + { + reader = ExcelReaderFactory.CreateBinaryReader(stream); + } + else + { + fileErrorMessage = "Formato Excel non supportato"; + return; + } + + using (reader) + { + var configuration = new ExcelDataSetConfiguration() + { + ConfigureDataTable = (_) => new ExcelDataTableConfiguration() + { + UseHeaderRow = true + } + }; + + var dataSet = reader.AsDataSet(configuration); + + foreach (DataTable table in dataSet.Tables) + { + var sheetName = table.TableName; + var headers = new List(); + var dataRows = new List>(); + + foreach (DataColumn column in table.Columns) + { + headers.Add(column.ColumnName); + } + + foreach (DataRow dataRow in table.Rows) + { + var row = new Dictionary(); + foreach (var header in headers) + { + var value = dataRow[header]; + row[header] = value == DBNull.Value ? "" : value?.ToString() ?? ""; + } + dataRows.Add(row); + } + + fileSheets[sheetName] = headers; + fileData[sheetName] = dataRows; + } + + if (fileSheets.Any()) + { + selectedSheet = fileSheets.First().Key; + } + + Logger.LogInformation("File Excel processato: {FilePath}, Sheets: {SheetCount}", + filePath, dataSet.Tables.Count); + } + + await Task.CompletedTask; + } + catch (Exception ex) + { + Logger.LogError(ex, "Errore nel processing del file Excel: {FilePath}", filePath); + throw; + } + } + private async Task OnFileSelected(InputFileChangeEventArgs e) { try @@ -719,7 +963,9 @@ public partial class DataCoupler : ComponentBase return; } - // Process file based on type + Logger.LogInformation("File caricato per preview: {FileName}", file.Name); + + // Process file based on type (solo per preview, non salva sul server) if (extension == ".csv") { await ProcessCsvFile(file); diff --git a/Data_Coupler/Pages/Login.razor b/Data_Coupler/Pages/Login.razor index 68dc1c4..9efe644 100644 --- a/Data_Coupler/Pages/Login.razor +++ b/Data_Coupler/Pages/Login.razor @@ -7,7 +7,7 @@