public void ReportError(Guid project_id, Guid sprint_id, Guid submission_id, ReportErrorM model)
{
try
{
Submission submission = EnsureExisted(project_id, sprint_id, submission_id);
TaskSubmission task_submission = _taskSubmission.GetOne(ts => ts.SubmissionId.Equals(submission_id) && ts.TaskId.Equals(model.TaskId));
if (task_submission == null)
{
throw NotFound();
}
task_submission.Passed = model.Passed;
task_submission.Failed = model.Failed;
task_submission.IsTested = true;
task_submission.Message = model.Message;
Data.Models.Task task = _task.GetOne(t => t.Id.Equals(model.TaskId));
task.Status = model.Failed != 0 ? "Error" : "Complete";
SaveChanges();
}
catch (Exception e)
{
throw e is RequestException ? e : _errorHandler.WriteLog("An error occurred!",
e, DateTime.Now, "Server", "Service-Submission-ReportError");
}
}
public async System.Threading.Tasks.Task Add(Data.Models.Task task)
{
task.IsActive = true;
await _applicationDbContext.AddAsync(task);
await _applicationDbContext.SaveChangesAsync();
}
private async Task <Data.Models.Task> MapToDataModel(TaskServiceModel entity, string userId)
{
Data.Models.Task task = new Data.Models.Task
{
Id = entity.Id,
Name = entity.Name,
Description = entity.Description,
Budget = entity.Budget,
CompleationDate = entity.CompleationDate,
DueDate = entity.DueDate,
PictureUrl = entity.PictureUrl
};
User user = await this._userManager.FindByIdAsync(userId);
task.Issuer = user;
TaskCategory taskCategory = this._context.TaskCategories.Find(entity.TaskCategoryId);
task.TaskCategory = taskCategory;
Data.Models.TaskStatus taskStatus = this._context.TaskStatuses.Find(entity.TaskStatusId);
task.TaskStatus = taskStatus;
Location location = this._context.Locations.Find(entity.LocationId);
task.Location = location;
return(task);
}
public ServiceResponse <Data.Models.Task> UpdateTask(Data.Models.Task task)
{
try
{
var temp = _db.Tasks.Find(task.Id);
temp.Name = task.Name;
temp.Deadline = task.Deadline;
temp.AssignedTo = task.AssignedTo;
temp.ProgressNote = task.ProgressNote;
temp.ProblemNote = task.ProblemNote;
_db.Tasks.Update(temp);
_db.SaveChanges();
return(new ServiceResponse <Data.Models.Task>
{
IsSuccess = true,
Message = "New Task Updated",
Time = DateTime.UtcNow,
Data = task
});
}
catch (Exception e)
{
return(new ServiceResponse <Data.Models.Task>
{
IsSuccess = false,
Message = e.StackTrace,
Time = DateTime.UtcNow,
Data = null
});
}
}
private async Task <bool> UpdateTasks(int[] selectedTasksId, int sprintId)
{
var currentSprint = await _manageSprintsService.GetSprintAsync(sprintId, true);
var isOwner = await _accessCheckService.IsOwnerAsync(currentSprint.TeamId);
if (isOwner)
{
foreach (var selectedTaskId in selectedTasksId)
{
var currentTask = await _manageTasksService.GetTaskByIdAsync(selectedTaskId);
var task = new Data.Models.Task
{
Id = currentTask.Id,
TeamId = currentTask.TeamId,
Name = currentTask.Name,
StoryPoints = currentTask.StoryPoints,
Link = currentTask.Link,
SprintId = sprintId,
MemberId = currentTask.MemberId
};
await _manageTasksService.EditTaskAsync(task);
}
return(true);
}
return(false);
}
public async Task <Data.Models.Task> Create(int id, Data.Models.Task task)
{
try
{
var project = await _context.Projects
.Include(p => p.Tasks)
.SingleOrDefaultAsync(p => p.Id == id);
var tasks = project.Tasks.ToList();
tasks.Add(task);
project.Tasks = tasks;
_context.Set <Project>().Update(project);
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(null);
}
if (task.Developer != null)
{
task.Developer = task.Developer.WithoutPassword();
}
return(task);
}
public async Task <IActionResult> ChangeTask([FromBody] UpdateTaskModel updateTaskModel)
{
NewResponseModel newTaskResponseModel = new NewResponseModel();
try
{
Data.Models.Task task = await _db.GetTask(updateTaskModel.Task.Id); //Data.Task.FirstAsync(c => c.Id == updateTaskModel.Task.Id);
task.Name = updateTaskModel.TaskName;
task.Description = updateTaskModel.TaskDescription;
task.UserId = updateTaskModel.UserId;
task.StatusId = updateTaskModel.StatusId;
task.EndDate = updateTaskModel.TaskFinishDate;
/*newTaskResponseModel =*/ await _db.ChangeTask(task);
newTaskResponseModel.CreatedId = task.Id;
newTaskResponseModel.Message = "Success !!!";
return(Ok(newTaskResponseModel));
}
catch (Exception ex)
{
newTaskResponseModel.Message = ex.Message;
return(BadRequest(newTaskResponseModel));
}
}
public ServiceResponse <Data.Models.Task> Create(Data.Models.Task task)
{
DateTime now = DateTime.UtcNow;
try
{
_db.Tasks.Add(task);
_db.SaveChanges();
return(new ServiceResponse <Data.Models.Task>
{
IsSuccess = true,
Message = "New Task created",
Time = DateTime.UtcNow,
Data = task
});
}
catch (Exception e)
{
return(new ServiceResponse <Data.Models.Task>
{
IsSuccess = false,
Message = e.StackTrace,
Time = DateTime.UtcNow,
Data = task
});
}
}
public async System.Threading.Tasks.Task Post([FromBody] Data.Models.Task P)
{
await System.Threading.Tasks.Task.Run(() =>
{
data.SaveAsync(P);
});
}
private DisplayTaskViewModel MapToDisplayViewModel(Data.Models.Task model)
=> new DisplayTaskViewModel
{
Name = model.Name,
Description = model.Description,
Id = model.Id
};
public EditTaskViewModel MapToEditTaskViewModel(Data.Models.Task model)
=> new EditTaskViewModel
{
Id = model.Id,
Name = model.Name,
Description = model.Description,
Tests = model.Tests
};
public async Task <TaskServiceModel> DeleteAsync(string id)
{
Data.Models.Task task = await this._context.Tasks.FindAsync(id);
this._context.Remove(task);
await this._context.SaveChangesAsync();
return(null);
}
public async Task <IActionResult> EditTaskAsync(TaskFormViewModel taskViewModel)
{
if (ModelState.IsValid)
{
if (taskViewModel.LinkValidation == null && !Regex.IsMatch(taskViewModel.TaskLink, @"^(?:http(s):\/\/)(github\.com\/)|(bitbucket\.org\/)[\w\d\S]+(\/[\w\d\S]+)*$"))
{
return(RedirectToAction("EditTask", new { teamId = taskViewModel.TeamId, taskId = taskViewModel.TaskId, errorMessage = _localizer["LinkFieldError"] }));
}
else if (taskViewModel.LinkValidation != null && !Regex.IsMatch(taskViewModel.TaskLink, @"^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+$"))
{
return(RedirectToAction("EditTask", new { teamId = taskViewModel.TeamId, taskId = taskViewModel.TaskId, errorMessage = _localizer["LinkFieldError"] }));
}
var task = new Data.Models.Task
{
Id = taskViewModel.TaskId,
TeamId = taskViewModel.TeamId,
Name = taskViewModel.TaskName,
StoryPoints = taskViewModel.TaskStoryPoints,
Link = taskViewModel.TaskLink,
SprintId = taskViewModel.TaskSprintId,
MemberId = taskViewModel.TaskMemberId
};
var currentTask = await _manageTasksService.GetTaskByIdAsync(taskViewModel.TaskId);
if (currentTask.Name == taskViewModel.TaskName &&
currentTask.Link == taskViewModel.TaskLink &&
currentTask.StoryPoints == taskViewModel.TaskStoryPoints &&
currentTask.MemberId == taskViewModel.TaskMemberId
)
{
return(RedirectToAction("EditTask", new { teamId = taskViewModel.TeamId, taskId = taskViewModel.TaskId, errorMessage = _localizer["HasntAnyChange"] }));
}
var result = await EditTaskAsync(task);
if (result)
{
return(RedirectToAction("AllTasksForTeam", new { teamId = taskViewModel.TeamId }));
}
else
{
return(RedirectToAction("NotOwnerError", new { teamId = taskViewModel.TaskId }));
}
}
var teamMembers = await GetAllTeamMembersAsync(taskViewModel.TeamId);
taskViewModel.TeamMembers = new List <TeamMemberViewModel>();
teamMembers.ForEach(t => taskViewModel.TeamMembers.Add(new TeamMemberViewModel
{
Member = t.Member,
Id = t.Id
}));
return(View(taskViewModel));
}
public Task Get(Guid id)
{
Data.Models.Task foundTask = TaskRepository.Get(id);
if (foundTask == null)
{
return(null);
}
return(new Task(foundTask));
}
public async Task <IActionResult> AddTaskIntoTeamAsync(TaskFormViewModel taskFormViewModel)
{
if (ModelState.IsValid)
{
var task = new Data.Models.Task
{
Id = taskFormViewModel.TaskId,
TeamId = taskFormViewModel.TeamId,
Name = taskFormViewModel.TaskName,
StoryPoints = taskFormViewModel.TaskStoryPoints,
Link = taskFormViewModel.TaskLink,
SprintId = taskFormViewModel.TaskSprintId,
MemberId = 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>();
taskFormViewModel.Sprints = new List <SprintViewModel>().ToList();
teamMembers.ForEach(t => taskFormViewModel.TeamMembers.Add(new TeamMemberViewModel()
{
Member = t.Member,
Id = t.Id
}));
teamSprints.ToList().ForEach(t => taskFormViewModel.Sprints.Add(new SprintViewModel()
{
Name = t.Name,
Id = t.Id
}));
return(View(taskFormViewModel));
}
/// <summary>
/// Serializes a Task data model into a TaskModel view model
/// </summary>
/// <param name="task"></param>
/// <returns></returns>
public static TaskModel SerializeTask(Data.Models.Task task)
{
return(new TaskModel
{
Id = task.Id,
CreatedOn = task.CreatedOn,
UpdatedOn = task.UpdatedOn,
Deadline = task.Deadline,
Objective = task.Objective,
});
}
private async Task <bool> AddTaskAsync(Data.Models.Task task)
{
if (await _accessCheckService.IsOwnerAsync(task.TeamId))
{
return(await _manageTasksService.AddTaskAsync(task));
}
else
{
return(false);
}
}
public async System.Threading.Tasks.Task AssignCareTakerToTask(string taskId, string careTakerId)
{
Data.Models.Task task = await this._context.Tasks.FindAsync(taskId);
User careTaker = await this._userManager.FindByIdAsync(careTakerId);
task.Assignee = careTaker;
this._context.Update(task);
await this._context.SaveChangesAsync();
}
public async Task <IActionResult> AddTaskAsync(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("AddTask", new { teamId = taskFormViewModel.TeamId, sprintId = taskFormViewModel.TaskSprintId, errorMessage = _localizer["LinkFieldError"] }));
}
else if (taskFormViewModel.LinkValidation != null && !Regex.IsMatch(taskFormViewModel.TaskLink, @"^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+$"))
{
return(RedirectToAction("AddTask", new { teamId = taskFormViewModel.TeamId, sprintId = taskFormViewModel.TaskSprintId, errorMessage = _localizer["LinkFieldError"] }));
}
var task = new Data.Models.Task
{
Id = taskFormViewModel.TaskId,
TeamId = taskFormViewModel.TeamId,
Name = taskFormViewModel.TaskName,
StoryPoints = taskFormViewModel.TaskStoryPoints,
Link = taskFormViewModel.TaskLink,
SprintId = taskFormViewModel.TaskSprintId,
MemberId = 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);
taskFormViewModel.TeamMembers = new List <TeamMemberViewModel>();
teamMembers.ForEach(t => taskFormViewModel.TeamMembers.Add(new TeamMemberViewModel()
{
Member = t.Member,
Id = t.Id
}));
return(View(taskFormViewModel));
}
public async System.Threading.Tasks.Task InsertAsync_TaskRepositoryReturns_True()
{
//Arrange
Data.Models.Task task = new Data.Models.Task {
Id = 6, Name = "Task6", TeamId = 6, SprintId = 6, MemberId = 6, Link = "Link6", StoryPoints = 6
};
//Act
var result = await _taskRepository.InsertAsync(task);
//Assert
Assert.IsTrue(result);
}
public async System.Threading.Tasks.Task UpdateAsync_TaskRepositoryReturns_False()
{
//Arrange
Data.Models.Task task = new Data.Models.Task {
Id = 8, Name = "Task2", TeamId = 2, SprintId = 2, MemberId = 6, Link = "Link2", StoryPoints = 2
};
//Act
var result = await _taskRepository.UpdateAsync(task);
//Assert
Assert.IsFalse(result);
}
//TODO: isUser should be falase best practice
public async Task <TaskServiceModel> UpdateAsync(TaskServiceModel entity, string issuerrId, bool isUser = true)
{
User user = await this._userManager.FindByIdAsync(issuerrId);
Data.Models.Task task = await this._context.Tasks.Include(x => x.Location)
.Include(x => x.Issuer)
.Include(x => x.Assignee)
.Include(x => x.TaskStatus)
.Include(x => x.TaskCategory)
.FirstOrDefaultAsync(x => x.Id == entity.Id);
if (isUser)
{
if (task.TaskStatus.Name != TaskStatusesConstants.Awaiting)
{
throw new TaskNotCorrectStatusException($"Only tasks with status {TaskStatusesConstants.Awaiting} can be editted!");
}
}
task.Name = entity.Name;
task.Description = entity.Description;
task.Budget = entity.Budget;
task.CompleationDate = entity.CompleationDate;
task.DueDate = entity.DueDate;
task.PictureUrl = entity.PictureUrl;
if (entity.AssigneeId != null)
{
User assignee = await this._userManager.FindByIdAsync(entity.AssigneeId);
task.Assignee = assignee;
}
TaskCategory taskCategory = this._context.TaskCategories.Find(entity.TaskCategoryId);
task.TaskCategory = taskCategory;
Data.Models.TaskStatus taskStatus = this._context.TaskStatuses.Find(entity.TaskStatusId);
task.TaskStatus = taskStatus;
task.Issuer = user;
Location location = this._context.Locations.Find(entity.LocationId);
task.Location = location;
this._context.Update(task);
await this._context.SaveChangesAsync();
return(null);
}
public async Task <TaskServiceModel> GetByIdAsync(string id)
{
Data.Models.Task task = this._context.Tasks
.Include(x => x.Location)
.Include(x => x.Issuer)
.Include(x => x.Assignee)
.Include(x => x.TaskStatus)
.Include(x => x.TaskCategory)
.FirstOrDefault(x => x.Id == id);
TaskServiceModel serviceModel = this.MapToServiceModel(task);
return(serviceModel);
}
public async Task <Data.Models.Task> Update(int idProject, Data.Models.Task task, int idTask, string role)
{
try
{
var project = await _context.Projects
.Include(p => p.Tasks)
.SingleOrDefaultAsync(p => p.Id == idProject);
var tasks = project.Tasks.ToList();
var taskForUpdate = tasks.SingleOrDefault(t => t.Id == idTask);
if (taskForUpdate == null)
{
Debug.WriteLine("Wrong task for project!");
return(null);
}
if (task.Developer != null && taskForUpdate.Developer != task.Developer)
{
if (role == Roles.Developer)
{
Debug.WriteLine("Developer can't update this task!");
return(null);
}
if (DeveloperTasks(task.Developer) >= 3)
{
Debug.WriteLine("Developer already have 3 tasks!");
return(null);
}
}
UpdateTask(ref taskForUpdate, task, role);
project.Tasks = tasks;
_context.Set <Project>().Update(project);
await _context.SaveChangesAsync();
task.Id = idTask;
if (task.Developer != null)
{
task.Developer = task.Developer.WithoutPassword();
}
return(GetById(taskForUpdate.Id));
}
catch (Exception)
{
return(null);
}
}
public async Task <IActionResult> EditTaskAsync(TaskFormViewModel taskViewModel)
{
if (ModelState.IsValid)
{
var task = new Data.Models.Task
{
Id = taskViewModel.TaskId,
TeamId = taskViewModel.TeamId,
Name = taskViewModel.TaskName,
StoryPoints = taskViewModel.TaskStoryPoints,
Link = taskViewModel.TaskLink,
SprintId = taskViewModel.TaskSprintId,
MemberId = taskViewModel.TaskMemberId
};
var currentTask = await _manageTasksService.GetTaskByIdAsync(taskViewModel.TaskId);
if (currentTask.Name == taskViewModel.TaskName &&
currentTask.Link == taskViewModel.TaskLink &&
currentTask.StoryPoints == taskViewModel.TaskStoryPoints &&
currentTask.MemberId == taskViewModel.TaskMemberId
)
{
return(RedirectToAction("EditTask", new { teamId = taskViewModel.TeamId, taskId = taskViewModel.TaskId, errorMessage = _localizer["HasntAnyChange"] }));
}
var result = await EditTaskAsync(task);
if (result)
{
return(RedirectToAction("AllTasksForTeam", new { teamId = taskViewModel.TeamId }));
}
else
{
return(RedirectToAction("NotOwnerError", new { teamId = taskViewModel.TaskId }));
}
}
var teamMembers = await GetAllTeamMembersAsync(taskViewModel.TeamId);
taskViewModel.TeamMembers = new List <TeamMemberViewModel>();
teamMembers.ForEach(t => taskViewModel.TeamMembers.Add(new TeamMemberViewModel
{
Member = t.Member,
Id = t.Id
}));
return(View(taskViewModel));
}
public async System.Threading.Tasks.Task DeleteAsync_TaskRepositoryReturns_True()
{
//Arrange
Data.Models.Task task = new Data.Models.Task {
Id = 2, Name = "Task2", TeamId = 2, SprintId = 2, MemberId = 2, Link = "Link2", StoryPoints = 2
};
_context.Task.Add(task);
_context.SaveChanges();
//Act
var result = await _taskRepository.DeleteAsync(task);
//Assert
Assert.IsTrue(result);
}
public static TaskModel SerializeTask(Data.Models.Task task)
{
return(new TaskModel
{
Id = task.Id,
ProgramId = task.ProgramId,
OutlineId = task.OutlineId,
Name = task.Name,
Status = task.Status,
Deadline = task.Deadline,
AssignedTo = task.AssignedTo,
ProgressNote = task.ProgressNote,
ProblemNote = task.ProblemNote,
LastUpdate = task.LastUpdate
});
}
// Helper for update task
private void UpdateTask(ref Data.Models.Task taskForUpdate, Data.Models.Task task, string role)
{
if (role != Roles.Developer)
{
taskForUpdate.Progress = task.Progress;
taskForUpdate.Status = task.Status;
taskForUpdate.Description = task.Description;
taskForUpdate.Deadline = task.Deadline;
taskForUpdate.Developer = task.Developer;
}
else
{
taskForUpdate.Progress = task.Progress;
taskForUpdate.Status = task.Status;
taskForUpdate.Description = task.Description;
}
}
public async Task <IActionResult> AddTask([FromBody] Data.Models.Task task)
{
NewResponseModel newTaskResponseModel = new NewResponseModel();
try
{
await _db.AddTask(task);
newTaskResponseModel.Message = "Success !!!";
newTaskResponseModel.CreatedId = task.Id;
return(Ok(newTaskResponseModel));
}
catch (Exception ex)
{
newTaskResponseModel.Message = ex.Message;
return(BadRequest(newTaskResponseModel));
}
}
public ServiceResponse <Data.Models.Task> CreateTask(Data.Models.Task task)
{
try
{
_db.Tasks.Add(task);
_db.SaveChanges();
var temp = _db.Outlines.Find(task.OutlineId);
var tempProgram = _db.Programs.Find(task.ProgramId);
temp.TotalTask += 1;
tempProgram.TotalTask += 1;
_db.Outlines.Update(temp);
_db.SaveChanges();
_db.Programs.Update(tempProgram);
_db.SaveChanges();
_outlineService.SetProgressPercentage(task.OutlineId);
_programService.SetProgressPercentage(task.ProgramId);
return(new ServiceResponse <Data.Models.Task>
{
IsSuccess = true,
Message = "New Task Added",
Time = DateTime.UtcNow,
Data = task
});
}
catch (Exception e)
{
return(new ServiceResponse <Data.Models.Task>
{
IsSuccess = false,
Message = e.StackTrace,
Time = DateTime.UtcNow,
Data = null
});
}
}
