public async Task <IActionResult> PutTask(Guid id, UpdateTaskDTO task)
{
if (id != task.Id)
{
return(BadRequest());
}
try
{
await _taskService.UpdateAsync(id, task);
}
catch (DbUpdateConcurrencyException)
{
if (!_taskService.IsTaskExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Updates task from UpdateTaskDTO
/// </summary>
/// <param name="dto">Update model</param>
/// <param name="childrenAmount">Amount of children records</param>
public void UpdateFromDTO(UpdateTaskDTO dto, int childrenAmount)
{
if (Name != dto.Name)
{
Name = dto.Name;
}
if (Description != dto.Description)
{
Description = dto.Description;
}
if (StartDate != dto.StartDate)
{
StartDate = dto.StartDate;
}
if (FinishDate != dto.FinishDate)
{
FinishDate = dto.FinishDate;
}
if (ParentTaskId != dto.ParentTaskId)
{
ParentTaskId = dto.ParentTaskId;
}
if (StateId != dto.StateId && childrenAmount == 0)
{
StateId = dto.StateId;
}
}
public IActionResult Update(long id, UpdateTaskDTO item)
{
TaskItem updatedTask = _mapper.Map <TaskItem>(item);
var task = _context.TaskItems.Find(id);
if (task == null)
{
return(NotFound());
}
//If the task is in a final status, cannot be updated
if (task.Status.isFinalStatus())
{
return(BadRequest("La tarea se encuentra en un estado final, no puede ser modificada"));
}
/*if(task.Status == TaskStatus.Canceled && updatedTask.Status == TaskStatus.Done)
* {
* return BadRequest("No se puede actualizar una tarea cancelada a finalizada");
* }*/
task.Status = updatedTask.Status;
task.Name = updatedTask.Name;
_context.TaskItems.Update(task);
_context.SaveChanges();
return(NoContent());
}
/// <summary>
/// Updates task by id.
/// </summary>
/// <param name="id">Task id</param>
/// <param name="task">Update task model</param>
public async Task <TMSTask> UpdateAsync(Guid id, UpdateTaskDTO task)
{
var taskEntity = await _taskRep.FindAsync(id);
if (taskEntity != null)
{
await _taskRep.UpdateAsync(task, taskEntity);
await UpdateParentTaskState(task.ParentTaskId ?? Guid.Empty);
}
return(taskEntity);
}
public async Task <IActionResult> UpdateTask([FromBody] UpdateTaskDTO taskDTO)
{
if (taskDTO == null)
{
return(BadRequest());
}
var taskToUpdate = await _taskRepository.GetFirstAsync(r => r.Id == taskDTO.Id);
_mapper.Map(taskDTO, taskToUpdate);
try
{
await _taskRepository.UpdateAsync(taskToUpdate);
}
catch (Exception)
{
throw new Exception("Update of task failed");
}
return(NoContent());
}
public IActionResult Update(long id, UpdateTaskDTO item)
{
TaskItem updatedTask = _mapper.Map <TaskItem>(item);
var task = _context.TaskItems.Find(id);
if (task == null)
{
return(NotFound());
}
if (task.Status.isFinalStatus())
{
return(BadRequest("La tarea se encuentra en un estado final, no puede ser modificada"));
}
task.Status = updatedTask.Status;
task.Name = updatedTask.Name;
_context.TaskItems.Update(task);
_context.SaveChanges();
return(NoContent());
}
public Task <CommandResponse> Patch([FromBody] UpdateTaskDTO value)
{
return(commandProcessor.ProcessAsync <TaskCommandHandler, UpdateTaskCommand, CommandResponse>(new UpdateTaskCommand(value)));
}
/// <inheritdoc/>
public async Task UpdateAsync(UpdateTaskDTO dto, TMSTask taskEntity)
{
taskEntity.UpdateFromDTO(dto, await GetChildrenAmount(taskEntity.Id));
await _context.SaveChangesAsync();
}
public UpdateTaskCommand(UpdateTaskDTO updateTaskDTO)
{
this.UpdateTaskDTO = updateTaskDTO;
}
