public async Task PlayerController_POST_CreatePlayer_PlayerIdIsReturned()
{
// 1. Arrange
HttpClient client = this.WebApplicationFactory.CreateClient();
RegisterPlayerRequest registerPlayerRequest = TestData.RegisterPlayerRequest;
String uri = "api/players/";
StringContent content = Helpers.CreateStringContent(registerPlayerRequest);
client.DefaultRequestHeaders.Add("api-version", "2.0");
// 2. Act
HttpResponseMessage response = await client.PostAsync(uri, content, CancellationToken.None);
// 3. Assert
response.StatusCode.ShouldBe(HttpStatusCode.Created);
String responseAsJson = await response.Content.ReadAsStringAsync();
responseAsJson.ShouldNotBeNullOrEmpty();
RegisterPlayerResponse responseObject = JsonConvert.DeserializeObject <RegisterPlayerResponse>(responseAsJson);
responseObject.ShouldNotBeNull();
responseObject.PlayerId.ShouldNotBe(Guid.Empty);
}
public ContentResult edit(RegisterPlayerRequest request)
{
string msg = string.Empty;
var flag = _memberService.EditMemberPlayer(request, UserContext.WebUserContext, out msg);
return(Result <string>(flag, msg));
}
public async Task RegisterPlayer(String golfClubName, TableRow tableRow)
{
String clientToken = await this.GetToken(TokenType.Client, "golfhandicap.testdatagenerator", "golfhandicap.testdatagenerator").ConfigureAwait(false);;
Func <String, String> baseAddressResolver = (address) => { return($"http://127.0.0.1:{this.ManagementAPIPort}"); };
HttpClient httpClient = new HttpClient();
IPlayerClient playerClient = new PlayerClient(baseAddressResolver, httpClient);
List <GetGolfClubResponse> golfClubList = await playerClient.GetGolfClubList(clientToken, Guid.Empty, CancellationToken.None).ConfigureAwait(false);;
GetGolfClubResponse golfClub = golfClubList.SingleOrDefault(g => g.Name == golfClubName);
if (golfClub != null)
{
DateTime dateOfBirth = DateTime.Now.AddYears(Int32.Parse(tableRow["Age"]) * -1).AddDays(-1);
RegisterPlayerRequest registerPlayerRequest = new RegisterPlayerRequest
{
DateOfBirth = dateOfBirth,
EmailAddress = tableRow["EmailAddress"],
Gender = tableRow["Gender"],
ExactHandicap = Decimal.Parse(tableRow["ExactHandicap"]),
FamilyName = tableRow["FamilyName"],
GivenName = tableRow["GivenName"],
};
var registerPlayerResponse = await playerClient.RegisterPlayer(registerPlayerRequest, CancellationToken.None).ConfigureAwait(false);
await playerClient.RequestClubMembership(clientToken, registerPlayerResponse.PlayerId, golfClub.Id, CancellationToken.None).ConfigureAwait(false);
}
}
public async Task GivenTheFollowingPlayersHaveRegistered(Table table)
{
foreach (TableRow tableRow in table.Rows)
{
Int32 age = Int32.Parse(tableRow["Age"]);
RegisterPlayerRequest registerPlayerRequest = new RegisterPlayerRequest
{
DateOfBirth = DateTime.Now.AddYears(age * -1),
FamilyName = tableRow["FamilyName"],
GivenName = tableRow["GivenName"],
MiddleName = tableRow["MiddleName"],
EmailAddress = tableRow["EmailAddress"],
ExactHandicap = Decimal.Parse(tableRow["ExactHandicap"]),
Gender = tableRow["Gender"],
};
this.TestingContext.RegisterPlayerRequests.Add(tableRow["PlayerNumber"], registerPlayerRequest);
RegisterPlayerResponse registerPlayerResponse =
await this.TestingContext.DockerHelper.PlayerClient.RegisterPlayer(registerPlayerRequest, CancellationToken.None).ConfigureAwait(false);
this.TestingContext.RegisterPlayerResponses.Add(tableRow["PlayerNumber"], registerPlayerResponse);
}
}
/// <summary>
/// Registers the player.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <RegisterPlayerResponse> RegisterPlayer(RegisterPlayerRequest request,
CancellationToken cancellationToken)
{
RegisterPlayerResponse response = null;
String requestUri = $"{this.BaseAddress}/api/Player";
try
{
String requestSerialised = JsonConvert.SerializeObject(request);
StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
// Make the Http Call here
HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
// Process the response
String content = await this.HandleResponse(httpResponse, cancellationToken);
// call was successful so now deserialise the body to the response object
response = JsonConvert.DeserializeObject <RegisterPlayerResponse>(content);
}
catch (Exception ex)
{
// An exception has occurred, add some additional information to the message
Exception exception = new Exception($"Error creating the new player {request.GivenName} {request.FamilyName}.", ex);
throw exception;
}
return(response);
}
public async Task GivenIAmLoggedInAsPlayerNumber(String playerNumber)
{
RegisterPlayerRequest registerPlayerRequest = this.TestingContext.GetRegisterPlayerRequest(playerNumber);
this.TestingContext.PlayerToken = await this.TestingContext.DockerHelper.GetToken(TokenType.Password,
"golfhandicap.mobile",
"golfhandicap.mobile",
registerPlayerRequest.EmailAddress,
"123456").ConfigureAwait(false);
}
/// <summary>
/// Creates the player datav2.
/// </summary>
/// <param name="testDataGenerator">The test data generator.</param>
/// <param name="numberPlayersPerClub">The number players per club.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private static async Task CreatePlayerDatav2(ITestDataGenerator testDataGenerator,
Int32 lastClub,
Int32 numberPlayersPerClub,
CancellationToken cancellationToken)
{
Int32 clubCounter = lastClub + 1;
foreach (GolfClubDetails golfClubDetails in Program.GolfClubs)
{
for (Int32 i = 0; i < numberPlayersPerClub; i++)
{
RegisterPlayerRequest registerPlayerRequest = new RegisterPlayerRequest
{
DateOfBirth = DateTime.Now.AddYears(-30),
EmailAddress = $"player{i}.{clubCounter}@testplayer.co.uk",
ExactHandicap = i,
GivenName = $"Club {clubCounter}",
Gender = "M",
FamilyName = $"Test Player {i}",
MiddleName = null
};
RegisterPlayerResponse registerPlayerResponse = await testDataGenerator.RegisterPlayer(registerPlayerRequest, cancellationToken);
Console.WriteLine($"Created Player {registerPlayerRequest.GivenName} {registerPlayerRequest.FamilyName}");
//String token = await testDataGenerator.GetToken(TokenType.Password,
// "developerClient",
// "developerClient",
// registerPlayerRequest.EmailAddress,
// "123456",
// new List<String>
// {
// "openid",
// "profile",
// "managementapi"
// });
await testDataGenerator.RequestClubMembership(Program.accessToken, registerPlayerResponse.PlayerId, golfClubDetails.GolfClubId, cancellationToken);
Console.WriteLine($"Player {registerPlayerRequest.GivenName} {registerPlayerRequest.FamilyName} membership requested");
Program.Players.Add(new PlayerDetails
{
GolfClubId = golfClubDetails.GolfClubId,
PlayerId = registerPlayerResponse.PlayerId,
PlayingHandicap = Convert.ToInt32(registerPlayerRequest.ExactHandicap), // TODO: Rounding
EmailAddress = registerPlayerRequest.EmailAddress
});
}
clubCounter++;
}
}
public IEnumerator RegisterPlayer(Action <RegisterPlayerResponse> onRegisterPlayerResponse,
Action <string> onError)
{
RegisterPlayerRequest request = new RegisterPlayerRequest();
yield return(SyncPost(
request,
responseText =>
{
onRegisterPlayerResponse(RegisterPlayerResponse.FromJSON(responseText));
},
onError
));
}
public async Task <IActionResult> CreatePlayer([FromBody] RegisterPlayerRequest request,
CancellationToken cancellationToken)
{
Guid playerId = Guid.NewGuid();
// Create the command
RegisterPlayerCommand command = RegisterPlayerCommand.Create(playerId, request);
// Route the command
await this.CommandRouter.Route(command, cancellationToken);
// return the result
return(this.Created($"{PlayerController.ControllerRoute}/{playerId}", new RegisterPlayerResponse
{
PlayerId = playerId
}));
}
public JsonResult registerplayer(RegisterPlayerRequest request)
{
var res = new Result <string>();
string msg = string.Empty;
res.flag = _memberService.RegisterMemberPlayer(request, out msg);
if (res.flag)
{
res.flag = true;
res.msg = "/player/player/index";
}
else
{
res.msg = msg;
res.flag = false;
}
return(Json(res, JsonRequestBehavior.DenyGet));
}
public void GivenIRegisterTheFollowingDetailsForAPlayer(Table table)
{
TableRow tableRow = table.Rows.Single();
RegisterPlayerRequest registerPlayerRequest = new RegisterPlayerRequest
{
DateOfBirth = DateTime.ParseExact(tableRow["DateOfBirth"], "yyyy-MM-dd", null),
FamilyName = tableRow["FamilyName"],
GivenName = tableRow["GivenName"],
MiddleName = tableRow["MiddleName"],
EmailAddress = tableRow["EmailAddress"],
ExactHandicap = Decimal.Parse(tableRow["ExactHandicap"]),
Gender = tableRow["Gender"]
};
this.TestingContext.RegisterPlayerRequest = registerPlayerRequest;
this.TestingContext.RegisterPlayerRequests.Add(tableRow["PlayerNumber"], registerPlayerRequest);
}
/// <summary>
/// Registers the player.
/// </summary>
/// <param name="viewModel">The view model.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task RegisterPlayer(RegistrationViewModel viewModel,
CancellationToken cancellationToken)
{
// Translate the view model into the api request
RegisterPlayerRequest apiRequest = new RegisterPlayerRequest
{
DateOfBirth = viewModel.DateOfBirth,
Gender = viewModel.Gender == 0 ? "M" : "F",
EmailAddress = viewModel.EmailAddress,
MiddleName = viewModel.MiddleName,
ExactHandicap = decimal.Parse(viewModel.ExactHandicap),
FamilyName = viewModel.LastName,
GivenName = viewModel.FirstName
};
RegisterPlayerResponse apiResponse = await this.PlayerClient.RegisterPlayer(apiRequest, cancellationToken);
// Set the result in the view model
viewModel.PlayerId = apiResponse.PlayerId;
}
public async Task GivenTheFollowingPlayersAreClubMembersOfTheFollowingGolfClubs(Table table)
{
foreach (TableRow tableRow in table.Rows)
{
RegisterPlayerRequest registerPlayerRequest = this.TestingContext.GetRegisterPlayerRequest(tableRow["PlayerNumber"]);
RegisterPlayerResponse registerPlayerResponse = this.TestingContext.GetRegisterPlayerResponse(tableRow["PlayerNumber"]);
CreateGolfClubResponse golfClubResponse = this.TestingContext.GetCreateGolfClubResponse(tableRow["GolfClubNumber"]);
this.TestingContext.PlayerToken = await this.TestingContext.DockerHelper.GetToken(TokenType.Password,
"golfhandicap.mobile",
"golfhandicap.mobile",
registerPlayerRequest.EmailAddress,
"123456").ConfigureAwait(false);
await this.TestingContext.DockerHelper.PlayerClient.RequestClubMembership(this.TestingContext.PlayerToken,
registerPlayerResponse.PlayerId,
golfClubResponse.GolfClubId,
CancellationToken.None).ConfigureAwait(false);
}
}
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 async Task RegisterPlayerAsync(RegisterPlayerRequest registerPlayerRequest)
{
var alreadyExists = _gamePlays.Exists(ga => ga.HubConnectionId == Context.ConnectionId);
if (alreadyExists)
{
return;
}
var gamePlay = new GamePlay
{
HubConnectionId = Context.ConnectionId,
Game = registerPlayerRequest.Game,
Player = registerPlayerRequest.Player,
CardPlayed = new Card()
};
_gamePlays.Add(gamePlay);
await Groups.AddToGroupAsync(Context.ConnectionId, registerPlayerRequest.Game.Id);
await UpdateGame(gamePlay.Game.Id);
}
/// <summary>
/// Gets the add measured course to club request.
/// </summary>
/// <param name="playerId">The player identifier.</param>
/// <param name="registerPlayerRequest">The register player request.</param>
/// <param name="commandId">The command identifier.</param>
/// <value>
/// The add measured course to club request.
/// </value>
private RegisterPlayerCommand(Guid playerId, RegisterPlayerRequest registerPlayerRequest, Guid commandId) : base(commandId)
{
this.PlayerId = playerId;
this.RegisterPlayerRequest = registerPlayerRequest;
}
/// <summary>
/// Creates this instance.
/// </summary>
/// <param name="playerId">The player identifier.</param>
/// <param name="registerPlayerRequest">The register player request.</param>
/// <returns></returns>
public static RegisterPlayerCommand Create(Guid playerId, RegisterPlayerRequest registerPlayerRequest)
{
return(new RegisterPlayerCommand(playerId, registerPlayerRequest, Guid.NewGuid()));
}
/// <summary>
/// Registers the player.
/// </summary>
/// <param name="registerPlayerRequest">The register player request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <RegisterPlayerResponse> RegisterPlayer(RegisterPlayerRequest registerPlayerRequest,
CancellationToken cancellationToken)
{
return(await this.PlayerClient.RegisterPlayer(registerPlayerRequest, cancellationToken));
}
