public async Task <CompleteTaskCommandResult> CompleteTaskCommandHandler(CompleteTaskCommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var task = await _taskRepository.ByIdAsync(command.Id);
if (task.IsComplete)
{
return(new CompleteTaskCommandResult()
{
Succees = true
});
}
task.IsComplete = true;
var affectedRecordsCount = await _taskRepository.UpdateRecordAsync(task);
var succees = affectedRecordsCount == 1;
return(new CompleteTaskCommandResult
{
Succees = succees
});
}
public void Delete(int id)
{
var completeTaskCommand = new CompleteTaskCommand(
taskId: id,
completionDate: DateTime.UtcNow
);
_commandProcessor.Send(completeTaskCommand);
}
public static CompleteTaskCommand ToCompleteTaskCommand(this TaskVm model)
{
var command = new CompleteTaskCommand()
{
Id = model.Id,
IsComplete = model.IsComplete
};
return(command);
}
public OperationResult Delete(int taskId)
{
var completeTaskCommand = new CompleteTaskCommand(
taskId: taskId,
completionDate: DateTime.UtcNow
);
_commandProcessor.Send(completeTaskCommand);
return(new OperationResult.OK());
}
public async Task <IActionResult> CompleteTask(CompleteTaskCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _taskService.CompleteTaskCommandHandler(command);
return(Ok(result));
}
public HttpResponseMessage PutCompleteTask(Guid id)
{
var command = new CompleteTaskCommand
{
TaskId = id
};
var response = _commandBus.Send(command);
return(response.Success ? SuccessResponseMessage() : ErrorResponseMessage(response));
}
public WorkPageViewModel()
{
WPOpenProjectCommand = new WPOpenProjectCommand(this);
BeginStopWorkCommand = new BeginStopWorkCommand(this);
CompleteTaskCommand = new CompleteTaskCommand(this);
AddNoteCommand = new AddNoteCommand(this);
ToggleNotesCommand = new ToggleNotesCommand();
CloseProjectCommand = new CloseProjectCommand(this);
DeleteNoteCommand = new DeleteNoteCommand();
EditNoteCommand = new EditNoteCommand(this);
}
public void Establish()
{
_tasksDAO = new Tasks.Adapters.DataAccess.TasksDAO();
_tasksDAO.Clear();
_cmd = new CompleteTaskCommand(TASK_ID, _COMPLETION_DATE);
_commandProcessor = A.Fake <IAmACommandProcessor>();
A.CallTo(() => _commandProcessor.Post(A <TaskCompletedEvent> ._));
_handler = new CompleteTaskCommandHandler(_tasksDAO, _commandProcessor);
}
/// <summary>
/// Converts to completetaskcommand.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">model</exception>
public static CompleteTaskCommand ToCompleteTaskCommand(this TaskVm model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
CompleteTaskCommand command = new CompleteTaskCommand
{
Id = model.Id
};
return(command);
}
public async Task <CompleteTaskCommandResult> CompleteTaskCommandHandler(CompleteTaskCommand command)
{
var task = await _taskRepository.ByIdAsync(command.TaskId);
task.IsComplete = !task.IsComplete;
var updatingResult = await _taskRepository.UpdateRecordAsync(task);
return(new CompleteTaskCommandResult
{
IsSucceed = updatingResult != 0
});
}
public void Establish()
{
_taskToBeCompleted = new Task("My Task", "My Task Description", DateTime.Now);
_tasksDAO = new Tasks.Adapters.DataAccess.TasksDAO();
_tasksDAO.Clear();
_taskToBeCompleted = _tasksDAO.Add(_taskToBeCompleted);
_cmd = new CompleteTaskCommand(_taskToBeCompleted.Id, s_COMPLETION_DATE);
s_commandProcessor = A.Fake <IAmACommandProcessor>();
_handler = new CompleteTaskCommandHandler(_tasksDAO, s_commandProcessor);
}
public async Task <IActionResult> CompleteTask(CompleteTaskCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _taskService.CompleteTaskCommandHandler(command);
return(Ok(new { Success = true }));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <IActionResult> Complete(CompleteTaskCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _taskService.CompleteTaskCommandHandler(command);
return(Ok(result));
}
catch (NotFoundException <Guid> )
{
return(NotFound());
}
}
public async Task <CompleteTaskCommandResult> CompleteTaskCommandHandler(CompleteTaskCommand command)
{
var isSucceed = true;
var task = await _taskRepository.ByIdAsync(command.Id);
task.IsComplete = true;
var affectedRecordsCount = await _taskRepository.UpdateRecordAsync(task);
if (affectedRecordsCount < 1)
{
isSucceed = false;
}
return(new CompleteTaskCommandResult()
{
Succeed = isSucceed
});
}
public TasksModule(IRetrieveTaskViewModels taskViewModelRetriever,
IBuildViews <TaskViewModel, TaskView> taskViewBuilder,
IAmACommandProcessor commandProcessor)
{
this.taskViewModelRetriever = taskViewModelRetriever;
this.taskViewBuilder = taskViewBuilder;
this.commandProcessor = commandProcessor;
Get["/tasks/{id}"] = _ =>
{
var viewModel = taskViewModelRetriever.Get(_.id);
return(taskViewBuilder.Build(viewModel));
};
Delete["/tasks/{id}"] = _ =>
{
var command = new CompleteTaskCommand(_.id, DateTime.UtcNow);
commandProcessor.Send(command);
return(Negotiate.WithStatusCode(HttpStatusCode.OK));
};
}
private async Task <CompleteTaskCommandResult> CompleteTask(CompleteTaskCommand command)
{
return(await httpClient.PutJsonAsync <CompleteTaskCommandResult>($"tasktodo/{command.Id}/{command.IsComplete}", command));
}
public async Task <CompleteTaskCommandResult> Complete(CompleteTaskCommand command)
{
return(await _httpClient.PutJsonAsync <CompleteTaskCommandResult>($"tasks/{command.Id}:complete", command));
}
public void Post_Complete_should_add_flash_message()
{
var command = new CompleteTaskCommand(1);
tasksController.Complete(command);
FlashMessage flashMessage = tasksController.TempData.GetFlashMessages().First();
Assert.AreEqual("success", flashMessage.Key);
StringAssert.Contains("Completed task:", flashMessage.Message);
}
private async Task <CompleteTaskCommandResult> Update(CompleteTaskCommand command)
{
return(await httpClient.PutJsonAsync <CompleteTaskCommandResult>($"Tasks/{command.TaskId}", command));
}
public void Post_Complete_should_send_to_mediator()
{
var command = new CompleteTaskCommand(1);
tasksController.Complete(command);
mockMediator.Verify(x => x.Send(command), Times.Once());
}
private async Task <CompleteTaskCommandResult> CompleteTask(CompleteTaskCommand command)
{
return(await httpClient.PutJsonAsync <CompleteTaskCommandResult>("tasks", command));
}
public ActionResult Complete(CompleteTaskCommand command)
{
Task task = mediator.Send(command);
this.Flash("success", string.Format("Completed task: {0}", task.Title));
return Json(new { success = true });
}
private async Task <CompleteTaskCommandResult> Complete(CompleteTaskCommand command) =>
await _httpClient.PutJsonAsync <CompleteTaskCommandResult>("tasks/complete", command);
public ActionResult Complete(Guid taskId)
{
var command = new CompleteTaskCommand(taskId);
return Execute(command) ?? RedirectToAction("All", "Tasks");
}
