public string Manage(MatchFeedModel feedModel, string tournamentId, string homeTeamId, string awayTeamId)
{
IEnumerable <int> keys = new List <int>()
{
feedModel.Key
};
EntitiesByKeyQuery <Match> matchQuery = new EntitiesByKeyQuery <Match>(keys);
Match match = queryDispatcher.Dispatch <EntitiesByKeyQuery <Match>, IEnumerable <Match> >(matchQuery).FirstOrDefault();
if (match != null)
{
UpdateMatchCommand updateCommand = Mapper.Map <UpdateMatchCommand>(feedModel);
updateCommand.Id = match.Id;
return(commandDispatcher.Dispatch <UpdateMatchCommand, string>(updateCommand));
}
CreateMatchCommand createCommand = Mapper.Map <CreateMatchCommand>(feedModel);
createCommand.TournamentId = tournamentId;
createCommand.HomeTeamId = homeTeamId;
createCommand.AwayTeamId = awayTeamId;
return(commandDispatcher.Dispatch <CreateMatchCommand, string>(createCommand));
}
public async Task <IActionResult> CreateMatch([FromBody] CreateMatchCommand command)
{
command.UserId = UserId;
var created = await Mediator.Send(command);
return(Ok(created));
}
public async Task <MatchModel> CreateMatch([FromBody] CreateMatchCommand command)
{
if (command == null)
{
throw new ArgumentException(nameof(command));
}
return(await matchService.CreateMatch(command));
}
private async Task AddMatch(MatchResponse match, TeamDto homeTeam, TeamDto awayTeam)
{
var date = TryParseDate(match.dateEvent, match.strTime);
var score = Score.CreateNew("Placeholder", TryParseInt(match.intHomeScore), TryParseInt(match.intAwayScore));
var command = new CreateMatchCommand(match.strEvent, homeTeam.Id, awayTeam.Id, date.GetValueOrDefault(), "Placeholder",
score, match.strSeason,
match.idEvent);
await CommandsExecutor.Execute(command);
}
public void ShouldMatchCommandHaveNotEmptyValues()
{
//Arrange
var command = new CreateMatchCommand
{
AwayTeam = new List <int>(),
HouseTeam = new List <int>(),
};
//Assert
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <ValidationException>();
}
public void Handle(ResetDbCommand message)
{
// 1. Clear the relational DB used to track scheduled matches
_repository.ResetDb();
// 2. Places two commands to create new matches against MatchSaga
var cmd1 = new CreateMatchCommand("WP0001", "Frogs", "Sharks");
EventBus.Send(cmd1);
var cmd2 = new CreateMatchCommand("WP0002", "Sharks", "Eels");
EventBus.Send(cmd2);
}
public async Task Handle_GivenInvalidRequest_ShouldThrowForbiddenException()
{
// Arrange
var teamsRepository = new EfDeletableEntityRepository <Team>(this.dbContext);
var playWeeksRepository = new EfDeletableEntityRepository <PlayWeek>(this.dbContext);
var command = new CreateMatchCommand {
HomeTeamId = 1, AwayTeamId = 4, PlayWeekId = 1, PlayDate = new DateTime(2019, 08, 15), TournamentTableId = 1
};
var sut = new CreateMatchCommandHandler(this.deletableEntityRepository, teamsRepository, playWeeksRepository);
// Act & Assert
await Should.ThrowAsync <ForbiddenException>(sut.Handle(command, It.IsAny <CancellationToken>()));
}
public async System.Threading.Tasks.Task CreateMatchWithValidInputReturnSuccessTestAsync()
{
//Arrange
Mock <IRepository <Domain.MainBoundleContext.Match> > matchMoqRepository = new Mock <IRepository <Domain.MainBoundleContext.Match> >();
matchMoqRepository.Setup(m => m.InsertAtomic(It.IsAny <Domain.MainBoundleContext.Match>()))
.Verifiable();
Mock <IRepository <Manager> > managerMoqRepository = new Mock <IRepository <Manager> >();
managerMoqRepository.Setup(m => m.GetByID(It.IsAny <int>()))
.Returns(new Manager
{
Id = 3,
Name = "Test",
});
Mock <IRepository <Referee> > refereeMoqRepository = new Mock <IRepository <Referee> >();
refereeMoqRepository.Setup(m => m.GetByID(It.IsAny <int>()))
.Verifiable();
Mock <IRepository <Player> > playerMoqRepository = new Mock <IRepository <Player> >();
playerMoqRepository.Setup(m => m.Get(It.IsAny <bool>()))
.Verifiable();
Mock <IRepository <PlayerMatch> > playerMatchMoqRepository = new Mock <IRepository <PlayerMatch> >();
playerMatchMoqRepository.Setup(m => m.Insert(It.IsAny <PlayerMatch>()))
.Verifiable();
var moqUnitOfWork = new Mock <IUnitOfWork>();
moqUnitOfWork.Setup(uow => uow.MatchRepository).Returns(matchMoqRepository.Object);
moqUnitOfWork.Setup(uow => uow.ManagerRepository).Returns(managerMoqRepository.Object);
moqUnitOfWork.Setup(uow => uow.RefereeRepository).Returns(refereeMoqRepository.Object);
moqUnitOfWork.Setup(uow => uow.PlayerRepository).Returns(playerMoqRepository.Object);
moqUnitOfWork.Setup(uow => uow.PlayerMatchRepository).Returns(playerMatchMoqRepository.Object);
var createMatchCommand = new CreateMatchCommand();
var createMatchCommandHandler = new CreateMatchCommandHandler(moqUnitOfWork.Object);
// Act
await createMatchCommandHandler.Handle(createMatchCommand, CancellationToken.None);
//Assert
matchMoqRepository.Verify(m => m.InsertAtomic(It.IsAny <Domain.MainBoundleContext.Match>()), Times.Once,
"CreateAsync must be called only once");
moqUnitOfWork.Verify(m => m.Commit(), Times.Once, "Commit must be called only once");
}
public async Task <IActionResult> Create(CreateMatchCommand command)
{
if (!this.ModelState.IsValid)
{
var notValidViewModel = await this.Mediator.Send(new GetMatchesForPlayWeekQuery { PlayWeekId = command.PlayWeekId });
return(this.View("~/Areas/Administration/Views/MatchFixtures/Details.cshtml", notValidViewModel));
}
var viewModel = await this.Mediator.Send(command);
return(this.RedirectToAction(nameof(Details), new GetMatchesForPlayWeekQuery {
PlayWeekId = command.PlayWeekId
}));
}
public async Task Handle_GivenValidRequest_ShouldCreateMatch()
{
// Arrange
var teamsRepository = new EfDeletableEntityRepository <Team>(this.dbContext);
var playWeeksRepository = new EfDeletableEntityRepository <PlayWeek>(this.dbContext);
var command = new CreateMatchCommand {
HomeTeamId = 1, AwayTeamId = 5, PlayWeekId = 1, PlayDate = new DateTime(2019, 08, 15), TournamentTableId = 1
};
var sut = new CreateMatchCommandHandler(this.deletableEntityRepository, teamsRepository, playWeeksRepository);
// Act
var matchId = await sut.Handle(command, It.IsAny <CancellationToken>());
// Assert
matchId.ShouldBeGreaterThan(0);
var createdMatch = this.dbContext.Matches.SingleOrDefault(x => x.ScheduledDate == new DateTime(2019, 08, 15));
createdMatch.HomeTeamId.ShouldBe(1);
}
public async Task <MatchModel> CreateMatch(CreateMatchCommand command)
{
Player winner = await playersApiClient.GetPlayer(command.WinnerId);
Player loser = await playersApiClient.GetPlayer(command.LoserId);
PlayersRatings ratings = await ratingApiClient.CalculatePlayersRatings(RatingMapper.Map(winner, loser));
UpdatePlayerRequest updateWinnerRequest = new UpdatePlayerRequest(winner.Id, winner.Name, ratings.WinnerRating.Rating, ratings.WinnerRating.Deviation, ratings.WinnerRating.Volatility);
winner = await playersApiClient.UpdatePlayer(updateWinnerRequest);
UpdatePlayerRequest updateLoserRequest = new UpdatePlayerRequest(loser.Id, loser.Name, ratings.LoserRating.Rating, ratings.LoserRating.Deviation, ratings.LoserRating.Volatility);
loser = await playersApiClient.UpdatePlayer(updateLoserRequest);
CreateMatchRequest createMatchRequest = new CreateMatchRequest(winner.Id, loser.Id, command.Score);
Match match = await matchesApiClient.CreateMatch(createMatchRequest);
return(MatchMapper.Map(match, new List <Player> {
winner, loser
}));
}
public async Task <ActionResult> CreateMatch([FromBody] CreateMatchCommand command)
{
var matchId = await _commandHandler.CreateMatch(command);
return(Created($"{Request.Scheme}://{Request.Host}/Api/Matches/{matchId}", matchId));
}
public async Task <ActionResult <int> > Create(CreateMatchCommand command)
{
return(await Mediator.Send(command));
}
public async Task <IActionResult> Create([FromBody] CreateMatchCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public async Task <Response <int> > Post([FromBody] CreateMatchCommand command)
{
return(await Mediator.Send(command));
}
