public async Task <ResultsEngineStatuses> Process(IPlayerResultEngineContext context, ISaveStandardResultRequest request, ResultsEngineResponse response)
{
var matchModel = await context.PlayerFixture.GetMatch(request.MatchID);
matchModel.SetWalkover(Walkover.None);
return(ResultsEngineStatuses.Success);
}
public void SetContext(IPlayerResultEngineContext context)
{
if (this._context != null)
{
throw new InvalidOperationException("Context already set.");
}
this._context = context;
}
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 ResultsEngineResponse SaveStandardResultRequest(IPlayerResultEngineContext context, ISaveStandardResultRequest 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 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(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(IPlayerResultEngineContext context, IResultsEngineRequest request, ResultsEngineResponse response)
{
// TODO - use validation result
if (context.PlayerFixture.IsMatchPending(request.MatchID))
{
throw new InvalidResultsEngineOperationException("Match is pending. To make changes you will need to confirm the match details first.");
}
if (context.PlayerFixture.IsMatchProcessed(request.MatchID))
{
throw new InvalidResultsEngineOperationException("Match has already been processed. To make changes you will need to revert this match first.");
}
return(Task.FromResult(ResultsEngineStatuses.Success));
}
public async Task <IPlayerResultEngine> GetEngine(IResultsEngineRequest request)
{
await this._competitionRepository.GetForUpdate(request.CompetitionID);
Entities.Competition competition = await this._competitionRepository.GetWithStages(request.CompetitionID);
CompetitionStage stage = this.GetStage(competition, request.CompetitionStageLoadMode, request.CompetitionStageValue);
PlayerFixture fixture = await this._playerFixtureRepository.GetFull(request.FixtureID);
IPlayerFixtureModel playerFixtureModel = this._serviceProvider.GetService <IPlayerFixtureModel>();
IPlayerResultEngineContext context = this._serviceProvider.GetService <IPlayerResultEngineContext>();
context.Initialise(competition, stage, fixture.CompetitionRound.CompetitionEvent, fixture.CompetitionRound, playerFixtureModel);
var engine = this._serviceProvider.GetService <IPlayerResultEngine>();
engine.SetContext(context);
await playerFixtureModel.Initialise(fixture, context);
return(engine);
}
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 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 Task <ResultsEngineStatuses> Process(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
context.PlayerFixture.CalculateFixture();
return(Task.FromResult <ResultsEngineStatuses>(ResultsEngineStatuses.Success));
}
public IList <IProcessor <IPlayerResultEngineContext, ISaveStandardResultRequest, ResultsEngineResponse> > Create(IPlayerResultEngineContext context,
ISaveStandardResultRequest request)
{
var list = new List <IProcessor <IPlayerResultEngineContext, ISaveStandardResultRequest, ResultsEngineResponse> >();
switch (context.CompetitionStage.CompetitionStageFormatID)
{
case CompetitionStageFormats.SingleKnockout:
{
list.Add(this._validateMatchStatusProcessor);
list.Add(this._validateGameResultsProcessor);
list.Add(this._parseGamesProcessor);
list.Add(this._matchCalculationProcessor);
list.Add(this._walkoverProcessor);
list.Add(this._fixtureCalculationProcessor);
list.Add(this._pendingFixtureProcessor);
list.Add(this._competitionResultProcessor);
}
break;
case CompetitionStageFormats.SingleLeague:
case CompetitionStageFormats.Groups:
break;
default:
throw new ArgumentOutOfRangeException();
}
return(list);
}
public Task <bool> IsSatisfiedBy(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
return(Task.FromResult(true));
}
public async Task <ResultsEngineStatuses> Process(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
await context.PlayerFixture.CalculateMatches();
return(ResultsEngineStatuses.Success);
}
public Task <ResultsEngineStatuses> Process(IPlayerResultEngineContext context, IUpdatePendingPlayerFixtureRequest request, ResultsEngineResponse response)
{
context.PlayerFixture.UpdatePendingFixture(request.CompletedFixture);
return(Task.FromResult(ResultsEngineStatuses.Success));
}
public Task <bool> IsSatisfiedBy(IPlayerResultEngineContext context, IUpdatePendingPlayerFixtureRequest request, ResultsEngineResponse response)
{
return(Task.FromResult <bool>(context.PlayerFixture.IsPending()));
}
public Task <bool> IsSatisfiedBy(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
return(Task.FromResult(context.PlayerFixture.IsComplete() && context.PlayerFixture.Data.CompetitionRound.CompetitionRoundTypeID == CompetitionRoundTypes.Final));
}
public IList <IProcessor <IPlayerResultEngineContext, IUpdatePendingPlayerFixtureRequest, ResultsEngineResponse> > Create(IPlayerResultEngineContext context,
IUpdatePendingPlayerFixtureRequest request)
{
var list = new List <IProcessor <IPlayerResultEngineContext, IUpdatePendingPlayerFixtureRequest, ResultsEngineResponse> >();
switch (context.CompetitionStage.CompetitionStageFormatID)
{
case CompetitionStageFormats.SingleKnockout:
{
list.Add(this._updatePendingFixtureProcessor);
}
break;
case CompetitionStageFormats.SingleLeague:
case CompetitionStageFormats.Groups:
break;
default:
throw new ArgumentOutOfRangeException();
}
return(list);
}
public Task <bool> IsSatisfiedBy(IPlayerResultEngineContext context, IGameResults request, ResultsEngineResponse response)
{
bool result = !context.PlayerFixture.IsMatchProcessed(request.MatchID);
return(Task.FromResult(result));
}
