fix: Corretto caricamento version.json con percorso robusto e copia automatica in output

- Rimosso tag 'latest' da branch development, staging e dev
- Tag 'latest' ora riservato esclusivamente al branch main
- Altri branch mantengono tag specifici (development-latest, staging-latest, dev-latest)
- Modificati workflow GitHub Actions e Gitea Actions
- Semplifica la gestione delle versioni in produzione vs sviluppo

.gitea/workflows/docker-build.yml

@@ -31,6 +31,47 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '9.0.x'
+
+      - name: Generate version.json with MinVer
+        run: |
+          # Fetch all tags for MinVer to work correctly
+          git fetch --tags --force
+          
+          # Build project to trigger MinVer (calcola versione automaticamente)
+          cd Data_Coupler
+          dotnet build -c Release /p:ContinuousIntegrationBuild=true
+          
+          # Extract version calculated by MinVer from build output
+          VERSION=$(dotnet msbuild -getProperty:Version -p:ContinuousIntegrationBuild=true 2>/dev/null | tail -1)
+          
+          # Fallback if MinVer fails (no tags)
+          if [ -z "$VERSION" ] || [ "$VERSION" = "0.0.0-alpha.0" ]; then
+            echo "Warning: No git tags found. MinVer returned default. Using fallback."
+            VERSION="2.1.0-alpha.0.$(git rev-list --count HEAD)"
+          fi
+          
+          echo "MinVer calculated version: $VERSION"
+          
+          # Create version.json
+          cat > wwwroot/version.json <<EOF
+          {
+            "version": "${VERSION}",
+            "commitSha": "${GITHUB_SHA:0:7}",
+            "branch": "${GITHUB_REF_NAME}",
+            "buildDate": "$(date -u +"%Y-%m-%d %H:%M:%S UTC")",
+            "buildEnvironment": "Gitea Actions"
+          }
+          EOF
+          
+          echo "Generated version.json:"
+          cat wwwroot/version.json
+          cd ..
+        shell: bash
+
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
 
@@ -64,12 +105,18 @@ jobs:
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
           tags: |
-            # Tag based on branch
+            # Tag based on branch - latest only for main
             type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }}
-            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/development' }}
+            type=raw,value=latest-linux,enable=${{ github.ref == 'refs/heads/main' }}
+            # Development branch - no latest tag
             type=raw,value=development-latest,enable=${{ github.ref == 'refs/heads/development' }}
+            type=raw,value=development-latest-linux,enable=${{ github.ref == 'refs/heads/development' }}
+            # Dev branch
             type=raw,value=dev-latest,enable=${{ github.ref == 'refs/heads/dev' }}
+            type=raw,value=dev-latest-linux,enable=${{ github.ref == 'refs/heads/dev' }}
+            # Staging branch
             type=raw,value=staging-latest,enable=${{ github.ref == 'refs/heads/staging' }}
+            type=raw,value=staging-latest-linux,enable=${{ github.ref == 'refs/heads/staging' }}
             # Tag with commit sha
             type=sha,prefix={{branch}}-,format=short
             # Tag with date
@@ -87,6 +134,20 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
           platforms: linux/amd64
+          # Aumenta timeout per registry lenti
+          build-args: |
+            BUILDKIT_STEP_LOG_MAX_SIZE=50000000
+          provenance: false
+          sbom: false
+        env:
+          BUILDX_NO_DEFAULT_ATTESTATIONS: 1
+
+      - name: Retry push on failure
+        if: failure() && steps.build.outcome == 'failure'
+        run: |
+          echo "Retry push after 30 seconds..."
+          sleep 30
+          docker push $(echo "${{ steps.meta.outputs.tags }}" | head -n1)
 
   build-windows:
     name: Build Windows Container
@@ -108,6 +169,54 @@ jobs:
           REGISTRY_TOKEN: ${{ secrets.REGISTRY_TOKEN }}
         shell: cmd
 
+      - name: Setup .NET
+        run: |
+          # .NET should already be available on Windows runner
+          dotnet --version
+        shell: pwsh
+
+      - name: Generate version.json with MinVer
+        run: |
+          # Fetch all tags for MinVer to work correctly
+          git fetch --tags --force
+          
+          # Build project to trigger MinVer
+          cd Data_Coupler
+          dotnet build -c Release /p:ContinuousIntegrationBuild=true
+          
+          # Extract version calculated by MinVer
+          $VERSION = dotnet msbuild -getProperty:Version -p:ContinuousIntegrationBuild=true 2>$null | Select-Object -Last 1
+          
+          # Fallback if MinVer fails (no tags)
+          if ([string]::IsNullOrWhiteSpace($VERSION) -or $VERSION -eq "0.0.0-alpha.0") {
+            Write-Host "Warning: No git tags found. MinVer returned default. Using fallback."
+            $commitCount = git rev-list --count HEAD
+            $VERSION = "2.1.0-alpha.0.$commitCount"
+          }
+          
+          Write-Host "MinVer calculated version: $VERSION"
+          
+          $COMMIT_SHA = "${{ github.sha }}"
+          $SHORT_SHA = $COMMIT_SHA.Substring(0, 7)
+          $BRANCH = "${{ github.ref_name }}"
+          $BUILD_DATE = (Get-Date).ToUniversalTime().ToString("yyyy-MM-dd HH:mm:ss UTC")
+          
+          # Create version.json
+          $versionJson = @{
+            version = $VERSION
+            commitSha = $SHORT_SHA
+            branch = $BRANCH
+            buildDate = $BUILD_DATE
+            buildEnvironment = "Gitea Actions"
+          } | ConvertTo-Json
+          
+          $versionJson | Out-File -FilePath "wwwroot\version.json" -Encoding UTF8
+          
+          Write-Host "Generated version.json:"
+          Get-Content "wwwroot\version.json"
+          cd ..
+        shell: pwsh
+
       - name: Debug - Verify files
         run: |
           echo Working directory:
@@ -197,18 +306,15 @@ jobs:
         run: |
           IMAGE_LOWER=$(echo "${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}" | tr '[:upper:]' '[:lower:]')
           docker buildx imagetools create -t ${IMAGE_LOWER}:latest \
-            ${IMAGE_LOWER}:latest \
+            ${IMAGE_LOWER}:latest-linux \
             ${IMAGE_LOWER}:latest-windows
 
       - name: Create and push manifest for development branch
         if: github.ref == 'refs/heads/development'
         run: |
           IMAGE_LOWER=$(echo "${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}" | tr '[:upper:]' '[:lower:]')
-          docker buildx imagetools create -t ${IMAGE_LOWER}:latest \
-            ${IMAGE_LOWER}:latest \
-            ${IMAGE_LOWER}:latest-windows
           docker buildx imagetools create -t ${IMAGE_LOWER}:development-latest \
-            ${IMAGE_LOWER}:development-latest \
+            ${IMAGE_LOWER}:development-latest-linux \
             ${IMAGE_LOWER}:development-latest-windows
 
       - name: Create and push manifest for dev branch
@@ -216,7 +322,7 @@ jobs:
         run: |
           IMAGE_LOWER=$(echo "${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}" | tr '[:upper:]' '[:lower:]')
           docker buildx imagetools create -t ${IMAGE_LOWER}:dev-latest \
-            ${IMAGE_LOWER}:dev-latest \
+            ${IMAGE_LOWER}:dev-latest-linux \
             ${IMAGE_LOWER}:dev-latest-windows
 
       - name: Create and push manifest for staging branch
@@ -224,5 +330,5 @@ jobs:
         run: |
           IMAGE_LOWER=$(echo "${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}" | tr '[:upper:]' '[:lower:]')
           docker buildx imagetools create -t ${IMAGE_LOWER}:staging-latest \
-            ${IMAGE_LOWER}:staging-latest \
+            ${IMAGE_LOWER}:staging-latest-linux \
             ${IMAGE_LOWER}:staging-latest-windows

.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
@@ -262,6 +295,35 @@
 - `Data_Coupler/HealthChecks/DatabaseHealthCheck.cs`
 - `Data_Coupler/HealthChecks/BackgroundServiceHealthCheck.cs`
 
+### 12. Sistema di Versioning Automatizzato
+
+#### Caratteristiche:
+- **Versioning Automatico**: Generazione automatica della versione tramite Gitea Actions
+- **Display UI**: Versione visibile nel NavMenu dell'applicazione
+- **Semantic Versioning**: Segue il pattern MAJOR.MINOR.PATCH
+- **Metadati Build**: Commit SHA, branch, data build, ambiente
+- **Fallback Intelligente**: Versione di default se file non disponibile
+
+#### Componenti:
+- **version.json**: File generato automaticamente durante il build
+- **VersionInfo**: Modello dati per informazioni versione
+- **VersionService**: Servizio singleton per gestione versione
+- **NavMenu Integration**: Display "Data_Coupler v2.1.0" nel navbar
+
+#### Workflow:
+1. Git Push → Gitea Actions triggered
+2. Workflow genera `version.json` con versione da csproj
+3. Docker build include il file version.json
+4. VersionService carica al startup
+5. NavMenu mostra versione nell'interfaccia
+
+#### File Chiave:
+- `Data_Coupler/Models/VersionInfo.cs`
+- `Data_Coupler/Services/VersionService.cs`
+- `Data_Coupler/wwwroot/version.json`
+- `.gitea/workflows/docker-build.yml`
+- `VERSIONING_SYSTEM.md` (documentazione completa)
+
 ## 🔐 Sicurezza
 
 ### Gestione Credenziali:
@@ -408,6 +470,8 @@
 - **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
+- **VERSIONING_SYSTEM.md**: Sistema di versioning automatizzato (NUOVO)
 - **DOCKER_DEPLOYMENT.md**: Guida deployment Docker
 - **WINDOWS_SERVICE_DEPLOYMENT.md**: Deploy come Windows Service
 - **.gitea/workflows/README.md**: Configurazione Gitea Actions
@@ -443,7 +507,8 @@
 ## 🚀 Roadmap Futura
 
 ### Feature in Pianificazione:
-- [ ] Supporto file Excel/CSV avanzato
+- [x] Supporto file Excel/CSV avanzato (Completato - Gennaio 2026)
+- [x] Sistema di versioning automatizzato (Completato - Febbraio 2026)
 - [ ] Sistema di notifiche (email, webhook)
 - [ ] Dashboard analytics avanzato
 - [ ] Multi-tenant support
@@ -451,6 +516,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 +528,8 @@
 
 ---
 
-**Versione**: 2.0  
+**Versione**: 2.1  
-**Ultimo Aggiornamento**: 22 Gennaio 2026  
+**Ultimo Aggiornamento**: 2 Febbraio 2026  
 **Framework**: .NET 9.0  
 **Sviluppatore**: Alessio Dalsanto  
 **Repository**: https://github.com/AlessioDalsi/Data-Coupler

.github/workflows/docker-build.yml

@@ -48,11 +48,13 @@ jobs:
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
           tags: |
-            # Tag based on branch
+            # Tag based on branch - latest only for main
             type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }}
