public IActionResult Authenticate([FromBody] CreatePlayerDto playerDto)
{
var user = userService.Authenticate(playerDto.Username, playerDto.Password);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Id.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
// return basic user info (without password) and token to store client side
return(Ok(new AuthenticatedPlayerDto(user, tokenString)));
}
/// <summary>
/// Adds new player.
/// </summary>
/// <param name="playerDto">The player for adding.</param>
public Player Add(CreatePlayerDto playerDto)
{
var newEntity = new PlayerEntity {
FirstName = playerDto.FirstName,
LastName = playerDto.LastName,
BirthYear = playerDto.BirthYear,
Height = playerDto.Height,
Weight = playerDto.Weight
};
if (!_dbStorageSpecification.IsSatisfiedBy(newEntity))
{
throw new InvalidEntityException();
}
_dalPlayers.Add(newEntity);
_unitOfWork.Commit();
return(new Player(newEntity.Id, newEntity.FirstName, newEntity.LastName)
{
BirthYear = newEntity.BirthYear,
Height = newEntity.Height,
Weight = newEntity.Weight
});
}
/// <summary>
/// Create a new player.
/// </summary>
/// <param name="playerToCreate">A Player to create.</param>
public Player Create(CreatePlayerDto playerToCreate)
{
_authService.CheckAccess(AuthOperations.Players.Create);
if (playerToCreate == null)
{
throw new ArgumentNullException(nameof(playerToCreate));
}
return(_playerRepository.Add(playerToCreate));
}
/// <summary>
/// Initializes a new instance
/// </summary>
public CreatePlayerDtoBuilder()
{
_player = new CreatePlayerDto {
FirstName = "FirstName",
LastName = "LastName",
BirthYear = 1983,
Height = 186,
Weight = 95
};
}
public void CreateNewPlayer_NewPlayerCreated_ReturnsPlayerId()
{
_repositoryServiceMock.Setup(s => s.CreateNewPlayerAsync(It.Is <CreatePlayerDto>(i => i.Name == "Paul"))).ReturnsAsync(newPlayerModel.Id);;
_repositoryServiceMock.Setup(s => s.GetPlayerById(16)).ReturnsAsync(newPlayerModel);
var newPlayer = new CreatePlayerDto {
Name = "Paul"
};
var result = _playerService.CreatePlayer(newPlayer).Result;
Assert.AreEqual(result.Id, newPlayerModel.Id);
Assert.AreEqual(result.Name, newPlayerModel.Name);
}
public async Task <IActionResult> CreatePlayer([FromBody] CreatePlayerDto dto, string connectionId)
{
try
{
var player = await _setupRelay.CreatePlayer(dto.Name, dto.Type, connectionId, dto.PlayVsComputer, dto.ComputerLevel);
return(Ok(player));
}
catch (SetupException ex)
{
return(BadRequest(ex.Message));
}
}
public PlayerDto AddNewPlayer(CreatePlayerDto player)
{
var maxId = _Players.Max(i => i.Id);
var newPlayer = new PlayerDto()
{
Id = (maxId + 1),
FirstName = player.FirstName,
LastName = player.LastName
};
_Players.Add(newPlayer);
return(newPlayer);
}
//Create player
public async Task <PlayerDto> CreatePlayer(CreatePlayerDto newPlayer)
{
if (newPlayer is null)
{
throw new ArgumentNullException(nameof(newPlayer));
}
var id = await _playerRepository.CreateNewPlayerAsync(newPlayer);
var newlyCreatedPlayer = await GetPlayerById(id);
return(newlyCreatedPlayer);
}
//create player with name
public async Task <int> CreateNewPlayerAsync(CreatePlayerDto newPlayer)
{
string query = @"INSERT INTO public.player(name)
VALUES (@name);
SELECT currval(pg_get_serial_sequence('player','id'));";
using (var conn = CreateConnection())
{
var newPlayerId = await conn.QueryFirstAsync <int>(query, new { name = newPlayer.Name });
return(newPlayerId);
}
}
public IActionResult Register([FromBody] CreatePlayerDto playerDto)
{
try
{
var player = playerDto.ToModel();
// save
userService.Create(player, playerDto.Password);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <IActionResult> Post([FromBody] CreatePlayerDto newPlayer)
{
if (newPlayer == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var player = PlayersDataStore.Instance.AddNewPlayer(newPlayer);
return(CreatedAtRoute(ApiRoutes.GetPlayerByIdRouteName, new { playerId = player.Id }, player));
}
public CreatePlayerDto CreatePlayer([FromBody] CreatePlayerDto playerDto)
{
using (GameShopDBContext gameShopDBContext = new GameShopDBContext())
{
Player player = new Player();
player.PlayerName = playerDto.PlayerName;
player.Email = playerDto.Email;
player.Phone = playerDto.Phone;
player.BirthDate = playerDto.BirthDate;
player.Gender = playerDto.Gender;
player.Password = playerDto.Password;
gameShopDBContext.Players.Add(player);
gameShopDBContext.SaveChanges();
return(playerDto);
}
}
public void WhenIExecuteCreatePlayer()
{
var playerToAdd = new CreatePlayerDto {
FirstName = _playerFirstName,
LastName = _playerLastName,
BirthYear = _birthYear,
Height = _height,
Weight = _weight
};
try
{
_player = _playerService.Create(playerToAdd);
}
catch (Exception exception)
{
_exception = exception;
}
}
public async Task <PlayerDto> CreatePlayer(CreatePlayerDto createPlayerDto)
{
if (false == IsModelValid(createPlayerDto, out string issues))
{
throw new ArgumentException($"Player model is not valid. Issues: {issues}");
}
var selectedTeam = await _context.Teams.FirstAsync((team) => team.Id == createPlayerDto.SelectedTeamId);
var playerToBeCreated = _mapper.Map <CreatePlayerDto, PlayerModel>(createPlayerDto);
var createdPlayer = await _context.Players.AddAsync(playerToBeCreated);
await _context.SaveChangesAsync();
var playerDto = _mapper.Map <PlayerModel, PlayerDto>(createdPlayer.Entity);
return(playerDto);
}
public void Create_InvalidNullPlayer_ArgumentNullExceptionIsThrown()
{
var gotException = false;
// Arrange
CreatePlayerDto newPlayer = null;
var sut = BuildSUT();
// Act
try
{
sut.Create(newPlayer);
}
catch (ArgumentNullException)
{
gotException = true;
}
// Assert
Assert.IsTrue(gotException);
}
public async Task <GamePlayerDto> CreateAsync(CreatePlayerDto model)
{
Player p = ObjectMapper.Map <Player>(model);
p.Id = Guid.NewGuid();
Game g = GameStore.GetGameByJoinCode(model.JoinCode);
if (g.Players.Select(p => p.Name.ToLower()).Contains(model.Name.ToLower()))
{
throw new UserFriendlyException("Name already taken", $"The name '{model.Name}' has already been taken by another player!");
}
if (model.Name.Length > 20)
{
throw new UserFriendlyException("Name too long", $"Name cannot be longer than 20 characters.");
}
g.Players.Add(p);
GameStore.AddOrUpdateGame(g);
GamePlayerDto gp = new GamePlayerDto();
gp.Game = g;
gp.Player = p;
return(gp);
}
public async Task <PlayerDto> Post(CreatePlayerDto playerModel)
{
var newPlayer = await _playerService.CreatePlayer(playerModel);
return(newPlayer);
}
private bool IsModelValid(CreatePlayerDto createPlayerDto, out string issues)
{
issues = "";
return(true);
}
public static PlayerModel ToPlayerModel(this IMapper mapper, CreatePlayerDto createPlayerDto)
{
var playerModel = mapper.Map <CreatePlayerDto, PlayerModel>(createPlayerDto);
return(playerModel);
}
public IActionResult Create(CreatePlayerDto player)
{
this.db.Players.Add(player.ToModel());
this.db.SaveChanges();
return(this.Ok());
}
private void VerifyCreatePlayer(CreatePlayerDto playerDto, Times times)
{
_playerRepositoryMock.Verify(pr => pr.Add(playerDto), times);
}
