public async Task <IResult <bool> > ScheduleTask(CreateTaskCommand command) { string key = command.Key; string group = command.Group; IJobDetail jobDetail = JobBuilder.Create <ScheduledEventOccuredJob>() .WithIdentity($"job_{key}", group) .UsingJobData("command", command.Command.ToString()) .UsingJobData("type", command.Type) .UsingJobData("log-context", JsonConvert.SerializeObject(_sessionStorage.GetTraceHeaders())) .RequestRecovery(true) .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity($"trigger_{key}", group) .ForJob(jobDetail) .WithCronSchedule(command.CronString) .StartNow() .Build(); await _scheduler.ScheduleJob(jobDetail, trigger); return(new Success <bool>(true)); }
public void TextInitialize() { var kernel = AssemblyConfiguration.Kernel; _createTaskCommand = kernel.Get <CreateTaskCommand>(); _sut = kernel.Get <GetTasksQuery>(); }
public async void Should_Update_Entity_Successfully() { var cmd = new CreateTaskCommand { Description = "Test", DueDate = DateTime.Now.AddDays(1), Title = "Before" }; var createHandler = ServiceProvider.GetService <IRequestHandler <CreateTaskCommand, DomainLayer.Entities.Task> >(); var updateHandler = ServiceProvider.GetService <IRequestHandler <UpdateTaskCommand, DomainLayer.Entities.Task> >(); var insertedTask = await createHandler.Handle(cmd, new CancellationToken()); var result = await updateHandler.Handle(new UpdateTaskCommand { Id = insertedTask.Id, Description = insertedTask.Description, Title = "After", DueDate = insertedTask.DueDate }, new CancellationToken()); Assert.False(string.IsNullOrEmpty(result.Id)); Assert.Equal(1, await ApplicationDbContext.Tasks.CountAsync()); Assert.Equal(result.Title, (await ApplicationDbContext.Tasks.FirstAsync()).Title); }
public void CreateATaskWithExactlyThoseParameters_WhenInvokedWithValidParameters() { // Arrange var databaseStub = new Mock <IDatabase>(); var factoryStub = new Mock <IModelsFactory>(); var projectMock = new Mock <IProject>(); var ownerStub = new Mock <IUser>(); var taskMock = new Mock <ITask>(); var validParameters = new List <string>() { "0", "0", "BuildTheStar", "Pending" }; var createTaskCommand = new CreateTaskCommand(databaseStub.Object, factoryStub.Object); databaseStub.Setup(db => db.Projects).Returns(new List <IProject> { projectMock.Object }); projectMock.Setup(p => p.Users).Returns(new List <IUser> { ownerStub.Object }); projectMock.Setup(p => p.Tasks).Returns(new List <ITask>()); // Act createTaskCommand.Execute(validParameters); // Assert Assert.AreEqual("Pending", projectMock.Object.Tasks[0].State); Assert.AreEqual("BuildTheStar", projectMock.Object.Tasks[0].Name); Assert.AreEqual(ownerStub.Object, projectMock.Object.Tasks[0].Owner); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "list/{listid}/tasks")] TaskDTO task, string listid) { try { var command = new CreateTaskCommand { ListId = listid, Name = task.Name, Description = task.Description }; var handler = Container.GetInstance <ICommandHander <CreateTaskCommand, string> >(); var id = await handler.Execute(command); var uri = new Uri(string.Format(Environment.GetEnvironmentVariable("TASK_RESOURCE_URI"), listid, id)); return(new CreatedResult(uri, null)); } catch (ResourceNotFoundException ex) { Container.GetInstance <TelemetryClient>().TrackException(ex); return(new NotFoundResult()); } catch (Exception ex) { Container.GetInstance <TelemetryClient>().TrackException(ex); return(new InternalServerErrorResult()); } }
public void ReturnMessegeContainingSuccessfullyCreated_WhenInvokedWithValidParameters() { // Arrange var databaseStub = new Mock <IDatabase>(); var factoryStub = new Mock <IModelsFactory>(); var projectMock = new Mock <IProject>(); var ownerStub = new Mock <IUser>(); var taskStub = new Mock <ITask>(); var validParameters = new List <string>() { "0", "0", "BuildTheStar", "Pending" }; var createTaskCommand = new CreateTaskCommand(databaseStub.Object, factoryStub.Object); databaseStub.Setup(db => db.Projects).Returns(new List <IProject> { projectMock.Object }); projectMock.Setup(p => p.Users).Returns(new List <IUser> { ownerStub.Object }); projectMock.Setup(p => p.Tasks).Returns(new List <ITask>()); // Act string result = createTaskCommand.Execute(validParameters); // Assert StringAssert.Contains("Successfully created", result); }
public void CallsProjectsPropertyIndexer_WhenInvokedWithValidParameters() { // Arrange var databaseMock = new Mock <IDatabase>(); var factoryStub = new Mock <IModelsFactory>(); var projectStub = new Mock <IProject>(); var ownerStub = new Mock <IUser>(); var taskStub = new Mock <ITask>(); var validParameters = new List <string>() { "0", "0", "BuildTheStar", "Pending" }; var createTaskCommand = new CreateTaskCommand(databaseMock.Object, factoryStub.Object); databaseMock.Setup(db => db.Projects).Returns(new List <IProject> { projectStub.Object }); databaseMock.SetupGet(db => db.Projects[It.IsAny <int>()]); projectStub.Setup(p => p.Users).Returns(new List <IUser> { ownerStub.Object }); projectStub.Setup(p => p.Tasks).Returns(new List <ITask> { taskStub.Object }); // Act createTaskCommand.Execute(validParameters); // Assert databaseMock.Verify(db => db.Projects[It.IsAny <int>()], Times.Once); }
public void AddTheCreatedTaskToTheProject_WhenInvokedWithValidParameters() { // Arrange var databaseStub = new Mock <IDatabase>(); var factoryStub = new Mock <IModelsFactory>(); var projectMock = new Mock <IProject>(); var ownerStub = new Mock <IUser>(); var taskStub = new Mock <ITask>(); var validParameters = new List <string>() { "0", "0", "BuildTheStar", "Pending" }; var createTaskCommand = new CreateTaskCommand(databaseStub.Object, factoryStub.Object); databaseStub.Setup(db => db.Projects).Returns(new List <IProject> { projectMock.Object }); projectMock.Setup(p => p.Users).Returns(new List <IUser> { ownerStub.Object }); projectMock.Setup(p => p.Tasks).Returns(new List <ITask>()); // Act createTaskCommand.Execute(validParameters); // Assert Assert.AreEqual(1, projectMock.Object.Tasks.Count); }
public async Task ShouldNot_CreateDuplicateTask() { var items = new Dictionary<string, TaskToDo>() { { "task1", new TaskToDo() { Name = "task1", StatusCode = "NotStarted" } } }; var collection = new InMemoryItemsCollection<TaskToDo>(items); var handler = new DefaultCommandHandlers(collection); var newTaskCmd = new CreateTaskCommand() { Name = "task1", Priority = 1, Statues = "NotStarted" }; var ex = await Assert.ThrowsAsync<AppException>(async () => await handler.Handle(newTaskCmd, CancellationToken.None)); Assert.Equal("Task with the same name already exists", ex.Message); }
public async Task CreateTask(CreateTaskCommand command) { try { _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", await _authHandler.GetAuthAccessToken()); var response = await _httpClient.PostAsJsonAsync <CreateTaskCommand>("api/Tasks", command); if (response.IsSuccessStatusCode) { var commandResult = await response.Content.ReadFromJsonAsync <CreateTaskCommandResult>(); var tasks = new List <TaskDto>(_tasksSubject.Value); tasks.Add(commandResult.Payload); _tasksSubject.OnNext(tasks); _apiCallResultSubject.OnNext(new ApiCallResult <string>() { IsSucceed = true, Operation = "CreateTask" }); } } catch (Exception ex) { _apiCallResultSubject.OnNext(new ApiCallResult <string>() { IsSucceed = false, Operation = "CreateTask", ErrorMessage = ex.Message }); } }
/// <summary> /// Handles task create. /// </summary> /// <param name="command">Command.</param> /// <param name="uowFactory">Application unit of work factory.</param> public void HandleCreateTask(CreateTaskCommand command, IAppUnitOfWorkFactory uowFactory) { using (var uow = uowFactory.Create()) { var project = uow.ProjectRepository.Get(command.ProjectId); if (project != null && project.User.Id != command.UserId) { throw new DomainException("User does not own the project."); } var user = uow.UserRepository.Get(command.UserId); var task = new Entities.Task() { DueDate = DateTime.MaxValue, IsDone = command.IsDone, Text = command.Text.Trim(), Project = project, User = user, }; uow.TaskRepository.Add(task); uow.SaveChanges(); command.TaskId = task.Id; } }
public void Execute_CallsUsersIndex_WithCorrectId() { // Arrange var userStub = new Mock <IUser>(); var projectMock = new Mock <IProject>(); projectMock.Setup(x => x.Users[0]).Returns(userStub.Object); projectMock.Setup(x => x.Tasks.Add(It.IsAny <ITask>())); var databaseStub = new Mock <IDatabase>(); databaseStub.Setup(x => x.Projects[0]).Returns(projectMock.Object); var factoryStub = new Mock <IModelsFactory>(); var expectedIndex = 0; var sut = new CreateTaskCommand(databaseStub.Object, factoryStub.Object); var validParameters = new List <string>() { "0", "0", "BuildTheStar", "Pending" }; // Act sut.Execute(validParameters); // Assert projectMock.Verify(x => x.Users[expectedIndex], Times.Once); }
public IHttpActionResult CreateTask([FromBody] CreateTaskCommand command) { if (command == null) { return(BadRequest(DefaultMessages.InvalidBody)); } ValidationError error = new CreateTaskCommandValidator().Validate(command); if (error.IsInvalid) { return(BadRequest(error.Error)); } ProjectsRepository projectsRepository = new ProjectsRepository(Connection, User); Project project = projectsRepository.Find(command.ProjectId); if (project == null) { return(BadRequest("Projeto não encontrado.")); } if (command.RequirementId > 0) { RequirementsRepository requirementsRepository = new RequirementsRepository(Connection); Requirement requirement = requirementsRepository.Find(command.ProjectId, command.RequirementId); if (requirement == null) { return(BadRequest("Requisito não encontrado neste projeto.")); } } TaskRepository taskRepository = new TaskRepository(Connection); return(Ok(taskRepository.Create(command))); }
public void Execute_ShouldInvokeProjectsPropertyIndexer_WhenPassedValidProjectId(int projectId) { var databaseMock = new Mock <IDatabase>(); var factoryStub = new Mock <IModelsFactory>(); var projectStub = new Mock <IProject>(); var userStub = new Mock <IUser>(); var taskStub = new Mock <ITask>(); var users = new List <IUser>() { userStub.Object }; var tasks = new List <ITask>(); projectStub.SetupGet(x => x.Users).Returns(users); projectStub.SetupGet(x => x.Tasks).Returns(tasks); var userId = 0; var taskName = "Pesho"; var taskState = "Pending"; databaseMock.SetupGet(x => x.Projects[projectId]).Returns(projectStub.Object); factoryStub.Setup(x => x.CreateTask(userStub.Object, taskName, taskState)).Returns(taskStub.Object); var sut = new CreateTaskCommand(databaseMock.Object, factoryStub.Object); var parameters = new List <string>() { projectId.ToString(), userId.ToString(), taskName, taskState }; sut.Execute(parameters); databaseMock.Verify(x => x.Projects[projectId], Times.Once); }
public async System.Threading.Tasks.Task Handle(CreateTaskCommand message) { var task = OTask.Factory.Create(message.UserId, message.Name); await _repository.SaveAsync(task); this.Data.TaskId = task.Id; }
public async System.Threading.Tasks.Task ShouldCreateTask() { var userId = await RunAsDefaultUserAsync(); var employeeId = await SendAsync(new CreateEmployeeCommand { Name = "New Employee" }); var command = new CreateTaskCommand { EmployeeId = employeeId, Title = "Tasks" }; var itemId = await SendAsync(command); var item = await FindAsync <Domain.Entities.Task>(itemId); item.Should().NotBeNull(); item.EmployeeId.Should().Be(command.EmployeeId); item.Title.Should().Be(command.Title); item.CreatedBy.Should().Be(userId); item.Created.Should().BeCloseTo(DateTime.Now, 10000); item.LastModifiedBy.Should().BeNull(); item.LastModified.Should().BeNull(); }
public void CallTheUsersPropertyIndexerOfTheProject_WithThePassedId() { // Arrange var databaseMock = new Mock <IDatabase>(); var factoryMock = new Mock <IModelsFactory>(); var projectMock = new Mock <IProject>(); var userMock = new Mock <IUser>(); int projectId = 0; int userId = 0; IList <string> parameters = new List <string>() { "0", "0", "BuildTheStar", "Pending" }; databaseMock.Setup(d => d.Projects[projectId]).Returns(projectMock.Object); databaseMock.Setup(d => d.Projects[projectId].Users[userId]).Returns(userMock.Object); databaseMock.Setup(d => d.Projects[projectId].Tasks).Returns(new List <ITask>()); ICommand createTaskCommand = new CreateTaskCommand(databaseMock.Object, factoryMock.Object); // Act createTaskCommand.Execute(parameters); // Assert databaseMock.Verify(d => d.Projects[projectId].Users[userId], Times.Exactly(2)); }
public static void TaskMapper(this InputModelToDomainMappingProfile profile) { profile.CreateMap <CreateTaskInputModel, CreateTaskCommand>() .ForMember(x => x.Id, opt => opt.Ignore()) .ForMember(x => x.Status, opt => opt.Ignore()) .ForMember(x => x.Name, opt => opt.Ignore()) .ForMember(x => x.ValidationResult, opt => opt.Ignore()) .ConstructUsing(x => CreateTaskCommand.Create( x.Title, x.Description)); profile.CreateMap <UpdateTaskInputModel, UpdateTaskCommand>() .ForMember(x => x.Name, opt => opt.Ignore()) .ForMember(x => x.ValidationResult, opt => opt.Ignore()) .ConstructUsing(x => UpdateTaskCommand.Create( x.Id, x.Title, x.Description, x.Status)); profile.CreateMap <DeleteTaskInputModel, DeleteTaskCommand>() .ForMember(x => x.Title, opt => opt.Ignore()) .ForMember(x => x.Description, opt => opt.Ignore()) .ForMember(x => x.Status, opt => opt.Ignore()) .ForMember(x => x.Name, opt => opt.Ignore()) .ForMember(x => x.ValidationResult, opt => opt.Ignore()) .ConstructUsing(x => DeleteTaskCommand.Create(x.id)); }
public void ShouldRequireMinimumFields() { var command = new CreateTaskCommand(); FluentActions.Invoking(() => SendAsync(command)).Should().Throw <ValidationException>(); }
public void TaskWorker_DoWorkAsync() { // Arrange var worker = GetService <ITaskWorker>(); var queue = GetService <ITaskQueue>(); var mediator = GetService <IMediator>(); var context = GetService <IAmiUnitOfWork>(); var command = new CreateTaskCommand() { Command = new ProcessObjectCommand() { Id = Guid.NewGuid().ToString(), AmountPerAxis = 1, DesiredSize = 0 } }; var cts = new CancellationTokenSource(); cts.CancelAfter(3000); // Act var result1 = mediator.Send(command, cts.Token).Result; worker.StartAsync(cts.Token); var result2 = context.TaskRepository.GetFirstOrDefault(e => e.Id == Guid.Parse(result1.Id)); // Assert Assert.IsNotNull(result1); Assert.AreEqual(TaskStatus.Queued, result1.Status); Assert.AreEqual(CommandType.ProcessObjectCommand, result1.Command.CommandType); Assert.AreEqual(WorkerStatus.Terminated, worker.WorkerStatus); Assert.IsNotNull(result2); Assert.AreEqual(TaskStatus.Failed, (TaskStatus)result2.Status); Assert.AreEqual("Unexpected null exception. ObjectEntity not found.", result2.Message); }
public void Execute_AddsTask_ToProject() { // Arrange var taskStub = new Mock <ITask>(); var userStub = new Mock <IUser>(); var projectsMock = new Mock <IProject>(); projectsMock.Setup(x => x.Users[0]).Returns(userStub.Object); projectsMock.Setup(x => x.Tasks.Add(It.IsAny <ITask>())); var databaseStub = new Mock <IDatabase>(); databaseStub.Setup(x => x.Projects[0]).Returns(projectsMock.Object); var factoryStub = new Mock <IModelsFactory>(); factoryStub.Setup(x => x.CreateTask(userStub.Object, "BuildTheStar", "Pending")).Returns(taskStub.Object); var sut = new CreateTaskCommand(databaseStub.Object, factoryStub.Object); var validParameters = new List <string>() { "0", "0", "BuildTheStar", "Pending" }; // Act sut.Execute(validParameters); // Assert projectsMock.Verify(x => x.Tasks.Add(taskStub.Object), Times.Once); }
private void NewTaskCommand_Executed(object sender, RoutedEventArgs e) { CreateTaskCommand CreateClick = new CreateTaskCommand(this); CreateClick.Execute(); ViewableTasks.View.Refresh(); }
public Task Create(CreateTaskCommand command) { var user = _userRepository.GetById(command.UserId); var task = new Task(user, command.Title); _repository.Create(task); return(task); }
public TasksViewModel() { RemoveTaskCommand = new RemoveTaskCommand(this); CreateTaskCommand = new CreateTaskCommand(this); ErrorMessage = ""; NewTaskName = ""; TasksList = System.Threading.Tasks.Task.Run(() => this.GetTasks()).Result; }
public CreateInfo When(CreateTaskCommand cmd) { var id = idGenerator.Next<TaskAggregate>(); var defaultName = "Task " + id; var agg = new TaskAggregate(); agg.Create(id, defaultName); repository.Save(agg); return new CreateInfo{Id = id, DefaultName = defaultName}; }
public GenericCommandResult Create( [FromBody] CreateTaskCommand command, [FromServices] TaskHandler handler ) { command.User = User.Claims.FirstOrDefault(x => x.Type == "user_id")?.Value; return((GenericCommandResult)handler.Handle(command)); }
private static void PopulateCreateCommand(int taskId, CreateTaskCommand model, MySqlCommand command) { command.Parameters.Add("@projectId", MySqlDbType.Int32).Value = model.ProjectId; command.Parameters.Add("@requirementId", MySqlDbType.Int32).Value = model.RequirementId; command.Parameters.Add("@taskId", MySqlDbType.Int32).Value = taskId; command.Parameters.Add("@name", MySqlDbType.VarChar).Value = model.Name; command.Parameters.Add("@description", MySqlDbType.VarChar).Value = model.Description; command.Parameters.Add("@stage", MySqlDbType.Int32).Value = model.Stage; }
public static CreateTaskCommand ToCreateTaskCommand(this TaskVm model) { var command = new CreateTaskCommand() { Subject = model.Subject, AssignedToId = model.AssignedToId }; return(command); }
public void Create(string taskName) { var cmd = new CreateTaskCommand() { Name = taskName, UserId = GetCurrentUserId() }; Bus.Send(cmd); }
public void TestInitialize() { var commandFactory = AssemblyConfiguration.Kernel.Get <CommandFactory>(); var queryFactory = AssemblyConfiguration.Kernel.Get <QueryFactory>(); _mapper = AssemblyConfiguration.Kernel.Get <IMapper>(); _createTaskCommand = commandFactory.GetInstance <CreateTaskCommand>(); _getTaskQuery = queryFactory.GetInstance <GetTasksQuery>(); _sut = commandFactory.GetInstance <UpdateTaskCommand>(); }
public static CreateTaskCommand ToCreateTaskCommand(this CreateTaskVm model) { var command = new CreateTaskCommand() { AssignedMemberId = model.AssignedMemberId == Guid.Empty ? null : model.AssignedMemberId, Subject = model.Subject }; return(command); }
public ActionResult Create(TaskDto task) { var command = new CreateTaskCommand(task.Id, task.Description, task.Due); return Execute(command) ?? View(task); }