private void PerformImport(Dictionary <TeamProjectInfo, List <WorkItemConfigurationItem> > teamProjectsWithProcessConfigurations, ImportOptions options)
{
var numberOfSteps = teamProjectsWithProcessConfigurations.Aggregate(0, (a, p) => a += p.Value.Count);
var task = new ApplicationTask("Importing process configurations", numberOfSteps, true);
PublishStatus(new StatusEventArgs(task));
var worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
var tfs = GetSelectedTfsTeamProjectCollection();
var store = tfs.GetService <WorkItemStore>();
WorkItemConfigurationItemImportExport.Import(this.Logger, task, true, store, teamProjectsWithProcessConfigurations, options);
};
worker.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
Logger.Log("An unexpected exception occurred while importing process configurations", e.Error);
task.SetError(e.Error);
task.SetComplete("An unexpected exception occurred");
}
else
{
task.SetComplete(task.IsError ? "Failed" : (task.IsWarning ? "Succeeded with warnings" : "Succeeded"));
}
};
worker.RunWorkerAsync();
}
public static WorkItemConfiguration FromTeamProject(TfsTeamProjectCollection tfs, Project project)
{
// Export work item type definitions.
var projectWorkItemTypes = new List <WorkItemConfigurationItem>();
foreach (WorkItemType workItemType in project.WorkItemTypes)
{
projectWorkItemTypes.Add(WorkItemConfigurationItem.FromXml(workItemType.Export(false)));
}
// Export categories.
projectWorkItemTypes.Add(WorkItemConfigurationItemImportExport.GetCategories(project));
// Export process configuration.
var commonConfig = WorkItemConfigurationItemImportExport.GetCommonConfiguration(project);
if (commonConfig != null)
{
projectWorkItemTypes.Add(commonConfig);
}
var agileConfig = WorkItemConfigurationItemImportExport.GetAgileConfiguration(project);
if (agileConfig != null)
{
projectWorkItemTypes.Add(agileConfig);
}
var processConfig = WorkItemConfigurationItemImportExport.GetProcessConfiguration(project);
if (processConfig != null)
{
projectWorkItemTypes.Add(processConfig);
}
return(new WorkItemConfiguration(project.Name, projectWorkItemTypes));
}
private void ExportSelectedWorkItemTypes(object argument)
{
var workItemTypesToExport = new List <WorkItemConfigurationItemExport>();
var workItemTypes = this.SelectedWorkItemTypes;
if (workItemTypes.Count == 1)
{
// Export to single file.
var workItemType = workItemTypes.Single();
var dialog = new SaveFileDialog();
dialog.FileName = workItemType.Name + ".xml";
dialog.Filter = "XML Files (*.xml)|*.xml";
var result = dialog.ShowDialog(Application.Current.MainWindow);
if (result == true)
{
workItemTypesToExport.Add(new WorkItemConfigurationItemExport(workItemType.TeamProject, workItemType.WorkItemTypeDefinition, dialog.FileName));
}
}
else
{
// Export to a directory structure.
var dialog = new System.Windows.Forms.FolderBrowserDialog();
dialog.Description = "Please select the path where to export the Work Item Type Definition files (*.xml). They will be stored in a folder per Team Project.";
var result = dialog.ShowDialog();
if (result == System.Windows.Forms.DialogResult.OK)
{
var rootFolder = dialog.SelectedPath;
foreach (var workItemType in workItemTypes)
{
var fileName = Path.Combine(rootFolder, workItemType.TeamProject.Name, workItemType.Name + ".xml");
workItemTypesToExport.Add(new WorkItemConfigurationItemExport(workItemType.TeamProject, workItemType.WorkItemTypeDefinition, fileName));
}
}
}
if (workItemTypesToExport.Any())
{
var task = new ApplicationTask("Exporting " + workItemTypesToExport.Count.ToCountString("work item type"), workItemTypesToExport.Count, true);
PublishStatus(new StatusEventArgs(task));
var worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
WorkItemConfigurationItemImportExport.Export(this.Logger, task, workItemTypesToExport);
};
worker.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
Logger.Log("An unexpected exception occurred while exporting work item types", e.Error);
task.SetError(e.Error);
task.SetComplete("An unexpected exception occurred");
}
else
{
task.SetComplete("Exported " + workItemTypesToExport.Count.ToCountString("work item type"));
}
};
worker.RunWorkerAsync();
}
}
public MacroInformationDialog()
{
InitializeComponent();
this.Macros = WorkItemConfigurationItemImportExport.GetSupportedMacroDefinitions();
this.SelectedMacro = this.Macros.FirstOrDefault();
this.CopyToClipboardCommand = new RelayCommand(CopyToClipboard, CanCopyToClipboard);
this.DataContext = this;
}
private void GetWorkItemCategories(object argument)
{
var teamProjectNames = this.SelectedTeamProjects.Select(p => p.Name).ToList();
var task = new ApplicationTask("Retrieving work item categories", teamProjectNames.Count, true);
PublishStatus(new StatusEventArgs(task));
var step = 0;
var worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
var tfs = GetSelectedTfsTeamProjectCollection();
var store = tfs.GetService <WorkItemStore>();
var results = new List <WorkItemCategoryInfo>();
foreach (var teamProjectName in teamProjectNames)
{
task.SetProgress(step++, string.Format(CultureInfo.CurrentCulture, "Processing Team Project \"{0}\"", teamProjectName));
try
{
var project = store.Projects[teamProjectName];
var categoriesXml = WorkItemConfigurationItemImportExport.GetCategoriesXml(project);
var categoryList = WorkItemCategoryList.Load(categoriesXml);
foreach (var category in categoryList.Categories)
{
results.Add(new WorkItemCategoryInfo(teamProjectName, categoryList, category));
}
}
catch (Exception exc)
{
task.SetWarning(string.Format(CultureInfo.CurrentCulture, "An error occurred while processing Team Project \"{0}\"", teamProjectName), exc);
}
if (task.IsCanceled)
{
task.Status = "Canceled";
break;
}
}
e.Result = results;
};
worker.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
Logger.Log("An unexpected exception occurred while retrieving work item categories", e.Error);
task.SetError(e.Error);
task.SetComplete("An unexpected exception occurred");
}
else
{
this.WorkItemCategories = (ICollection <WorkItemCategoryInfo>)e.Result;
task.SetComplete("Retrieved " + this.WorkItemCategories.Count.ToCountString("work item category"));
}
};
worker.RunWorkerAsync();
}
private void ImportWorkItemCategoryList(object argument)
{
var result = MessageBox.Show("This will import the work item category list to all selected Team Projects. Certain applications like Microsoft Test Manager rely on categories so modifying them can reduce their functionality. Are you sure you want to continue?", "Confirm Import", MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result != MessageBoxResult.Yes)
{
return;
}
var task = new ApplicationTask("Importing work item category list", this.SelectedTeamProjects.Count, true);
PublishStatus(new StatusEventArgs(task));
var step = 0;
var worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
var tfs = GetSelectedTfsTeamProjectCollection();
var store = tfs.GetService <WorkItemStore>();
var categoriesXml = this.SelectedWorkItemCategoryList.Save();
foreach (var teamProject in this.SelectedTeamProjects)
{
try
{
task.SetProgress(step++, string.Format(CultureInfo.CurrentCulture, "Importing work item category list in Team Project \"{0}\"", teamProject.Name));
var project = store.Projects[teamProject.Name];
WorkItemConfigurationItemImportExport.SetCategories(project, categoriesXml);
}
catch (Exception exc)
{
task.SetError(string.Format(CultureInfo.CurrentCulture, "An error occurred while importing the work item category list for Team Project \"{0}\"", teamProject.Name), exc);
}
if (task.IsCanceled)
{
task.Status = "Canceled";
break;
}
}
};
worker.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
Logger.Log("An unexpected exception occurred while importing the work item category list", e.Error);
task.SetError(e.Error);
task.SetComplete("An unexpected exception occurred");
}
else
{
task.SetComplete(task.IsError ? "Failed" : (task.IsWarning ? "Succeeded with warnings" : "Succeeded"));
}
};
worker.RunWorkerAsync();
}
private void LoadWorkItemCategoryList(object argument)
{
using (var dialog = new TeamProjectPicker(TeamProjectPickerMode.SingleProject, false))
{
var result = dialog.ShowDialog(Application.Current.MainWindow.GetIWin32Window());
if (result == System.Windows.Forms.DialogResult.OK && dialog.SelectedProjects != null && dialog.SelectedProjects.Length > 0)
{
var teamProjectCollection = dialog.SelectedTeamProjectCollection;
var teamProject = dialog.SelectedProjects.First();
var task = new ApplicationTask("Loading work item category list");
PublishStatus(new StatusEventArgs(task));
var worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
var tfs = GetTfsTeamProjectCollection(teamProjectCollection.Uri);
var store = tfs.GetService <WorkItemStore>();
var project = store.Projects[teamProject.Name];
var categoriesXml = WorkItemConfigurationItemImportExport.GetCategoriesXml(project);
var selectedWorkItemCategoryList = WorkItemCategoryList.Load(categoriesXml);
var availableWorkItemTypeReferences = project.WorkItemTypes.Cast <WorkItemType>().Select(w => new WorkItemTypeReference {
Name = w.Name
}).ToList();
e.Result = new Tuple <WorkItemCategoryList, ICollection <WorkItemTypeReference> >(selectedWorkItemCategoryList, availableWorkItemTypeReferences);
};
worker.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
Logger.Log("An unexpected exception occurred while importing the work item category list", e.Error);
task.SetError(e.Error);
task.SetComplete("An unexpected exception occurred");
}
else
{
var loadResult = (Tuple <WorkItemCategoryList, ICollection <WorkItemTypeReference> >)e.Result;
this.SelectedWorkItemCategoryList = loadResult.Item1;
this.AvailableWorkItemTypeReferences = loadResult.Item2;
this.SelectedWorkItemCategory = this.SelectedWorkItemCategoryList.Categories.FirstOrDefault();
task.SetComplete("Done");
}
};
worker.RunWorkerAsync();
}
}
}
private void PreviewTransformation()
{
try
{
this.outputTextBox.Foreground = (Brush)TextBox.ForegroundProperty.DefaultMetadata.DefaultValue;
var input = this.inputTextBox.Text;
var transformation = this.transformationTextBox.Text;
var output = string.Empty;
if (!string.IsNullOrWhiteSpace(input) && !string.IsNullOrWhiteSpace(transformation))
{
// Perform the transformation.
output = WorkItemConfigurationTransformer.Transform(this.TransformationType, input, transformation);
// Also replace macros to complete the preview.
output = WorkItemConfigurationItemImportExport.ReplaceTeamProjectMacros(output, this.SelectedItem.TeamProject);
}
this.outputTextBox.Text = output;
}
catch (Exception exc)
{
this.outputTextBox.Foreground = Brushes.Red;
this.outputTextBox.Text = exc.ToString();
}
}
private void GetProcessConfigurations(object argument)
{
var teamProjects = this.SelectedTeamProjects.ToList();
var task = new ApplicationTask("Retrieving process configurations", teamProjects.Count, true);
PublishStatus(new StatusEventArgs(task));
var step = 0;
var worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
var tfs = GetSelectedTfsTeamProjectCollection();
var store = tfs.GetService <WorkItemStore>();
var results = new List <WorkItemConfigurationItemExport>();
foreach (var teamProject in teamProjects)
{
task.SetProgress(step++, string.Format(CultureInfo.CurrentCulture, "Processing Team Project \"{0}\"", teamProject.Name));
try
{
var project = store.Projects[teamProject.Name];
if (this.SelectedTeamProjectCollection.TeamFoundationServer.MajorVersion >= TfsMajorVersion.V12)
{
var processConfiguration = WorkItemConfigurationItemImportExport.GetProcessConfiguration(project);
if (processConfiguration != null)
{
results.Add(new WorkItemConfigurationItemExport(teamProject, processConfiguration));
}
}
else
{
var commonConfiguration = WorkItemConfigurationItemImportExport.GetCommonConfiguration(project);
if (commonConfiguration != null)
{
results.Add(new WorkItemConfigurationItemExport(teamProject, commonConfiguration));
}
var agileConfiguration = WorkItemConfigurationItemImportExport.GetAgileConfiguration(project);
if (agileConfiguration != null)
{
results.Add(new WorkItemConfigurationItemExport(teamProject, agileConfiguration));
}
}
}
catch (Exception exc)
{
task.SetWarning(string.Format(CultureInfo.CurrentCulture, "An error occurred while processing Team Project \"{0}\"", teamProject.Name), exc);
}
if (task.IsCanceled)
{
task.Status = "Canceled";
break;
}
}
e.Result = results;
};
worker.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
Logger.Log("An unexpected exception occurred while retrieving process configurations", e.Error);
task.SetError(e.Error);
task.SetComplete("An unexpected exception occurred");
}
else
{
this.ProcessConfigurations = (ICollection <WorkItemConfigurationItemExport>)e.Result;
task.SetComplete("Retrieved " + this.ProcessConfigurations.Count.ToCountString("process configuration"));
}
};
worker.RunWorkerAsync();
}
private void ApplyTransformations(object argument)
{
var simulate = this.Simulate;
var saveCopy = this.SaveCopy;
if (!simulate)
{
var result = MessageBox.Show("This will apply the specified transformations to all selected Team Projects. Are you sure you want to continue?", "Confirm Transformation", MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result != MessageBoxResult.Yes)
{
return;
}
}
var teamProjects = this.SelectedTeamProjects.ToList();
var transformations = this.Transformations.ToList();
var task = new ApplicationTask("Transforming work item configuration", teamProjects.Count, true);
PublishStatus(new StatusEventArgs(task));
var step = 0;
var worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
var tfs = GetSelectedTfsTeamProjectCollection();
var store = tfs.GetService <WorkItemStore>();
var numTransformations = 0;
foreach (var teamProject in teamProjects)
{
task.SetProgress(step++, string.Format(CultureInfo.CurrentCulture, "Processing Team Project \"{0}\"", teamProject.Name));
try
{
var project = store.Projects[teamProject.Name];
// Apply the transformations only if everything succeeded for the Team Project; cache them in the mean time.
var transformedItems = new List <WorkItemConfigurationItem>();
foreach (var transformation in transformations)
{
if (transformation.WorkItemConfigurationItemType == WorkItemConfigurationItemType.WorkItemType)
{
// Apply work item type definition transformation, which can apply to multiple work item type definitions (semicolon separated).
// If no work item type names are specified, apply to all work item types in the project.
var workItemTypeNames = (string.IsNullOrEmpty(transformation.WorkItemTypeNames) ? project.WorkItemTypes.Cast <WorkItemType>().Select(w => w.Name) : transformation.WorkItemTypeNames.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries));
foreach (var workItemTypeName in workItemTypeNames)
{
// If the work item type has already been processed before, continue with that version.
var itemToTransform = transformedItems.FirstOrDefault(w => string.Equals(w.Name, workItemTypeName, StringComparison.OrdinalIgnoreCase));
if (itemToTransform == null)
{
// If the work item type wasn't processed yet, find the one with the specified name (if it exists).
var wit = project.WorkItemTypes.Cast <WorkItemType>().FirstOrDefault(w => string.Equals(w.Name, workItemTypeName, StringComparison.OrdinalIgnoreCase));
if (wit != null)
{
itemToTransform = WorkItemTypeDefinition.FromXml(wit.Export(false));
}
}
if (itemToTransform != null)
{
task.Status = "Transforming " + itemToTransform.DisplayName;
var transformed = WorkItemConfigurationTransformer.Transform(transformation.TransformationType, itemToTransform.XmlDefinition, transformation.TransformationXml);
if (string.Equals(itemToTransform.XmlDefinition.DocumentElement.OuterXml, transformed.DocumentElement.OuterXml))
{
task.Status = "The transformation was applied but did not result in any changes, skipping.";
}
else
{
itemToTransform.XmlDefinition = transformed;
transformedItems.Add(itemToTransform);
}
}
else
{
task.Status = "Skipping \"{0}\": a work item type with this name was not found in the Team Project".FormatCurrent(workItemTypeName);
}
}
}
else if (transformation.WorkItemConfigurationItemType == WorkItemConfigurationItemType.Categories)
{
var itemToTransform = transformedItems.FirstOrDefault(w => w.Type == WorkItemConfigurationItemType.Categories);
if (itemToTransform == null)
{
itemToTransform = WorkItemConfigurationItemImportExport.GetCategories(project);
}
task.Status = "Transforming " + itemToTransform.DisplayName;
var transformed = WorkItemConfigurationTransformer.Transform(transformation.TransformationType, itemToTransform.XmlDefinition, transformation.TransformationXml);
if (string.Equals(itemToTransform.XmlDefinition.DocumentElement.OuterXml, transformed.DocumentElement.OuterXml))
{
task.Status = "The transformation was applied but did not result in any changes, skipping.";
}
else
{
itemToTransform.XmlDefinition = transformed;
transformedItems.Add(itemToTransform);
}
}
else if (transformation.WorkItemConfigurationItemType == WorkItemConfigurationItemType.AgileConfiguration)
{
var itemToTransform = transformedItems.FirstOrDefault(w => w.Type == WorkItemConfigurationItemType.AgileConfiguration);
if (itemToTransform == null)
{
itemToTransform = WorkItemConfigurationItemImportExport.GetAgileConfiguration(project);
}
if (itemToTransform != null)
{
task.Status = "Transforming " + itemToTransform.DisplayName;
var transformed = WorkItemConfigurationTransformer.Transform(transformation.TransformationType, itemToTransform.XmlDefinition, transformation.TransformationXml);
if (string.Equals(itemToTransform.XmlDefinition.DocumentElement.OuterXml, transformed.DocumentElement.OuterXml))
{
task.Status = "The transformation was applied but did not result in any changes, skipping.";
}
else
{
itemToTransform.XmlDefinition = transformed;
transformedItems.Add(itemToTransform);
}
}
}
else if (transformation.WorkItemConfigurationItemType == WorkItemConfigurationItemType.CommonConfiguration)
{
var itemToTransform = transformedItems.FirstOrDefault(w => w.Type == WorkItemConfigurationItemType.CommonConfiguration);
if (itemToTransform == null)
{
itemToTransform = WorkItemConfigurationItemImportExport.GetCommonConfiguration(project);
}
if (itemToTransform != null)
{
task.Status = "Transforming " + itemToTransform.DisplayName;
var transformed = WorkItemConfigurationTransformer.Transform(transformation.TransformationType, itemToTransform.XmlDefinition, transformation.TransformationXml);
if (string.Equals(itemToTransform.XmlDefinition.DocumentElement.OuterXml, transformed.DocumentElement.OuterXml))
{
task.Status = "The transformation was applied but did not result in any changes, skipping.";
}
else
{
itemToTransform.XmlDefinition = transformed;
transformedItems.Add(itemToTransform);
}
}
}
else if (transformation.WorkItemConfigurationItemType == WorkItemConfigurationItemType.ProcessConfiguration)
{
var itemToTransform = transformedItems.FirstOrDefault(w => w.Type == WorkItemConfigurationItemType.ProcessConfiguration);
if (itemToTransform == null)
{
itemToTransform = WorkItemConfigurationItemImportExport.GetProcessConfiguration(project);
}
if (itemToTransform != null)
{
task.Status = "Transforming " + itemToTransform.DisplayName;
var transformed = WorkItemConfigurationTransformer.Transform(transformation.TransformationType, itemToTransform.XmlDefinition, transformation.TransformationXml);
if (string.Equals(itemToTransform.XmlDefinition.DocumentElement.OuterXml, transformed.DocumentElement.OuterXml))
{
task.Status = "The transformation was applied but did not result in any changes, skipping.";
}
else
{
itemToTransform.XmlDefinition = transformed;
transformedItems.Add(itemToTransform);
}
}
}
else
{
throw new ArgumentException("The Work Item Configuration Item Type is unknown: " + transformation.WorkItemConfigurationItemType.ToString());
}
if (task.IsCanceled)
{
break;
}
}
// Only apply the transformations if they all succeeded (i.e. there was no exception).
if (task.IsCanceled)
{
break;
}
else
{
var teamProjectsWithConfigurationItems = new Dictionary <TeamProjectInfo, List <WorkItemConfigurationItem> >()
{
{ teamProject, transformedItems }
};
var options = ImportOptions.None;
if (simulate)
{
options |= ImportOptions.Simulate;
}
if (saveCopy)
{
options |= ImportOptions.SaveCopy;
}
WorkItemConfigurationItemImportExport.Import(this.Logger, task, false, store, teamProjectsWithConfigurationItems, options);
}
numTransformations += transformedItems.Count;
}
catch (Exception exc)
{
task.SetWarning(string.Format(CultureInfo.CurrentCulture, "An error occurred while processing Team Project \"{0}\"", teamProject.Name), exc);
}
if (task.IsCanceled)
{
task.Status = "Canceled";
break;
}
}
e.Result = numTransformations;
};
worker.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
Logger.Log("An unexpected exception occurred while transforming work item configuration", e.Error);
task.SetError(e.Error);
task.SetComplete("An unexpected exception occurred");
}
else
{
var numTransformations = (int)e.Result;
task.SetComplete("Applied transformation to " + numTransformations.ToCountString("work item configuration item"));
}
};
worker.RunWorkerAsync();
}
private void GetWorkItemTypes(object argument)
{
var teamProjects = this.SelectedTeamProjects.ToList();
var task = new ApplicationTask("Retrieving work item types", teamProjects.Count, true);
PublishStatus(new StatusEventArgs(task));
var step = 0;
var worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
var tfs = GetSelectedTfsTeamProjectCollection();
var store = tfs.GetService <WorkItemStore>();
var results = new List <WorkItemTypeInfo>();
foreach (var teamProject in teamProjects)
{
task.SetProgress(step++, string.Format(CultureInfo.CurrentCulture, "Processing Team Project \"{0}\"", teamProject.Name));
try
{
var project = store.Projects[teamProject.Name];
var categoriesXml = WorkItemConfigurationItemImportExport.GetCategoriesXml(project);
var categoryList = WorkItemCategoryList.Load(categoriesXml);
foreach (WorkItemType workItemType in project.WorkItemTypes)
{
var parameters = new Dictionary <string, object>()
{
{ "WorkItemType", workItemType.Name },
{ "TeamProject", workItemType.Project.Name }
};
var workItemCount = store.QueryCount("SELECT [System.Id] FROM WorkItems WHERE [System.WorkItemType] = @WorkItemType AND [System.TeamProject] = @TeamProject", parameters);
var referencingCategories = categoryList.Categories.Where(c => c.WorkItemTypes.Concat(new WorkItemTypeReference[] { c.DefaultWorkItemType }).Any(w => string.Equals(w.Name, workItemType.Name, StringComparison.OrdinalIgnoreCase))).Select(c => c.Name);
var workItemTypeDefinition = WorkItemTypeDefinition.FromXml(workItemType.Export(false));
results.Add(new WorkItemTypeInfo(teamProject, workItemType.Name, workItemType.Description, workItemCount, referencingCategories.ToList(), workItemTypeDefinition));
}
}
catch (Exception exc)
{
task.SetWarning(string.Format(CultureInfo.CurrentCulture, "An error occurred while processing Team Project \"{0}\"", teamProject.Name), exc);
}
if (task.IsCanceled)
{
task.Status = "Canceled";
break;
}
}
e.Result = results;
};
worker.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
Logger.Log("An unexpected exception occurred while retrieving work item types", e.Error);
task.SetError(e.Error);
task.SetComplete("An unexpected exception occurred");
}
else
{
this.WorkItemTypes = (ICollection <WorkItemTypeInfo>)e.Result;
task.SetComplete("Retrieved " + this.WorkItemTypes.Count.ToCountString("work item type"));
}
};
worker.RunWorkerAsync();
}
private void DeleteSelectedWorkItemCategories(object argument)
{
var workItemCategoriesToDelete = this.SelectedWorkItemCategories;
var result = MessageBox.Show("This will delete the selected work item categories. Certain applications like Microsoft Test Manager rely on categories so deleting them can reduce their functionality. Are you sure you want to continue?", "Confirm Delete", MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result != MessageBoxResult.Yes)
{
return;
}
var task = new ApplicationTask("Deleting " + workItemCategoriesToDelete.Count.ToCountString("work item category"), workItemCategoriesToDelete.Count, true);
PublishStatus(new StatusEventArgs(task));
var step = 0;
var worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
var tfs = GetSelectedTfsTeamProjectCollection();
var store = tfs.GetService <WorkItemStore>();
foreach (var categoriesByTeamProject in workItemCategoriesToDelete.GroupBy(c => c.TeamProject).ToList())
{
var teamProjectName = categoriesByTeamProject.Key;
try
{
var project = store.Projects[teamProjectName];
var categoriesXml = WorkItemConfigurationItemImportExport.GetCategoriesXml(project);
var categoryList = WorkItemCategoryList.Load(categoriesXml);
foreach (var workItemCategoryToDelete in categoriesByTeamProject)
{
try
{
task.SetProgress(step++, string.Format(CultureInfo.CurrentCulture, "Deleting work item category \"{0}\" from Team Project \"{1}\"", workItemCategoryToDelete.WorkItemCategory.Name, workItemCategoryToDelete.TeamProject));
var category = categoryList.Categories.FirstOrDefault(c => string.Equals(c.RefName, workItemCategoryToDelete.WorkItemCategory.RefName, StringComparison.OrdinalIgnoreCase));
if (category != null)
{
categoryList.Categories.Remove(category);
}
}
catch (Exception exc)
{
task.SetError(string.Format(CultureInfo.CurrentCulture, "An error occurred while deleting the work item category \"{0}\" for Team Project \"{1}\"", workItemCategoryToDelete.WorkItemCategory.Name, workItemCategoryToDelete.TeamProject), exc);
}
}
categoriesXml = categoryList.Save();
WorkItemConfigurationItemImportExport.SetCategories(project, categoriesXml);
}
catch (Exception exc)
{
task.SetError(string.Format(CultureInfo.CurrentCulture, "An error occurred while processing Team Project \"{0}\"", teamProjectName), exc);
}
if (task.IsCanceled)
{
task.Status = "Canceled";
break;
}
}
};
worker.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
Logger.Log("An unexpected exception occurred while deleting work item categories", e.Error);
task.SetError(e.Error);
task.SetComplete("An unexpected exception occurred");
}
else
{
task.SetComplete("Deleted " + workItemCategoriesToDelete.Count.ToCountString("work item category"));
}
// Refresh the list.
GetWorkItemCategories(null);
};
worker.RunWorkerAsync();
}