/// <summary>
/// Gets the player scores report.
/// </summary>
/// <param name="playerId">The player identifier.</param>
/// <param name="numberOfScores">The number of scores.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <GetPlayerScoresResponse> GetPlayerScoresReport(Guid playerId,
Int32 numberOfScores,
CancellationToken cancellationToken)
{
Guard.ThrowIfInvalidGuid(playerId, nameof(playerId));
Guard.ThrowIfZero(numberOfScores, nameof(numberOfScores));
Guard.ThrowIfNegative(numberOfScores, nameof(numberOfScores));
GetPlayerScoresResponse response = new GetPlayerScoresResponse();
using (ManagementAPIReadModel context = this.ReadModelResolver())
{
List <PublishedPlayerScore> reportData = await context.PublishedPlayerScores.Where(p => p.PlayerId == playerId).OrderByDescending(p => p.TournamentDate).Take(numberOfScores).ToListAsync(cancellationToken);
reportData.ForEach(f => response.Scores.Add(new PlayerScoreResponse
{
TournamentDate = f.TournamentDate,
GolfClubId = f.GolfClubId,
MeasuredCourseId = f.MeasuredCourseId,
PlayerId = f.PlayerId,
TournamentId = f.TournamentId,
NetScore = f.NetScore,
MeasuredCourseName = f.MeasuredCourseName,
GolfClubName = f.GolfClubName,
MeasuredCourseTeeColour = f.MeasuredCourseTeeColour,
TournamentFormat = (TournamentFormat)f.TournamentFormat,
GrossScore = f.GrossScore,
CSS = f.CSS,
TournamentName = f.TournamentName,
PlayingHandicap = f.PlayingHandicap
}));
}
return(response);
}
private ManagementAPIReadModel GetContext(String databaseName)
{
DbContextOptionsBuilder <ManagementAPIReadModel> builder = new DbContextOptionsBuilder <ManagementAPIReadModel>()
.UseInMemoryDatabase(databaseName)
.ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning));
ManagementAPIReadModel context = new ManagementAPIReadModel(builder.Options);
return(context);
}
/// <summary>
/// Initialises the database.
/// </summary>
/// <param name="app">The application.</param>
/// <param name="environment">The environment.</param>
private async Task InitialiseDatabase(IApplicationBuilder app,
IHostingEnvironment environment)
{
using (IServiceScope scope = app.ApplicationServices.GetService <IServiceScopeFactory>().CreateScope())
{
ManagementAPIReadModel managementApiReadModel = scope.ServiceProvider.GetRequiredService <ManagementAPIReadModel>();
SeedingType seedingType = Startup.Configuration.GetValue <SeedingType>("SeedingType");
DatabaseSeeding.InitialiseDatabase(managementApiReadModel, seedingType);
}
}
public async Task ReportingManager_GetNumberOfMembersByAgeCategoryReport_NoMembers_ReportDataReturned()
{
String databaseName = Guid.NewGuid().ToString("N");
ManagementAPIReadModel context = this.GetContext(databaseName);
Func <ManagementAPIReadModel> contextResolver = () => { return(context); };
ReportingManager reportingManager = new ReportingManager(contextResolver);
GetNumberOfMembersByAgeCategoryReportResponse reportData = await reportingManager.GetNumberOfMembersByAgeCategoryReport(GolfClubTestData.AggregateId, CancellationToken.None);
reportData.GolfClubId.ShouldBe(GolfClubTestData.AggregateId);
reportData.MembersByAgeCategoryResponse.ShouldBeEmpty();
}
public async Task ReportingManager_GetPlayerScores_NoMembers_ReportDataReturned()
{
String databaseName = Guid.NewGuid().ToString("N");
ManagementAPIReadModel context = this.GetContext(databaseName);
List <PublishedPlayerScore> reportingData = new List <PublishedPlayerScore>();
Func <ManagementAPIReadModel> contextResolver = () => { return(context); };
ReportingManager reportingManager = new ReportingManager(contextResolver);
GetPlayerScoresResponse reportData = await reportingManager.GetPlayerScoresReport(PlayerTestData.AggregateId, 10, CancellationToken.None);
reportData.Scores.Count.ShouldBe(reportingData.Count);
}
public async Task ReportingManager_GetMembersHandicapListReport_NoMembers_ReportDataReturned()
{
String databaseName = Guid.NewGuid().ToString("N");
ManagementAPIReadModel context = this.GetContext(databaseName);
List <PlayerHandicapListReporting> reportingData = new List <PlayerHandicapListReporting>();
Func <ManagementAPIReadModel> contextResolver = () => { return(context); };
ReportingManager reportingManager = new ReportingManager(contextResolver);
GetMembersHandicapListReportResponse reportData = await reportingManager.GetMembersHandicapListReport(GolfClubTestData.AggregateId, CancellationToken.None);
reportData.GolfClubId.ShouldBe(GolfClubTestData.AggregateId);
reportData.MembersHandicapListReportResponse.Count.ShouldBe(reportingData.Count);
}
/// <summary>
/// Gets the number of members report.
/// </summary>
/// <param name="golfClubId">The golf club identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <GetNumberOfMembersReportResponse> GetNumberOfMembersReport(Guid golfClubId,
CancellationToken cancellationToken)
{
Guard.ThrowIfInvalidGuid(golfClubId, nameof(golfClubId));
GetNumberOfMembersReportResponse response = new GetNumberOfMembersReportResponse();
using (ManagementAPIReadModel context = this.ReadModelResolver())
{
Int32 membersCount = await context.GolfClubMembershipReporting.CountAsync(g => g.GolfClubId == golfClubId, cancellationToken);
response.NumberOfMembers = membersCount;
response.GolfClubId = golfClubId;
}
return(response);
}
public async Task ReportingManager_GetNumberOfMembersByTimePeriodReport_NoMembers_ReportDataReturned(String timePeriod, TimePeriod expectedTimePeriod)
{
String databaseName = Guid.NewGuid().ToString("N");
ManagementAPIReadModel context = this.GetContext(databaseName);
List <GolfClubMembershipReporting> reportingData = new List <GolfClubMembershipReporting>();
Func <ManagementAPIReadModel> contextResolver = () => { return(context); };
ReportingManager reportingManager = new ReportingManager(contextResolver);
GetNumberOfMembersByTimePeriodReportResponse reportData = await reportingManager.GetNumberOfMembersByTimePeriodReport(GolfClubTestData.AggregateId, timePeriod, CancellationToken.None);
reportData.GolfClubId.ShouldBe(GolfClubTestData.AggregateId);
reportData.TimePeriod.ShouldBe(expectedTimePeriod);
reportData.MembersByTimePeriodResponse.ShouldBeEmpty();
}
public async Task ReportingManager_GetNumberOfMembersReport_ReportDataReturned()
{
String databaseName = Guid.NewGuid().ToString("N");
ManagementAPIReadModel context = this.GetContext(databaseName);
List <GolfClubMembershipReporting> reportingData = new List <GolfClubMembershipReporting>();
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-20),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 1,
PlayerGender = "M",
PlayerName = "Test Player 1"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-25),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 2,
PlayerGender = "M",
PlayerName = "Test Player 2"
});
await context.GolfClubMembershipReporting.AddRangeAsync(reportingData, CancellationToken.None);
await context.SaveChangesAsync(CancellationToken.None);
Func <ManagementAPIReadModel> contextResolver = () => { return(context); };
ReportingManager reportingManager = new ReportingManager(contextResolver);
GetNumberOfMembersReportResponse reportData = await reportingManager.GetNumberOfMembersReport(GolfClubTestData.AggregateId, CancellationToken.None);
reportData.GolfClubId.ShouldBe(GolfClubTestData.AggregateId);
reportData.NumberOfMembers.ShouldBe(reportingData.Count);
}
/// <summary>
/// Gets the number of members by age category report.
/// </summary>
/// <param name="golfClubId">The golf club identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <GetNumberOfMembersByAgeCategoryReportResponse> GetNumberOfMembersByAgeCategoryReport(Guid golfClubId,
CancellationToken cancellationToken)
{
// TODO: get the configured age categories from the golf club record
Guard.ThrowIfInvalidGuid(golfClubId, nameof(golfClubId));
GetNumberOfMembersByAgeCategoryReportResponse response = new GetNumberOfMembersByAgeCategoryReportResponse();
using (ManagementAPIReadModel context = this.ReadModelResolver())
{
// Get the members grouped by age
IQueryable <GolfClubMembershipReporting> members = context.GolfClubMembershipReporting.Where(g => g.GolfClubId == golfClubId).AsQueryable();
DateTime zeroTime = new DateTime(1, 1, 1);
// Group the members records by age
var membersByAge = members.GroupBy(g => (zeroTime + DateTime.Now.Date.Subtract(g.DateOfBirth)).Year).Select(x => new
{
Age = x.Key,
Count = x.Count()
});
// Now build the members by age category to go into the response
var membersByAgeCategory = membersByAge.Select(x => new
{
AgeCategory = (x.Age < 17 ? "Junior" :
x.Age >= 17 && x.Age < 19 ? "Juvenile" :
x.Age >= 19 && x.Age < 21 ? "Youth" :
x.Age >= 21 && x.Age < 25 ? "Young Adult" :
x.Age >= 25 && x.Age < 65 ? "Adult" :
x.Age >= 65 ? "Senior" : "Unknown"),
Count = x.Count
});
response.GolfClubId = golfClubId;
response.MembersByAgeCategoryResponse = membersByAgeCategory.GroupBy(g => g.AgeCategory).Select(x => new MembersByAgeCategoryResponse
{
AgeCategory = x.Key,
NumberOfMembers = x.Sum(s => s.Count)
}).ToList();
}
return(response);
}
public static void InitialiseDatabase(ManagementAPIReadModel managementApiReadModel,
SeedingType seedingType)
{
try
{
if (managementApiReadModel.Database.IsSqlServer())
{
managementApiReadModel.Database.Migrate();
}
managementApiReadModel.SaveChanges();
}
catch (Exception ex)
{
String connString = managementApiReadModel.Database.GetDbConnection().ConnectionString;
Exception newException = new Exception($"Connection String [{connString}]", ex);
throw newException;
}
}
public async Task ReportingManager_GetMembersHandicapListReport_ReportDataReturned()
{
String databaseName = Guid.NewGuid().ToString("N");
ManagementAPIReadModel context = this.GetContext(databaseName);
List <PlayerHandicapListReporting> reportingData = new List <PlayerHandicapListReporting>();
reportingData.Add(new PlayerHandicapListReporting
{
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
HandicapCategory = 1,
PlayerName = "Test Player 1",
ExactHandicap = 5.4m,
PlayingHandicap = 5
});
reportingData.Add(new PlayerHandicapListReporting
{
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
HandicapCategory = 2,
PlayerName = "Test Player 2",
ExactHandicap = 12.8m,
PlayingHandicap = 13
});
await context.PlayerHandicapListReporting.AddRangeAsync(reportingData, CancellationToken.None);
await context.SaveChangesAsync(CancellationToken.None);
Func <ManagementAPIReadModel> contextResolver = () => { return(context); };
ReportingManager reportingManager = new ReportingManager(contextResolver);
GetMembersHandicapListReportResponse reportData = await reportingManager.GetMembersHandicapListReport(GolfClubTestData.AggregateId, CancellationToken.None);
reportData.GolfClubId.ShouldBe(GolfClubTestData.AggregateId);
reportData.MembersHandicapListReportResponse.ShouldNotBeEmpty();
reportData.MembersHandicapListReportResponse.Count.ShouldBe(reportingData.Count);
}
/// <summary>
/// Gets the members handicap list report.
/// </summary>
/// <param name="golfClubId">The golf club identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <GetMembersHandicapListReportResponse> GetMembersHandicapListReport(Guid golfClubId,
CancellationToken cancellationToken)
{
Guard.ThrowIfInvalidGuid(golfClubId, nameof(golfClubId));
GetMembersHandicapListReportResponse response = new GetMembersHandicapListReportResponse();
using (ManagementAPIReadModel context = this.ReadModelResolver())
{
List <PlayerHandicapListReporting> reportData = context.PlayerHandicapListReporting.Where(p => p.GolfClubId == golfClubId).ToList();
response.GolfClubId = golfClubId;
reportData.ForEach(f => response.MembersHandicapListReportResponse.Add(new MembersHandicapListReportResponse
{
GolfClubId = f.GolfClubId,
PlayerId = f.PlayerId,
HandicapCategory = f.HandicapCategory,
ExactHandicap = f.ExactHandicap,
PlayingHandicap = f.PlayingHandicap,
PlayerName = f.PlayerName
}));
}
return(response);
}
/// <summary>
/// Gets the number of members by handicap category report.
/// </summary>
/// <param name="golfClubId">The golf club identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <GetNumberOfMembersByHandicapCategoryReportResponse> GetNumberOfMembersByHandicapCategoryReport(Guid golfClubId,
CancellationToken cancellationToken)
{
Guard.ThrowIfInvalidGuid(golfClubId, nameof(golfClubId));
GetNumberOfMembersByHandicapCategoryReportResponse response = new GetNumberOfMembersByHandicapCategoryReportResponse();
using (ManagementAPIReadModel context = this.ReadModelResolver())
{
response.GolfClubId = golfClubId;
List <IGrouping <Int32, GolfClubMembershipReporting> > groupedData = await context.GolfClubMembershipReporting.Where(g => g.GolfClubId == golfClubId).GroupBy(g => g.HandicapCategory).ToListAsync(cancellationToken);
foreach (IGrouping <Int32, GolfClubMembershipReporting> golfClubMembershipReportings in groupedData)
{
response.MembersByHandicapCategoryResponse.Add(new MembersByHandicapCategoryResponse
{
HandicapCategory = golfClubMembershipReportings.Key,
NumberOfMembers = golfClubMembershipReportings.Count()
});
}
}
return(response);
}
public async Task ReportingManager_GetPlayerScores_ReportDataReturned()
{
String databaseName = Guid.NewGuid().ToString("N");
ManagementAPIReadModel context = this.GetContext(databaseName);
List <PublishedPlayerScore> reportingData = new List <PublishedPlayerScore>();
reportingData.Add(new PublishedPlayerScore
{
TournamentDate = TournamentTestData.TournamentDate,
PlayerId = PlayerTestData.AggregateId,
TournamentFormat = TournamentTestData.TournamentFormat,
GolfClubId = TournamentTestData.GolfClubId,
MeasuredCourseId = TournamentTestData.MeasuredCourseId,
TournamentId = TournamentTestData.AggregateId,
CSS = TournamentTestData.CSS,
NetScore = TournamentTestData.NetScore,
MeasuredCourseName = GolfClubTestData.MeasuredCourseName,
GolfClubName = GolfClubTestData.Name,
MeasuredCourseTeeColour = GolfClubTestData.TeeColour,
GrossScore = TournamentTestData.GrossScore,
TournamentName = TournamentTestData.Name
});
await context.PublishedPlayerScores.AddRangeAsync(reportingData, CancellationToken.None);
await context.SaveChangesAsync(CancellationToken.None);
Func <ManagementAPIReadModel> contextResolver = () => { return(context); };
ReportingManager reportingManager = new ReportingManager(contextResolver);
GetPlayerScoresResponse reportData = await reportingManager.GetPlayerScoresReport(PlayerTestData.AggregateId, 10, CancellationToken.None);
reportData.Scores.Count.ShouldBe(reportingData.Count);
}
/// <summary>
/// Gets the number of members by time period report.
/// </summary>
/// <param name="golfClubId">The golf club identifier.</param>
/// <param name="timePeriod">The time period.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <GetNumberOfMembersByTimePeriodReportResponse> GetNumberOfMembersByTimePeriodReport(Guid golfClubId,
String timePeriod,
CancellationToken cancellationToken)
{
TimePeriod parsedTimePeriod = Enum.Parse <TimePeriod>(timePeriod, true);
GetNumberOfMembersByTimePeriodReportResponse response = new GetNumberOfMembersByTimePeriodReportResponse();
response.GolfClubId = golfClubId;
using (ManagementAPIReadModel context = this.ReadModelResolver())
{
// get the base query data
IQueryable <GolfClubMembershipReporting> data = context.GolfClubMembershipReporting.Where(r => r.GolfClubId == golfClubId).AsQueryable();
List <MembersByTimePeriodResponse> membersByTimePeriodResponse = null;
// Build the database query depending on the time period requested
if (parsedTimePeriod == TimePeriod.Day)
{
response.TimePeriod = Service.DataTransferObjects.Responses.TimePeriod.Day;
membersByTimePeriodResponse = data.GroupBy(x => new
{
x.DateJoined.Date
},
(key,
group) => new MembersByTimePeriodResponse
{
Period = key.Date.ToString("yyyy-MM-dd"),
NumberOfMembers = group.Count()
}).ToList();
}
// TODO: May re-introduce this later on
//else if (parsedTimePeriod == TimePeriod.Week)
//{
// response.TimePeriod = Service.DataTransferObjects.Responses.TimePeriod.Week;
// membersByTimePeriodResponse = data.GroupBy(x => new
// {
// x.DateJoined.Date
// },
// (key,
// group) => new MembersByTimePeriodResponse
// {
// Period = $"{key.Date.ToString("yyyy")}-{ISOWeek.GetWeekNumber(key.Date):D2}",
// NumberOfMembers = group.Count()
// }).ToList();
//}
else if (parsedTimePeriod == TimePeriod.Month)
{
response.TimePeriod = Service.DataTransferObjects.Responses.TimePeriod.Month;
membersByTimePeriodResponse = data.GroupBy(x => new
{
x.DateJoined.Date
},
(key,
group) => new MembersByTimePeriodResponse
{
Period = key.Date.ToString("yyyy-MM"),
NumberOfMembers = group.Count()
}).ToList();
membersByTimePeriodResponse = membersByTimePeriodResponse.GroupBy(g => g.Period).Select(x => new MembersByTimePeriodResponse
{
Period = x.Key,
NumberOfMembers = x.Sum(s => s.NumberOfMembers)
}).ToList();
}
else if (parsedTimePeriod == TimePeriod.Year)
{
response.TimePeriod = Service.DataTransferObjects.Responses.TimePeriod.Year;
membersByTimePeriodResponse = data.GroupBy(x => new
{
Year = x.DateJoined.Date
},
(key,
group) => new MembersByTimePeriodResponse
{
Period = key.Year.ToString("yyyy"),
NumberOfMembers = group.Count()
}).ToList();
membersByTimePeriodResponse = membersByTimePeriodResponse.GroupBy(g => g.Period).Select(x => new MembersByTimePeriodResponse
{
Period = x.Key,
NumberOfMembers = x.Sum(s => s.NumberOfMembers)
}).ToList();
}
Int32 runningTotal = 0;
response.MembersByTimePeriodResponse = membersByTimePeriodResponse?.OrderBy(x => x.Period).Select(x => new MembersByTimePeriodResponse
{
NumberOfMembers = runningTotal += x.NumberOfMembers,
Period = x.Period
}).ToList();
}
return(response);
}
public async Task ReportingManager_GetNumberOfMembersByTimePeriodReport_ByYear_ReportDataReturned()
{
String databaseName = Guid.NewGuid().ToString("N");
ManagementAPIReadModel context = this.GetContext(databaseName);
List <GolfClubMembershipReporting> reportingData = new List <GolfClubMembershipReporting>();
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = new DateTime(2019, 08, 16),
DateOfBirth = DateTime.Now.AddYears(-20),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 1,
PlayerGender = "M",
PlayerName = "Test Player 1"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = new DateTime(2019, 08, 16),
DateOfBirth = DateTime.Now.AddYears(-25),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 2,
PlayerGender = "M",
PlayerName = "Test Player 2"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = new DateTime(2018, 08, 16),
DateOfBirth = DateTime.Now.AddYears(-25),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 2,
PlayerGender = "M",
PlayerName = "Test Player 3"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = new DateTime(2018, 07, 15),
DateOfBirth = DateTime.Now.AddYears(-25),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 4"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = new DateTime(2018, 07, 14),
DateOfBirth = DateTime.Now.AddYears(-25),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 5"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = new DateTime(2017, 06, 13),
DateOfBirth = DateTime.Now.AddYears(-25),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 6"
});
context.GolfClubMembershipReporting.AddRange(reportingData);
context.SaveChanges();
Func <ManagementAPIReadModel> contextResolver = () => { return(context); };
ReportingManager reportingManager = new ReportingManager(contextResolver);
GetNumberOfMembersByTimePeriodReportResponse reportData = await reportingManager.GetNumberOfMembersByTimePeriodReport(GolfClubTestData.AggregateId, TimePeriod.Year.ToString(), CancellationToken.None);
reportData.GolfClubId.ShouldBe(GolfClubTestData.AggregateId);
reportData.TimePeriod.ShouldBe(TimePeriod.Year);
reportData.MembersByTimePeriodResponse.ShouldNotBeNull();
reportData.MembersByTimePeriodResponse.ShouldNotBeEmpty();
reportData.MembersByTimePeriodResponse.Count.ShouldBe(3);
reportData.MembersByTimePeriodResponse[0].Period.ShouldBe("2017");
reportData.MembersByTimePeriodResponse[0].NumberOfMembers.ShouldBe(1);
reportData.MembersByTimePeriodResponse[1].Period.ShouldBe("2018");
reportData.MembersByTimePeriodResponse[1].NumberOfMembers.ShouldBe(4);
reportData.MembersByTimePeriodResponse[2].Period.ShouldBe("2019");
reportData.MembersByTimePeriodResponse[2].NumberOfMembers.ShouldBe(6);
}
public async Task ReportingManager_GetNumberOfMembersByAgeCategoryReport_ReportDataReturned()
{
String databaseName = Guid.NewGuid().ToString("N");
ManagementAPIReadModel context = this.GetContext(databaseName);
List <GolfClubMembershipReporting> reportingData = new List <GolfClubMembershipReporting>();
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-16),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 1,
PlayerGender = "M",
PlayerName = "Test Player 1"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-18),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 2,
PlayerGender = "M",
PlayerName = "Test Player 2"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-18),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 2,
PlayerGender = "M",
PlayerName = "Test Player 3"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-19),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 2,
PlayerGender = "M",
PlayerName = "Test Player 4"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-20),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 5"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-22),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 6"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-24),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 7"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-26),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 8"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-35),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 9"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-64),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 10"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-65),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 11"
});
reportingData.Add(new GolfClubMembershipReporting
{
DateJoined = DateTime.Now,
DateOfBirth = DateTime.Now.AddYears(-70),
PlayerId = Guid.NewGuid(),
GolfClubId = GolfClubTestData.AggregateId,
GolfClubName = GolfClubTestData.Name,
HandicapCategory = 3,
PlayerGender = "M",
PlayerName = "Test Player 12"
});
await context.GolfClubMembershipReporting.AddRangeAsync(reportingData, CancellationToken.None);
await context.SaveChangesAsync(CancellationToken.None);
Func <ManagementAPIReadModel> contextResolver = () => { return(context); };
ReportingManager reportingManager = new ReportingManager(contextResolver);
GetNumberOfMembersByAgeCategoryReportResponse reportData = await reportingManager.GetNumberOfMembersByAgeCategoryReport(GolfClubTestData.AggregateId, CancellationToken.None);
reportData.GolfClubId.ShouldBe(GolfClubTestData.AggregateId);
reportData.MembersByAgeCategoryResponse.ShouldNotBeEmpty();
reportData.MembersByAgeCategoryResponse.Single(q => q.AgeCategory == "Junior").NumberOfMembers.ShouldBe(1);
reportData.MembersByAgeCategoryResponse.Single(q => q.AgeCategory == "Juvenile").NumberOfMembers.ShouldBe(2);
reportData.MembersByAgeCategoryResponse.Single(q => q.AgeCategory == "Youth").NumberOfMembers.ShouldBe(2);
reportData.MembersByAgeCategoryResponse.Single(q => q.AgeCategory == "Young Adult").NumberOfMembers.ShouldBe(2);
reportData.MembersByAgeCategoryResponse.Single(q => q.AgeCategory == "Adult").NumberOfMembers.ShouldBe(3);
reportData.MembersByAgeCategoryResponse.Single(q => q.AgeCategory == "Senior").NumberOfMembers.ShouldBe(2);
}
public async Task StopContainersForScenarioRun()
{
try
{
IPEndPoint sqlEndpoint = Setup.DatabaseServerContainer.ToHostExposedEndpoint("1433/tcp");
String server = "127.0.0.1";
String database = $"ManagementAPIReadModel{this.TestId:N}";
String user = "******";
String password = "******";
String port = sqlEndpoint.Port.ToString();
String connectionString = $"server={server},{port};user id={user}; password={password}; database={database};";
ManagementAPI.Database.ManagementAPIReadModel context = new ManagementAPIReadModel(connectionString);
context.Database.EnsureDeleted();
if (this.ManagementAPIContainer != null)
{
this.ManagementAPIContainer.StopOnDispose = true;
this.ManagementAPIContainer.RemoveOnDispose = true;
this.ManagementAPIContainer.Dispose();
}
if (this.MessagingServiceContainer != null)
{
this.MessagingServiceContainer.StopOnDispose = true;
this.MessagingServiceContainer.RemoveOnDispose = true;
this.MessagingServiceContainer.Dispose();
}
if (this.EventStoreContainer != null)
{
this.EventStoreContainer.StopOnDispose = true;
this.EventStoreContainer.RemoveOnDispose = true;
this.EventStoreContainer.Dispose();
}
if (this.SecurityServiceContainer != null)
{
this.SecurityServiceContainer.StopOnDispose = true;
this.SecurityServiceContainer.RemoveOnDispose = true;
this.SecurityServiceContainer.Dispose();
}
if (this.SubscriptionServiceContainer != null)
{
this.SubscriptionServiceContainer.StopOnDispose = true;
this.SubscriptionServiceContainer.RemoveOnDispose = true;
this.SubscriptionServiceContainer.Dispose();
}
if (this.TestNetwork != null)
{
this.TestNetwork.Stop();
this.TestNetwork.Remove(true);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
