Topic/niggles v16 2 (#2339)

MrHinsh · web-flow · commit 25ececfc7cbe · 2024-09-06T22:32:20.000+01:00
Two fixes for exceptions:

```
System.NullReferenceException: Ссылка на объект не указывает на экземпляр объекта.
   в MigrationTools.Tools.TfsNodeStructureTool.GetNewNodeName(String sourceNodePath, TfsNodeStructureType nodeStructureType) в D:\a\azure-devops-migration-tools\azure-devops-migration-tools\src\MigrationTools.Clients.TfsObjectModel\Tools\TfsNodeStructureTool.cs:строка 111
   в MigrationTools.Tools.TfsNodeStructureTool.CreateNodes(XmlNodeList nodeList, String treeType, TfsNodeStructureType nodeStructureType) в D:\a\azure-devops-migration-tools\azure-devops-migration-tools\src\MigrationTools.Clients.TfsObjectModel\Tools\TfsNodeStructureTool.cs:строка 349
   в MigrationTools.Tools.TfsNodeStructureTool.ProcessCommonStructure(String treeTypeSource, String localizedTreeTypeName, String projectTarget, TfsNodeStructureType nodeStructureType) в D:\a\azure-devops-migration-tools\azure-devops-migration-tools\src\MigrationTools.Clients.TfsObjectModel\Tools\TfsNodeStructureTool.cs:строка 468
   в MigrationTools.Tools.TfsNodeStructureTool.MigrateAllNodeStructures() в D:\a\azure-devops-migration-tools\azure-devops-migration-tools\src\MigrationTools.Clients.TfsObjectModel\Tools\TfsNodeStructureTool.cs:строка 400
   в MigrationTools.Tools.TfsNodeStructureTool.ProcessorExecutionBegin(TfsProcessor processor) в D:\a\azure-devops-migration-tools\azure-devops-migration-tools\src\MigrationTools.Clients.TfsObjectModel\Tools\TfsNodeStructureTool.cs:строка 278
   в MigrationTools.Processors.TfsWorkItemMigrationProcessor.InternalExecute() в D:\a\azure-devops-migration-tools\azure-devops-migration-tools\src\MigrationTools.Clients.TfsObjectModel\Processors\TfsWorkItemMigrationProcessor.cs:строка 103
   в MigrationTools.Processors.Infrastructure.Processor.Execute() в D:\a\azure-devops-migration-tools\azure-devops-migration-tools\src\MigrationTools\Processors\Infrastructure\Processor.cs:строка 105
```

and 

```
System.FormatException: Die Eingabezeichenfolge hat das falsche Format.
   bei System.Text.StringBuilder.FormatError()
   bei System.Text.StringBuilder.AppendFormatHelper(IFormatProvider provider, String format, ParamsArray args)
   bei System.String.FormatHelper(IFormatProvider provider, String format, ParamsArray args)
   bei System.String.Format(String format, Object arg0, Object arg1)
   bei MigrationTools.Processors.TfsWorkItemMigrationProcessor.CreateWorkItem_Shell(ProjectData destProject, WorkItemData currentRevisionWorkItem, String destType) in D:\a\azure-devops-migration-tools\azure-devops-migration-tools\src\MigrationTools.Clients.TfsObjectModel\Processors\TfsWorkItemMigrationProcessor.cs:Zeile 360.
   bei MigrationTools.Processors.TfsWorkItemMigrationProcessor.ReplayRevisions(List`1 revisionsToMigrate, WorkItemData sourceWorkItem, WorkItemData targetWorkItem) in D:\a\azure-devops-migration-tools\azure-devops-migration-tools\src\MigrationTools.Clients.TfsObjectModel\Processors\TfsWorkItemMigrationProcessor.cs:Zeile 687.
