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);
}
