Data-Coupler/TROUBLESHOOTING_MAPPED_FIELD.md

Troubleshooting MappedDestinationField NULL

Data: 20 Ottobre 2025

Problema Segnalato

Il campo MappedDestinationField rimane sempre NULL nelle associazioni anche quando viene fatto un mapping.

Analisi del Problema

Come Dovrebbe Funzionare

1. L'utente crea un mapping: CardCode (sorgente) → cardcode__c (destinazione)
2. L'utente seleziona CardCode come campo chiave sorgente
3. Durante il trasferimento, il sistema dovrebbe:
   • Cercare CardCode nel dizionario fieldMappings
   • Trovare il valore mappato cardcode__c
   • Salvarlo in MappedDestinationField

Struttura Dati

// fieldMappings è un Dictionary<string, string>
// Chiave: nome colonna sorgente (es. "CardCode")
// Valore: nome campo destinazione (es. "cardcode__c")

Dictionary<string, string> fieldMappings = new()
{
    { "CardCode", "cardcode__c" },
    { "CardName", "Name" },
    { "City", "BillingCity" }
};

// sourceKeyField è la colonna selezionata come chiave
string sourceKeyField = "CardCode";

// Logica di ricerca
if (fieldMappings.ContainsKey(sourceKeyField))
{
    mappedDestinationField = fieldMappings[sourceKeyField]; // Dovrebbe essere "cardcode__c"
}

Possibili Cause

1. Campo Chiave Non Mappato ❌

Scenario: L'utente seleziona un campo chiave che NON è stato mappato.

Esempio:

Mappings creati:
- CardName → Name
- City → BillingCity

Campo chiave selezionato: CardCode ← NON MAPPATO!

Risultato: MappedDestinationField = NULL

Soluzione: Verificare che il campo chiave selezionato sia presente nei mappings.

2. Case Sensitivity Issues ⚠️

Scenario: Il nome del campo chiave non corrisponde esattamente alla chiave nel dizionario.

Esempio:

Mapping creato: "cardcode" → "cardcode__c"
Campo chiave: "CardCode" ← Diverso per maiuscole!

Risultato: ContainsKey restituisce false

Soluzione: Verificare che il nome sia identico (case-sensitive).

3. Spazi o Caratteri Nascosti 🔍

Scenario: Presenza di spazi all'inizio/fine del nome campo.

Esempio:

Mapping: "CardCode " → "cardcode__c" (nota lo spazio finale)
Campo chiave: "CardCode"

Risultato: Non corrisponde

Soluzione: Trim dei nomi campo durante la creazione del mapping.

Logging Diagnostico Aggiunto

Ho aggiunto logging dettagliato per diagnosticare il problema:

Logger.LogDebug("MAPPING DEBUG: Tentativo di trovare mapping per sourceKeyField: '{SourceKeyField}'", sourceKeyField);
Logger.LogDebug("MAPPING DEBUG: Mappings disponibili: {Mappings}", 
    string.Join(", ", fieldMappings.Select(m => $"{m.Key} -> {m.Value}")));

if (fieldMappings.ContainsKey(sourceKeyField))
{
    mappedDestinationField = fieldMappings[sourceKeyField];
    Logger.LogDebug("MAPPING DEBUG: Trovato mapping: '{SourceKeyField}' -> '{MappedField}'", 
        sourceKeyField, mappedDestinationField);
}
else
{
    Logger.LogWarning("MAPPING DEBUG: Campo chiave '{SourceKeyField}' NON trovato nei mappings!", 
        sourceKeyField);
}

Procedura di Diagnosi

Step 1: Abilitare Logging Debug

In appsettings.Development.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "Data_Coupler.Pages.DataCoupler": "Debug"
    }
  }
}

Step 2: Eseguire un Trasferimento Dati

1. Creare almeno un mapping che include il campo chiave
2. Selezionare il campo chiave
3. Eseguire il trasferimento
4. Monitorare i log

Step 3: Analizzare i Log

Cercare le righe MAPPING DEBUG:

Caso 1: Campo Trovato ✅

[Debug] MAPPING DEBUG: Tentativo di trovare mapping per sourceKeyField: 'CardCode'
[Debug] MAPPING DEBUG: Mappings disponibili: CardCode -> cardcode__c, CardName -> Name
[Debug] MAPPING DEBUG: Trovato mapping: 'CardCode' -> 'cardcode__c'
[Info] COMPOSITE: Associazione creata con ID: 42 - MappedField: cardcode__c

Risultato: MappedDestinationField dovrebbe essere popolato correttamente.

Caso 2: Campo Non Trovato ❌

[Debug] MAPPING DEBUG: Tentativo di trovare mapping per sourceKeyField: 'CardCode'
[Debug] MAPPING DEBUG: Mappings disponibili: CardName -> Name, City -> BillingCity
[Warning] MAPPING DEBUG: Campo chiave 'CardCode' NON trovato nei mappings!
[Info] COMPOSITE: Associazione creata con ID: 42 - MappedField: N/A

Problema: Il campo chiave non è stato mappato!

Soluzione: Creare un mapping per il campo chiave.

Step 4: Verificare il Database

-- Verifica le associazioni create
SELECT 
    Id,
    KeyValue,
    SourceKeyField,
    DestinationKeyField,
    MappedDestinationField,
    DestinationEntity,
    CreatedAt
FROM KeyAssociations
ORDER BY CreatedAt DESC
LIMIT 10;

Cosa Cercare:

• SourceKeyField: Dovrebbe essere il nome del campo chiave (es. "CardCode")
• MappedDestinationField:
  • Se NULL → il campo non era nei mappings
  • Se valorizzato → tutto OK

Soluzione Temporanea

Se il problema persiste, puoi verificare manualmente nel database:

-- Trova associazioni senza campo mappato
SELECT COUNT(*) 
FROM KeyAssociations 
WHERE MappedDestinationField IS NULL;

-- Verifica un'associazione specifica
SELECT 
    KeyValue,
    SourceKeyField,
    MappedDestinationField,
    AdditionalInfo
FROM KeyAssociations
WHERE Id = [ID_ASSOCIAZIONE];

Test Case

Per testare la funzionalità:

Test 1: Campo Mappato ✅

1. Crea mapping: CardCode → cardcode__c
2. Seleziona campo chiave: CardCode
3. Esegui trasferimento
4. Verifica: MappedDestinationField = "cardcode__c"

Test 2: Campo Non Mappato ❌

1. Crea mapping: CardName → Name (NON mappare CardCode)
2. Seleziona campo chiave: CardCode
3. Esegui trasferimento
4. Verifica: MappedDestinationField = NULL
5. Log: "Campo chiave 'CardCode' NON trovato nei mappings!"

Test 3: Controllo Validazione

Il sistema dovrebbe impedire il trasferimento se il campo chiave non è mappato (controllo aggiunto precedentemente).

Prossimi Passi

1. Eseguire un test con logging abilitato
2. Catturare i log durante il trasferimento
3. Analizzare l'output del MAPPING DEBUG
4. Determinare se il problema è:
   • Campo non mappato (normale, warning utente)
   • Bug nel codice di lookup (da fixare)
   • Problema di encoding/spazi (sanitizzare input)

File Modificati

• ✅ Data_Coupler/Pages/DataCoupler.razor.cs - Aggiunto logging diagnostico

Status: 🔍 IN DIAGNOSI

Logging aggiunto, in attesa di eseguire test per identificare la causa esatta.