```
diff --git a/docs/Reference/Generated/MigrationTools.xml b/docs/Reference/Generated/MigrationTools.xml
diff --git a/src/MigrationTools.Clients.TfsObjectModel/Processors/TfsWorkItemMigrationProcessor.cs b/src/MigrationTools.Clients.TfsObjectModel/Processors/TfsWorkItemMigrationProcessor.cs
@@ -357,7 +357,7 @@ private WorkItemData CreateWorkItem_Shell(ProjectData destProject, WorkItemData
                 }
                 else
                 {
-                    throw new Exception(string.Format("WARNING: Unable to find '{0}' in the target project. Either the work item specific is from the source, or its being specified in the {tool} defenition in your configuration file! ", destType, nameof(WorkItemTypeMappingTool)));
+                    throw new Exception($"WARNING: Unable to find '{destType}' in the target project. Either the work item specific is from the source, or its being specified in the {nameof(WorkItemTypeMappingTool)} definition in your configuration file! ");
                 }
                 activity?.Stop();
                 activity?.SetStatus(ActivityStatusCode.Ok);
diff --git a/src/MigrationTools.Clients.TfsObjectModel/Tools/TfsNodeStructureTool.cs b/src/MigrationTools.Clients.TfsObjectModel/Tools/TfsNodeStructureTool.cs
@@ -59,7 +59,7 @@ public class TfsNodeStructureTool : Tool<TfsNodeStructureToolOptions>
         private string _sourceProjectName;
         private NodeInfo[] _sourceRootNodes;
         private ICommonStructureService4 _targetCommonStructureService;
-        
+
         private string _targetProjectName;
         private KeyValuePair<string, string>? _lastResortRemapRule;
 
@@ -77,7 +77,7 @@ public void ApplySettings(TfsNodeStructureToolSettings settings)
             _targetProjectName = settings.TargetProjectName;
         }
 
-        public void ValidateAllNodesExistOrAreMapped(TfsProcessor processor, List<WorkItemData> sourceWorkItems, string sourceProject,string targetProject)
+        public void ValidateAllNodesExistOrAreMapped(TfsProcessor processor, List<WorkItemData> sourceWorkItems, string sourceProject, string targetProject)
         {
             ContextLog.Information("Validating::Check that all Area & Iteration paths from Source have a valid mapping on Target");
             if (!Options.Enabled && targetProject != sourceProject)
@@ -108,22 +108,24 @@ public string GetNewNodeName(string sourceNodePath, TfsNodeStructureType nodeStr
             var lastResortRule = GetLastResortRemappingRule();
 
             Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers", mappers);
-            foreach (var mapper in mappers)
+            if (mappers != null)
             {
-                Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}", mapper.Key);
-                if (Regex.IsMatch(sourceNodePath, mapper.Key, RegexOptions.IgnoreCase))
-                {
-                    Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::Match", mapper.Key);
-                    string replacement = Regex.Replace(sourceNodePath, mapper.Key, mapper.Value);
-                    Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::replaceWith({replace})", mapper.Key, replacement);
-                    return replacement;
-                }
-                else
+                foreach (var mapper in mappers)
                 {
-                    Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::NoMatch", mapper.Key);
+                    Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}", mapper.Key);
+                    if (Regex.IsMatch(sourceNodePath, mapper.Key, RegexOptions.IgnoreCase))
+                    {
+                        Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::Match", mapper.Key);
+                        string replacement = Regex.Replace(sourceNodePath, mapper.Key, mapper.Value);
+                        Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::replaceWith({replace})", mapper.Key, replacement);
+                        return replacement;
+                    }
+                    else
+                    {
+                        Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::NoMatch", mapper.Key);
+                    }
                 }
             }
-
             if (!Regex.IsMatch(sourceNodePath, lastResortRule.Key, RegexOptions.IgnoreCase))
             {
                 Log.LogWarning("NodeStructureEnricher.NodePathNotAnchoredException({sourceNodePath}, {nodeStructureType})", sourceNodePath, nodeStructureType.ToString());
@@ -153,7 +155,7 @@ private KeyValuePair<string, string> GetLastResortRemappingRule()
 
         private NodeInfo GetOrCreateNode(string nodePath, DateTime? startDate, DateTime? finishDate)
         {
-             Log.LogDebug("TfsNodeStructureTool:GetOrCreateNode({nodePath}, {startDate}, {finishDate})", nodePath, startDate, finishDate);
+            Log.LogDebug("TfsNodeStructureTool:GetOrCreateNode({nodePath}, {startDate}, {finishDate})", nodePath, startDate, finishDate);
             if (_pathToKnownNodeMap.TryGetValue(nodePath, out var info))
             {
                 Log.LogInformation(" Node {0} already migrated, nothing to do", nodePath);
@@ -261,13 +263,13 @@ private Dictionary<string, string> GetMaps(TfsNodeStructureType nodeStructureTyp
                 case TfsNodeStructureType.Area:
                     return Options.Areas != null ? Options.Areas.Mappings : new Dictionary<string, string>();
                 case TfsNodeStructureType.Iteration:
-                    return Options.Iterations != null ?  Options.Iterations.Mappings : new Dictionary<string, string>();
+                    return Options.Iterations != null ? Options.Iterations.Mappings : new Dictionary<string, string>();
                 default:
                     throw new ArgumentOutOfRangeException(nameof(nodeStructureType), nodeStructureType, null);
             }
         }
 
-        public  void ProcessorExecutionBegin(TfsProcessor processor)
+        public void ProcessorExecutionBegin(TfsProcessor processor)
         {
             if (Options.Enabled)
             {
@@ -278,13 +280,14 @@ public  void ProcessorExecutionBegin(TfsProcessor processor)
                     MigrateAllNodeStructures();
                 }
                 RefreshForProcessorType(processor);
-            } else
+            }
+            else
             {
                 Log.LogWarning("TfsNodeStructureTool: TfsNodeStructureTool is disabled! This may cause work item migration errors! ");
             }
         }
 
-        protected  void EntryForProcessorType(TfsProcessor processor)
+        protected void EntryForProcessorType(TfsProcessor processor)
         {
             if (processor is null)
             {
@@ -309,10 +312,10 @@ protected  void EntryForProcessorType(TfsProcessor processor)
             }
         }
 
-        protected  void RefreshForProcessorType(TfsProcessor processor)
+        protected void RefreshForProcessorType(TfsProcessor processor)
         {
- 
-                ((TfsWorkItemMigrationClient)processor.Target.WorkItems).Store?.RefreshCache(true);
+
+            ((TfsWorkItemMigrationClient)processor.Target.WorkItems).Store?.RefreshCache(true);
         }
 
         private void CreateNodes(XmlNodeList nodeList, string treeType, TfsNodeStructureType nodeStructureType)
@@ -493,7 +496,7 @@ private bool ShouldCreateNode(string userFriendlyPath, TfsNodeStructureType node
                 if (DotNet.Globbing.Glob.Parse(filter).IsMatch(userFriendlyPath))
                 {
                     if (!_matchedPath.Contains(userFriendlyPath))
-                    { 
+                    {
                         _matchedPath.Add(userFriendlyPath);
                         return true;
                     }
@@ -534,7 +537,7 @@ public string GetFieldNameFromTfsNodeStructureToolType(TfsNodeStructureType node
         public List<NodeStructureItem> CheckForMissingPaths(TfsProcessor processor, List<WorkItemData> workItems, TfsNodeStructureType nodeType)
         {
             EntryForProcessorType(processor);
-             Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths");
+            Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths");
             _targetCommonStructureService.ClearProjectInfoCache();
 
             string fieldName = GetFieldNameFromTfsNodeStructureToolType(nodeType);
@@ -545,24 +548,24 @@ public List<NodeStructureItem> CheckForMissingPaths(TfsProcessor processor, List
                 .Distinct()
                 .ToList();
 
-             Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths::{nodeType}Nodes::{count}", nodeType.ToString(), nodePaths.Count);
+            Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths::{nodeType}Nodes::{count}", nodeType.ToString(), nodePaths.Count);
 
             List<NodeStructureItem> missingPaths = new List<NodeStructureItem>();
 
             foreach (var missingItem in nodePaths)
             {
-                 Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:Checking::{sourceSystemPath}", missingItem.sourceSystemPath);
-                 Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:Checking::{@missingItem}", missingItem);
+                Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:Checking::{sourceSystemPath}", missingItem.sourceSystemPath);
+                Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:Checking::{@missingItem}", missingItem);
                 bool keepProcessing = true;
                 try
                 {
                     missingItem.targetPath = GetNewNodeName(missingItem.sourcePath, nodeType);
-                     Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:GetNewNodeName::{@missingItem}", missingItem);
+                    Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:GetNewNodeName::{@missingItem}", missingItem);
                 }
                 catch (NodePathNotAnchoredException ex)
                 {
-                     Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:NodePathNotAnchoredException::{sourceSystemPath}", missingItem.sourceSystemPath);
-                     Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:NodePathNotAnchoredException::{@missingItem}", missingItem);
+                    Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:NodePathNotAnchoredException::{sourceSystemPath}", missingItem.sourceSystemPath);
+                    Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:NodePathNotAnchoredException::{@missingItem}", missingItem);
                     missingItem.anchored = false;
                     List<int> workItemsNotAncored = workItems.SelectMany(x => x.Revisions.Values)
                         .Where(x => x.Fields[fieldName].Value.ToString().Contains(missingItem.sourcePath))
@@ -580,13 +583,13 @@ public List<NodeStructureItem> CheckForMissingPaths(TfsProcessor processor, List
                     PopulateIterationDatesFronSource(missingItem);
                     try
                     {
-                         Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::{targetSystemPath}", missingItem.targetSystemPath);
+                        Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::{targetSystemPath}", missingItem.targetSystemPath);
                         NodeInfo c = _targetCommonStructureService.GetNodeFromPath(missingItem.targetSystemPath);
-                         Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::FOUND::{@missingItem}::FOUND", missingItem);
+                        Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::FOUND::{@missingItem}::FOUND", missingItem);
                     }
                     catch
                     {
-                         Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::NOTFOUND:{targetSystemPath}", missingItem.targetSystemPath);
+                        Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::NOTFOUND:{targetSystemPath}", missingItem.targetSystemPath);
                         if (Options.ShouldCreateMissingRevisionPaths && ShouldCreateNode(missingItem.targetSystemPath, nodeType))
                         {
 
@@ -595,7 +598,7 @@ public List<NodeStructureItem> CheckForMissingPaths(TfsProcessor processor, List
                         else
                         {
                             missingPaths.Add(missingItem);
-                             Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::LOG-ONLY::{@missingItem}", missingItem);
+                            Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::LOG-ONLY::{@missingItem}", missingItem);
                         }
                     }
                 }
@@ -611,7 +614,7 @@ private void PopulateIterationDatesFronSource(NodeStructureItem missingItem)
         {
             if (missingItem.nodeType == "Iteration")
             {
-                 Log.LogDebug("TfsNodeStructureTool:PopulateIterationDatesFronSource:{sourceSystemPath}", missingItem.sourceSystemPath);
+                Log.LogDebug("TfsNodeStructureTool:PopulateIterationDatesFronSource:{sourceSystemPath}", missingItem.sourceSystemPath);
                 try
                 {
                     var sourceNode = _sourceCommonStructureService.GetNodeFromPath(missingItem.sourceSystemPath);
@@ -621,7 +624,7 @@ private void PopulateIterationDatesFronSource(NodeStructureItem missingItem)
                 }
                 catch (Exception)
                 {
-                     Log.LogTrace("TfsNodeStructureTool:PopulateIterationDatesFronSource:{@missingItem}", missingItem);
+                    Log.LogTrace("TfsNodeStructureTool:PopulateIterationDatesFronSource:{@missingItem}", missingItem);
                     missingItem.startDate = null;
                     missingItem.finishDate = null;
                     missingItem.sourcePathExists = false;

Original file line number	Diff line number	Diff line change
`@@ -357,7 +357,7 @@ private WorkItemData CreateWorkItem_Shell(ProjectData destProject, WorkItemData`
`357`	`357`	`}`
`358`	`358`	`else`
`359`	`359`	`{`
`360`		`- throw new Exception(string.Format("WARNING: Unable to find '{0}' in the target project. Either the work item specific is from the source, or its being specified in the {tool} defenition in your configuration file! ", destType, nameof(WorkItemTypeMappingTool)));`
	`360`	`+ throw new Exception($"WARNING: Unable to find '{destType}' in the target project. Either the work item specific is from the source, or its being specified in the {nameof(WorkItemTypeMappingTool)} definition in your configuration file! ");`
`361`	`361`	`}`
`362`	`362`	`activity?.Stop();`
`363`	`363`	`activity?.SetStatus(ActivityStatusCode.Ok);`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public class TfsNodeStructureTool : Tool<TfsNodeStructureToolOptions>`
`59`	`59`	`private string _sourceProjectName;`
`60`	`60`	`private NodeInfo[] _sourceRootNodes;`
`61`	`61`	`private ICommonStructureService4 _targetCommonStructureService;`
`62`		`-`
	`62`	`+`
