Refatorar gerenciamento de colunas na replicação SQL

As colunas selecionadas e ignoradas na classe `SQLInteraction` agora são gerenciadas por um `Dictionary<string, ColumnMapping>`, permitindo um mapeamento mais flexível entre colunas de origem e destino, além de indicar se uma coluna deve ser ignorada.

A função `GetSelectedColumns` na classe `ConfigHelper` foi atualizada para retornar o novo tipo de dados, refletindo a nova estrutura de configuração.

No arquivo `UserConfig.xml`, a estrutura das colunas foi alterada para incluir atributos `source`, `destination` e `ignore`, proporcionando uma configuração mais detalhada.

Várias partes do código foram comentadas para indicar que o sistema anterior de colunas selecionadas e ignoradas não está mais em uso.

Author: kill74

SPOtoSQL-Snapshots/ConsoleApp1/Sqlserver/SQLInteraction.cs

@@ -28,8 +28,9 @@ internal class SQLInteraction
         public string CurrentTime { get; set; }
 
         // Store selected and ignored columns from configuration
-        private HashSet<string> SelectedColumns { get; set; }
+        // private HashSet<string> SelectedColumns { get; set; }
         private HashSet<string> IgnoredColumns { get; set; }
+        private Dictionary<string, ColumnMapping> ColumnMappings { get; set; }
 
         /// <summary>
         /// Initializes the SQL table for the specified SharePoint list,
