public async Task CreatePlayer_WhenCalled_CreateNewPlayer()
{
const int id = 1;
const string name = "Petr Cech";
var playerCreateDto = new PlayerCreateDto
{
Name = name
};
var expectedPlayer = new Player
{
Id = id,
Name = name
};
_playerService.Setup(p => p.GetDetailByIdAsync(It.IsAny <int>())).ReturnsAsync(expectedPlayer);
var result = await _playersController.CreatePlayer(playerCreateDto);
var okObjectResult = result as OkObjectResult;
var okObjectResultValue = okObjectResult.Value as PlayerDetailDto;
_playerService.Verify(p => p.CreateAsync(It.IsAny <Player>()), Times.Once);
Assert.That(result, Is.TypeOf <OkObjectResult>());
Assert.That(okObjectResultValue.Name, Is.EqualTo(name));
}
public async Task <IActionResult> OnPostAsync([FromBody] PlayerCreateDto dto)
{
if (!ModelState.IsValid)
{
return(await Task.FromResult(new JsonResult(new
{
Status = false,
ErrorMessage = ModelState.Where(e => e.Value.Errors.Count > 0).Select(e => e.Value.Errors.First().ErrorMessage).First()
})));
}
var userId = _accountContext.UserId;
var command = new CreateCommand(dto.Name, dto.Gender, userId, dto.Str, dto.Con, dto.Dex, dto.Int);
await _bus.SendCommand(command);
if (_notifications.HasNotifications())
{
var errorMessage = string.Join("；", _notifications.GetNotifications().Select(x => x.Content));
return(await Task.FromResult(new JsonResult(new
{
status = false,
errorMessage
})));
}
return(await Task.FromResult(new JsonResult(new
{
status = true
})));
}
public async Task <ActionResult <PlayerDto> > PostPlayer(PlayerCreateDto playerCreateDto)
{
if (playerCreateDto.Name == null)
{
ModelState.AddModelError("Name", "Player name is required.");
}
if (playerCreateDto.Name == String.Empty)
{
ModelState.AddModelError("Name", "Player name cannot be empty.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Player player = _mapper.Map <Player>(playerCreateDto);
_context.Players.Add(player);
await _context.SaveChangesAsync();
PlayerDto playerDto = _mapper.Map <PlayerDto>(player);
return(CreatedAtAction(nameof(GetPlayer), new { id = player.Id }, playerDto));
}
public ActionResult <PlayerReadDto> CreatePlayer(PlayerCreateDto playerCreateDto)
{
var playerModel = _mapper.Map <Players>(playerCreateDto);
_repository.CreatePlayer(playerModel);
_repository.SaveChanges();
var playerReadDto = _mapper.Map <PlayerReadDto>(playerModel);
return(CreatedAtRoute(nameof(GetPlayerbyId), new { Id = playerReadDto.Id }, playerReadDto));
}
public async Task <IActionResult> Create([FromBody] PlayerCreateDto playerCreateDto)
{
var player = _mapper.Map <Player>(playerCreateDto);
_repository.Create(player);
var isSuccess = await _repository.SaveChangesAsync();
if (!isSuccess)
{
return(BadRequest());
}
var playerViewDto = _mapper.Map <PlayerViewDto>(player);
return(CreatedAtRoute("GetPlayer", new { id = playerViewDto.PlayerId }, playerViewDto));
}
public async Task <IActionResult> CreatePlayer([FromBody] PlayerCreateDto playerCreateDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var playerToCreate = _mapper.Map <Player>(playerCreateDto);
await _playerService.CreateAsync(playerToCreate);
var player = await _playerService.GetDetailByIdAsync(playerToCreate.Id);
var returnPlayer = _mapper.Map <PlayerDetailDto>(player);
return(Ok(returnPlayer));
}
public IActionResult Post([FromBody] PlayerCreateDto playerCreateDto)
{
if (playerCreateDto == null || ModelState.IsValid == false)
{
return(BadRequest());
}
var savedPlayer = mapper.Map <Player>(playerCreateDto);
playerRepository.Create(savedPlayer);
if (playerRepository.Save() == false)
{
return(StatusCode(500, "Unable to Save Player"));
}
return(CreatedAtRoute("GetPlayer", new { savedPlayer.ID }, savedPlayer));;
}
public async Task <IActionResult> Create([FromBody] PlayerCreateDto player)
{
var team = await _teamRepository.GetByIdAsync(player.TeamId);
if (team == null)
{
return(BadRequest($"Invalid country Id { player.TeamId }"));
}
if (await _playerRepository.ExistAsync(p => p.Email == player.Email))
{
return(BadRequest($"Invalid email - It is already registered in the system"));
}
var completeNameResult = CompleteName.Create(player.FirstName, player.LastName);
if (completeNameResult.IsFailure)
{
return(BadRequest(completeNameResult.Error));
}
var emailResult = Email.Create(player.Email);
if (emailResult.IsFailure)
{
return(BadRequest(emailResult.Error));
}
var newPlayer = new Player(completeNameResult.Value, player.BirthDate, emailResult.Value, player.Phone, team);
await _playerRepository.AddAsync(newPlayer);
await _unitOfWork.Commit();
return(Ok());
}
public virtual Task <PlayerDto> CreateAsync(PlayerCreateDto input)
{
return(_playersAppService.CreateAsync(input));
}