`63`	`63`	`private string _targetProjectName;`
`64`	`64`	`private KeyValuePair<string, string>? _lastResortRemapRule;`
`65`	`65`
`@@ -77,7 +77,7 @@ public void ApplySettings(TfsNodeStructureToolSettings settings)`
`77`	`77`	`_targetProjectName = settings.TargetProjectName;`
`78`	`78`	`}`
`79`	`79`
`80`		`- public void ValidateAllNodesExistOrAreMapped(TfsProcessor processor, List<WorkItemData> sourceWorkItems, string sourceProject,string targetProject)`
	`80`	`+ public void ValidateAllNodesExistOrAreMapped(TfsProcessor processor, List<WorkItemData> sourceWorkItems, string sourceProject, string targetProject)`
`81`	`81`	`{`
`82`	`82`	`ContextLog.Information("Validating::Check that all Area & Iteration paths from Source have a valid mapping on Target");`
`83`	`83`	`if (!Options.Enabled && targetProject != sourceProject)`
`@@ -108,22 +108,24 @@ public string GetNewNodeName(string sourceNodePath, TfsNodeStructureType nodeStr`
`108`	`108`	`var lastResortRule = GetLastResortRemappingRule();`
`109`	`109`
`110`	`110`	`Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers", mappers);`
`111`		`- foreach (var mapper in mappers)`
	`111`	`+ if (mappers != null)`
