public IActionResult PostPlayer([FromBody] PlayerDetailsDto playerDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var player = new Player
{
Id = Guid.NewGuid().ToString(),
FirstName = playerDto.FirstName,
LastName = playerDto.LastName,
Nickname = playerDto.Nickname,
DateOfBirth = playerDto.DateOfBirth,
CountryId = playerDto.CountryId,
GameId = playerDto.GameId,
TeamId = playerDto.TeamId
};
var create = _repo.Create <Player>(player);
return(Ok(create.Success));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async void SaveAll()
{
var dataToSave = PlayerDetailsCache.Select(playerDetails =>
{
var details = new PlayerDetailsDto
{
Handicap101 = playerDetails.Handicap101,
Handicap201 = playerDetails.Handicap201,
Handicap301 = playerDetails.Handicap301,
Handicap401 = playerDetails.Handicap401,
Handicap501 = playerDetails.Handicap501,
HandicapCricket = playerDetails.HandicapCricket,
Name = playerDetails.Name,
NickName = playerDetails.NickName,
Id = playerDetails.Id
};
var definition = new ImageDefinitionDto
{
Name = playerDetails.PlayerImageDefinition.Name,
SourceBytes = playerDetails.PlayerImageDefinition.SourceBytes
};
details.PlayerImageDefinition = definition;
details.SelectedFlight = playerDetails.SelectedFlight;
return(details);
}).ToList();
await _playerSerialiser.Serialize(dataToSave);
}
public IActionResult PutPlayer([FromRoute] string id, [FromBody] PlayerDetailsDto playerDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != playerDto.Id)
{
return(BadRequest());
}
try
{
var getPlayer = _repo.GetFirst <Player>(x => x.Id.Equals(id), null,
String.Join(",",
new object[]
{
nameof(Player.Game), nameof(Player.Country), nameof(Player.Team)
}));
if (!getPlayer.Success)
{
return(NotFound());
}
var player = getPlayer.Data;
player.FirstName = playerDto.FirstName ?? player.FirstName;
player.LastName = playerDto.LastName ?? player.LastName;
player.Nickname = playerDto.Nickname ?? player.Nickname;
player.TeamId = playerDto.TeamId ?? player.TeamId;
var update = _repo.Update <Player>(player);
return(Ok(update.Data));
}
catch (DbUpdateConcurrencyException)
{
if (!PlayerExists(id))
{
return(NotFound());
}
return(BadRequest());
}
}
public async Task <PlayerDetailsDto> GetPlayerDetailsAsync(string accountId)
{
var recentMatchesUrl = string.Format(DotaApiEndpoints.PlayerRecentMatchesUrlTemplate, accountId);
var heroesUrl = string.Format(DotaApiEndpoints.PlayerHeroesUrlTemplate, accountId);
var winsLossesUrl = string.Format(DotaApiEndpoints.PlayerWinLossUrlTemplate, accountId);
var detailsTask = this.GetPlayerProfileAsync(accountId);
var winsLossesTask = this.httpClient.GetAsync(winsLossesUrl);
var recentMatchesTask = this.httpClient.GetAsync(recentMatchesUrl);
var heroesTask = this.httpClient.GetAsync(heroesUrl);
await Task.WhenAll(detailsTask, winsLossesTask, recentMatchesTask, heroesTask);
var detailsDto = detailsTask.Result;
var winLossData = winsLossesTask.Result;
var recentMatchesData = recentMatchesTask.Result;
var heroesData = heroesTask.Result;
var winLossJsonModel = this.jsonSerializer.Deserialize <PlayerWinsLossesJsonModel>(winLossData);
var recentMatchesJsonModel = this.jsonSerializer.Deserialize <ICollection <PlayerRecentMatchesJsonModel> >(recentMatchesData);
var playerHeroesJsonModel = this.jsonSerializer.Deserialize <ICollection <PlayerHeroesJsonModel> >(heroesData)?.Take(NumberOfBestHeroesToShow).ToList();
var winLossDto = this.mapper.Map <PlayerWinsLossesDto>(winLossJsonModel);
var recentMatchesDto = this.mapper.Map <ICollection <PlayerRecentMatchesDto> >(recentMatchesJsonModel);
var heroesDto = this.mapper.Map <ICollection <PlayerHeroesDto> >(playerHeroesJsonModel);
foreach (var hero in heroesDto)
{
hero.Hero = await this.heroesProvider.GetHeroAsync(hero.HeroId);
}
foreach (var match in recentMatchesDto)
{
match.Hero = await this.heroesProvider.GetHeroAsync(match.HeroId);
}
var playerDetailsDto = new PlayerDetailsDto {
Details = detailsDto, Heroes = heroesDto, RecentMatchHistory = recentMatchesDto, WinsAndLosses = winLossDto
};
return(playerDetailsDto);
}
