public async Task <ServiceResponse <GetPlayerDto> > UpdatePlayer(UpdatePlayerDto updatePlayer)
{
ServiceResponse <GetPlayerDto> serviceResponse = new ServiceResponse <GetPlayerDto>();
try
{
Player player = await _context.Player.FirstOrDefaultAsync(c => c.PlayerID == updatePlayer.PlayerID);
player.Country = await _context.Country.FirstOrDefaultAsync(c => c.CountryID == updatePlayer.CountryID);
player.Race = await _context.Race.FirstOrDefaultAsync(c => c.RaceID == updatePlayer.RaceID);
player.Name = updatePlayer.Name;
player.NickName = updatePlayer.NickName;
player.Age = updatePlayer.Age;
player.LastName = updatePlayer.LastName;
_context.Player.Update(player);
await _context.SaveChangesAsync();
serviceResponse.Data = _mapper.Map <GetPlayerDto>(player);
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public async Task <Player> Update(UpdatePlayerDto playerDto)
{
var player = await _context.Players.FirstOrDefaultAsync(p => p.Name == playerDto.Name);
if (player == null)
{
// Add function that creates instead of having it nested in an Update function - repository pattern
var newPlayer = new Player
{
Id = Guid.NewGuid(),
Name = playerDto.Name,
TimesPlayed = 1
};
await _context.Players.AddAsync(newPlayer);
}
else
{
player.TimesPlayed += 1;
_context.Players.Update(player);
}
await _context.SaveChangesAsync();
return(player);
}
// Returns a single playerDto from UpdatePlayerResultDto
private UpdatePlayerDto GetPlayerFromUpdatePlayerResultDto(UpdatePlayerResultDto player)
{
var updatePlayerDto = new UpdatePlayerDto {
Name = player.Name
};
return(updatePlayerDto);
}
public async Task <PlayerDto> UpdatePlayer(int playerToBeUpdatedId, UpdatePlayerDto updatePlayerDto)
{
if (false == IsModelValid(updatePlayerDto, out string issues))
{
throw new ArgumentException($"Player model is not valid. Issues: {issues}");
}
var playerToBeUpdated = await _context.Players.FirstOrDefaultAsync((player) => playerToBeUpdatedId == player.Id);
if (null != playerToBeUpdated)
{
if (null != updatePlayerDto.Id && updatePlayerDto.Id.HasValue)
{
var newProposedPlayerId = updatePlayerDto.Id.Value;
if (playerToBeUpdatedId != newProposedPlayerId)
{
throw new NotImplementedException("Update of player Id is not yet implemented.");
}
}
if (null != updatePlayerDto.SelectedTeamId && updatePlayerDto.SelectedTeamId.HasValue)
{
var newSelectedTeamId = updatePlayerDto.SelectedTeamId.Value;
var newlySelectedTeam = await _context.Teams.FirstOrDefaultAsync((team) => newSelectedTeamId == team.Id);
if (null == newlySelectedTeam)
{
throw new ArgumentOutOfRangeException($"Selected team with specified Id: {newSelectedTeamId} does not exist.");
}
playerToBeUpdated.SelectedTeam = newlySelectedTeam;
playerToBeUpdated.SelectedTeamId = newSelectedTeamId;
}
if (null != updatePlayerDto.LastName)
{
playerToBeUpdated.LastName = updatePlayerDto.LastName;
}
if (null != updatePlayerDto.FirstName)
{
playerToBeUpdated.FirstName = updatePlayerDto.FirstName;
}
if (null != updatePlayerDto.Nickname)
{
playerToBeUpdated.Nickname = updatePlayerDto.Nickname;
}
}
else
{
throw new ArgumentOutOfRangeException($"Player with specified Id: {playerToBeUpdatedId} does not exist.");
}
playerToBeUpdated.ModifiedUTC = DateTime.UtcNow;
var updatedPlayer = _context.Players.Update(playerToBeUpdated);
var result = await _context.SaveChangesAsync();
var playerDto = _mapper.Map <PlayerModel, PlayerDto>(updatedPlayer.Entity);
return(playerDto);
}
public async Task <IActionResult> UpdatePlayer(UpdatePlayerDto updatedPlayer)
{
ServiceResponse <GetPlayerDto> response = await _playerService.UpdatePlayer(updatedPlayer);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public async Task <bool> UpdateData([FromBody] UpdatePlayerDto update)
{
var data = await dbContext.Players.Where(x => x.Id == update.Id).FirstOrDefaultAsync();
data.Name = update.Name; // +" "+"Bishwas";
data.Address = update.Address;
data.Email = update.Email;
dbContext.Players.Update(data);
await dbContext.SaveChangesAsync();
return(true);
}
public async Task <ServiceResponse <GetPlayerDto> > UpdatePlayer(UpdatePlayerDto updatedPlayer)
{
ServiceResponse <GetPlayerDto> serviceResponse = new ServiceResponse <GetPlayerDto>();
try
{
Player player = await _context.Players.FirstOrDefaultAsync(p => p.Id == updatedPlayer.Id);
// check that player can afford new building
if (player.Money >= player.Buildings[updatedPlayer.BuildingId].Cost)
{
// makes sure player doesn't get income from time spent with 0 income
if (player.Income == 0)
{
player.LastUpdate = DateTime.Now;
}
var Building = player.Buildings[updatedPlayer.BuildingId];
// deduct cost of building from money
player.Money -= Building.Cost;
// calculate cost for next building
Building.Cost = (int)(Building.Cost * Building.CostIncrease);
// sets owned to +1 to reflect purchase
Building.Owned += 1;
// adds buildings income to players income to reflect purchase
player.Income += Building.IncomeIncrease;
// finally sets players building to updated building and save it to database
player.Buildings[updatedPlayer.BuildingId] = Building;
_context.Players.Update(player);
await _context.SaveChangesAsync();
}
serviceResponse.Data = _mapper.Map <GetPlayerDto>(player);
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public async Task <IActionResult> Put(int playerId, [FromBody] UpdatePlayerDto updatePlayer)
{
if (updatePlayer == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//TODO::implement PUT update logic to validate all fields being updated
//and logic to update all fields
return(NoContent());
}
public async Task <IActionResult> Update([FromBody] UpdatePlayerDto playerDto)
{
Log.Logger.Information($"Updating {playerDto.Name} to Players");
if (playerDto == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
var result = await _repository.Update(playerDto);
return(NoContent());
}
private bool IsModelValid(UpdatePlayerDto updatePlayerDto, out string issues)
{
issues = "";
return(true);
}
public async Task <IActionResult> UpdatePLayer(UpdatePlayerDto id)
{
return(Ok(await _playerService.UpdatePlayer(id)));
}