`112`	`112`	`{`
`113`		`- Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}", mapper.Key);`
`114`		`- if (Regex.IsMatch(sourceNodePath, mapper.Key, RegexOptions.IgnoreCase))`
`115`		`- {`
`116`		`- Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::Match", mapper.Key);`
`117`		`- string replacement = Regex.Replace(sourceNodePath, mapper.Key, mapper.Value);`
`118`		`- Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::replaceWith({replace})", mapper.Key, replacement);`
`119`		`- return replacement;`
`120`		`- }`
`121`		`- else`
	`113`	`+ foreach (var mapper in mappers)`
`122`	`114`	`{`
`123`		`- Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::NoMatch", mapper.Key);`
	`115`	`+ Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}", mapper.Key);`
	`116`	`+ if (Regex.IsMatch(sourceNodePath, mapper.Key, RegexOptions.IgnoreCase))`
	`117`	`+ {`
	`118`	`+ Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::Match", mapper.Key);`
	`119`	`+ string replacement = Regex.Replace(sourceNodePath, mapper.Key, mapper.Value);`
	`120`	`+ Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::replaceWith({replace})", mapper.Key, replacement);`
	`121`	`+ return replacement;`
	`122`	`+ }`
	`123`	`+ else`
	`124`	`+ {`
	`125`	`+ Log.LogDebug("NodeStructureEnricher.GetNewNodeName::Mappers::{key}::NoMatch", mapper.Key);`
	`126`	`+ }`
