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); } }