public async Task <IActionResult> GetTournamentList([FromRoute] Guid golfClubId, CancellationToken cancellationToken)
{
GetTournamentListResponse response = new GetTournamentListResponse();
using (MockDatabaseDbContext context = this.MockDatabaseDbContextResolver())
{
List <Tournament> tournaments = await context.Tournaments.Where(t => t.GolfClubId == golfClubId).ToListAsync(cancellationToken);
foreach (Tournament tournament in tournaments)
{
response.Tournaments.Add(new GetTournamentResponse
{
TournamentName = tournament.TournamentName,
TournamentId = tournament.TournamentId,
TournamentDate = tournament.TournamentDate,
HasBeenCancelled = tournament.HasBeenCancelled,
HasBeenCompleted = tournament.HasBeenCompleted,
HasResultBeenProduced = tournament.HasResultBeenProduced,
MeasuredCourseId = tournament.MeasuredCourseId,
MeasuredCourseName = tournament.MeasuredCourseName,
MeasuredCourseSSS = tournament.MeasuredCourseSSS,
MeasuredCourseTeeColour = tournament.MeasuredCourseTeeColour,
PlayerCategory = (PlayerCategory)tournament.PlayerCategory,
PlayersScoresRecordedCount = tournament.PlayersScoresRecordedCount,
PlayersSignedUpCount = tournament.PlayersSignedUpCount,
TournamentFormat = (TournamentFormat)tournament.TournamentFormat
});
}
}
return(this.Ok(response));
}
public async Task <IActionResult> GetPlayer([FromRoute] Guid playerId)
{
List <KeyValuePair <String, StringValues> > headers = this.Request.Headers.ToList();
using (MockDatabaseDbContext context = this.MockDatabaseDbContextResolver())
{
// Find the player
Player player = context.Players.SingleOrDefault(p => p.PlayerId == playerId);
if (player == null)
{
return(this.NotFound());
}
else
{
return(this.Ok(new GetPlayerDetailsResponse
{
DateOfBirth = player.DateOfBirth,
FirstName = player.FirstName,
EmailAddress = player.EmailAddress,
LastName = player.LastName,
ExactHandicap = player.ExactHandicap,
Gender = player.Gender,
FullName = $"{player.FirstName} {player.LastName}",
HasBeenRegistered = true,
PlayingHandicap = this.CalculatePlayingHandicap(player.ExactHandicap),
HandicapCategory = this.CalculateHandicapCategory(this.CalculatePlayingHandicap(player.ExactHandicap))
}));
}
}
}
public RequestClubMembershipSteps(ScenarioContext scenarioContext)
{
this.App = scenarioContext.Get <IApp>("App");
String connectionString = "server=192.168.1.132;database=MockDatabase;user id=root;password=Pa55word";
this.MockDatabase = new MockDatabaseDbContext(connectionString);
}
public FeatureBase(FeatureContext featureContext,
ScenarioContext scenarioContext)
{
this.FeatureContext = featureContext;
this.ScenarioContext = scenarioContext;
String connectionString = "server=192.168.1.132;database=MockDatabase;user id=root;password=Pa55word";
this.MockDatabase = new MockDatabaseDbContext(connectionString);
}
public void GivenThereAreNoPlayersSignedUp()
{
MockDatabaseDbContext context = this.MockDatabase;
List <RegisteredUser> usersToRemove = context.RegisteredUsers.ToList();
context.RemoveRange(usersToRemove);
List <Player> playersToRemove = context.Players.ToList();
context.RemoveRange(playersToRemove);
context.SaveChanges();
}
public void ThenTheDetailsForAreShown(String golfClubName)
{
MockDatabaseDbContext context = this.MockDatabase;
GolfClub golfClub = context.GolfClubs.Single(c => c.Name == golfClubName);
AppResult golfClubNameLabel = this.App.WaitForElement(c => c.Marked("GolfClubName")).Single();
AppResult townLabel = this.App.WaitForElement(c => c.Marked("Town")).Single();
AppResult regionLabel = this.App.WaitForElement(c => c.Marked("Region")).Single();
AppResult postCodeLabel = this.App.WaitForElement(c => c.Marked("PostCode")).Single();
golfClubNameLabel.Text.ShouldBe(golfClub.Name);
townLabel.Text.ShouldBe(golfClub.Town);
regionLabel.Text.ShouldBe(golfClub.Region);
postCodeLabel.Text.ShouldBe(golfClub.PostalCode);
}
public async Task <IActionResult> RequestClubMembership([FromRoute] Guid playerId,
[FromRoute] Guid golfClubId,
CancellationToken cancellationToken)
{
List <KeyValuePair <String, StringValues> > headers = this.Request.Headers.ToList();
String authHeader = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).SingleOrDefault().SingleOrDefault();
if (authHeader == null)
{
return(this.Unauthorized());
}
using (MockDatabaseDbContext context = this.MockDatabaseDbContextResolver())
{
Player player = context.Players.SingleOrDefault(p => p.PlayerId == playerId);
if (player == null)
{
return(this.BadRequest());
}
GolfClub golfClub = context.GolfClubs.SingleOrDefault(c => c.GolfClubId == golfClubId);
if (golfClub == null)
{
return(this.BadRequest());
}
GolfClubMembership membership = new GolfClubMembership
{
PlayerId = playerId,
AcceptedDateTime = DateTime.Now,
GolfClubId = golfClubId,
GolfClubName = golfClub.Name,
MembershipId = Guid.NewGuid(),
PlayerDateOfBirth = player.DateOfBirth,
PlayerFullName = $"{player.FirstName} {player.LastName}",
PlayerGender = player.Gender,
};
await context.GolfClubMemberships.AddAsync(membership, cancellationToken);
await context.SaveChangesAsync(cancellationToken);
}
return(this.NoContent());
}
public async Task <IActionResult> GetGolfClubList(CancellationToken cancellationToken)
{
List <KeyValuePair <String, StringValues> > headers = this.Request.Headers.ToList();
String authHeader = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).SingleOrDefault().SingleOrDefault();
if (authHeader == null)
{
return(this.Unauthorized());
}
using (MockDatabaseDbContext context = this.MockDatabaseDbContextResolver())
{
// Find the clubs
List <GolfClub> golfClubs = await context.GolfClubs.ToListAsync(cancellationToken);
if (!golfClubs.Any())
{
return(this.NotFound());
}
else
{
List <GetGolfClubResponse> response = new List <GetGolfClubResponse>();
foreach (GolfClub golfClub in golfClubs)
{
response.Add(new GetGolfClubResponse
{
AddressLine1 = golfClub.AddressLine1,
AddressLine2 = golfClub.AddressLine2,
EmailAddress = golfClub.EmailAddress,
Id = golfClub.GolfClubId,
Name = golfClub.Name,
PostalCode = golfClub.PostalCode,
Region = golfClub.Region,
TelephoneNumber = golfClub.TelephoneNumber,
Town = golfClub.Town,
Website = golfClub.Website
});
}
return(this.Ok(response));
}
}
}
public async Task <IActionResult> SignUpForTournament([FromRoute] Guid playerId,
[FromRoute] Guid tournamentId,
CancellationToken cancellationToken)
{
List <KeyValuePair <String, StringValues> > headers = this.Request.Headers.ToList();
String authHeader = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).SingleOrDefault().SingleOrDefault();
if (authHeader == null)
{
return(this.Unauthorized());
}
using (MockDatabaseDbContext context = this.MockDatabaseDbContextResolver())
{
Player player = context.Players.SingleOrDefault(p => p.PlayerId == playerId);
if (player == null)
{
return(this.BadRequest());
}
Tournament tournament = context.Tournaments.SingleOrDefault(t => t.TournamentId == tournamentId);
if (tournament == null)
{
return(this.BadRequest());
}
PlayerTournamentSignIn playerTournamentSignIn = new PlayerTournamentSignIn
{
PlayerId = playerId,
TournamentId = tournamentId
};
await context.PlayerTournamentSignIns.AddAsync(playerTournamentSignIn, cancellationToken);
await context.SaveChangesAsync(cancellationToken);
}
return(this.NoContent());
}
public async Task <IActionResult> PostPlayer([FromBody] RegisterPlayerRequest request,
CancellationToken cancellationToken)
{
// create a player
Player player = new Player
{
PlayerId = Guid.NewGuid(),
LastName = request.LastName,
FirstName = request.FirstName,
DateOfBirth = request.DateOfBirth,
EmailAddress = request.EmailAddress,
ExactHandicap = request.ExactHandicap,
Gender = request.Gender,
MiddleName = request.MiddleName
};
// create a user
RegisteredUser user = new RegisteredUser
{
EmailAddress = request.EmailAddress,
Password = "******",
UserId = Guid.NewGuid()
};
// Add to mock database
using (MockDatabaseDbContext context = this.MockDatabaseDbContextResolver())
{
await context.RegisteredUsers.AddAsync(user, cancellationToken);
await context.Players.AddAsync(player, cancellationToken);
await context.SaveChangesAsync(cancellationToken);
}
return(this.Ok(new RegisterPlayerResponse
{
PlayerId = player.PlayerId
}));
}
public void GivenTheFollowingGolfClubsAreRegistered(Table table)
{
MockDatabaseDbContext context = this.MockDatabase;
List <GolfClub> golfClubsToRemove = context.GolfClubs.ToList();
context.RemoveRange(golfClubsToRemove);
foreach (TableRow tableRow in table.Rows)
{
GolfClub golfClub = new GolfClub
{
GolfClubId = Guid.NewGuid(),
Name = tableRow["GolfClubName"],
Town = tableRow["Town"],
Region = tableRow["Region"],
PostalCode = tableRow["PostalCode"]
};
context.GolfClubs.Add(golfClub);
}
context.SaveChanges();
}
public async Task <IActionResult> GetPlayerMemberships([FromRoute] Guid playerId, CancellationToken cancellationToken)
{
List <KeyValuePair <String, StringValues> > headers = this.Request.Headers.ToList();
String authHeader = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).SingleOrDefault().SingleOrDefault();
if (authHeader == null)
{
return(this.Unauthorized());
}
using (MockDatabaseDbContext context = this.MockDatabaseDbContextResolver())
{
IQueryable <GolfClubMembership> playerMemberships = context.GolfClubMemberships.Where(m => m.PlayerId == playerId);
if (!playerMemberships.Any())
{
return(this.NotFound());
}
List <ClubMembershipResponse> membershipResponses = new List <ClubMembershipResponse>();
foreach (GolfClubMembership golfClubMembership in playerMemberships)
{
membershipResponses.Add(new ClubMembershipResponse
{
AcceptedDateTime = golfClubMembership.AcceptedDateTime,
GolfClubId = golfClubMembership.GolfClubId,
MembershipId = golfClubMembership.MembershipId,
GolfClubName = golfClubMembership.GolfClubName,
MembershipNumber = "000001",
Status = MembershipStatus.Accepted
});
}
return(this.Ok(membershipResponses));
}
}
private async Task InitialiseDatabase(IApplicationBuilder app)
{
using (IServiceScope scope = app.ApplicationServices.GetService <IServiceScopeFactory>().CreateScope())
{
MockDatabaseDbContext mockDatabase = scope.ServiceProvider.GetRequiredService <MockDatabaseDbContext>();
try
{
if (mockDatabase.Database.IsMySql())
{
mockDatabase.Database.Migrate();
}
// mockDatabase.SaveChanges();
}
catch (Exception ex)
{
var connString = mockDatabase.Database.GetDbConnection().ConnectionString;
Exception newException = new Exception($"Connection String [{connString}]", ex);
throw newException;
}
}
}
public FeatureBase()
{
String connectionString = "server=192.168.1.132;database=MockDatabase;user id=root;password=Pa55word";
this.MockDatabase = new MockDatabaseDbContext(connectionString);
}
