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/README.md

@@ -0,0 +1,287 @@
+# Gitea Actions per Data-Coupler
+
+## 📋 Panoramica
+
+Questo repository utilizza **Gitea Actions** per automatizzare la build e la pubblicazione delle immagini Docker del progetto Data-Coupler.
+
+## 🔧 Configurazione
+
+### Prerequisiti
+
+Per utilizzare Gitea Actions su questo repository, è necessario:
+
+1. **Gitea Account**: Avere un account su Gitea (gitea.com o istanza self-hosted)
+2. **Repository Settings**: Abilitare Gitea Actions nelle impostazioni del repository
+3. **Container Registry**: Avere accesso al Gitea Container Registry
+4. **Secret Configuration**: Configurare il secret `GITEA_TOKEN`
+
+### Configurazione del Secret REGISTRY_TOKEN
+
+Il workflow richiede un token di accesso per pubblicare le immagini Docker sul registry:
+
+1. Vai su **Settings → Secrets** nel repository Gitea
+2. Crea un nuovo secret chiamato `REGISTRY_TOKEN`
+3. Il valore deve essere un Personal Access Token con i seguenti permessi:
+   - `write:packages` - Per pubblicare container images
+   - `read:packages` - Per leggere images esistenti
+
+#### Come Creare un Personal Access Token su Gitea
+
+1. Vai su **Settings → Applications** nel tuo profilo Gitea
+2. Clicca su **Generate New Token**
+3. Nome del token: `Data-Coupler Docker Build`
+4. Seleziona i seguenti scopes:
+   - `write:packages`
+   - `read:packages`
+5. Clicca su **Generate Token**
+6. Copia il token generato (sarà mostrato solo una volta)
+
+### Configurazione del Repository Path
+
+Nel file `.gitea/workflows/docker-build.yml`, verifica le variabili di registry:
+
+```yaml
+env:
+  REGISTRY: gitea.home-nas-ds.org  # La tua istanza Gitea self-hosted
+  IMAGE_NAME: alessio/data-coupler  # username/repo sulla tua istanza
+```
+
+**Importante**: 
+- `REGISTRY` deve puntare alla tua istanza Gitea con Container Registry abilitato
+- `IMAGE_NAME` deve essere nel formato `username/repo` della tua istanza
+- Assicurati che il Container Registry sia abilitato su Gitea (Settings → Packages)
+
+## 🚀 Workflow
+
+### Docker Build Workflow
+
+**File**: `.gitea/workflows/docker-build.yml`
+
+#### Trigger Events
+
+Il workflow si attiva automaticamente su:
+- **Push** sui branch: `main`, `development`, `staging`
+- **Manual dispatch** tramite interfaccia web
+
+#### Jobs
+
+Il workflow è composto da 3 job principali:
+
+##### 1. `build-linux` - Build Immagine Linux
+- **Runner**: `ubuntu-latest`
+- **Dockerfile**: `./Dockerfile`
+- **Platform**: `linux/amd64`
+- **Tags generati**:
+  - `latest` (per branch `main` e `development`)
+  - `development-latest` (per branch `development`)
+  - `staging-latest` (per branch `staging`)
+  - `<branch>-<sha>` (per ogni commit)
+  - `<branch>-<timestamp>` (con data/ora)
+
+##### 2. `build-windows` - Build Immagine Windows
+- **Runner**: `windows-2022`
+- **Dockerfile**: `./Dockerfile.windows`
+- **Platform**: Windows Server 2022
+- **Tags generati**: Come Linux ma con suffisso `-windows`
+
+##### 3. `create-manifest` - Multi-Platform Manifest
+- **Runner**: `ubuntu-latest`
+- **Dipendenze**: `build-linux`, `build-windows`
+- Crea manifest multi-piattaforma che combinano le immagini Linux e Windows
+
+### Strategia di Tagging
+
+#### Branch `main`
+- `latest` - Tag condiviso per versione stabile
+- `latest-windows` - Versione Windows
+- `main-<sha>` - Tag specifico per commit
+- `main-<timestamp>` - Tag con timestamp
+
+#### Branch `development`
+- `latest` - Tag condiviso per ultime funzionalità
+- `development-latest` - Tag specifico per development
+- `latest-windows` / `development-latest-windows` - Versioni Windows
+- `development-<sha>` - Tag specifico per commit
+- `development-<timestamp>` - Tag con timestamp
+
+#### Branch `staging`
+- `staging-latest` - Tag per ambiente di staging
+- `staging-latest-windows` - Versione Windows
+- `staging-<sha>` - Tag specifico per commit
+- `staging-<timestamp>` - Tag con timestamp
+
+## 📦 Utilizzo delle Immagini
+
+### Pull delle Immagini
+
+#### Da Gitea Container Registry
+
+```bash
+# Ultima versione stabile (main/development)
+docker pull gitea.home-nas-ds.org/alessio/data-coupler:latest
+
+# Versione development specifica
+docker pull gitea.home-nas-ds.org/alessio/data-coupler:development-latest
+
+# Versione staging
+docker pull gitea.home-nas-ds.org/alessio/data-coupler:staging-latest
+
+# Versione Windows
+docker pull gitea.home-nas-ds.org/alessio/data-coupler:latest-windows
+```
+
+### Docker Compose
+
+Modifica il `docker-compose.yml` per usare le immagini Gitea:
+
+```yaml
+services:
+  data-coupler:
+    image: gitea.home-nas-ds.org/alessio/data-coupler:latest
+    # ... resto della configurazione
+```
+
+## 🔍 Monitoraggio
+
+### Visualizzare lo Stato dei Workflow
+
+1. Vai nella tab **Actions** del repository Gitea
+2. Seleziona il workflow **Build and Push Docker Images**
+3. Visualizza i dettagli di ogni esecuzione
+
+### Log e Debug
+
+- I log di ogni job sono disponibili nell'interfaccia Gitea Actions
+- Per debug dettagliato, attiva il manual dispatch con opzione `force_build`
+
+## 🔄 Differenze con GitHub Actions
+
+### Principali Differenze
+
+1. **Context Variables**:
+   - Gitea Actions usa le **stesse variabili** di GitHub Actions: `github.*`
+   - Esempio: `github.ref`, `github.sha`, `github.actor`
+   - **Nota**: Anche se il servizio è Gitea, le variabili mantengono il prefisso `github` per compatibilità
+
+2. **Username**:
+   - Nel workflow è hardcoded come `alessio` per semplicità
+   - Puoi usare `${{ github.actor }}` se preferisci (utente che ha triggerato il workflow)
+
+3. **Registry**:
+   - GitHub: `ghcr.io` → Gitea: `gitea.home-nas-ds.org` (istanza self-hosted)
+   - Gitea non ha un registry pubblico centralizzato come GitHub
+
+4. **Secret Name**:
+   - GitHub: `GITHUB_TOKEN` (automatico) → Gitea: `REGISTRY_TOKEN` (configurato manualmente)
+   - **Nota**: Il secret non può iniziare con `GITEA_` per limitazioni di Gitea
+
+4. **Attestation**:
+   - Il job di attestation non è presente su Gitea (feature GitHub specifica)
+
+### Compatibilità
+
+Gitea Actions è compatibile con la maggior parte delle GitHub Actions disponibili su GitHub Marketplace, incluse:
+- `actions/checkout@v4`
+- `docker/setup-buildx-action@v3`
+- `docker/login-action@v3`
+- `docker/build-push-action@v5`
+- `docker/metadata-action@v5`
+
+## 🛠️ Troubleshooting
+
+### Verificare che il Container Registry sia Abilitato
+
+Prima di tutto, verifica che il Container Registry sia abilitato sulla tua istanza Gitea:
+
+1. **Controlla la configurazione Gitea** (`app.ini`):
+   ```ini
+   [packages]
+   ENABLED = true
+   ```
+
+2. **Verifica accesso al registry**:
+   ```bash
+   curl https://gitea.home-nas-ds.org/v2/
+   # Dovrebbe rispondere con status 401 (richiede autenticazione)
+   # Se ottieni 404, il registry non è abilitato
+   ```
+
+3. **Test autenticazione**:
+   ```bash
+   echo "YOUR_TOKEN" | docker login gitea.home-nas-ds.org -u alessio --password-stdin
+   ```
+
+### Errore di Autenticazione
+
+Se ottieni errori di autenticazione:
+1. Verifica che il secret `REGISTRY_TOKEN` sia configurato correttamente
+2. Assicurati che il token abbia i permessi `write:packages`
+3. Controlla che il token non sia scaduto
+
+### Build Fallita
+
+Se la build fallisce:
+1. Controlla i log del job specifico
+2. Verifica che i Dockerfile siano presenti e corretti
+3. Assicurati che le dipendenze NuGet siano accessibili
+
+### Immagini Non Pubblicate
+
+Se le immagini non vengono pubblicate:
+1. Verifica che `IMAGE_NAME` sia corretto
+2. Controlla che il registry sia accessibile
+3. Verifica i permessi del token
+
+## 📚 Risorse
+
+- [Gitea Actions Documentation](https://docs.gitea.io/en-us/actions/)
+- [GitHub Actions Compatibility](https://docs.gitea.io/en-us/usage/actions/comparison/)
+- [Docker Build Push Action](https://github.com/docker/build-push-action)
+
+## 📝 Note
+
+- **Registry Self-Hosted**: Questo workflow è configurato per usare un'istanza Gitea self-hosted (`gitea.home-nas-ds.org`)
+- **Container Registry**: Assicurati che il Container Registry sia abilitato nella tua istanza Gitea (Settings → Packages)
+- **Accesso Pubblico/Privato**: Le immagini sono private per default; configura le impostazioni del package per renderle pubbliche se necessario
+- **Esecuzione Manuale**: Il workflow supporta anche l'esecuzione manuale tramite `workflow_dispatch`
+- **Manifest Multi-Platform**: I manifest multi-platform permettono di usare lo stesso tag per Linux e Windows
+- **Alternative Registry**: Se non hai un'istanza Gitea con registry, puoi configurare Docker Hub o altri registry modificando la variabile `REGISTRY`
+
+### 🐳 Configurazione Registry Alternativi
+
+Se il Container Registry di Gitea non è disponibile, puoi usare alternative:
+
+#### Docker Hub
+```yaml
+env:
+  REGISTRY: docker.io
+  IMAGE_NAME: username/data-coupler
+
+# Nel login step:
+- name: Log in to Docker Hub
+  uses: docker/login-action@v3
+  with:
+    username: ${{ secrets.DOCKER_USERNAME }}
+    password: ${{ secrets.DOCKER_TOKEN }}
+```
+
+#### GitHub Container Registry (come fallback)
+```yaml
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: alessio/data-coupler
+
+# Nel login step:
+- name: Log in to GHCR
+  uses: docker/login-action@v3
+  with:
+    registry: ghcr.io
+    username: ${{ github.actor }}
+    password: ${{ secrets.GITHUB_TOKEN }}
+```
+
+---
+
+**Versione**: 1.0  
+**Ultimo Aggiornamento**: 24 Gennaio 2026  
+**Maintainer**: Alessio Dalsanto

.gitea/workflows/docker-build.yml

@@ -0,0 +1,334 @@
+name: Build and Push Docker Images
+
+on:
+  push:
+    branches:
+      - main
+      - staging
+  workflow_dispatch:
+    inputs:
+      force_build:
+        description: 'Force build even without code changes'
+        required: false
+        default: false
+        type: boolean
+
+env:
+  # Gitea Container Registry (self-hosted instance)
+  REGISTRY: gitea.home-nas-ds.org
+  # Repository path (format: owner/repo)
+  IMAGE_NAME: alessio/data-coupler
+
+jobs:
+  build-linux:
+    name: Build Linux Container
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      
+    steps:
+      - 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
+
+      - name: Debug - Check registry access
+        run: |
+          echo "Testing registry access..."
+          curl -v https://gitea.home-nas-ds.org/v2/ || echo "Registry not accessible"
+          echo "Registry: ${{ env.REGISTRY }}"
+          echo "Image: ${{ env.IMAGE_NAME }}"
+        continue-on-error: true
+
+      - name: Debug - Verify secret is configured
+        run: |
+          if [ -z "${{ secrets.REGISTRY_TOKEN }}" ]; then
+            echo "::error::REGISTRY_TOKEN secret is not configured or is empty!"
+            exit 1
+          else
+            echo "REGISTRY_TOKEN secret is configured (length: ${#REGISTRY_TOKEN})"
+          fi
+        env:
+          REGISTRY_TOKEN: ${{ secrets.REGISTRY_TOKEN }}
+
+      - name: Log in to Gitea Container Registry
+        run: |
+          echo "${{ secrets.REGISTRY_TOKEN }}" | docker login ${{ env.REGISTRY }} -u alessio --password-stdin
+        shell: bash
+
+      - name: Extract metadata for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            # Tag based on branch - latest only for main
+            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }}
+            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
+            type=raw,value={{branch}}-{{date 'YYYYMMDD-HHmmss'}}
+          flavor: |
+            latest=false
+
+      - name: Build and push Linux Docker image
+        id: build
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          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
+    runs-on: windows
+    permissions:
+      contents: read
+      packages: write
+      
+    steps:
+      - name: Checkout repository with Git
+        run: |
+          git clone --depth 1 --branch ${{ github.ref_name }} https://alessio:%REGISTRY_TOKEN%@gitea.home-nas-ds.org/${{ github.repository }}.git .
+          if not exist Dockerfile.windows (
+            echo ERROR: Dockerfile.windows not found
+            exit /b 1
+          )
+          echo SUCCESS: Repository cloned
+        env:
+          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:
+          cd
+          echo.
+          echo Dockerfiles found:
+          dir Dockerfile* /B 2>nul || echo No Dockerfiles found
+        shell: cmd
+        continue-on-error: true
+
+      - name: Debug - Verify secret
+        run: |
+          if "${{ secrets.REGISTRY_TOKEN }}"=="" (
+            echo ERROR: REGISTRY_TOKEN not configured!
+            exit /b 1
+          ) else (
+            echo REGISTRY_TOKEN is configured
+          )
+        shell: cmd
+
+      - name: Log in to Gitea Container Registry
+        run: echo ${{ secrets.REGISTRY_TOKEN }} | docker login ${{ env.REGISTRY }} -u alessio --password-stdin
+        shell: cmd
+
+      - name: Build and push Windows Docker image
+        run: |
+          set IMAGE_LOWER=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          set BRANCH=${{ github.ref_name }}
+          set SHA=${{ github.sha }}
+          set SHORT_SHA=%SHA:~0,7%
+          
+          REM Determine tags based on branch
+          set TAGS=
+          if "%BRANCH%"=="main" (
+            set TAGS=%IMAGE_LOWER%:latest-windows
+            set TAGS=%TAGS% %IMAGE_LOWER%:main-windows-%SHORT_SHA%
+          )
+          if "%BRANCH%"=="development" (
+            set TAGS=%IMAGE_LOWER%:latest-windows
+            set TAGS=%TAGS% %IMAGE_LOWER%:development-latest-windows
+            set TAGS=%TAGS% %IMAGE_LOWER%:development-windows-%SHORT_SHA%
+          )
+          if "%BRANCH%"=="staging" (
+            set TAGS=%IMAGE_LOWER%:staging-latest-windows
+            set TAGS=%TAGS% %IMAGE_LOWER%:staging-windows-%SHORT_SHA%
+          )
+          
+          echo Building Windows Docker image...
+          docker build -t temp-windows -f Dockerfile.windows .
+          if errorlevel 1 (
+            echo Build failed!
+            exit /b 1
+          )
+          
+          echo Tagging and pushing images...
+          for %%t in (%TAGS%) do (
+            echo Tagging: %%t
+            docker tag temp-windows %%t
+            echo Pushing: %%t
+            docker push %%t
+          )
+          
+          echo Cleaning up temporary image...
+          docker rmi temp-windows
+          
+          echo Windows build completed successfully!
+        shell: cmd
+
+  create-manifest:
+    name: Create Multi-Platform Manifest
+    runs-on: ubuntu-latest
+    needs: [build-linux, build-windows]
+    permissions:
+      contents: read
+      packages: write
+      
+    steps:
+      - name: Log in to Gitea Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: alessio
+          password: ${{ secrets.REGISTRY_TOKEN }}
+
+      - name: Create and push manifest for main branch
+        if: github.ref == 'refs/heads/main'
+        run: |
+          IMAGE_LOWER=$(echo "${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}" | tr '[:upper:]' '[:lower:]')
+          docker buildx imagetools create -t ${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}:development-latest \
+            ${IMAGE_LOWER}:development-latest-linux \
+            ${IMAGE_LOWER}:development-latest-windows
+
+      - name: Create and push manifest for dev branch
+        if: github.ref == 'refs/heads/dev'
+        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-linux \
+            ${IMAGE_LOWER}:dev-latest-windows
+
+      - name: Create and push manifest for staging branch
+        if: github.ref == 'refs/heads/staging'
+        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-linux \
+            ${IMAGE_LOWER}:staging-latest-windows

.github/copilot-instructions.md

@@ -0,0 +1,535 @@
+# Data-Coupler - GitHub Copilot Instructions
+
+## 📋 Panoramica del Progetto
+
+**Data-Coupler** è una soluzione enterprise di integrazione dati sviluppata in .NET 9.0 con architettura Blazor Server. Il sistema facilita il trasferimento e la sincronizzazione di dati tra diverse tipologie di sorgenti: database relazionali, REST API, file Excel/CSV con funzionalità avanzate di mapping, scheduling e gestione associazioni.
+
+## 🏗️ Architettura del Sistema
+
+### Progetti Principali
+
+1. **CredentialManager** - Libreria per gestione sicura delle credenziali
+   - Crittografia dei dati sensibili con Data Protection API
+   - Persistenza su database SQLite
+   - Supporto per credenziali database e REST API
+   - Gestione profili Data Coupler e schedulazioni
+
+2. **DataConnection** - Libreria per connessioni dati
+   - **Database supportati**: SQL Server, MySQL, PostgreSQL, Oracle, SQLite, IBM DB2, SAP HANA
+   - **REST API**: Generic REST, Salesforce, SAP Business One Service Layer
+   - Factory pattern per gestione provider
+   - Operazioni batch e parallel processing
+
+3. **Data_Coupler** - Applicazione Blazor Server
+   - Interfaccia web per gestione credenziali e profili
+   - Sistema di trasferimento dati con mapping intelligente
+   - Schedulazione avanzata con background services
+   - Sistema di backup e ripristino completo
+
+4. **Components** - Libreria componenti UI riutilizzabili
+   - Componenti Blazor per gestione profili
+   - Selettori e editor configurazioni
+   - UI responsive con Bootstrap 5
+
+## 🎯 Feature Implementate
+
+### 1. Gestione Credenziali Sicura
+
+#### Caratteristiche:
+- **Crittografia**: Password e chiavi API crittografate con `IDataProtectionProvider`
+- **Multi-piattaforma**: Supporto per database eterogenei e REST API
+- **Test Connessioni**: Validazione credenziali prima del salvataggio
+- **CRUD Completo**: Interfaccia web per gestione completa
+
+#### File Chiave:
+- `CredentialManager/Services/ICredentialService.cs`
+- `CredentialManager/Services/EncryptionService.cs`
+- `Data_Coupler/Pages/CredentialManagement.razor`
+
+### 2. Sistema di Profili Data Coupler
+
+#### Caratteristiche:
+- **Profili Riutilizzabili**: Configurazioni salvate per trasferimenti ricorrenti
+- **Mapping Campi**: Sistema avanzato di mappatura tra sorgente e destinazione
+- **Sorgenti Multiple**: Database, REST API, File (Excel/CSV)
+- **Gestione Completa**: CRUD con validazione e test
+
+#### Componenti:
+- **Sorgente**: Tipo (Database/REST/File), credenziale, tabella/endpoint/percorso file
+- **Destinazione**: Tipo, credenziale, tabella/endpoint
+- **Mapping**: Corrispondenza campi sorgente → destinazione
+- **Chiave Sorgente**: Campo identificativo univoco per tracking
+
+#### File Chiave:
+- `CredentialManager/Models/DataCouplerProfile.cs`
+- `CredentialManager/Services/DataCouplerProfileService.cs`
+- `Data_Coupler/Pages/ProfilesManagement.razor`
+
+### 3. Sistema di Associazioni Record (Key Associations)
+
+#### Caratteristiche:
+- **Tracciamento ID**: Memorizza relazione tra chiavi sorgente e ID destinazione
+- **Prevenzione Duplicati**: Verifica esistenza prima di creare nuovi record
+- **Pre-Discovery**: Cerca record esistenti nella destinazione prima della creazione
+- **Hash Comparison**: Rileva modifiche dati tramite hash SHA256
+- **Validazione Intelligente**: Verifica esistenza ID destinazione, cleanup automatico
+
+#### Flusso Operativo:
+1. Estrazione record da sorgente
+2. Verifica associazione esistente in locale
+3. **PRE-DISCOVERY**: Se non esiste, cerca nella destinazione tramite chiave
+4. Se trovato → Crea associazione + Aggiorna record
+5. Se non trovato → Crea nuovo record + Associazione
+6. Calcola hash dati per tracking modifiche future
+
+#### File Chiave:
+- `CredentialManager/Models/KeyAssociation.cs`
+- `CredentialManager/Services/KeyAssociationService.cs`
+- `Data_Coupler/Pages/KeyAssociations.razor`
+- `Data_Coupler/Services/AssociationService.cs`
+
+#### Gestione Avanzata:
+- **Pulizia Selettiva**: Elimina associazioni per sorgente/destinazione specifica
+- **Pulizia Totale**: Reset completo sistema associazioni
+- **Validazione**: Trova e pulisce associazioni con ID non più validi
+- **Export/Import**: CSV per backup e migrazione dati
+
+### 4. Trasferimento Dati Avanzato
+
+#### Caratteristiche Standard:
+- **Mapping Automatico**: Trasformazione campi sorgente → destinazione
+- **Batch Processing**: Elaborazione ottimizzata per grandi volumi
+- **Error Handling**: Gestione errori robusta con retry logic
+- **Logging Dettagliato**: Tracciamento completo operazioni
+
+#### Salesforce Composite API:
+- **Batch Operations**: Fino a 25 operazioni per request (limite Salesforce)
+- **Parallel Processing**: Elaborazione parallela batch multipli
+- **Performance**: 10-25x più veloce per grandi dataset
+- **Riduzione API Calls**: 60-90% in meno chiamate
+
+#### Metodi Batch Implementati:
+- `BatchExecuteQueriesAsync`: Esecuzione parallela multiple query SOQL
+- `BatchFindEntitiesByKeysAsync`: Ricerca batch entità con diverse chiavi
+- `BatchGetEntitiesByIdsAsync`: Recupero batch tramite ID (max 200 per query)
+- `ExtractAllEntitiesAsync`: Estrazione completa con paginazione automatica
+- `ExtractEntitiesParallelAsync`: Estrazione parallela con deduplicazione
+- `ExtractLargeDatasetAsync`: Estrattore intelligente con auto-detect strategia
+- `ExtractRecentlyModifiedAsync`: Sincronizzazione incrementale
+
+#### File Chiave:
+- `Data_Coupler/Pages/DataCoupler.razor.cs`
+- `DataConnection/REST/Implementations/SalesforceServiceClient.cs`
+- `Data_Coupler/Services/ScheduledProfileExecutionService.cs`
+
+### 5. Sistema di Schedulazione Avanzata
+
+#### Tipi di Schedulazione:
+1. **Una Volta (Once)**: Esecuzione singola a data/ora specifica
+2. **Giornaliera (Daily)**: Ogni giorno a orario specifico
+3. **Settimanale (Weekly)**: Ogni settimana in giorno specifico
+4. **Mensile (Monthly)**: Ogni mese in giorno specifico
+5. **A Intervalli (Interval)**: Ricorrente ogni N unità di tempo
+   - Secondi, Minuti, Ore, Giorni, Settimane, Mesi
+   - Esempio: Ogni 5 minuti, ogni 2 ore, ogni 30 secondi
+
+#### Componenti Sistema:
+- **ProfileSchedule**: Modello dati schedulazione
+- **ScheduledExecutionBackgroundService**: Background service per esecuzione automatica
+- **ScheduledProfileExecutionService**: Logica completa trasferimento schedulato
+- **ProfileScheduleService**: CRUD e gestione schedule
+
+#### Funzionalità:
+- **Esecuzione Automatica**: Background service sempre attivo
+- **Gestione Stato**: Tracciamento esecuzioni (success, failed, running)
+- **Storico Esecuzioni**: Log completo con timestamp, record processati, errori
+- **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`
+- `CredentialManager/Services/ProfileScheduleService.cs`
+- `Data_Coupler/BackgroundServices/ScheduledExecutionBackgroundService.cs`
+- `Data_Coupler/Pages/Scheduling.razor`
+- `Data_Coupler/Pages/SchedulingHistory.razor`
+
+### 6. Sistema di Backup e Ripristino
+
+#### Funzionalità Export:
+- **Configurazione Flessibile**: Export selettivo per componente
+- **Componenti Supportati**:
+  - Profili Data Coupler
+  - Credenziali (senza dati sensibili)
+  - Associazioni Chiavi
+  - Schedulazioni
+- **Formato JSON**: Leggibile e versionato
+- **Metadati**: Timestamp, utente, descrizione, componenti inclusi
+
+#### Funzionalità Import:
+- **Validazione Rigorosa**: Controllo formato, versione, integrità dati
+- **Modalità Ripristino**:
+  - **Overwrite**: Sostituisce dati esistenti
+  - **Merge**: Integra con dati esistenti
+  - **Preview**: Mostra anteprima senza eseguire
+- **Transazioni Sicure**: Rollback automatico in caso di errori
+
+#### Sicurezza:
+- **Esclusione Dati Sensibili**: Password e API keys non inclusi in backup
+- **Crittografia Opzionale**: Backup crittografati per sicurezza extra
+- **Audit Logging**: Tracciamento completo operazioni backup/restore
+
+#### File Chiave:
+- `Data_Coupler/Services/BackupService.cs`
+- `Data_Coupler/Models/BackupModels.cs`
+- `Data_Coupler/Pages/SettingsPage.razor`
+
+### 7. Sincronizzazione Eliminazioni (Deletion Sync)
+
+#### Caratteristiche:
+- **Rilevamento Eliminazioni**: Identifica record eliminati da sorgente
+- **Sincronizzazione Automatica**: Elimina corrispondenti in destinazione
+- **Gestione Associazioni**: Aggiorna/elimina associazioni correlate
+- **Modalità Sicura**: Preview eliminazioni prima dell'esecuzione
+- **Logging Completo**: Traccia tutte le operazioni di eliminazione
+- **Configurazione Granulare**:
+  - **Disabilitata** completamente nei trasferimenti manuali (DataCoupler.razor)
+  - **Configurabile** nelle schedulazioni tramite flag `EnableDeletionSync`
+  - **Default: false** per massima sicurezza
+  - Warning esplicito nell'UI per operazioni critiche
+
+#### Sicurezza:
+- La funzionalità è **disabilitata di default** per evitare eliminazioni accidentali
+- Disponibile **solo per le schedulazioni** con configurazione esplicita
+- L'utente deve attivamente abilitare la funzione con piena consapevolezza
+- Logging completo di tutte le operazioni di eliminazione per audit trail
+
+#### File Chiave:
+- `Data_Coupler/Services/DeletionSyncService.cs`
+- `Data_Coupler/Services/ScheduledProfileExecutionService.cs`
+- `CredentialManager/Models/ProfileSchedule.cs` (campo `EnableDeletionSync`)
+- `Data_Coupler/Pages/Scheduling.razor` (UI configurazione)
+
+### 8. Sistema di Autenticazione
+
+#### Caratteristiche:
+- **Login Protetto**: Autenticazione via credenziali o token
+- **Session Management**: Gestione sessioni utente
+- **Password Sicure**: Hashing con algoritmi moderni
+- **Remember Me**: Persistenza login opzionale
+
+#### File Chiave:
+- `Data_Coupler/Services/AuthenticationService.cs`
+- `Data_Coupler/Pages/Login.razor`
+- `Data_Coupler/Middleware/AuthenticationMiddleware.cs`
+
+### 9. Interfaccia Utente Avanzata
+
+#### Pagine Principali:
+- **Dashboard** (`Index.razor`): Panoramica sistema e quick actions
+- **Data Coupler** (`DataCoupler.razor`): Interfaccia principale trasferimento dati
+- **Gestione Profili** (`ProfilesManagement.razor`): CRUD profili completo
+- **Schedulazione** (`Scheduling.razor`): Gestione schedule con UI intuitiva
+- **Storico Schedulazioni** (`SchedulingHistory.razor`): Visualizzazione esecuzioni
+- **Associazioni** (`KeyAssociations.razor`): Gestione completa associazioni
+- **Credenziali** (`CredentialManagement.razor`): CRUD credenziali
+- **Impostazioni** (`SettingsPage.razor`): Backup, sistema, sicurezza, manutenzione
+
+#### Componenti UI:
+- **ProfileSelector**: Selezione e caricamento profili
+- **ProfileSaver**: Salvataggio profili con validazione
+- **ProfileManagement**: CRUD profili completo
+- **Toast Notifications**: Feedback utente in tempo reale
+- **Modal Dialogs**: Conferme operazioni critiche
+- **Progress Indicators**: Feedback operazioni lunghe
+
+#### Design:
+- **Bootstrap 5**: Framework CSS responsive
+- **Font Awesome**: Iconografia consistente
+- **Dark/Light Mode**: Temi personalizzabili
+- **Mobile Responsive**: Ottimizzato per dispositivi mobili
+
+### 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
+- **Database Health**: Verifica connessione database
+- **Background Services**: Stato background services
+- **Memory Monitoring**: Tracciamento utilizzo memoria
+- **Performance Metrics**: Statistiche performance sistema
+
+#### File Chiave:
+- `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:
+- **Data Protection API**: Crittografia con chiavi managed da .NET
+- **Key Rotation**: Supporto rotazione chiavi automatica
+- **Secure Storage**: Persistenza sicura su SQLite
+
+### Input Validation:
+- **SQL Injection Prevention**: Query parametrizzate ovunque
+- **XSS Protection**: Sanitizzazione input utente
+- **Whitelist Validation**: Validazione nomi tabelle/campi
+
+### Comunicazioni Sicure:
+- **HTTPS**: Forzato in produzione
+- **Certificate Validation**: Validazione certificati SSL/TLS
+- **Secure Headers**: Security headers HTTP
+
+### Audit Logging:
+- **Tracciamento Accessi**: Log accessi credenziali
+- **Operazioni Sensibili**: Log modifiche configurazioni
+- **Security Events**: Alert eventi sicurezza
+
+## 🛠️ Convenzioni di Codice
+
+### Naming:
+- **Classes/Interfaces**: PascalCase (es. `DataConnectionFactory`)
+- **Methods**: PascalCase (es. `GetDataAsync`)
+- **Properties**: PascalCase (es. `ConnectionString`)
+- **Private Fields**: camelCase con underscore (es. `_logger`)
+- **Local Variables**: camelCase (es. `connectionName`)
+
+### Async/Await:
+- Tutti i metodi I/O sono asincroni
+- Naming convention: `*Async` suffix
+- Uso di `CancellationToken` per operazioni cancellabili
+- **MAI** usare `.Result` o `.Wait()` - rischio deadlock
+
+### Dependency Injection:
+- **Singleton**: Servizi stateless (es. `IEncryptionService`)
+- **Scoped**: Servizi con stato per request (es. `IDataConnectionFactory`)
+- **Transient**: Servizi leggeri (es. validators)
+
+### Error Handling:
+- Try-catch con logging specifico
+- Messaggi utente user-friendly
+- Dettagli tecnici nei log, non in UI
+- Rollback transazioni in caso di errore
+
+## 📝 Pattern Architetturali Utilizzati
+
+### 1. Repository Pattern:
+- Astrazione accesso dati
+- `*Service` interfacce per business logic
+- `*Repository` per accesso database
+
+### 2. Factory Pattern:
+- `DataConnectionFactory`: Creazione connessioni database/REST
+- `RestServiceClientFactory`: Creazione client REST specifici
+
+### 3. Strategy Pattern:
+- Diversi provider database (SQL Server, MySQL, PostgreSQL, etc.)
+- Diversi client REST (Generic, Salesforce, SAP B1)
+
+### 4. Observer Pattern:
+- Background services per schedulazioni
+- Event-driven processing
+
+## 🧪 Testing
+
+### Unit Tests:
+- Copertura servizi core
+- Mock di dipendenze esterne
+- Test naming: `MethodName_Scenario_ExpectedBehavior`
+
+### Integration Tests:
+- Test connessioni database reali
+- Test API REST con server di test
+- Test end-to-end UI con Playwright
+
+## 📦 Deployment
+
+### Docker Support:
+- `Dockerfile`: Immagine Linux
+- `Dockerfile.windows`: Immagine Windows
+- `docker-compose.yml`: Orchestrazione multi-container
+- Health checks integrati
+
+### Windows Service:
+- Deploy come Windows Service
+- Auto-start configurabile
+- Logging Windows Event Log
+
+### Azure Deployment:
+- App Service support
+- Container Apps support
+- Key Vault integration per secrets
+
+## 🔄 Workflow di Sviluppo
+
+### Branching Strategy:
+- `main`: Produzione stabile
+- `development`: Sviluppo attivo (pubblica su `latest` tag)
+- `feature/*`: Nuove feature
+- `hotfix/*`: Fix urgenti
+
+### CI/CD Pipeline:
+
+#### GitHub Actions (`.github/workflows/docker-build.yml`)
+- **Branch `main`**: Pubblica immagini Docker con tag `latest`
+- **Branch `development`**: Pubblica immagini Docker con tag `latest` e `development-latest`
+- **Branch `staging`**: Pubblica immagini Docker con tag `staging-latest`
+- **Ogni commit**: Crea tag con SHA e timestamp per tracciabilità
+- **Registry**: GitHub Container Registry (`ghcr.io`)
+
+#### Gitea Actions (`.gitea/workflows/docker-build.yml`)
+- **Stessa configurazione** di GitHub Actions
+- **Registry**: Gitea Container Registry (`gitea.home-nas-ds.org`)
+- **Supporto**: Istanza Gitea self-hosted con registry abilitato
+- **Setup**: Richiede secret `REGISTRY_TOKEN` con permessi `write:packages`
+- **Documentazione**: `.gitea/workflows/README.md`
+
+**Note sui Tag Docker**:
+- `latest`: Condiviso tra `main` e `development` per garantire accesso alle ultime funzionalità
+- `development-latest`: Specifico per il branch `development`, utile per distinguere le versioni in sviluppo
+- `staging-latest`: Dedicato al branch `staging` per test pre-produzione
+- Disponibile su **entrambi** i registry (GitHub e Gitea)
+
+### Commit Messages:
+- Formato: `[Tipo] Descrizione breve`
+- Tipi: `[Feature]`, `[Fix]`, `[Refactor]`, `[Docs]`, `[Test]`
+- Esempio: `[Feature] Implementato sistema schedulazione avanzata`
+
+### Code Review:
+- Ogni PR richiede review
+- Checklist: code style, tests, documentation
+- CI/CD automatico
+
+## 📚 Documentazione Correlata
+
+### File di Documentazione nel Progetto:
+- **AGENTS.md**: Guida completa per AI agents e Copilot
+- **ADVANCED_SCHEDULING_SYSTEM.md**: Sistema schedulazione dettagliato
+- **GESTIONE_ASSOCIAZIONI_AVANZATA.md**: Sistema associazioni completo
+- **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
+
+## 🎓 Best Practices per AI Assistants
+
+### Quando Modificare Codice:
+1. **Leggere Documentazione**: Consultare file MD correlati
+2. **Analizzare Pattern**: Seguire pattern esistenti nel codebase
+3. **Validare Input**: Sempre validare parametri
+4. **Error Handling**: Gestire tutti i possibili errori
+5. **Logging**: Aggiungere log appropriati
+6. **Testing**: Creare/aggiornare test correlati
+7. **Documentazione**: Aggiornare XML comments e MD files
+
+### Quando Creare Nuove Feature:
+1. **Progettare Prima**: Pianificare architettura
+2. **Seguire Convenzioni**: Rispettare code style
+3. **Dependency Injection**: Registrare nuovi servizi in `Program.cs`
+4. **Database Changes**: Creare migration Entity Framework
+5. **UI Consistency**: Seguire design pattern esistente
+6. **Documentare**: Creare/aggiornare documentazione
+
+### Red Flags da Evitare:
+- ❌ Hardcoded credentials o secrets
+- ❌ SQL injection vulnerabilities
+- ❌ Blocking calls in async methods
+- ❌ Catch generico senza logging
+- ❌ Modifiche database senza migration
+- ❌ Breaking changes senza versioning
+- ❌ Codice duplicato invece di refactoring
+
+## 🚀 Roadmap Futura
+
+### Feature in Pianificazione:
+- [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
+- [ ] API REST pubblica
+- [ ] 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)
+- [ ] Caching distribuito (Redis)
+- [ ] Message queue (RabbitMQ/Azure Service Bus)
+- [ ] Elasticsearch per log search
+- [ ] Prometheus/Grafana per monitoring
+
+---
+
+**Versione**: 2.1  
+**Ultimo Aggiornamento**: 2 Febbraio 2026  
+**Framework**: .NET 9.0  
+**Sviluppatore**: Alessio Dalsanto  
+**Repository**: https://github.com/AlessioDalsi/Data-Coupler

.github/workflows/docker-build.yml

@@ -4,7 +4,7 @@ on:
   push:
     branches:
       - main
-      - dev
+      - development
       - staging
   workflow_dispatch:
     inputs:
@@ -48,9 +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' }}
+            # 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
@@ -107,6 +111,8 @@ jobs:
           tags: |
             # Tag based on branch with windows suffix
             type=raw,value=latest-windows,enable=${{ github.ref == 'refs/heads/main' }}
+            type=raw,value=latest-windows,enable=${{ github.ref == 'refs/heads/development' }}
+            type=raw,value=development-latest-windows,enable=${{ github.ref == 'refs/heads/development' }}
             type=raw,value=dev-latest-windows,enable=${{ github.ref == 'refs/heads/dev' }}
             type=raw,value=staging-latest-windows,enable=${{ github.ref == 'refs/heads/staging' }}
             # Tag with commit sha
@@ -165,6 +171,14 @@ jobs:
             ${IMAGE_LOWER}:latest \
             ${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}:development-latest \
+            ${IMAGE_LOWER}:development-latest \
+            ${IMAGE_LOWER}:development-latest-windows
+
       - name: Create and push manifest for dev branch
         if: github.ref == 'refs/heads/dev'
         run: |

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/Migrations/20260123104841_AddEnableDeletionSyncToProfileSchedule.Designer.cs

@@ -0,0 +1,585 @@
+// <auto-generated />
+using System;
+using CredentialManager.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace CredentialManager.Migrations
+{
+    [DbContext(typeof(CredentialDbContext))]
+    [Migration("20260123104841_AddEnableDeletionSyncToProfileSchedule")]
+    partial class AddEnableDeletionSyncToProfileSchedule
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "9.0.0");
+
+            modelBuilder.Entity("CredentialManager.Models.CredentialEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AdditionalParameters")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("CommandTimeout")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(30);
+
+                    b.Property<string>("ConnectionString")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DatabaseName")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DatabaseType")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedApiKey")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedAuthToken")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedPassword")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Headers")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Host")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IgnoreSslErrors")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Port")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("RestServiceType")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TimeoutSeconds")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(100);
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DatabaseType");
+
+                    b.HasIndex("IsActive");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Type");
+
+                    b.ToTable("Credentials", (string)null);
+                });
+
+            modelBuilder.Entity("CredentialManager.Models.DataCouplerProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<string>("CreatedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeletionAction")
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeletionMarkField")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeletionMarkValue")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DestinationCredentialId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("DestinationEndpoint")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationSchema")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationTable")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FieldMappingJson")
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTime?>("LastUsedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SourceCredentialId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SourceCustomQuery")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceDatabaseName")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceFilePath")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceKeyField")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceSchema")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceTable")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("SyncDeletions")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("UseRecordAssociations")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("DestinationCredentialId");
+
+                    b.HasIndex("DestinationType");
+
+                    b.HasIndex("IsActive");
+
+                    b.HasIndex("LastUsedAt");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("SourceCredentialId");
+
+                    b.HasIndex("SourceType");
+
+                    b.ToTable("DataCouplerProfiles", (string)null);
+                });
+
+            modelBuilder.Entity("CredentialManager.Models.KeyAssociation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AdditionalInfo")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Data_Hash")
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("DeletionSynced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("DeletionSyncedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationEntity")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationId")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationKeyField")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsSourceDeleted")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("KeyValue")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastVerifiedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MappedDestinationField")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RestCredentialName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceKeyField")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourcesInfo")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("DestinationEntity");
+
+                    b.HasIndex("IsActive");
+
+                    b.HasIndex("KeyValue")
+                        .HasDatabaseName("IX_KeyAssociations_KeyValue");
+
+                    b.HasIndex("LastVerifiedAt");
+
+                    b.HasIndex("RestCredentialName");
+
+                    b.HasIndex("KeyValue", "DestinationEntity", "RestCredentialName")
+                        .IsUnique()
+                        .HasDatabaseName("IX_KeyAssociations_Unique");
+
+                    b.ToTable("KeyAssociations", (string)null);
+                });
+
+            modelBuilder.Entity("CredentialManager.Models.ProfileSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DailyTime")
+                        .HasMaxLength(10)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DayOfMonth")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DayOfWeek")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationDatabaseOverride")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EnableDeletionSync")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ExecutionCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("IntervalUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("IntervalValue")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("LastExecutionMessage")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("LastExecutionRecordCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("LastExecutionStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastExecutionTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("NextExecutionTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ScheduleType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ScheduledDateTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceDatabaseOverride")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProfileId");
+
+                    b.ToTable("ProfileSchedules");
+                });
+
+            modelBuilder.Entity("CredentialManager.Models.ScheduleExecutionHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AdditionalInfo")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationInfo")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DestinationType")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ErrorDetails")
+                        .HasMaxLength(5000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Message")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProfileName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("RecordsProcessed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RecordsWithErrors")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SourceInfo")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SourceType")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TriggeredBy")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProfileId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("StartTime");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TriggerType");
+
+                    b.ToTable("ScheduleExecutionHistories", (string)null);
+                });
+
+            modelBuilder.Entity("CredentialManager.Models.DataCouplerProfile", b =>
+                {
+                    b.HasOne("CredentialManager.Models.CredentialEntity", "DestinationCredential")
+                        .WithMany()
+                        .HasForeignKey("DestinationCredentialId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("CredentialManager.Models.CredentialEntity", "SourceCredential")
+                        .WithMany()
+                        .HasForeignKey("SourceCredentialId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("DestinationCredential");
+
+                    b.Navigation("SourceCredential");
+                });
+
+            modelBuilder.Entity("CredentialManager.Models.ProfileSchedule", b =>
+                {
+                    b.HasOne("CredentialManager.Models.DataCouplerProfile", "Profile")
+                        .WithMany()
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("CredentialManager.Models.ScheduleExecutionHistory", b =>
+                {
+                    b.HasOne("CredentialManager.Models.ProfileSchedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Schedule");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

CredentialManager/Migrations/20260123104841_AddEnableDeletionSyncToProfileSchedule.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace CredentialManager.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddEnableDeletionSyncToProfileSchedule : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "EnableDeletionSync",
+                table: "ProfileSchedules",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "EnableDeletionSync",
+                table: "ProfileSchedules");
+        }
+    }
+}

CredentialManager/Migrations/CredentialDbContextModelSnapshot.cs

@@ -382,6 +382,9 @@ namespace CredentialManager.Migrations
                         .HasMaxLength(100)
                         .HasColumnType("TEXT");
 
+                    b.Property<bool>("EnableDeletionSync")
+                        .HasColumnType("INTEGER");
+
                     b.Property<int>("ExecutionCount")
                         .HasColumnType("INTEGER");
 

CredentialManager/Models/ProfileSchedule.cs

@@ -70,6 +70,9 @@ public class ProfileSchedule
     [MaxLength(100)]
     public string? DestinationDatabaseOverride { get; set; }
 
+    // Configurazione sincronizzazione eliminazioni (default: disabilitata)
+    public bool EnableDeletionSync { get; set; } = false;
+
     // Metadati
     [MaxLength(100)]
     public string? CreatedBy { get; set; }

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/BackupModels.cs

@@ -289,6 +289,9 @@ public class ProfileScheduleBackup
 
     [JsonPropertyName("createdBy")]
     public string? CreatedBy { get; set; }
+
+    [JsonPropertyName("enableDeletionSync")]
+    public bool EnableDeletionSync { get; set; } = false;
 }
 
 /// <summary>

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);
@@ -1496,8 +1742,10 @@ public partial class DataCoupler : ComponentBase
                 recordNumber++;
             }
 