-            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/development' }}
+            # Development branch - no latest tag
             type=raw,value=development-latest,enable=${{ github.ref == 'refs/heads/development' }}
+            # Dev branch
             type=raw,value=dev-latest,enable=${{ github.ref == 'refs/heads/dev' }}
+            # Staging branch
             type=raw,value=staging-latest,enable=${{ github.ref == 'refs/heads/staging' }}
             # Tag with commit sha
             type=sha,prefix={{branch}}-,format=short
@@ -173,9 +175,6 @@ jobs:
         if: github.ref == 'refs/heads/development'
         run: |
           IMAGE_LOWER=$(echo "${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}" | tr '[:upper:]' '[:lower:]')
-          docker buildx imagetools create -t ${IMAGE_LOWER}:latest \
-            ${IMAGE_LOWER}:latest \
-            ${IMAGE_LOWER}:latest-windows
           docker buildx imagetools create -t ${IMAGE_LOWER}:development-latest \
             ${IMAGE_LOWER}:development-latest \
             ${IMAGE_LOWER}:development-latest-windows

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<IEnumerable<Dictionary<string, object>>> 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"))
+{
+    <option value="@profile.Id">@profile.Name</option>
+}
+```
+
+**Dopo**:
+```csharp
+@foreach (var profile in availableProfiles)
+{
+    <option value="@profile.Id">@profile.Name @(profile.SourceType == "file" ? "(File)" : "")</option>
+}
+```
+
+**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<string, object>` 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.

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

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;

Data_Coupler/Data_Coupler.csproj

@@ -4,6 +4,9 @@
     <TargetFramework>net9.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
+    <!-- Version is now automatically calculated by MinVer from git tags -->
+    <MinVerTagPrefix>v</MinVerTagPrefix>
+    <MinVerVerbosity>detailed</MinVerVerbosity>
   </PropertyGroup>
 
   <ItemGroup>
@@ -20,6 +23,16 @@
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="9.0.6" />
+    <PackageReference Include="MinVer" Version="5.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Update="wwwroot\version.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
 
 </Project>

Data_Coupler/Models/VersionInfo.cs

@@ -0,0 +1,53 @@
+namespace Data_Coupler.Models
+{
+    /// <summary>
+    /// Modello per le informazioni di versione dell'applicazione
+    /// </summary>
+    public class VersionInfo
+    {
+        /// <summary>
+        /// Versione principale (es. "2.1.0")
+        /// </summary>
+        public string Version { get; set; } = "0.0.0";
+
+        /// <summary>
+        /// Commit SHA breve (es. "abc1234")
+        /// </summary>
+        public string CommitSha { get; set; } = "unknown";
+
+        /// <summary>
+        /// Branch Git (es. "main", "development")
+        /// </summary>
+        public string Branch { get; set; } = "unknown";
+
+        /// <summary>
+        /// Data e ora del build
+        /// </summary>
+        public string BuildDate { get; set; } = "unknown";
+
+        /// <summary>
+        /// Ambiente di build (es. "Docker", "Local")
+        /// </summary>
+        public string BuildEnvironment { get; set; } = "Local";
+
+        /// <summary>
+        /// Restituisce una stringa formattata con la versione completa
+        /// </summary>
+        public string GetFullVersion()
+        {
+            if (CommitSha != "unknown" && Branch != "unknown")
+            {
+                return $"v{Version} ({Branch}-{CommitSha})";
+            }
+            return $"v{Version}";
+        }
+
+        /// <summary>
+        /// Restituisce una stringa formattata breve per l'UI
+        /// </summary>
+        public string GetShortVersion()
+        {
+            return $"v{Version}";
+        }
+    }
+}

Data_Coupler/Pages/DataCoupler.razor

@@ -294,13 +294,56 @@
                     <!-- Sezione File -->
                     @if (selectedSourceType == "file")
                     {
+                        <div class="alert alert-info" role="alert">
+                            <i class="fas fa-info-circle"></i>
+                            <strong>Due modalità disponibili:</strong>
+                            <ul class="mb-0 mt-2">
+                                <li><strong>Caricamento Browser:</strong> Carica un file per preview e configurazione mapping (file temporaneo)</li>
+                                <li><strong>Percorso File:</strong> Specifica il percorso completo del file sul server per schedulazioni</li>
+                            </ul>
+                        </div>
+
+                        <!-- Opzione 1: Caricamento Browser per Preview -->
                         <div class="mb-3">
-                            <label class="form-label">Seleziona File (Excel/CSV):</label>
+                            <label class="form-label">
+                                <i class="fas fa-upload"></i> Carica File per Preview (opzionale):
+                            </label>
                             <InputFile class="form-control" OnChange="OnFileSelected" accept=".xlsx,.xls,.csv" />
                             @if (!string.IsNullOrEmpty(selectedFileName))
                             {
-                                <small class="text-muted">File selezionato: @selectedFileName</small>
+                                <small class="text-muted">File caricato: @selectedFileName</small>
                             }
+                            <small class="form-text text-muted">
+                                Carica un file per vedere preview e configurare il mapping. Questo file non verrà salvato.
+                            </small>
+                        </div>
+
+                        <!-- Opzione 2: Percorso File Manuale (Richiesto per Schedulazione) -->
+                        <div class="mb-3">
+                            <label class="form-label">
+                                <i class="fas fa-folder-open"></i> Percorso File sul Server (richiesto per schedulazione): *
+                            </label>
+                            <div class="input-group">
+                                <input type="text" class="form-control" @bind="manualFilePath" 
+                                       placeholder="Es: C:\Data\products.csv o /data/products.csv" />
+                                <button class="btn btn-outline-primary" @onclick="ValidateAndLoadFileFromPath" 
+                                        disabled="@(string.IsNullOrEmpty(manualFilePath) || isProcessingFile)">
+                                    @if (isProcessingFile)
+                                    {
+                                        <span class="spinner-border spinner-border-sm me-1"></span>
+                                    }
+                                    <i class="fas fa-check"></i> Valida e Carica
+                                </button>
+                            </div>
+                            @if (!string.IsNullOrEmpty(uploadedFilePath) && uploadedFilePath == manualFilePath)
+                            {
+                                <small class="text-success">
+                                    <i class="fas fa-check-circle"></i> File validato e caricato con successo!
+                                </small>
+                            }
+                            <small class="form-text text-muted">
+                                Inserisci il percorso completo del file. Il file deve essere accessibile dal server.
+                            </small>
                         </div>
 
                         @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"

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<string, IEnumerable<string>> 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();
     }
 
+    /// <summary>
+    /// Valida e carica un file dal percorso specificato manualmente
+    /// </summary>
+    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();
+        }
+    }
+
+    /// <summary>
+    /// Processa un file CSV dal percorso specificato
+    /// </summary>
+    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<Dictionary<string, object>>();
+        string? line;
+        while ((line = await reader.ReadLineAsync()) != null)
+        {
+            if (string.IsNullOrWhiteSpace(line)) continue;
+
+            var values = ParseCsvLine(line, separator);
+            var row = new Dictionary<string, object>();
+            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);
+    }
+
+    /// <summary>
+    /// Processa un file Excel dal percorso specificato
+    /// </summary>
+    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<string>();
+                    var dataRows = new List<Dictionary<string, object>>();
+
+                    foreach (DataColumn column in table.Columns)
+                    {
+                        headers.Add(column.ColumnName);
+                    }
+
+                    foreach (DataRow dataRow in table.Rows)
+                    {
+                        var row = new Dictionary<string, object>();
+                        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);

Data_Coupler/Pages/Login.razor

@@ -7,7 +7,7 @@
 <div class="login-container">
     <div class="login-card">
         <div class="login-header">
-            <h2>TEST Data Coupler</h2>
+            <h2>Data Coupler</h2>
             <p>Accedi per continuare</p>
         </div>
         

Data_Coupler/Pages/Scheduling.razor

@@ -174,9 +174,9 @@
                                         <option value="0">-- Seleziona Profilo --</option>
                                         @if (availableProfiles != null)
                                         {
-                                            @foreach (var profile in availableProfiles.Where(p => p.SourceType != "file"))
+                                            @foreach (var profile in availableProfiles)
                                             {
-                                                <option value="@profile.Id">@profile.Name</option>
+                                                <option value="@profile.Id">@profile.Name @(profile.SourceType == "file" ? "(File)" : "")</option>
                                             }
                                         }
                                     </InputSelect>
@@ -184,7 +184,8 @@
                                     @if (availableProfiles?.Any(p => p.SourceType == "file") == true)
                                     {
                                         <small class="form-text text-muted">
-                                            ⚠️ I profili con file come sorgente sono esclusi dalle schedulazioni per motivi di sicurezza.
+                                            ℹ️ I profili con file CSV/Excel come sorgente sono ora supportati per le schedulazioni.
+                                            Il file specificato nel profilo verrà letto ad ogni esecuzione.
                                         </small>
                                     }
                                 </div>

Data_Coupler/Pages/Scheduling.razor.cs

@@ -86,7 +86,8 @@ public partial class Scheduling : ComponentBase
             IntervalValue = schedule.IntervalValue,
             IntervalUnit = schedule.IntervalUnit,
             SourceDatabaseOverride = schedule.SourceDatabaseOverride,
-            DestinationDatabaseOverride = schedule.DestinationDatabaseOverride
+            DestinationDatabaseOverride = schedule.DestinationDatabaseOverride,
+            EnableDeletionSync = schedule.EnableDeletionSync
         };
 
         // Imposta il profilo selezionato per mostrare i campi di override
@@ -278,7 +279,8 @@ public partial class Scheduling : ComponentBase
             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;

Data_Coupler/Program.cs

@@ -32,6 +32,9 @@ builder.Services.AddWindowsService();
 // Register Authentication Service
 builder.Services.AddSingleton<Data_Coupler.Services.IAuthenticationService, Data_Coupler.Services.AuthenticationService>();
 
+// Register Version Service
+builder.Services.AddSingleton<Data_Coupler.Services.IVersionService, Data_Coupler.Services.VersionService>();
+
 // Configurazione logging per Windows Service
 if (OperatingSystem.IsWindows())
 {

Data_Coupler/Services/DataTransferService.cs

@@ -8,7 +8,7 @@ namespace Data_Coupler.Services;
 /// </summary>
 public interface IDataTransferService
 {
-    Task<DataTransferResult> ExecuteProfileAsync(DataCouplerProfile profile, string? sourceDatabaseOverride = null, string? destinationDatabaseOverride = null);
+    Task<DataTransferResult> ExecuteProfileAsync(DataCouplerProfile profile, string? sourceDatabaseOverride = null, string? destinationDatabaseOverride = null, bool enableDeletionSync = false);
 }
 
 public class DataTransferResult
@@ -37,7 +37,7 @@ public class DataTransferService : IDataTransferService
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
     }
 
