public virtual async Task <ResultModel> UpdateTaskAsync(UpdateTaskViewModel task)
{
var dbTaskResult = _context.Tasks
.Include(x => x.AssignedUsers)
.FirstOrDefault(x => (x.Id == task.Id) & (x.IsDeleted == false));
if (dbTaskResult == null)
{
return(ExceptionMessagesEnum.TaskNotFound.ToErrorModel());
}
var taskModel = TaskMapper(task, dbTaskResult);
_context.Tasks.Update(taskModel);
var result = await _context.PushAsync();
if (result.IsSuccess)
{
await AddOrUpdateUsersToTaskGroupAsync(dbTaskResult, task.UserTeam);
await _notify.UpdateTaskNotificationAsync(taskModel);
}
return(new ResultModel
{
IsSuccess = result.IsSuccess,
Errors = result.Errors
});
}
public async Task <IActionResult> UpdateTask([FromBody] UpdateTaskViewModel createTask)
{
string token = Request.Headers["Authorization"];
var userID = JWTExtensions.GetDecodeTokenByProperty(token, "nameid").ToInt();
createTask.CurrentUser = userID;
return(Ok(await _taskService.UpdateTask(createTask)));
}
public async Task <IActionResult> UpdateAsync([FromBody] UpdateTaskViewModel updateTaskViewModel)
{
var updateTaskDto = _mapper.Map <UpdateTaskDto>(updateTaskViewModel);
var updatedTaskDto = await _taskService.UpdateAsync(updateTaskDto);
var updatedTaskViewModel = _mapper.Map <UpdateTaskViewModel>(updatedTaskDto);
return(Ok(updatedTaskViewModel));
}
public IHttpActionResult UpdateTask(int ticketId, int id, UpdateTaskViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_ticketsService.UpdateTask(ticketId, id, model);
return(Ok());
}
public IActionResult Update(UpdateTaskViewModel item)
{
var taskToUpdate = _tasks.FirstOrDefault(t => t.Id == item.Id);
if (taskToUpdate != null)
{
taskToUpdate.Description = item.Description;
return(Ok());
}
return(NotFound());
}
public async Task <IActionResult> Update([FromForm] UpdateTaskViewModel model)
{
if (ModelState.IsValid)
{
TempData["ModelState"] = null;
var command = this.unitOfWork.Create <UpdateTaskCommand>();
var result = await command.ExecuteAsync(model);
}
return(Redirect($"/Tasks/Details/{model.Id}"));
}
public async Task <JsonResult> UpdateTask(UpdateTaskViewModel model)
{
if (!ModelState.IsValid)
{
return(JsonModelStateErrors());
}
var response = await _taskManager.UpdateTaskAsync(model);
return(Json(response));
}
public IActionResult Put(int id, [FromBody] UpdateTaskViewModel vm)
{
return(ApiAction(() =>
{
var contract = _mapper.Map <UpdateTaskContract>(vm);
contract.Id = id;
contract.IsNew = false; //Damos por sentado que ya no es nueva para que desaparezca el icono. El usuario la editó
_taskService.Update(contract);
return Accepted(new { id });
}));
}
public void CreateTaskTest()
{
var client = new TestServer(WebHost
.CreateDefaultBuilder()
.UseContentRoot(ProjectUtil.GetProjectPath("TaskManager.sln", "", typeof(Startup).Assembly))
.UseStartup <Startup>())
.CreateClient();
var model = new UpdateTaskViewModel {
Description = "test001", Status = TaskStatus.NotDone, Tag = "test", Type = "test"
};
var result = client.PostAsJsonAsync("Task/Create", new { taskModel = model, userId = 1, userName = "******" }).Result;
Assert.NotNull(result);
}
/// <summary>
/// Creates UpdateTaskViewModel object with given Id,
/// Description, Priority level and Completeness.
/// </summary>
/// <param name="id">Task id.</param>
/// <param name="description">Task description.</param>
/// <param name="priorityLevel">Task priority level.</param>
/// <param name="isCompleted">Task completeness</param>
/// <returns>Created UpdateTaskViewModel object.</returns>
protected static UpdateTaskViewModel BuildUpdateTaskViewModel(int id = 3,
string description = "Default",
int priorityLevel = (int)TaskPriorityLevel.Low,
bool isCompleted = false)
{
var updateTaskViewModel = new UpdateTaskViewModel()
{
Id = id,
Description = description,
PriorityLevel = (TaskPriorityLevel)priorityLevel,
IsCompleted = isCompleted
};
return(updateTaskViewModel);
}
public IActionResult Create(UpdateTaskViewModel taskModel, int userId, string userName)
{
if (ModelState.IsValid)
{
_taskRepository.AddOrUpate(new TaskModel()
{
CreateTime = DateTime.Now,
Description = taskModel.Description,
Owner = userId,
Status = taskModel.Status,
Tag = taskModel.Tag,
Type = taskModel.Type
});
return(RedirectToAction(nameof(Index), new { userId, userName }));
}
return(View(taskModel));
}
public IActionResult Edit(int userId, string userName, int id, [Bind("Id,Description,Owner,Status,Tag,Type,CreateTime")] UpdateTaskViewModel taskModel)
{
if (id != taskModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var task = _taskRepository.FindOne(taskModel.Id);
task.Description = taskModel.Description;
task.Status = taskModel.Status;
task.Tag = taskModel.Tag;
task.Type = taskModel.Type;
_taskRepository.AddOrUpate(task);
return(RedirectToAction(nameof(Index), new { userId, userName }));
}
return(View(taskModel));
}
public async Task <IActionResult> Update(UpdateTaskViewModel model)
{
if (ModelState.IsValid)
{
var taskObj = mapper.Map <TaskObject>(model);
try
{
await repository.Update(taskObj);
logger.LogInformation($"Task with ID \"{taskObj.Id}\" updated.");
}
catch (TaskRepositoryException ex)
{
ModelState.AddModelError(ex.Key, ex.Message);
return(PartialView(model));
}
return(RedirectToAction(nameof(Details), new { id = taskObj.Id, updateTree = true }));
}
return(PartialView(model));
}
public virtual async Task <ResultModel> UpdateTaskAsync(UpdateTaskViewModel task)
{
var dbTaskResult = _context.Tasks
.Include(x => x.AssignedUsers)
.FirstOrDefault(x => (x.Id == task.Id) & (x.IsDeleted == false));
if (dbTaskResult == null)
{
return(ExceptionMessagesEnum.TaskNotFound.ToErrorModel());
}
var lastStatus = dbTaskResult.Status;
var lastPriority = dbTaskResult.TaskPriority;
var taskModel = TaskMapper(task, dbTaskResult);
_context.Tasks.Update(taskModel);
var result = await _context.PushAsync();
if (!result.IsSuccess)
{
return(result);
}
await AddOrUpdateUsersToTaskGroupAsync(dbTaskResult, task.UserTeam);
if (task.Status != lastStatus)
{
await _notify.ChangeStatusTaskNotificationAsync(taskModel, lastStatus);
}
else if (task.TaskPriority != lastPriority)
{
await _notify.ChangePriorityTaskNotificationAsync(taskModel, lastPriority);
}
else
{
await _notify.UpdateTaskNotificationAsync(taskModel);
}
return(result);
}
internal static Task TaskMapper(UpdateTaskViewModel taskViewModel, Task dbTaskResult)
{
if (dbTaskResult == null)
{
return(null);
}
dbTaskResult.Name = taskViewModel.Name;
dbTaskResult.Description = taskViewModel.Description;
dbTaskResult.StartDate = taskViewModel.StartDate;
dbTaskResult.EndDate = taskViewModel.EndDate;
dbTaskResult.Status = taskViewModel.Status;
dbTaskResult.TaskPriority = taskViewModel.TaskPriority;
dbTaskResult.UserId = taskViewModel.UserId;
if (!string.IsNullOrWhiteSpace(dbTaskResult.Files))
{
dbTaskResult.Files = JsonConvert.SerializeObject(taskViewModel.Files);
}
return(dbTaskResult);
}
public async Task <IActionResult> Update([FromBody] UpdateTaskViewModel updateTaskViewModel)
{
var task = dMContext.Tasks
.Include(t => t.TaskGroup)
.ThenInclude(tg => tg.Group)
.SingleOrDefault(t => t.Id == updateTaskViewModel.TaskId);
if (task == null)
{
return(NotFoundJson());
}
if (!VerifyIsGroupAdministrator(task.TaskGroup.Group.Id))
{
return(UnauthorizedJson());
}
task.Bounty = updateTaskViewModel.Bounty;
task.Name = updateTaskViewModel.Name;
await dMContext.SaveChangesAsync();
return(SucceededJson());
}
public IActionResult Edit(int userId, string userName, int?id)
{
if (id == null)
{
return(NotFound());
}
ViewData["UserName"] = userName;
ViewData["UserId"] = userId;
var task = _taskRepository.FindOne((int)id);
UpdateTaskViewModel taskModel = new UpdateTaskViewModel()
{
Id = task.Id,
Description = task.Description,
Status = task.Status,
Tag = task.Tag,
Type = task.Type
};
if (taskModel == null)
{
return(NotFound());
}
return(View(taskModel));
}
public UpdateTaskCommand(UpdateTaskViewModel upVM, ITaskDataService taskDataService)
{
_upVM = upVM;
_taskDataService = taskDataService;
}
public void UpdateTask(int ticketId, int id, UpdateTaskViewModel model)
{
var command = new UpdateTaskCommand(model.Title, model.Description, model.Status, model.AssignedTo, ticketId, id);
_bus.Send(command);
}
public async Task <IActionResult> Update(UpdateTaskViewModel item)
{
await service.UpdateTask(item.Id.ToString(), item.Description);
return(Ok());
}
