Use user mapping when migrating team capacities

Author: satano

src/MigrationTools.Clients.TfsObjectModel/Processors/TfsTeamSettingsCore.cs

@@ -1,12 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.TeamFoundation.Client;
 using Microsoft.TeamFoundation.Core.WebApi.Types;
 using Microsoft.TeamFoundation.Framework.Client;
 using Microsoft.TeamFoundation.Work.WebApi;
 using Microsoft.VisualStudio.Services.WebApi;
+using MigrationTools.Tools;
 
 namespace MigrationTools.Processors
 {
@@ -21,9 +23,11 @@ internal static void MigrateCapacities(
             TeamFoundationTeam targetTeam,
             Dictionary<string, string> iterationMap,
             Lazy<List<TeamFoundationIdentity>> identityCache,
+            bool useUserMapping,
             ITelemetryLogger telemetry,
             ILogger log,
-            LogLevel exceptionLogLevel)
+            LogLevel exceptionLogLevel,
+            IServiceProvider services)
         {
             log.LogInformation("Migrating team capacities..");
 
@@ -48,7 +52,7 @@ internal static void MigrateCapacities(
                         List<TeamMemberCapacityIdentityRef> sourceCapacities = GetSourceCapacities(
                             sourceHttpClient, sourceTeamContext, sourceIteration);
                         List<TeamMemberCapacityIdentityRef> targetCapacities = GetTargetCapacities(
-                            sourceCapacities, targetIteration.Path, identityCache, log);
+                            sourceCapacities, targetIteration.Path, useUserMapping, identityCache, log, services);
 
                         if (targetCapacities.Count > 0)
                         {
@@ -83,13 +87,22 @@ private static List<TeamMemberCapacityIdentityRef> GetSourceCapacities(
         private static List<TeamMemberCapacityIdentityRef> GetTargetCapacities(
             List<TeamMemberCapacityIdentityRef> sourceCapacities,
             string targetIteration,
+            bool useUserMapping,
             Lazy<List<TeamFoundationIdentity>> identityCache,
-            ILogger log)
+            ILogger log,
+            IServiceProvider services)
         {
-            var targetCapacities = new List<TeamMemberCapacityIdentityRef>();
+            List<TeamMemberCapacityIdentityRef> targetCapacities = [];
+            Dictionary<string, string> userMapping = null;
+            if (useUserMapping)
+            {
+                TfsCommonTools commonTools = services.GetRequiredService<TfsCommonTools>();
+                userMapping = commonTools.UserMapping.UserMappings.Value;
+            }
+
             foreach (var sourceCapacity in sourceCapacities)
             {
-                if (TryMatchIdentity(sourceCapacity, identityCache, out TeamFoundationIdentity targetIdentity))
+                if (TryMatchIdentity(sourceCapacity, identityCache, userMapping, out TeamFoundationIdentity targetIdentity))
                 {
                     targetCapacities.Add(new TeamMemberCapacityIdentityRef
                     {
@@ -127,51 +140,66 @@ private static void ReplaceTargetCapacities(
         private static bool TryMatchIdentity(
             TeamMemberCapacityIdentityRef sourceCapacity,
             Lazy<List<TeamFoundationIdentity>> identityCache,
+            Dictionary<string, string> userMapping,
             out TeamFoundationIdentity targetIdentity)
         {
-            var sourceDisplayName = sourceCapacity.TeamMember.DisplayName;
-            var index = sourceDisplayName.IndexOf("<");
+            var sourceName = sourceCapacity.TeamMember.DisplayName;
+            var index = sourceName.IndexOf("<");
             if (index > 0)
             {
-                sourceDisplayName = sourceDisplayName.Substring(0, index).Trim();
+                sourceName = sourceName.Substring(0, index).Trim();
             }
 
+            targetIdentity = MatchIdentity(sourceName, identityCache);
+            if ((targetIdentity is null) && (userMapping is not null))
+            {
+                if (userMapping.TryGetValue(sourceName, out var mappedName) && !string.IsNullOrEmpty(mappedName))
+                {
+                    targetIdentity = MatchIdentity(mappedName, identityCache);
+                }
+            }
+
+            // last attempt to match on unique name
+            // Match: "John Michael Bolden" to Bolden, "John Michael" on "[email protected]" unique name
+            if (targetIdentity is null)
+            {
+                var sourceUniqueName = sourceCapacity.TeamMember.UniqueName;
+                targetIdentity = identityCache.Value.FirstOrDefault(i => i.UniqueName == sourceUniqueName);
+            }
+
+            return targetIdentity is not null;
+        }
+
+        private static TeamFoundationIdentity MatchIdentity(string sourceName, Lazy<List<TeamFoundationIdentity>> identityCache)
+        {
             // Match:
             //   "Doe, John" to "Doe, John"
             //   "John Doe" to "John Doe"
-            targetIdentity = identityCache.Value.FirstOrDefault(i => i.DisplayName == sourceDisplayName);
+            TeamFoundationIdentity targetIdentity = identityCache.Value.FirstOrDefault(i => i.DisplayName == sourceName);
             if (targetIdentity == null)
             {
-                if (sourceDisplayName.Contains(", "))
+                if (sourceName.Contains(", "))
                 {
                     // Match:
                     //   "Doe, John" to "John Doe"
-                    var splitName = sourceDisplayName.Split(',');
-                    sourceDisplayName = $"{splitName[1].Trim()} {splitName[0].Trim()}";
-                    targetIdentity = identityCache.Value.FirstOrDefault(i => i.DisplayName == sourceDisplayName);
+                    var splitName = sourceName.Split(',');
+                    sourceName = $"{splitName[1].Trim()} {splitName[0].Trim()}";
+                    targetIdentity = identityCache.Value.FirstOrDefault(i => i.DisplayName == sourceName);
                 }
                 else
                 {
-                    if (sourceDisplayName.Contains(' '))
+                    if (sourceName.Contains(' '))
                     {
                         // Match:
                         //   "John Doe" to "Doe, John"
-                        var splitName = sourceDisplayName.Split(' ');
-                        sourceDisplayName = $"{splitName[1].Trim()}, {splitName[0].Trim()}";
-                        targetIdentity = identityCache.Value.FirstOrDefault(i => i.DisplayName == sourceDisplayName);
+                        var splitName = sourceName.Split(' ');
+                        sourceName = $"{splitName[1].Trim()}, {splitName[0].Trim()}";
+                        targetIdentity = identityCache.Value.FirstOrDefault(i => i.DisplayName == sourceName);
                     }
                 }
-
-                // last attempt to match on unique name
-                // Match: "John Michael Bolden" to Bolden, "John Michael" on "[email protected]" unique name
-                if (targetIdentity == null)
-                {
-                    var sourceUniqueName = sourceCapacity.TeamMember.UniqueName;
-                    targetIdentity = identityCache.Value.FirstOrDefault(i => i.UniqueName == sourceUniqueName);
-                }
             }
 
-            return targetIdentity is not null;
+            return targetIdentity;
         }
     }
 }

src/MigrationTools.Clients.TfsObjectModel/Processors/TfsTeamSettingsProcessor.cs

@@ -272,8 +272,8 @@ private void MigrateCapacities(
             TfsTeamSettingsCore.MigrateCapacities(
                 sourceHttpClient, Source.TfsProject.Guid, sourceTeam,
                 targetHttpClient, Target.TfsProject.Guid, targetTeam,
-                iterationMap, _targetTeamFoundationIdentitiesLazyCache,
-                Telemetry, Log, exceptionLogLevel: LogLevel.Warning);
+                iterationMap, _targetTeamFoundationIdentitiesLazyCache, Options.UseUserMapping,
+                Telemetry, Log, exceptionLogLevel: LogLevel.Warning, Services);
         }
     }
 }

src/MigrationTools.Clients.TfsObjectModel/Processors/TfsTeamSettingsProcessorOptions.cs

@@ -1,12 +1,10 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using MigrationTools.Processors.Infrastructure;
 
 namespace MigrationTools.Processors
 {
     public class TfsTeamSettingsProcessorOptions : ProcessorOptions
     {
-
         /// <summary>
         /// Migrate original team settings after their creation on target team project
         /// </summary>
@@ -36,5 +34,11 @@ public class TfsTeamSettingsProcessorOptions : ProcessorOptions
         /// </summary>
         public List<string> Teams { get; set; }
 
+        /// <summary>
+        /// Use user mapping file from TfsTeamSettingsTool when matching users when migrating capacities.
+        /// By default, users in source are matched in target users by current display name. When this is set to `true`,
+        /// users are matched also by mapped name from user mapping file.
+        /// </summary>
+        public bool UseUserMapping { get; set; }
     }
-}
+}

src/MigrationTools.Clients.TfsObjectModel/Tools/TfsTeamSettingsTool.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -231,8 +231,8 @@ private void MigrateCapacities(
             TfsTeamSettingsCore.MigrateCapacities(
                 _processor.Source.GetClient<WorkHttpClient>(), _processor.Source.WorkItems.Project.Guid, sourceTeam,
                 _processor.Target.GetClient<WorkHttpClient>(), _processor.Target.WorkItems.Project.Guid, targetTeam,
-                iterationMap, _targetTeamFoundationIdentitiesLazyCache,
-                Telemetry, Log, exceptionLogLevel: LogLevel.Error);
+                iterationMap, _targetTeamFoundationIdentitiesLazyCache, Options.UseUserMapping,
+                Telemetry, Log, exceptionLogLevel: LogLevel.Error, Services);
         }
     }
 }