`124`	`127`	`}`
`125`	`128`	`}`
`126`		`-`
`127`	`129`	`if (!Regex.IsMatch(sourceNodePath, lastResortRule.Key, RegexOptions.IgnoreCase))`
`128`	`130`	`{`
`129`	`131`	`Log.LogWarning("NodeStructureEnricher.NodePathNotAnchoredException({sourceNodePath}, {nodeStructureType})", sourceNodePath, nodeStructureType.ToString());`
`@@ -153,7 +155,7 @@ private KeyValuePair<string, string> GetLastResortRemappingRule()`
`153`	`155`
`154`	`156`	`private NodeInfo GetOrCreateNode(string nodePath, DateTime? startDate, DateTime? finishDate)`
`155`	`157`	`{`
`156`		`- Log.LogDebug("TfsNodeStructureTool:GetOrCreateNode({nodePath}, {startDate}, {finishDate})", nodePath, startDate, finishDate);`
	`158`	`+ Log.LogDebug("TfsNodeStructureTool:GetOrCreateNode({nodePath}, {startDate}, {finishDate})", nodePath, startDate, finishDate);`
`157`	`159`	`if (_pathToKnownNodeMap.TryGetValue(nodePath, out var info))`
`158`	`160`	`{`
`159`	`161`	`Log.LogInformation(" Node {0} already migrated, nothing to do", nodePath);`
`@@ -261,13 +263,13 @@ private Dictionary<string, string> GetMaps(TfsNodeStructureType nodeStructureTyp`
`261`	`263`	`case TfsNodeStructureType.Area:`
`262`	`264`	`return Options.Areas != null ? Options.Areas.Mappings : new Dictionary<string, string>();`
`263`	`265`	`case TfsNodeStructureType.Iteration:`
`264`		`- return Options.Iterations != null ? Options.Iterations.Mappings : new Dictionary<string, string>();`
	`266`	`+ return Options.Iterations != null ? Options.Iterations.Mappings : new Dictionary<string, string>();`
