public async Task GivenWhenICreateATournamentWithTheFollowingDetails(Table table)
{
foreach (TableRow tableRow in table.Rows)
{
CreateGolfClubResponse createGolfClubResponse = this.TestingContext.GetCreateGolfClubResponse(tableRow["GolfClubNumber"]);
List <MeasuredCourseListResponse> measuredCourseList = await this.TestingContext.DockerHelper.GolfClubClient.GetMeasuredCourses(this.TestingContext.GolfClubAdministratorToken,
createGolfClubResponse.GolfClubId,
CancellationToken.None).ConfigureAwait(false);
MeasuredCourseListResponse measuredCourse = measuredCourseList.Single(m => m.Name == tableRow["MeasuredCourseName"]);
TournamentFormat tournamentFormat = Enum.Parse <TournamentFormat>(tableRow["TournamentFormat"], true);
PlayerCategory playerCategory = Enum.Parse <PlayerCategory>(tableRow["PlayerCategory"], true);
// Work out the tournament date
DateTime tournamentDate = this.CalculateTournamentDate(tableRow);
CreateTournamentRequest createTournamentRequest = new CreateTournamentRequest
{
Format = (Int32)tournamentFormat,
Name = tableRow["TournamentName"],
MeasuredCourseId = measuredCourse.MeasuredCourseId,
MemberCategory = (Int32)playerCategory,
TournamentDate = tournamentDate
};
this.TestingContext.CreateTournamentRequests.Add(new Tuple <String, String, String>(tableRow["GolfClubNumber"], tableRow["MeasuredCourseName"],
tableRow["TournamentNumber"]), createTournamentRequest);
}
}
public string GetMarketValue(PlayerCategory category)
{
string marketValue = "";
switch (category)
{
case PlayerCategory.Amateur:
marketValue = "100";
break;
case PlayerCategory.Professional:
marketValue = "1000";
break;
}
return(marketValue);
}
public void TournamentAggregate_CreateTournament_InvalidData_ErrorThrown(Boolean validTournamentDate,
Boolean validGolfClubId,
Boolean validMeasuredCourseId,
Int32 measuredCourseSSS,
String name,
PlayerCategory memberCategory,
TournamentFormat tournamentFormat,
Type exceptionType)
{
TournamentAggregate aggregate = TournamentTestData.GetEmptyTournamentAggregate();
DateTime tournamentDate = validTournamentDate ? TournamentTestData.TournamentDate : DateTime.MinValue;
Guid golfClubId = validGolfClubId ? TournamentTestData.GolfClubId : Guid.Empty;
Guid measuredCourseId = validMeasuredCourseId ? TournamentTestData.MeasuredCourseId : Guid.Empty;
Should.Throw(() => { aggregate.CreateTournament(tournamentDate, golfClubId, measuredCourseId, measuredCourseSSS, name, memberCategory, tournamentFormat); },
exceptionType);
}
public LongPeerId(ulong accountId, byte id, byte slot, PlayerCategory unk)
{
AccountId = accountId;
PeerId = new PeerId(id, slot, unk);
}
public PeerId(byte id, byte slot, PlayerCategory unk)
{
Id = id;
Slot = slot;
Category = unk;
}
public CategoryStats(PlayerCategory playerCategory)
{
this.category = playerCategory;
}
public virtual void SetCategory(PlayerCategory category)
{
Category = category;
}
