Ejemplo n.º 1
0
        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));
        }
Ejemplo n.º 2
0
        public void TextInitialize()
        {
            var kernel = AssemblyConfiguration.Kernel;

            _createTaskCommand = kernel.Get <CreateTaskCommand>();
            _sut = kernel.Get <GetTasksQuery>();
        }
Ejemplo n.º 3
0
        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);
        }
Ejemplo n.º 4
0
        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);
        }
Ejemplo n.º 5
0
        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());
            }
        }
Ejemplo n.º 6
0
        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);
        }
Ejemplo n.º 7
0
        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);
        }
Ejemplo n.º 8
0
        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
                });
            }
        }
Ejemplo n.º 11
0
        /// <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;
            }
        }
Ejemplo n.º 12
0
        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);
        }
Ejemplo n.º 13
0
        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);
        }
Ejemplo n.º 15
0
        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;
        }
Ejemplo n.º 16
0
        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));
        }
Ejemplo n.º 18
0
        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));
        }
Ejemplo n.º 19
0
        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);
        }
Ejemplo n.º 21
0
        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);
        }
Ejemplo n.º 22
0
        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));
        }
Ejemplo n.º 27
0
 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);
        }
Ejemplo n.º 29
0
        public void Create(string taskName)
        {
            var cmd = new CreateTaskCommand()
            {
                Name   = taskName,
                UserId = GetCurrentUserId()
            };

            Bus.Send(cmd);
        }
Ejemplo n.º 30
0
        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>();
        }
Ejemplo n.º 31
0
        public static CreateTaskCommand ToCreateTaskCommand(this CreateTaskVm model)
        {
            var command = new CreateTaskCommand()
            {
                AssignedMemberId = model.AssignedMemberId == Guid.Empty ? null : model.AssignedMemberId,
                Subject          = model.Subject
            };

            return(command);
        }
Ejemplo n.º 32
0
 public ActionResult Create(TaskDto task)
 {
     var command = new CreateTaskCommand(task.Id, task.Description, task.Due);
     return Execute(command) ?? View(task);
 }