@@ -42,10 +43,10 @@ public void Build()
             try
             {
                 // Load selected and ignored columns from configuration
-                this.SelectedColumns = ConfigurationReader.GetSelectedColumns();
+                // this.SelectedColumns = ConfigurationReader.GetSelectedColumns();
                 this.IgnoredColumns = ConfigurationReader.GetIgnoredColumns();
 
-                LogInfo("Build", $"Selected columns from config: {(this.SelectedColumns == null ? "All" : string.Join(", ", this.SelectedColumns))}");
+                // LogInfo("Build", $"Selected columns from config: {(this.SelectedColumns == null ? "All" : string.Join(", ", this.SelectedColumns))}");
                 LogInfo("Build", $"Ignored columns from config: {(this.IgnoredColumns == null ? "None" : string.Join(", ", this.IgnoredColumns))}");
 
                 this.TableName = this.ToPascalCase(this.List.Name, false);
@@ -224,24 +225,37 @@ private void BuildDictionary()
             int skippedFields = 0;
             int ignoredFields = 0;
 
+            this.ColumnMappings = ConfigurationReader.GetSelectedColumns();
+            this.IgnoredColumns = ConfigurationReader.GetIgnoredColumns();
+
             foreach (Field field in this.List.Fields)
             {
                 if (field.TypeAsString != "Computed")
                 {
                     try
                     {
-                        string columnName = this.GetActualColName(field);
+                        string columnName = field.InternalName;
 
-                        // Skip if the column is in the ignored list
-                        if (this.IgnoredColumns != null && this.IgnoredColumns.Contains(columnName))
+                        if (this.ColumnMappings != null && this.ColumnMappings.TryGetValue(columnName, out var mapping))
+                        {
+                            if (mapping.Ignore)
+                            {
+                                ignoredFields++;
+                                LogInfo("BuildDictionary", $"Ignored field (by mapping): {columnName}");
+                                continue;
+                            }
+                            
+                            string destinationName = mapping.Destination;
+                            this.FNDictionary.Add(this.GetKeyName(destinationName, 1), field);
+                            processedFields++;
+                            LogInfo("BuildDictionary", $"Added mapped field: {columnName} -> {destinationName}");
+                        }
+                        else if (this.IgnoredColumns != null && this.IgnoredColumns.Contains(columnName))
                         {
                             ignoredFields++;
-                            LogInfo("BuildDictionary", $"Ignored field: {columnName}");
-                            continue;
+                            LogInfo("BuildDictionary", $"Ignored field (global): {columnName}");
                         }
-
-                        // Only add the field if it's selected in configuration or if no specific columns are selected
-                        if (this.SelectedColumns == null || this.SelectedColumns.Contains(columnName))
+                        else if (this.ColumnMappings == null)
                         {
                             this.FNDictionary.Add(this.GetKeyName(columnName, 1), field);
                             processedFields++;
@@ -250,7 +264,7 @@ private void BuildDictionary()
                         else
                         {
                             skippedFields++;
-                            LogInfo("BuildDictionary", $"Skipped field (not selected): {columnName}");
+                            LogInfo("BuildDictionary", $"Skipped field (not mapped): {columnName}");
                         }
                     }
                     catch (Exception ex)
@@ -259,10 +273,6 @@ private void BuildDictionary()
                         LogError("BuildDictionary", $"Failed to process field: {field.Title}", ex);
                     }
                 }
-                else
-                {
-                    skippedFields++;
-                }
             }
 
             LogInfo("BuildDictionary",

SPOtoSQL-Snapshots/ConsoleApp1/XmlConfig/ConfigHelper.cs

@@ -44,45 +44,45 @@ private static void LoadConfig()
         /// Gets the list of columns that should be included in the replication process.
         /// </summary>
         /// <returns>
-        /// A HashSet of column names to include, or null if all columns should be included.
+        /// A Dictionary of column mappings, or null if all columns should be included.
         /// </returns>
-        public static HashSet<string> GetSelectedColumns()
+        public static Dictionary<string, ColumnMapping> GetSelectedColumns()
         {
             LoadConfig();
 
             try
             {
-                var columnNodes = _xmlDoc.SelectNodes("//Configuration/ReplicationConfiguration/SelectColumns/Column");
+                var columnNodes = _xmlDoc.SelectNodes("//Configuration/ReplicationConfiguration/SelectColumns/column");
 
-                // If no column nodes exist, return null to indicate all columns should be included
                 if (columnNodes == null || columnNodes.Count == 0)
                 {
                     Console.WriteLine("No specific columns configured. All columns will be included.");
                     return null;
                 }
 
-                // Create case-insensitive HashSet for column names
-                var selectedColumns = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+                var columnMappings = new Dictionary<string, ColumnMapping>(StringComparer.OrdinalIgnoreCase);
 
                 foreach (XmlNode node in columnNodes)
                 {
-                    if (!string.IsNullOrWhiteSpace(node.InnerText))
+                    var sourceAttr = node.Attributes["source"];
+                    var destAttr = node.Attributes["destination"];
+                    var ignoreAttr = node.Attributes["ignore"];
+
+                    if (sourceAttr != null)
                     {
-                        string columnName = node.InnerText.Trim();
-                        selectedColumns.Add(columnName);
-                        Console.WriteLine($"Added selected column: {columnName}");
+                        var mapping = new ColumnMapping
+                        {
+                            Source = sourceAttr.Value,
+                            Destination = destAttr?.Value ?? sourceAttr.Value,
+                            Ignore = ignoreAttr != null && bool.Parse(ignoreAttr.Value)
+                        };
+
+                        columnMappings[mapping.Source] = mapping;
+                        Console.WriteLine($"Added column mapping: {mapping.Source} -> {mapping.Destination} (Ignore: {mapping.Ignore})");
                     }
                 }
 
-                // If no valid columns were added, return null to include all columns
-                if (selectedColumns.Count == 0)
-                {
-                    Console.WriteLine("No valid columns specified. All columns will be included.");
-                    return null;
-                }
-
-                Console.WriteLine($"Total selected columns: {selectedColumns.Count}");
-                return selectedColumns;
+                return columnMappings.Count > 0 ? columnMappings : null;
             }
             catch (Exception ex)
             {
@@ -311,4 +311,11 @@ public class SharePointListConfig
         public bool AutoAddNewColumns { get; set; }
         public bool Disabled { get; set; }
     }
+
+    public class ColumnMapping
+    {
+        public string Source { get; set; }
+        public string Destination { get; set; }
+        public bool Ignore { get; set; }
+    }
 }