private void InitializeViewModelsContainer()
{
TeamsViewModel teamsViewModel = new TeamsViewModel(this);
teamsViewModel.TeamSelected += OnTeamSelected;
AllTeamsViewModel allTeamsViewModel = new AllTeamsViewModel(this);
// TODO: subscribe to AllTeamsViewModel events
ProjectsViewModel projectsViewModel = new ProjectsViewModel(this);
projectsViewModel.ProjectSelected += OnProjectSelected;
ProductBacklogViewModel productBacklogViewModel = new ProductBacklogViewModel(this);
SprintViewModel sprintViewModel = new SprintViewModel(this);
AllUserTasksViewModel allUserTasksViewModel = new AllUserTasksViewModel(this);
ReviewViewModel reviewViewModel = new ReviewViewModel(this);
Logout.LogoutViewModel logoutViewModel = new Logout.LogoutViewModel(this);
ContainerBuilder builder = new ContainerBuilder();
builder.RegisterInstance(projectsViewModel);
builder.RegisterInstance(teamsViewModel);
builder.RegisterInstance(allTeamsViewModel);
builder.RegisterInstance(productBacklogViewModel);
builder.RegisterInstance(sprintViewModel);
builder.RegisterInstance(allUserTasksViewModel);
builder.RegisterInstance(reviewViewModel);
builder.RegisterInstance(logoutViewModel);
_viewModelsContainer = builder.Build();
}
public static AllTasksForTeamViewModel Create(Business.Models.Team team,
bool isOwner,
List <Business.Models.Sprint> sprints,
List <Business.Models.Task> tasks)
{
var teamMemberViewModels = new List <TeamMemberViewModel>();
var sprintViewModels = new List <SprintViewModel>();
var taskViewModels = new List <TaskViewModel>();
foreach (var teamMember in team.TeamMembers)
{
var teamMemberViewModel = TeamMemberViewModel.Create(teamMember);
teamMemberViewModels.Add(teamMemberViewModel);
}
foreach (var sprint in sprints)
{
var sprintViewModel = SprintViewModel.Create(sprint, isOwner, 0);
sprintViewModels.Add(sprintViewModel);
}
foreach (var task in tasks)
{
var taskViewModel = TaskViewModel.Create(task);
taskViewModels.Add(taskViewModel);
}
return(new AllTasksForTeamViewModel(team, isOwner, teamMemberViewModels, sprintViewModels, taskViewModels));
}
// GET: Sprints/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SprintViewModel sprintViewModel = new SprintViewModel();
sprintViewModel.Sprint = db.Sprints.Find(id);
if (sprintViewModel.Sprint == null)
{
return(HttpNotFound());
}
List <Historia> historiasDoSprint = new List <Historia>();
List <Historia> llstHistorias = db.Historias.AsNoTracking().ToList();
List <SprintAuxiliar> historiasSprintAtualAux = db.SprintAuxiliar.AsNoTracking().Where(c => c.SprintId == sprintViewModel.Sprint.Id).ToList();
historiasSprintAtualAux.ForEach(historiaAux =>
{
sprintViewModel.ScrumBoardViewModel.HistoriasDoSprint.Add(llstHistorias.Where(c => c.Id == historiaAux.HistoriaId).SingleOrDefault());
});
sprintViewModel.ScrumBoardViewModel.Historias = llstHistorias.Where(c => c.DataTermino == null).Except(sprintViewModel.ScrumBoardViewModel.HistoriasDoSprint).ToList();
return(View(sprintViewModel));
}
public async Task <IActionResult> AddSprintAsync(SprintViewModel sprintViewModel)
{
if (ModelState.IsValid)
{
var sprints = await _manageSprintsService.GetAllSprintsAsync(sprintViewModel.TeamId, new DisplayOptions());
var sprint = new Sprint
{
TeamId = sprintViewModel.TeamId,
Name = sprintViewModel.Name,
DaysInSprint = sprintViewModel.DaysInSprint,
StoryPointInHours = sprintViewModel.StoryPointInHours
};
var result = await AddSprintAsync(sprint);
if (result)
{
return(RedirectToAction("AllSprints", new { teamId = sprintViewModel.TeamId }));
}
else
{
return(RedirectToAction("NotOwnerError", new { teamId = sprintViewModel.TeamId }));
}
}
return(View(sprintViewModel));
}
public async Task <IActionResult> GetSprintById(int sprintId)
{
var sprint = await _manageSprintsService.GetSprintAsync(sprintId, true);
if (sprint == null)
{
return(View("ErrorGetAllSprints"));
}
var sprintViewModel = new SprintViewModel()
{
DaysInSprint = sprint.DaysInSprint,
Id = sprint.Id,
Tasks = CreateTaskViewModels(sprint.Tasks),
Status = sprint.Status,
Name = sprint.Name,
StoryPointInHours = sprint.StoryPointInHours,
TeamId = sprint.TeamId
};
sprintViewModel.TotalStoryPoint = sprint.Tasks.Count > 0 ? sprint.Tasks.Sum(t => t.StoryPoints) : 0;
sprintViewModel.AverageStoryPoint = await _manageSprintsService.GetAverageStoryPointAsync(sprint);
if (await _accessCheckService.IsOwnerAsync(sprint.TeamId))
{
sprintViewModel.IsOwner = true;
}
else
{
sprintViewModel.IsOwner = false;
}
return(View(sprintViewModel));
}
public SprintMenu()
{
InitializeComponent();
svm = new SprintViewModel();
this.DataContext = svm;
}
public async Task <IActionResult> Post(SprintViewModel data)
{
data.Completed = false;
var content = JsonConvert.SerializeObject(data);
await http.PostAsync("http://localhost:62021/api/sprint", new StringContent(content, Encoding.UTF8, "application/json"));
return(Redirect("/sprint"));
}
public ActionResult CreateSprint(Guid id)
{
var model = new SprintViewModel()
{
ProjectId = id
};
return(View(model));
}
public ActionResult SetupSprint(SprintViewModel model)
{
if (model != null)
{
return(View());
}
ViewBag.ErrorMsg = "An error ocurred";
return(View("Error"));
}
public ActionResult EditSprint(Guid sprintid, Guid projectId)
{
var model = new SprintViewModel()
{
ProjectId = projectId,
Sprint = _sprintService.FindById(sprintid)
};
return(View(model));
}
public async Task <IActionResult> AddSprintAsync(SprintViewModel sprintViewModel)
{
if (ModelState.IsValid)
{
sprintViewModel.Status = PossibleStatuses.CreatedStatus;
var sprints = await _manageSprintsService.GetAllSprintsAsync(sprintViewModel.TeamId, new DisplayOptions());
var activeSprint = sprints.FirstOrDefault(i => i.Status == PossibleStatuses.ActiveStatus);
if (activeSprint != null && sprintViewModel.Status == PossibleStatuses.ActiveStatus)
{
return(RedirectToAction("AddSprint", new { teamId = sprintViewModel.TeamId, errorMessage = _localizer["ActiveFieldError"] }));
}
var createdSprint = sprints.FirstOrDefault(i => i.Status == PossibleStatuses.CreatedStatus);
if (createdSprint != null && sprintViewModel.Status == PossibleStatuses.CreatedStatus)
{
return(RedirectToAction("AddSprint", new { teamId = sprintViewModel.TeamId, errorMessage = _localizer["СreatedSprintExist"] }));
}
var sameSprint = sprints.FirstOrDefault(i => i.Name == sprintViewModel.Name);
if (sameSprint != null)
{
return(RedirectToAction("AddSprint", new { teamId = sprintViewModel.TeamId, errorMessage = _localizer["SprintWithSameName"] }));
}
var newSprint = new Sprint
{
TeamId = sprintViewModel.TeamId,
Name = sprintViewModel.Name,
DaysInSprint = sprintViewModel.DaysInSprint,
StoryPointInHours = sprintViewModel.StoryPointInHours,
Status = sprintViewModel.Status
};
var result = await AddSprintAsync(newSprint);
if (result && sprintViewModel.SelectTasksIds != null &&
await UpdateTasks(sprintViewModel.SelectTasksIds, newSprint.Id))
{
return(RedirectToAction("AllSprints", new { teamId = sprintViewModel.TeamId }));
}
else
{
return(RedirectToAction("NotOwnerError", new { teamId = sprintViewModel.TeamId }));
}
}
else
{
return(View(sprintViewModel));
}
}
public ActionResult Create([Bind(Include = "Sprint,Tasks")] SprintViewModel sprintVM)
{
if (ModelState.IsValid)
{
var isSprintValid = DbEntityValidator.CheckSprint(sprintVM.Sprint);
if (!string.IsNullOrEmpty(isSprintValid))
{
return(FailedAction(isSprintValid, sprintVM));
}
foreach (var task in sprintVM.Tasks)
{
var isTaskValid = DbEntityValidator.CheckTask(task);
if (!string.IsNullOrEmpty(isTaskValid))
{
return(FailedAction(isTaskValid, sprintVM));
}
}
var sprint = new Sprint
{
ProjectID = ApplicationState.Instance.CurrentProjectID,
StartDate = sprintVM.Sprint.StartDate,
EstimatedFinishDate = sprintVM.Sprint.EstimatedFinishDate,
Description = sprintVM.Sprint.Description,
Milestone = sprintVM.Sprint.Milestone,
Name = sprintVM.Sprint.Name,
ActualFinishDate = null
};
dbContext.Sprints.Add(sprint);
dbContext.SaveChanges();
var activityDescription = ApplicationState.Instance.CurrentUser.FirstName + " "
+ ApplicationState.Instance.CurrentUser.LastName
+ " created new sprint - " + sprint.Name;
new ActivityMonitorUpdater(dbContext).WriteToDatabase(activityDescription, ApplicationState.Instance.CurrentProjectID);
var tasks = new List <Task>();
foreach (var task in sprintVM.Tasks)
{
task.SprintID = sprint.ID;
activityDescription = ApplicationState.Instance.CurrentUser.FirstName + " "
+ ApplicationState.Instance.CurrentUser.LastName
+ " created new task - " + task.Summary;
new ActivityMonitorUpdater(dbContext).WriteToDatabase(activityDescription, ApplicationState.Instance.CurrentProjectID);
}
dbContext.Tasks.AddRange(sprintVM.Tasks);
dbContext.SaveChanges();
return(RedirectToAction("Index", "Program"));
}
return(FailedAction("Sprint is not valid, please check all fields", sprintVM));
}
public ActionResult CreateSprint(SprintViewModel sprint)
{
//var idProject =
var client = new RestClient(Constant.CreateSprintAsync);
var request = new RestRequest(Method.POST)
.AddParameter("Name", sprint.Name)
.AddParameter("IdProject", Session["idProject"]);
client.Execute(request);
return(RedirectToAction("ProjectDetail", new { id = Session["idProject"] }));
}
public async Task <IActionResult> AddSprintAsync(int teamId, string errorMessage)
{
var team = await _manageSprintsService.GetTeam(teamId);
var sprintViewModel = new SprintViewModel()
{
Id = teamId, Name = team.TeamName
};
ViewBag.ErrorMessage = errorMessage;
return(View(sprintViewModel));
}
public async Task <IActionResult> GetSprintById(int sprintId)
{
var sprint = await _manageSprintsService.GetSprintAsync(sprintId, true);
if (sprint == null)
{
return(View("ErrorGetAllSprints"));
}
var sprintViewModel = new SprintViewModel()
{
DaysInSprint = sprint.DaysInSprint,
Id = sprint.Id,
Tasks = new List <TaskViewModel>(),
Status = sprint.Status,
Name = sprint.Name,
StoryPointInHours = sprint.StoryPointInHours,
TeamId = sprint.TeamId
};
sprint.Tasks.ToList().ForEach(t => sprintViewModel.Tasks.Add(new TaskViewModel()
{
TeamMember = t.MemberId != null ? new TeamMemberViewModel()
{
Member = t.TeamMember.Member, MemberId = t.MemberId.ToString()
} : null,
Name = t.Name,
StoryPoints = t.StoryPoints,
Id = t.Id,
Link = t.Link,
Completed = t.Completed
}
));
sprintViewModel.TotalStoryPoint = sprint.Tasks.Count > 0 ? sprint.Tasks.Sum(t => t.StoryPoints) : 0;
sprintViewModel.AverageStoryPoint = await _manageSprintsService.GetAverageStoryPointAsync(sprint);
if (await _accessCheckService.IsOwnerAsync(sprint.TeamId))
{
sprintViewModel.IsOwner = true;
}
else
{
sprintViewModel.IsOwner = false;
}
return(View(sprintViewModel));
}
public async Task <IActionResult> GetSprintById(int sprintId)
{
var sprint = await _manageSprintsService.GetSprintAsync(sprintId, true);
if (sprint == null)
{
return(View("ErrorGetAllSprints"));
}
var sprintViewModel = new SprintViewModel()
{
DaysInSprint = sprint.DaysInSprint,
Id = sprint.Id,
Tasks = new List <TaskViewModel>(),
Status = sprint.Status,
Name = sprint.Name,
StoryPointInHours = sprint.StoryPointInHours,
TeamId = sprint.TeamId
};
sprint.Tasks.ToList().ForEach(t => sprintViewModel.Tasks.Add(new TaskViewModel()
{
TeamMember = new TeamMemberViewModel()
{
Member = t.TeamMember.Member, MemberId = t.MemberId.ToString()
},
Name = t.Name,
StoryPoints = t.StoryPoints,
Id = t.Id,
Link = t.Link,
Completed = t.Completed
}
));
if (await _accessCheckService.IsOwnerAsync(sprint.TeamId))
{
ViewBag.AddVision = "visible";
}
else
{
ViewBag.AddVision = "collapse";
}
return(View(sprintViewModel));
}
public ActionResult IndexSprint(int projectId, int sprintNo)
{
var existProject = new Project();
existProject = db.Projects.FirstOrDefault(x => x.ProjectId == projectId);
var sprintModel = new SprintViewModel
{
ProjectId = projectId,
ProjectCurrentSprint = existProject.CurrentSprintNo,
SprintCount = ProjectRepository.GetSprintCount(projectId),
SprintNo = sprintNo,
SprintBacklogs = ProjectRepository.GetSprintBacklogs(projectId, sprintNo)
};
return(View(sprintModel));
}
public CreateUserStoryPage()
{
this.InitializeComponent();
var cmbtype = new UserStoryTypeViewModel();
cmb_type.ItemsSource = cmbtype.UserStoryTypes;
var cmbsprint = new SprintViewModel();
cmb_sprint.ItemsSource = cmbsprint.Sprints;
var cmbstatus = new ScrumStageViewModel();
cmb_status.ItemsSource = cmbstatus.ScrumStages;
this.navigationHelper = new NavigationHelper(this);
this.navigationHelper.LoadState += this.NavigationHelper_LoadState;
this.navigationHelper.SaveState += this.NavigationHelper_SaveState;
}
public async Task <IActionResult> AddSprintAsync(int teamId, string errorMessage)
{
var team = await _manageSprintsService.GetTeam(teamId);
ViewBag.ErrorMessage = errorMessage;
var tasks = (await _manageTasksService.GetAllTasksForTeamAsync(teamId, new DisplayOptions()))
.Where(task => task.SprintId == null && task.Completed == false);
var sprint = Sprint.Create(teamId, tasks.ToList());
var isOwner = false;
if (await _accessCheckService.IsOwnerAsync(teamId))
{
isOwner = true;
}
var sprintViewModel = SprintViewModel.Create(sprint, isOwner, 0);
return(View(sprintViewModel));
}
public async Task <IActionResult> GetSprintById(int sprintId)
{
var sprint = await _manageSprintsService.GetSprintAsync(sprintId, true);
if (sprint == null)
{
return(View("ErrorGetAllSprints"));
}
var isOwner = false;
if (await _accessCheckService.IsOwnerAsync(sprint.TeamId))
{
isOwner = true;
}
var averageStoryPoint = await _manageSprintsService.GetAverageStoryPointAsync(sprint);
var sprintViewModel = SprintViewModel.Create(sprint, isOwner, averageStoryPoint);
return(View(sprintViewModel));
}
public static TaskFormViewModel Create(Business.Models.Task task,
string errorMessage,
List <Business.Models.TeamMember> teamMembers,
List <Business.Models.Sprint> sprints)
{
var teamMember = teamMembers.FirstOrDefault(t => t.Id == task.MemberId);
var teamMemberViewModels = new List <TeamMemberViewModel>();
string taskMemberName;
if (teamMember != null)
{
taskMemberName = teamMember.Member.UserName;
}
else
{
taskMemberName = "";
}
foreach (var member in teamMembers)
{
if (member != null)
{
var teamMemberViewModel = TeamMemberViewModel.Create(member);
teamMemberViewModels.Add(teamMemberViewModel);
}
}
var sprintViewModels = new List <SprintViewModel>();
foreach (var sprint in sprints)
{
var sprintViewModel = SprintViewModel.Create(sprint, false, 0);
sprintViewModels.Add(sprintViewModel);
}
return(new TaskFormViewModel(task, taskMemberName, errorMessage, teamMemberViewModels));
}
public async Task <IActionResult> AddSprintAsync(int teamId, string errorMessage)
{
var team = await _manageSprintsService.GetTeam(teamId);
var sprintViewModel = new SprintViewModel()
{
Id = teamId, Name = team.TeamName, Tasks = new List <TaskViewModel>()
};
ViewBag.ErrorMessage = errorMessage;
var tasks = (await _manageTasksService.GetAllTasksForTeamAsync(teamId, new DisplayOptions())).Where(task => task.SprintId == null && task.Completed == false);
tasks.ToList().ForEach(t => sprintViewModel.Tasks.Add(new TaskViewModel()
{
Name = t.Name,
Id = t.Id
}
));
sprintViewModel.SelectTasks = await SelectTasks(teamId);
return(View(sprintViewModel));
}
public ActionResult EditSprint(SprintViewModel model)
{
var userId = User.Identity.GetUserId();
if (userId == null)
{
return(RedirectToAction("Login", "Profile"));
}
var user = _applicationUserManager.FindById(userId);
if (user == null)
{
return(RedirectToAction("Login", "Profile"));
}
if (ModelState.IsValid)
{
_sprintService.Update(model.Sprint);
return(RedirectToAction("Details", new { id = model.ProjectId }));
}
return(View());
}
public AddSprintCommand(SprintViewModel sprint)
{
Sprint = sprint;
}
public Sprint(IHttpClient client, string sprintId, string projectId)
{
DataContext = new SprintViewModel(client, sprintId, projectId);
InitializeComponent();
}
public SprintView()
{
this.InitializeComponent();
sprintViewModel = new SprintViewModel();
DataContext = sprintViewModel;
}
public UpdateSprintCommand(SprintViewModel sprint)
{
Sprint = sprint;
}
public async Task <IActionResult> Put([FromBody] SprintViewModel model)
{
return(Ok(await _mediator.Send(new UpdateSprintCommand(model))));
}
private ViewResult FailedAction(string message, SprintViewModel sprintVM)
{
TempData[Constants.NOTICE] = message;
sprintVM.Tasks = new List <Task>();
return(View(sprintVM));
}
public ActionResult ViewProject(int id)
{
var project = _dataManager.FindProjectById(id);
if (project == null)
{
return(HttpNotFound());
}
var userId = HttpContext.User.Identity.GetUserId();
var userAccessList = _dataManager.GetUserAccessOnProject(id);
bool isOwner = userId.Equals(project.OwnerId);
bool hasAccess = userAccessList.Any(access => access.UserId.Equals(userId));
if (!isOwner &&
!hasAccess)
{
//TODO: Update to display error that the user does not have access to the project
return(HttpNotFound());
}
List <ReferenceTaskViewModel> taskList = new List <ReferenceTaskViewModel>();
foreach (var taskModel in project.TaskList)
{
if (taskModel.SprintId == null || taskModel.SprintId == 0)
{
ReferenceTaskViewModel taskReference = new ReferenceTaskViewModel()
{
Id = taskModel.Id,
Name = taskModel.Name
};
if (taskModel.Status.Equals(TaskState.Finished))
{
taskReference.IsCompleted = true;
}
taskList.Add(taskReference);
}
}
List <SprintViewModel> sprintList = new List <SprintViewModel>();
foreach (var sprintModel in project.SprintList)
{
SprintViewModel model = Mapper.Map <SprintViewModel>(sprintModel);
int openTasks = 0;
int workingTask = 0;
int finishedTasks = 0;
int percentageOfCompletion = 0;
try
{
//TODO see why what is the problem and why the respons is 0 0 0
model.Tasks.ForEach(task =>
{
TaskModel currentTask = project.TaskList.Find(taskModel => taskModel.Id == task.Id);
if (currentTask.Status != null)
{
if (currentTask.Status.Equals(TaskState.Open))
{
openTasks++;
}
else if (currentTask.Status.Equals(TaskState.Working) ||
currentTask.Status.Equals(TaskState.Review))
{
workingTask++;
}
else if (currentTask.Status.Equals(TaskState.Finished))
{
task.IsCompleted = true;
finishedTasks++;
}
}
});
int totalNumberOfTasks = openTasks + workingTask + finishedTasks;
percentageOfCompletion = finishedTasks * 100 / totalNumberOfTasks;
}
catch
{
Console.WriteLine("Failed to calculate sprint task status for project " + project.Name);
}
model.OpenTasks = openTasks;
model.WorkingTasks = workingTask;
model.FinishedTasks = finishedTasks;
model.PercentageOfCompletion = percentageOfCompletion;
sprintList.Add(model);
}
ProjectViewModel viewModel = new ProjectViewModel()
{
Name = project.Name,
Id = project.Id,
OwnerId = project.OwnerId,
TaskList = taskList,
SprintList = sprintList
};
return(View("ViewProject", viewModel));
}
public async Task <IActionResult> AddTaskIntoTeamAsync(TaskFormViewModel taskFormViewModel)
{
if (ModelState.IsValid)
{
if (taskFormViewModel.LinkValidation == null && !Regex.IsMatch(taskFormViewModel.TaskLink,
@"^(?:http(s):\/\/)(github\.com\/)|(bitbucket\.org\/)[\w\d\S]+(\/[\w\d\S]+)*$"))
{
return(RedirectToAction("AddTaskIntoTeam", new { teamId = taskFormViewModel.TeamId,
errorMessage = _localizer["LinkFieldError"] }));
}
else if (taskFormViewModel.LinkValidation != null && !Regex.IsMatch(taskFormViewModel.TaskLink,
@"^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+$"))
{
return(RedirectToAction("AddTaskIntoTeam", new { teamId = taskFormViewModel.TeamId,
errorMessage = _localizer["LinkFieldError"] }));
}
var task = Business.Models.Task.Create(taskFormViewModel.TaskId,
taskFormViewModel.TeamId,
null,
taskFormViewModel.TaskName,
taskFormViewModel.TaskStoryPoints,
taskFormViewModel.TaskLink,
taskFormViewModel.TaskSprintId,
taskFormViewModel.TaskMemberId);
var isOwner = await _accessCheckService.IsOwnerAsync(task.TeamId);
if (!isOwner)
{
return(RedirectToAction("NotOwnerError", new { teamId = taskFormViewModel.TeamId }));
}
var result = await _manageTasksService.AddTaskAsync(task);
if (result)
{
return(RedirectToAction("GetSprintById", "ManageSprints", new { sprintId = taskFormViewModel.TaskSprintId }));
}
else
{
return(RedirectToAction("AddTaskError", new { teamId = taskFormViewModel.TeamId }));
}
}
var teamMembers = await GetAllTeamMembersAsync(taskFormViewModel.TeamId);
var teamSprints = await _manageSprintsService.GetAllSprintsAsync(taskFormViewModel.TeamId, new DisplayOptions());
taskFormViewModel.TeamMembers = new List <TeamMemberViewModel>();
foreach (var teamMember in teamMembers)
{
var teamMemberViewModel = TeamMemberViewModel.Create(teamMember);
taskFormViewModel.TeamMembers.Add(teamMemberViewModel);
}
taskFormViewModel.Sprints = new List <SprintViewModel>();
foreach (var teamSprint in teamSprints)
{
var sprintViewModel = SprintViewModel.Create(teamSprint, false, 0);
taskFormViewModel.Sprints.Add(sprintViewModel);
}
return(View(taskFormViewModel));
}
