public IActionResult Put(int id, [FromBody] PlayerUpdateDto playerUpdateDto)
{
if (playerUpdateDto == null || ModelState.IsValid == false)
{
return(BadRequest());
}
if (playerRepository.Exists(id) == false)
{
return(NotFound());
}
Models.Player playerToUpdate = playerRepository.Get(id);
if (playerToUpdate == null)
{
return(NotFound());
}
mapper.Map(playerUpdateDto, playerToUpdate);
if (!playerRepository.Save())
{
return(StatusCode(500, "A problem occured"));
}
return(NoContent());
}
public async Task UpdatePlayer_WhenCalled_UpdateExistingPlayer()
{
const int id = 1;
const string updateName = "Alexandre Lacazette";
var playerUpdateDto = new PlayerUpdateDto
{
Name = updateName
};
var player = new Player
{
Id = id,
Name = "Petr Cech"
};
var expectedPlayer = new Player
{
Id = id,
Name = updateName
};
_playerService.Setup(p => p.GetByIdAsync(id)).ReturnsAsync(player);
_playerService.Setup(p => p.GetDetailByIdAsync(id)).ReturnsAsync(expectedPlayer);
var result = await _playersController.UpdatePlayer(id, playerUpdateDto);
var okObjectResult = result as OkObjectResult;
var okObjectResultValue = okObjectResult.Value as PlayerDetailDto;
_playerService.Verify(p => p.UpdateAsync(It.IsAny <Player>()), Times.Once);
Assert.That(result, Is.TypeOf <OkObjectResult>());
Assert.That(okObjectResultValue.Name, Is.EqualTo(updateName));
}
public async Task UpdatePlayer(PlayerUpdateDto player)
{
var dbPlayer = await _appDbContext.Players.SingleOrDefaultAsync(o => o.Id == player.Id);
dbPlayer.FirstName = player.FirstName;
dbPlayer.Surname = player.Surname;
dbPlayer.Initials = player.Initials;
dbPlayer.IsArchived = player.IsArchived;
_appDbContext.Players.Update(dbPlayer);
await _appDbContext.SaveChangesAsync();
}
public async Task <IActionResult> Update([FromRoute] int id, [FromBody] PlayerUpdateDto playerUpdateDto)
{
var player = await _repository.GetAsync(id);
_mapper.Map(playerUpdateDto, player);
_repository.Update(player);
var isSuccess = await _repository.SaveChangesAsync();
if (!isSuccess)
{
return(BadRequest());
}
return(NoContent());
}
public async Task <int> CreatePlayer(PlayerUpdateDto player)
{
var newPlayer = new Player
{
FirstName = player.FirstName,
Surname = player.Surname,
Initials = player.Initials,
IsArchived = player.IsArchived
};
_appDbContext.Players.Add(newPlayer);
await _appDbContext.SaveChangesAsync();
return(newPlayer.Id);
}
public ActionResult UpdatePlayer(int id, PlayerUpdateDto playerUpdateDto)
{
var playerModelFromRepo = _repository.GetPlayerById(id);
if (playerModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(playerUpdateDto, playerModelFromRepo);
_repository.UpdatePlayer(playerModelFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public IActionResult UpdatePlayer(int playerId, [FromBody] PlayerUpdateDto playerDto)
{
if (playerDto == null || playerId != playerDto.Id)
{
return(BadRequest(ModelState));
}
var playerObj = _mapper.Map <Player>(playerDto);
if (!_playerRepo.UpdatePlayer(playerObj))
{
ModelState.AddModelError("", $"Something went wrong when updating the record {playerObj.Name}");
return(StatusCode(500, ModelState));
}
return(NoContent());
}
public async Task UpdatePlayer_WhenCalled_ReturnNotFound()
{
const int id = 1;
const string updateName = "Alexandre Lacazette";
var playerUpdateDto = new PlayerUpdateDto
{
Name = updateName
};
_playerService.Setup(p => p.GetByIdAsync(id)).ReturnsAsync((Player)null);
var result = await _playersController.UpdatePlayer(id, playerUpdateDto);
_playerService.Verify(p => p.GetByIdAsync(id), Times.Once);
_playerService.Verify(p => p.UpdateAsync(It.IsAny <Player>()), Times.Never);
Assert.That(result, Is.TypeOf <NotFoundResult>());
}
public async Task <IActionResult> UpdatePlayer(int id, [FromBody] PlayerUpdateDto playerUpdateDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var player = await _playerService.GetByIdAsync(id);
if (player == null)
{
return(NotFound());
}
_mapper.Map(playerUpdateDto, player);
await _playerService.UpdateAsync(player);
var updatedPlayer = await _playerService.GetDetailByIdAsync(id);
var returnPlayer = _mapper.Map <PlayerDetailDto>(updatedPlayer);
return(Ok(returnPlayer));
}
public async Task <IActionResult> PutPlayer(Guid id, PlayerUpdateDto playerUpdateDto)
{
if (id != playerUpdateDto.Id)
{
return(BadRequest());
}
if (playerUpdateDto.Name == null)
{
ModelState.AddModelError("Name", "Player name is required.");
}
if (playerUpdateDto.Name == String.Empty)
{
ModelState.AddModelError("Name", "Player name cannot be empty.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Player player = await _context.Players.FindAsync(id);
if (player == null)
{
return(NotFound());
}
player.Name = playerUpdateDto.Name;
_context.Players.Update(player);
await _context.SaveChangesAsync();
return(NoContent());
}
public virtual Task <PlayerDto> UpdateAsync(Guid id, PlayerUpdateDto input)
{
return(_playersAppService.UpdateAsync(id, input));
}
public ActionResult UpsertPlayer([FromRoute] Guid id, [FromBody] PlayerUpdateDto model) => ResourceUpsert(id, model);
public async Task <ActionResult> UpdatePlayer([FromBody] PlayerUpdateDto player)
{
await _playerService.UpdatePlayer(player);
return(NoContent());
}
public async Task <ActionResult <int> > CreatePlayer([FromBody] PlayerUpdateDto player)
{
var id = await _playerService.CreatePlayer(player);
return(Ok(id));
}