src/MigrationTools.Clients.TfsObjectModel/Tools/TfsTeamSettingsToolOptions.cs

@@ -1,14 +1,10 @@
-using System;
-using System.Collections.Generic;
-using Microsoft.TeamFoundation.Build.Client;
-using MigrationTools.Enrichers;
+using System.Collections.Generic;
 using MigrationTools.Tools.Infrastructure;
 
 namespace MigrationTools.Tools
 {
     public class TfsTeamSettingsToolOptions : ToolOptions, ITfsTeamSettingsToolOptions
     {
-
         /// <summary>
         /// Migrate original team settings after their creation on target team project
         /// </summary>
@@ -27,22 +23,29 @@ public class TfsTeamSettingsToolOptions : ToolOptions, ITfsTeamSettingsToolOptio
         /// <default>false</default>
         public bool MigrateTeamCapacities { get; set; }
 
+        /// <summary>
+        /// Use user mapping file from TfsTeamSettingsTool when matching users when migrating capacities.
+        /// By default, users in source are matched in target users by current display name. When this is set to `true`,
+        /// users are matched also by mapped name from user mapping file.
+        /// </summary>
+        public bool UseUserMapping { get; set; }
+
         /// <summary>
         /// List of Teams to process. If this is `null` then all teams will be processed.
         /// </summary>
         public List<string> Teams { get; set; }
-
     }
 
     public interface ITfsTeamSettingsToolOptions
     {
-
         public bool MigrateTeamSettings { get; set; }
 
         public bool UpdateTeamSettings { get; set; }
 
         public bool MigrateTeamCapacities { get; set; }
 
         public List<string> Teams { get; set; }
+
+        public bool UseUserMapping { get; set; }
     }
-}
+}