public async Task <bool> UpdateTaskByIdAsync(int id, TaskUpdateDto taskUpdateDto)
{
var task = _mapper.Map <Models.Task>(taskUpdateDto);
return(await _repo.UpdateTaskByIdAsync(id, task));
}
public ActionResult PatchTask(long id, JsonPatchDocument <TaskUpdateDto> jsonPatchDocument)
{
_logger.LogInformation("Consultando a tarefa de Id: {id}", id);
Models.Task task = _tasksRepo.GetTaskById(id);
if (task == null)
{
_logger.LogWarning("A tarefa de Id: {id} não existe", id);
return(NotFound());
}
_logger.LogInformation("Aplicando a alteração na classe de DTO");
TaskUpdateDto taskUpdateDto = _mapper.Map <TaskUpdateDto>(task);
jsonPatchDocument.ApplyTo(taskUpdateDto, ModelState);
_logger.LogInformation("Validando a alteração feita na classe de DTO");
if (!TryValidateModel(taskUpdateDto))
{
return(ValidationProblem(ModelState));
}
_logger.LogInformation("Alterando a tarefa de Id: {id}", id);
_mapper.Map(taskUpdateDto, task);
_tasksRepo.SaveChanges();
return(NoContent());
}
public TaskDto Change(TaskUpdateDto task)
{
var entity = mapper.Map <TaskBase>(task);
taskManager.Change(entity);
return(mapper.Map <TaskDto>(entity));
}
public IActionResult UpdateTask(int id, [FromBody] JsonPatchDocument <TaskUpdateDto> patchDoc)
{
var taskData = TasksDataStore.Current.Tasks.FirstOrDefault(x => x.Id.Equals(id));
if (taskData == null)
{
return(NotFound());
}
var taskToPatch = new TaskUpdateDto();
patchDoc.ApplyTo(taskToPatch);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
foreach (var property in taskToPatch.GetType().GetProperties())
{
if (property.GetValue(taskToPatch) != null)
{
taskData.GetType().GetProperty(property.Name).SetValue(taskData, property.GetValue(taskToPatch));
}
}
if (!TryValidateModel(taskToPatch))
{
return(BadRequest(ModelState));
}
return(NoContent());
}
public async Task <IActionResult> UpdateTasksIndex(TaskUpdateDto taskUpdateDto)
{
var userId = await _userManager.FindByNameAsync(User.Identity.Name);
taskUpdateDto.AppUserId = userId.Id;
await _tasksManager.UpdateTasksPost(taskUpdateDto);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> UpdateTaskAsync(int id, [FromBody] TaskUpdateDto taskUpdateDto)
{
var result = await _service.UpdateTaskByIdAsync(id, taskUpdateDto);
if (!result)
{
return(BadRequest("Update failed!"));
}
return(NoContent());
}
public void PutTask_ExistingIdPassed_ReturnsNoContent()
{
_mockTasksRepo.Setup(r => r.GetTaskById(It.IsAny <long>())).Returns(new Task());
TaskUpdateDto taskUpdateDto = new TaskUpdateDto()
{
Title = "Fazer teste técnico"
};
var noContentResult = _controller.PutTask(5, taskUpdateDto);
Assert.IsType <NoContentResult>(noContentResult);
}
public void PutTask_UnknownIdPassed_ReturnsNotFound()
{
_mockTasksRepo.Setup(r => r.GetTaskById(It.IsAny <long>())).Returns((Task)null);
TaskUpdateDto taskUpdateDto = new TaskUpdateDto()
{
Title = "Fazer teste técnico"
};
var notFoundResult = _controller.PutTask(5, taskUpdateDto);
Assert.IsType <NotFoundResult>(notFoundResult);
}
public ActionResult UpdateTask(int id, TaskUpdateDto taskUpdate)
{
var task = _repository.GetTaskById(id);
if (task == null)
{
return(NotFound());
}
_mapper.Map(taskUpdate, task);
_repository.UpdateTask(task);
_repository.SaveChanges();
return(NoContent());
}
public IActionResult UpdateTask(int id, [FromBody] TaskUpdateDto task)
{
var taskToUpdate = TasksDataStore.Current.Tasks.FirstOrDefault(x => x.Id.Equals(id));
if (taskToUpdate == null)
{
return(NotFound());
}
foreach (var property in task.GetType().GetProperties())
{
taskToUpdate.GetType().GetProperty(property.Name).SetValue(taskToUpdate, property.GetValue(task));
}
return(NoContent());
}
public IActionResult UpdateTask(TaskUpdateDto model)
{
if (ModelState.IsValid)
{
_taskService.Update(new Task()
{
Id = model.Id,
Description = model.Description,
Name = model.Name,
PriorityId = model.PriorityId
});
return(RedirectToAction("Index"));
}
ViewBag.PriorityList = new SelectList(_priorityService.GetAll(), "Id", "Definition", model.PriorityId);
return(View(model));
}
public ActionResult PutTask(long id, TaskUpdateDto taskUpdateDto)
{
_logger.LogInformation("Consultando a tarefa de Id: {id}", id);
Models.Task task = _tasksRepo.GetTaskById(id);
if (task == null)
{
_logger.LogWarning("A tarefa de Id: {id} não existe", id);
return(NotFound());
}
_logger.LogInformation("Editando a tarefa de Id: {id}", id);
_mapper.Map(taskUpdateDto, task);
_tasksRepo.SaveChanges();
if (task.TaskTags != null && task.TaskTags.Count > 0)
{
_logger.LogInformation("Deletando as tags atuais da tarefa de Id: {id}", id);
_taskTagsRepo.DeleteTaskTags(task.TaskTags);
_taskTagsRepo.SaveChanges();
}
if (taskUpdateDto.Tags != null && taskUpdateDto.Tags.Count > 0)
{
Tag tag;
TaskTag taskTag = new TaskTag()
{
TaskId = task.Id
};
_logger.LogInformation("Cadastrando as novas tags da tarefa de Id: {id}", id);
foreach (TagUpdateDto tagUpdateDto in taskUpdateDto.Tags)
{
tag = _mapper.Map <Tag>(tagUpdateDto);
_tagsRepo.PostTag(tag);
_tagsRepo.SaveChanges();
taskTag.TagId = tag.Id;
_taskTagsRepo.PostTaskTag(taskTag);
_taskTagsRepo.SaveChanges();
}
}
return(NoContent());
}
public IActionResult UpdateTask(long id, [FromBody] TaskUpdateDto updateDto)
{
var existingTask = _taskRepository.GetSingle(id);
if (existingTask == null)
{
return(NotFound());
}
Mapper.Map(updateDto, existingTask);
_taskRepository.Update(existingTask);
bool result = _taskRepository.Save();
if (!result)
{
return(new StatusCodeResult(500));
}
return(Ok(Mapper.Map <TaskDto>(existingTask)));
}
public async Task <TaskUpdateDto> UpdateTasksPost(TaskUpdateDto taskUpdateDto)
{
//var veri = await _generictaskdate.GetAllAsync();
var gunluk = _taskDateDal.GetGunluk();
var haftalik = _taskDateDal.GetHaftalık();
var aylik = _taskDateDal.GetAylik();
if (taskUpdateDto.TaskDate == gunluk)
{
taskUpdateDto.StartDate = DateTime.Now;
taskUpdateDto.FinishDate = DateTime.Now.AddDays(1);
}
else if (taskUpdateDto.TaskDate == haftalik)
{
taskUpdateDto.StartDate = DateTime.Now;
taskUpdateDto.FinishDate = DateTime.Now.AddDays(7);
}
else if (taskUpdateDto.TaskDate == aylik)
{
taskUpdateDto.StartDate = DateTime.Now;
taskUpdateDto.FinishDate = DateTime.Now.AddDays(30);
}
taskUpdateDto.Status = "Active";
//await _genericDal.UpdateAsync(_mapper.Map<Tasks>(taskUpdateDto));
return(null);
}
public async Task <IActionResult> UpdateTaskForUser(string idUser, string idTask, [FromBody] TaskUpdateDto taskUpdateDto)
{
if (null == taskUpdateDto)
{
return(BadRequest());
}
if (taskUpdateDto.Name == taskUpdateDto.Description)
{
ModelState.AddModelError(nameof(TaskUpdateDto), "Task Name and Description should not match");
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
var userId = ObjectId.Parse(idUser);
if (!await _appRepository.UserExistsAsync(userId))
{
return(NotFound());
}
var taskId = ObjectId.Parse(idTask);
var taskToUpdate = await _appRepository.GetTaskAsync(userId, taskId);
if (null == taskToUpdate)
{
return(NotFound()); // won't allow Upserting
}
Mapper.Map(taskUpdateDto, taskToUpdate);
var result = await _appRepository.UpdateTaskAsync(userId, taskId, taskToUpdate);
if (!result)
{
throw new Exception($"Failed to update task: {idTask}, for author: {idUser}");
}
return(NoContent());
}