public void PlayerAggregate_Register_NoMiddleName_PlayerRegistered(String middleName) { PlayerAggregate playerAggregate = PlayerTestData.GetEmptyPlayerAggregate(); Decimal exactHandicap = PlayerTestData.ExactHandicapCat1; Int32 playingHandicap = PlayerTestData.PlayingHandicapCat1; Int32 handicapCategory = PlayerTestData.HandicapCategoryCat1; playerAggregate.Register(PlayerTestData.FirstName, middleName, PlayerTestData.LastName, PlayerTestData.Gender, PlayerTestData.DateOfBirth, exactHandicap, PlayerTestData.EmailAddress); playerAggregate.FirstName.ShouldBe(PlayerTestData.FirstName); playerAggregate.MiddleName.ShouldBe(middleName); playerAggregate.LastName.ShouldBe(PlayerTestData.LastName); playerAggregate.Gender.ShouldBe(PlayerTestData.Gender); playerAggregate.DateOfBirth.ShouldBe(PlayerTestData.DateOfBirth); playerAggregate.ExactHandicap.ShouldBe(exactHandicap); playerAggregate.EmailAddress.ShouldBe(PlayerTestData.EmailAddress); playerAggregate.PlayingHandicap.ShouldBe(playingHandicap); playerAggregate.HandicapCategory.ShouldBe(handicapCategory); playerAggregate.FullName.ShouldBe(PlayerTestData.FullNameEmptyMiddleName); }
public void PlayerAggregate_Register_PlayerRegistered(Int32 category) { PlayerAggregate playerAggregate = PlayerTestData.GetEmptyPlayerAggregate(); Decimal exactHandicap = 0; Int32 playingHandicap = 0; Int32 handicapCategory = 0; switch (category) { case 1: exactHandicap = PlayerTestData.ExactHandicapCat1; playingHandicap = PlayerTestData.PlayingHandicapCat1; handicapCategory = PlayerTestData.HandicapCategoryCat1; break; case 2: exactHandicap = PlayerTestData.ExactHandicapCat2; playingHandicap = PlayerTestData.PlayingHandicapCat2; handicapCategory = PlayerTestData.HandicapCategoryCat2; break; case 3: exactHandicap = PlayerTestData.ExactHandicapCat3; playingHandicap = PlayerTestData.PlayingHandicapCat3; handicapCategory = PlayerTestData.HandicapCategoryCat3; break; case 4: exactHandicap = PlayerTestData.ExactHandicapCat4; playingHandicap = PlayerTestData.PlayingHandicapCat4; handicapCategory = PlayerTestData.HandicapCategoryCat4; break; case 5: exactHandicap = PlayerTestData.ExactHandicapCat5; playingHandicap = PlayerTestData.PlayingHandicapCat5; handicapCategory = PlayerTestData.HandicapCategoryCat5; break; } playerAggregate.Register(PlayerTestData.FirstName, PlayerTestData.MiddleName, PlayerTestData.LastName, PlayerTestData.Gender, PlayerTestData.DateOfBirth, exactHandicap, PlayerTestData.EmailAddress); playerAggregate.FirstName.ShouldBe(PlayerTestData.FirstName); playerAggregate.MiddleName.ShouldBe(PlayerTestData.MiddleName); playerAggregate.LastName.ShouldBe(PlayerTestData.LastName); playerAggregate.Gender.ShouldBe(PlayerTestData.Gender); playerAggregate.DateOfBirth.ShouldBe(PlayerTestData.DateOfBirth); playerAggregate.ExactHandicap.ShouldBe(exactHandicap); playerAggregate.EmailAddress.ShouldBe(PlayerTestData.EmailAddress); playerAggregate.PlayingHandicap.ShouldBe(playingHandicap); playerAggregate.HandicapCategory.ShouldBe(handicapCategory); playerAggregate.FullName.ShouldBe(PlayerTestData.FullName); }
public void PlayerAggregate_CanBeCreated_IsCreated() { PlayerAggregate player = PlayerAggregate.Create(PlayerTestData.AggregateId); player.ShouldNotBeNull(); player.AggregateId.ShouldBe(PlayerTestData.AggregateId); }
public void PlayerAggregate_InvalidData_ErrorThrown() { Should.Throw <ArgumentNullException>(() => { PlayerAggregate player = PlayerAggregate.Create(Guid.Empty); }); }
public async Task SignUpPlayerForTournament(Guid tournamentId, Guid playerId, CancellationToken cancellationToken) { // Validate the tournament Id TournamentAggregate tournament = await this.TournamentRepository.GetLatestVersion(tournamentId, cancellationToken); PlayerAggregate player = await this.PlayerRepository.GetLatestVersion(playerId, cancellationToken); if (!player.HasBeenRegistered) { throw new InvalidOperationException("A player must be registered to sign up for a club tournament"); } try { GolfClubMembershipAggregate golfClubMembership = await this.ClubMembershipRepository.GetLatestVersion(tournament.GolfClubId, cancellationToken); golfClubMembership.GetMembership(player.AggregateId, player.DateOfBirth, player.Gender); } catch (NotFoundException nex) { throw new InvalidOperationException("A player must be a member of the club to sign up for a club tournament"); } tournament.SignUpForTournament(playerId); await this.TournamentRepository.SaveChanges(tournament, cancellationToken); }
/// <summary> /// Requests the club membership. /// </summary> /// <param name="playerId">The player identifier.</param> /// <param name="golfClubId">The golf club identifier.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns></returns> /// <exception cref="InvalidDataException"> /// Unable to request club membership for a player that has not been registered /// or /// Unable to request club membership for a club that has not been created /// </exception> public async Task RequestClubMembership(Guid playerId, Guid golfClubId, CancellationToken cancellationToken) { // Rehydrate the golf club membership aggregate GolfClubMembershipAggregate golfClubMembershipAggregate = await this.GolfClubMembershipRepository.GetLatestVersion(golfClubId, cancellationToken); // Validate the player id firstly PlayerAggregate playerAggregate = await this.PlayerRepository.GetLatestVersion(playerId, cancellationToken); if (!playerAggregate.HasBeenRegistered) { throw new InvalidDataException("Unable to request club membership for a player that has not been registered"); } // Now validate the club GolfClubAggregate golfClubAggregate = await this.GolfClubRepository.GetLatestVersion(golfClubId, cancellationToken); if (!golfClubAggregate.HasBeenCreated) { throw new InvalidDataException("Unable to request club membership for a club that has not been created"); } // Ok all the data has been validated, now run through the aggregate rules golfClubMembershipAggregate.RequestMembership(playerId, playerAggregate.FullName, playerAggregate.DateOfBirth, playerAggregate.Gender, DateTime.Now); // Save any pending changes await this.GolfClubMembershipRepository.SaveChanges(golfClubMembershipAggregate, cancellationToken); }
public void PlayerAggregate_CreateSecurityUser_SecurityUserCreated() { PlayerAggregate playerAggregate = PlayerTestData.GetRegisteredPlayerAggregate(); playerAggregate.CreateSecurityUser(PlayerTestData.SecurityUserId); playerAggregate.SecurityUserId.ShouldBe(PlayerTestData.SecurityUserId); playerAggregate.HasSecurityUserBeenCreated.ShouldBeTrue(); }
public void PlayerAggregate_AdjustHandicap_HandicapAdjustmentIsZero_HandicapNotAdjusted() { PlayerAggregate playerAggregate = PlayerTestData.GetRegisteredPlayerAggregate(); playerAggregate.AdjustHandicap(PlayerTestData.HandicapAdjustmentNoChange, PlayerTestData.TournamentId, PlayerTestData.GolfClubId, PlayerTestData.MeasuredCourseId, PlayerTestData.ScoreDate); playerAggregate.ExactHandicap.ShouldBe(PlayerTestData.ExactHandicap); playerAggregate.PlayingHandicap.ShouldBe(PlayerTestData.PlayingHandicap); }
public void PlayerAggregate_AdjustHandicap_PlayerNotRegistered_ErrorThrown() { PlayerAggregate playerAggregate = PlayerTestData.GetEmptyPlayerAggregate(); Should.Throw <InvalidOperationException>(() => playerAggregate.AdjustHandicap(PlayerTestData.HandicapAdjustment, PlayerTestData.TournamentId, PlayerTestData.GolfClubId, PlayerTestData.MeasuredCourseId, PlayerTestData.ScoreDate)); }
public void PlayerAggregate_AdjustHandicap_HandicapIncrease_HandicapAdjusted() { PlayerAggregate playerAggregate = PlayerTestData.GetRegisteredPlayerAggregate(); playerAggregate.AdjustHandicap(PlayerTestData.HandicapAdjustmentIncrease, PlayerTestData.TournamentId, PlayerTestData.GolfClubId, PlayerTestData.MeasuredCourseId, PlayerTestData.ScoreDate); playerAggregate.ExactHandicap.ShouldBe(PlayerTestData.NewExactHandicapIncreased); playerAggregate.PlayingHandicap.ShouldBe(PlayerTestData.NewPlayingHandicapIncreased); }
public static ServerResponse BeginGame() { string playerId = System.Guid.NewGuid().ToString(); //stub in for now; eventually have a text field where player can enter name string playerName = "Chase"; Command command = new BeginNewGame(playerId, playerName); Aggregate player = new PlayerAggregate(); bool success = CommandHandler.HandleCommand(player, playerId, command); ServerResponse response = new ServerResponse(playerId, ModelNameGetter.GetModelName(player.GetType()), !success); return(response); }
public async Task <IActionResult> GetPlayer([FromRoute] Guid playerId, [FromQuery] Boolean includeMemberships, CancellationToken cancellationToken) { PlayerAggregate player = await this.PlayerRepository.GetLatestVersion(playerId, cancellationToken); if (!player.HasBeenRegistered) { return(this.NotFound($"Player not found with Id {playerId}")); } GetPlayerResponse playerResponse = new GetPlayerResponse { DateOfBirth = player.DateOfBirth, EmailAddress = player.EmailAddress, HasBeenRegistered = player.HasBeenRegistered, ExactHandicap = player.ExactHandicap, FirstName = player.FirstName, FullName = player.FullName, Gender = player.Gender, HandicapCategory = player.HandicapCategory, LastName = player.LastName, MiddleName = player.MiddleName, PlayingHandicap = player.PlayingHandicap, SecurityUserId = player.SecurityUserId }; if (includeMemberships) { List <ClubMembershipResponse> playerMemberships = await this.Manager.GetPlayersClubMemberships(playerId, cancellationToken); if (playerMemberships != null && playerMemberships.Count != 0) { playerMemberships.ForEach(p => { playerResponse.ClubMemberships.Add(new PlayerClubMembership { MembershipId = p.MembershipId, Status = p.Status.ConvertTo <MembershipStatus>(), MembershipNumber = p.MembershipNumber, RejectionReason = p.RejectionReason, AcceptedDateTime = p.AcceptedDateTime, GolfClubId = p.GolfClubId, GolfClubName = p.GolfClubName, RejectedDateTime = p.RejectedDateTime }); }); } } return(this.Ok(playerResponse)); }
public static PlayerAggregate GetRegisteredPlayerAggregate() { PlayerAggregate playerAggregate = PlayerAggregate.Create(PlayerTestData.AggregateId); playerAggregate.Register(PlayerTestData.FirstName, PlayerTestData.MiddleName, PlayerTestData.LastName, PlayerTestData.Gender, PlayerTestData.DateOfBirth, PlayerTestData.ExactHandicap, PlayerTestData.EmailAddress); return(playerAggregate); }
public void PlayerAggregate_Register_PlayerAlreadyRegistered_ErrorThrown() { PlayerAggregate playerAggregate = PlayerTestData.GetRegisteredPlayerAggregate(); Should.Throw <InvalidOperationException>(() => { playerAggregate.Register(PlayerTestData.FirstName, PlayerTestData.MiddleName, PlayerTestData.LastName, PlayerTestData.Gender, PlayerTestData.DateOfBirth, PlayerTestData.ExactHandicapCat1, PlayerTestData.EmailAddress); }); }
public void PlayerAggregate_Register_InvalidData(String firstName, String lastName, String gender, Boolean dateOfBirthInFuture, Decimal exactHandicap, String emailAddress, Type exceptionType) { PlayerAggregate playerAggregate = PlayerTestData.GetEmptyPlayerAggregate(); DateTime dateOfBirth = dateOfBirthInFuture ? DateTime.Now.AddYears(5) : PlayerTestData.DateOfBirth; Should.Throw(() => { playerAggregate.Register(firstName, PlayerTestData.MiddleName, lastName, gender, dateOfBirth, exactHandicap, emailAddress); }, exceptionType); }
/// <summary> /// Handles the command. /// </summary> /// <param name="command">The command.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns></returns> private async Task HandleCommand(RegisterPlayerCommand command, CancellationToken cancellationToken) { // Rehydrate the aggregate PlayerAggregate player = await this.PlayerRepository.GetLatestVersion(command.PlayerId, cancellationToken); // Call the aggregate method player.Register(command.RegisterPlayerRequest.GivenName, command.RegisterPlayerRequest.MiddleName, command.RegisterPlayerRequest.FamilyName, command.RegisterPlayerRequest.Gender, command.RegisterPlayerRequest.DateOfBirth, command.RegisterPlayerRequest.ExactHandicap, command.RegisterPlayerRequest.EmailAddress); // Now create a security user RegisterUserRequest request = new RegisterUserRequest { EmailAddress = command.RegisterPlayerRequest.EmailAddress, Claims = new Dictionary <String, String> { { "PlayerId", command.PlayerId.ToString() } }, Password = "******", PhoneNumber = "123456789", MiddleName = command.RegisterPlayerRequest.MiddleName, FamilyName = command.RegisterPlayerRequest.FamilyName, GivenName = command.RegisterPlayerRequest.GivenName, Roles = new List <String> { "Player" } }; RegisterUserResponse createSecurityUserResponse = await this.OAuth2SecurityService.RegisterUser(request, cancellationToken); // Record this in the aggregate player.CreateSecurityUser(createSecurityUserResponse.UserId); // Save the changes await this.PlayerRepository.SaveChanges(player, cancellationToken); // Setup the response command.Response = new RegisterPlayerResponse { PlayerId = command.PlayerId }; }
public void PlayerAggregate_Register_PlayerRegistered_HandicapEdgeCase_HighEnd(Int32 category, Decimal highendValue) { PlayerAggregate playerAggregate = PlayerTestData.GetEmptyPlayerAggregate(); Decimal exactHandicap = 0; Int32 handicapCategory = 0; switch (category) { case 1: exactHandicap = highendValue; handicapCategory = PlayerTestData.HandicapCategoryCat1; break; case 2: exactHandicap = highendValue; handicapCategory = PlayerTestData.HandicapCategoryCat2; break; case 3: exactHandicap = highendValue; handicapCategory = PlayerTestData.HandicapCategoryCat3; break; case 4: exactHandicap = highendValue; handicapCategory = PlayerTestData.HandicapCategoryCat4; break; case 5: exactHandicap = highendValue; handicapCategory = PlayerTestData.HandicapCategoryCat5; break; } playerAggregate.Register(PlayerTestData.FirstName, PlayerTestData.MiddleName, PlayerTestData.LastName, PlayerTestData.Gender, PlayerTestData.DateOfBirth, exactHandicap, PlayerTestData.EmailAddress); playerAggregate.HandicapCategory.ShouldBe(handicapCategory); }
public static PlayerAggregate GetRegisteredPlayerAggregateWithHandicapAdjustment() { PlayerAggregate playerAggregate = PlayerAggregate.Create(PlayerTestData.AggregateId); playerAggregate.Register(PlayerTestData.FirstName, PlayerTestData.MiddleName, PlayerTestData.LastName, PlayerTestData.Gender, PlayerTestData.DateOfBirth, PlayerTestData.ExactHandicap, PlayerTestData.EmailAddress); playerAggregate.AdjustHandicap(PlayerTestData.HandicapAdjustment, PlayerTestData.TournamentId, PlayerTestData.GolfClubId, PlayerTestData.MeasuredCourseId, PlayerTestData.ScoreDate); return(playerAggregate); }
public void PlayerAggregate_AdjustHandicap_InvalidData_ErrorThrown(Boolean validAdjustment, Boolean validTournamentId, Boolean validGolfClubId, Boolean validMeasuredCourseId, Boolean validScoreDate, Type exceptionType) { PlayerAggregate playerAggregate = PlayerTestData.GetRegisteredPlayerAggregate(); HandicapAdjustmentDataTransferObject handicapAdjustment = validAdjustment ? PlayerTestData.HandicapAdjustment : null; Guid tournamentId = validTournamentId ? PlayerTestData.TournamentId : Guid.Empty; Guid golfClubId = validGolfClubId ? PlayerTestData.GolfClubId : Guid.Empty; Guid measuredCourseId = validMeasuredCourseId ? PlayerTestData.MeasuredCourseId : Guid.Empty; DateTime scoreDate = validScoreDate ? PlayerTestData.ScoreDate: DateTime.MinValue; Should.Throw(() => { playerAggregate.AdjustHandicap(handicapAdjustment, tournamentId, golfClubId, measuredCourseId, scoreDate); }, exceptionType); }
/// <summary> /// Applies the handicap adjustment. /// </summary> /// <param name="score">The score.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns></returns> private async Task ApplyHandicapAdjustment(PlayerScoreRecordDataTransferObject score, CancellationToken cancellationToken) { PlayerAggregate playerAggregate = await this.PlayerRepository.GetLatestVersion(score.PlayerId, cancellationToken); List <HandicapAdjustment> adjustments = this.HandicapAdjustmentCalculatorService.CalculateHandicapAdjustment(playerAggregate.ExactHandicap, score.CSS, score.HoleScores); Logger.LogInformation($"Player Id {playerAggregate.AggregateId} Total Adjustment [{adjustments.Sum(x => x.TotalAdjustment)}]"); foreach (HandicapAdjustment adjustment in adjustments) { Player.HandicapAdjustmentDataTransferObject handicapAdjustment = new Player.HandicapAdjustmentDataTransferObject { TotalAdjustment = adjustment.TotalAdjustment, AdjustmentValuePerStroke = adjustment.AdjustmentValuePerStroke, NumberOfStrokesBelowCss = adjustment.NumberOfStrokesBelowCss }; playerAggregate.AdjustHandicap(handicapAdjustment, score.TournamentId, score.GolfClubId, score.MeasuredCourseId, score.ScoreDate); } await this.PlayerRepository.SaveChanges(playerAggregate, cancellationToken); }
public void PlayerAggregate_CreateSecurityUser_PlayerNotRegistered_ErrorThrown() { PlayerAggregate playerAggregate = PlayerTestData.GetEmptyPlayerAggregate(); Should.Throw <InvalidOperationException>(() => { playerAggregate.CreateSecurityUser(PlayerTestData.SecurityUserId); }); }
public void PlayerAggregate_CreateSecurityUser_SecurityUserAlreadyAdded_ErrorThrown() { PlayerAggregate playerAggregate = PlayerTestData.GetRegisteredPlayerAggregateWithSecurityUserCreated(); Should.Throw <InvalidOperationException>(() => { playerAggregate.CreateSecurityUser(PlayerTestData.SecurityUserId); }); }
public void PlayerAggregate_CreateSecurityUser_InvalidData_ErrorThrown() { PlayerAggregate playerAggregate = PlayerTestData.GetRegisteredPlayerAggregate(); Should.Throw <ArgumentNullException>(() => { playerAggregate.CreateSecurityUser(Guid.Empty); }); }
public AnalysisCenter(League league, Team team) { InitializeComponent(); this.league = league; this.team = team; this.lblTeam.Text = string.Format("{0}: {1}, {2,12:C2}", team.Name, team.Owner, team.Budget); LeagueConstants lc = LeagueConstants.For(league.FantasyLeague); this.stats = new List <Stat>(); this.stats.Add(new Stat("Runs", new CountingStatAnalyzer("Runs", lc.RosterableBatterCountPerTeam * lc.TeamCount, league.Batters, b => ((Batter)b).ProjectedR, b => string.IsNullOrEmpty(b.FantasyTeam) ? 0 : ((Batter)b).ProjectedR))); this.stats.Add(new Stat("Home Runs", new CountingStatAnalyzer("Home Runs", lc.RosterableBatterCountPerTeam * lc.TeamCount, league.Batters, b => ((Batter)b).ProjectedHR, b => string.IsNullOrEmpty(b.FantasyTeam) ? 0 : ((Batter)b).ProjectedHR))); this.stats.Add(new Stat("RBIs", new CountingStatAnalyzer("RBIs", lc.RosterableBatterCountPerTeam * lc.TeamCount, league.Batters, b => ((Batter)b).ProjectedRBI, b => string.IsNullOrEmpty(b.FantasyTeam) ? 0 : ((Batter)b).ProjectedRBI))); this.stats.Add(new Stat("Steals", new CountingStatAnalyzer("Steals", lc.RosterableBatterCountPerTeam * lc.TeamCount, league.Batters, b => ((Batter)b).ProjectedSB, b => string.IsNullOrEmpty(b.FantasyTeam) ? 0 : ((Batter)b).ProjectedSB))); this.stats.Add(new Stat("OPS", new RatioStatAnalyzer("OPS", lc.RosterableBatterCountPerTeam * lc.TeamCount, true, league.Batters, b => ((Batter)b).ProjectedBB + ((Batter)b).ProjectedH, b => ((Batter)b).ProjectedAB))); this.stats.Add(new Stat("Wins", new CountingStatAnalyzer("Wins", lc.RosterablePitcherCountPerTeam * lc.TeamCount, league.Pitchers, p => ((Pitcher)p).ProjectedW, p => string.IsNullOrEmpty(p.FantasyTeam) ? 0 : ((Pitcher)p).ProjectedW))); this.stats.Add(new Stat("Saves", new CountingStatAnalyzer("Saves", lc.RosterablePitcherCountPerTeam * lc.TeamCount, league.Pitchers, p => ((Pitcher)p).ProjectedSV, p => string.IsNullOrEmpty(p.FantasyTeam) ? 0 : ((Pitcher)p).ProjectedSV))); this.stats.Add(new Stat("Strikeouts", new CountingStatAnalyzer("Strikeouts", lc.RosterablePitcherCountPerTeam * lc.TeamCount, league.Pitchers, p => ((Pitcher)p).ProjectedK, p => string.IsNullOrEmpty(p.FantasyTeam) ? 0 : ((Pitcher)p).ProjectedK))); this.stats.Add(new Stat("ERA", new RatioStatAnalyzer("ERA", lc.RosterablePitcherCountPerTeam * lc.TeamCount, false, league.Pitchers, p => ((Pitcher)p).ProjectedER * 27, p => ((Pitcher)p).ProjectedOutsRecorded))); this.stats.Add(new Stat("WHIP", new RatioStatAnalyzer("WHIP", lc.RosterablePitcherCountPerTeam * lc.TeamCount, false, league.Pitchers, p => (((Pitcher)p).ProjectedWalks + ((Pitcher)p).ProjectedHits) * 3, p => ((Pitcher)p).ProjectedOutsRecorded))); Dictionary <IPlayer, PlayerAggregate> playerAnalysis = new Dictionary <IPlayer, PlayerAggregate>(); foreach (Stat stat in this.stats) { foreach (PlayerAnalysis analysis in stat.Analyzer.Analyze()) { PlayerAggregate agg; if (!playerAnalysis.TryGetValue(analysis.Player, out agg)) { agg = new PlayerAggregate(analysis.Player); playerAnalysis[analysis.Player] = agg; } agg.Analyses.Add(analysis); } } float budgetPerStat = team.Budget / this.stats.Count; this.allAggregates = new List <PlayerAggregate>(); foreach (PlayerAggregate agg in playerAnalysis.Values) { agg.Summarize(budgetPerStat, this.stats); this.allAggregates.Add(agg); } this.allAggregates.Sort((x, y) => y.ProjectedValue.CompareTo(x.ProjectedValue)); this.filteredAggregates = new List <PlayerAggregate>(); this.UpdatePlayerFilter(); this.WordWheelPlayers(); this.UpdateWB(); this.lvAnalysis.BeginUpdate(); int columnWidth = this.lvAnalysis.Width / (lc.ScoringStatExtractors.Count + lc.SupportingStatExtractors.Count + 1); this.lvAnalysis.Columns.Add("Player Name", columnWidth); foreach (IStatExtractor extractor in lc.ScoringStatExtractors.Union(lc.SupportingStatExtractors)) { ColumnHeader column = new ColumnHeader(); column.Text = extractor.StatName; column.Width = columnWidth; if (!extractor.MoreIsBetter) { column.Tag = "asc"; } this.lvAnalysis.Columns.Add(column); } this.lvAnalysis.EndUpdate(); this.UpdatePlayerListView(league.AllPlayers); }
public static PlayerAggregate GetEmptyPlayerAggregate() { PlayerAggregate playerAggregate = PlayerAggregate.Create(PlayerTestData.AggregateId); return(playerAggregate); }