`265`	`267`	`default:`
`266`	`268`	`throw new ArgumentOutOfRangeException(nameof(nodeStructureType), nodeStructureType, null);`
`267`	`269`	`}`
`268`	`270`	`}`
`269`	`271`
`270`		`- public void ProcessorExecutionBegin(TfsProcessor processor)`
	`272`	`+ public void ProcessorExecutionBegin(TfsProcessor processor)`
`271`	`273`	`{`
`272`	`274`	`if (Options.Enabled)`
`273`	`275`	`{`
`@@ -278,13 +280,14 @@ public void ProcessorExecutionBegin(TfsProcessor processor)`
`278`	`280`	`MigrateAllNodeStructures();`
`279`	`281`	`}`
`280`	`282`	`RefreshForProcessorType(processor);`
`281`		`- } else`
	`283`	`+ }`
	`284`	`+ else`
`282`	`285`	`{`
`283`	`286`	`Log.LogWarning("TfsNodeStructureTool: TfsNodeStructureTool is disabled! This may cause work item migration errors! ");`
`284`	`287`	`}`
`285`	`288`	`}`
`286`	`289`
`287`		`- protected void EntryForProcessorType(TfsProcessor processor)`
	`290`	`+ protected void EntryForProcessorType(TfsProcessor processor)`
