🔧 (appsettings.json, configuration.json): update configuration struct…

…ure for consistency

♻️ (TfsStaticEnrichers.cs, TfsChangeSetMappingToolOptions.cs, ServiceCollectionExtensions.cs): refactor code for better readability and maintainability
📝 (MigrationTools.xml): update generated documentation to reflect recent changes
💡 (MigrationHostTests.cs): comment out FieldMaps clearing for future review

The configuration structure is updated to ensure consistency across different files. The refactoring in the code improves readability and maintainability by aligning the naming conventions and formatting. The generated documentation is updated to reflect the recent changes in the codebase. Commenting out the FieldMaps clearing in the tests is done to review its necessity in future updates.

♻️ (MigrationTools): refactor field mapping logic and remove deprecated tests

- Remove `FieldMapContainer` and related configurations.
- Replace `FieldMapContainer` with `FieldMappingTool`.
- Update `StaticEnrichers` to include `FieldMappingTool`.
- Delete outdated test files `EngineConfigurationBuilderTests.cs` and `EngineConfigurationTests.cs`.
- Update `FieldMapContainerTests` to use `FieldMappingToolOptions`.

The changes streamline the field mapping logic by replacing the `FieldMapContainer` with a more cohesive `FieldMappingTool`. This reduces redundancy and improves maintainability. Outdated tests are removed to reflect the new configuration structure, ensuring the codebase remains clean and relevant.

✨ (FieldMappingTool): add FieldMappingTool and its configuration options

Introduce a new `FieldMappingTool` class to handle field mappings for work items. This tool allows for the configuration and application of field mappings based on work item types. The `FieldMappingToolOptions` class is also added to manage the configuration settings for the `FieldMappingTool`.

🔧 (ServiceCollectionExtensions): register FieldMappingTool and its options

Update the `ServiceCollectionExtensions` to register the `FieldMappingTool` and its configuration options. This ensures that the tool is available for dependency injection and properly configured.

♻️ (EngineConfiguration): remove FieldMaps from EngineConfiguration

Remove the `FieldMaps` property from the `EngineConfiguration` class as it is now managed by the `FieldMappingToolOptions`. This refactor centralizes the field mapping logic and configuration, making the codebase cleaner and more maintainable.

These changes are done to modularize the field mapping functionality, making it easier to manage and extend. The new `FieldMappingTool` provides a dedicated place for field mapping logic, improving code organization and maintainability.

♻️ (EngineConfigurationBuilder.cs): remove FieldMaps initialization and comment out example field maps
💡 (IFieldMap.cs): mark Configure method as obsolete
♻️ (MigrationProcessorBase.cs, StaticProcessorBase.cs): inject StaticEnrichers dependency

FieldMaps initialization is removed to streamline the configuration process. Example field maps are commented out to reduce clutter and potential confusion. The Configure method in IFieldMap.cs is marked as obsolete to indicate it should not be used in future implementations. StaticEnrichers dependency is injected into MigrationProcessorBase and StaticProcessorBase to enhance the flexibility and extensibility of the processors.

♻️ (refactor): update migration context classes to use TfsMigrationProcessorBase and enrichers

Refactor migration context classes to inherit from TfsMigrationProcessorBase instead of MigrationProcessorBase. This change improves code consistency and leverages the new base class functionalities. Additionally, update constructors to include TfsStaticEnrichers and StaticEnrichers for better extensibility and maintainability. Remove the obsolete TestRunsMigrationContext class to clean up the codebase.

♻️ (MigrationContext): refactor migration contexts to use TfsMigrationProcessorBase and TfsStaticProcessorBase

Refactor migration contexts to inherit from `TfsMigrationProcessorBase` and `TfsStaticProcessorBase` for better code organization and consistency. This change also integrates `TfsStaticEnrichers` and `StaticEnrichers` into the constructors, ensuring that enrichers are properly utilized across different migration contexts. This improves the maintainability and extensibility of the codebase by centralizing common functionality and reducing redundancy.

♻️ (refactor): extend StaticProcessorBase to TfsStaticProcessorBase

Refactor multiple classes to inherit from the new TfsStaticProcessorBase
instead of StaticProcessorBase. This change introduces a new base class,
TfsStaticProcessorBase, which includes additional enrichers specific to
TFS (Team Foundation Server) migrations. This refactor aims to improve
code modularity and maintainability by separating TFS-specific logic
from the general static processor logic.

✨ (TfsStaticProcessorBase): add new abstract class TfsStaticProcessorBase

Introduce a new abstract class `TfsStaticProcessorBase` to serve as a base for TFS-specific static processors. This class extends `StaticProcessorBase` and includes additional dependencies specific to TFS, such as `TfsStaticEnrichers`. This change aims to modularize and encapsulate TFS-specific logic, making the codebase more maintainable and extensible.

