public async Task <Response <List <MatchDetailsModel> > > GetMatchDetailsAsync(MatchBaseRequest request)
{
request.SessionId = await _sessionManager.GetKey();
var response = new Response <List <MatchDetailsModel> >();
var matchDetails = await _unitOfWorkManager.ExecuteSingleAsync
<IMatchDetailsRepository, IEnumerable <MatchDetailsModel> >
(u => u.GetMatchDetails(request));
if (matchDetails.Any())
{
response.Data = matchDetails.ToList();
}
else
{
var clientResponse = await _matchClient.GetClientMatchDetailsAsync(request);
var mapped = clientResponse.Select(x => _matchDetailsMapper.Map(x));
var storedResponse = await _unitOfWorkManager.ExecuteSingleAsync
<IMatchDetailsRepository, DataListResult <MatchDetailsModel> >
(u => u.InsertMatchDetailsEntry(mapped, request));
var detailedMatch = await _unitOfWorkManager.ExecuteSingleAsync
<IMatchDetailsRepository, IEnumerable <MatchDetailsModel> >
(u => u.GetMatchDetails(request));
response.Data = detailedMatch.ToList();
}
return(response);
}
private async Task <IEnumerable <MatchDetailsModel> > GetMatchStored(MatchBaseRequest request)
{
var matchDetails = await _unitOfWorkManager.ExecuteSingleAsync
<IMatchDetailsRepository, IEnumerable <MatchDetailsModel> >
(u => u.GetMatchDetails(request));
if (matchDetails.Any())
{
return(matchDetails);
}
return(null);
}
public async Task LogUsageStat(string actionName)
{
var action = await _unitOfWorkManager.ExecuteSingleAsync <IApiUsageFrequencyRepository, ActionEndPointModel>(u => u.GetActionAsync(actionName));
if (action.IsNotNull())
{
var response = await _unitOfWorkManager.ExecuteSingleAsync <IApiUsageFrequencyRepository, bool>(u => u.InsertUsage(action.Id));
if (!response)
{
//log here
}
}
}
/// <summary>
/// Initial Seeding of the database for the following tables:
/// -> Language
/// -> Queue
/// -> Tier
/// -> Item
/// -> Champion
/// -> Champion Abilities
/// -> Ability
/// -> Skins
/// </summary>
/// <returns>List of NonDataResult</returns>
public async Task <IEnumerable <NonDataResult> > SeedAsync()
{
var response = new List <NonDataResult>();
//insert languages
var langaugeResult = await _unitOfWorkManager.ExecuteSingleAsync <ILanguageRepository, NonDataResult>(u => u.InsertBaseLanguageOptionsAsync());
response.Add(langaugeResult);
//insert queues
var queueResult = await _unitOfWorkManager.ExecuteSingleAsync <IQueueRepository, NonDataResult>(u => u.InsertBaseQueuesAsync());
response.Add(queueResult);
//insert tiers
var tierResult = await _unitOfWorkManager.ExecuteSingleAsync <ITierRepository, NonDataResult>(u => u.InsertBaseTiersAsync());
response.Add(tierResult);
//generate session
var session = await _sessionClient.GetClientSessionAsync();
//fetch items using session
var items = await _generalClient.GetClientItemsAsync(GeneralBaseRequest.CreateInstance(session.SessionId));
//insert items
var itemResult = await _unitOfWorkManager.ExecuteSingleAsync <IItemRepository, NonDataResult>
(u => u.InsertItemsAsync(items.Select(x => _itemMapper.Map(x))));
//fetch champions using session
var champions = await _generalClient.GetClientChampionsAsync(GeneralBaseRequest.CreateInstance(session.SessionId));
var mappedChampions = champions.Select(x => _championMapper.Map(x));
//use champions to get all abilities
var abilities = mappedChampions.SelectMany(x => x.Abilities);
//insert abilities
var abilityResult = await _unitOfWorkManager.ExecuteSingleAsync <IAbilityRepository, NonDataResult>
(u => u.InsertAbilitiesAsync(abilities));
response.Add(abilityResult);
//insert champions
var championResult = await _unitOfWorkManager.ExecuteSingleAsync <IChampionRepository, NonDataResult>
(u => u.InsertChampionsAsync(mappedChampions));
response.Add(championResult);
//insert champion abilities
var championAbilitiesResult = await _unitOfWorkManager.ExecuteSingleAsync <IChampionAbilitiesRepository, NonDataResult>(u => u.InsertLinkingRelationships(mappedChampions));
response.Add(championAbilitiesResult);
foreach (var champion in mappedChampions)
{
//foreach champion fetch champion skins
var skins = await _generalClient.GetClientChampionSkinsAsync(ChampionSkinsRequest.CreateInstance(session.SessionId, champion.PaladinsChampionId));
var mappedSkins = skins.Select(x => _skinMapper.Map(x)).SelectMany(x => x.ToList());
//insert skin
var skinResult = await _unitOfWorkManager.ExecuteSingleAsync <ISkinRepository, NonDataResult>(u => u.InsertBaseChampionSkins(mappedSkins));
response.Add(skinResult);
}
return(response);
}
public async Task <PagedResponse <FriendModel> > GetPagedPlayerFriendsAsync(PlayerPagedRequest request)
{
return(await _unitOfWorkManager.ExecuteSingleAsync
<IFriendRepository, PagedResponse <FriendModel> >
(u => u.GetPagedFriendsAsync(request)));
}
public async Task Log(ExceptionLogModel model)
{
await _unitOfWorkManager.ExecuteSingleAsync <IExceptionLogRepository, bool>(u => u.InsertLogAsync(model));
}
public async Task <IEnumerable <ChangeLogModel> > FetchChangeLogAsync(ChangeLogAdminSearchModel model)
{
return(await _unitOfWorkManager.ExecuteSingleAsync <IChangeLogRepository, IEnumerable <ChangeLogModel> >
(u => u.GetChangeLogAsync(model)));
}
public async Task <PagedResponse <ChampionModel> > GetChampionsAsync(PagedRequest request)
{
return(await _unitOfWorkManager.ExecuteSingleAsync
<IChampionRepository, PagedResponse <ChampionModel> >
(u => u.GetChampionsAsync(request)));
}
public async Task <IEnumerable <PlayerModel> > GetPlayerAsync(PlayerAdminSearchModel request)
{
return(await _unitOfWorkManager.ExecuteSingleAsync
<IPlayerRepository, IEnumerable <PlayerModel> >
(u => u.GetPlayers(request)));
}