public void ResumeMapperUnitTests_ToWorkItemModel()
{
// Arrange
const string titleValue = "a";
const string aliasValue = "b";
const string linkValue = "c";
const string subtitleValue = "d";
const string descriptionValue = "e";
XElement element = new XElement(
"Root",
new XElement("title", titleValue),
new XElement("alias", aliasValue),
new XElement("link", linkValue),
new XElement("subtitle", subtitleValue),
new XElement("description", descriptionValue)
);
IWorkItemModelDao dao = new WorkItemModelXmlDao(element);
// Act
WorkItemModel model = ResumeMapper.ToWorkItemModel(dao);
// Assert
Assert.IsNotNull(model);
Assert.AreEqual(titleValue, model.Title);
Assert.AreEqual(aliasValue, model.Alias);
Assert.AreEqual(linkValue, model.Link);
Assert.AreEqual(subtitleValue, model.Subtitle);
Assert.AreEqual(descriptionValue, model.Description);
}
public async Task <IActionResult> CreateWorkItem([FromBody] WorkItemModel workItemModel)
{
string userId = null;
var currentUser = HttpContext.User;
if (currentUser != null)
{
userId = currentUser.FindFirst("id").Value;
}
if (userId != null)
{
bool isSuccess = await _workItemsRepository.CreateWorkItem(workItemModel, userId);
if (isSuccess)
{
if (workItemModel.WorkItemId > 0)
{
return(Ok(new Response <bool> {
Code = HttpStatusCode.OK, Data = isSuccess, Message = ResponseMessageModel.WorkItemMessage.WorkItemUpdation
}));
}
return(Ok(new Response <bool> {
Code = HttpStatusCode.OK, Data = isSuccess, Message = ResponseMessageModel.WorkItemMessage.WorkItemCreated
}));
}
}
return(BadRequest(new ErrorResponse(ResponseMessageModel.WorkItemMessage.PleaseContactToAdministrator)));
}
public void OpenWorkItem(WorkItemModel workItemModel)
{
if (workItemModel == null)
{
return;
}
int selectedWorkItemId = workItemModel.Id;
IWorkItemDocument widoc = null;
try
{
var documentService = GetService <DocumentService>();
widoc = documentService.GetWorkItem(CurrentContext.TeamProjectCollection, selectedWorkItemId, this);
documentService.ShowWorkItem(widoc);
}
finally
{
if (widoc != null)
{
widoc.Release(this);
}
}
}
/// <summary>
/// Calculates cross-sprint metrics for a top-level work item (i.e. User Story) and all its children.
/// </summary>
/// <param name="parent">Top level work item.</param>
/// <returns></returns>
public CrossSprintMetricsModel CalculateCrossSprintMetricsForWorkItem(WorkItemModel parent)
{
var crossSprintMetrics = new CrossSprintMetricsModel
{
IterationMetrics = parent.ChildItems
.GroupBy(x => x.IterationPath)
.OrderBy(x => x.Key)
.Select(x => CalculateWorkItemIterationMetrics(x))
.Where(x => x.TotalTime > 0),
WorkItemTitle = parent.Title,
WorkItemID = parent.ID,
};
crossSprintMetrics.NumberOfIterations = crossSprintMetrics.IterationMetrics.Count();
foreach (var iterationMetric in crossSprintMetrics.IterationMetrics)
{
crossSprintMetrics.NumberOfBugs += iterationMetric.NumberOfBugs;
crossSprintMetrics.NumberOfOpenBugs += iterationMetric.NumberOfOpenBugs;
crossSprintMetrics.TimeBugFixing += iterationMetric.TimeBugFixing;
crossSprintMetrics.TimeDeveloping += iterationMetric.TimeDeveloping;
crossSprintMetrics.TimeTesting += iterationMetric.TimeTesting;
crossSprintMetrics.TotalTime += iterationMetric.TotalTime;
crossSprintMetrics.TotalEstimatedTime += iterationMetric.EstimatedTime;
}
crossSprintMetrics.BugFixingPercentageOfDev = crossSprintMetrics.TimeBugFixing / crossSprintMetrics.TimeDeveloping;
return(crossSprintMetrics);
}
private WorkItemModel WorkItemModelFromResponse(WorkItemResponse response)
{
WorkItemModel model = new WorkItemModel();
FillOutWorkItemModel(model, response);
return(model);
}
public IHttpActionResult Put(WorkItemModel workModel)
{
try
{
return(Ok(_worksService.Modify(workModel)));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public WorkItemModel Modify(WorkItemModel workModel)
{
using (var context = _dbContextFactory.Create())
{
var work = context.Works.Where(w => w.Id == workModel.Id)
.FirstOrDefault();
work.Title = workModel.Title;
work.IsCompleted = workModel.Completed;
context.SaveChanges();
return(workModel);
}
}
public async Task <IActionResult> Get(int id)
{
var result = await _service.GetWorkItemByID(id);
WorkItemModel wim = new WorkItemModel();
wim.Id = result.Id;
wim.Title = result.Fields["System.Title"].ToString();
// wim.RemainingTime = Convert.ToInt32(result.Fields["Microsoft.VSTS.Scheduling.RemainingWork"]);
wim.url = result.Url;
return(Ok(wim));
}
private void FillOutWorkItemModel(WorkItemModel model, WorkItemResponse response)
{
model.Activity = response.Fields.Activity;
model.CompletedWork = response.Fields.CompletedWork;
model.IterationPath = response.Fields.IterationPath;
model.OriginalEstimate = response.Fields.OriginalEstimate;
model.RemainingWork = response.Fields.RemainingWork;
model.State = response.Fields.State;
model.Title = response.Fields.Title;
model.WorkItemType = response.Fields.WorkItemType;
model.ID = response.ID;
}
public async Task <WorkItemModel> GetProjectWorkItemById(int id)
{
WorkItemModel workItemModel = new WorkItemModel();
string api = string.Empty;
string commentapi = string.Empty;
if (id.ToString() != null)
{
api = String.Format(VSTSAPI.GetWorkItemsById, _appSettings.VSTS.AccountName, id);
commentapi = String.Format(VSTSAPI.GetWorkItemCommentsByID, _appSettings.VSTS.AccountName, id);
}
return(await _dataRepository.GetWorkItemById(api, commentapi));
}
public async Task <WorkItemModel> CreateWorkitem(CreateWorkItem workItem)
{
WorkItemModel workItemModel = new WorkItemModel();
try
{
workItemModel = await workItemManager.CreateWorkitem(workItem);
}
catch (Exception)
{
}
return(workItemModel);
}
public async Task <WorkItemModel> CreateAttachmentToWorkitem(int workItemid, string solname, string projectid,
string orgnizationurl, string builderroreport)
{
WorkItemModel workItemModel = new WorkItemModel();
try
{
workItemModel = await workItemManager.CreateAttachmentToWorkitem(workItemid, solname, projectid,
orgnizationurl, builderroreport);
}
catch (Exception)
{
}
return(workItemModel);
}
public async Task <IActionResult> GetProjectWorkItemsById(int projectId, int workItemId)
{
WorkItemModel WorkItem = await _workItemsRepository.GetProjectWorkItemById(workItemId);
if (WorkItem != null)
{
return(Ok(new Response <WorkItemModel> {
Code = HttpStatusCode.OK, Data = WorkItem, Message = string.Empty
}));
}
else
{
return(BadRequest(new ErrorResponse(ResponseMessageModel.WorkItemMessage.PleaseContactToAdministrator)));
}
}
public async Task <WorkItem> Create(
string accessToken,
string organization,
string project,
string type,
WorkItemModel model
)
{
var url = URL_TEMPLATE.Replace(
"{organization}",
organization
).Replace(
"{project}",
project
).Replace(
"{type}",
type
);
var result = await Post <WorkItem>(
url,
accessToken,
model
//new List<object>
//{
// new
// {
// op = "add",
// path = "/fields/System.Title",
// value = title,
// },
// new
// {
// op = "add",
// path = "/fields/System.Description",
// value = $"Description for {title}",
// },
//}
);
if (!result.Successful)
{
return(new WorkItem());
}
return(result.Result);
}
public IEnumerable <WorkItemModel> GetPersonalWork()
{
List <WorkItemModel> items = new List <WorkItemModel>();
if (_isInitialized)
{
IEnumerable <XElement> elements = _personalWorkDoc.Descendants("work");
foreach (XElement element in elements)
{
IWorkItemModelDAO dao = new WorkItemModelXMLDAO(element);
WorkItemModel item = new WorkItemModel(dao);
items.Add(item);
}
}
return(items);
}
public WorkItemModel Create(WorkItemModel workModel)
{
using (var context = _dbContextFactory.Create())
{
var work = new Work
{
WorkListId = workModel.WorkListId,
Title = workModel.Title,
IsCompleted = false
};
context.Works.Add(work);
context.SaveChanges();
workModel.Id = work.Id;
return(workModel);
}
}
public override void AddWorkItem(WorkItemModel workItemModel)
{
try
{
if (workItemModel == null)
{
return;
}
var GitPendingChangesModelType =
Type.GetType(
"Microsoft.TeamFoundation.Git.Controls.PendingChanges.GitPendingChangesModel,Microsoft.TeamFoundation.Git.Controls");
var gitPendingChangesModel = ServiceProvider.GetService(GitPendingChangesModelType);
var method = GitPendingChangesModelType.GetMethod("AddWorkItemsByIdAsync",
BindingFlags.Public | BindingFlags.Instance);
method.Invoke(gitPendingChangesModel, new object[] { new[] { workItemModel.Id } });
}
catch (Exception ex)
{
ShowNotification(ex.ToString(), NotificationType.Error);
}
}
public void AddWorkItem(WorkItemModel workItemModel)
{
try
{
if (workItemModel == null)
{
return;
}
int selectedWorkItemId = workItemModel.Id;
var pc = GetService <IPendingChangesExt>();
var model = pc.GetType().GetField("m_workItemsSection", BindingFlags.NonPublic | BindingFlags.Instance);
var t = model.FieldType;
var mm = model.GetValue(pc);
var m = t.GetMethod("AddWorkItemById", BindingFlags.NonPublic | BindingFlags.Instance);
m.Invoke(mm, new object[] { selectedWorkItemId });
}
catch (Exception ex)
{
ShowNotification(ex.ToString(), NotificationType.Error);
}
}
public async Task <bool> CreateWorkItem(WorkItemModel workItemModel, bool isAdmin, string userId)
{
string userName = string.Empty;
var adminProjSettings = await _projectdata.GetProjectSettings(workItemModel.Id);
if (!isAdmin)
{
UserModel user = await _userData.GetUserDetail(userId);
if (user != null)
{
userName = user.UserName;
}
else
{
return(false);
}
}
else
{
userName = userId;
}
string api = string.Empty;
workItemModel.AssignTo = adminProjSettings != null && adminProjSettings.Count > 0 ? adminProjSettings[0].DefaultAssignment : string.Empty;
List <string> projectNames = await _projectdata.GetProjectName(workItemModel.Id);
workItemModel.ProjectId = projectNames != null && projectNames.Count > 0 ? projectNames[0] : string.Empty;
workItemModel.State = adminProjSettings != null && adminProjSettings.Count > 0 ? adminProjSettings[0].CreatedItemStatus : string.Empty;
if (adminProjSettings != null && adminProjSettings.Count > 0)
{
api = workItemModel.WorkItemId != 0 ? String.Format(VSTSAPI.UpdateWorkItem, _appSettings.VSTS.AccountName, workItemModel.ProjectId, workItemModel.WorkItemId, _appSettings.VSTS.ByPassRules) : String.Format(VSTSAPI.CreateWorkItem, _appSettings.VSTS.AccountName, workItemModel.ProjectId, adminProjSettings[0].CreatedItemType.ToLower(), _appSettings.VSTS.ByPassRules);
}
return(await _dataRepository.CreateWorkItem(workItemModel, api, userName));
}
public async Task <WorkItemModel> CreateLinkedWorkitem(CreateWorkItem workItem)
{
WorkItemModel workItemModel = new WorkItemModel();
DevOpsConnectionPool poolObj = _builderPool.Get();
try
{
List <Params> ListParams = new List <Params>();
//VssCredentials creds = new VssBasicCredential(string.Empty, personalaccesstoken);
//VssConnection connection = new VssConnection(new Uri(c_collectionUri), creds);
//ProjectHttpClient projectClient = connection.GetClient<ProjectHttpClient>();
var workItemTrackingClient = poolObj.VssConnection.GetClient <WorkItemTrackingHttpClient>();
JsonPatchDocument patchDocument = new JsonPatchDocument();
Fields field = null;
string title = $"Error deploying solution {workItem.crmsolutioname} in {workItem.crmorgurl}.";
string bugtest = $"Error deploying solution {workItem.crmsolutioname} in {workItem.crmorgurl}. \n See attachment file for full error log.";
string description = $"Error deploying solution {workItem.crmsolutioname} in {workItem.crmorgurl}. \n See attachment file for full error log.";
switch (workItem.type.ToLower())
{
case "bug":
field = new Fields()
{
AssignedTo = workItem.assignedTo,
BugText = bugtest,
Priority = "2",
Title = title,
Severity = "2 - High"
};
ListParams.AddRange(GetBugFields(field));
break;
default: //Issue,Feature,Task
field = new Fields()
{
AssignedTo = workItem.assignedTo,
Description = description,
Priority = "2",
Title = title,
Severity = "2 - High"
};
ListParams.AddRange(GetTaskIssueFeatureFields(field));
break;
}
foreach (var item in ListParams)//there will be one type of witalways
{
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Microsoft.VisualStudio.Services.WebApi.Patch.Operation.Add,
Path = item.Path,
Value = item.Value,
}
);
}
if (workItem.parentWit > 0)
{
/* patchDocument.Add(new Microsoft.VisualStudio.Services.WebApi.Patch.Json.JsonPatchOperation()
* {
* Operation = Microsoft.VisualStudio.Services.WebApi.Patch.Operation.Add,
* Path = "/fields/System.Title",
* Value = "childWIT"
* });*/
patchDocument.Add(new Microsoft.VisualStudio.Services.WebApi.Patch.Json.JsonPatchOperation()
{
Operation = Microsoft.VisualStudio.Services.WebApi.Patch.Operation.Add,
Path = "/relations/-",
Value = new
{
rel = "System.LinkTypes.Hierarchy-Reverse",
url = poolObj.VssConnection.Uri.AbsoluteUri + "/" + workItem.projectname + "/_apis/wit/workItems/" + workItem.parentWit
}
});
}
var workitem = await workItemTrackingClient.CreateWorkItemAsync(patchDocument, workItem.projectid, workItem.type);
if (workitem != null)
{
workItemModel.Id = workitem.Id.Value;
workItemModel.url = workitem.Url;
}
}
catch (Exception ex)
{
}
finally
{
_builderPool.Return(poolObj);
}
return(workItemModel);
}
public IEnumerable <WorkItemModel> GetAllWorkItems()
{
var model = new WorkItemModel();
return(model.MyWorkItems());
}
public async Task <WorkItemModel> CreateWorkitem(CreateWorkItem workItem)
{
WorkItemModel workItemModel = new WorkItemModel();
DevOpsConnectionPool poolObj = _builderPool.Get();
try
{
List <Params> ListParams = new List <Params>();
//VssCredentials creds = new VssBasicCredential(string.Empty, personalaccesstoken);
//VssConnection connection = new VssConnection(new Uri(c_collectionUri), creds);
//ProjectHttpClient projectClient = connection.GetClient<ProjectHttpClient>();
var workItemTrackingClient = poolObj.VssConnection.GetClient <WorkItemTrackingHttpClient>();
JsonPatchDocument patchDocument = new JsonPatchDocument();
Fields field = null;
string title = $"error deploying solution {workItem.crmsolutioname} in {workItem.crmorgurl}";
string bugtest = $"error deploying solution {workItem.crmsolutioname} in {workItem.crmorgurl}. \n see attachment file for full error log.";
string description = $"error deploying solution {workItem.crmsolutioname} in {workItem.crmorgurl}. \n see attachment file for full error log.";
switch (workItem.type.ToLower())
{
case "bug":
field = new Fields()
{
AssignedTo = workItem.assignedTo,
BugText = bugtest, //workItem.bugtest,
Priority = "2",
Title = title, //workItem.title,
Severity = "2 - High"
};
ListParams.AddRange(GetBugFields(field));
break;
default: //Issue,Feature,Task
field = new Fields()
{
AssignedTo = workItem.assignedTo,
Description = description, //workItem.description,
Priority = "2",
Title = title,
Severity = "2 - High"
};
ListParams.AddRange(GetTaskIssueFeatureFields(field));
break;
}
foreach (var item in ListParams)
{
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Microsoft.VisualStudio.Services.WebApi.Patch.Operation.Add,
Path = item.Path,
Value = item.Value,
}
);
}
var workitem = await workItemTrackingClient.CreateWorkItemAsync(patchDocument, workItem.projectid, workItem.type);
if (workitem != null)
{
workItemModel.Id = workitem.Id.Value;
workItemModel.url = workitem.Url;
}
}
catch (Exception)
{
}
finally
{
_builderPool.Return(poolObj);
}
return(workItemModel);
}
public static JsonPatchDocument ToPatchDocument(this WorkItemModel model, string ProjectName, WorkItem parent = null)
{
var workItemType = "User Story";
if (model.Type == "Bug")
{
workItemType = "Bug";
}
if (parent != null)
{
workItemType = "Task";
}
var azurePriority = 5;
if (model.BacklogPriority > 0 && model.BacklogPriority < 1000)
{
azurePriority = 1;
}
else if (model.BacklogPriority >= 1000 && model.BacklogPriority < 10000)
{
azurePriority = 2;
}
else if (model.BacklogPriority >= 10000 && model.BacklogPriority < 100000)
{
azurePriority = 3;
}
else if (model.BacklogPriority >= 100000 && model.BacklogPriority < 500000)
{
azurePriority = 4;
}
var patchDocument = new JsonPatchDocument
{
new JsonPatchOperation()
{
Operation = Operation.Add, Path = "/fields/System.Title", Value = model.Title
},
new JsonPatchOperation()
{
Operation = Operation.Add, Path = "/fields/System.AreaPath", Value = $"{ProjectName}\\{model.AreaPath}"
},
new JsonPatchOperation()
{
Operation = Operation.Add, Path = "/fields/System.IterationPath", Value = $"{ProjectName}\\{model.IterationPath}"
},
new JsonPatchOperation()
{
Operation = Operation.Add, Path = "/fields/System.WorkItemType", Value = workItemType
},
new JsonPatchOperation()
{
Operation = Operation.Add, Path = "/fields/System.State", Value = model.State
},
new JsonPatchOperation()
{
Operation = Operation.Add, Path = "/fields/System.AssignedTo", Value = model.AssignedTo
},
new JsonPatchOperation()
{
Operation = Operation.Add, Path = "/fields/System.CreatedBy", Value = model.CreatedBy
},
new JsonPatchOperation()
{
Operation = Operation.Add, Path = "/fields/System.CreatedDate", Value = model.CreatedDate
},
new JsonPatchOperation()
{
Operation = Operation.Add, Path = "/fields/System.Tags", Value = model.Tags
}
};
if (model.Type == "Bug")
{
patchDocument.Add(new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/Microsoft.VSTS.TCM.ReproSteps",
Value =
$"<pre>Ported by tfs-to-devops @ {DateTime.Now:dd-MMM-yyyy HH:mm:ss}{Environment.NewLine}</pre><p><hr></p>{model.HtmlDescription}"
});
private void RegisterMessages()
{
Messenger.Default.Register <UpdateWaitSpinnerMessage>(this, ProcessUpdateWaitSpinnerMessage);
Messenger.Default.Register <RefreshMessage>(this,
(message) =>
{
switch (message.ItemToRefresh)
{
case RefreshTarget.Pools:
AsyncOperationTracker.Instance.AddTrackedInternalOperation(this.GetDataAsync(dataProvider, false, false, true));
break;
case RefreshTarget.WorkItems:
AsyncOperationTracker.Instance.AddTrackedInternalOperation(this.GetDataAsync(dataProvider, true, false, false));
break;
}
}
);
Messenger.Default.Register <ModelNotFoundAfterRefresh>(this, (message) =>
{
ModelBase modelBase = message.Model;
WorkItemModel workItemModel = modelBase as WorkItemModel;
if (workItemModel != null)
{
this.workItems.Remove(workItemModel);
FirePropertyChangedEvent("WorkItemTabTitle");
SelectedWorkItem = null;
}
PoolModel poolModel = modelBase as PoolModel;
if (poolModel != null)
{
this.pools.Remove(poolModel);
FirePropertyChangedEvent("PoolTabTitle");
SelectedPool = null;
SelectedTVM = null;
}
JobModel jobModel = modelBase as JobModel;
if (jobModel != null)
{
jobModel.ParentWorkItem.Jobs.Remove(jobModel);
FirePropertyChangedEvent("JobTabTitle");
}
TaskModel taskModel = modelBase as TaskModel;
if (taskModel != null)
{
taskModel.ParentJob.Tasks.Remove(taskModel);
taskModel.ParentJob.UpdateTaskView();
FirePropertyChangedEvent("TasksTabTitle");
}
TvmModel vmModel = modelBase as TvmModel;
if (vmModel != null)
{
vmModel.ParentPool.Tvms.Remove(vmModel);
vmModel.ParentPool.UpdateTvmView();
FirePropertyChangedEvent("VMsTabTitle");
selectedTVM = null;
}
});
}
public async Task <List <WorkItemModel> > GetAllworkItems(string projectName, string searchText)
{
List <WorkItemModel> workItems = new List <WorkItemModel>();
WorkItemModel workItemModel = null;
DevOpsConnectionPool poolObj = _builderPool.Get();
try
{
//VssCredentials creds = new VssBasicCredential(string.Empty, personalaccesstoken);
//VssConnection connection = new VssConnection(new Uri(c_collectionUri), creds);
var workItemTrackingClient = poolObj.VssConnection.GetClient <WorkItemTrackingHttpClient>();
// create a wiql object and build our query
var wiql = new Wiql()
{
// NOTE: Even if other columns are specified, only the ID & URL will be available in the WorkItemReference
Query = "Select [Id] " +
"From WorkItems " +
"Where " +
"[System.TeamProject] = '" + projectName + "' " +
"And [System.WorkItemType] <> '' AND [System.State] <> '' " +
"AND [System.Title] contains words '" + searchText + "' ORDER BY [Id]",
};
var httpClient = poolObj.VssConnection.GetClient <WorkItemTrackingHttpClient>();
var result = await httpClient.QueryByWiqlAsync(wiql);
var ids = result.WorkItems.Select(item => item.Id).ToArray();
// some error handling
if (ids.Length == 0)
{
return(workItems);
}
// build a list of the fields we want to see
var fields = new[] { "System.Id", "System.Title", "System.State" };
// get work items for the ids found in query
var witems = await httpClient.GetWorkItemsAsync(ids, fields, result.AsOf);
if (witems != null && witems.Count > 0)
{
foreach (var witem in witems)
{
workItemModel = new WorkItemModel()
{
Id = witem.Id.HasValue ? witem.Id.Value : 01,
url = witem.Url
};
workItems.Add(workItemModel);
}
}
}
catch (Exception ex)
{
}
finally
{
_builderPool.Return(poolObj);
}
return(workItems);
}
