/// <summary>
/// Create a new custom state
/// </summary>
/// <param name="procId"></param>
/// <param name="witRefName"></param>
/// <param name="StateName"></param>
/// <param name="StateCategory"></param>
/// <returns></returns>
private static string CreateNewState(Guid procId, string witRefName, string StateName, string StateCategory)
{
if (witRefName.StartsWith("Microsoft."))
{
witRefName = CreateInheritedWIT(procId, witRefName);
}
WorkItemStateInputModel workItemState = new WorkItemStateInputModel();
workItemState.Name = StateName;
workItemState.StateCategory = StateCategory;
workItemState.Color = "6a4c46";
ProcessHttpClient.CreateStateDefinitionAsync(workItemState, procId, witRefName).Wait();
return(witRefName);
}
/// <summary>
/// Move up a state in the work item state list
/// </summary>
/// <param name="procId"></param>
/// <param name="witRefName"></param>
/// <param name="StateName"></param>
private static void MoveUpState(Guid procId, string witRefName, string StateName)
{
var states = ProcessHttpClient.GetStateDefinitionsAsync(procId, witRefName).Result;
var state = (from p in states where p.Name == StateName select p).FirstOrDefault();
if (state == null)
{
throw new Exception("Can not find state " + StateName);
}
WorkItemStateInputModel workItemState = new WorkItemStateInputModel();
workItemState.Order = state.Order - 1;
ProcessHttpClient.UpdateStateDefinitionAsync(workItemState, procId, witRefName, state.Id).Wait();
}
public static void ProcessFile(VssConnection connection, string type, string fileContent)
{
switch (type)
{
case "project":
var project = JsonConvert.DeserializeObject <Project>(fileContent);
var projectClient = connection.GetClient <ProjectHttpClient>();
try
{
var existingProject = projectClient.GetProject(project.Name).SyncResult();
if (existingProject != null)
{
//TODO: add capabilities or changes
return;
}
}
catch (Exception e)
{
//this throws an exception if the project does not exists
}
var capabilities = new Dictionary <string, Dictionary <string, string> >();
Dictionary <string, string> versionControlProperties = new Dictionary <string, string>();
versionControlProperties[TeamProjectCapabilitiesConstants.VersionControlCapabilityAttributeName] =
SourceControlTypes.Git.ToString();
// Setup process properties
Dictionary <string, string> processProperaties = new Dictionary <string, string>();
processProperaties[TeamProjectCapabilitiesConstants.ProcessTemplateCapabilityTemplateTypeIdAttributeName] =
ProcessMap["Basic"].ToString();
capabilities[TeamProjectCapabilitiesConstants.VersionControlCapabilityName] =
versionControlProperties;
capabilities[TeamProjectCapabilitiesConstants.ProcessTemplateCapabilityName] =
processProperaties;
var newProject = new TeamProject()
{
Name = project.Name,
Description = project.Description,
Visibility = (ProjectVisibility)project.Visibility,
Capabilities = capabilities
};
projectClient.QueueCreateProject(newProject).SyncResult();
break;
case "process":
var process = JsonConvert.DeserializeObject <AzdoBoardsManager.Models.Process>(fileContent);
var processClient = connection.GetClient <WorkItemTrackingProcessHttpClient>();
if (ProcessMap.ContainsKey(process.ReferenceName ?? process.Name))
{
return;
}
if (string.IsNullOrWhiteSpace(process.ReferenceName))
{
return;
}
var createProcess = new CreateProcessModel()
{
Name = process.Name,
Description = process.Description,
ReferenceName = process.ReferenceName,
};
if (!string.IsNullOrEmpty(process.ParentProcessId))
{
createProcess.ParentProcessTypeId = ProcessMap[process.ParentProcessId];
}
var processInfo = processClient.CreateNewProcessAsync(createProcess).SyncResult();
ProcessMap.Add(processInfo.ReferenceName ?? processInfo.Name, processInfo.TypeId);
break;
case "workitemtype":
var workItemType = JsonConvert.DeserializeObject <AzdoBoardsManager.Models.WorkItemType>(fileContent);
WorkItemTypes.Add(workItemType.Id, workItemType);
var witClient = connection.GetClient <WorkItemTrackingProcessHttpClient>();
try
{
var types = witClient.GetProcessWorkItemTypesAsync(ProcessMap[workItemType.ProcessId]).SyncResult();
var existingWit = witClient.GetProcessWorkItemTypeAsync(ProcessMap[workItemType.ProcessId], workItemType.Id).SyncResult();
if (existingWit != null)
{
//TODO: add capabilities or changes
return;
}
}
catch (Exception e)
{
//this throws an exception if the project does not exists
}
var createWorkItemType = new CreateProcessWorkItemTypeRequest()
{
Name = workItemType.Name,
Description = workItemType.Description,
Color = workItemType.Color,
Icon = workItemType.Icon,
InheritsFrom = workItemType.Inherits,
IsDisabled = workItemType.IsDisabled
};
var processName = workItemType.ProcessId;
witClient.CreateProcessWorkItemTypeAsync(createWorkItemType, ProcessMap[processName]).SyncResult();
break;
case "workitemtypestates":
var witTrackingClient = connection.GetClient <WorkItemTrackingProcessHttpClient>();
var workItemTypeStates = JsonConvert.DeserializeObject <List <WorkItemTypeState> >(fileContent);
if (workItemTypeStates.Count == 0)
{
return;
}
var firstWorkItem = workItemTypeStates[0];
var workItemId = firstWorkItem.WorkItemId;
var processId = ProcessMap[WorkItemTypes[firstWorkItem.WorkItemId].ProcessId];
var stateDefinitions = witTrackingClient.GetStateDefinitionsAsync(
processId,
firstWorkItem.WorkItemId
).SyncResult();
var stateDefinitionsMap = new Dictionary <string, bool>();
//We iterate to verify what is existing what needs to be created
foreach (var workItemTypeState in workItemTypeStates)
{
stateDefinitionsMap.Add(workItemTypeState.Name, false);
foreach (var def in stateDefinitions)
{
if (def.Name.Equals(workItemTypeState.Name))
{
stateDefinitionsMap[workItemTypeState.Name] = true;
}
}
}
//Extra will be deleted
foreach (var def in stateDefinitions)
{
if (!stateDefinitionsMap.ContainsKey(def.Name))
{
witTrackingClient.DeleteStateDefinitionAsync(
processId,
workItemId,
def.Id
).SyncResult();
}
}
//We create the missing ones
foreach (var workItemTypeState in workItemTypeStates)
{
if (!stateDefinitionsMap[workItemTypeState.Name])
{
var workItemStateInputModel = new WorkItemStateInputModel()
{
Name = workItemTypeState.Name,
Color = workItemTypeState.Color,
StateCategory = workItemTypeState.StateCategory,
Order = workItemTypeState.Order
};
var states = witTrackingClient.CreateStateDefinitionAsync(
workItemStateInputModel,
processId,
workItemTypeState.WorkItemId
).SyncResult();
}
}
break;
}
}
