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