public async Task <IActionResult> DeleteTaskCompletionByTaskId(Guid taskId)
{
User loggedOnUser = await _identityBusiness.GetUserAsync(User);
Task completedTask = await _taskBookBusiness.GetUsersTaskCompletionByUserAndTaskId(loggedOnUser.Id, taskId);
if (completedTask?.DateTimeCompleted == null || completedTask.AssignedToUserId == null)
{
return(NotFound());
}
if (completedTask.AssignedToUserId != loggedOnUser.Id)
{
return(Forbid());
}
bool deleted = await _taskBookBusiness.DeleteTaskCompletion(taskId);
if (!deleted)
{
return(NotFound());
}
return(NoContent());
}
public async Task <ActionResult> DeleteTask(Guid groupId, Guid taskId)
{
User loggedOnUser = await _identityBusiness.GetUserAsync(User);
bool isUserRelatedWithGroup = await _taskBookBusiness.IsUserRelatedWithGroup(loggedOnUser.Id, groupId);
if (!isUserRelatedWithGroup)
{
return(NotFound());
}
Task task = await _taskBookBusiness.GetTaskByTaskId(taskId);
if (task == null)
{
return(NotFound());
}
bool isUserTaskCreator = await _taskBookBusiness.IsUserTaskCreator(loggedOnUser.Id, taskId);
if (!isUserTaskCreator)
{
return(Forbid());
}
bool deleted = await _taskBookBusiness.DeleteTask(taskId);
if (!deleted)
{
return(NotFound());
}
return(NoContent());
}
public async Task <ActionResult> UpdateTask(Guid groupId, Guid taskId, [FromBody] UpdateGroupTaskParameters parameters)
{
if (parameters == null)
{
return(BadRequest());
}
User loggedOnUser = await _identityBusiness.GetUserAsync(User);
bool isUserRelatedWithGroup = await _taskBookBusiness.IsUserRelatedWithGroup(loggedOnUser.Id, groupId);
if (!isUserRelatedWithGroup)
{
return(NotFound());
}
bool isUserTaskCreator = await _taskBookBusiness.IsUserTaskCreator(loggedOnUser.Id, taskId);
if (!isUserTaskCreator)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState));
}
if (!parameters.Deadline.HasValue)
{
ModelState.AddModelError(nameof(parameters.Deadline), "Please provide a deadline date.");
return(UnprocessableEntity(ModelState));
}
DateTime serverDateTime = await _taskBookBusiness.GetServerDateTime();
if (parameters.Deadline < serverDateTime)
{
ModelState.AddModelError(nameof(parameters.Deadline), "Deadline cannot be in the past.");
return(UnprocessableEntity(ModelState));
}
Task updatedTask = await _taskBookBusiness.UpdateGroupTask(
taskId,
parameters.Title,
parameters.Description,
parameters.Deadline.Value);
if (updatedTask == null)
{
return(NotFound());
}
var model = _mapper.Map <TaskViewModel>(updatedTask);
return(Ok(model));
}
public async Task <IActionResult> GetUserTaskCompletionByTaskId(Guid taskId)
{
User loggedOnUser = await _identityBusiness.GetUserAsync(User);
Task completedTask = await _taskBookBusiness.GetUsersTaskCompletionByUserAndTaskId(loggedOnUser.Id, taskId);
if (completedTask == null)
{
return(NotFound());
}
var model = _mapper.Map <TaskViewModel>(completedTask);
return(Ok(model));
}
public async Task <IActionResult> CreateTaskAssignment(Guid?taskId)
{
if (!taskId.HasValue)
{
return(BadRequest());
}
User loggedOnUser = await _identityBusiness.GetUserAsync(User);
Task userTask = await _taskBookBusiness.GetUsersTaskByUserAndTaskId(loggedOnUser.Id, taskId.Value);
if (userTask == null)
{
return(NotFound());
}
if (userTask.AssignedToUserId.HasValue)
{
if (userTask.AssignedToUserId != loggedOnUser.Id)
{
return(Conflict("Task has already been assigned to a different assignee."));
}
if (userTask.DateTimeCompleted.HasValue)
{
return(Conflict("Cannot create task assignment for a completed task."));
}
Task existing = await _taskBookBusiness.GetUsersTaskAssignmentByUserAndTaskId(loggedOnUser.Id, taskId.Value);
var existingModel = _mapper.Map <TaskViewModel>(existing);
return(Ok(existingModel));
}
Task assignedTask = await _taskBookBusiness.CreateTaskAssignmen(loggedOnUser.Id, taskId.Value);
var model = _mapper.Map <TaskViewModel>(assignedTask);
return(CreatedAtRoute(nameof(GetUserTaskAssignmentByTaskId), new { TaskId = assignedTask.Id }, model));
}
public async Task <IActionResult> CreateTaskCompletion(Guid?taskId)
{
if (!taskId.HasValue)
{
return(BadRequest());
}
User loggedOnUser = await _identityBusiness.GetUserAsync(User);
Task userTask = await _taskBookBusiness.GetUsersTaskByUserAndTaskId(loggedOnUser.Id, taskId.Value);
if (userTask == null)
{
return(NotFound());
}
if (!userTask.AssignedToUserId.HasValue)
{
return(Conflict("There should be a task assignment before task completion."));
}
if (userTask.AssignedToUserId != loggedOnUser.Id)
{
return(Conflict("Assignment to another assignee exists."));
}
if (userTask.DateTimeCompleted.HasValue)
{
Task existing = await _taskBookBusiness.GetUsersTaskCompletionByUserAndTaskId(loggedOnUser.Id, taskId.Value);
var existingModel = _mapper.Map <TaskViewModel>(existing);
return(Ok(existingModel));
}
Task completedTask = await _taskBookBusiness.CreateTaskCompletion(loggedOnUser.Id, taskId.Value);
var model = _mapper.Map <TaskViewModel>(completedTask);
return(CreatedAtRoute(nameof(GetUserTaskCompletionByTaskId), new { TaskId = completedTask.Id }, model));
}
public async Task <IActionResult> GetTaskByTaskId(Guid groupId, Guid taskId)
{
User loggedOnUser = await _identityBusiness.GetUserAsync(User);
bool isUserRelatedWithGroup = await _taskBookBusiness.IsUserRelatedWithGroup(loggedOnUser.Id, groupId);
if (!isUserRelatedWithGroup)
{
return(NotFound());
}
Task task = await _taskBookBusiness.GetTaskByTaskId(taskId);
if (task == null)
{
return(NotFound());
}
var models = _mapper.Map <TaskViewModel>(task);
return(Ok(models));
}