`288`	`291`	`{`
`289`	`292`	`if (processor is null)`
`290`	`293`	`{`
`@@ -309,10 +312,10 @@ protected void EntryForProcessorType(TfsProcessor processor)`
`309`	`312`	`}`
`310`	`313`	`}`
`311`	`314`
`312`		`- protected void RefreshForProcessorType(TfsProcessor processor)`
	`315`	`+ protected void RefreshForProcessorType(TfsProcessor processor)`
`313`	`316`	`{`
`314`		`-`
`315`		`- ((TfsWorkItemMigrationClient)processor.Target.WorkItems).Store?.RefreshCache(true);`
	`317`	`+`
	`318`	`+ ((TfsWorkItemMigrationClient)processor.Target.WorkItems).Store?.RefreshCache(true);`
`316`	`319`	`}`
`317`	`320`
`318`	`321`	`private void CreateNodes(XmlNodeList nodeList, string treeType, TfsNodeStructureType nodeStructureType)`
`@@ -493,7 +496,7 @@ private bool ShouldCreateNode(string userFriendlyPath, TfsNodeStructureType node`
`493`	`496`	`if (DotNet.Globbing.Glob.Parse(filter).IsMatch(userFriendlyPath))`
`494`	`497`	`{`
`495`	`498`	`if (!_matchedPath.Contains(userFriendlyPath))`
`496`		`- {`
	`499`	`+ {`
`497`	`500`	`_matchedPath.Add(userFriendlyPath);`
`498`	`501`	`return true;`
`499`	`502`	`}`
`@@ -534,7 +537,7 @@ public string GetFieldNameFromTfsNodeStructureToolType(TfsNodeStructureType node`
`534`	`537`	`public List<NodeStructureItem> CheckForMissingPaths(TfsProcessor processor, List<WorkItemData> workItems, TfsNodeStructureType nodeType)`
`535`	`538`	`{`
`536`	`539`	`EntryForProcessorType(processor);`
`537`		`- Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths");`
	`540`	`+ Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths");`
`538`	`541`	`_targetCommonStructureService.ClearProjectInfoCache();`
`539`	`542`
`540`	`543`	`string fieldName = GetFieldNameFromTfsNodeStructureToolType(nodeType);`
`@@ -545,24 +548,24 @@ public List<NodeStructureItem> CheckForMissingPaths(TfsProcessor processor, List`
`545`	`548`	`.Distinct()`
`546`	`549`	`.ToList();`
`547`	`550`
`548`		`- Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths::{nodeType}Nodes::{count}", nodeType.ToString(), nodePaths.Count);`
	`551`	`+ Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths::{nodeType}Nodes::{count}", nodeType.ToString(), nodePaths.Count);`
`549`	`552`
`550`	`553`	`List<NodeStructureItem> missingPaths = new List<NodeStructureItem>();`
`551`	`554`
`552`	`555`	`foreach (var missingItem in nodePaths)`
`553`	`556`	`{`
`554`		`- Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:Checking::{sourceSystemPath}", missingItem.sourceSystemPath);`
`555`		`- Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:Checking::{@missingItem}", missingItem);`
	`557`	`+ Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:Checking::{sourceSystemPath}", missingItem.sourceSystemPath);`
	`558`	`+ Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:Checking::{@missingItem}", missingItem);`
`556`	`559`	`bool keepProcessing = true;`
`557`	`560`	`try`
`558`	`561`	`{`
`559`	`562`	`missingItem.targetPath = GetNewNodeName(missingItem.sourcePath, nodeType);`
`560`		`- Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:GetNewNodeName::{@missingItem}", missingItem);`
	`563`	`+ Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:GetNewNodeName::{@missingItem}", missingItem);`
`561`	`564`	`}`
`562`	`565`	`catch (NodePathNotAnchoredException ex)`
`563`	`566`	`{`
`564`		`- Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:NodePathNotAnchoredException::{sourceSystemPath}", missingItem.sourceSystemPath);`
`565`		`- Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:NodePathNotAnchoredException::{@missingItem}", missingItem);`
	`567`	`+ Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:NodePathNotAnchoredException::{sourceSystemPath}", missingItem.sourceSystemPath);`
	`568`	`+ Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:NodePathNotAnchoredException::{@missingItem}", missingItem);`