-            // 3.5 Sincronizza le cancellazioni (se abilitato)
+            // 3.5 Sincronizzazione cancellazioni (DISABILITATA per trasferimenti manuali)
+            // Questa funzionalità è disponibile solo per le schedulazioni con configurazione esplicita
             int deletedCount = 0;
+            /* DELETION SYNC DISABILITATA PER TRASFERIMENTI MANUALI
             if (useRecordAssociations && !string.IsNullOrEmpty(sourceKeyField))
             {
                 try
@@ -1570,6 +1818,7 @@ public partial class DataCoupler : ComponentBase
                     });
                 }
             }
+            */
 
             // 4. Mostra risultati
             if (errorCount == 0)

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>
@@ -336,6 +337,30 @@
                             </label>
                         </div>
 
+                        <div class="card mb-3">
+                            <div class="card-header bg-warning text-dark">
+                                <h6 class="mb-0">
+                                    <i class="fas fa-exclamation-triangle"></i> Opzioni Avanzate
+                                </h6>
+                            </div>
+                            <div class="card-body">
+                                <div class="form-check mb-2">
+                                    <InputCheckbox @bind-Value="editingSchedule.EnableDeletionSync" class="form-check-input" id="enableDeletionSyncCheckbox" />
+                                    <label class="form-check-label" for="enableDeletionSyncCheckbox">
+                                        <strong>Abilita sincronizzazione eliminazioni</strong>
+                                    </label>
+                                </div>
+                                <div class="alert alert-warning mb-0">
+                                    <small>
+                                        <i class="fas fa-info-circle"></i>
+                                        <strong>Attenzione:</strong> Se abilitata, i record eliminati dalla sorgente saranno automaticamente eliminati anche dalla destinazione durante l'esecuzione schedulata.
+                                        Questa opzione è <strong>disabilitata di default</strong> per motivi di sicurezza.
+                                        Usare con cautela!
+                                    </small>
+                                </div>
+                            </div>
+                        </div>
+
                         <div class="d-flex justify-content-end gap-2">
                             <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Annulla</button>
                             <button type="submit" class="btn btn-primary">

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/IScheduledProfileExecutionService.cs

