public async Task <ResponseApi> Handle(CreateTeamCommand request, CancellationToken cancellationToken) { _logger.LogInformation($"Create Team : { JsonSerializer.Serialize(request)}"); try { var validate = request.Validate(_teamRepository); if (!validate.IsValid) { _logger.LogInformation($"ERROR - Create Team : { JsonSerializer.Serialize(validate.Errors.Select(x=> new { Campo = x.PropertyName, Erro = x.ErrorMessage }).ToList() )}"); return(new ResponseApi(false, "Erro ao inserir o time", validate.Errors.Select(x => new { Campo = x.PropertyName, Erro = x.ErrorMessage }).ToList())); } Team team = new Team(request.TeamName); await _teamRepository.Create(team); var response = new { Id = team.Id, TeamName = team.TeamName, isActive = team.IsActive }; _logger.LogInformation($"SUCCESS - Create Team : { JsonSerializer.Serialize(request)}"); return(new ResponseApi(true, "Time Inserido com Sucesso", response)); } catch (Exception e) { _logger.LogInformation($"ERROR - Create Team : { JsonSerializer.Serialize(e)}"); return(new ResponseApi(false, "Erro ao inserir o time", e.InnerException.ToString())); } }
public string Manage(TeamFeedModel feedModel) { IEnumerable <int> teamKeys = new List <int>() { feedModel.Key }; EntitiesByKeyQuery <Team> teamQuery = new EntitiesByKeyQuery <Team>(teamKeys); Team team = queryDispatcher.Dispatch <EntitiesByKeyQuery <Team>, IEnumerable <Team> >(teamQuery).FirstOrDefault(); if (team != null) { return(team.Id); } IEnumerable <int> sportKeys = new List <int>() { CommonConstants.ESPORT_KEY }; EntitiesByKeyQuery <Sport> sportQuery = new EntitiesByKeyQuery <Sport>(sportKeys); Sport sport = queryDispatcher.Dispatch <EntitiesByKeyQuery <Sport>, IEnumerable <Sport> >(sportQuery).First(); CreateTeamCommand teamCommand = Mapper.Map <CreateTeamCommand>(feedModel); teamCommand.SportId = sport.Id; return(commandDispatcher.Dispatch <CreateTeamCommand, string>(teamCommand)); }
public void ExecuteAllThreeMethodsOnce_WhenValidParametersArePassed() { //Arrange this.componentsFactoryMock .Setup(x => x.CreateTeam(this.validTeamName)) .Returns(this.teamMock.Object); var sut = new CreateTeamCommand(this.historyEventWriterMock.Object, personsCollectionMock.Object, this.componentsFactoryMock.Object); var parameters = new List <string>() { this.validTeamName }; //Act var returnMessage = sut.Execute(parameters); //Assert this.componentsFactoryMock.Verify(x => x.CreateTeam(this.validTeamName), Times.Once); this.personsCollectionMock.Verify(x => x.AddTeam(teamMock.Object), Times.Once); this.historyEventWriterMock. Verify(x => x.AddHistoryEvent( returnMessage, null, null, teamMock.Object, null ), Times.Once); }
public async Task Handle_GivenInvalidRequest_ShouldThrowPlayerDoesNotHaveALinkedSteamAccountException() { // Arrange var command = new CreateTeamCommand { Name = "ValidTeam", Description = "SomeDescriptionIDontKnow", TournamentFormatId = 2, TeamImage = It.IsAny <IFormFile>() }; var playersRepository = new EfDeletableEntityRepository <Player>(this.dbContext); var userAccessorMock = new Mock <IUserAccessor>(); userAccessorMock.Setup(x => x.UserId).Returns("Foo2"); var sut = new CreateTeamCommandHandler( It.IsAny <IDeletableEntityRepository <Team> >(), It.IsAny <IDeletableEntityRepository <TournamentFormat> >(), It.IsAny <IDeletableEntityRepository <PlayerTeam> >(), playersRepository, It.IsAny <ICloudinaryHelper>(), It.IsAny <IMapper>(), userAccessorMock.Object); // Act & Assert await Should.ThrowAsync <PlayerDoesNotHaveALinkedSteamAccountException>(sut.Handle(command, It.IsAny <CancellationToken>())); }
public async Task Should_ThrowException_When_PassInvalidUserId() { // Arrange IUnitOfWork unitOfWork = new UnitOfWork(_fixture.Context); IRepository <Team> repository = new Repository <Team>(_fixture.Context); IRepository <User> userRepository = new Repository <User>(_fixture.Context); var handler = new CreateTeamHandler(unitOfWork, repository, userRepository, _logger, _mapper); var request = new CreateTeamCommand(companyId: 1, userId: 1, "Test Team", members: new List <int>() { -11, 2 }, approvers: new List <int>() { 1 }); // Act var tcs = new CancellationToken(); // Assert var exception = await Assert.ThrowsAsync <VacationTrackingException>(async() => { var result = await handler.Handle(request, tcs); }); Assert.Equal(ExceptionMessages.InvalidUserId, exception.Message); Assert.Equal(400, exception.Code); }
public async Task <IActionResult> Create([FromBody] CreateTeamCommand command) { command.UserId = User.Identity.Name; await mediator.Send(command); return(Ok()); }
public async Task Should_ValidatorReturnFalse_When_EmptyApprover() { TeamCommandValidator validator = new TeamCommandValidator(); // Arrange IUnitOfWork unitOfWork = new UnitOfWork(_fixture.Context); IRepository <Team> repository = new Repository <Team>(_fixture.Context); IRepository <User> userRepository = new Repository <User>(_fixture.Context); var handler = new CreateTeamHandler(unitOfWork, repository, userRepository, _logger, _mapper); var request = new CreateTeamCommand(companyId: 1, userId: 1, "Test Team", members: new List <int>() { 1, 2 }, approvers: new List <int>() { 1 }); // Act var result = await validator.ValidateAsync(request); //Assert Assert.True(result.IsValid); }
public async Task Should_CreateTeam_When_PassValidParameters() { // Arrange IUnitOfWork unitOfWork = new UnitOfWork(_fixture.Context); IRepository <Team> repository = new Repository <Team>(_fixture.Context); IRepository <User> userRepository = new Repository <User>(_fixture.Context); var handler = new CreateTeamHandler(unitOfWork, repository, userRepository, _logger, _mapper); var request = new CreateTeamCommand(companyId: 1, userId: 1, "Test Team", members: new List <int>() { 1, 2 }, approvers: new List <int>() { 1 }); // Act var tcs = new CancellationToken(); var result = await handler.Handle(request, tcs); // Assert Assert.Equal("Test Team", result.TeamName); Assert.Equal(2, result.TeamMembers.Count(x => x.IsMember)); Assert.Equal(1, result.TeamMembers.Count(x => x.IsApprover)); Assert.Equal(1, result.CreatedBy); }
public IActionResult CreateTeam([FromBody] TeamModel teamModel) { var command = new CreateTeamCommand(teamModel); CommandDispatcher.Handle(command); return(Ok()); }
public async Task Handle(CreateTeamCommand command) { Team team = new Team(command.Id, command.Year, command.TeamCode, command.League, command.Home, command.Name); await _session.Add(team); await _session.Commit(); }
public async Task <CommandResponse> ExecuteAsync(CreateTeamCommand command) { // map team TeamRepository teamRepository = unitOfWork.GetRepository <Team, TeamRepository>(); Team team = mapper.Map <Team>(command.CreateTeamDTO); // insert bool insertingStatus = false; string message = "Team created"; try { insertingStatus = await teamRepository.InsertAsync(team); await unitOfWork.SaveAsync(); } catch (System.Exception e) { insertingStatus = false; message = Common.Algorithms.GetFullText(e); } // result return(new CommandResponse { IsSucessed = insertingStatus, Message = message }); }
public void MapCreateTeamRequestShouldSucceed() { // Arrange var name = "Test"; var image = "Image"; var description = "Descriptor"; var layout = Guid.NewGuid().ToString(); var apiVersion = "1.0"; // Act var request = new CreateTeamRequest(new CreateTeamFromQuery() { ApiVersion = apiVersion }, new CreateTeamFromBody() { Name = name, Image = image, Description = description, Layout = layout }); var command = new CreateTeamCommand(name, image, description, layout); var mappedCommand = _cqsMapper.Map(request); // Assert command.Should().BeEquivalentTo(mappedCommand); }
public async Task Handle(CreateTeamCommand message) { var team = _dataMapper.Map <Team>(message.Team); var createdTeam = await _repository.AddAsync(team); await _bus.RaiseEvent(new TeamCreatedEvent(_dataMapper.Map <TeamDto>(team))); }
public async Task <IActionResult> Create() { var viewModel = new CreateTeamCommand { Formats = await this.Mediator.Send(new GetAllTournamentFormatsSelectListQuery()) }; return(this.View(viewModel)); }
public CreateTeamCommand Map(CreateTeamRequest request) { var command = new CreateTeamCommand(request.Name, request.Image, request.Description, request.Layout); return(command); }
public void ThrowWhen_NoOtherTeams() { //Arrange var fakeProvider = new FakeTeamProvider(); var list = new List <string>(); var sut = new CreateTeamCommand(list, fakeProvider); //Act & Assert Assert.ThrowsException <ArgumentException>(() => sut.Execute()); }
public void Execute_Less_Params_ThrowEx() { var fakeProvider = new FakeTeamProvider(); var listParams = new List <string>(); var sut = new CreateTeamCommand(listParams, fakeProvider); //Act & Assert Assert.ThrowsException <ArgumentException>(() => sut.Execute(), "Parameters count is not valid!"); }
public void CreateTeam_Successfully() { var factory = new Mock <IFactory>(); var result = new CreateTeamCommand(new List <string>() { "Team5" }, database, factory.Object).Execute(); Assert.AreEqual("Created team: 'Team5'.", result); }
public async Task <ActionResult> AddTeamAsync( [FromRoute] Guid squadId, [FromBody] CreateTeamCommand createTeamCommand, CancellationToken cancellationToken) { createTeamCommand.SquadId = squadId; await _squadHandler.CreateTeamAsync(createTeamCommand, cancellationToken); return(Ok()); }
public void ThrowExceptionWithInvalidParameters() { var factoryMock = new Mock <IFactory>(); var dbMock = new Mock <IDataBase>(); var sut = new CreateTeamCommand(factoryMock.Object, dbMock.Object); Assert.ThrowsException <ArgumentException> (() => sut.Execute(new List <string> { })); }
public void Handle(CreateTeamCommand command) { // TODO validate using (var dbContext = new ManagementDataContext()) { Team team = CreateTeamEntity(command); dbContext.Teams.Add(team); dbContext.SaveChanges(); } }
public void IsValid_ShouldBeTrue_WhenNameIsNotNull() { var command = new CreateTeamCommand { Name = "Not Null < 200 byte" }; var validator = new CreateTeamCommandValidator(); var result = validator.Validate(command); result.IsValid.ShouldBe(true); }
public async Task <IActionResult> Create(CreateTeamCommand command) { if (!this.ModelState.IsValid) { command.Formats = await this.Mediator.Send(new GetAllTournamentFormatsSelectListQuery()); return(this.View(command)); } var teamId = await this.Mediator.Send(command); return(this.RedirectToAction(nameof(Details), new { Id = teamId })); }
public async Task CreateTeamAsync( CreateTeamCommand createTeamCommand, CancellationToken cancellationToken) { var squad = await _teamDomainService.CreateTeamAsync(createTeamCommand.Name, createTeamCommand.TeamOwnerId, createTeamCommand.SquadId, createTeamCommand.Description, cancellationToken); _squadRepository.Update(squad); await _squadRepository.SaveAsync(cancellationToken); }
public void IsValid_ShouldBeFalse_WhenNameIsNull() { var command = new CreateTeamCommand { Name = null }; var validator = new CreateTeamCommandValidator(); var result = validator.Validate(command); result.IsValid.ShouldBe(false); }
public async Task <ActionResult> CreateNewTeam([FromBody] CreateTeamCommand cteateTeam) { var result = await _mediator.Send(cteateTeam); if (result) { return(Ok(new HttpResponse { Code = 200 })); } return(Ok(new HttpResponse { Code = 201, Message = "Create Failed" })); }
public async Task Should_ThrowException_When_PassExistingTeamName() { // Arrange var team = new Team() { TeamName = "Test Team", CompanyId = 1, CreatedAt = DateTime.UtcNow, CreatedBy = -1 }; team.TeamMembers.Add(new TeamMember() { IsApprover = true, IsMember = true, UserId = 1 }); _fixture.Context.Teams.Attach(team); await _fixture.Context.SaveChangesAsync(); IUnitOfWork unitOfWork = new UnitOfWork(_fixture.Context); IRepository <Team> repository = new Repository <Team>(_fixture.Context); IRepository <User> userRepository = new Repository <User>(_fixture.Context); var handler = new CreateTeamHandler(unitOfWork, repository, userRepository, _logger, _mapper); var request = new CreateTeamCommand(companyId: 1, userId: 1, "Test Team", members: new List <int>() { 1, 2 }, // UserId: 3 belongs to companyId: 1 approvers: new List <int>() { 1 }); // Act var tcs = new CancellationToken(); // Assert var exception = await Assert.ThrowsAsync <VacationTrackingException>(async() => { var result = await handler.Handle(request, tcs); }); Assert.Equal(ExceptionMessages.TeamNameAlreadyExist, exception.Message); Assert.Equal(400, exception.Code); }
public async Task <IActionResult> CreateAsync( [Required] CreateTeamCommand createTeamCommand) { var response = await _mediator.Send(createTeamCommand); if (response) { return(new OkResult()); } else { return(BadRequest()); } }
public async Task <ActionResult> CreateAsync([FromBody] CreateTeamCommand createTeamCommand) { try { Team createdTeam = await _createTeamCommandHandler .HandleAsync(createTeamCommand) .ConfigureAwait(false); return(CreatedAtAction(nameof(GetById), new { id = createdTeam.Id }, createdTeam)); } catch (EntityAlreadyExistsException exception) { return(Conflict(exception.Message)); } }
public async Task <ActionResult> CreateTeamAysnc([FromBody] CreateTeamCommand request) { try { request.SetUser(User.GetUserId()); var response = await _mediator.Send(request); return(Ok(response)); } catch (Exception ex) { _logger.Error(ex, $"Operation failed into controller {Routes.Create_Team} with message: {ex.Message}"); return(BadRequest(ex.Message)); } }