`566`	`569`	`missingItem.anchored = false;`
`567`	`570`	`List<int> workItemsNotAncored = workItems.SelectMany(x => x.Revisions.Values)`
`568`	`571`	`.Where(x => x.Fields[fieldName].Value.ToString().Contains(missingItem.sourcePath))`
`@@ -580,13 +583,13 @@ public List<NodeStructureItem> CheckForMissingPaths(TfsProcessor processor, List`
`580`	`583`	`PopulateIterationDatesFronSource(missingItem);`
`581`	`584`	`try`
`582`	`585`	`{`
`583`		`- Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::{targetSystemPath}", missingItem.targetSystemPath);`
	`586`	`+ Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::{targetSystemPath}", missingItem.targetSystemPath);`
`584`	`587`	`NodeInfo c = _targetCommonStructureService.GetNodeFromPath(missingItem.targetSystemPath);`
`585`		`- Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::FOUND::{@missingItem}::FOUND", missingItem);`
	`588`	`+ Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::FOUND::{@missingItem}::FOUND", missingItem);`
`586`	`589`	`}`
`587`	`590`	`catch`
`588`	`591`	`{`
`589`		`- Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::NOTFOUND:{targetSystemPath}", missingItem.targetSystemPath);`
	`592`	`+ Log.LogDebug("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::NOTFOUND:{targetSystemPath}", missingItem.targetSystemPath);`
`590`	`593`	`if (Options.ShouldCreateMissingRevisionPaths && ShouldCreateNode(missingItem.targetSystemPath, nodeType))`
`591`	`594`	`{`
`592`	`595`
`@@ -595,7 +598,7 @@ public List<NodeStructureItem> CheckForMissingPaths(TfsProcessor processor, List`
`595`	`598`	`else`
`596`	`599`	`{`
`597`	`600`	`missingPaths.Add(missingItem);`
`598`		`- Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::LOG-ONLY::{@missingItem}", missingItem);`
	`601`	`+ Log.LogTrace("TfsNodeStructureTool:CheckForMissingPaths:CheckTarget::LOG-ONLY::{@missingItem}", missingItem);`
`599`	`602`	`}`
`600`	`603`	`}`
`601`	`604`	`}`
`@@ -611,7 +614,7 @@ private void PopulateIterationDatesFronSource(NodeStructureItem missingItem)`
`611`	`614`	`{`
`612`	`615`	`if (missingItem.nodeType == "Iteration")`
`613`	`616`	`{`
`614`		`- Log.LogDebug("TfsNodeStructureTool:PopulateIterationDatesFronSource:{sourceSystemPath}", missingItem.sourceSystemPath);`
	`617`	`+ Log.LogDebug("TfsNodeStructureTool:PopulateIterationDatesFronSource:{sourceSystemPath}", missingItem.sourceSystemPath);`
`615`	`618`	`try`
`616`	`619`	`{`
`617`	`620`	`var sourceNode = _sourceCommonStructureService.GetNodeFromPath(missingItem.sourceSystemPath);`
`@@ -621,7 +624,7 @@ private void PopulateIterationDatesFronSource(NodeStructureItem missingItem)`
`621`	`624`	`}`
`622`	`625`	`catch (Exception)`
`623`	`626`	`{`
`624`		`- Log.LogTrace("TfsNodeStructureTool:PopulateIterationDatesFronSource:{@missingItem}", missingItem);`
	`627`	`+ Log.LogTrace("TfsNodeStructureTool:PopulateIterationDatesFronSource:{@missingItem}", missingItem);`
`625`	`628`	`missingItem.startDate = null;`
`626`	`629`	`missingItem.finishDate = null;`
`627`	`630`	`missingItem.sourcePathExists = false;`