appsettings.json

@@ -13,6 +13,14 @@
   },
   "MigrationTools": {
     "CommonEnrichers": {
+      "FieldMappingTool": {
+        "Enabled": false,
+        "FieldMaps": null
+      },
+      "TfsChangeSetMappingTool": {
+        "Enabled": false,
+        "File": null
+      },
       "TfsNodeStructure": {
         "Enabled": true,
         "NodeBasePaths": [],
@@ -84,10 +92,6 @@
       },
       "TfsEmbededImagesEnricher": {
         "Enabled": true
-      },
-      "TfsChangeSetMappingTool": {
-        "Enabled": false,
-        "File": "C:\\temp\\ChangeSetMappingFile.json"
       }
     },
     "ProcessorDefaults": {

configuration.json

@@ -57,11 +57,11 @@
         "ExportBasePath": "c:\\temp\\WorkItemAttachmentExport",
         "MaxRevisions": 480000000
       },
-      "TfsChangeSetMapping": {
+      "TfsChangeSetMappingTool": {
         "Enabled": true,
         "File": "C:\\temp\\ChangeSetMappingFile.json"
       },
-      "TfsFieldMappings": {
+      "FieldMappingTool": {
         "Enabled": true,
         "FieldMaps": [
           {

src/MigrationTools.Clients.AzureDevops.ObjectModel/Enrichers/TfsStaticEnrichers.cs

@@ -24,7 +24,6 @@ public class TfsStaticEnrichers
         public TfsEmbededImagesEnricher EmbededImages { get; private set; }
 
         public TfsGitRepositoryEnricher GitRepository { get; private set; }
-
         public TfsStaticEnrichers(ITelemetryLogger telemetry,
                                         ILogger<TfsStaticEnrichers> logger,
                                         TfsUserMappingEnricher userMappingEnricher,
@@ -34,7 +33,10 @@ public TfsStaticEnrichers(ITelemetryLogger telemetry,
                                         TfsWorkItemLinkEnricher workItemLinkEnricher,
                                         TfsWorkItemEmbededLinkEnricher workItemEmbeddedLinkEnricher,
                                         TfsValidateRequiredField requiredFieldValidator,
-                                        TfsTeamSettingsEnricher teamSettingsEnricher, TfsEmbededImagesEnricher embededImagesEnricher, TfsGitRepositoryEnricher tfsGitRepositoryEnricher)
+                                        TfsTeamSettingsEnricher teamSettingsEnricher,
+                                        TfsEmbededImagesEnricher embededImagesEnricher,
+                                        TfsGitRepositoryEnricher tfsGitRepositoryEnricher
+            )
         {
             UserMapping = userMappingEnricher;
             Attachment = attachmentEnricher;
@@ -46,7 +48,6 @@ public TfsStaticEnrichers(ITelemetryLogger telemetry,
             TeamSettings = teamSettingsEnricher;
             EmbededImages = embededImagesEnricher;
             GitRepository = tfsGitRepositoryEnricher;
-
         }
 
     }

src/MigrationTools.Clients.AzureDevops.ObjectModel/ProcessorEnrichers/TfsChangeSetMappingToolOptions.cs

@@ -5,7 +5,7 @@ namespace MigrationTools.ProcessorEnrichers
 {
     public class TfsChangeSetMappingToolOptions : ProcessorEnricherOptions
     {
-        public const string ConfigurationSectionName = "MigrationTools:CommonEnrichers:ChangeSetMappingTool";
+        public const string ConfigurationSectionName = "MigrationTools:CommonEnrichers:TfsChangeSetMappingTool";
         public override Type ToConfigure => typeof(TfsChangeSetMappingTool);
 
         public string ChangeSetMappingFile { get; set; }

src/MigrationTools.Clients.AzureDevops.ObjectModel/ServiceCollectionExtensions.cs

@@ -32,17 +32,26 @@ public static void AddMigrationToolServicesForClientAzureDevOpsObjectModel(this
             switch (configuration.GetMigrationConfigVersion())
             {
                 case ConfigurationExtensions.MigrationConfigVersion.before16:
-
                     context.AddSingleton<TfsAttachmentEnricher>().AddSingleton<IOptions<TfsAttachmentEnricherOptions>>(Microsoft.Extensions.Options.Options.Create(configuration.GetSectionCommonEnrichers_v15<TfsAttachmentEnricherOptions>(TfsAttachmentEnricherOptions.ConfigurationSectionName)));
+
                     context.AddSingleton<TfsUserMappingEnricher>().AddSingleton<IOptions<TfsUserMappingEnricherOptions>>(Microsoft.Extensions.Options.Options.Create(configuration.GetSectionCommonEnrichers_v15<TfsUserMappingEnricherOptions>(TfsUserMappingEnricherOptions.ConfigurationSectionName)));
+
                     context.AddSingleton<TfsValidateRequiredField>().AddSingleton<IOptions<TfsValidateRequiredFieldOptions>>(Microsoft.Extensions.Options.Options.Create(configuration.GetSectionCommonEnrichers_v15<TfsValidateRequiredFieldOptions>(TfsValidateRequiredFieldOptions.ConfigurationSectionName)));
+
                     context.AddSingleton<TfsWorkItemLinkEnricher>().AddSingleton<IOptions<TfsWorkItemLinkEnricherOptions>>(Microsoft.Extensions.Options.Options.Create(configuration.GetSectionCommonEnrichers_v15<TfsWorkItemLinkEnricherOptions>(TfsWorkItemLinkEnricherOptions.ConfigurationSectionName)));
+
                     context.AddSingleton<TfsWorkItemEmbededLinkEnricher>().AddSingleton<IOptions<TfsWorkItemEmbededLinkEnricherOptions>>(Microsoft.Extensions.Options.Options.Create(configuration.GetSectionCommonEnrichers_v15<TfsWorkItemEmbededLinkEnricherOptions>(TfsWorkItemEmbededLinkEnricherOptions.ConfigurationSectionName)));
+
                     context.AddSingleton<TfsEmbededImagesEnricher>().AddSingleton<IOptions<TfsEmbededImagesEnricherOptions>>(Microsoft.Extensions.Options.Options.Create(configuration.GetSectionCommonEnrichers_v15<TfsEmbededImagesEnricherOptions>(TfsEmbededImagesEnricherOptions.ConfigurationSectionName)));
+
                     context.AddSingleton<TfsGitRepositoryEnricher>().AddSingleton<IOptions<TfsGitRepositoryEnricherOptions>>(Microsoft.Extensions.Options.Options.Create(configuration.GetSectionCommonEnrichers_v15<TfsGitRepositoryEnricherOptions>(TfsGitRepositoryEnricherOptions.ConfigurationSectionName)));
+
                     context.AddSingleton<TfsNodeStructure>().AddSingleton<IOptions<TfsNodeStructureOptions>>(Microsoft.Extensions.Options.Options.Create(configuration.GetSectionCommonEnrichers_v15<TfsNodeStructureOptions>(TfsNodeStructureOptions.ConfigurationSectionName)));
+
                     context.AddSingleton<TfsRevisionManager>().AddSingleton<IOptions<TfsRevisionManagerOptions>>(Microsoft.Extensions.Options.Options.Create(configuration.GetSectionCommonEnrichers_v15<TfsRevisionManagerOptions>(TfsRevisionManagerOptions.ConfigurationSectionName)));
+
                     context.AddSingleton<TfsTeamSettingsEnricher>().AddSingleton<IOptions<TfsTeamSettingsEnricherOptions>>(Microsoft.Extensions.Options.Options.Create(configuration.GetSectionCommonEnrichers_v15<TfsTeamSettingsEnricherOptions>(TfsTeamSettingsEnricherOptions.ConfigurationSectionName)));
+
                     break;
                 case ConfigurationExtensions.MigrationConfigVersion.v16:
                     context.AddSingleton<TfsAttachmentEnricher>().AddOptions<TfsAttachmentEnricherOptions>().Bind(configuration.GetSection(TfsAttachmentEnricherOptions.ConfigurationSectionName));
@@ -57,6 +66,7 @@ public static void AddMigrationToolServicesForClientAzureDevOpsObjectModel(this
                     context.AddSingleton<TfsTeamSettingsEnricher>().AddOptions<TfsTeamSettingsEnricherOptions>().Bind(configuration.GetSection(TfsTeamSettingsEnricherOptions.ConfigurationSectionName));
                     break;
             }
+
             context.AddSingleton<TfsStaticEnrichers>();
 
             // EndPoint Enrichers

src/MigrationTools.Host.Tests/MigrationHostTests.cs

@@ -39,7 +39,7 @@ public void TestEngineExecuteEmptyFieldMaps()
         {
             EngineConfiguration ec = host.Services.GetRequiredService<EngineConfiguration>();
             ec.Processors.Clear();
-            ec.FieldMaps.Clear();
+            //ec.FieldMaps.Clear();
             IMigrationEngine me = host.Services.GetRequiredService<IMigrationEngine>();
             me.Run();
         }
@@ -49,7 +49,7 @@ public void TestEngineExecuteEmptyFieldMaps()
         public void TestEngineExecuteProcessors()
         {
             EngineConfiguration ec = host.Services.GetRequiredService<EngineConfiguration>();
-            ec.FieldMaps.Clear();
+            //ec.FieldMaps.Clear();
             IMigrationEngine me = host.Services.GetRequiredService<IMigrationEngine>();
             me.Run();
         }

src/MigrationTools.Host/MigrationToolHost.cs

@@ -117,7 +117,6 @@ public static IHostBuilder CreateDefaultBuilder(string[] args, Action<IConfigura
                                Log.Warning("!!ACTION REQUIRED!! You are using a deprecated version of the configuration, please update to v16. backward compatability will be removed in a future version.");
                                //logger.LogCritical("The config file {ConfigFile} uses an outdated format. We are continuing to support this format through a grace period. Use '{ExecutableName}.exe init' to create a new configuration file and port over your old configuration.", configFile, Assembly.GetEntryAssembly().GetName().Name);
                                var parsed = reader.BuildFromFile(configFile); // TODO revert tp 
-                               options.FieldMaps = parsed.FieldMaps;
                                options.GitRepoMapping = parsed.GitRepoMapping;
                                options.Processors = parsed.Processors;
                                options.Source = parsed.Source;
@@ -128,10 +127,6 @@ public static IHostBuilder CreateDefaultBuilder(string[] args, Action<IConfigura
                                // This code Converts the new config format to the v1 and v2 runtme format.
                                options.Version = configuration.GetValue<string>("MigrationTools:Version");
 
-                               //options.FieldMaps = configuration.GetSection("MigrationTools:FieldMaps").Get<IFieldMap[]>();
-
-                               options.FieldMaps = configuration.GetSection("MigrationTools:CommonEnrichers:TfsFieldMappings:FieldMaps")?.ToMigrationToolsList<IFieldMapConfig>(child => child.GetMigrationToolsOption<IFieldMapConfig>("FieldMapType"));
-
                                options.GitRepoMapping = configuration.GetSection("MigrationTools:CommonEnrichers:TfsGitRepoMappings:WorkItemGitRepos").Get<Dictionary<string, string>>();
 
                                options.Processors = configuration.GetSection("MigrationTools:Processors")?.ToMigrationToolsList<IProcessorConfig>(child => child.GetMigrationToolsOption<IProcessorConfig>("ProcessorType"));

src/MigrationTools.Tests/Core/Engine/Containers/FieldMapContainerTests.cs

@@ -5,32 +5,31 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MigrationTools._EngineV1.Configuration;
 using MigrationTools._EngineV1.Containers;
+using MigrationTools.ProcessorEnrichers.WorkItemProcessorEnrichers;
+using MigrationTools.Tests;
 
 namespace MigrationTools.Engine.Containers.Tests
 {
     [TestClass()]
     public class FieldMapContainerTests
     {
-        private IOptions<EngineConfiguration> CreateEngineConfiguration()
+        private IOptions<FieldMappingToolOptions> CreateFieldMappingToolOptions()
         {
-            var ecb = new EngineConfigurationBuilder(new NullLogger<EngineConfigurationBuilder>());
-            var ec = ecb.CreateEmptyConfig();
-            var opts = Microsoft.Extensions.Options.Options.Create(ec);
+           var options = new FieldMappingToolOptions();
+            options.Enabled = true;
+            var opts = Microsoft.Extensions.Options.Options.Create(options);
             return opts;
         }
 
         private IServiceProvider CreateServiceProvider()
         {
-            ServiceCollection sc = new ServiceCollection();
-            sc.AddTransient<SimpleFieldMapMock>();
-            IServiceProvider sp = sc.BuildServiceProvider();
-            return sp;
+            return ServiceProviderHelper.GetWorkItemMigrationProcessor();
         }
 
         [TestMethod(), TestCategory("L0")]
         public void FieldMapContainerTest()
         {
-            var config = CreateEngineConfiguration();
+            var config = CreateFieldMappingToolOptions();
 
             Assert.AreEqual(0, config.Value.FieldMaps.Count);
 
@@ -41,10 +40,8 @@ public void FieldMapContainerTest()
             config.Value.FieldMaps.Add(testSimple);
 
             Assert.AreEqual(1, config.Value.FieldMaps.Count);
-
-            var fieldMapContainer = new FieldMapContainer(CreateServiceProvider(), config, new NullLogger<FieldMapContainer>());
-            fieldMapContainer.EnsureConfigured();
-            Assert.AreEqual(1, fieldMapContainer.Count);
+           var fieldMappTool = ActivatorUtilities.CreateInstance<FieldMappingTool>(CreateServiceProvider(), config, new NullLogger<FieldMappingTool>());
+            Assert.AreEqual(1, fieldMappTool.Count);
         }
     }
 }