public PlayerBaseRequest CreateBasePlayerRequest(PlayerPagedRequest request)
{
return(new PlayerBaseRequest
{
PlayerName = request.PlayerName
});
}
public PlayerLoadoutsRequest CreatePlayerLoadoutsRequest(PlayerPagedRequest request)
{
return(new PlayerLoadoutsRequest
{
PlayerName = request.PlayerName,
LanguageId = (int)LanguageEnum.English,
});
}
public async Task <IActionResult> GetPlayerMatchHistory([FromBody] PlayerPagedRequest request)
{
await _playerService
.GetPlayerMatchHistoryAsync(_resolver.CreateBasePlayerRequest(request));
var response = await _playerMobileService.GetPagedPlayerMatchHistoryAsync(request);
return(Ok(response));
}
public async Task <IActionResult> GetPlayerChampionStats([FromBody] PlayerPagedRequest request)
{
var model = await _playerService
.GetPlayerChampionRanksAsync(_resolver.CreateBasePlayerRequest(request));
var response = await _playerMobileService.GetPagedPlayerChampionStatsAsync(request, model.Data);
return(Ok(response));
}
public async Task <PagedResponse <FriendModel> > GetPagedFriendsAsync(PlayerPagedRequest request)
{
var friends = await Context.Friend
.Include(x => x.Player)
.Where(x => x.Player.Name.Contains(request.PlayerName))
.Select(x => new FriendModel
{
Id = x.Id,
PaladinsPlayerId = x.PplayerId,
AccountId = x.AccountId,
CreatedOn = x.CreatedOn,
Name = x.Name,
LastUpdatedOn = x.LastUpdatedOn
}).ToListAsync();
return(new PagedResponse <FriendModel>(friends, request));
}
public async Task <PagedResponse <PlayerChampionStatsModel> > GetPagedPlayerChampionStatsAsync(PlayerPagedRequest request, PlayerModel model)
{
return(await _unitOfWorkManager.ExecuteSingleAsync
<IChampionRepository, PagedResponse <PlayerChampionStatsModel> >
(u => u.GetPagedPlayerChampionStats(request, model)));
}
public async Task <PagedResponse <PlayerLoadoutModel> > GetPagedPlayerLoadoutsAsync(PlayerPagedRequest request, PlayerModel model)
{
return(await _unitOfWorkManager.ExecuteSingleAsync
<ILoadoutRepository, PagedResponse <PlayerLoadoutModel> >
(u => u.GetPagedLoadoutsAsync(request, model)));
}
public async Task <PagedResponse <MatchHistoryModel> > GetPagedPlayerMatchHistoryAsync(PlayerPagedRequest request)
{
return(await _unitOfWorkManager.ExecuteSingleAsync
<IMatchHistoryRepository, PagedResponse <MatchHistoryModel> >
(u => u.GetPagedMatchHistoriesAsync(request)));
}
public async Task <PagedResponse <FriendModel> > GetPagedPlayerFriendsAsync(PlayerPagedRequest request)
{
return(await _unitOfWorkManager.ExecuteSingleAsync
<IFriendRepository, PagedResponse <FriendModel> >
(u => u.GetPagedFriendsAsync(request)));
}
/// <summary>
/// Db response of paged response for match histories
/// </summary>
/// <param name="request">Based Paged request with playername</param>
/// <returns>a paged history</returns>
public async Task <PagedResponse <MatchHistoryModel> > GetPagedMatchHistoriesAsync(PlayerPagedRequest request)
{
var matchhistories = await Context.PlayerMatchHistory
.Include(x => x.Player)
.Include(x => x.Champion)
.Where(x => x.Player.Name.Contains(request.PlayerName))
.Select(x => new MatchHistoryModel
{
Id = x.Id,
Assists = x.Assists,
Deaths = x.Deaths,
MatchResult = x.MatchResult,
ChampionName = x.Champion.Name,
Kills = x.Kills,
PaladinsChampionId = x.PchampionId,
PaladinsMatchId = x.PmatchId
})
.OrderByDescending(x => x.Id)
.ToListAsync();
return(new PagedResponse <MatchHistoryModel>(matchhistories, request));
}
public async Task <PagedResponse <PlayerLoadoutModel> > GetPagedLoadoutsAsync(PlayerPagedRequest request, PlayerModel model)
{
var loadouts = await Context.Loadout
.Include(x => x.LoadoutItem)
.Include(x => x.Champion)
.Where(x => x.PlayerName.Contains(request.PlayerName))
.Select(x => new PlayerLoadoutModel
{
Id = x.Id,
PaladinsPlayerId = x.PplayerId,
LoadoutName = x.LoadoutName,
PaladinsLoadoutId = x.PloadoutId,
PlayerName = x.PlayerName,
PaladinsChampionId = x.PchampionId,
ChampionName = x.Champion.Name,
ChampionUrl = x.Champion.Url,
CreatedOn = x.CreatedOn,
LastUpdatedOn = x.LastUpdatedOn,
LoadoutItems = (from loadoutItem in x.LoadoutItem
select new PlayerLoadoutItemModel
{
CardName = loadoutItem.Name,
PaladinsItemId = loadoutItem.PitemId,
ItemName = loadoutItem.Item.DeviceName,
ItemUrl = loadoutItem.Item.ItemIconUrl,
Description = loadoutItem.Item.Description,
PointsAssignedToItem = loadoutItem.Points
}).ToList()
})
.OrderBy(x => x.ChampionName)
.ToListAsync();
return(new PagedResponse <PlayerLoadoutModel>(loadouts, request));
}
public async Task <PagedResponse <PlayerChampionStatsModel> > GetPagedPlayerChampionStats(PlayerPagedRequest request, PlayerModel model)
{
var response = await Context.PlayerChampionStats
.Include(x => x.Champion)
.Where(x => x.PlayerId == model.PlayerId)
.Select(x => new PlayerChampionStatsModel
{
Assists = x.Assists,
CreatedOn = x.CreatedOn,
Deaths = x.Deaths,
Id = x.Id,
Kills = x.Kills,
LastUpdatedOn = x.LastUpdatedOn,
Losses = x.Losses,
PaladinsChampionId = x.PchampionId,
ChampionName = x.Champion.Name,
ChampionUrl = x.Champion.Url,
PlayerId = x.PlayerId,
Rank = x.Rank,
Wins = x.Wins
}).ToListAsync();
return(new PagedResponse <PlayerChampionStatsModel>(response, request));
}
