public async Task <IActionResult> UpdateTask(string id, [FromBody] UpdateTaskDto updateTaskDto)
{
try
{
if (updateTaskDto == null)
{
_logger.LogError("Object sent from client is null.");
return(BadRequest("Object is null"));
}
if (!ModelState.IsValid)
{
_logger.LogError("Invalid object sent from client.");
return(BadRequest("Invalid model object"));
}
await _taskRepository.UpdateAsync(new TaskEntity
{
RowKey = id,
PartitionKey = updateTaskDto.ProjectId,
Name = updateTaskDto.Name,
Description = updateTaskDto.Description,
IsComplete = updateTaskDto.IsComplete,
ETag = "*"
});
return(Ok(updateTaskDto));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside Update action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
internal MyTask UpdateTask(int idl, int idt, UpdateTaskDto model)
{
MyTask oldTask = this.GetTask(idl, idt);
model.MyListId = idl;
model.MyTaskId = idt;
if (model.Title != null)
{
oldTask.Title = model.Title;
}
if (model.Description != null)
{
oldTask.Description = model.Description;
}
if (model.DoDate != null)
{
oldTask.DoDate = model.DoDate;
}
oldTask.Done = model.Done;
if (model.MyList != null)
{
oldTask.MyList = model.MyList;
}
db.MyTasks.Update(oldTask);
db.SaveChanges();
return(oldTask);
}
public async Task <TaskDto> UpdateAsync(UpdateTaskDto updateTaskDto)
{
var taskEntity = await _tripFlipDbContext
.Tasks
.Include(task => task.TaskList)
.SingleOrDefaultAsync(task => task.Id == updateTaskDto.Id);
EntityValidationHelper
.ValidateEntityNotNull(taskEntity, ErrorConstants.TaskNotFound);
// Validate current user has route 'Editor' role.
await EntityValidationHelper.ValidateCurrentUserRouteRoleAsync(
currentUserService : _currentUserService,
tripFlipDbContext : _tripFlipDbContext,
routeId : taskEntity.TaskList.RouteId,
routeRoleToValidate : RouteRoles.Editor,
errorMessage : ErrorConstants.NotRouteEditor);
taskEntity.Description = updateTaskDto.Description;
taskEntity.PriorityLevel = _mapper.Map <Domain.Entities.Enums.TaskPriorityLevel>(updateTaskDto.PriorityLevel);
taskEntity.IsCompleted = updateTaskDto.IsCompleted;
await _tripFlipDbContext.SaveChangesAsync();
var taskDto = _mapper.Map <TaskDto>(taskEntity);
return(taskDto);
}
public async Task UpdateAsync_ValidTaskToUpdate_Updates()
{
//Arrange
Tools.SetupCurrentUserService(_mocker);
var sut = CreateSut();
var update = new UpdateTaskDto(Guid.NewGuid(), "update", true, Guid.NewGuid(), null);
var transferServiceExtensions = Tools.SetupTransferServiceExtensions();
var task = new Mock <ITaskEntity>();
transferServiceExtensions.Setup(o => o.AsTaskDto(task.Object))
.Returns(Tools.DefaultTaskDto);
_mocker.GetMock <ITaskRepository>()
.Setup(o => o.GetAsync(update.Id, Tools.User.Id))
.ReturnsAsync(task.Object);
//Act
var result = await sut.UpdateAsync(update);
//Assert
result.ShouldNotBeNull();
transferServiceExtensions.Verify(o => o.AsTaskDto(task.Object));
task.Verify(o => o.Update(update.Name, update.IsComplete, update.GroupId, update.Deadline));
_mocker.GetMock <ITaskRepository>()
.Verify(o => o.UpdateAsync(task.Object));
}
public async Task <IActionResult> Put(UpdateTaskDto taskDto)
{
var taskEntity = SimpleMapper.Map <UpdateTaskDto, TaskEntity>(taskDto);
await _taskService.UpdateAsync(taskEntity);
return(Ok());
}
public bool UpdateTask(UpdateTaskDto task) //Fix
{
var taskObj = GetTask(task.Id);
taskObj.Description = task.Description;
taskObj.End = task.End;
_db.Task.Update(taskObj);
return(Save());
}
public IActionResult Update(int id)
{
TempData["menu"] = "task";
UpdateTaskDto updateTaskDto = _mapper.Map <UpdateTaskDto>(_taskService.GetById(id));
ViewBag.UrgentList = new SelectList(_urgentService.GetAll(), "Id", "Definition", updateTaskDto.UrgentId);
return(View(updateTaskDto));
}
public IActionResult Update([FromBody] UpdateTaskDto taskDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
_toDoTaskServices.Update(taskDto);
return(Ok());
}
//Update Model service, call through the Jquerry.js
public void Update(UpdateTaskDto input)
{
Task update = _taskRepo.FirstOrDefault(i => i.Id == input.Id);
update.Name = input.Name;
update.Description = input.Description;
_taskRepo.UpdateAsync(update);
//ObjectMapper.Map<UpdateTaskDto>(update);
}
public Task UpdateTask(Guid id, UpdateTaskDto taskDto)
{
var task = _unitOfWork.Repository <Task>().Find(id);
task.Title = taskDto.Title;
task.Description = taskDto.Description;
_unitOfWork.Repository <Task>().Update(task);
_unitOfWork.Complete();
return(task);
}
public ActionResult <MyTask> PatchMyTask(int idList, int idTask, UpdateTaskDto model)
{
// TODO: Your code her
if (service.IsContainsListId(idList) && service.IsContainsTaskId(idTask))
{
return(Ok(service.UpdateTask(idList, idTask, model)));
}
else
{
return(NotFound());
}
}
public void Update(UpdateTaskDto updateTaskDto)
{
ToDoTask task = new ToDoTask()
{
Id = updateTaskDto.Id,
Description = updateTaskDto.Description,
DueDate = updateTaskDto.DueDate,
IsCompleted = updateTaskDto.IsCompleted,
Name = updateTaskDto.Name
};
_repository.Update(task);
}
public async Task <TaskDto> UpdateAsync(UpdateTaskDto dto)
{
var userId = _currentUserService.GetCurrentUser().Id;
var task = await _taskRepository.GetAsync(dto.Id, userId);
if (task is null)
{
throw new TaskIdInvalidException();
}
task.Update(dto.Name, dto.IsComplete, dto.GroupId, dto.Deadline);
await _taskRepository.UpdateAsync(task);
return(task.AsTaskDto());
}
public IActionResult Update(UpdateTaskDto model)
{
if (ModelState.IsValid)
{
var task = _taskService.GetById(model.Id);
task.Name = model.Name;
task.Description = model.Description;
task.State = false;
task.UrgentId = model.UrgentId;
_taskService.Update(task);
return(RedirectToAction("Index"));
}
ViewBag.UrgentList = new SelectList(_urgentService.GetAll(), "Id", "Definition", model.UrgentId);
return(View(model));
}
public void UpdateSprintTask(UpdateTaskDto updateTaskDto)
{
try
{
var task = Db.SprintTasks.Where(x => x.Id == updateTaskDto.Id).SingleOrDefault();
task.Title = updateTaskDto.Title;
task.Description = updateTaskDto.Description;
task.DeveloperId = updateTaskDto.DeveloperId;
Db.SaveChanges();
var developers = Db.Developers.Where(x => x.Id == updateTaskDto.DeveloperId).SingleOrDefault();
mail.SendMail(
developers.Email,
developers.FirstName,
"Task has been Created <br/>" +
"Title : " + updateTaskDto.Title + "<br/>" +
"Description : " + updateTaskDto.Description + "<br/>" +
"Best luck PMS bot"
);
}
catch (Exception)
{
throw;
}
}
public BaseResponse <TaskDto> Update([FromBody] UpdateTaskDto taskDto, Guid id)
{
var res = _taskService.UpdateTask(id, taskDto);
return(new SuccessResponse <TaskDto>(_mapper.Map <TaskDto>(res)));
}
public IActionResult EditTask(UpdateTaskDto updateTaskDto)
{
teamLeaderRepository.UpdateSprintTask(updateTaskDto);
return(RedirectToAction("ShowSprints", new RouteValueDictionary(
new { controller = "TeamLeader", action = "ShowTasks", Id = updateTaskDto.SprintId })));
}
public async Task <IActionResult> Update([FromBody] UpdateTaskDto dto)
{
var task = await _taskService.UpdateAsync(dto);
return(Ok(task));
}
public async System.Threading.Tasks.Task <ReadTaskDto> UpdateAsync(int id, string userId, UpdateTaskDto model)
{
var task = await _unitOfWork.TaskRepostitory.FindByCondition(t => t.Id == id, true)
.Include(t => t.Developer)
.Include(t => t.Project)
.ThenInclude(p => p.Manager)
.FirstAsync();
if (task == null)
{
throw new TaskException($"Can't find task with id = {id}", HttpStatusCode.NotFound);
}
if (task.Project.ManagerId != userId)
{
throw new TaskException($"Don't have permission to edit this task.", HttpStatusCode.Forbidden);
}
var developer = await _userManager.FindByEmailAsync(model.DeveloperEmail);
if (developer == null)
{
throw new TaskException($"Developer with email {model.DeveloperEmail} not found!", HttpStatusCode.NotFound);
}
task.Title = model.Title;
task.Description = model.Description;
task.IssueDate = model.IssueDate;
task.DeadLine = model.DeadLine;
task.DeveloperId = developer.Id;
task.StatusId = model.StatusId;
await _unitOfWork.SaveAsync();
var updatedTask = await _unitOfWork.TaskRepostitory.GetTaskByIdWithDetailsAsync(id, false);
_logger.LogInfo($"Deleted task with id = {updatedTask.Id}.");
return(_mapper.Map <ReadTaskDto>(updatedTask));
}
public Task <RequestResult <TaskModel> > UpdateTaskAsync(UpdateTaskDto dto)
{
return(_webClient.ExecuteRequestAsync(webApi => webApi.UpdateTask(dto)));
}
