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;
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)
{
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(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(ITeamResultEngineContext context, IResultsEngineRequest request, ResultsEngineResponse response)
{
var status = ResultsEngineStatuses.Success;
var pendingFixtures = await context.GetPendingFixtures();
foreach (TeamFixture pendingFixture in pendingFixtures)
{
var updateRequest = UpdatePendingTeamFixtureRequest.New()
.WithCompetitionID(pendingFixture.CompetitionID)
.WithFixtureID(pendingFixture.ID)
.WithCompetitionStageID(pendingFixture.CompetitionRound.CompetitionEvent.CompetitionStage.ID)
.WithCompletedFixture(context.Fixture.Data)
.Build();
ITeamResultEngine engine = await this._teamResultEngineManager.GetEngine(updateRequest);
var updateResponse = engine.UpdatePendingFixture(updateRequest);
status = updateResponse.Status;
if (status != ResultsEngineStatuses.Success)
{
break;
}
}
return(status);
}
public async Task <ITeamResultEngine> GetEngine(IResultsEngineRequest request)
{
this._unitOfWork.GuardCheckInTransaction();
await this._competitionRepository.GetForUpdate(request.CompetitionID);
Entities.Competition competition = await this._competitionRepository.GetWithStages(request.CompetitionID);
CompetitionStage stage = this.GetStage(competition, request.CompetitionStageLoadMode, request.CompetitionStageValue);
TeamFixture fixture = await this._fixtureRepository.GetTeamFixtureFull(request.FixtureID);
if (fixture.CompetitionRound.Competition.ID != competition.ID)
{
throw new ArgumentException("Incorrect competition/fixture ID combination", nameof(request));
}
ITeamFixtureModel teamFixtureModel = this._serviceProvider.GetService <ITeamFixtureModel>();
ITeamResultEngineContext context = this._serviceProvider.GetService <ITeamResultEngineContext>();
await context.Initialise(competition, stage, fixture.CompetitionRound.CompetitionEvent, fixture.CompetitionRound, teamFixtureModel);
var engine = this._serviceProvider.GetService <ITeamResultEngine>();
engine.SetContext(context);
await teamFixtureModel.Initialise(fixture, context);
return(engine);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var ok = true;
RuleSetXRule rule = await context.GetRuleSpecification(Entities.Rule.Rules.CheckMaximumGamesForHigherRankedTeamPerCompetition);
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(context.Competition.ID);
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 async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, ISetMatchWalkoverRequest request, ResultsEngineResponse response)
{
var match = await context.Fixture.GetMatch(request.MatchID);
await match.SetWalkover(request);
return(ResultsEngineStatuses.Success);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IRevertResultRequest request, ResultsEngineResponse response)
{
var matchModel = await context.Fixture.GetMatch(request.MatchID);
await this._careerTeamGameStatisticService.Remove(matchModel.Data);
return(ResultsEngineStatuses.Success);
}
public async Task <bool> IsSatisfiedBy(ITeamResultEngineContext context, IResultsEngineRequest request, ResultsEngineResponse response)
{
var matchModel = await context.Fixture.GetMatch(request.MatchID);
var handicapSetting = context.Fixture.GetHandicapSetting();
var result = handicapSetting != null && !matchModel.IsProcessed() && matchModel.HasGamesAndAllGamesProcessed();
return(result);
}
public void SetContext(ITeamResultEngineContext context)
{
if (this._context != null)
{
throw new InvalidOperationException("Context already set.");
}
this._context = context;
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, ISaveStandardResultRequest request, ResultsEngineResponse response)
{
var match = await context.Fixture.GetMatch(request.MatchID);
match.Data.ClearGames();
match.Data.MatchStatusID = MatchStatuses.Temporary;
return(ResultsEngineStatuses.Success);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IResultsEngineRequest request, ResultsEngineResponse response)
{
var match = await context.Fixture.GetMatch(request.MatchID);
var engine = this._teamMatchHandicapCalculationEngineFactory.Create(context.Fixture.GetHandicapSetting());
await engine.Calculate(match.Data);
return(ResultsEngineStatuses.Success);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IResultsEngineRequest request, ResultsEngineResponse response)
{
var leagueEvent = context.CompetitionEvent.CastEntity <League>();
var leagueTable = await context.GetLeagueTable();
var engine = this._leagueTableCalculationEngineFactory.Create(context.Fixture.Data);
await engine.Add(leagueEvent, leagueTable, context.Fixture.Data);
return(ResultsEngineStatuses.Success);
}
public async Task <bool> IsSatisfiedBy(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
if (request.UpdatePlayerCompetitionStatistics)
{
var match = await context.Fixture.GetMatch(request.MatchID);
return(match.IsMatchProcessedWithResult());
}
return(false);
}
public async Task <bool> IsSatisfiedBy(ITeamResultEngineContext context, IRevertResultRequest 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(ITeamResultEngineContext context, IResultsEngineRequest request, ResultsEngineResponse response)
{
if (context.Fixture.Completed)
{
var pendingFixtures = await context.GetPendingFixtures();
return(pendingFixtures.Count > 0);
}
return(false);
}
public ResultsEngineResponse Execute(ITeamResultEngineContext context, IRevertResultRequest request)
{
this._unitOfWork.GuardCheckInTransaction();
var response = new ResultsEngineResponse();
var processors = this._processorFactory.Create(context, request);
var status = this._processorExecutor.Execute(context, request, response, processors);
response.Status = status;
return(response);
}
public Task <ResultsEngineResponse> Execute(ITeamResultEngineContext context, ISetMatchWalkoverRequest request)
{
this._unitOfWork.GuardCheckInTransaction();
var response = new ResultsEngineResponse();
var processors = this._processorFactory.Create(context, request);
var status = this._processorExecutor.Execute(context, request, response, processors);
response.Status = status;
return(Task.FromResult(response));
}
public Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IResultsEngineRequest request, ResultsEngineResponse response)
{
if (context.Fixture.IsMatchPending(request.MatchID))
{
response.ValidationResult.Errors.Add(new ValidationFailure("MatchStatus", "Match is pending. To make changes you will need to confirm the match details first."));
}
if (context.Fixture.IsMatchProcessed(request.MatchID))
{
response.ValidationResult.Errors.Add(new ValidationFailure("MatchStatus", "Match has already been processed. To make changes you will need to revert this match first."));
}
return(ResultEngineStatusMapper.MapFromValidationResult(response.ValidationResult));
}
private bool Validate(ITeamResultEngineContext context, ResultsEngineResponse response, ReadOnlyCollection <CompetitionPlayerGameStatistic> statistics, int playerID, BowlsResults.Common.Domain.Entities.Team team)
{
var ok = true;
var otherClub = statistics.FirstOrDefault(x => x.PlayerID == playerID && x.Team.Club.ID != team.Club.ID);
if (otherClub != null)
{
var player = context.GetPreloadedPlayer(playerID);
response.ValidationResult.Errors.Add(new ValidationFailure($"SingleClubPlayer{playerID}", $"{player.DisplayName} has already played for {otherClub.Team.Club.Name} in this competition."));
ok = false;
}
return(ok);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IResultsEngineRequest request, ResultsEngineResponse response)
{
var match = await context.Fixture.GetMatch(request.MatchID);
var matchCalculationConfiguration = await match.GetMatchCalculationEngineConfiguration();
if (!matchCalculationConfiguration.AllowDraw)
{
if (match.Data.IsDraw())
{
response.ValidationResult.Errors.Add(new ValidationFailure("MatchResult", "Match has ended in a draw which is not allowed"));
}
}
return(await ResultEngineStatusMapper.MapFromValidationResult(response.ValidationResult));
}
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 <bool> IsSatisfiedBy(ITeamResultEngineContext context, IRevertResultRequest 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);
}
private static bool Validate(ITeamResultEngineContext context, ResultsEngineResponse response, ReadOnlyCollection <CompetitionPlayerGameStatistic> statistics, int playerID, int teamID, int maxGamesBeforeTied)
{
bool ok = true;
var grouping = statistics.Where(x => x.PlayerID == playerID && x.Team.ID != teamID).GroupBy(x => x.Team).FirstOrDefault(x => x.Count() >= maxGamesBeforeTied);
if (grouping != null)
{
var player = context.GetPreloadedPlayer(playerID);
response.ValidationResult.Errors.Add(new ValidationFailure($"CheckTiedToTeam{player.ID}",
$"{player.DisplayName} has already played {maxGamesBeforeTied} or more games for {grouping.Key.Name} and is tied to that team for this competition."));
ok = false;
}
return(ok);
}
private async Task <bool> Validate(ITeamResultEngineContext context, ResultsEngineResponse response, ReadOnlyCollection <CompetitionPlayerGameStatistic> statistics, List <int> competitionIDs, int maxGames, int playerID)
{
var ok = true;
var grouping = statistics.Where(x => x.PlayerID == playerID && competitionIDs.Contains(x.CompetitionID)).GroupBy(x => x.CompetitionID).FirstOrDefault(x => x.Count() >= maxGames);
if (grouping != null)
{
var relatedCompetition = await this._competitionRepository.Get(grouping.Key);
var player = context.GetPreloadedPlayer(playerID);
response.ValidationResult.Errors.Add(new ValidationFailure($"MaxGamesHigherComp{playerID}", $"{player.DisplayName} has already played {maxGames} or more games in {relatedCompetition.Name}, and is tied to that competition."));
ok = false;
}
return(ok);
}
public async Task <ResultsEngineStatuses> Process(ITeamResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
var ok = true;
RuleSetXRule rule = await context.GetRuleSpecification(Entities.Rule.Rules.SingleClub);
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 = this.Validate(context, response, statistics, playerID, team);
}
return(ResultEngineStatusMapper.MapFromBool(ok));
}
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);
}
private bool Validate(ITeamResultEngineContext context, ResultsEngineResponse response, ReadOnlyCollection <CompetitionPlayerGameStatistic> statistics, IEnumerable <int> teamIDs, int maxGames, int playerID)
{
var ok = true;
if (playerID > 0)
{
var grouping = statistics.Where(x => x.PlayerID == playerID && teamIDs.Contains(x.Team.ID)).GroupBy(x => x.Team).FirstOrDefault(x => x.Count() >= maxGames);
//var grouping = statistics.Where(x => teamIDs.Contains(x.Team.ID)).GroupBy(x => x.Team).FirstOrDefault(x => x.Count() >= maxGames);
if (grouping != null)
{
var player = context.GetPreloadedPlayer(playerID);
response.ValidationResult.Errors.Add(new ValidationFailure($"MaxGamesTeamPerComp{playerID}",
$"{player.DisplayName} has already played {maxGames} or more games for {grouping.Key.Name}, who are a higher ranked team in this competition."));
ok = false;
}
}
return(ok);
}
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);
}
