private void SetQueryItem(QueryFolder queryFolder, QueryFolder parentFolder, string sourceProjectName)
{
QueryItem newItem = null;
foreach (QueryItem subQuery in queryFolder)
{
try
{
if (subQuery.GetType() == typeof(QueryFolder))
{
newItem = new QueryFolder(subQuery.Name);
if (!parentFolder.Contains(subQuery.Name))
{
parentFolder.Add(newItem);
store.Projects[projectName].QueryHierarchy.Save();
SetQueryItem((QueryFolder)subQuery, (QueryFolder)newItem, sourceProjectName);
}
else
{
logger.Info(String.Format("Query Folder {0} already exists", subQuery));
}
}
else
{
QueryDefinition oldDef = (QueryDefinition)subQuery;
string queryText = oldDef.QueryText.Replace(sourceProjectName, projectName).Replace("User Story", "Product Backlog Item").Replace("Issue", "Impediment");
newItem = new QueryDefinition(subQuery.Name, queryText);
if (!parentFolder.Contains(subQuery.Name))
{
parentFolder.Add(newItem);
store.Projects[projectName].QueryHierarchy.Save();
}
else
{
logger.Info(String.Format("Query Definition {0} already exists", subQuery));
}
}
}
catch (Exception ex)
{
if (newItem != null)
{
newItem.Delete();
}
logger.Info(String.Format("Error creating Query: {0} : {1}", subQuery, ex.Message));
continue;
}
}
}
private static QueryDefinition CreateNewQuery(Project workItemProject, QueryFolder myQueriesFolder, string queryName)
{
QueryDefinition newBugsQuery = new QueryDefinition(queryName,
@"SELECT [System.Id],[System.WorkItemType],
[System.Title],[System.AssignedTo],[System.State],[System.Tags]
FROM WorkItems WHERE[System.WorkItemType] = '{0}'
AND[System.State] = 'New'");
myQueriesFolder.Add(newBugsQuery);
workItemProject.QueryHierarchy.Save();
return(newBugsQuery);
}
/// <summary>
/// Add Query Definition under a specific Query Folder.
/// </summary>
/// <param name="targetHierarchy">The object that represents the whole of the target query tree</param>
/// <param name="query">Query Definition - Contains the Query Details</param>
/// <param name="QueryFolder">Parent Folder</param>
void MigrateQuery(QueryHierarchy targetHierarchy, QueryDefinition query, QueryFolder parentFolder)
{
if (parentFolder.FirstOrDefault(q => q.Name == query.Name) != null)
{
this.totalQueriesSkipped++;
Trace.WriteLine($"Skipping query '{query.Name}' as already exists");
}
else
{
// Sort out any path issues in the quertText
var fixedQueryText = query.QueryText.Replace($"'{Engine.Source.Config.Project}", $"'{Engine.Target.Config.Project}"); // the ' should only items at the start of areapath etc.
if (config.PrefixProjectToNodes)
{
// we need to inject the team name as a folder in the structure too
fixedQueryText = fixedQueryText.Replace($"{Engine.Target.Config.Project}\\", $"{Engine.Target.Config.Project}\\{Engine.Source.Config.Project}\\");
}
if (config.SourceToTargetFieldMappings != null)
{
foreach (var sourceField in config.SourceToTargetFieldMappings.Keys)
{
fixedQueryText = query.QueryText.Replace($"{sourceField}", $"'{config.SourceToTargetFieldMappings[sourceField]}");
}
}
// you cannot just add an item from one store to another, we need to create a new object
var queryCopy = new QueryDefinition(query.Name, fixedQueryText);
this.totalQueriesAttempted++;
Trace.WriteLine($"Migrating query '{query.Name}'");
parentFolder.Add(queryCopy);
try
{
targetHierarchy.Save(); // moved the save here for better error message
this.totalQueriesMigrated++;
}
catch (Exception ex)
{
this.totalQueryFailed++;
Trace.WriteLine($"Error saving query '{query.Name}', probably due to invalid area or iteration paths");
Trace.WriteLine($"Source Query: '{query}'");
Trace.WriteLine($"Target Query: '{fixedQueryText}'");
Trace.WriteLine(ex.Message);
targetHierarchy.Refresh(); // get the tree without the last edit
}
}
}
private void CreateFolderHyerarchy(string[] toCreate, QueryItem currentItem, int focus = 0)
{
if (currentItem is QueryFolder)
{
QueryFolder currentFolder = (QueryFolder)currentItem;
if (!currentFolder.Contains(toCreate[focus]))
{
currentFolder.Add(new QueryFolder(toCreate[focus]));
Log.LogInformation(" Created: {0}", toCreate[focus]);
}
if (toCreate.Length != focus + 1)
{
CreateFolderHyerarchy(toCreate, currentFolder[toCreate[focus]], focus + 1);
}
}
}
void CreateFolderHyerarchy(string[] toCreate, QueryItem currentItem, int focus = 0)
{
if (currentItem is QueryFolder)
{
QueryFolder currentFolder = (QueryFolder)currentItem;
if (!currentFolder.Contains(toCreate[focus]))
{
currentFolder.Add(new QueryFolder(toCreate[focus]));
Trace.WriteLine(string.Format(" Created: {0}", toCreate[focus]));
}
if (toCreate.Length != focus + 1)
{
CreateFolderHyerarchy(toCreate, currentFolder[toCreate[focus]], focus + 1);
}
}
}
/// <summary>
/// Copies all queries from specified folder, adds them to specified folder without
/// modifying the former folder's queries
/// </summary>
/// <param name="oldFolder"></param>
/// <param name="newFolder"></param>
public void CopyPreviousQueryFolderContent(QueryFolder oldFolder, QueryFolder newFolder)
{
// List of all the old folder's queries
List <QueryDefinition> oldQueryList = new List <QueryDefinition>();
oldQueryList.AddRange(GetAllTeamQueries(oldFolder));
// List for the new folder's queries, copy of the previous list
List <QueryDefinition> newQueryList = new List <QueryDefinition>();
newQueryList.AddRange(oldQueryList);
// iterates through each query in copied list, adds newly constructed queries in new folder
foreach (var queryItem in newQueryList)
{
QueryDefinition queryDefinition = new QueryDefinition(queryItem.Name, queryItem.QueryText);
newFolder.Add(queryDefinition);
}
newFolder.Project?.QueryHierarchy.Save();
}
/// <summary>
/// Define Query Folders under the current parent
/// </summary>
/// <param name="targetHierarchy">The object that represents the whole of the target query tree</param>
/// <param name="sourceFolder">The source folder in tree on source instance</param>
/// <param name="parentFolder">The target folder in tree on target instance</param>
private void MigrateFolder(QueryHierarchy targetHierarchy, QueryFolder sourceFolder, QueryFolder parentFolder)
{
// We only migrate non-private folders and their contents
if (sourceFolder.IsPersonal)
{
Log.LogInformation("Found a personal folder {sourceFolderName}. Migration only available for shared Team Query folders", sourceFolder.Name);
}
else
{
this.totalFoldersAttempted++;
// we need to replace the team project name in folder names as it included in query paths
var requiredPath = sourceFolder.Path.Replace($"{Source.Project}/", $"{Target.Project}/");
// Is the project name to be used in the migration as an extra folder level?
if (_Options.PrefixProjectToNodes == true)
{
// we need to inject the team name as a folder in the structure
requiredPath = requiredPath.Replace(_Options.SharedFolderName, $"{_Options.SharedFolderName}/{Source.Project}");
// If on the root level we need to check that the extra folder has already been added
if (sourceFolder.Path.Count(f => f == '/') == 1)
{
var targetSharedFolderRoot = (QueryFolder)parentFolder[_Options.SharedFolderName];
QueryFolder extraFolder = (QueryFolder)targetSharedFolderRoot.FirstOrDefault(q => q.Path == requiredPath);
if (extraFolder == null)
{
// we are at the root level on the first pass and need to create the extra folder for the team name
Log.LogInformation("Adding a folder '{Project}'", Source.Project);
extraFolder = new QueryFolder(Source.Project);
targetSharedFolderRoot.Add(extraFolder);
targetHierarchy.Save(); // moved the save here a more immediate and relavent error message
}
// adjust the working folder to the newly added one
parentFolder = targetSharedFolderRoot;
}
}
// check if there is a folder of the required name, using the path to make sure it is unique
QueryFolder targetFolder = (QueryFolder)parentFolder.FirstOrDefault(q => q.Path == requiredPath);
if (targetFolder != null)
{
Log.LogInformation("Skipping folder '{sourceFolderName}' as already exists", sourceFolder.Name);
}
else
{
Log.LogInformation("Migrating a folder '{sourceFolderName}'", sourceFolder.Name);
targetFolder = new QueryFolder(sourceFolder.Name);
parentFolder.Add(targetFolder);
targetHierarchy.Save(); // moved the save here a more immediate and relavent error message
}
// Process child items
foreach (QueryItem sub_query in sourceFolder)
{
if (sub_query.GetType() == typeof(QueryFolder))
{
MigrateFolder(targetHierarchy, (QueryFolder)sub_query, (QueryFolder)targetFolder);
}
else
{
MigrateQuery(targetHierarchy, (QueryDefinition)sub_query, (QueryFolder)targetFolder);
}
}
}
}
/// <summary>
/// Copies all queries from specified folder, adds them to specified folder without
/// modifying the former folder's queries
/// </summary>
/// <param name="oldFolder"></param>
/// <param name="newFolder"></param>
public void CopyPreviousQueryFolderContent(QueryFolder oldFolder, QueryFolder newFolder)
{
// List of all the old folder's queries
List<QueryDefinition> oldQueryList = new List<QueryDefinition>();
oldQueryList.AddRange(GetAllTeamQueries(oldFolder));
// List for the new folder's queries, copy of the previous list
List<QueryDefinition> newQueryList = new List<QueryDefinition>();
newQueryList.AddRange(oldQueryList);
// iterates through each query in copied list, adds newly constructed queries in new folder
foreach (var queryItem in newQueryList)
{
QueryDefinition queryDefinition = new QueryDefinition(queryItem.Name, queryItem.QueryText);
newFolder.Add(queryDefinition);
}
newFolder.Project.QueryHierarchy.Save();
}
/// <summary>
/// Moves a query folder or query to another targeted folder
/// </summary>
/// <param name="queryItem"></param>
/// <param name="targetFolder"></param>
public void MoveQueryItem(QueryItem queryItem, QueryFolder targetFolder)
{
targetFolder.Add(queryItem);
targetFolder.Project.QueryHierarchy.Save();
}
private void SetQueryItem(QueryFolder queryFolder, QueryFolder parentFolder, string sourceProjectName)
{
QueryItem newItem = null;
foreach (QueryItem subQuery in queryFolder)
{
try
{
if (subQuery.GetType() == typeof(QueryFolder))
{
newItem = new QueryFolder(subQuery.Name);
if (!parentFolder.Contains(subQuery.Name))
{
parentFolder.Add(newItem);
store.Projects[projectName].QueryHierarchy.Save();
SetQueryItem((QueryFolder)subQuery, (QueryFolder)newItem, sourceProjectName);
}
else
{
logger.WarnFormat("Query Folder {0} already exists", subQuery);
}
}
else
{
QueryDefinition oldDef = (QueryDefinition)subQuery;
string queryText = oldDef.QueryText.Replace(sourceProjectName, projectName).Replace("User Story", "Product Backlog Item").Replace("Issue", "Impediment");
newItem = new QueryDefinition(subQuery.Name, queryText);
if (!parentFolder.Contains(subQuery.Name))
{
parentFolder.Add(newItem);
store.Projects[projectName].QueryHierarchy.Save();
}
else
{
logger.WarnFormat("Query Definition {0} already exists", subQuery);
}
}
}
catch (Exception ex)
{
if (newItem != null)
newItem.Delete();
logger.ErrorFormat("Error creating Query: {0} : {1}", subQuery, ex.Message);
continue;
}
}
}
public static void CopySubStuff(QueryFolder sourceQueryFolder, QueryFolder targetQueryFolder)
{
var workItemStore = sourceQueryFolder.Project.Store;
var variables = new Dictionary <string, string>
{
{ "project", sourceQueryFolder.Project.Name }
};
foreach (var sourceQueryFolderSubItem in sourceQueryFolder)
{
if (sourceQueryFolderSubItem is QueryDefinition sourceQueryDefinition)
{
//this is a query definition
//only try to migrate query if query is valid.
try
{
var query = new Query(workItemStore, sourceQueryDefinition.QueryText, variables);
if (sourceQueryDefinition.QueryType == QueryType.List)
{
query.RunQuery();
}
else
{
query.RunLinkQuery();
}
}
catch (Microsoft.TeamFoundation.WorkItemTracking.Client.ValidationException)
{
//query was not valid: iteration path no longer exists or something alike.
continue;
}
catch
{
//crash
throw;
}
string queryText = sourceQueryDefinition.QueryText;
queryText = queryText.Replace(sourceQueryDefinition.Project.Name, targetQueryFolder.Project.Name);
if (targetQueryFolder.Contains(sourceQueryDefinition.Name))
{
targetQueryFolder[sourceQueryDefinition.Name].Delete();
}
targetQueryFolder.Add(new QueryDefinition(sourceQueryDefinition.Name, queryText));
}
else
{
if (sourceQueryFolderSubItem is QueryFolder sourceSubQueryFolder)
{
//this is a query folder
var targetSubQueryFolder = new QueryFolder(sourceSubQueryFolder.Name);
if (targetQueryFolder.Contains(sourceSubQueryFolder.Name))
{
targetQueryFolder[targetSubQueryFolder.Name].Delete();
}
targetQueryFolder.Add(targetSubQueryFolder);
CopySubStuff(sourceSubQueryFolder, targetSubQueryFolder);
}
}
}
}
/// <summary>
/// Moves a query folder or query to another targeted folder
/// </summary>
/// <param name="queryItem"></param>
/// <param name="targetFolder"></param>
public void MoveQueryItem(QueryItem queryItem, QueryFolder targetFolder)
{
targetFolder.Add(queryItem);
targetFolder.Project.QueryHierarchy.Save();
}
