public CompetitionEntrantValidator(SameSexGameVariationValidator sameSexGameVariationValidator, MixedGameVariationValidator mixedGameVariationValidator) { this.RuleFor(x => x.Players).Custom((data, context) => { List <CompetitionEntrant> currentEntrants = (List <CompetitionEntrant>)context.RootContextData["CurrentEntrants"]; IEnumerable <int> result = currentEntrants.SelectMany(y => y.GetPlayerIDs()); var newIDs = context.InstanceToValidate.GetPlayerIDs(); bool match = newIDs.Any(playerID => result.Contains(playerID)); if (match) { context.AddFailure(new ValidationFailure(context.PropertyName, "A selected Player already exists in another entrant.")); } }); this.RuleFor(x => x.Players).Custom((data, context) => { Entities.Competition competition = (Entities.Competition)context.RootContextData["Competition"]; if (competition.GameVariation.IsMixed() && !competition.GameVariation.IsAnyCombination() && !competition.GameVariation.IsSingles()) { mixedGameVariationValidator.Validate(context); } else if (!competition.GameVariation.IsMixed()) { sameSexGameVariationValidator.Validate(context); } } ); }
public static void ValidateGameFormat(ValidationResult validationResult, Entities.Competition competition, GameFormats gameFormat) { if (competition.GetEntryGameFormat() != gameFormat) { validationResult.Errors.Add(new ValidationFailure("GameFormat", "Invalid Game Format.")); } }
private async Task SaveCompetition(CreateCompetitionCommand command) { this._competition = Entities.Competition.Create( this._header, this._season, command.Organiser, command.Scope, command.Format, command.AgeGroup, command.Gender, command.AssociationID, command.Name, command.StartDate, command.EndDate); this._competition.Sponsor = command.Sponsor; this._competition.OrganisingClub = this._organiserClub; this._competition.VenueClub = this._venueClub; this._competition.GameVariation = this._gameVariation; if (command.DataBit1.HasValue) { this._competition.DataBit1 = command.DataBit1; } this._competition.SetAuditFields(); await this._competitionRepository.Save(this._competition); }
public AddCompetitionEntrantCommandValidator(SinglesAddCompetitionEntrantModelValidator singlesAddCompetitionEntrantModelValidator, DoublesAddCompetitionEntrantModelValidator doublesAddCompetitionEntrantModelValidator, ThreesomesAddCompetitionEntrantModelValidator threesomesAddCompetitionEntrantModelValidator, FoursAddCompetitionEntrantModelValidator foursAddCompetitionEntrantModelValidator) { this.RuleFor(x => x.CompetitionID).NotEmpty(); this.RuleFor(x => x.Entrant).NotEmpty().DependentRules(() => { this.RuleFor(x => x.Entrant).Must(x => !x.HasDuplicatePlayer()).WithMessage("A player exists more than once."); }).DependentRules(() => { this.RuleFor(c => c.Entrant).Custom((data, context) => { Entities.Competition competition = (Entities.Competition)context.RootContextData["Competition"]; switch (competition.GetEntryGameFormat()) { case GameFormats.Singles: singlesAddCompetitionEntrantModelValidator.Validate(context); break; case GameFormats.Doubles: doublesAddCompetitionEntrantModelValidator.Validate(context); break; case GameFormats.Threesomes: threesomesAddCompetitionEntrantModelValidator.Validate(context); break; case GameFormats.Fours: foursAddCompetitionEntrantModelValidator.Validate(context); break; default: throw new ArgumentOutOfRangeException(); } }); }); }
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 Initialise(Entities.Competition competition, CompetitionStage stage, CompetitionEvent competitionEvent, CompetitionRound round, ITeamFixtureModel teamFixture) { this.Competition = competition; this.CompetitionStage = stage; this.CompetitionEvent = competitionEvent; this.CompetitionRound = round; this.Fixture = teamFixture; }
public static void Validate(ValidationResult validationResult, Entities.Competition competition) { ValidateRegistrationOnline(validationResult, competition); if (validationResult.IsValid) { ValidateRegistrationStatus(validationResult, competition); } }
public void Initialise(Entities.Competition competition, CompetitionStage stage, CompetitionEvent competitionEvent, CompetitionRound round, IPlayerFixtureModel playerFixture) { this.Competition = competition; this.CompetitionStage = stage; this.CompetitionEvent = competitionEvent; this.CompetitionRound = round; this.PlayerFixture = playerFixture; }
public virtual CompetitionEntrant CreateEntrant(Entities.Competition competition) { var data = new CompetitionEntrant(); data.CompetitionRegistration = this; data.CompetitionEntrantStatusID = CompetitionEntrantStatuses.Pending; data.CompetitionID = competition.ID; data.EntrantGameFormatID = competition.GameVariation.GameFormatID; this.Entrants.Add(data); return(data); }
public SameSexGameVariationValidator() { this.RuleFor(x => x.Players).Custom((data, context) => { Entities.Competition competition = (Entities.Competition)context.RootContextData["Competition"]; Genders gender = competition.GenderID; if (data.Any(y => y.Player.GenderID != gender)) { context.AddFailure(new ValidationFailure(context.PropertyName, $"All players must be {gender}")); } }); }
private async Task Load(AddPlayerFixtureCommand command) { await this._competitionRepository.GetForUpdate(command.Competition.CompetitionID); this._competition = await this._competitionRepository.GetWithStages(command.Competition.CompetitionID); this._competitionStage = this._competition.GetStage(command.Competition.CompetitionStageLookupMode, command.Competition.CompetitionStageValue); this._competitionEvent = await this._competitionEventRepository.Get(command.CompetitionEventID); var rounds = await this._playerCompetitionRoundRepository.GetAll(this._competitionEvent.ID); await this.LoadRound(command, rounds); await this.LoadEntrants(command); await this.PendingFixtures(command); }
private async Task Load(UpdateOnlineRegistrationConfigurationCommand command) { await this._competitionRepository.GetForUpdate(command.CompetitionID); this._competition = await this._competitionRepository.GetWithRegistrationConfiguration(command.CompetitionID); this._association = await this._associationRepository.GetWithContacts(this._competition.AssociationID); if (this._competition.CompetitionOrganiserID == CompetitionOrganisers.Club) { this._club = await this._clubRepository.GetWithContacts(this._competition.OrganisingClub.ID); } if (command.OrganiserContactID.HasValue) { this._organiserContact = await this._contactRepository.Get(command.OrganiserContactID.Value); } }
private CompetitionStage GetStage(Entities.Competition competition, CompetitionStageLoadModes loadMode, int?optionsCompetitionStageValue) { switch (loadMode) { case CompetitionStageLoadModes.ByID: return(competition.GetStageByID(optionsCompetitionStageValue.Value)); break; case CompetitionStageLoadModes.BySequence: return(competition.GetStageBySequence(optionsCompetitionStageValue.Value)); break; default: throw new ArgumentOutOfRangeException(nameof(loadMode), loadMode, null); } }
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); }
private async Task Load(CreateDoublesRegistrationCommand command) { this._competition = await this._competitionRepository.GetForUpdate(command.Registration.CompetitionID); this._competition = await this._competitionRepository.GetWithRegistrationConfiguration(this._competition.ID); }
public CompetitionRegistrationPlayerConfirmationEmailMessage(Entities.Competition competition, CompetitionRegistration competitionRegistration, List <CompetitionDate> dates) { this._competition = competition; this._competitionRegistration = competitionRegistration; this._dates = dates; }
private async Task <DefaultIdentityCommandResponse> CreateFixture(CompetitionEntrantResult result, Entities.Competition competition, CompetitionEvent compEvent, CompetitionEntrant winnerEntrant, CompetitionEntrant loserEntrant) { var command = new AddPlayerFixtureCommand { Competition = new CompetitionLookupModel { CompetitionID = result.CompetitionID, CompetitionStageLookupMode = CompetitionLookupModel.CompetitionStageLookupModes.Auto }, CompetitionEventID = compEvent.ID, Round = new CompetitionRoundLookupModel { RoundType = CompetitionRoundTypes.Final, GameNumber = 0, CreateIfMissing = true }, Date = competition.StartDate, TotalLegs = 1, VenueType = VenueTypes.Neutral, Entrant1 = new PlayerFixtureEntrantConfigurationModel { Mode = PlayerFixtureEntrantConfigurationModel.PendingEntrantModes.Manual, EntrantID = winnerEntrant.ID }, Entrant2 = new PlayerFixtureEntrantConfigurationModel { Mode = PlayerFixtureEntrantConfigurationModel.PendingEntrantModes.Manual, EntrantID = loserEntrant.ID }, Reference = "F" }; var commandHandler = this._serviceProvider.GetService <AddPlayerFixtureCommandHandler>(); return(await commandHandler.Handle(command)); }
private async Task <CompetitionEntrant> CreateEntrant(CompetitionEntrant entrant, Entities.Competition competition) { List <CompetitionEntrantPlayer> players = new List <CompetitionEntrantPlayer>(); var competitionEntrant = new CompetitionEntrant { CompetitionID = competition.ID, EntrantGameFormatID = competition.GetEntryGameFormat() }; foreach (var competitionEntrantPlayer in entrant.Players) { var playerEntrant = new CompetitionEntrantPlayer { Entrant = competitionEntrant, Player = new Common.Domain.Entities.Player { ID = competitionEntrantPlayer.Player.ID }, FirstName = competitionEntrantPlayer.FirstName, LastName = competitionEntrantPlayer.LastName, CompetitionID = competition.ID }; competitionEntrant.Players.Add(playerEntrant); } competitionEntrant.Confirm(); await this._sessionProvider.Session.SaveAsync(competitionEntrant); return(competitionEntrant); }
public async Task <DefaultIdentityCommandResponse> Handle(AddCompetitionEntrantCommand command) { var status = false; DefaultIdentityCommandResponse response; this._unitOfWork.Begin(); this._registrationUnitOfWork.Begin(); RecaptchaResponse recaptchaResponse = null; try { this._competition = await this._competitionRepository.GetForUpdate(command.CompetitionID); this._entrants = await this._competitionEntrantRepository.GetAll(this._competition.ID); Dictionary <int, Common.Domain.Entities.Player> newPlayers = await this._playerRepository.GetDictionary(command.Entrant.GetPlayerIDs().ToArray()); var validationContext = new ValidationContext <AddCompetitionEntrantCommand>(command); validationContext.RootContextData.Add("Competition", this._competition); this._validationResult = await this._addCompetitionEntrantCommandValidator.ValidateAsync(validationContext); if (this._validationResult.IsValid) { var competitionEntrant = this._competition.CreateEntrant(); this.AddPlayer(competitionEntrant, command.Entrant.Player1, newPlayers); this.AddPlayer(competitionEntrant, command.Entrant.Player2, newPlayers); this.AddPlayer(competitionEntrant, command.Entrant.Player3, newPlayers); this.AddPlayer(competitionEntrant, command.Entrant.Player4, newPlayers); var competitionEntrantValidationContext = new ValidationContext <CompetitionEntrant>(competitionEntrant); competitionEntrantValidationContext.RootContextData.Add("Competition", this._competition); competitionEntrantValidationContext.RootContextData.Add("CurrentEntrants", this._entrants); this._validationResult = await this._competitionEntrantValidator.ValidateAsync(competitionEntrantValidationContext); if (this._validationResult.IsValid) { await this._competitionEntrantRepository.Save(competitionEntrant); } this._unitOfWork.SoftCommit(); this._registrationUnitOfWork.SoftCommit(); status = true; response = DefaultIdentityCommandResponse.Create(this._validationResult, competitionEntrant.ID); } else { this._unitOfWork.Rollback(); this._registrationUnitOfWork.Rollback(); response = DefaultIdentityCommandResponse.Create(this._validationResult); } } catch (Exception e) { this._unitOfWork.Rollback(); this._registrationUnitOfWork.Rollback(); Console.WriteLine(e); throw; } return(response); }
public async Task <DefaultCommandResponse> Handle(AddCompetitionEntrantResultCommand command) { var status = false; DefaultCommandResponse response = new DefaultCommandResponse(); this._unitOfWork.Begin(); this._adminUnitOfWork.Begin(); RecaptchaResponse recaptchaResponse = null; try { this._competition = await this._competitionRepository.GetForUpdate(command.CompetitionID); this._entrants = await this._competitionEntrantRepository.GetAll(command.CompetitionID); var existingResults = await this._competitionEntrantResultRepository.GetAll(command.CompetitionID); if (existingResults.Count > 0) { this._validationResult.Errors.Add(new ValidationFailure("ExistingResult", "There has already been a result submitted.")); } if (this._validationResult.IsValid) { this._validationResult = await this._validator.ValidateAsync(command); } if (this._validationResult.IsValid) { foreach (var roundResult in command.Rounds) { var data = new CompetitionEntrantResult(); data.CompetitionID = this._competition.ID; data.SeasonID = this._competition.Season.ID; data.CompetitionName = this._competition.Name; data.WinnerEntrant = this._entrants.Single(x => x.ID == roundResult.Winner.EntrantID); data.LoserEntrant = this._entrants.Single(x => x.ID == roundResult.Loser.EntrantID); data.WinnerChalks = roundResult.Winner.Score.Chalks; data.WinnerHandicap = roundResult.Winner.Score.Handicap; data.LoserChalks = roundResult.Loser.Score.Chalks; data.LoserHandicap = roundResult.Loser.Score.Handicap; data.CompetitionRoundTypeID = roundResult.RoundTypeID; data.CompetitionEntrantResultStatusID = CompetitionEntrantResultStatuses.Pending; data.SetAuditFields(this._user.ID); await this._competitionEntrantResultRepository.Save(data); } this._unitOfWork.SoftCommit(); this._adminUnitOfWork.SoftCommit(); } else { this._unitOfWork.Rollback(); this._adminUnitOfWork.Rollback(); } response = DefaultCommandResponse.Create(this._validationResult); } catch (Exception e) { this._unitOfWork.Rollback(); this._adminUnitOfWork.Rollback(); Console.WriteLine(e); throw; } return(response); }
private static void ValidateRegistrationOnline(ValidationResult validationResult, Entities.Competition competition) { bool unavailable = false; if (competition.RegistrationConfiguration != null) { switch (competition.RegistrationConfiguration.CompetitionRegistrationModeID) { case CompetitionRegistrationModes.Unavailable: unavailable = true; break; case CompetitionRegistrationModes.Invitational: validationResult.Errors.Add(new ValidationFailure("RegistrationStatus", "This competition is an invitational and cannot be entered online.")); break; } } else { unavailable = true; } if (unavailable) { validationResult.Errors.Add(new ValidationFailure("RegistrationStatus", "This competition cannot be entered online. Please contact the club directly using the detail below.")); } }
public async Task SendSummaryEmail(List <CompetitionRegistration> registrations, Entities.Competition competition) { var dates = await this._competitionDateRepository.GetByCompetition(competition.ID); var message1 = new CompetitionRegistrationOrganiserSummaryEmailMessage(competition, registrations, dates); await this._emailSender.Send(message1); }
public async Task SendConfirmationEmails(CompetitionRegistration registration, Entities.Competition competition) { var dates = await this._competitionDateRepository.GetByCompetition(competition.ID); var message1 = new CompetitionRegistrationPlayerConfirmationEmailMessage(competition, registration, dates); await this._emailSender.Send(message1); var message2 = new CompetitionRegistrationOrganiserConfirmationEmailMessage(competition, registration, dates); await this._emailSender.Send(message2); }
public CompetitionRegistrationOrganiserSummaryEmailMessage(Entities.Competition competition, List <CompetitionRegistration> competitionRegistrations, List <CompetitionDate> dates) { this._competition = competition; this._competitionRegistrations = competitionRegistrations; this._dates = dates; }
private static void ValidateRegistrationStatus(ValidationResult validationResult, Entities.Competition competition) { switch (competition.GetRegistrationStatus()) { case CompetitionRegistrationStatuses.Closed: validationResult.Errors.Add(new CompetitionRegistrationClosed(competition.RegistrationConfiguration.CloseDate.Value)); break; case CompetitionRegistrationStatuses.NotOpenYet: validationResult.Errors.Add(new CompetitionRegistrationNotOpen(competition.RegistrationConfiguration.OpenDate.Value)); break; } }
private async Task Load(int competitionID) { this._competition = await this._competitionRepository.GetForUpdate(competitionID); }