@@ -21,4 +21,11 @@ public interface IScheduledProfileExecutionService
     /// Esegue un profilo Data Coupler specificato dall'ID
     /// </summary>
     Task<ProfileExecutionResult> ExecuteProfileAsync(int profileId);
+
+    /// <summary>
+    /// Esegue un profilo Data Coupler specificato dall'ID con configurazione sincronizzazione eliminazioni
+    /// </summary>
+    /// <param name="profileId">ID del profilo da eseguire</param>
+    /// <param name="enableDeletionSync">Se true, sincronizza le eliminazioni dalla sorgente alla destinazione</param>
+    Task<ProfileExecutionResult> ExecuteProfileAsync(int profileId, bool enableDeletionSync);
 }

Data_Coupler/Services/ScheduledExecutionBackgroundService.cs

@@ -69,11 +69,11 @@ public class ScheduledExecutionBackgroundService : BackgroundService
                 {
                     if (ShouldExecuteSchedule(schedule, currentTime))
                     {
-                        _logger.LogInformation("Esecuzione schedulata per profilo: {ProfileName} (Schedule: {ScheduleName})",
+                        _logger.LogInformation("Esecuzione schedulata per profilo: {ProfileName} (Schedule: {ScheduleName}) - DeletionSync: {DeletionSync}",
-                            schedule.Profile?.Name ?? "N/A", schedule.Name);
+                            schedule.Profile?.Name ?? "N/A", schedule.Name, schedule.EnableDeletionSync);
 
-                        // Esegui il profilo
+                        // Esegui il profilo con il flag deletion sync dalla schedulazione
-                        var result = await executionService.ExecuteProfileAsync(schedule.ProfileId);
+                        var result = await executionService.ExecuteProfileAsync(schedule.ProfileId, schedule.EnableDeletionSync);
 
                         // Aggiorna la schedulazione
                         await UpdateScheduleAfterExecution(scheduleService, schedule, currentTime, result.Success);

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;
 
@@ -28,6 +29,7 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
     private readonly IDataConnectionCredentialService _dataConnectionCredentialService;
     private readonly IKeyAssociationService _keyAssociationService;
     private readonly IAssociationService _associationService;
+    private readonly IDeletionSyncService _deletionSyncService;
     private readonly ILogger<ScheduledProfileExecutionService> _logger;
 
     public ScheduledProfileExecutionService(
@@ -37,6 +39,7 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
         IDataConnectionCredentialService dataConnectionCredentialService,
         IKeyAssociationService keyAssociationService,
         IAssociationService associationService,
+        IDeletionSyncService deletionSyncService,
         ILogger<ScheduledProfileExecutionService> logger)
     {
         _profileService = profileService;
@@ -45,6 +48,7 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
         _dataConnectionCredentialService = dataConnectionCredentialService;
         _keyAssociationService = keyAssociationService;
         _associationService = associationService;
+        _deletionSyncService = deletionSyncService;
         _logger = logger;
     }
 
@@ -52,6 +56,14 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
     /// Esegue un profilo Data Coupler specificato dall'ID
     /// </summary>
     public async Task<ProfileExecutionResult> ExecuteProfileAsync(int profileId)
+    {
+        return await ExecuteProfileAsync(profileId, enableDeletionSync: false);
+    }
+
+    /// <summary>
+    /// Esegue un profilo Data Coupler specificato dall'ID con configurazione sincronizzazione eliminazioni
+    /// </summary>
+    public async Task<ProfileExecutionResult> ExecuteProfileAsync(int profileId, bool enableDeletionSync)
     {
         var startTime = DateTime.UtcNow;
         var result = new ProfileExecutionResult
@@ -61,7 +73,7 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
 
         try
         {
-            _logger.LogInformation("Inizio esecuzione profilo schedulato ID: {ProfileId}", profileId);
+            _logger.LogInformation("Inizio esecuzione profilo schedulato ID: {ProfileId} - DeletionSync: {DeletionSync}", profileId, enableDeletionSync);
 
             // Carica il profilo
             var profile = await _profileService.GetProfileByIdAsync(profileId);
@@ -78,7 +90,7 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
             await _profileService.UpdateLastUsedAsync(profile.Id);
 
             // Esegue il trasferimento dati con la logica completa
-            var recordsTransferred = await ExecuteDataTransferAsync(profile);
+            var recordsTransferred = await ExecuteDataTransferAsync(profile, enableDeletionSync);
 
             result.Success = true;
             result.RecordsProcessed = recordsTransferred;
@@ -106,10 +118,11 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
     /// Metodo principale per l'esecuzione del trasferimento dati
     /// Implementa la stessa logica di StartDataTransferWithComposite
     /// </summary>
-    private async Task<int> ExecuteDataTransferAsync(DataCouplerProfile profile)
+    private async Task<int> ExecuteDataTransferAsync(DataCouplerProfile profile, bool enableDeletionSync = false)
     {
         _logger.LogInformation("=== INIZIO TRASFERIMENTO DATI SCHEDULATO ===");
-        _logger.LogInformation("Esecuzione profilo: {ProfileName} (ID: {ProfileId})", profile.Name, profile.Id);
+        _logger.LogInformation("Esecuzione profilo: {ProfileName} (ID: {ProfileId}) - DeletionSync: {DeletionSync}", 
+            profile.Name, profile.Id, enableDeletionSync);
 
         try
         {
@@ -118,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)
@@ -151,12 +170,12 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
             if (useSalesforceComposite)
             {
                 _logger.LogInformation("Utilizzo Salesforce Composite API per il trasferimento");
-                return await ExecuteDataTransferWithCompositeAsync(profile, sourceRecords, restClient, restEntity, restCredential!, fieldMappings);
+                return await ExecuteDataTransferWithCompositeAsync(profile, sourceRecords, restClient, restEntity, restCredential!, fieldMappings, enableDeletionSync);
             }
             else
             {
                 _logger.LogInformation("Utilizzo metodo trasferimento standard per il trasferimento");
-                return await ExecuteDataTransferStandardAsync(profile, sourceRecords, restClient, restEntity, restCredential!, fieldMappings);
+                return await ExecuteDataTransferStandardAsync(profile, sourceRecords, restClient, restEntity, restCredential!, fieldMappings, enableDeletionSync);
             }
         }
         catch (Exception ex)
@@ -175,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");
@@ -366,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>
@@ -389,9 +630,11 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
         IRestServiceClient restClient,
         RestEntitySummary restEntity,
         RestApiCredential restCredential,
-        Dictionary<string, string> fieldMappings)
+        Dictionary<string, string> fieldMappings,
+        bool enableDeletionSync = false)
     {
-        _logger.LogInformation("Iniziando trasferimento dati standard per {RecordCount} record", sourceRecords.Count());
+        _logger.LogInformation("Iniziando trasferimento dati standard per {RecordCount} record - DeletionSync: {DeletionSync}", 
+            sourceRecords.Count(), enableDeletionSync);
 
         int successCount = 0;
         int errorCount = 0;
@@ -454,6 +697,50 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
         _logger.LogInformation("Trasferimento completato. Successi: {SuccessCount}, Errori: {ErrorCount}", 
             successCount, errorCount);
 
+        // Sincronizzazione cancellazioni (se abilitata)
+        if (enableDeletionSync && profile.UseRecordAssociations && !string.IsNullOrEmpty(profile.SourceKeyField))
+        {
+            try
+            {
+                _logger.LogInformation("SCHEDULED: Inizio sincronizzazione cancellazioni...");
+
+                // Estrai tutti i valori chiave presenti nella sorgente
+                var sourceKeyValues = sourceRecords
+                    .Select(r => r.ContainsKey(profile.SourceKeyField) ? r[profile.SourceKeyField]?.ToString() : null)
+                    .Where(k => !string.IsNullOrEmpty(k))
+                    .Cast<string>()
+                    .Distinct()
+                    .ToList();
+
+                _logger.LogInformation("SCHEDULED: Trovati {Count} valori chiave nella sorgente", sourceKeyValues.Count);
+
+                // Sincronizza le cancellazioni
+                var deletionOptions = new DeletionSyncOptions
+                {
+                    Action = DeletionAction.Delete // Default: elimina fisicamente
+                };
+
+                var deletionResult = await _deletionSyncService.SyncDeletionsAsync(
+                    sourceKeyValues,
+                    restEntity.Name,
+                    restCredential.Name,
+                    restClient,
+                    deletionOptions);
+
+                if (deletionResult.DeletedRecordsDetected > 0)
+                {
+                    _logger.LogInformation("SCHEDULED: Sincronizzazione cancellazioni completata - {Detected} rilevati, {Synced} sincronizzati, {Errors} errori",
+                        deletionResult.DeletedRecordsDetected,
+                        deletionResult.DeletedRecordsSynced,
+                        deletionResult.SyncErrors);
+                }
+            }
+            catch (Exception delEx)
+            {
+                _logger.LogError(delEx, "SCHEDULED: Errore durante la sincronizzazione delle cancellazioni");
+            }
+        }
+
         return successCount;
     }
 
@@ -467,15 +754,17 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
         IRestServiceClient restClient,
         RestEntitySummary restEntity,
         RestApiCredential restCredential,
-        Dictionary<string, string> fieldMappings)
+        Dictionary<string, string> fieldMappings,
+        bool enableDeletionSync = false)
     {
-        _logger.LogInformation("Iniziando trasferimento dati COMPOSITE per {RecordCount} record", sourceRecords.Count());
+        _logger.LogInformation("Iniziando trasferimento dati COMPOSITE per {RecordCount} record - DeletionSync: {DeletionSync}", 
+            sourceRecords.Count(), enableDeletionSync);
 
         // Verifica che sia effettivamente un SalesforceServiceClient
         if (!(restClient is DataConnection.REST.Implementations.SalesforceServiceClient salesforceClient))
         {
             _logger.LogWarning("Client REST non è SalesforceServiceClient, fallback al metodo standard");
-            return await ExecuteDataTransferStandardAsync(profile, sourceRecords, restClient, restEntity, restCredential, fieldMappings);
+            return await ExecuteDataTransferStandardAsync(profile, sourceRecords, restClient, restEntity, restCredential, fieldMappings, enableDeletionSync);
         }
 
         try
@@ -738,6 +1027,50 @@ public class ScheduledProfileExecutionService : IScheduledProfileExecutionServic
             _logger.LogInformation("COMPOSITE SCHEDULED: Trasferimento completato. Creazioni: {SuccessCount}, Aggiornamenti: {UpdatedCount}, Saltati: {SkippedCount}, Errori: {ErrorCount}",
                 successCount, updatedCount, skippedCount, errorCount);
 
+            // Sincronizzazione cancellazioni (se abilitata)
+            if (enableDeletionSync && currentUseRecordAssociations && !string.IsNullOrEmpty(profile.SourceKeyField))
+            {
+                try
+                {
+                    _logger.LogInformation("COMPOSITE SCHEDULED: Inizio sincronizzazione cancellazioni...");
+
+                    // Estrai tutti i valori chiave presenti nella sorgente
+                    var sourceKeyValues = sourceRecords
+                        .Select(r => r.ContainsKey(profile.SourceKeyField) ? r[profile.SourceKeyField]?.ToString() : null)
+                        .Where(k => !string.IsNullOrEmpty(k))
+                        .Cast<string>()
+                        .Distinct()
+                        .ToList();
+
+                    _logger.LogInformation("COMPOSITE SCHEDULED: Trovati {Count} valori chiave nella sorgente", sourceKeyValues.Count);
+
+                    // Sincronizza le cancellazioni
+                    var deletionOptions = new DeletionSyncOptions
+                    {
+                        Action = DeletionAction.Delete // Default: elimina fisicamente
+                    };
+
+                    var deletionResult = await _deletionSyncService.SyncDeletionsAsync(
+                        sourceKeyValues,
+                        currentEntityName,
+                        currentCredentialName,
+                        restClient,
+                        deletionOptions);
+
+                    if (deletionResult.DeletedRecordsDetected > 0)
+                    {
+                        _logger.LogInformation("COMPOSITE SCHEDULED: Sincronizzazione cancellazioni completata - {Detected} rilevati, {Synced} sincronizzati, {Errors} errori",
+                            deletionResult.DeletedRecordsDetected,
+                            deletionResult.DeletedRecordsSynced,
+                            deletionResult.SyncErrors);
+                    }
+                }
+                catch (Exception delEx)
+                {
+                    _logger.LogError(delEx, "COMPOSITE SCHEDULED: Errore durante la sincronizzazione delle cancellazioni");
+                }
+            }
+
             return totalProcessed;
         }
         catch (Exception ex)

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:**
@@ -157,19 +193,55 @@ docker build -t data-coupler:local-windows -f Dockerfile.windows .
 ```
 
 **Immagini Disponibili:**
-- **Linux**: `ghcr.io/alessiodalsi/data-coupler:latest`
+- **Linux/Multi-platform**: `ghcr.io/alessiodalsi/data-coupler:latest`
 - **Windows**: `ghcr.io/alessiodalsi/data-coupler:latest-windows`
+- **Development**: `ghcr.io/alessiodalsi/data-coupler:development-latest`
 - **Dev**: `ghcr.io/alessiodalsi/data-coupler:dev-latest`
 - **Staging**: `ghcr.io/alessiodalsi/data-coupler:staging-latest`
 
+**Note**: Il tag `latest` viene automaticamente aggiornato sia dal branch `main` che dal branch `development` per garantire che le ultime funzionalità siano sempre disponibili. Il tag `development-latest` è specifico per il branch development.
+
 📚 **Documentazione Docker Completa**: Vedi [DOCKER_DEPLOYMENT.md](DOCKER_DEPLOYMENT.md) e [GITHUB_ACTIONS_SETUP.md](GITHUB_ACTIONS_SETUP.md)
 
+### 🔄 CI/CD Pipeline
+
+Il progetto supporta pipeline CI/CD automatiche su:
+
+**GitHub Actions** (`.github/workflows/docker-build.yml`):
+- Build automatica su push ai branch `main`, `development`, `staging`
+- Pubblicazione su GitHub Container Registry (`ghcr.io`)
+- Multi-platform manifest (Linux + Windows)
+
+**Gitea Actions** (`.gitea/workflows/docker-build.yml`):
+- Stessa configurazione di GitHub Actions
+- Pubblicazione su Gitea Container Registry (`gitea.home-nas-ds.org`)
+- Istanza Gitea self-hosted con registry abilitato
+- Configurazione: `.gitea/workflows/README.md`
+
+**Immagini su Gitea** (self-hosted):
+```bash
+# Pull da Gitea Container Registry
+docker pull gitea.home-nas-ds.org/alessio/data-coupler:latest
+
+# Versioni disponibili
+docker pull gitea.home-nas-ds.org/alessio/data-coupler:development-latest
+docker pull gitea.home-nas-ds.org/alessio/data-coupler:staging-latest
+```
+
+📚 **Setup Gitea**: Vedi [.gitea/workflows/README.md](.gitea/workflows/README.md)
+
 ## Caratteristiche di Sicurezza
 
 - **Crittografia**: Le password vengono crittografate prima del salvataggio
 - **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