Adicionar suporte a configurações de listas no XML

Implementa novas funcionalidades para gerenciar configurações de listas no processo de replicação de dados do SharePoint para o SQL Server.

- Adiciona a variável privada `_columnMappings` em `SQLInteraction.cs` para armazenar mapeamentos de colunas.
- Modifica o método `GetSelectedColumns` em `ConfigHelper.cs` para aceitar um parâmetro opcional `listName`.
- Introduz o método `GetListConfigurations` para carregar configurações de listas a partir de um arquivo XML.
- Adiciona o método auxiliar `GetListColumns` para extrair colunas específicas de cada lista.
- Atualiza `UserConfig.xml` para incluir uma nova estrutura de configuração de listas, permitindo definições específicas e mantendo configurações globais.

Author: kill74

SPOtoSQL-Snapshots/ConsoleApp1/Sqlserver/SQLInteraction.cs

@@ -31,6 +31,7 @@ internal class SQLInteraction
         // private HashSet<string> SelectedColumns { get; set; }
         private HashSet<string> IgnoredColumns { get; set; }
         private Dictionary<string, ColumnMapping> ColumnMappings { get; set; }
+        private Dictionary<string, ColumnMapping> _columnMappings;
 
         /// <summary>
         /// Initializes the SQL table for the specified SharePoint list,

SPOtoSQL-Snapshots/ConsoleApp1/XmlConfig/ConfigHelper.cs

@@ -46,12 +46,32 @@ private static void LoadConfig()
         /// <returns>
         /// A Dictionary of column mappings, or null if all columns should be included.
         /// </returns>
-        public static Dictionary<string, ColumnMapping> GetSelectedColumns()
+        public static Dictionary<string, ColumnMapping> GetSelectedColumns(string listName = null)
         {
             LoadConfig();
 
             try
             {
+                // Primeiro verifica configurações específicas da lista
+                if (!string.IsNullOrEmpty(listName))
+                {
+                    var listConfigs = GetListConfigurations();
+                    if (listConfigs != null && listConfigs.TryGetValue(listName, out var listConfig))
+                    {
+                        if (listConfig.Ignore)
+                        {
+                            Console.WriteLine($"List {listName} is configured to be ignored.");
+                            return null;
+                        }
+                        if (listConfig.Columns != null)
+                        {
+                            Console.WriteLine($"Using specific configuration for list: {listName}");
+                            return listConfig.Columns;
+                        }
+                    }
+                }
+
+                // Se não encontrar configuração específica, usa as configurações globais
                 var columnNodes = _xmlDoc.SelectNodes("//Configuration/ReplicationConfiguration/SelectColumns/column");
 
                 if (columnNodes == null || columnNodes.Count == 0)
@@ -298,6 +318,77 @@ private static bool IsValidListConfig(SharePointListConfig config)
 
             return true;
         }
+
+        public static Dictionary<string, ListConfiguration> GetListConfigurations()
+        {
+            LoadConfig();
+
+            try
+            {
+                var listNodes = _xmlDoc.SelectNodes("//Configuration/ReplicationConfiguration/Lists/List");
+                if (listNodes == null || listNodes.Count == 0)
+                    return null;
+
+                var listConfigs = new Dictionary<string, ListConfiguration>(StringComparer.OrdinalIgnoreCase);
+
+                foreach (XmlNode listNode in listNodes)
+                {
+                    var nameAttr = listNode.Attributes["name"];
+                    var contextAttr = listNode.Attributes["context"];
+                    var ignoreAttr = listNode.Attributes["ignore"];
+
+                    if (nameAttr != null)
+                    {
+                        var listConfig = new ListConfiguration
+                        {
+                            Name = nameAttr.Value,
+                            Context = contextAttr?.Value,
+                            Ignore = ignoreAttr != null && bool.Parse(ignoreAttr.Value),
+                            Columns = GetListColumns(listNode)
+                        };
+
+                        listConfigs[listConfig.Name] = listConfig;
+                    }
+                }
+
+                return listConfigs.Count > 0 ? listConfigs : null;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error reading list configurations: {ex.Message}");
+                throw;
+            }
+        }
+
+        private static Dictionary<string, ColumnMapping> GetListColumns(XmlNode listNode)
+        {
+            var columnNodes = listNode.SelectNodes(".//Columns/column");
+            if (columnNodes == null || columnNodes.Count == 0)
+                return null;
+
+            var columnMappings = new Dictionary<string, ColumnMapping>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (XmlNode node in columnNodes)
+            {
+                var sourceAttr = node.Attributes["source"];
+                var destAttr = node.Attributes["destination"];
+                var ignoreAttr = node.Attributes["ignore"];
+
+                if (sourceAttr != null)
+                {
+                    var mapping = new ColumnMapping
+                    {
+                        Source = sourceAttr.Value,
+                        Destination = destAttr?.Value ?? sourceAttr.Value,
+                        Ignore = ignoreAttr != null && bool.Parse(ignoreAttr.Value)
+                    };
+
+                    columnMappings[mapping.Source] = mapping;
+                }
+            }
+
+            return columnMappings.Count > 0 ? columnMappings : null;
+        }
     }
 
     /// <summary>
@@ -318,4 +409,12 @@ public class ColumnMapping
         public string Destination { get; set; }
         public bool Ignore { get; set; }
     }
+
+    public class ListConfiguration
+    {
+        public string Name { get; set; }
+        public string Context { get; set; }
+        public bool Ignore { get; set; }
+        public Dictionary<string, ColumnMapping> Columns { get; set; }
+    }
 }