public void Init()
{
_taskRepository = Substitute.For<TaskRepository>();
_projectRepository = Substitute.For<IProjectRepository>();
_console = Substitute.For<IConsole>();
_addTaskCommand = new AddTaskCommand(_console, _taskRepository, _projectRepository, "secrets Eat more donuts.");
}
public async Task <ActionResult> AddTask([CustomizeValidator(Interceptor = typeof(API.Middleware.ValidatorInterceptor))] DelegatedTaskViewModel task)
{
var addTaskCommand = new AddTaskCommand(task.Type, task.Deadline, task.Notes);
await Mediator.Send(addTaskCommand);
return(NoContent());
}
public async System.Threading.Tasks.Task Handle(AddTaskCommand message)
{
var task = OTask.Factory.Create(message.TaskId, message.UserId, message.Name);
await _repository.SaveAsync(task);
this.Data.TaskId = task.Id;
}
private async Task AddDisconnectedTask()
{
var taskType = SourceParticipant.IsJudge() ? TaskType.Judge : TaskType.Participant;
var disconnected = new AddTaskCommand(SourceConference.Id, SourceParticipant.Id, "Disconnected", taskType);
await CommandHandler.Handle(disconnected);
}
public void Should_throw_conference_not_found_exception_when_conference_does_not_exist()
{
var conferenceId = Guid.NewGuid();
var participantId = Guid.NewGuid();
var command = new AddTaskCommand(conferenceId, participantId, "alert", TaskType.Participant);
Assert.ThrowsAsync <ConferenceNotFoundException>(() => _handler.Handle(command));
}
public TaskListViewModel(ITaskFactory taskFactory, ITaskRepository taskRepository)
{
TaskDataList = new ObservableCollection <TaskData>();
DispStatusList = new ObservableCollection <string>(TaskStatusEnumUtil.GetEnumValueList());
AddTaskCommand = new AddTaskCommand(taskFactory, taskRepository);
FindAllTaskCommand = new FindAllTaskCommand(taskFactory, taskRepository);
}
public async Task AddTaskCommandHandler_ReturnsTask()
{
var command = new AddTaskCommand {
Filename = _config.TodoFile, Task = "Test string", AddCreationDate = true
};
TaskItem result = await _handler.Handle(command, new CancellationToken());
result.Text.Should().EndWith("Test string");
}
public void add_a_task_to_the_task_repository()
{
var project = new Project("secrets");
var addTaskCommand = new AddTaskCommand(_console, _taskRepository, _projectRepository, "secrets Eat more donuts.");
var task = new Task("Eat more donuts.", project);
_projectRepository.FindProjectByName("secrets").Returns(project);
addTaskCommand.Execute();
_taskRepository.Received().Add(task);
}
private async Task Add(string text, bool addCreationDate)
{
var command = new AddTaskCommand {
Filename = Configuration.TodoFile, Task = text, AddCreationDate = addCreationDate
};
var task = await Mediator.Send(command);
Console.WriteLine(task.ToString());
Console.WriteLine($"TODO: {task.LineNumber} added.");
}
public async Task AddTaskCommandHandler_AppendsTextToTodoFile()
{
var command = new AddTaskCommand {
Filename = _config.TodoFile, Task = "Test string"
};
_ = await _handler.Handle(command, new CancellationToken());
_taskFile.LineAppended.Should().Be("Test string");
_taskFile.TaskLines[0].Should().Be("Test string");
}
public async Task <IActionResult> AddTask([FromBody] AddTaskCommand command)
{
if (command is null)
{
return(BadRequest());
}
var taskId = await _mediator.Send(command);
return(CreatedAtAction("AddTask", new { id = taskId }));
}
public async Task <AddTaskResponse> AddTask(AddTaskCommand command)
{
var response = await _mediator.Send(command);
if (Notification.HasNotification())
{
return(null);
}
return(response);
}
public async Task AddTaskCommandHandler_AppendsTextToOtherFile()
{
var command = new AddTaskCommand {
Filename = "Other.txt", Task = "Test string"
};
_ = await _handler.Handle(command, new CancellationToken());
_taskFile.LineAppended.Should().Be("Test string");
_taskFile.OtherLines[0].Should().Be("Test string");
}
public async Task <IActionResult> Add(AddTaskCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _taskService.AddTaskCommandHandler(command);
return(Created($"/api/tasks/{result.Payload.Id}", result));
}
public static AddTaskCommand ToAddTaskCommand(this TaskVm model)
{
var command = new AddTaskCommand()
{
AssignedTold = model.AssignedToId,
Subject = model.Subject,
IsComplete = model.IsComplete
};
return(command);
}
public void Publish(AddTaskCommand message)
{
var exchange = ResolveExchange <AddTaskCommand>().Exchange;
Client
.DeclareExchange(e => e.WithName(exchange))
.Publish <AddTaskCommand>(
m =>
m.WithExchange(exchange)
.WithMessage(message));
}
public static AddTaskCommand ToAddTaskCommand(this TaskVm model)
{
var command = new AddTaskCommand()
{
Member = model.Member,
Text = model.Text,
IsDone = model.IsDone
};
return(command);
}
private Response AddTask()
{
var cmd = new AddTaskCommand(
Request.Form.taskName,
Request.Form.taskDecription,
DateTime.Parse(Request.Form.taskDueDate)
);
commandProcessor.Send(cmd);
return(TasksView());
}
public void Establish()
{
_tasksDAO = new Tasks.Adapters.DataAccess.TasksDAO();
_tasksDAO.Clear();
_cmd = new AddTaskCommand(TASK_NAME, TASK_DESCRIPTION, _now);
_commandProcessor = A.Fake <IAmACommandProcessor>();
_handler = new AddTaskCommandHandler(_tasksDAO, _commandProcessor);
}
public IActionResult Post([FromBody] TaskModel newTask)
{
var addTaskCommand = new AddTaskCommand(
taskName: newTask.TaskName,
taskDescription: newTask.TaskDescription,
dueDate: DateTime.Parse(newTask.DueDate)
);
_commandProcessor.Send(addTaskCommand);
return(this.CreatedAtRoute("GetTask", new { id = addTaskCommand.TaskId }, null));
}
public async Task <AddTaskCommandResult> AddTaskCommandHandler(AddTaskCommand command)
{
var task = _mapper.Map <TaskDm>(command);
var persistedTask = await _taskRepository.CreateRecordAsync(task);
var vm = _mapper.Map <TaskVm>(persistedTask);
return(new AddTaskCommandResult()
{
Payload = vm
});
}
public async void GivenTwoHandlersForOneCommand_WhenSendMethodIsBeingCalled_ThenOnlyFIrstHandlersIsBeingCalled()
{
//Given
var query = new AddTaskCommand("cleaning");
//When
await mediator.Send(query);
//Then
_taskList.Tasks.Count.Should().Be.EqualTo(1);
_taskList.Tasks.Should().Have.SameValuesAs("cleaning");
}
public async Task AddTaskCommandHandler_PrependsCreationDateToFile()
{
var command = new AddTaskCommand {
Filename = _config.TodoFile, Task = "Test string", AddCreationDate = true
};
_ = await _handler.Handle(command, new CancellationToken());
string now = DateTime.Now.Date.ToString("yyyy-MM-dd");
_taskFile.LineAppended.Should().Be($"{now} Test string");
}
public AddTaskViewModel(INavigator <InnerViewModel> nnavigator, ITaskDataService taskDataService)
{
navigator = (IInnerNavigator <Task>)nnavigator;
TaskToAdd = new Task {
IssueId = navigator.ParentViewModel.SelectedIssue.Id,
Title = "",
Description = "",
Progress = 0
};
AddTaskCommand = new AddTaskCommand(this, taskDataService);
CloseInnerViewCommand = new CloseInnerViewCommand(this);
}
public async Task Should_send_disconnect_messages_to_participants_and_service_bus_on_participant_disconnect()
{
var conference = TestConference;
var participantForEvent = conference.GetParticipants().First(x => x.UserRole == UserRole.Individual);
var callbackEvent = new CallbackEvent
{
EventType = EventType.Disconnected,
EventId = Guid.NewGuid().ToString(),
ParticipantId = participantForEvent.Id,
ConferenceId = conference.Id,
Reason = "Unexpected drop",
TimeStampUtc = DateTime.UtcNow
};
var updateStatusCommand = new UpdateParticipantStatusAndRoomCommand(conference.Id, participantForEvent.Id,
ParticipantState.Disconnected, null);
CommandHandlerMock.Setup(x => x.Handle(updateStatusCommand));
var addParticipantDisconnectedTask =
new AddTaskCommand(conference.Id, conference.Id, "Disconnected", TaskType.Participant);
CommandHandlerMock.Setup(x => x.Handle(addParticipantDisconnectedTask));
await _sut.HandleAsync(callbackEvent);
CommandHandlerMock.Verify(
x => x.Handle(It.Is <UpdateParticipantStatusAndRoomCommand>(command =>
command.ConferenceId == conference.Id &&
command.ParticipantId == participantForEvent.Id &&
command.ParticipantState == ParticipantState.Disconnected &&
command.Room == null)), Times.Once);
CommandHandlerMock.Verify(
x => x.Handle(It.Is <AddTaskCommand>(command =>
command.ConferenceId == conference.Id &&
command.OriginId == participantForEvent.Id &&
command.TaskType == TaskType.Participant)), Times.Once);
CommandHandlerMock.Verify(
x => x.Handle(It.Is <AddTaskCommand>(command =>
command.ConferenceId == conference.Id &&
command.OriginId == conference.Id &&
command.TaskType == TaskType.Hearing)), Times.Never);
CommandHandlerMock.Verify(
x => x.Handle(It.Is <AddTaskCommand>(command =>
command.ConferenceId == participantForEvent.Id &&
command.OriginId == participantForEvent.Id &&
command.TaskType == TaskType.Judge)), Times.Never);
}
public Guid Add(string taskName)
{
var taskId = Guid.NewGuid();
var cmd = new AddTaskCommand()
{
TaskId = taskId,
UserId = GetCurrentUserId(),
Name = taskName
};
Bus.Send(cmd);
return(taskId);
}
protected override async Task PublishStatusAsync(CallbackEvent callbackEvent)
{
var query = new GetTasksForConferenceQuery(SourceConference.Id);
var tasks = await QueryHandler.Handle <GetTasksForConferenceQuery, List <Domain.Task> >(query);
var task = tasks.SingleOrDefault(x => x.Type == TaskType.Participant && x.OriginId == SourceParticipant.Id && x.Status != TaskStatus.ToDo);
if (task == null)
{
var command = new AddTaskCommand(SourceConference.Id, SourceParticipant.Id, "Media blocked", TaskType.Participant);
await CommandHandler.Handle(command);
}
}
public ProjectsPageViewModel()
{
NewProjectCommand = new NewProjectCommand(this);
AddTaskCommand = new AddTaskCommand(this);
RemoveTaskCommand = new RemoveTaskCommand(this);
SaveProjectCommand = new SaveProjectCommand(this);
OpenProjectCommand = new OpenProjectCommand(this);
EnumList = new List <Stage>();
foreach (Stage stage in Enum.GetValues(typeof(Stage)))
{
EnumList.Add(stage);
}
}
public OperationResult Post(TaskModel newTask)
{
var addTaskCommand = new AddTaskCommand(
taskName: newTask.TaskName,
taskDecription: newTask.TaskDescription,
dueDate: DateTime.Parse(newTask.DueDate)
);
commandProcessor.Send(addTaskCommand);
return(new OperationResult.Created
{
RedirectLocation = new Uri(string.Format("{0}/tasks/{1}", communicationContext.ApplicationBaseUri, addTaskCommand.TaskId))
});
}
public async Task <IActionResult> AddTaskAsync(Guid conferenceId, [FromBody] AddTaskRequest addTaskRequest)
{
_logger.LogDebug($"Adding a task {addTaskRequest.Body} for participant {addTaskRequest.ParticipantId} in conference {conferenceId}");
try
{
var command = new AddTaskCommand(conferenceId, addTaskRequest.ParticipantId, addTaskRequest.Body, addTaskRequest.TaskType);
await _commandHandler.Handle(command);
return(NoContent());
}
catch (Exception e)
{
_logger.LogError(e, "Unable to add a task {taskBody} for participant {participant} in conference {conference}",
addTaskRequest.Body, addTaskRequest.ParticipantId, conferenceId);
return(BadRequest());
}
}
public void TaskCommandHandler_Handle_AddTaskCommand_AddInvalidValidTasks(string description, string longDescription, int deadlineDaysAfter, bool facebookProject, bool partOfProject)
{
IRequestHandler <AddTaskCommand, bool> handler = GetCommandHandlerInstance();
var commmand = new AddTaskCommand()
{
Description = description,
LongDescription = longDescription,
DeadLine = DateTime.UtcNow.AddDays(deadlineDaysAfter),
ProjectId = facebookProject ? FacebookId : WindowsProjectId,
ReporterId = facebookProject ? MarkId : GatesId,
AssigneeId = facebookProject && partOfProject? MarkId : GatesId
};
Action handle = () => handler.Handle(commmand, default).Wait();
handle.Should().Throw <ValidationException>();
}
public async Task HandleInvokesAddTaskAsyncWithCorrectData()
{
var options = this.CreateNewContextOptions();
using (var context = new AllReadyContext(options)) {
var sut = new AddTaskCommandHandler(context);
var message = new AddTaskCommand {
AllReadyTask = new AllReadyTask()
};
await sut.Handle(message);
}
using (var context = new AllReadyContext(options)) {
var tasks = context.Tasks.Count();
Assert.Equal(tasks, 1);
}
}
