public EditWorkItem(
IWorkApplicationService workApplicationService,
IWeekApplicationService weekApplicationService,
IAssigneeApplicationService assigneeApplicationService,
IEpicApplicationService epicApplicationService,
WorkItemViewModel workItem)
{
_workApplicationService = workApplicationService;
_weekApplicationService = weekApplicationService;
_assigneeApplicationService = assigneeApplicationService;
_epicApplicationService = epicApplicationService;
_workItemViewModel = workItem;
InitializeComponent();
LoadData();
DataContext = this;
if (_workItemViewModel.Id.HasValue)
{
DateStatusChanged.Focus();
}
else
{
IssueID.Focus();
}
}
private void Update()
{
if (!FormIsValid())
{
return;
}
var team = CbbTeam.SelectedItem?.ToString();
_workItemViewModel.IssueId = IssueID.Text;
_workItemViewModel.Epic = (EpicViewModel)CbbEpic.SelectedItem ?? _workItemViewModel.Epic;
_workItemViewModel.Week = (WeekViewModel)CbbWeek.SelectedItem ?? _workItemViewModel.Week;
_workItemViewModel.Type = CbbType.SelectedItem != null ? (WorkType)CbbType.SelectedItem : _workItemViewModel.Type;
_workItemViewModel.Status = (WorkStatus)CbbStatus.SelectedItem;
_workItemViewModel.AcceptanceReleaseDate = AcceptanceReleaseDate.SelectedDate;
_workItemViewModel.ProductionReleaseDate = ProductionReleaseDate.SelectedDate;
_workItemViewModel.Assignee = (AssigneeViewModel)CbbAssignee.SelectedItem ?? _workItemViewModel.Assignee;
_workItemViewModel.Team = _workItemViewModel.Assignee != null ? _workItemViewModel.Assignee.Team : string.IsNullOrEmpty(team) ? _workItemViewModel.Team : team;
_workItemViewModel.StartImpedimentDate = StartImpedimentAt.SelectedDate;
_workItemViewModel.EndImpedimentDate = EndImpedimentAt.SelectedDate;
_workItemViewModel.Observations = ImpObservation.Text;
_workItemViewModel.UpdatedBy = "master";
_workItemViewModel.CreatedBy = "master";
_workItemViewModel = _workApplicationService.CreateOrUpdate(_workItemViewModel, DateStatusChanged.SelectedDate);
if (MessageBox.Show("Work item has updated, Do you want continue editing?", "Information.", MessageBoxButton.YesNo) == MessageBoxResult.No)
{
Close();
}
}
public EditTaskPage(WorkItemViewModel selectedItem) : this()
{
_selectedItem = selectedItem;
Vm.Init(_selectedItem);
BindingContext = Vm;
Title = selectedItem.Title;
}
private string GetOrganization(WorkItemViewModel item)
{
var project = _repository.GetSingle <Project>(p => p.Name == GetProject(item));
var organization = project != null?_repository.GetSingle <VstsOrganization>(o => o.Id == project.Organization) : null;
return(organization != null ? organization.Name : string.Empty);
}
private void CreateNewWorkItem()
{
if (!FormIsValid())
{
return;
}
_workItemViewModel = new WorkItemViewModel
{
IssueId = IssueID.Text,
Week = (WeekViewModel)CbbWeek.SelectedItem,
Type = (WorkType)CbbType.SelectedItem,
TechDebt = TechDebt.IsChecked ?? false,
BacklogDate = IncludeDate.SelectedDate.Value,
Assignee = (AssigneeViewModel)CbbAssignee.SelectedItem,
AcceptanceReleaseDate = ReleaseDate.SelectedDate,
Epic = (EpicViewModel)CbbEpic.SelectedItem,
CreatedBy = "master"
};
_workApplicationService.CreateOrUpdate(_workItemViewModel, null);
MessageBox.Show("Work item has created", "Information.");
Close();
}
protected override bool IsSupported(WorkItemViewModel item)
{
var type = item[WorkItemTypeField];
return(string.Equals(type, WorkItemTypeBug, StringComparison.OrdinalIgnoreCase) ||
string.Equals(type, WorkItemTypeTask, StringComparison.OrdinalIgnoreCase));
}
private IEnumerable <int> GetPullRequestIds(WorkItemViewModel workItem)
{
var ids = workItem.Relations?
.Where(r => string.Equals(r.RelationType, ArtifactLink, StringComparison.OrdinalIgnoreCase) && r.Url.LocalPath.Contains(PullRequestId))
.Select(r => r.Url.LocalPath.Substring(r.Url.LocalPath.LastIndexOf(ForwardSlash) + 1))
.ToArray();
if (ids is null)
{
return(Enumerable.Empty <int>());
}
var convertedIds = new List <int>(ids.Count());
foreach (var idString in ids)
{
if (int.TryParse(idString, out var id))
{
convertedIds.Add(id);
}
else
{
_logger.LogError("Error parsing pull request for work item {WorkItemId}; String to parse: {StringToParse}", workItem.WorkItemId, idString);
}
}
return(convertedIds);
}
public async Task <bool> IsInCodeReview(WorkItemViewModel workItem)
{
var isActiveWithCodeReviewTag = IsActive(workItem) && workItem.Fields.ContainsKey(WorkItemTagsField) && ContainsTag(workItem.Fields[WorkItemTagsField], CodeReviewTag);
if (isActiveWithCodeReviewTag)
{
return(true);
}
if (!IsActive(workItem))
{
return(false);
}
var pullRequestIds = GetPullRequestIds(workItem);
if (pullRequestIds == null || !pullRequestIds.Any())
{
return(false);
}
var pullRequests = await _repository.GetAsync <PullRequest>(p => pullRequestIds.Contains(p.PullRequestId));
return(pullRequests.Count() == pullRequestIds.Count() && pullRequests.Any(p => p.State == PullRequestState.Active));
}
public ETAValues GetETAValues(WorkItemViewModel workItem)
{
return(new ETAValues(
GetEtaValue(workItem, OriginalEstimateField),
GetEtaValue(workItem, RemainingWorkField),
GetEtaValue(workItem, CompletedWorkField)));
}
public WorkItemViewModel CreateOrUpdate(WorkItemViewModel model, DateTime?dateChanged)
{
var workItem = _mapper.Map <WorkItem>(model);
var result = _workRepository.Find(workItem.Id);
if (result == null)
{
workItem.CreatedBy = model.CreatedBy;
workItem.UpdatedAt = DateTime.Now;
_workRepository.Add(workItem);
if (dateChanged != null)
{
workItem = PutDateByStatus(workItem, dateChanged.GetValueOrDefault());
}
var worksheet = CreateOrUpdateSerializable(workItem);
_workSheetRepository.Add(worksheet);
_transaction.Commit();
var viewModel = _mapper.Map <WorkItemViewModel>(workItem);
return(viewModel);
}
else
{
result.UpdatedBy = model.CreatedBy;
var week = _mapper.Map <Week>(model.Week);
var assignee = _mapper.Map <Assignee>(model.Assignee);
var team = assignee != null ? assignee.Team : model.Team;
result.WeekId = week.Id;
result.SetStatus(model.Status);
result.SetType(model.Type);
result.SetAcceptanceReleaseDate(model.AcceptanceReleaseDate);
result.SetProductionReleaseDate(model.ProductionReleaseDate);
result.SetStartImpedimentDate(model.StartImpedimentDate);
result.SetEndImpedimentDate(model.EndImpedimentDate);
result.SetObservations(model.Observations);
result.SetTeam(team);
result.AssigneeId = assignee?.Id;
if (dateChanged != null)
{
result = PutDateByStatus(result, dateChanged.GetValueOrDefault());
}
_workRepository.Update(result);
var worksheet = CreateOrUpdateSerializable(result);
_workSheetRepository.Update(worksheet);
_transaction.Commit();
var viewModel = _mapper.Map <WorkItemViewModel>(result);
return(viewModel);
}
}
private async Task <WorkItemViewModel> CreateWorkItemViewModel(Guid?id)
{
var workItem = await _repo.GetWorkItem(id);
WorkItemViewModel vm = new WorkItemViewModel
{
WorkItemId = workItem.WorkItemId,
WorkItem = workItem,
WorkId = workItem.Work.WorkId
};
if (workItem.PartsForWork != null || workItem.PartsForWork.Count() > 0)
{
vm.NumPartsForWork = workItem.PartsForWork.Count();
}
if (workItem.StartDate != null)
{
vm.StartDate = workItem.StartDate;
}
if (workItem.InvoiceDate != null)
{
vm.CompleteDate = workItem.InvoiceDate;
}
return(vm);
}
// GET: WorkItems/Create
public ActionResult Create()
{
//Create an empty work item
WorkItem workItem = new WorkItem()
{
ProjectId = ProjectId
};
//Set initial values to the view model that will be rendered in the view
WorkItemViewModel wItem = TheModelFactory.Create(workItem);
wItem.Mode = Mode.Create;
wItem.DueDate = DateTime.Now.Date;
wItem.ProjectName = ProjectViewModelSession.ProjectName;
//Set the list of team members that will be shown in the drop down for selection
IEnumerable <TeamMemberViewModel> teamMemberList = ProjectViewModelSession.TeamMembersViewModel;
wItem.TeamMemberList = new SelectList(teamMemberList, "TeamMemberId", "FullName");
//Wrap the container
WorkItemContainerViewModel container = new WorkItemContainerViewModel()
{
WorkItemsMenu = MenuWorkItemsSession,
WorkItemViewModel = wItem
};
return(View(container));
}
public EditTaskPage()
{
InitializeComponent();
_selectedItem = new WorkItemViewModel(new WorkItem());
Vm.NavigateBack = NavigateBack;
Vm.Init(_selectedItem);
BindingContext = Vm;
}
/// <summary>
/// Converts a value.
/// </summary>
/// <param name="value">The value produced by the binding source.</param>
/// <param name="targetType">The type of the binding target property.</param>
/// <param name="parameter">The converter parameter to use.</param>
/// <param name="culture">The culture to use in the converter.</param>
/// <returns>
/// A converted value. If the method returns null, the valid null value is used.
/// </returns>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (value != null && (value is WorkItem))
{
return(WorkItemViewModel.ConvertFrom(value as WorkItem));
}
return(null);
}
// TODO: DataSource should not have knowledge on the type specific to reporters!
public async Task <WorkitemInformationViewModel> GetWorkItemInfo(WorkItemViewModel workItem, IEnumerable <TeamMemberViewModel> team)
{
(var estimatedToComplete, var timeSpent) = GetEtaMetric(workItem, team, allowZeroEstimate: true);
var isInCodeReview = await IsInCodeReview(workItem);
if (IsResolved(workItem) || (!IsActive(workItem) && !IsNew(workItem)) || !IsAssignedToTeamMember(workItem, team))
{
return(null);
}
var workItemInfo = new WorkitemInformationViewModel
{
Id = workItem.WorkItemId,
Title = workItem.Fields[WorkItemTitleField],
State = workItem.Fields[WorkItemStateField],
Url = GetWorkItemUrl(GetProject(workItem), workItem.WorkItemId),
// Priority = workItem.Fields[prio]
AssignedTo = GetUserReference(workItem.Fields[WorkItemAssignedToField]),
Type = workItem.Fields[WorkItemTypeField],
IsBlocked = ContainsTag(workItem, "blocked"),
IsOnHold = ContainsTag(workItem, "onhold"),
Estimated = estimatedToComplete,
Spent = timeSpent,
PullRequests = Enumerable.Empty <WorkitemPullRequest>(),
};
var pullRequestIds = GetPullRequestIds(workItem);
if (pullRequestIds != null && pullRequestIds.Any())
{
var pullRequests = await _repository.GetAsync <PullRequest>(p => pullRequestIds.Contains(p.PullRequestId));
workItemInfo.PullRequests = pullRequestIds.Select(pId =>
{
var prInfo = new WorkitemPullRequest {
Id = pId
};
var pr = pullRequests.SingleOrDefault(p => p.PullRequestId == pId);
if (pr == null)
{
return(prInfo);
}
prInfo.Url = GetPullRequestUrl(GetProject(workItem), pr.Repository, pId);
prInfo.Title = pr.Title;
prInfo.TimeActive = GetPullRequestActiveTime(pr);
prInfo.Author = pr.Author;
prInfo.State = pr.State.ToString();
return(prInfo);
});
}
workItemInfo.Warnings = GetWorkitemWarnings(workItemInfo, workItem);
return(workItemInfo);
}
private void Verify(IWorkItemEvent @event, WorkItemViewModel workItem, TeamMemberViewModel teamMember, DateTime expecetdDate)
{
@event.Should().BeOfType <WorkItemReOpenedEvent>();
@event.Date.Should().BeCloseTo(expecetdDate, TimeSpan.FromSeconds(1));
@event.WorkItem.Id.Should().Be(workItem.WorkItemId);
@event.AssociatedUser.Should().NotBeNull();
@event.AssociatedUser.Email.Should().Be(teamMember.Email);
@event.AssociatedUser.Title.Should().Be(teamMember.DisplayName);
}
private bool ContainsTag(WorkItemViewModel workItem, string tag)
{
if (!workItem.Fields.ContainsKey(WorkItemTagsField))
{
return(false);
}
return(ContainsTag(workItem.Fields[WorkItemTagsField], tag));
}
public async Task <ActionResult> Edit(int id)
{
_logger.LogInformation("Loading WorkItem/Task Details to Edit");
var workItemEnity = await this.workItemService.GetWorkItemById(id);
WorkItemViewModel workItemViewModel = _objectMapper.WorkItemEnityToWorkItemViewModel(workItemEnity);
return(View(workItemViewModel));
}
private IEnumerable <IWorkItemEvent> Run(WorkItemViewModel item, params TeamMemberViewModel[] team)
{
return(_classifier.Classify(new WorkItemResolutionRequest
{
StartDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow,
WorkItem = item,
Team = team
}));
}
public ActionResult EditTask(WorkItemViewModel model)
{
WorkItem item = unitOfWork.WorkItemRepository.GetByID(model.Id);
item.AssignedWorker = model.AssignedWorker;
unitOfWork.WorkItemRepository.Update(item);
unitOfWork.Save();
return(RedirectToAction("Index"));
}
public WorkItem WorkItemViewModelToWorkItemEnity(WorkItemViewModel workItemViewModel)
{
return(new WorkItem()
{
TaskId = workItemViewModel.TaskId,
Name = workItemViewModel.Name,
NoOfHours = workItemViewModel.NoOfHours,
IsCompleted = workItemViewModel.IsCompleted,
});
}
public ActionResult Edit(WorkItemViewModel workItem)
{
if (ModelState.IsValid)
{
var entity = Mapper.Map <WorkItem>(workItem);
_workItemService.Update(entity);
return(RedirectToAction("Index"));
}
ViewBag.ProjectId = new SelectList(_projectService.GetAll(), "Id", "Name", workItem.ProjectId);
return(View(workItem));
}
public ActionResult EditTask(WorkItemViewModel model)
{
string newAssignWorkerUsername = Request.Form["AssignedWorker"].ToString();
ApplicationUser newAssignUser = unitOfWork.UserRepository.Get().Where(s => s.UserName.Equals(newAssignWorkerUsername)).SingleOrDefault();
WorkItem item = unitOfWork.WorkItemRepository.GetByID(model.Id);
item.AssignedWorker = newAssignUser;
unitOfWork.WorkItemRepository.Update(item);
unitOfWork.Save();
return(RedirectToAction("Index"));
}
public IEnumerable <IWorkItemEvent> Classify(WorkItemViewModel item, ClassificationScope scope)
{
var rs = from c in _classifiers
let resolutions = c.Classify(new WorkItemResolutionRequest {
WorkItem = item, Team = scope.Team, StartDate = scope.StartDate, EndDate = scope.EndDate
})
from r in resolutions
where IsInRange(r, scope) || IsError(r)
select r;
return(rs.ToList());
}
public ActionResult Draft(WorkItemViewModel workItem)
{
try
{
// TODO: Add insert logic here
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
/// <summary>
/// 分组模式-待办
/// </summary>
/// <param name="pagerInfo"></param>
/// <param name="keyWord">流程模板名称</param>
/// <returns></returns>
public JsonResult MyUnfinishedWorkItemByGroup()
{
return(this.ExecuteFunctionRun(() =>
{
string orderBy = "ORDER BY " +
WorkItem.WorkItem.TableName + "." + WorkItem.WorkItem.PropertyName_Priority + " DESC," +
WorkItem.WorkItem.TableName + "." + WorkItem.WorkItem.PropertyName_ReceiveTime + " DESC";
string[] conditions = Engine.PortalQuery.GetWorkItemConditions(this.UserValidator.UserID, DateTime.MinValue, DateTime.MaxValue, WorkItem.WorkItemState.Unfinished, string.Empty, OThinker.Data.BoolMatchValue.Unspecified, string.Empty, false, WorkItem.WorkItem.TableName);
DataTable dtWorkitem = Engine.PortalQuery.QueryWorkItem(conditions, -1, -1, orderBy, WorkItem.WorkItem.TableName);
string[] columns = new string[] { WorkItem.WorkItem.PropertyName_OrgUnit };
Dictionary <string, string> unitNames = this.GetUnitNamesFromTable(dtWorkitem, columns);
Dictionary <string, string> workflowNames = this.GetWorkflowNamesFromTable(dtWorkitem);
Dictionary <string, WorkItemGroup> workflowGroups = new Dictionary <string, WorkItemGroup>();
// 获取分组集合
foreach (DataRow row in dtWorkitem.Rows)
{
string workflowCode = row[WorkItem.WorkItem.PropertyName_WorkflowCode] + string.Empty;
if (!workflowGroups.ContainsKey(workflowCode))
{
string workflowName = workflowNames[workflowCode] + string.Empty;
workflowGroups.Add(workflowCode, new WorkItemGroup(workflowCode, workflowName));
}
var workItem = new WorkItemViewModel()
{
Priority = row[WorkItem.WorkItem.PropertyName_Priority] + string.Empty,
Urged = this.GetColumnsValue(row, WorkItem.WorkItem.PropertyName_Urged).ToString() == "1" ? true : false,
ObjectID = row[WorkItem.WorkItem.PropertyName_ObjectID] + string.Empty,
InstanceId = row[WorkItem.WorkItem.PropertyName_InstanceId] + string.Empty,
WorkflowCode = workflowCode,
InstanceName = row[Instance.InstanceContext.PropertyName_InstanceName] + string.Empty,
ActivityCode = row[WorkItem.WorkItem.PropertyName_ActivityCode] + string.Empty,
DisplayName = row[WorkItem.WorkItem.PropertyName_DisplayName] + string.Empty,
ReceiveTime = this.GetValueFromDate(row[WorkItem.WorkItem.PropertyName_ReceiveTime], WorkItemTimeFormat),
Originator = row[WorkItem.WorkItem.PropertyName_Originator] + string.Empty,
OriginatorName = row[Instance.InstanceContext.PropertyName_OriginatorName] + string.Empty,
OriginatorOUName = this.GetValueFromDictionary(unitNames, row[Instance.InstanceContext.PropertyName_OrgUnit] + string.Empty)
};
workflowGroups[workflowCode].WorkItems.Add(workItem);
}
List <WorkItemGroup> gridDatas = new List <WorkItemGroup>();
foreach (string key in workflowGroups.Keys)
{
gridDatas.Add(workflowGroups[key]);
}
GridViewModel <WorkItemGroup> result = new GridViewModel <WorkItemGroup>(workflowGroups.Count, gridDatas);
return Json(result, JsonRequestBehavior.AllowGet);
}, FunctionNode.Workspace_MyUnfinishedWorkItem_Code));
}
// GET: WorkItems/Details/5
public ActionResult Details(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
WorkItemViewModel workItem = Mapper.Map <WorkItemViewModel>(_workItemService.Get(id.Value));
if (workItem == null)
{
return(HttpNotFound());
}
return(View(workItem));
}
private float GetEtaFromUpdates(WorkItemViewModel wi, string field)
{
if (wi.Updates == null || !wi.Updates.Any())
{
return(0);
}
var recoveredValue = wi.Updates
.LastOrDefault(u => (u[WorkItemStateField]?.NewValue == WorkItemStateClosed || u[WorkItemStateField]?.NewValue == WorkItemStateResolved) && u.Fields.ContainsKey(field))?
.Fields[field].OldValue;
float.TryParse(recoveredValue, out var result);
return(result);
}
private DateTime?GetStatusDate(WorkItemViewModel workItem)
{
if (workItem.Status == WorkStatus.Done)
{
return(workItem.DoneDate);
}
else if (workItem.Status == WorkStatus.AwaitingProduction)
{
return(workItem.AwaitingProductionDate);
}
else if (workItem.Status == WorkStatus.TestingInAcceptance)
{
return(workItem.TestingInAcceptanceDate);
}
else if (workItem.Status == WorkStatus.AwaitingAcceptanceTests)
{
return(workItem.AwaitingAcceptanceTestsDate);
}
else if (workItem.Status == WorkStatus.Testing)
{
return(workItem.TestingDate);
}
else if (workItem.Status == WorkStatus.AwaitingTests)
{
return(workItem.AwaitingTestsDate);
}
else if (workItem.Status == WorkStatus.Reviewing)
{
return(workItem.ReviewingDate);
}
else if (workItem.Status == WorkStatus.AwaitingCodeReview)
{
return(workItem.AwaitingCodeReviewDate);
}
else if (workItem.Status == WorkStatus.InProgress)
{
return(workItem.InProgressDate);
}
else if (workItem.Status == WorkStatus.ToDo)
{
return(workItem.ToDoDate);
}
else if (workItem.Status == WorkStatus.Backlog)
{
return(workItem.BacklogDate);
}
return(null);
}
private static WorkItemResolutionRequest GetRequest(IEnumerable <WorkItemUpdateViewModel> updates, string type = Constants.WorkItemTypeTask)
{
var workItem = new WorkItemViewModel {
Fields = new Dictionary <string, string>(), WorkItemId = 0
};
workItem.Fields.Add(Constants.WorkItemTypeField, type);
workItem.Updates = updates;
return(new WorkItemResolutionRequest
{
WorkItem = workItem,
Team = GetFakeTeam()
});
}
