public void Initialize() { // prepare the fakes fakeAnalyst = new Analyst("fake", "fake", "fake"); fakeDonor = new DonorAggregate("fake"); fakeCommand = new CreateProjectCommand(fakeDonor.Id, fakeAnalyst.Id, "acronym", "fake", "fake", DateTime.UtcNow); // initialize the mocks behaviour mockUnitOfWork = new Mock <IUnitOfWork>(); mockTransaction = new Mock <ITransaction>(); mockRepository = new Mock <IRepository>(); mockRepository .Setup(x => x.Get <Analyst>()) .Returns(new[] { fakeAnalyst }.AsQueryable()); mockRepository .Setup(x => x.Get <DonorAggregate>()) .Returns(new[] { fakeDonor }.AsQueryable()); mockRepository .Setup(x => x.Add(It.IsAny <ProjectAggregate>())) .Callback <ProjectAggregate>((p) => fakeProjectAggregate = p); mockUnitOfWork .Setup(x => x.CreateRepository()) .Returns(mockRepository.Object); mockUnitOfWork .Setup(x => x.BeginTransaction()) .Returns(mockTransaction.Object); }
public void GetById_Integration_ReturnsData() { string filePath = Path.Combine(AppContext.BaseDirectory, Path.GetRandomFileName() + ".dbtest"); using (SQLiteDbContext dbContext = new SQLiteDbContext(filePath)) { dbContext.Initialise(); dbContext.BeginTransaction(); IProjectRequestAggregateRepository projectRequestAggregateRepo = new ProjectRequestAggregateRepository(dbContext); ICreateProjectCommand createProjectCommand = new CreateProjectCommand(dbContext, new ProjectValidator()); ISetLogFileUnprocessedCommand setLogFileUnprocessedCommand = Substitute.For <ISetLogFileUnprocessedCommand>(); ICreateProjectRequestAggregateCommand createProjectRequestAggregateCommand = new CreateProjectRequestAggregateCommand(dbContext, new ProjectRequestAggregateValidator(), new LogFileRepository(dbContext), setLogFileUnprocessedCommand); IDeleteProjectRequestAggregateCommand deleteProjectRequestAggregateCommand = new DeleteProjectRequestAggregateCommand(dbContext, projectRequestAggregateRepo, new LogFileRepository(dbContext), setLogFileUnprocessedCommand); // create the project ProjectModel projectA = DataHelper.CreateProjectModel(); createProjectCommand.Execute(projectA); // create the request aggregate record for ProjectA ProjectRequestAggregateModel projectRequestAggregate = DataHelper.CreateProjectRequestAggregateModel(); projectRequestAggregate.ProjectId = projectA.Id; createProjectRequestAggregateCommand.Execute(projectRequestAggregate); int id = projectRequestAggregate.Id; Assert.Greater(id, 0); // fetch the record ProjectRequestAggregateModel result = projectRequestAggregateRepo.GetById(id); Assert.IsNotNull(result); Assert.AreEqual(projectRequestAggregate.Id, id); Assert.AreEqual(projectRequestAggregate.RegularExpression, result.RegularExpression); Assert.AreEqual(projectRequestAggregate.AggregateTarget, result.AggregateTarget); } }
public IActionResult Post([FromBody] ProjectCreateModel model) { var command = new CreateProjectCommand(model.Title, model.Description, new Guid(User.GetClaim("id"))); _bus.PublishCommand(command); return(Ok()); }
public async Task CreateProjectTest() { _mediator.Setup(m => m.Send(It.IsAny <CreateProjectCommand>(), new System.Threading.CancellationToken())) .Returns(Task.FromResult(new Core.ApiResponse.ApiResult { Code = Core.Enums.Code.Ok })); _authorizationService.Setup(g => g.GetUser()) .Returns(new Core.DataStructure.ControllerUser { UserName = "******", UserId = 1234 }); var command = new CreateProjectCommand { ProjectName = "测试标题", Desc = "测试描述", Platform = "github" }; var controller = new ProjectController(_mediator.Object, _log.Object, _authorizationService.Object, _projectQueries.Object); var result = await controller.CreateProjectAsync(command); Assert.NotNull(result); Assert.Equal(Code.Ok, result.Code); }
public async Task InputDataIsOk_Executed_ReturnProjectId() { //Arrange var projectRepository = new Mock <IProjectRepository>(); // LÁ DO COMMANDS => PROJECTS => CREATEPROJECT var createProjectCommand = new CreateProjectCommand { Title = "Título teste", Description = "Descrição teste", TotalCost = 5000, IdClient = 1, IdFreelancer = 2, FinishedAt = DateTime.Parse("2022-04-08") }; var createProjectCommandHandler = new CreateProjectCommandHandler(projectRepository.Object); //Act var id = await createProjectCommandHandler.Handle(createProjectCommand, new CancellationToken()); //Assert Assert.True(id >= 0); // VERIFICAR SE O MÉTODO DO REPOSITORY FOI CHAMADO // IsAny => PADRÃO PARA SABER SE O ENTITY PROJECT FOI CHAMADO UMA VEZ "ONCE" // It.IsAny<Project>()) É UMA SOBRECARGA LÁ NO REPOSITORY }
public async Task TestCreateMethod() { // Arrange TestLambdaContext context; APIGatewayProxyRequest request; APIGatewayProxyResponse response; string json = System.Text.Json.JsonSerializer.Serialize(new { Title = "Hello World", Type = ProjectType.List.ToString(), Status = Status.Active.ToString(), Priority = Prioritization.High.ToString(), PercentageCompleted = 50 }); request = new APIGatewayProxyRequest { Headers = new Dictionary <string, string>(), Body = json, Path = "/projects" }; context = new TestLambdaContext(); var functions = new CreateProjectCommand(); // Act response = await functions.RunHandler(request, context); // Assert Assert.Equal(201, response.StatusCode); Assert.Null(response.Body); Assert.NotEmpty(response.Headers["Location"]); }
public async void handle_ProjectCategorieslNull_test() { Project project = new Project(); ProjectCategory pc = null; this._unitOfUnitMock.Setup(mock => mock.ProjectRepository.Create(It.IsAny <Project>())).Returns(project); this._unitOfUnitMock .Setup(mock => mock.RelationsRepository.CreateProjectCategory(It.IsAny <ProjectCategory>())).Returns(pc); CreateProjectCommand command = new CreateProjectCommand(new CreateProjectModel() { ProjectName = "test", Categories = new List <Category>() { new Category() { CategoryId = 1, CategoryName = "test", Created = DateTime.Now, Id = 1 } } }); CreateProjectHandler handler = new CreateProjectHandler(this._unitOfUnitMock.Object); var result = await handler.Handle(command, new CancellationTokenSource().Token); Assert.False((bool)result); }
public override async Task InitializeAsync() { await base.DisposeAsync(); createProjectCommand = new CreateProjectCommand("project1", true); createProjectDto = await SendAsync(createProjectCommand); }
private async Task <ICommandResult <Project> > CreateProject(UploadTestResultCommand command) { var createProjectCommand = new CreateProjectCommand(command.ProjectName); var projectCommandResult = await _projectCommandHandler.ExecuteAsync(createProjectCommand); return(projectCommandResult); }
public void ShouldRequireMinimumFields() { var command = new CreateProjectCommand(); FluentActions.Invoking(() => SendAsync(command)).Should().Throw <ValidationException>(); }
private void PopulateCreateCommand(CreateProjectCommand model, MySqlCommand command, int projectId) { command.Parameters.Add("@projectId", MySqlDbType.Int32).Value = projectId; command.Parameters.Add("@name", MySqlDbType.VarChar).Value = model.Name; command.Parameters.Add("@resume", MySqlDbType.VarChar).Value = model.Resume; command.Parameters.Add("@openingDate", MySqlDbType.DateTime).Value = DateTime.Now; }
public async Task <ActionResult <CreateProjectCommandResponse> > Create( [FromBody] CreateProjectCommand createProjectCommand) { var response = await _mediator.Send(createProjectCommand); return(Ok(response)); }
private DomainModel.Project CreateProject(CreateProjectCommand project) { int vkGroupId = this.groupInfoProvider.GetVkGroupId(project.Url); VkGroup group = this.vkGroupRepository.GetGroupById(vkGroupId); bool isGroupExists = group != null; DomainModel.Project projectToCreate = new DomainModel.Project { Title = project.Title, CreationDate = this.dateTimeHelper.GetDateTimeNow(), AccountId = project.AccountId, VkGroup = group ?? new VkGroup { Id = vkGroupId, Name = this.groupInfoProvider.GetVkGroupName(project.Url), Url = project.Url, Type = VkGroupType.Group } }; using (ITransactionScope transaction = this.unitOfWorkProvider.CreateTransaction().Begin()) { this.projectRepository.Save(projectToCreate); if (!isGroupExists) { this.AddGroupRelatedData(projectToCreate); } transaction.Commit(); } return(projectToCreate); }
public async Task <CommandResponse> ExecuteAsync(CreateProjectCommand command) { // map project ProjectRepository projectRepository = unitOfWork.GetRepository <Project, ProjectRepository>(); Project project = command.ServiceProvider.GetService <IMapper>() .Map <Project>(command.CreateProjectDTO); // insert bool isInserted = false; string message = "Project created"; try { isInserted = await projectRepository.InsertAsync(project); await unitOfWork.SaveAsync(); } catch (System.Exception e) { isInserted = false; message = Common.Algorithms.GetFullText(e); } // result return(new CommandResponse { IsSucessed = isInserted, Message = message }); }
public async Task <Result <CommandResult> > Handle(CreateProjectCommand request, CancellationToken cancellationToken) { if (!request.IsValid()) { await PublishValidationErrorsAsync(request); return(Result.Failure <CommandResult>(ApplicationMessages.Create_Failed)); } var project = _mapper.Map <Project>(request); var exist = await _projectRepository.ExistByNameAsync(project.Id, project.Name); if (exist) { await _mediator.Publish(new DomainNotification("", ApplicationMessages.Name_Already_Exist)); return(Result.Failure <CommandResult>(ApplicationMessages.Create_Failed)); } await _projectRepository.CreateAsync(project); return(Result.Success(new CommandResult(project.Id, ApplicationMessages.Create_Success))); }
public ActionResult Create(CreateProjectViewModelPost create) { Request.ThrowIfDifferentReferrer(); var currentUser = _userManager.FindById(User.Identity.GetUserId()); if (ModelState.IsValid && currentUser != null && PathNameValidation.CheckContainsNoForbiddenPathCharacters(ModelState, nameof(create.Name), create.Name) && CheckProjectNameAlreadyInUse(nameof(create.Name), create.Name, currentUser) && SessionDefinitionValidation.CheckDefinitionTemplateJson(ModelState, nameof(create.SessionDefinitionTemplate), create.SessionDefinitionTemplate)) { var command = new CreateProjectCommand() { Owner = currentUser, SessionDefinitionTemplate = create.SessionDefinitionTemplate, Name = create.Name, Description = create.Description }; _dispatcher.Dispatch(command); return(RedirectToAction(nameof(Details), new { projectId = command.NewId })); } var newCreate = Mapper.Map <CreateProjectViewModel>(create); newCreate.SessionDefinitionTemplates = GetSessionTemplatesList(); return(View(newCreate)); }
public async Task <IActionResult> CreateProject( [FromBody] CreateProjectCommand command, [FromServices] IMediator mediator) { var result = await mediator.Send(command); return(StatusCode(200, result)); }
public async Task <IActionResult> CreateProject([FromBody] CreateProjectRequest createProjectRequest) { //Validate request var createProjectCommand = new CreateProjectCommand(createProjectRequest); var res = await Mediator.Send(createProjectCommand); return(Ok(res)); }
public Option <SuccessResult, ErrorResult> Create(CreateProjectCommand command) { return(_createProjectCommandValidator .Validate(command) .OnSuccess(errorBuilder => { _projectRepository.Insert(_mapper.Create(command)); })); }
public async Task <IActionResult> CreateProject([FromBody] CreateProjectRequest createProjectRequest) { var createProjectCommand = new CreateProjectCommand(User, createProjectRequest); var createProjectResult = await _mediator.Send(createProjectCommand); return(createProjectResult.IsSuccess ? CreatedAtAction(nameof(GetDetails), createProjectResult.Value) : BadRequest(createProjectResult.Error)); }
public async void handle_Exception_test() { Project project = new Project() { Id = 1 }; ProjectCategory pc = new ProjectCategory(); ProjectResearcher pr = new ProjectResearcher(); OrganisationProject op = new OrganisationProject(); this._unitOfUnitMock.Setup(mock => mock.ProjectRepository.Create(It.IsAny <Project>())).Returns(project); this._unitOfUnitMock .Setup(mock => mock.RelationsRepository.CreateProjectCategory(It.IsAny <ProjectCategory>())).Returns(pc); this._unitOfUnitMock .Setup(mock => mock.RelationsRepository.CreateProjectResearcher(It.IsAny <ProjectResearcher>())) .Returns(pr); this._unitOfUnitMock.Setup(mock => mock.RelationsRepository.CreateOrganisationProject(It.IsAny <OrganisationProject>())).Throws(new Exception()); CreateProjectCommand command = new CreateProjectCommand( new CreateProjectModel() { ProjectName = "test", Categories = new List <Category>() { new Category() { CategoryId = 1, CategoryName = "test", Created = DateTime.Now, Id = 1 } }, ResearcherCategories = new List <ResearcherCategory>() { new ResearcherCategory() { Researcher = new Researcher() { Id = 1 }, Category = new Category() { Id = 1 } } }, Organisations = new List <Organisation>() { new Organisation() { Id = 1, } } }); CreateProjectHandler handler = new CreateProjectHandler(this._unitOfUnitMock.Object); var result = await handler.Handle(command, new CancellationTokenSource().Token); Assert.Null(result); }
public void Should_AssignCorrect_If_TypeOfProject_IsValid() { var expectedHandler = new CreateProjectHandler(mockUnitOfWork.Object); fakeCommand = new CreateProjectCommand(fakeDonor.Id, fakeAnalyst.Id, "acronym", "TaPackage", "fake", DateTime.UtcNow); expectedHandler.Execute(fakeCommand); fakeProjectAggregate.ProjectType.Should().Be(TypeOfProject.TaPackage); }
public async Task <ProjectGetResponseModel> Post([FromBody] CreateProjectCommand command, [FromHeader(Name = "X-Request-Id")] string?requestId) { requestId ??= Activity.Current?.Id ?? HttpContext.TraceIdentifier; var identifiedCommand = new IdentifiedCommand <CreateProjectCommand, ProjectGetResponseModel>(command, requestId); ProjectGetResponseModel result = await _mediator.Send(identifiedCommand); return(result); }
public void Should_AssignCorrect_If_TypeOfTender_IsValid() { var expectedHandler = new CreateProjectHandler(mockUnitOfWork.Object); fakeCommand = new CreateProjectCommand(fakeDonor.Id, fakeAnalyst.Id, "acronym", "fake", "NegotiatedProcedure", DateTime.UtcNow); expectedHandler.Execute(fakeCommand); fakeProjectAggregate.TenderProcessType.Should().Be(TypeOfTenderProcess.NegotiatedProcedure); }
public async Task <IActionResult> CreateProjectAsync([FromBody] Domain.AggregatesModel.Project project) { var command = new CreateProjectCommand() { Project = project }; var result = await _mediator.Send(command); return(Ok(result)); }
public async Task <IActionResult> CreatProject([FromBody] Zhengwei.Project.Domain.AggregatesModel.Project project) { var command = new CreateProjectCommand() { Project = project }; var pro = await _mediator.Send(command); return(Ok(pro)); }
public async Task <IActionResult> CreateProject([FromBody] CreateProjectCommand createProjectCommand) { var commandResult = await _projectCommandHandler.ExecuteAsync(createProjectCommand); if (commandResult.Success) { return(Ok(commandResult.Result)); } return(BadRequest(createProjectCommand)); }
public void Initialize() { // prepare the fakes fakeAnalyst = new Analyst("fake", "fake", "fake"); fakeDonor = new DonorAggregate("fake"); fakeCommand = new CreateProjectCommand(fakeDonor.Id, fakeAnalyst.Id, "acronym", "fake", "fake", DateTime.UtcNow); // initialize the mocks behaviour mockUnitOfWork = new Mock <IUnitOfWork>(); mockRepository = new Mock <IRepository>(); }
public ActionResult Create(CreateProjectCommand command) { if (!ModelState.IsValid) { return(View(command)); } command.CreatedByUserId = User.Identity.GetUserId(); PipelineService.HandleCommand(command); return(RedirectToAction("Index")); }
public async Task <IActionResult> CreateProject(CreateProjectCommand createProjectCommand) { await _mediator.Publish( new CreateProjectCommand { Key = createProjectCommand.Key.ToUpper(), Name = createProjectCommand.Name }); return(Ok()); }