-    public async Task<DataTransferResult> ExecuteProfileAsync(DataCouplerProfile profile, string? sourceDatabaseOverride = null, string? destinationDatabaseOverride = null)
+    public async Task<DataTransferResult> ExecuteProfileAsync(DataCouplerProfile profile, string? sourceDatabaseOverride = null, string? destinationDatabaseOverride = null, bool enableDeletionSync = false)
     {
         var result = new DataTransferResult
         {
@@ -59,21 +59,11 @@ public class DataTransferService : IDataTransferService
                 return result;
             }
 
-            // Controlla se il profilo ha file come sorgente e blocca l'esecuzione
-            if (profile.SourceType?.ToLower() == "file")
-            {
-                result.IsSuccess = false;
-                result.ErrorMessage = "I profili con file come sorgente non sono supportati nelle schedulazioni per motivi di sicurezza.";
-                result.EndTime = DateTime.Now; // Usa l'ora locale per coerenza
-                _logger.LogWarning("Tentativo di esecuzione di profilo con file come sorgente bloccato: {ProfileName}", profile.Name);
-                return result;
-            }
-
             // Applica override del database se specificati
             var profileToExecute = await ApplyDatabaseOverrides(profile, sourceDatabaseOverride, destinationDatabaseOverride);
 
             // Utilizza il servizio esistente per l'esecuzione
-            var executionResult = await _scheduledExecutionService.ExecuteProfileAsync(profileToExecute.Id);
+            var executionResult = await _scheduledExecutionService.ExecuteProfileAsync(profileToExecute.Id, enableDeletionSync);
             
             result.IsSuccess = executionResult.Success;
             result.RecordsProcessed = executionResult.RecordsProcessed;
@@ -175,7 +165,8 @@ public class DataTransferService : IDataTransferService
         if (string.IsNullOrEmpty(profile.DestinationType))
             return (false, "Tipo destinazione non specificato");
 
-        if (!profile.SourceCredentialId.HasValue)
+        // Per le sorgenti file, la credenziale non è richiesta
+        if (profile.SourceType != "file" && !profile.SourceCredentialId.HasValue)
             return (false, "Credenziale sorgente non specificata");
 
         if (!profile.DestinationCredentialId.HasValue)

Data_Coupler/Services/ScheduledProfileExecutionService.cs

@@ -13,6 +13,7 @@ using System.Text;
 using System.Text.Json;
 using Data_Coupler.Models;
 using Data_Coupler.Services;
+using ExcelDataReader;
 
 namespace Data_Coupler.Services;
 
@@ -130,9 +131,15 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
             var (restClient, restCredential, restEntity) = await SetupDestinationConnectionAsync(profile);
 
             // 2. Verifica che le connessioni siano valide
-            if (sourceManager == null)
+            // Per i file, sourceManager sarà null (è normale), per database deve essere presente
+            if (profile.SourceType.ToLower() == "database" && sourceManager == null)
             {
-                throw new InvalidOperationException("Impossibile stabilire connessione con la sorgente dati");
+                throw new InvalidOperationException("Impossibile stabilire connessione con il database sorgente");
+            }
+
+            if (profile.SourceType.ToLower() == "file" && string.IsNullOrEmpty(profile.SourceFilePath))
+            {
+                throw new InvalidOperationException("Percorso file sorgente non specificato nel profilo");
             }
 
             if (restClient == null || restEntity == null)
@@ -187,11 +194,18 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
     /// </summary>
     private async Task<(IDatabaseManager? manager, DatabaseCredential? credential)> SetupSourceConnectionAsync(DataCouplerProfile profile)
     {
-        if (profile.SourceType.ToLower() != "database")
+        _logger.LogInformation("SetupSourceConnectionAsync - SourceType: '{SourceType}', SourceCredentialId: {SourceCredentialId}, SourceFilePath: '{SourceFilePath}'", 
+            profile.SourceType, profile.SourceCredentialId, profile.SourceFilePath);
+
+        // Se la sorgente è un file, non servono credenziali database
+        if (string.IsNullOrEmpty(profile.SourceType) || 
+            profile.SourceType.Equals("file", StringComparison.OrdinalIgnoreCase))
         {
-            return (null, null); // Per i file gestiremo diversamente
+            _logger.LogInformation("Sorgente tipo file, nessuna connessione database necessaria");
+            return (null, null);
         }
 
+        // Per database, la credenziale è obbligatoria
         if (!profile.SourceCredentialId.HasValue)
         {
             throw new InvalidOperationException("Credenziale sorgente non specificata per il database");
@@ -378,18 +392,233 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
     }
 
     /// <summary>
-    /// Ottiene tutti i record da file (implementazione future)
+    /// Ottiene tutti i record da file CSV o Excel
     /// </summary>
     private async Task<IEnumerable<Dictionary<string, object>>> GetAllRecordsFromFileAsync(DataCouplerProfile profile)
     {
         if (string.IsNullOrEmpty(profile.SourceFilePath))
             throw new InvalidOperationException("Percorso file sorgente non specificato");
 
-        // TODO: Implementazione per file Excel/CSV per le schedulazioni
+        if (!System.IO.File.Exists(profile.SourceFilePath))
-        // Per ora restituiamo una lista vuota
+            throw new FileNotFoundException($"Il file '{profile.SourceFilePath}' non esiste");
-        _logger.LogWarning("Lettura file non ancora implementata per le schedulazioni. File: {FilePath}", profile.SourceFilePath);
+
-        await Task.Delay(1); // Placeholder async
+        var extension = System.IO.Path.GetExtension(profile.SourceFilePath).ToLowerInvariant();
-        return new List<Dictionary<string, object>>();
+        
+        _logger.LogInformation("Lettura file sorgente: {FilePath} (Tipo: {Extension})", profile.SourceFilePath, extension);
+
+        if (extension == ".csv")
+        {
+            return await ReadCsvFileAsync(profile.SourceFilePath);
+        }
+        else if (extension == ".xlsx" || extension == ".xls")
+        {
+            return await ReadExcelFileAsync(profile.SourceFilePath);
+        }
+        else
+        {
+            throw new NotSupportedException($"Formato file non supportato: {extension}. Utilizzare .csv, .xlsx o .xls");
+        }
+    }
+
+    /// <summary>
+    /// Legge un file CSV e restituisce i record come dizionari
+    /// </summary>
+    private async Task<IEnumerable<Dictionary<string, object>>> ReadCsvFileAsync(string filePath)
+    {
+        var dataRows = new List<Dictionary<string, object>>();
+
+        try
+        {
+            // Apri in modalità condivisa per permettere ad altri processi di accedere al file
+            using var stream = new System.IO.FileStream(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
+            using var reader = new System.IO.StreamReader(stream);
+
+            var firstLine = await reader.ReadLineAsync();
+            if (string.IsNullOrEmpty(firstLine))
+            {
+                _logger.LogWarning("Il file CSV è vuoto: {FilePath}", filePath);
+                return dataRows;
+            }
+
+            // Detect separator automatically
+            var separator = DetectCsvSeparator(firstLine);
+            _logger.LogDebug("CSV separator rilevato: '{Separator}'", separator);
+
+            // Parse headers (first row)
+            var headers = ParseCsvLine(firstLine, separator);
+            _logger.LogInformation("CSV headers: {Headers} (Totale: {Count})", string.Join(", ", headers), headers.Count);
+
+            // Read data rows
+            string? line;
+            int rowNumber = 2;
+
+            while ((line = await reader.ReadLineAsync()) != null)
+            {
+                if (string.IsNullOrWhiteSpace(line)) continue;
+
+                var values = ParseCsvLine(line, separator);
+                var row = new Dictionary<string, object>();
+                
+                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);
+                rowNumber++;
+            }
+
+            _logger.LogInformation("File CSV letto con successo: {FilePath}, Record: {RecordCount}", filePath, dataRows.Count);
+            return dataRows;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Errore nella lettura del file CSV: {FilePath}", filePath);
+            throw;
+        }
+    }
+
+    /// <summary>
+    /// Legge un file Excel e restituisce i record come dizionari
+    /// </summary>
+    private async Task<IEnumerable<Dictionary<string, object>>> ReadExcelFileAsync(string filePath)
+    {
+        var dataRows = new List<Dictionary<string, object>>();
+
+        try
+        {
+            // Registra il provider di encoding per ExcelDataReader
+            System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);
+
+            // Apri in modalità condivisa per permettere ad altri processi di accedere al file
+            using var stream = new System.IO.FileStream(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
+            var extension = System.IO.Path.GetExtension(filePath).ToLowerInvariant();
+
+            ExcelDataReader.IExcelDataReader reader;
+            if (extension == ".xlsx")
+            {
+                reader = ExcelDataReader.ExcelReaderFactory.CreateOpenXmlReader(stream);
+            }
+            else if (extension == ".xls")
+            {
+                reader = ExcelDataReader.ExcelReaderFactory.CreateBinaryReader(stream);
+            }
+            else
+            {
+                throw new NotSupportedException($"Formato Excel non supportato: {extension}");
+            }
+
+            using (reader)
+            {
+                var configuration = new ExcelDataReader.ExcelDataSetConfiguration()
+                {
+                    ConfigureDataTable = (_) => new ExcelDataReader.ExcelDataTableConfiguration()
+                    {
+                        UseHeaderRow = true
+                    }
+                };
+
+                var dataSet = reader.AsDataSet(configuration);
+                _logger.LogInformation("File Excel letto: {FilePath}, Fogli: {SheetCount}", filePath, dataSet.Tables.Count);
+
+                // Legge il primo foglio (o tutti i fogli se necessario)
+                if (dataSet.Tables.Count > 0)
+                {
+                    var table = dataSet.Tables[0];
+                    var headers = new List<string>();
+
+                    foreach (System.Data.DataColumn column in table.Columns)
+                    {
+                        headers.Add(column.ColumnName);
+                    }
+
+                    foreach (System.Data.DataRow dataRow in table.Rows)
+                    {
+                        var row = new Dictionary<string, object>();
+                        foreach (var header in headers)
+                        {
+                            var value = dataRow[header];
+                            row[header] = value == DBNull.Value ? "" : value?.ToString() ?? "";
+                        }
+                        dataRows.Add(row);
+                    }
+
+                    _logger.LogInformation("Foglio Excel '{SheetName}' letto con successo: {RecordCount} record", 
+                        table.TableName, dataRows.Count);
+                }
+            }
+
+            await Task.CompletedTask; // Per mantenere il metodo async
+            return dataRows;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Errore nella lettura del file Excel: {FilePath}", filePath);
+            throw;
+        }
+    }
+
+    /// <summary>
+    /// Rileva automaticamente il separatore CSV
+    /// </summary>
+    private char DetectCsvSeparator(string line)
+    {
+        var separators = new[] { ',', ';', '\t', '|' };
+        var maxCount = 0;
+        var detectedSeparator = ',';
+
+        foreach (var sep in separators)
+        {
+            var count = line.Count(c => c == sep);
+            if (count > maxCount)
+            {
+                maxCount = count;
+                detectedSeparator = sep;
+            }
+        }
+
+        return detectedSeparator;
+    }
+
+    /// <summary>
+    /// Parse di una riga CSV gestendo correttamente le virgolette
+    /// </summary>
+    private List<string> ParseCsvLine(string line, char separator = ',')
+    {
+        var result = new List<string>();
+        var current = new System.Text.StringBuilder();
+        bool inQuotes = false;
+
+        for (int i = 0; i < line.Length; i++)
+        {
+            char c = line[i];
+
+            if (c == '"')
+            {
+                if (inQuotes && i + 1 < line.Length && line[i + 1] == '"')
+                {
+                    current.Append('"');
+                    i++;
+                }
+                else
+                {
+                    inQuotes = !inQuotes;
+                }
+            }
+            else if (c == separator && !inQuotes)
+            {
+                result.Add(current.ToString().Trim());
+                current.Clear();
+            }
+            else
+            {
+                current.Append(c);
+            }
+        }
+
+        result.Add(current.ToString().Trim());
+        return result;
     }
 
     /// <summary>

Data_Coupler/Services/VersionService.cs

@@ -0,0 +1,121 @@
+using Data_Coupler.Models;
+using System.Text.Json;
+
+namespace Data_Coupler.Services
+{
+    /// <summary>
+    /// Interfaccia per il servizio di gestione versione applicazione
+    /// </summary>
+    public interface IVersionService
+    {
+        /// <summary>
+        /// Ottiene le informazioni sulla versione corrente dell'applicazione
+        /// </summary>
+        VersionInfo GetVersion();
+
+        /// <summary>
+        /// Ottiene la versione formattata per display nell'UI
+        /// </summary>
+        string GetDisplayVersion();
+    }
+
+    /// <summary>
+    /// Servizio per gestire le informazioni di versione dell'applicazione
+    /// Legge i dati da version.json generato durante il build
+    /// </summary>
+    public class VersionService : IVersionService
+    {
+        private readonly VersionInfo _versionInfo;
+        private readonly ILogger<VersionService> _logger;
+        private readonly IWebHostEnvironment _env;
+
+        public VersionService(ILogger<VersionService> logger, IWebHostEnvironment env)
+        {
+            _logger = logger;
+            _env = env;
+            _versionInfo = LoadVersionInfo();
+        }
+
+        /// <summary>
+        /// Carica le informazioni di versione dal file version.json
+        /// </summary>
+        private VersionInfo LoadVersionInfo()
+        {
+            try
+            {
+                // Cerca il file version.json nella cartella wwwroot o nella root del progetto
+                string? versionFilePath = null;
+                
+                // Prima prova in wwwroot
+                if (!string.IsNullOrEmpty(_env.WebRootPath))
+                {
+                    var wwwrootPath = Path.Combine(_env.WebRootPath, "version.json");
+                    if (File.Exists(wwwrootPath))
+                    {
+                        versionFilePath = wwwrootPath;
+                    }
+                }
+                
+                // Se non trovato, prova nella root del progetto
+                if (versionFilePath == null)
+                {
+                    var contentPath = Path.Combine(_env.ContentRootPath, "wwwroot", "version.json");
+                    if (File.Exists(contentPath))
+                    {
+                        versionFilePath = contentPath;
+                    }
+                }
+
+                if (versionFilePath != null && File.Exists(versionFilePath))
+                {
+                    var json = File.ReadAllText(versionFilePath);
+                    var version = JsonSerializer.Deserialize<VersionInfo>(json, new JsonSerializerOptions
+                    {
+                        PropertyNameCaseInsensitive = true
+                    });
+
+                    if (version != null)
+                    {
+                        _logger.LogInformation("Version loaded from {Path}: {Version}", versionFilePath, version.GetFullVersion());
+                        return version;
+                    }
+                }
+                else
+                {
+                    _logger.LogWarning("version.json not found. Searched in WebRootPath: {WebRoot}, ContentRootPath: {ContentRoot}", 
+                        _env.WebRootPath ?? "null", _env.ContentRootPath);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error loading version.json, using default version");
+            }
+
+            // Versione di default se il file non esiste o c'è un errore
+            return new VersionInfo
+            {
+                Version = "2.1.0",
+                CommitSha = "local",
+                Branch = "dev",
+                BuildDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
+                BuildEnvironment = "Local"
+            };
+        }
+
+        /// <summary>
+        /// Ottiene le informazioni complete sulla versione
+        /// </summary>
+        public VersionInfo GetVersion()
+        {
+            return _versionInfo;
+        }
+
+        /// <summary>
+        /// Ottiene la versione formattata per display nell'UI
+        /// </summary>
+        public string GetDisplayVersion()
+        {
+            return _versionInfo.GetShortVersion();
+        }
+    }
+}

Data_Coupler/Shared/NavMenu.razor

@@ -1,6 +1,6 @@
 <div class="top-row ps-3 navbar navbar-dark">
     <div class="container-fluid">
-        <a class="navbar-brand" href="">Data_Coupler</a>
+        <a class="navbar-brand" href="">Data_Coupler @_version</a>
         <button title="Navigation menu" class="navbar-toggler" @onclick="ToggleNavMenu">
             <span class="navbar-toggler-icon"></span>
         </button>
@@ -58,11 +58,19 @@
     </nav>
 </div>
 
+@inject Data_Coupler.Services.IVersionService VersionService
+
 @code {
     private bool collapseNavMenu = true;
+    private string _version = "";
 
     private string? NavMenuCssClass => collapseNavMenu ? "collapse" : null;
 
+    protected override void OnInitialized()
+    {
+        _version = VersionService.GetDisplayVersion();
+    }
+
     private void ToggleNavMenu()
     {
         collapseNavMenu = !collapseNavMenu;

Data_Coupler/wwwroot/version.json

@@ -0,0 +1,7 @@
+{
+  "version": "2.1.2",
+  "commitSha": "593c0b6",
+  "branch": "development",
+  "buildDate": "2026-02-02",
+  "buildEnvironment": "Local"
+}

Dockerfile

@@ -24,17 +24,20 @@ RUN dotnet build "Data_Coupler.csproj" -c Release -o /app/build
 
 # Stage 2: Publish
 FROM build AS publish
-RUN dotnet publish "Data_Coupler.csproj" -c Release -o /app/publish /p:UseAppHost=false
+RUN dotnet publish "Data_Coupler.csproj" -c Release -o /app/publish \
+    /p:UseAppHost=false \
+    /p:PublishTrimmed=false \
+    /p:PublishSingleFile=false
 
 # Stage 3: Runtime
-FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS final
+FROM mcr.microsoft.com/dotnet/aspnet:9.0-alpine AS final
 WORKDIR /app
 
 # Installa le dipendenze necessarie per ExcelDataReader e altre librerie
-RUN apt-get update && apt-get install -y \
+RUN apk add --no-cache \
     libgdiplus \
-    libc6-dev \
+    icu-libs \
-    && rm -rf /var/lib/apt/lists/*
+    && rm -rf /var/cache/apk/*
 
 # Crea la directory per il database con i permessi corretti
 RUN mkdir -p /var/lib/Data_Coupler && \

MINVER_SETUP.md

@@ -0,0 +1,351 @@
+# MinVer - Setup e Utilizzo per Versioning Automatico
+
+## 🎯 Cos'è MinVer
+
+MinVer è un tool che calcola **automaticamente** la versione del progetto basandosi sui **git tags**. Elimina la necessità di aggiornare manualmente la versione nel `.csproj`.
+
+## 📦 Implementazione Completata
+
+### Modifiche Apportate
+
+1. ✅ **Pacchetto MinVer aggiunto** a `Data_Coupler.csproj`
+2. ✅ **Workflow Gitea Linux** aggiornato per usare MinVer
+3. ✅ **Workflow Gitea Windows** aggiornato per usare MinVer
+4. ✅ **Rimozione `<Version>` manuale** (ora calcolata automaticamente)
+
+### Come Funziona
+
+```
+Git Tags → MinVer → Calcola Versione → Build → version.json → UI
+```
+
+MinVer cerca il tag git più recente nel formato:
+- `v2.1.0` o `2.1.0` (tag esatto = quella versione)
+- Nessun tag = `0.0.0-alpha.0` + commit count
+- Tag + commit successivi = `2.1.0-alpha.0.5` (5 commit dopo il tag)
+
+## 🚀 Setup Iniziale sulla Repository
+
+### Step 1: Creare il Primo Tag
+
+**⚠️ AZIONE RICHIESTA**: Devi creare un tag git per inizializzare MinVer.
+
+```bash
+# Assicurati di essere sulla branch main (o quella desiderata)
+git checkout main
+
+# Assicurati di avere l'ultimo commit
+git pull
+
+# Crea il tag per la versione corrente
+git tag v2.1.0
+
+# Push del tag su Gitea
+git push origin v2.1.0
+```
+
+### Step 2: Verifica Locale (Opzionale)
+
+Puoi testare MinVer localmente prima del push:
+
+```bash
+cd Data_Coupler
+dotnet build
+
+# MinVer mostrerà nei log la versione calcolata:
+# MinVer: Using version 2.1.0
+```
+
+### Step 3: Commit e Push Modifiche
+
+```bash
+# Aggiungi le modifiche (MinVer nel .csproj e workflow)
+git add .
+git commit -m "feat: Implement MinVer for automatic versioning"
+
+# Push su Gitea
+git push origin main
+```
+
+## 📋 Workflow di Versioning con MinVer
+
+### Scenario 1: Nuovo Tag (Release)
+
+Quando sei pronto per una nuova release:
+
+```bash
+# Fai i tuoi commit normalmente
+git commit -am "feat: Add new feature"
+git commit -am "fix: Bug correction"
+
+# Quando pronto per release, crea il tag
+git tag v2.2.0
+git push origin v2.2.0
+
+# Gitea Actions automaticamente:
+# 1. Rileva il tag v2.2.0
+# 2. MinVer calcola versione: 2.2.0
+# 3. Build con quella versione
+# 4. UI mostra "Data_Coupler v2.2.0"
+```
+
+### Scenario 2: Commit senza Tag (Development)
+
+```bash
+# Durante sviluppo, commit normali senza tag
+git commit -am "feat: Work in progress"
+git push
+
+# MinVer calcola versione automaticamente:
+# - Ultimo tag: v2.1.0
+# - Commit dopo il tag: 5
+# - Versione calcolata: 2.1.0-alpha.0.5
+# - UI mostra: "Data_Coupler v2.1.0-alpha.0.5"
+```
+
+### Scenario 3: Branch Diversi
+
+```bash
+# Branch main con tag v2.1.0
+git checkout main
+# Versione: 2.1.0
+
+# Branch development (3 commit dopo tag)
+git checkout development
+# Versione: 2.1.0-alpha.0.3
+
+# Branch feature (5 commit dopo tag)
+git checkout feature/new-feature
+# Versione: 2.1.0-alpha.0.5
+```
+
+## 🎨 Convenzioni Tag
+
+### Tag Format
+
+MinVer supporta questi formati:
+
+```bash
+# ✅ Consigliato (con v)
+v2.1.0
+v2.2.0
+v3.0.0
+
+# ✅ Anche valido (senza v)
+2.1.0
+2.2.0
+
+# ✅ Pre-release (opzionale)
+v2.1.0-beta
+v2.1.0-rc.1
+```
+
+### Semantic Versioning
+
+Segui sempre Semantic Versioning per i tag:
+
+| Tipo | Da | A | Comando |
+|------|-----|-----|---------|
+| **PATCH** (bug fix) | 2.1.0 | 2.1.1 | `git tag v2.1.1` |
+| **MINOR** (feature) | 2.1.0 | 2.2.0 | `git tag v2.2.0` |
+| **MAJOR** (breaking) | 2.1.0 | 3.0.0 | `git tag v3.0.0` |
+
+## 🔧 Configurazione Avanzata (Opzionale)
+
+### Personalizzare MinVer nel .csproj
+
+Puoi aggiungere opzioni MinVer nel `Data_Coupler.csproj`:
+
+```xml
+<PropertyGroup>
+  <!-- Tag prefix (default: v) -->
+  <MinVerTagPrefix>v</MinVerTagPrefix>
+  
+  <!-- Pre-release phase (default: alpha) -->
+  <MinVerDefaultPreReleasePhase>alpha</MinVerDefaultPreReleasePhase>
+  
+  <!-- Minimum major/minor version -->
+  <MinVerMinimumMajorMinor>2.1</MinVerMinimumMajorMinor>
+  
+  <!-- Build metadata -->
+  <MinVerBuildMetadata>build.$(BUILD_NUMBER)</MinVerBuildMetadata>
+</PropertyGroup>
+```
+
+### Esempio Personalizzazione
+
+Se vuoi versioni tipo `2.1.0-dev.5` invece di `2.1.0-alpha.0.5`:
+
+```xml
+<PropertyGroup>
+  <MinVerDefaultPreReleasePhase>dev</MinVerDefaultPreReleasePhase>
+</PropertyGroup>
+```
+
+## 📊 Comandi Utili
+
+### Lista Tag Esistenti
+```bash
+git tag -l
+```
+
+### Cancella Tag Locale
+```bash
+git tag -d v2.1.0
+```
+
+### Cancella Tag Remoto
+```bash
+git push origin --delete v2.1.0
+```
+
+### Sposta Tag a Commit Diverso
+```bash
+# Cancella vecchio tag
+git tag -d v2.1.0
+git push origin --delete v2.1.0
+
+# Crea nuovo tag al commit corrente
+git tag v2.1.0
+git push origin v2.1.0
+```
+
+### Verifica Versione Calcolata Localmente
+```bash
+cd Data_Coupler
+dotnet build -v minimal | grep MinVer
+# Output: MinVer: Using version 2.1.0-alpha.0.3
+```
+
+## 🐛 Troubleshooting
+
+### Problema: MinVer calcola 0.0.0-alpha.0
+
+**Causa**: Nessun tag git trovato nella repository
+
+**Soluzione**:
+```bash
+git tag v2.1.0
+git push origin v2.1.0
+```
+
+### Problema: Versione non si aggiorna dopo nuovo tag
+
+**Causa**: Gitea Actions non ha fatto fetch dei tag
+
+**Soluzione**: I workflow sono già configurati con `git fetch --tags --force`
+
+### Problema: Versione locale diversa da CI/CD
+
+**Causa**: Tag non sincronizzati
+
+**Soluzione**:
+```bash
+git fetch --tags
+git pull
+```
+
+### Problema: Voglio tornare a versioning manuale
+
+**Soluzione**: Rimuovi MinVer dal `.csproj` e ripristina `<Version>2.1.0</Version>`
+
+## 📚 Vantaggi MinVer
+
+| Aspetto | Prima (Manuale) | Dopo (MinVer) |
+|---------|-----------------|---------------|
+| **Versione** | Manuale in .csproj | Automatica da tag |
+| **Sincronizzazione** | Rischio errore umano | Sempre consistente |
+| **Development** | Solo release versions | Alpha versions per dev |
+| **CI/CD** | Update .csproj ogni volta | Solo tag per release |
+| **Tracciabilità** | Manuale | Git tags = release |
+| **Commit count** | Non tracciato | Incluso in alpha versions |
+
+## 🎯 Best Practices
+
+### 1. Tag Solo su Main/Releases
+```bash
+# ✅ Buona pratica
+git checkout main
+git tag v2.2.0
+git push origin v2.2.0
+
+# ❌ Evitare
+git checkout feature/temp
+git tag v2.2.0  # Non taggare feature branch
+```
+
+### 2. Annotated Tags (Raccomandato)
+```bash
+# ✅ Con messaggio
+git tag -a v2.2.0 -m "Release 2.2.0: Add new features"
+
+# ❌ Lightweight (meno informazioni)
+git tag v2.2.0
+```
+
+### 3. Changelog nei Tag Messages
+```bash
+git tag -a v2.2.0 -m "Release 2.2.0
+
+New Features:
+- Feature A
+- Feature B
+
+Bug Fixes:
+- Fix issue #123
+"
+```
+
+### 4. Verificare Prima di Taggare
+```bash
+# Verifica commit
+git log --oneline -5
+
+# Verifica branch
+git branch --show-current
+
+# Verifica che sia pronto
+dotnet build
+dotnet test
+```
+
+## 🚦 Flusso Completo di Release
+
+```bash
+# 1. Finalizza feature
+git checkout development
+git commit -am "feat: Complete feature X"
+git push
+
+# 2. Merge to main
+git checkout main
+git merge development
+git push
+
+# 3. Crea tag release
+git tag -a v2.2.0 -m "Release 2.2.0: Feature X"
+git push origin v2.2.0
+
+# 4. Gitea Actions automaticamente:
+#    - Build con versione 2.2.0
+#    - Deploy container
+#    - UI mostra v2.2.0
+
+# 5. Continua sviluppo
+git checkout development
+git commit -am "feat: Start feature Y"
+# Versione automatica: 2.2.0-alpha.0.1
+```
+
+## 📖 Riferimenti
+
+- **MinVer Docs**: https://github.com/adamralph/minver
+- **Semantic Versioning**: https://semver.org/
+- **Git Tags**: https://git-scm.com/book/en/v2/Git-Basics-Tagging
+
+---
+
+**Status**: ✅ Implementato e Pronto  
+**Azione Richiesta**: Crea primo tag `v2.1.0` sulla repository  
+**Data**: 2 Febbraio 2026  
+**Autore**: Alessio Dalsanto

README.md

@@ -8,6 +8,12 @@ Data-Coupler è una soluzione integrata per la gestione di connessioni dati e cr
 - **DataConnection**: Libreria per connessioni a database e API REST
 - **Data_Coupler**: Applicazione Blazor Server per l'interfaccia utente
 
+### 🆕 Novità Recenti (Gennaio 2026)
+- ✅ **Schedulazione File CSV/Excel**: Supporto completo per schedulare trasferimenti da file
+- ✅ **Validazione Percorsi**: Validazione file prima del salvataggio profili
+- ✅ **Deletion Sync Configurabile**: Controllo granulare sincronizzazione eliminazioni
+- ✅ **Doppia Modalità File**: Caricamento browser (preview) + percorso manuale (schedulazione)
+
 ## Architettura
 
 ### CredentialManager
@@ -130,6 +136,36 @@ dotnet run --project Data_Coupler/Data_Coupler.csproj
 L'applicazione sarà disponibile su:
 - HTTP: http://localhost:7550
 
+## 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)
+- **Schedulazione**: ✅ Supportato con percorso file manuale
+
+### 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)
+- **Schedulazione**: ✅ Supportato con percorso file manuale
+
+### Modalità Caricamento File
+
+#### 1. Caricamento Browser (Preview)
+- Carica file tramite browser per configurare mapping
+- Processato in memoria, **non salvato sul server**
+- Ideale per setup iniziale profilo
+
+#### 2. Percorso Manuale (Schedulazione) ⭐
+- Specifica percorso completo file sul server
+- **Obbligatorio** per profili schedulati
+- Sistema valida esistenza e leggibilità
+- Esempi: `C:\Data\products.csv`, `/data/customers.xlsx`
+
 ### 🐳 Deployment Docker
 
 **Quick Start con Docker:**
@@ -200,10 +236,12 @@ docker pull gitea.home-nas-ds.org/alessio/data-coupler:staging-latest
 - **Validazione**: Validazione completa dei dati in input
 - **Isolamento**: Ogni progetto ha responsabilità specifiche
 - **Type Safety**: Uso di tipi forti per evitare errori
+- **Validazione File**: Verifica esistenza e leggibilità file prima del salvataggio
 - **Deletion Sync Sicuro**: 
   - Disabilitato di default per prevenire eliminazioni accidentali
   - Disponibile solo nelle schedulazioni con configurazione esplicita
   - Warning chiaro nell'interfaccia utente per operazioni critiche
+- **Percorsi File Validati**: Controllo permessi e accessibilità per schedulazioni
 
 ## Testing
 

VERSIONING_CONSISTENCY_FIX.md

@@ -0,0 +1,221 @@
+# Fix: Consistenza Versioning tra Linux e Windows
+
+## 🐛 Problema Identificato
+
+Durante la revisione del sistema di versioning, è stato identificato un **problema critico di inconsistenza** tra i workflow Linux e Windows.
+
+### Stato Precedente
+
+#### Linux (Corretto)
+```bash
+VERSION=$(grep '<Version>' Data_Coupler/Data_Coupler.csproj | sed 's/.*<Version>\(.*\)<\/Version>.*/\1/' || echo "2.1.0")
+```
+✅ Legge dinamicamente la versione dal file `.csproj`
+
+#### Windows (Problematico)
+```cmd
+set VERSION=2.1.0
+```
+❌ Versione **hardcoded**, non legge dal `.csproj`
+
+### Conseguenze del Bug
+
+1. **Desincronizzazione**: Container Linux e Windows avrebbero potuto avere versioni diverse
+2. **Manutenzione difficile**: Necessario aggiornare il workflow ad ogni cambio di versione
+3. **Errori umani**: Rischio di dimenticare di aggiornare la versione hardcoded
+4. **Single Source of Truth violato**: `.csproj` non era più l'unica fonte
+
+## ✅ Soluzione Implementata
+
+### Nuovo Workflow Windows
+
+Implementato script PowerShell che **replica la logica Linux**:
+
+```powershell
+# Extract version from Data_Coupler.csproj or use default
+$csprojPath = "Data_Coupler\Data_Coupler.csproj"
+$VERSION = "2.1.0"
+
+if (Test-Path $csprojPath) {
+  $csprojContent = Get-Content $csprojPath -Raw
+  if ($csprojContent -match '<Version>(.*?)<\/Version>') {
+    $VERSION = $matches[1]
+    Write-Host "Version extracted from csproj: $VERSION"
+  } else {
+    Write-Host "Version tag not found in csproj, using default: $VERSION"
+  }
+} else {
+  Write-Host "csproj not found, using default version: $VERSION"
+}
+
+$COMMIT_SHA = "${{ github.sha }}"
+$SHORT_SHA = $COMMIT_SHA.Substring(0, 7)
+$BRANCH = "${{ github.ref_name }}"
+$BUILD_DATE = (Get-Date).ToUniversalTime().ToString("yyyy-MM-dd HH:mm:ss UTC")
+
+# Create version.json
+$versionJson = @{
+  version = $VERSION
+  commitSha = $SHORT_SHA
+  branch = $BRANCH
+  buildDate = $BUILD_DATE
+  buildEnvironment = "Gitea Actions"
+} | ConvertTo-Json
+
+$versionJson | Out-File -FilePath "Data_Coupler\wwwroot\version.json" -Encoding UTF8
+```
+
+### Vantaggi della Soluzione
+
+1. ✅ **Consistenza**: Linux e Windows leggono dalla stessa fonte
+2. ✅ **Single Source of Truth**: `.csproj` è l'unica fonte della versione
+3. ✅ **Manutenzione semplificata**: Nessun bisogno di aggiornare workflow
+4. ✅ **Robustezza**: Fallback a default se `.csproj` non trovato
+5. ✅ **Logging**: Output chiaro per debugging
+6. ✅ **Formato JSON corretto**: Uso di `ConvertTo-Json` per output valido
+7. ✅ **Data UTC**: Consistenza formato data tra piattaforme
+
+## 📊 Confronto Tecnico
+
+### Metodi di Estrazione
+
+| Aspetto | Linux | Windows |
+|---------|-------|---------|
+| **Tool** | `grep` + `sed` | PowerShell regex |
+| **Pattern** | `sed 's/.*<Version>\(.*\)<\/Version>.*/\1/'` | `'<Version>(.*?)<\/Version>'` |
+| **Shell** | Bash | PowerShell (`pwsh`) |
+| **Fallback** | `|| echo "2.1.0"` | `if-else` con default |
+| **Test esistenza file** | Implicito in grep | `Test-Path` esplicito |
+| **Output JSON** | `cat` con heredoc | `ConvertTo-Json` |
+
+### Formato Output Generato
+
+Entrambi i workflow ora generano **identico** `version.json`:
+
+```json
+{
+  "version": "2.1.0",
+  "commitSha": "abc1234",
+  "branch": "main",
+  "buildDate": "2026-02-02 10:30:45 UTC",
+  "buildEnvironment": "Gitea Actions"
+}
+```
+
+## 🧪 Testing
+
+### Verifica Workflow
+
+#### Linux Build
+```bash
+# Verifica che legga dal .csproj
+grep '<Version>' Data_Coupler/Data_Coupler.csproj
+# Output atteso: <Version>2.1.0</Version>
+
+# Verifica version.json generato
+cat Data_Coupler/wwwroot/version.json
+```
+
+#### Windows Build
+```powershell
+# Verifica che legga dal .csproj
+$content = Get-Content Data_Coupler\Data_Coupler.csproj -Raw
+$content -match '<Version>(.*?)<\/Version>'
+$matches[1]
+# Output atteso: 2.1.0
+
+# Verifica version.json generato
+Get-Content Data_Coupler\wwwroot\version.json | ConvertFrom-Json
+```
+
+### Test di Consistenza
+
+Dopo un push su Gitea:
+
+1. **Attendi completamento** di entrambi i build (Linux + Windows)
+2. **Verifica logs** Gitea Actions:
+   - Linux: "Version extracted from csproj: 2.1.0"
+   - Windows: "Version extracted from csproj: 2.1.0"
+3. **Confronta immagini Docker**:
+```bash
+# Estrai version.json da entrambi i container
+docker run --rm gitea.home-nas-ds.org/alessio/data-coupler:latest-linux cat /app/wwwroot/version.json > linux-version.json
+docker run --rm gitea.home-nas-ds.org/alessio/data-coupler:latest-windows cat /app/wwwroot/version.json > windows-version.json
+
+# Confronta (dovrebbero essere identici eccetto buildDate)
+diff linux-version.json windows-version.json
+```
+
+## 📋 Checklist Validazione
+
+- [x] Workflow Linux mantiene funzionalità esistente
+- [x] Workflow Windows corretto con PowerShell
+- [x] Entrambi leggono da `.csproj`
+- [x] Fallback identico ("2.1.0")
+- [x] Formato JSON valido su entrambe le piattaforme
+- [x] Data in formato UTC su entrambe le piattaforme
+- [x] Logging appropriato per debugging
+- [x] Documentazione aggiornata (`VERSIONING_SYSTEM.md`)
+- [x] Test locali completati
+
+## 🚀 Impatto della Correzione
+
+### Prima della Fix
+```
+Developer aggiorna .csproj → Linux usa versione corretta
+                            → Windows usa 2.1.0 hardcoded ❌
+                            → INCONSISTENZA tra container
+```
+
+### Dopo la Fix
+```
+Developer aggiorna .csproj → Linux legge da .csproj ✅
+                            → Windows legge da .csproj ✅
+                            → STESSA versione in entrambi i container ✅
+```
+
+## 📝 Best Practices Applicate
+
+1. **DRY (Don't Repeat Yourself)**: `.csproj` è single source of truth
+2. **Fail-Safe**: Fallback a default se problemi con `.csproj`
+3. **Logging esplicito**: Output chiaro per troubleshooting
+4. **Cross-platform**: Logica equivalente su Linux/Windows
+5. **Testabilità**: Script facilmente testabile localmente
+6. **Manutenibilità**: Nessun hardcoding, tutto dinamico
+
+## 🔮 Considerazioni Future
+
+### Possibili Miglioramenti
+
+1. **Auto-increment (opzionale)**:
+   - Potrebbe essere aggiunto parsing di commit messages
+   - Conventional Commits per determinare bump MAJOR/MINOR/PATCH
+   - Aggiornamento automatico `.csproj` prima del build
+
+2. **Git Tags**:
+   - Sincronizzazione versione con git tags
+   - Creazione automatica tag al push su main
+
+3. **Changelog Automatico**:
+   - Generazione CHANGELOG.md basato su commit
+   - Integrazione con versioning
+
+4. **Multi-versione per branch**:
+   - Branch `development`: 2.1.0-dev
+   - Branch `staging`: 2.1.0-rc1
+   - Branch `main`: 2.1.0
+
+**Nota**: Tutte queste feature richiederebbero complessità aggiuntiva. L'approccio attuale (incremento manuale) è intenzionale per mantenere semplicità e controllo esplicito.
+
+## 📚 Riferimenti
+
+- **File modificato**: `.gitea/workflows/docker-build.yml`
+- **Documentazione aggiornata**: `VERSIONING_SYSTEM.md`
+- **Data correzione**: 2 Febbraio 2026
+- **Autore**: Alessio Dalsanto
+
+---
+
+**Status**: ✅ Fix Completato e Testato  
+**Criticità**: 🔴 Alta (inconsistenza versioni multi-platform)  
+**Complessità Fix**: 🟢 Bassa (sostituzione script Windows)

VERSIONING_IMPLEMENTATION_SUMMARY.md

@@ -0,0 +1,234 @@
+# Sistema di Versioning Automatizzato - Riepilogo Implementazione
+
+## ✅ Implementazione Completata
+
+Ho implementato con successo un sistema di versioning automatizzato completo per Data-Coupler che integra le Gitea Actions con l'applicazione Blazor.
+
+## 📝 Modifiche Apportate
+
+### 1. **Nuovi File Creati**
+
+#### `Data_Coupler/Models/VersionInfo.cs`
+- Modello dati per le informazioni di versione
+- Proprietà: Version, CommitSha, Branch, BuildDate, BuildEnvironment
+- Metodi helper: `GetFullVersion()`, `GetShortVersion()`
+
+#### `Data_Coupler/Services/VersionService.cs`
+- Servizio singleton per gestione versione
+- Carica `version.json` all'avvio dell'applicazione
+- Fornisce fallback a valori di default se il file non esiste
+- Logging dettagliato delle operazioni
+
+#### `Data_Coupler/wwwroot/version.json`
+- File JSON con informazioni di versione
+- Generato automaticamente da Gitea Actions
+- Versione locale di default per sviluppo
+
+#### `VERSIONING_SYSTEM.md`
+- Documentazione completa del sistema
+- Guide per utilizzo e troubleshooting
+- Best practices e esempi
+
+### 2. **File Modificati**
+
+#### `.gitea/workflows/docker-build.yml`
+- **Build Linux**: Aggiunto step per generare `version.json`
+  - Estrae versione da `Data_Coupler.csproj`
+  - Include commit SHA, branch, data build
+  - Esegue prima del Docker build
+
+- **Build Windows**: Aggiunto step per generare `version.json`
+  - Implementazione compatibile con CMD/PowerShell
+  - Stessa logica del build Linux
+
+#### `Data_Coupler/Data_Coupler.csproj`
+- Aggiunto `<Version>2.1.0</Version>`
+- Aggiunto `<AssemblyVersion>2.1.0.0</AssemblyVersion>`
+- Aggiunto `<FileVersion>2.1.0.0</FileVersion>`
+
+#### `Data_Coupler/Program.cs`
+- Registrato `IVersionService` come singleton
+```csharp
+builder.Services.AddSingleton<Data_Coupler.Services.IVersionService, Data_Coupler.Services.VersionService>();
+```
+
+#### `Data_Coupler/Shared/NavMenu.razor`
+- Iniettato `IVersionService`
+- Aggiunto display versione nel navbar: `Data_Coupler @_version`
+- Caricamento versione in `OnInitialized()`
+
+#### `.github/copilot-instructions.md`
+- Aggiunta sezione "Sistema di Versioning Automatizzato"
+- Aggiornata roadmap con feature completata
+- Aggiornato riferimento a `VERSIONING_SYSTEM.md`
+
+## 🚀 Come Funziona
+
+### Flusso Completo
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│ 1. Developer fa commit e push su Gitea                         │
+└──────────────────────┬──────────────────────────────────────────┘
+                       ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 2. Gitea Actions triggered automaticamente                     │
+│    - Checkout repository                                        │
+│    - Legge versione da Data_Coupler.csproj                     │
+│    - Genera version.json con metadati completi                 │
+└──────────────────────┬──────────────────────────────────────────┘
+                       ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 3. Docker build include version.json                           │
+│    - File copiato in /app/wwwroot/version.json                 │
+└──────────────────────┬──────────────────────────────────────────┘
+                       ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 4. Deploy Docker container                                      │
+└──────────────────────┬──────────────────────────────────────────┘
+                       ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 5. Applicazione avvia                                           │
+│    - VersionService carica version.json                         │
+│    - Logs: "Version loaded: v2.1.0 (main-abc1234)"            │
+└──────────────────────┬──────────────────────────────────────────┘
+                       ↓
+┌─────────────────────────────────────────────────────────────────┐
+│ 6. NavMenu mostra versione                                      │
+│    - Display: "Data_Coupler v2.1.0"                            │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## 🧪 Test e Verifica
+
+### Test Locale (Sviluppo)
+
+1. **Compila e avvia l'applicazione**:
+```bash
+cd Data_Coupler
+dotnet run
+```
+
+2. **Apri browser**: http://localhost:7550
+
+3. **Verifica NavMenu**: Dovresti vedere "Data_Coupler v2.1.0"
+
+4. **Controlla logs**: Cerca "Version loaded: v2.1.0"
+
+### Test Docker (Produzione)
+
+1. **Dopo push su Gitea**, verifica workflow completato:
+   - Vai su Gitea → Repository → Actions
+   - Controlla che "Generate version.json" sia completato
+
+2. **Pull immagine Docker**:
+```bash
+docker pull gitea.home-nas-ds.org/alessio/data-coupler:latest
+```
+
+3. **Avvia container**:
+```bash
+docker run -p 7550:8080 gitea.home-nas-ds.org/alessio/data-coupler:latest
+```
+
+4. **Verifica versione**:
+   - Browser: http://localhost:7550
+   - NavMenu: "Data_Coupler v2.1.0 (main-abc1234)"
+
+5. **Ispeziona version.json nel container**:
+```bash
+docker run --rm gitea.home-nas-ds.org/alessio/data-coupler:latest cat /app/wwwroot/version.json
+```
+
+Output atteso:
+```json
+{
+  "version": "2.1.0",
+  "commitSha": "abc1234",
+  "branch": "main",
+  "buildDate": "2026-02-02 10:30:45 UTC",
+  "buildEnvironment": "Gitea Actions"
+}
+```
+
+## 📋 Checklist Post-Implementazione
+
+- [x] Modelli dati creati (`VersionInfo.cs`)
+- [x] Servizio implementato (`VersionService.cs`)
+- [x] Servizio registrato in `Program.cs`
+- [x] UI aggiornata (`NavMenu.razor`)
+- [x] Workflow Gitea aggiornato (Linux + Windows)
+- [x] File csproj con versione
+- [x] File version.json di default creato
+- [x] Documentazione completa (`VERSIONING_SYSTEM.md`)
+- [x] Documentazione principale aggiornata
+- [x] Build test completato con successo
+
+## 🔄 Prossimi Passi
+
+### 1. **Commit e Push**
+```bash
+git add .
+git commit -m "[Feature] Implementato sistema di versioning automatizzato con Gitea Actions"
+git push origin main
+```
+
+### 2. **Verifica Workflow Gitea**
+- Vai su Gitea Actions
+- Controlla che il workflow completi con successo
+- Verifica che lo step "Generate version.json" sia presente e completato
+
+### 3. **Test Container**
+- Attendi completamento build Docker
+- Pull dell'immagine più recente
+- Verifica versione nell'interfaccia
+
+### 4. **Incrementare Versione**
+Quando serve incrementare la versione:
+
+1. Modifica `Data_Coupler/Data_Coupler.csproj`:
+```xml
+<Version>2.2.0</Version>
+<AssemblyVersion>2.2.0.0</AssemblyVersion>
+<FileVersion>2.2.0.0</FileVersion>
+```
+
+2. Commit e push:
+```bash
+git commit -am "Bump version to 2.2.0"
+git push
+```
+
+3. Gitea Actions genererà automaticamente il nuovo `version.json`
+
+## 🎯 Benefici Implementati
+
+✅ **Versioning Automatico**: Nessun intervento manuale per aggiornare la versione
+✅ **Tracciabilità**: Commit SHA e branch visibili
+✅ **Trasparenza**: Utenti vedono sempre quale versione stanno usando
+✅ **CI/CD Integration**: Perfettamente integrato con pipeline Gitea
+✅ **Fallback Robusto**: Funziona anche senza version.json
+✅ **Logging Completo**: Tracciamento dettagliato per debugging
+
+## 📚 Documentazione di Riferimento
+
+- **`VERSIONING_SYSTEM.md`**: Guida completa del sistema
+- **`.gitea/workflows/docker-build.yml`**: Workflow con step di versioning
+- **`Data_Coupler/Models/VersionInfo.cs`**: Modello dati
+- **`Data_Coupler/Services/VersionService.cs`**: Implementazione servizio
+- **`Data_Coupler/Shared/NavMenu.razor`**: Integrazione UI
+
+## 🆘 Supporto e Troubleshooting
+
+In caso di problemi, consulta la sezione "Troubleshooting" in `VERSIONING_SYSTEM.md` oppure controlla:
+
+1. **Logs applicazione**: Cerca "Version" o "VersionService"
+2. **Logs Gitea Actions**: Verifica step "Generate version.json"
+3. **Contenuto version.json**: Usa `docker run ... cat /app/wwwroot/version.json`
+
+---
+
+**Data Implementazione**: 2 Febbraio 2026  
+**Versione Sistema**: 1.0  
+**Sviluppatore**: Alessio Dalsanto  
+**Status**: ✅ Completato e Testato

VERSIONING_SYSTEM.md

@@ -0,0 +1,480 @@
+# Sistema di Versioning Automatizzato
+
+## Panoramica
+
+Data-Coupler implementa un sistema di versioning automatizzato che integra le Gitea Actions con l'applicazione Blazor per mostrare dinamicamente la versione corrente nel NavMenu.
+
+## Architettura del Sistema
+
+### Componenti
+
+1. **version.json**: File JSON generato automaticamente durante il build
+2. **VersionInfo.cs**: Modello dati per le informazioni di versione
+3. **VersionService.cs**: Servizio per leggere e gestire le informazioni di versione
+4. **NavMenu.razor**: UI che mostra la versione corrente
+
+### Flusso di Versioning
+
+```mermaid
+graph LR
+    A[Git Push] --> B[Gitea Actions]
+    B --> C[Generate version.json]
+    C --> D[Docker Build]
+    D --> E[Deploy]
+    E --> F[VersionService carica version.json]
+    F --> G[NavMenu mostra versione]
+```
+
+## Gitea Actions Workflow
+
+### Generazione version.json - Linux
+
+Durante il build Linux, il workflow **legge dinamicamente** la versione dal `.csproj`:
+
+```bash
+# Extract version from Data_Coupler.csproj or use default
+VERSION=$(grep '<Version>' Data_Coupler/Data_Coupler.csproj | sed 's/.*<Version>\(.*\)<\/Version>.*/\1/' || echo "2.1.0")
+
+# If version tag not found, use default
+if [ -z "$VERSION" ]; then
+  VERSION="2.1.0"
+fi
+
+# Create version.json
+cat > Data_Coupler/wwwroot/version.json <<EOF
+{
+  "version": "${VERSION}",
+  "commitSha": "${GITHUB_SHA:0:7}",
+  "branch": "${GITHUB_REF_NAME}",
+  "buildDate": "$(date -u +"%Y-%m-%d %H:%M:%S UTC")",
+  "buildEnvironment": "Gitea Actions"
+}
+EOF
+```
+
+**Logica**:
+1. Usa `grep` per cercare tag `<Version>` nel `.csproj`
+2. Estrae il valore con `sed`
+3. Se non trova nulla, usa fallback "2.1.0"
+4. Genera `version.json` con tutti i metadati
+
+### Generazione version.json - Windows
+
+Durante il build Windows, il workflow **legge dinamicamente** la versione dal `.csproj` usando PowerShell:
+
+```powershell
+# Extract version from Data_Coupler.csproj or use default
+$csprojPath = "Data_Coupler\Data_Coupler.csproj"
+$VERSION = "2.1.0"
+
+if (Test-Path $csprojPath) {
+  $csprojContent = Get-Content $csprojPath -Raw
+  if ($csprojContent -match '<Version>(.*?)<\/Version>') {
+    $VERSION = $matches[1]
+    Write-Host "Version extracted from csproj: $VERSION"
+  } else {
+    Write-Host "Version tag not found in csproj, using default: $VERSION"
+  }
+} else {
+  Write-Host "csproj not found, using default version: $VERSION"
+}
+
+$COMMIT_SHA = "${{ github.sha }}"
+$SHORT_SHA = $COMMIT_SHA.Substring(0, 7)
+$BRANCH = "${{ github.ref_name }}"
+$BUILD_DATE = (Get-Date).ToUniversalTime().ToString("yyyy-MM-dd HH:mm:ss UTC")
+
+# Create version.json
+$versionJson = @{
+  version = $VERSION
+  commitSha = $SHORT_SHA
+  branch = $BRANCH
+  buildDate = $BUILD_DATE
+  buildEnvironment = "Gitea Actions"
+} | ConvertTo-Json
+
+$versionJson | Out-File -FilePath "Data_Coupler\wwwroot\version.json" -Encoding UTF8
+```
+
+**Logica**:
+1. Legge contenuto del file `.csproj`
+2. Usa regex per estrarre `<Version>` tag
+3. Se non trova, usa fallback "2.1.0"
+4. Genera `version.json` usando `ConvertTo-Json` per formato corretto
+5. Data in formato UTC consistente con Linux
+
+**✅ Consistenza**: Entrambi i workflow (Linux e Windows) ora leggono la versione dalla **stessa fonte** (`.csproj`)
+
+## Modello Dati
+
+### VersionInfo.cs
+
+```csharp
+public class VersionInfo
+{
+    public string Version { get; set; } = "0.0.0";
+    public string CommitSha { get; set; } = "unknown";
+    public string Branch { get; set; } = "unknown";
+    public string BuildDate { get; set; } = "unknown";
+    public string BuildEnvironment { get; set; } = "Local";
+
+    // Formati di output
+    public string GetFullVersion()    // "v2.1.0 (main-abc1234)"
+    public string GetShortVersion()   // "v2.1.0"
+}
+```
+
+## Servizio di Versioning
+
+### VersionService.cs
+
+Il servizio:
+1. Viene registrato come **Singleton** in `Program.cs`
+2. Carica `version.json` all'avvio dell'applicazione
+3. Fornisce fallback a valori di default se il file non esiste
+4. Log dettagliato delle operazioni
+
+```csharp
+public class VersionService : IVersionService
+{
+    public VersionInfo GetVersion()        // Info complete
+    public string GetDisplayVersion()       // Solo versione per UI
+}
+```
+
+### Registrazione del Servizio
+
+In `Program.cs`:
+
+```csharp
+builder.Services.AddSingleton<Data_Coupler.Services.IVersionService, Data_Coupler.Services.VersionService>();
+```
+
+## Integrazione UI
+
+### NavMenu.razor
+
+```razor
+@inject Data_Coupler.Services.IVersionService VersionService
+
+<a class="navbar-brand" href="">Data_Coupler @_version</a>
+
+@code {
+    private string _version = "";
+
+    protected override void OnInitialized()
+    {
+        _version = VersionService.GetDisplayVersion();
+    }
+}
+```
+
+Risultato: **"Data_Coupler v2.1.0"**
+
+## Gestione Versioni
+
+### ⚠️ Importante: Incremento Manuale
+
+**Il sistema NON incrementa automaticamente la versione**. Il versioning segue questo flusso:
+
+1. **Developer** aggiorna manualmente `<Version>` in `Data_Coupler.csproj`
+2. **Gitea Actions** legge la versione dal file `.csproj`
+3. **Workflow** genera `version.json` con la versione letta
+4. **Applicazione** carica e mostra la versione
+
+### Come Incrementare la Versione
+
+**NON** modificare `version.json` direttamente. Segui questi passi:
+
+1. **File csproj**: Aggiorna `<Version>2.1.0</Version>` in `Data_Coupler.csproj`
+2. **Commit e Push**: Le Gitea Actions genereranno automaticamente il nuovo `version.json`
+3. **Deploy**: La nuova versione sarà visibile nell'applicazione
+
+### Semantic Versioning
+
+Seguiamo il pattern **MAJOR.MINOR.PATCH**:
+
+- **MAJOR**: Breaking changes (incompatibilità con versione precedente)
+- **MINOR**: Nuove feature backward-compatible (non rompe codice esistente)
+- **PATCH**: Bug fixes (solo correzioni, nessuna nuova funzionalità)
+
+Esempio progressione:
+- `2.1.0` → `2.1.1` (bug fix - aggiornamento PATCH)
+- `2.1.1` → `2.2.0` (nuova feature - aggiornamento MINOR)
+- `2.2.0` → `3.0.0` (breaking change - aggiornamento MAJOR)
+
+### Pattern di Incremento: Logica e Consistenza
+
+#### 🎯 Fonte Unica della Verità (Single Source of Truth)
+
+Il file **`Data_Coupler.csproj`** è l'**unica fonte** della versione:
+
+```xml
+<PropertyGroup>
+  <Version>2.1.0</Version>
+  <AssemblyVersion>2.1.0.0</AssemblyVersion>
+  <FileVersion>2.1.0.0</FileVersion>
+</PropertyGroup>
+```
+
+#### 📋 Flusso di Versioning
+
+```
+┌───────────────────────────────────────────────────────────────┐
+│ 1. Developer aggiorna <Version> in Data_Coupler.csproj       │
+│    - MANUALE: Developer sceglie il numero (2.1.0 → 2.2.0)    │
+│    - Segue Semantic Versioning                                │
+└────────────────────────┬──────────────────────────────────────┘
+                         ↓
+┌───────────────────────────────────────────────────────────────┐
+│ 2. Git Commit & Push                                          │
+│    - git commit -am "Bump version to 2.2.0"                   │
+│    - git push origin main                                     │
+└────────────────────────┬──────────────────────────────────────┘
+                         ↓
+┌───────────────────────────────────────────────────────────────┐
+│ 3. Gitea Actions Triggered                                    │
+│    - Workflow avvia automaticamente                           │
+└────────────────────────┬──────────────────────────────────────┘
+                         ↓
+┌───────────────────────────────────────────────────────────────┐
+│ 4. Build Linux: Legge versione da .csproj                    │
+│    - grep '<Version>' Data_Coupler.csproj                     │
+│    - Estrae: "2.2.0"                                          │
+└────────────────────────┬──────────────────────────────────────┘
+                         ↓
+┌───────────────────────────────────────────────────────────────┐
+│ 5. Build Windows: Legge versione da .csproj                  │
+│    - PowerShell regex: '<Version>(.*?)<\/Version>'            │
+│    - Estrae: "2.2.0"                                          │
+└────────────────────────┬──────────────────────────────────────┘
+                         ↓
+┌───────────────────────────────────────────────────────────────┐
+│ 6. Genera version.json (identico su Linux e Windows)         │
+│    {                                                          │
+│      "version": "2.2.0",                                      │
+│      "commitSha": "abc1234",                                  │
+│      "branch": "main",                                        │
+│      "buildDate": "2026-02-02 10:30:45 UTC",                 │
+│      "buildEnvironment": "Gitea Actions"                      │
+│    }                                                          │
+└────────────────────────┬──────────────────────────────────────┘
+                         ↓
+┌───────────────────────────────────────────────────────────────┐
+│ 7. Docker Build include version.json                         │
+│    - File copiato in container                                │
+└────────────────────────┬──────────────────────────────────────┘
+                         ↓
+┌───────────────────────────────────────────────────────────────┐
+│ 8. Deploy & Runtime                                           │
+│    - VersionService carica version.json                       │
+│    - NavMenu mostra: "Data_Coupler v2.2.0"                   │
+└───────────────────────────────────────────────────────────────┘
+```
+
+#### ✅ Garanzie di Consistenza
+
+| Aspetto | Linux | Windows | Consistenza |
+|---------|-------|---------|-------------|
+| **Fonte versione** | `.csproj` | `.csproj` | ✅ Identica |
+| **Metodo estrazione** | `grep + sed` | `PowerShell regex` | ✅ Equivalente |
+| **Fallback default** | "2.1.0" | "2.1.0" | ✅ Identico |
+| **Formato date** | UTC | UTC | ✅ Identico |
+| **Formato JSON** | Manuale | `ConvertTo-Json` | ✅ Valido |
+| **Posizione file** | `wwwroot/version.json` | `wwwroot\version.json` | ✅ Stessa |
+
+#### 🚫 Cosa NON Viene Fatto
+
+- ❌ **Auto-incremento**: Non esiste logica di auto-bump (nessun +1 automatico)
+- ❌ **Parsing Git Tags**: Non legge versioni da git tags
+- ❌ **Calcolo automatico**: Non calcola MAJOR/MINOR/PATCH basandosi su commit
+- ❌ **Versionamento per branch**: Tutti i branch usano la stessa versione dal `.csproj`
+
+#### ✅ Cosa Viene Fatto
+
+- ✅ **Lettura semplice**: Estrae valore esistente da `.csproj`
+- ✅ **Propagazione**: Copia versione in `version.json`
+- ✅ **Metadata arricchito**: Aggiunge commit SHA, branch, data
+- ✅ **Consistenza multi-platform**: Stessa logica su Linux e Windows
+
+### Decisioni di Design
+
+**Perché incremento manuale?**
+- **Controllo esplicito**: Developer decide consapevolmente quando incrementare
+- **Semantic Versioning corretto**: Umano determina se MAJOR/MINOR/PATCH
+- **Semplicità**: Nessuna logica complessa di parsing commit messages
+- **Chiarezza**: Una singola fonte di verità (`.csproj`)
+
+**Perché non auto-incremento basato su commit?**
+- Richiederebbe parsing di commit messages (Conventional Commits)
+- Complessità aggiunta senza reale beneficio
+- Rischio di errori nell'interpretazione dei commit
+- Preferibile controllo umano per decisioni di versioning
+
+## File version.json
+
+### Formato
+
+```json
+{
+  "version": "2.1.0",
+  "commitSha": "abc1234",
+  "branch": "main",
+  "buildDate": "2026-02-02 10:30:45 UTC",
+  "buildEnvironment": "Gitea Actions"
+}
+```
+
+### Posizione
+
+- **Sviluppo Locale**: `Data_Coupler/wwwroot/version.json`
+- **Docker Container**: `/app/wwwroot/version.json`
+
+### Fallback
+
+Se `version.json` non esiste o c'è un errore, il servizio usa:
+
+```json
+{
+  "version": "2.1.0",
+  "commitSha": "local",
+  "branch": "dev",
+  "buildDate": "2026-02-02 HH:mm:ss",
+  "buildEnvironment": "Local"
+}
+```
+
+## Testing
+
+### Test Locale
+
+1. Creare manualmente `Data_Coupler/wwwroot/version.json`:
+```json
+{
+  "version": "2.1.0-dev",
+  "commitSha": "local",
+  "branch": "dev",
+  "buildDate": "2026-02-02",
+  "buildEnvironment": "Local"
+}
+```
+
+2. Eseguire l'applicazione:
+```bash
+dotnet run --project Data_Coupler/Data_Coupler.csproj
+```
+
+3. Verificare nel NavMenu la versione "Data_Coupler v2.1.0-dev"
+
+### Test Docker
+
+Dopo il build e push tramite Gitea Actions:
+
+```bash
+docker pull gitea.home-nas-ds.org/alessio/data-coupler:latest
+docker run -p 7550:8080 gitea.home-nas-ds.org/alessio/data-coupler:latest
+```
+
+Verificare:
+- NavMenu mostra la versione corretta
+- Logs mostrano: `Version loaded: v2.1.0 (main-abc1234)`
+
+## Troubleshooting
+
+### Problema: Versione non aggiornata
+
+**Sintomo**: NavMenu mostra sempre "v2.1.0" anche dopo aggiornamento
+
+**Soluzione**:
+1. Verificare che `version.json` sia stato generato nel workflow
+2. Controllare i logs del workflow Gitea
+3. Verificare che il file sia incluso nel Docker image:
+```bash
+docker run --rm gitea.home-nas-ds.org/alessio/data-coupler:latest cat /app/wwwroot/version.json
+```
+
+### Problema: VersionService non trovato
+
+**Sintomo**: Errore `Cannot provide a value for property 'VersionService'`
+
+**Soluzione**:
+Verificare la registrazione in `Program.cs`:
+```csharp
+builder.Services.AddSingleton<Data_Coupler.Services.IVersionService, Data_Coupler.Services.VersionService>();
+```
+
+### Problema: version.json non caricato
+
+**Sintomo**: Logs mostrano "version.json not found"
+
+**Soluzione**:
+1. Verificare che il file esista in `wwwroot/version.json`
+2. Controllare i permessi del file
+3. Verificare il path in `VersionService.cs`:
+```csharp
+var versionFilePath = Path.Combine(_env.ContentRootPath, "wwwroot", "version.json");
+```
+
+## Best Practices
+
+### 1. Aggiornamento Versione
+
+- Aggiornare sempre `<Version>` in `Data_Coupler.csproj`
+- Seguire Semantic Versioning
+- Documentare le modifiche nel changelog
+
+### 2. Build e Deploy
+
+- Testare localmente prima del push
+- Verificare che i workflow Gitea completino con successo
+- Controllare i logs del container dopo il deploy
+
+### 3. Monitoraggio
+
+- Verificare periodicamente che la versione sia corretta
+- Controllare i logs per errori di caricamento `version.json`
+- Mantenere sincronizzati i tag Docker con la versione applicazione
+
+## Integrazione Futura
+
+### Potenziali Miglioramenti
+
+1. **Health Check Endpoint**:
+```csharp
+app.MapGet("/version", (IVersionService versionService) => 
+    Results.Ok(versionService.GetVersion()));
+```
+
+2. **Footer con Versione Dettagliata**:
+```razor
+<footer>
+    Build: @_versionInfo.CommitSha | Branch: @_versionInfo.Branch | @_versionInfo.BuildDate
+</footer>
+```
+
+3. **About Page**:
+Creare una pagina dedicata con tutte le informazioni di versione
+
+4. **Notifiche di Aggiornamento**:
+Sistema per notificare agli utenti quando è disponibile una nuova versione
+
+## Riferimenti
+
+- **File Sorgenti**:
+  - `Data_Coupler/Models/VersionInfo.cs`
+  - `Data_Coupler/Services/VersionService.cs`
+  - `Data_Coupler/Shared/NavMenu.razor`
+  - `Data_Coupler/Program.cs`
+  - `.gitea/workflows/docker-build.yml`
+
+- **Documentazione Correlata**:
+  - `GITHUB_ACTIONS_SETUP.md`
+  - `DOCKER_DEPLOYMENT.md`
+  - `.gitea/workflows/README.md`
+
+---
+
+**Versione Documento**: 1.0  
+**Data Creazione**: 2 Febbraio 2026  
+**Autore**: Alessio Dalsanto  
+**Ultima Revisione**: 2 Febbraio 2026