private void ValidateGameInTournament(Game game, TournamentScheduleDto tournamentScheduleInfo)
{
if (tournamentScheduleInfo == null)
{
throw new ArgumentException(Resources.NoSuchToruanment);
}
var allGamesInTournament = QueryAllTournamentGames(game.TournamentId);
var oldGameToUpdate = allGamesInTournament.Where(gr => gr.Id == game.Id).SingleOrDefault();
if (oldGameToUpdate != null)
{
allGamesInTournament.Remove(oldGameToUpdate);
}
PutFreeDayTeamAsAway(game);
ValidateGameDateSet(game);
ValidateGameDate(tournamentScheduleInfo, game);
ValidateGameInRound(game, allGamesInTournament, tournamentScheduleInfo);
if (tournamentScheduleInfo.Scheme == TournamentSchemeEnum.One)
{
ValidateGamesInTournamentSchemeOne(game, allGamesInTournament);
}
else if (tournamentScheduleInfo.Scheme == TournamentSchemeEnum.Two)
{
ValidateGamesInTournamentSchemeTwo(game, allGamesInTournament);
}
}
private List <Game> GetGamesToSchedule(Game finishedGame, TournamentScheduleDto torunamentScheduleInfo)
{
List <Game> gamesToUpdate = new List <Game>();
List <Game> gamesInCurrentAndNextRounds = _gamesByTournamentIdInRoundsByNumbersQuery
.Execute(new GamesByRoundCriteria()
{
TournamentId = torunamentScheduleInfo.Id,
RoundNumbers = new List <byte>
{
finishedGame.Round,
Convert.ToByte(finishedGame.Round + 1)
}
});
// Schedule next games only if finished game is not in last round
if (!IsGameInLastRound(finishedGame, gamesInCurrentAndNextRounds))
{
Game oldGame = gamesInCurrentAndNextRounds.Where(gr => gr.Id == finishedGame.Id).SingleOrDefault();
gamesToUpdate.AddRange(GetGamesToUpdate(finishedGame, gamesInCurrentAndNextRounds));
if (finishedGame.AwayTeamId.HasValue &&
finishedGame.Result.GameScore.Home == 0 &&
finishedGame.Result.GameScore.Away == 0)
{
foreach (Game game in gamesToUpdate)
{
ClearGame(finishedGame, game);
}
}
}
return(gamesToUpdate);
}
/// <summary>
/// Edits result of specified instance of game.
/// </summary>
/// <param name="game">Game which result have to be to update.</param>
public void EditGameResult(Game game)
{
_authService.CheckAccess(AuthOperations.Games.EditResult);
ValidateResult(game.Result);
TournamentScheduleDto tournamentScheduleInfo = _tournamentScheduleDtoByIdQuery
.Execute(new TournamentScheduleInfoCriteria {
TournamentId = game.TournamentId
});
ValidateGame(game, tournamentScheduleInfo);
// Add autogeneration
if (tournamentScheduleInfo.Scheme == TournamentSchemeEnum.PlayOff)
{
ScheduleNextGames(game, tournamentScheduleInfo);
}
try
{
_gameRepository.Update(game);
}
catch (ConcurrencyException ex)
{
throw new MissingEntityException(ServiceResources.ExceptionMessages.GameNotFound, ex);
}
UpdateTournamentLastTimeUpdated(game);
_gameRepository.UnitOfWork.Commit();
}
private static string GetRoundName(int roundNumber, TournamentScheduleDto tournament)
{
string result;
if (tournament.Scheme != TournamentSchemeEnum.PlayOff)
{
result = $"Тур {roundNumber}";
}
else
{
var playoffRounds = new Dictionary <int, string>
{
[1] = "Финал",
[2] = "Полуфинал",
[3] = "Четверть-финал",
[4] = "Раунд 16",
[5] = "Раунд 32",
[6] = "Раунд 64",
[7] = "Раунд 128"
};
var reversedRoundNumber = tournament.Divisions.First().NumberOfRounds - roundNumber + 1;
if (!playoffRounds.TryGetValue(reversedRoundNumber, out result))
{
result = $"Тур {roundNumber}";
}
}
return(result);
}
/// <summary>
/// Creates a new game.
/// </summary>
/// <param name="game">Game to create.</param>
public void Create(Game game)
{
_authService.CheckAccess(AuthOperations.Games.Create);
if (game == null)
{
throw new ArgumentNullException("game");
}
if (game.Result != null)
{
ValidateResult(game.Result);
}
TournamentScheduleDto tournamentScheduleInfo = _tournamentScheduleDtoByIdQuery
.Execute(new TournamentScheduleInfoCriteria {
TournamentId = game.TournamentId
});
ValidateGame(game, tournamentScheduleInfo);
if (game.Result != null)
{
UpdateTournamentLastTimeUpdated(game);
}
else
{
// Set default empty result
game.Result = new Result();
}
_gameRepository.Add(game);
_gameRepository.UnitOfWork.Commit();
}
private static void ValidateAreSameTeamsInGames(
GameResultDto game,
Game newGame,
TournamentScheduleDto tournamentScheduleInfo)
{
string errorMessage = null;
if (GameValidation.IsFreeDayGame(newGame))
{
if (tournamentScheduleInfo.Scheme != TournamentSchemeEnum.PlayOff)
{
errorMessage = Resources.SameFreeDayGameInRound;
}
else
{
errorMessage = string.Format(
Resources.SameTeamInRound,
game.HomeTeamId);
}
}
else
{
errorMessage = String.Format(
Resources.SameGameInRound,
game.HomeTeamName,
game.AwayTeamName,
game.Round.ToString());
}
throw new ArgumentException(errorMessage);
}
private void ValidateGameInRound(Game newGame, ICollection <GameResultDto> games,
TournamentScheduleDto tournamentSсheduleInfo)
{
var teamsInTournament =
_tournamentTeamsQuery.Execute(new FindByTournamentIdCriteria
{
TournamentId = tournamentSсheduleInfo.Id
});
var newGameDivisionId = (int?)0;
if (IsNotPlayOffThemeAndBothTeamsNotNull(newGame, tournamentSсheduleInfo))
{
newGameDivisionId = teamsInTournament
.First(t => t.TeamId == newGame.AwayTeamId || t.TeamId == newGame.HomeTeamId).DivisionId;
}
var gamesInSameRoundSameDivision = (
from game in games
where game.Round == newGame.Round
join homeTeam in teamsInTournament
on game.HomeTeamId equals homeTeam.TeamId
where homeTeam.DivisionId == newGameDivisionId
join awayTeam in teamsInTournament
on game.HomeTeamId equals awayTeam.TeamId
where awayTeam.DivisionId == newGameDivisionId
select game
).ToList();
ValidateGameInRoundOnCreate(
newGame,
gamesInSameRoundSameDivision,
tournamentSсheduleInfo);
}
private void ValidateGameDate(TournamentScheduleDto tournament, Game game)
{
if (DateTime.Compare(tournament.StartDate, game.GameDate.Value) > 0 ||
DateTime.Compare(tournament.EndDate, game.GameDate.Value) < 0)
{
throw new ArgumentException(Resources.WrongRoundDate);
}
}
private void ScheduleNextGames(Game finishedGame, TournamentScheduleDto tournamentScheduleInfo)
{
List <Game> gamesToUpdate = GetGamesToSchedule(finishedGame, tournamentScheduleInfo);
foreach (Game nextGame in gamesToUpdate)
{
_gameRepository.Update(nextGame);
}
}
private void ValidateTeams(int?homeTeamId, int?awayTeamId, TournamentScheduleDto tournamentScheduleInfo)
{
if (tournamentScheduleInfo.Scheme == TournamentSchemeEnum.PlayOff)
{
if (!(homeTeamId == null && awayTeamId == null) &&
GameValidation.AreTheSameTeams(homeTeamId, awayTeamId))
{
throw new ArgumentException(Resources.GameResultSameTeam);
}
}
else if (GameValidation.AreTheSameTeams(homeTeamId, awayTeamId))
{
throw new ArgumentException(Resources.GameResultSameTeam);
}
}
private static void ValidateGameInRoundOnCreate(
Game newGame,
List <GameResultDto> gamesInRound,
TournamentScheduleDto tournamentScheduleInfo)
{
// We are sure that newGame is been created, not edited
foreach (GameResultDto game in gamesInRound)
{
if (GameValidation.AreSameTeamsInGames(game, newGame))
{
ValidateAreSameTeamsInGames(game, newGame, tournamentScheduleInfo);
}
else if (GameValidation.IsTheSameTeamInTwoGames(game, newGame))
{
ValidateIsTheSameTeamInTwoGames(game, newGame, tournamentScheduleInfo);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TournamentScheduleDtoBuilder"/> class
/// </summary>
public TournamentScheduleDtoBuilder()
{
_tournamentScheduleDto = new TournamentScheduleDto()
{
Id = DEFAULT_ID,
Name = "Tour1",
Scheme = TournamentSchemeEnum.One,
Divisions = new List <DivisionScheduleDto>
{
new DivisionScheduleDto
{
DivisionId = 1,
DivisionName = "First division",
TeamCount = 3
}
},
StartDate = DateTime.Parse(TEST_START_DATE),
EndDate = DateTime.Parse(TEST_END_DATE)
};
}
private static void ValidateAreSameTeamsInGames(
GameResultDto game,
Game newGame,
TournamentScheduleDto tournamentScheduleInfo)
{
string errorMessage = null;
var tmpres = (tournamentScheduleInfo.Scheme !=
TournamentSchemeEnum.PlayOff
? Resources.SameFreeDayGameInRound
: string.Format(
Resources.SameTeamInRound,
game.HomeTeamId));
errorMessage = GameValidation.IsFreeDayGame(newGame)
? tmpres
: string.Format(
Resources.SameGameInRound,
game.HomeTeamName,
game.AwayTeamName,
game.Round.ToString());
throw new ArgumentException(errorMessage);
}
/// <summary>
/// Edits specified instance of game.
/// </summary>
/// <param name="game">Game to update.</param>
public void Edit(Game game)
{
_authService.CheckAccess(AuthOperations.Games.Edit);
TournamentScheduleDto tournamentScheduleInfo = _tournamentScheduleDtoByIdQuery
.Execute(new TournamentScheduleInfoCriteria {
TournamentId = game.TournamentId
});
ValidateGame(game, tournamentScheduleInfo);
// Add autogeneration
if (tournamentScheduleInfo.Scheme == TournamentSchemeEnum.PlayOff &&
(game.Result != null || game.AwayTeamId == null))
{
ScheduleNextGames(game, tournamentScheduleInfo);
}
// Provide persisting results in case of editing dates
var existingGame = Get(game.Id);
var gameHasResults = existingGame != null && existingGame.Result.SetScores.Any(s => !s.IsEmpty);
if (gameHasResults)
{
game.Result = existingGame.Result;
}
try
{
_gameRepository.Update(game);
}
catch (ConcurrencyException ex)
{
throw new MissingEntityException(ServiceResources.ExceptionMessages.GameNotFound, ex);
}
_gameRepository.UnitOfWork.Commit();
}
private static void ValidateIsTheSameTeamInTwoGames(
GameResultDto game,
Game newGame,
TournamentScheduleDto tournamentScheduleInfo)
{
if (tournamentScheduleInfo.Scheme == TournamentSchemeEnum.PlayOff)
{
return;
}
if (GameValidation.IsFreeDayGame(newGame))
{
if (game.HomeTeamId != newGame.HomeTeamId &&
game.AwayTeamId != newGame.HomeTeamId)
{
throw new ArgumentException(Resources.SameFreeDayGameInRound);
}
else if (game.HomeTeamId != newGame.HomeTeamId ||
game.AwayTeamId != newGame.HomeTeamId)
{
throw new ArgumentException(string.Format(
Resources.SameTeamInRound,
(game.HomeTeamId == newGame.HomeTeamId)
? game.HomeTeamName
: game.AwayTeamName));
}
}
else
{
throw new ArgumentException(string.Format(
Resources.SameTeamInRound,
(game.HomeTeamId == newGame.HomeTeamId ||
game.HomeTeamId == newGame.AwayTeamId)
? game.HomeTeamName
: game.AwayTeamName));
}
}
private void MockGetScheduleInfo(int tournamentId, TournamentScheduleDto tournament)
{
_tournamentServiceMock.Setup(tr => tr.GetTournamentScheduleInfo(tournamentId)).Returns(tournament);
}
private void ValidateGame(Game game, TournamentScheduleDto tournamentScheduleInfo)
{
ValidateTeams(game.HomeTeamId, game.AwayTeamId, tournamentScheduleInfo);
ValidateGameInTournament(game, tournamentScheduleInfo);
}
private static bool IsNotPlayOffThemeAndBothTeamsNotNull(Game newGame, TournamentScheduleDto tournamentSсheduleInfo)
{
return(!(newGame.AwayTeamId == null &&
newGame.HomeTeamId == null &&
tournamentSсheduleInfo.Scheme == TournamentSchemeEnum.PlayOff));
}
