public async Task Tasks_UpdateTaskPriority_ShouldOk()
{
var newPriority = 10;
var result = await _taskService.GetAllAsync(CancellationToken.None);
Assert.NotNull(result);
Assert.IsNotEmpty(result);
Assert.AreEqual(result.Count, 1);
var task = result.FirstOrDefault();
Assert.NotNull(task);
Assert.AreNotEqual(newPriority, task.Priority);
var saveTask = new SaveTaskRequest();
var updated = _mapper.Map(task, saveTask);
updated.Priority = newPriority;
await _taskService.UpdateAsync(updated, CancellationToken.None);
var resultUpdated = await _taskService.GetAllAsync(CancellationToken.None);
Assert.NotNull(resultUpdated);
Assert.IsNotEmpty(resultUpdated);
Assert.AreEqual(resultUpdated.Count, 1);
var resultUpdatedTask = resultUpdated.FirstOrDefault();
Assert.IsNotNull(resultUpdatedTask);
Assert.AreEqual(resultUpdatedTask.Priority, newPriority);
}
public async Task Tasks_UnassignTaskFromProjectById_ShouldOk()
{
int?newIdProject = null;
var result = await _taskService.GetAllAsync(CancellationToken.None);
Assert.NotNull(result);
Assert.IsNotEmpty(result);
Assert.AreEqual(result.Count, 1);
var assigned = result.FirstOrDefault();
Assert.AreEqual(_assignedProject, assigned.Id_Project);
var saveTask = new SaveTaskRequest();
var updated = _mapper.Map(assigned, saveTask);
updated.Id_Project = newIdProject;
await _taskService.UpdateAsync(updated, CancellationToken.None);
var resultUnassigned = await _taskService.GetAllAsync(CancellationToken.None);
Assert.NotNull(result);
Assert.IsNotEmpty(result);
Assert.AreEqual(resultUnassigned.Count, 1);
var unassignedProjectId = resultUnassigned.FirstOrDefault().Id_Project;
Assert.Null(unassignedProjectId);
}
public async Task Tasks_UpdateTaskStatus_ShouldOk()
{
var newStatus = Context.Models.TaskStatus.InProgress;
var result = await _taskService.GetAllAsync(CancellationToken.None);
Assert.NotNull(result);
Assert.IsNotEmpty(result);
Assert.AreEqual(result.Count, 1);
var task = result.FirstOrDefault();
Assert.NotNull(task);
Assert.AreNotEqual(newStatus.ToString(), task.Status.ToString());
var saveTask = new SaveTaskRequest();
var updated = _mapper.Map(task, saveTask);
updated.Status = newStatus;
await _taskService.UpdateAsync(updated, CancellationToken.None);
var resultUpdated = await _taskService.GetAllAsync(CancellationToken.None);
Assert.NotNull(resultUpdated);
Assert.IsNotEmpty(resultUpdated);
Assert.AreEqual(resultUpdated.Count, 1);
var resultUpdatedTask = resultUpdated.FirstOrDefault();
Assert.IsNotNull(resultUpdatedTask);
Assert.AreEqual(resultUpdatedTask.Status.ToString(), newStatus.ToString());
}
public async Task Tasks_UpdateTaskDescription_ShouldOk()
{
var newDesc = "You have to create middleware to catch all your exception in business logic layer";
var result = await _taskService.GetAllAsync(CancellationToken.None);
Assert.NotNull(result);
Assert.IsNotEmpty(result);
Assert.AreEqual(result.Count, 1);
var task = result.FirstOrDefault();
Assert.NotNull(task);
Assert.AreNotEqual(newDesc, task.Description);
var saveTask = new SaveTaskRequest();
var updated = _mapper.Map(task, saveTask);
updated.Description = newDesc;
await _taskService.UpdateAsync(updated, CancellationToken.None);
var resultUpdated = await _taskService.GetAllAsync(CancellationToken.None);
Assert.NotNull(resultUpdated);
Assert.IsNotEmpty(resultUpdated);
Assert.AreEqual(resultUpdated.Count, 1);
var resultUpdatedTask = resultUpdated.FirstOrDefault();
Assert.IsNotNull(resultUpdatedTask);
Assert.AreEqual(resultUpdatedTask.Description, newDesc);
}
public async Task Tasks_UpdateTaskName_ShouldOk()
{
var newName = "Create middleware";
var result = await _taskService.GetAllAsync(CancellationToken.None);
Assert.NotNull(result);
Assert.IsNotEmpty(result);
Assert.AreEqual(result.Count, 1);
var task = result.FirstOrDefault();
Assert.NotNull(task);
Assert.AreNotEqual(newName, task.Name);
var saveTask = new SaveTaskRequest();
var updated = _mapper.Map(task, saveTask);
updated.Name = newName;
await _taskService.UpdateAsync(updated, CancellationToken.None);
var resultUpdated = await _taskService.GetAllAsync(CancellationToken.None);
Assert.NotNull(resultUpdated);
Assert.IsNotEmpty(resultUpdated);
Assert.AreEqual(resultUpdated.Count, 1);
var resultUpdatedTask = resultUpdated.FirstOrDefault();
Assert.IsNotNull(resultUpdatedTask);
Assert.AreEqual(resultUpdatedTask.Name, newName);
}
/// <inheritdoc/>
public async Task UpdateAsync(SaveTaskRequest task, CancellationToken cancellationToken)
{
var taskId = task.Id;
var source = await _taskRepository.GetTaskByIdAsync(taskId, cancellationToken);
var updated = _mapper.Map(task, source);
await _taskRepository.UpdateTaskAsync(updated, cancellationToken);
}
public virtual JsonResult VERUpdateTask(string operationNumber)
{
ResponseBase response = new ResponseBase();
var jsonDataRequest = PageSerializationHelper.DeserializeJsonForm(Request.Form[0]);
var viewModel = PageSerializationHelper.DeserializeObject <TaskViewModel>(jsonDataRequest.SerializedData);
try
{
viewModel.UpdateVerTaskViewModel(jsonDataRequest.ClientFieldData);
var saveRequest = new SaveTaskRequest
{
Model = viewModel
};
response = _verTaskService.SaveVerTask(saveRequest);
var workFlow = jsonDataRequest.ClientFieldData.FirstOrDefault(o => o.Name.Equals("changeStatus"));
var requestTask = new CompleteTaskRequest
{
TaskId = viewModel.TaskDataModel.TaskId,
InstanceId = viewModel.TaskDataModel.WorkflowInstanceId,
Status = VerGlobalValues.COMPLETE_TASK,
Action = VerGlobalValues.COMPLETE_ACTION_TASK
};
if (workFlow != null)
{
switch (workFlow.Value)
{
case VerGlobalValues.COMPLETE_ACTION_TASK:
requestTask.Action = VerGlobalValues.COMPLETE_ACTION_TASK;
requestTask.Status = VerGlobalValues.COMPLETE_TASK;
break;
case VerGlobalValues.REJECT_ACTION_TASK:
requestTask.Action = VerGlobalValues.REJECT_ACTION_TASK;
requestTask.Status = VerGlobalValues.REJECT_TASK;
break;
}
}
_verTaskService.CompleteTask(requestTask);
response.IsValid = true;
}
catch (Exception e)
{
response.IsValid = false;
response.ErrorMessage = e.ToString();
}
return(Json(response));
}
public async Task SaveTask_Success()
{
var model = new Domain.Models.Task {
Name = "TestTask", Description = "TestTask description"
};
var request = new SaveTaskRequest(model);
var handler = new SaveTaskRequestHandler(_trackingContext, Mapper.Instance);
var result = await handler.Handle(request, default(CancellationToken));
Assert.AreEqual(result, Unit.Value);
}
public async Task <IActionResult> Update(long id, [FromBody] SaveTaskRequest resource, CancellationToken cancellationToken)
{
if (id <= 0)
{
return(NotFound());
}
if (resource == null)
{
return(BadRequest());
}
await _taskService.UpdateAsync(resource, cancellationToken);
return(Ok(resource));
}
public async Task SaveTaskList_Validation(string taskName, bool instantiateModel, bool isValid)
{
Domain.Models.Task model = null;
if (instantiateModel)
{
model = new Domain.Models.Task {
Name = taskName
};
}
var request = new SaveTaskRequest(model);
var validator = new SaveTaskValidator();
var validationResult = await validator.ValidateAsync(request);
Assert.AreEqual(isValid, validationResult.IsValid);
}
public SaveTaskRequestApi(SaveTaskRequest request)
{
this.TaskID = request.TaskID;
this.ClientNickname = request.ClientNickname;
this.JobNumber = request.JobNumber;
this.TaskNumber = request.TaskNumber;
this.TaskTitle = request.TaskTitle;
this.TaskItemComment = request.TaskItemComment;
this.OwnerUserID = request.OwnerUserID;
this.RowVersion = request.RowVersion;
this.LastTaskItemID = request.LastTaskItemID;
this.DueDate = request.DueDate;
this.SpentTime = request.SpentTimeMinutes;
this.EffortEstimation = request.EffortEstimationMinutes;
}
public void Task_Forward_OK()
{
var configuration = GetConfigurationFile();
if (configuration.ForwardTaskTests == null || configuration.ForwardTaskTests.Count == 0)
{
throw new System.InvalidOperationException("No \"forwardTaskTests\" items configured in configuration file");
}
var users = taskrowClient.ListUsers();
foreach (var test in configuration.ForwardTaskTests)
{
var user1 = users.Where(a => a.MainEmail.Equals(test.User1Email, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
if (user1 == null)
{
throw new System.InvalidOperationException($"User e-mail=\"{test.User1Email}\" not found");
}
if (!user1.Active)
{
throw new System.InvalidOperationException($"User e-mail=\"{test.User1Email}\" is inactive");
}
var user2 = users.Where(a => a.MainEmail.Equals(test.User2Email, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
if (user2 == null)
{
throw new System.InvalidOperationException($"User e-mail=\"{test.User2Email}\" not found");
}
if (!user2.Active)
{
throw new System.InvalidOperationException($"User e-mail=\"{test.User2Email}\" is inactive");
}
if (user1.UserID == user2.UserID)
{
throw new System.InvalidOperationException($"Error in \"forwardTaskTests\" configuration, user1 and user2 are the same");
}
var taskReference = new TaskReference(test.TaskUrl);
var task = taskrowClient.GetTaskDetail(taskReference);
if (task == null)
{
throw new System.InvalidOperationException($"Task {test.TaskUrl} not found");
}
var taskComment = $"Task forwarded on {DateTime.Now:yyyy-MM-dd HH:mm:ss}";
int ownerUserID = task.Owner.UserID;
var dueDate = (task.DueDate >= DateTime.Now.Date ? task.DueDate : DateTime.Now.Date);
if (task.Owner.UserID == user1.UserID)
{
ownerUserID = user2.UserID;
}
else if (task.Owner.UserID == user2.UserID)
{
ownerUserID = user1.UserID;
}
else
{
throw new System.InvalidOperationException($"Task {test.TaskUrl}, has a unexpected owner");
}
var request = new SaveTaskRequest(task.TaskID, task.ClientNickname, task.JobNumber, task.TaskNumber, task.TaskTitle, taskComment, ownerUserID,
task.RowVersion, task.TaskItems.Last().TaskItemID, dueDate, 0, task.EffortEstimationMinutes);
var response = taskrowClient.SaveTask(request);
if (!response.Success)
{
throw new System.InvalidOperationException($"Error saving task: {response.Message}");
}
}
Assert.True(true);
}
