public async Task <bool> IsSatisfiedBy(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
if (request.UpdatePlayerCompetitionStatistics)
{
var match = await context.Fixture.GetMatch(request.MatchID);
return(context.Competition.PlayerMeritTableCalculationEngineID.HasValue && match.IsMatchProcessedWithResult());
}
return(false);
}
public async Task <bool> IsSatisfiedBy(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
if (context.PlayerFixture.IsComplete())
{
this._pendingFixtures = await this._playerFixtureRepository.GetPendingFixtures(context.PlayerFixture.Data.ID);
return(this._pendingFixtures.Count > 0);
}
return(false);
}
public async Task <bool> IsSatisfiedBy(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
if (request.UpdatePlayerCompetitionStatistics)
{
var leagueEvent = context.CompetitionEvent as League;
if (leagueEvent == null)
{
throw new InvalidResultsEngineOperationException("Invalid type specified for loaded competition event");
}
var match = await context.Fixture.GetMatch(request.MatchID);
return(leagueEvent.MeritCalculationEngineID.HasValue && match.IsMatchProcessedWithResult());
}
return(false);
}
public async Task <bool> IsSatisfiedBy(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
RuleSetXRule rule = await context.GetRuleSpecification(Entities.Rule.Rules.CheckMaximumGamesForHigherRankedTeamAnyCompetition);
return(rule != null);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var matchModel = await context.Fixture.GetMatch(request.MatchID);
foreach (var teamMatchXGame in matchModel.Data.Games)
{
foreach (var gameXPlayer in teamMatchXGame.Game.Players)
{
var dto = new CareerPlayerStatisticData();
dto.CompetitionID = context.Competition.ID;
dto.CompetitionStageID = matchModel.Data.TeamFixture.CompetitionRound.CompetitionEvent.CompetitionStage.ID;
dto.Game = gameXPlayer;
dto.TeamMatch = matchModel.Data;
await this._careerPlayerStatisticService.Add(dto);
}
}
return(ResultsEngineStatuses.Success);
}
public async Task <bool> IsSatisfiedBy(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var match = await context.Fixture.GetMatch(request.MatchID);
return(match.IsMatchProcessedWithResult() && request.UpdateCareerStatistics);
}
public Task <bool> IsSatisfiedBy(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
return(Task.FromResult(context.PlayerFixture.IsComplete() && context.PlayerFixture.Data.CompetitionRound.CompetitionRoundTypeID == CompetitionRoundTypes.Final));
}
public async Task <bool> IsSatisfiedBy(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
RuleSetXRule rule = await context.GetRuleSpecification(Entities.Rule.Rules.CheckTiedToTeam);
return(rule != null);
}
public Task <bool> IsSatisfiedBy(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
bool result = !context.Fixture.IsMatchProcessed(request.MatchID);
return(Task.FromResult(result));
}
public List <Tuple <int, BowlsResults.Common.Domain.Entities.Team> > GetAllPlayersWithTeam(IGameResults gameResults, ITeamMatchModel matchModel)
{
if (this._gameResultPlayersWithTeam == null)
{
this._gameResultPlayersWithTeam = gameResults.GameResults.SelectAllPlayersWithTeam(matchModel.Data);
}
return(this._gameResultPlayersWithTeam);
}
public async Task <ResultsEngineStatuses> Process(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
bool ok = true;
if (request.GameResults != null && request.GameResults.Count > 0)
{
var matchModel = await context.PlayerFixture.GetMatch(request.MatchID);
var competition = context.Competition;
var validationContext = new ValidationContext <List <GameResult> >(request.GameResults);
validationContext.RootContextData.Add("match", matchModel.Data);
validationContext.RootContextData.Add("gameCalculationEngineRepository", this._gameCalculationEngineRepository);
var result = await this._gameResultsValidator.ValidateAsync(validationContext);
response.SetValidationResult(result);
// HashSet<int> homePlayers = new HashSet<int>();
// HashSet<int> awayPlayers = new HashSet<int>();
//
// homePlayers.UnionWith(request.GameResults.SelectMany(x => x.HomePlayers.Where(y => y > 0)));
// awayPlayers.UnionWith(request.GameResults.SelectMany(x => x.AwayPlayers.Where(y => y > 0)));
//
// //foreach (var gameResult in request.GameResults)
// {
// if (!homePlayers.SequenceEqual(matchModel.Data.Home.GetPlayerIDs()))
// {
// response.ValidationResult.Errors.Add(new ValidationFailure(nameof(homePlayers),
// "Home players are different to the entrant players on the match."));
// ok = false;
// }
//
// if (!awayPlayers.SequenceEqual(matchModel.Data.Away.GetPlayerIDs()))
// {
// response.ValidationResult.Errors.Add(
// new ValidationFailure(nameof(awayPlayers), "Away players are different to the entrant players on the match"));
// ok = false;
// }
// }
}
if (response.ValidationResult.IsValid)
{
return(ResultsEngineStatuses.Success);
}
return(ResultsEngineStatuses.UnknownError);
}
public Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var processors = new List <IProcessor <ITeamResultEngineContext, IGameResults, ResultsEngineResponse> >();
processors.Add(this._singleClubRuleProcessor);
processors.Add(this._singleTeamRuleProcessor);
processors.Add(this._singleGamePerMatchGameNumber);
processors.Add(this._checkTiedToTeam);
processors.Add(this._checkMaximumGamesForHigherRankedTeamPerCompetitionProcessor);
processors.Add(this._checkMaximumGamesForHigherRankedCompetitionProcessor);
processors.Add(this._checkMaximumGamesForHigherRankedTeamAnyCompetition);
this._processorExecutor.Execute(context, request, response, processors, true);
return(ResultEngineStatusMapper.MapFromValidationResult(response.ValidationResult));
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var ok = true;
RuleSetXRule rule = await context.GetRuleSpecification(Entities.Rule.Rules.SingleTeam);
ITeamMatchModel match = await context.Fixture.GetMatch(request.MatchID);
var statistics = await context.GetCompetitionPlayerGameStatistic(request, match);
var allPlayers = context.GetAllPlayersWithTeam(request, match);
foreach (var(playerID, team) in allPlayers)
{
var otherTeam = statistics.FirstOrDefault(x => x.PlayerID == playerID && x.Team.ID != team.ID);
if (otherTeam != null)
{
var player = context.GetPreloadedPlayer(playerID);
response.ValidationResult.Errors.Add(new ValidationFailure($"SingleTeamPlayer{playerID}", $"{player.DisplayName} has already played for and is tied to {otherTeam.Team.Name}."));
ok = false;
}
}
return(ResultEngineStatusMapper.MapFromBool(ok));
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var ok = true;
RuleSetXRule rule = await context.GetRuleSpecification(Entities.Rule.Rules.SingleTeam);
ITeamMatchModel match = await context.Fixture.GetMatch(request.MatchID);
var statistics = await context.GetCompetitionPlayerGameStatistic(request, match);
var gameNumber = match.Data.TeamFixture.CompetitionRound.GameNumber;
var allPlayers = context.GetAllPlayersWithTeam(request, match);
foreach (var(playerID, team) in allPlayers)
{
if (statistics.Any(x => x.PlayerID == playerID && x.GameNumber == gameNumber))
{
var player = context.GetPreloadedPlayer(playerID);
response.ValidationResult.Errors.Add(new ValidationFailure($"SingleGamePerMatchGameNumber{playerID}", $"{player.DisplayName} has already played in game number {gameNumber}."));
ok = false;
}
}
return(ResultEngineStatusMapper.MapFromBool(ok));
}
public async Task <ResultsEngineStatuses> Process(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
if (request.GameResults != null && request.GameResults.Count > 0)
{
var matchModel = await context.PlayerFixture.GetMatch(request.MatchID);
var competition = context.Competition;
foreach (var gameResult in request.GameResults)
{
if (matchModel.GameExists(gameResult.MatchFormatXGameVariationID))
{
await matchModel.UpdateGame(gameResult);
}
else
{
await matchModel.AddGame(gameResult);
}
}
}
return(ResultsEngineStatuses.Success);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var ok = true;
var ruleSet = await context.GetRuleSet();
RuleSetXRule rule = await context.GetRuleSpecification(Entities.Rule.Rules.CheckMaximumGamesForHigherRankedTeamAnyCompetition);
int maxGames = rule.DataInt1.Value;
ITeamMatchModel match = await context.Fixture.GetMatch(request.MatchID);
BowlsResults.Common.Domain.Entities.Team homeTeam = match.Data.Home;
BowlsResults.Common.Domain.Entities.Team awayTeam = match.Data.Away;
var statistics = await context.GetCompetitionPlayerGameStatistic(request, match);
var teams = await this._competitionRepository.GetCompetitionTeams(ruleSet.Competitions.Select(x => x.CompetitionID).ToArray());
foreach (var gameResult in request.GameResults)
{
IEnumerable <int> homeIDs = GetHigherRankedTeamIDs(teams, homeTeam);
IEnumerable <int> awayIDs = GetHigherRankedTeamIDs(teams, awayTeam);
foreach (var playerID in gameResult.HomePlayers)
{
ok &= this.Validate(context, response, statistics, homeIDs, maxGames, playerID);
}
foreach (var playerID in gameResult.AwayPlayers)
{
ok &= this.Validate(context, response, statistics, awayIDs, maxGames, playerID);
}
}
return(ResultEngineStatusMapper.MapFromBool(ok));
}
public Task <ResultsEngineStatuses> Process(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var status = ResultsEngineStatuses.Success;
foreach (PlayerFixture pendingFixture in this._pendingFixtures)
{
var updateRequest = UpdatePendingPlayerFixtureRequest.New()
.WithCompetitionID(pendingFixture.CompetitionID)
.WithFixtureID(pendingFixture.ID)
.WithCompetitionStageID(pendingFixture.CompetitionRound.CompetitionEvent.CompetitionStage.ID)
.WithCompletedFixture(context.PlayerFixture.Data)
.Build();
IPlayerResultEngine engine = this._playerResultEngineManager.GetEngine(updateRequest).GetAwaiter().GetResult();
var updateResponse = engine.UpdatePendingFixture(updateRequest);
status = updateResponse.Status;
if (status != ResultsEngineStatuses.Success)
{
break;
}
}
return(Task.FromResult(status));
}
public async Task <ReadOnlyCollection <CompetitionPlayerGameStatistic> > GetCompetitionPlayerGameStatistic(IGameResults gameResults, ITeamMatchModel matchModel)
{
await this.LoadRuleSet();
if (this._competitionPlayerGameStatistics == null)
{
List <CompetitionPlayerGameStatistic> result =
await this._competitionPlayerGameStatisticRepository.GetAllByCompetitionAndPlayer(this._ruleSet.Competitions.Select(x => x.CompetitionID), gameResults.GameResults.SelectMany(x => x.AllPlayers), matchModel.Data.Date);
this._competitionPlayerGameStatistics = result.AsReadOnly();
}
return(this._competitionPlayerGameStatistics);
}
public async Task <ResultsEngineStatuses> Process(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var data = new PlayerCompetitionResult();
data.Fixture = context.PlayerFixture.Data;
data.Competition = context.Competition;
data.SeasonID = context.Competition.Season.ID;
data.Winner = context.PlayerFixture.Data.WinningEntrantID;
data.Loser = context.PlayerFixture.Data.LosingEntrantID;
await this._competitionResultRepository.Save(data);
return(ResultsEngineStatuses.Success);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var match = await context.Fixture.GetMatch(request.MatchID);
var meritTable = await context.GetCompetitionPlayerMeritTable();
var config = await this._meritCalculationEngineRepository.Get((byte)meritTable.MeritCalculationEngineID);
foreach (var teamMatchXGame in match.Data.Games)
{
foreach (var playerGame in teamMatchXGame.Game.Players.Where(x => x.Player.IsRealPlayer()))
{
var team = match.Data.GetTeamBySide(playerGame.SideID);
await this._playerMeritTableCalculationEngine.Add(meritTable, playerGame, team, context.CompetitionEvent, config);
}
}
meritTable.MatchAdded(match.Data);
return(ResultsEngineStatuses.Success);
}
public Task <bool> IsSatisfiedBy(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
return(Task.FromResult(true));
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
if (request.GameResults != null && request.GameResults.Count > 0)
{
var playerIDs = request.GameResults.SelectMany(x => x.AllPlayers).ToArray();
await context.PreloadPlayers(playerIDs);
ITeamMatchModel matchModel = await context.Fixture.GetMatch(request.MatchID);
var competition = context.Competition;
foreach (var gameResult in request.GameResults)
{
if (matchModel.GameExists(gameResult.MatchFormatXGameVariationID))
{
await matchModel.UpdateGame(gameResult);
}
else
{
await matchModel.AddGame(gameResult);
}
}
}
return(ResultsEngineStatuses.Success);
}
public async Task <ResultsEngineStatuses> Process(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
await context.PlayerFixture.CalculateMatches();
return(ResultsEngineStatuses.Success);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
if (request.GameResults != null && request.GameResults.Count > 0)
{
var match = await context.Fixture.GetMatch(request.MatchID);
var validationContext = new ValidationContext <List <GameResult> >(request.GameResults);
validationContext.RootContextData.Add("match", match.Data);
validationContext.RootContextData.Add("gameCalculationEngineRepository", this._gameCalculationEngineRepository);
var result = await this._gameResultsValidator.ValidateAsync(validationContext);
response.SetValidationResult(result);
}
if (response.ValidationResult.IsValid)
{
return(ResultsEngineStatuses.Success);
}
return(ResultsEngineStatuses.ValidationError);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var ok = true;
var ruleSet = await context.GetRuleSet();
RuleSetXRule rule = await context.GetRuleSpecification(Entities.Rule.Rules.CheckMaximumGamesForHigherRankedCompetition);
if (ruleSet.Competitions.Count > 0)
{
int maxGames = rule.DataInt1.Value;
ITeamMatchModel match = await context.Fixture.GetMatch(request.MatchID);
BowlsResults.Common.Domain.Entities.Team homeTeam = match.Data.Home;
BowlsResults.Common.Domain.Entities.Team awayTeam = match.Data.Away;
var statistics = await context.GetCompetitionPlayerGameStatistic(request, match);
var competitionIDs = ruleSet.Competitions.Select(x => x.CompetitionID).ToList();
// Get index of the competition
var index = competitionIDs.FindIndex(x => x == context.Competition.ID);
// Remove all other competitions to leave only higher ones
competitionIDs.RemoveRange(index, competitionIDs.Count - index);
var allPlayers = context.GetAllPlayersWithTeam(request, match);
foreach (var(playerID, team) in allPlayers)
{
ok &= await this.Validate(context, response, statistics, competitionIDs, maxGames, playerID);
}
}
return(ResultEngineStatusMapper.MapFromBool(ok));
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var ok = true;
RuleSetXRule rule = await context.GetRuleSpecification(Entities.Rule.Rules.CheckTiedToTeam);
int maxGamesBeforeTied = rule.DataInt1.Value;
ITeamMatchModel match = await context.Fixture.GetMatch(request.MatchID);
var statistics = await context.GetCompetitionPlayerGameStatistic(request, match);
var allPlayers = context.GetAllPlayersWithTeam(request, match);
foreach (var(playerID, team) in allPlayers)
{
ok &= Validate(context, response, statistics, playerID, team.ID, maxGamesBeforeTied);
}
return(ResultEngineStatusMapper.MapFromBool(ok));
}
public Task <ResultsEngineStatuses> Process(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
context.PlayerFixture.CalculateFixture();
return(Task.FromResult <ResultsEngineStatuses>(ResultsEngineStatuses.Success));
}
