public async Task <DsResponse> LoadData(DsRequest request)
{
DsResponse response = null;
try
{
var httpResponse = request.Mode switch
{
"Winrate" => await Http.PostAsJsonAsync("api/stats/winrate", request),
"Timeline" => await Http.PostAsJsonAsync("api/stats/timeline", request),
"MVP" => await Http.PostAsJsonAsync("api/stats/mvp", request),
"DPS" => await Http.PostAsJsonAsync("api/stats/dps", request),
"Synergy" => await Http.PostAsJsonAsync("api/stats/synergy", request),
"AntiSynergy" => await Http.PostAsJsonAsync("api/stats/antisynergy", request),
"Duration" => await Http.PostAsJsonAsync("api/stats/duration", request),
"Standard" => await Http.PostAsJsonAsync("api/stats/teamstandard", request),
_ => await Http.PostAsJsonAsync("api/stats/winrate", request)
};
if (httpResponse.IsSuccessStatusCode)
{
return(request.Mode switch
{
"Winrate" => await httpResponse.Content.ReadFromJsonAsync <DsResponse>(),
"Timeline" => await httpResponse.Content.ReadFromJsonAsync <TimelineResponse>(),
"MVP" => await httpResponse.Content.ReadFromJsonAsync <DsResponse>(),
"Duration" => await httpResponse.Content.ReadFromJsonAsync <TimelineResponse>(),
"Standard" => await httpResponse.Content.ReadFromJsonAsync <DsResponse>(),
_ => await httpResponse.Content.ReadFromJsonAsync <DsResponse>()
});
}
public static async Task GetInfo(sc2dsstatsContext context, string timespan)
{
DsRequest request = new DsRequest()
{
Filter = new DsFilter()
};
request.Filter.SetOff();
request.SetTime(timespan);
request.Filter.GameModes = new List <int>()
{
(int)Gamemode.Commanders, (int)Gamemode.CommandersHeroic
};
var replays = ReplayFilter.Filter(context, request);
var leaver = from r in replays
group r by r.Maxleaver > 89 into g
select new
{
Leaver = g.Key,
Count = g.Count()
};
var lleaver = await leaver.ToListAsync();
int count1 = lleaver[0].Count;
int count2 = lleaver[1].Count;
}
public async Task <string> GetLeaverInfo(string Timespan)
{
DsRequest request = new DsRequest()
{
Filter = new DsFilter()
};
request.Filter.SetOff();
request.SetTime(Timespan);
request.Filter.GameModes = new List <int>()
{
(int)DSData.Gamemode.Commanders, (int)DSData.Gamemode.CommandersHeroic
};
var replays = ReplayFilter.Filter(context, request);
var leaver = from r in replays
group r by r.Maxleaver > 89 into g
select new
{
Leaver = g.Key,
Count = g.Count()
};
var lleaver = await leaver.ToListAsync();
return(lleaver[0].Count == 0 ? "0" : (lleaver[1].Count / (double)lleaver[0].Count * 100).ToString("00.00"));
}
public static async Task <DsResponse> GetSynergy(sc2dsstatsContext context, DsRequest request)
{
var timestrings = DSData.Timestrings(request.Timespan);
var results = context.DsTimeResults
.Include(i => i.Teammates)
.AsNoTracking()
.Where(x => x.Player == request.Player && timestrings.Contains(x.Timespan) && x.Cmdr == request.Interest);
var synresults = await results.ToListAsync();
int tcount = synresults.Sum(s => s.Count);
var response = new DsResponse()
{
Interest = request.Interest,
Count = tcount,
AvgDuration = (int)(synresults.Sum(s => s.Duration) / tcount),
Items = new List <DsResponseItem>()
};
foreach (var cmdr in DSData.cmdrs)
{
var teammates = synresults.SelectMany(s => s.Teammates).Where(x => x.Cmdr == cmdr);
int count = teammates.Sum(s => s.Count);
response.Items.Add(new DsResponseItem()
{
Label = cmdr,
Count = count / 6,
Wins = teammates.Sum(s => s.Wins)
});
}
return(response);
}
public static async Task <DsResponse> GetMvp(sc2dsstatsContext context, DsRequest request)
{
var data = await GetMVPData(context, request);
var response = new DsResponse()
{
Interest = request.Interest,
Count = data.Select(s => s.Id).Distinct().Count(),
Items = new List <DsResponseItem>()
};
response.AvgDuration = (int)((double)data.Sum(s => s.Duration) / (double)data.Count);
foreach (var cmdr in Enum.GetValues <DSData.Commander>())
{
var cmdrreps = (request.Interest == "ALL") switch
{
true => data.Where(x => x.Race == (byte)cmdr),
false => data.Where(x => x.OppRace == (byte)cmdr)
};
response.Items.Add(new DsResponseItem()
{
Label = cmdr.ToString(),
Count = cmdrreps.Count(),
Wins = cmdrreps.Where(x => x.MVP == true).Count()
});
}
return(response);
}
public static async Task <double> GetQuits(sc2dsstatsContext context, DsRequest request)
{
var replays = GetCountReplays(context, request);
var quits = from r in replays
group r by r.Winner into g
select new
{
Winner = g.Key,
Count = g.Count()
};
var lquits = await quits.ToListAsync();
if (lquits.Any())
{
double sum = (double)lquits.Sum(s => s.Count);
if (sum > 0)
{
return(Math.Round(lquits.Where(x => x.Winner == -1).Count() * 100 / sum, 2));
}
else
{
return(0);
}
}
else
{
return(0);
}
}
public async Task <ActionResult <DsResponse> > GetAntiSynergy(DsRequest request)
{
Stopwatch sw = new Stopwatch();
sw.Start();
DsResponse response;
if (request.Filter == null || request.Filter.isDefault)
{
string hash = request.GenHash();
if (!memoryCache.TryGetValue(hash, out response))
{
response = await StatsService.GetAntiSynergy(context, request);
memoryCache.Set(hash, response, CacheService.BuildCacheOptions);
}
else
{
logger.LogInformation("antisynergy from cache");
}
}
else
{
response = await StatsService.GetAntiSynergy(context, request);
}
await SetLeaverQuit(request, response);
sw.Stop();
logger.LogInformation($"Get AntiSynergy in {sw.ElapsedMilliseconds} ms");
return(response);
}
public static DsResponse GetMvp(DsRequest request, List <CmdrStats> cmdrstats)
{
var stats = GetTimeStats(request, cmdrstats);
if (request.Interest != "ALL")
{
stats = stats.Where(x => x.RACE == (byte)DSData.GetCommander(request.Interest)).ToList();
}
List <DsResponseItem> items = request.Interest == "ALL"
? stats.GroupBy(g => g.RACE).Select(s => new DsResponseItem
{
Label = ((Commander)s.Key).ToString(),
Count = s.Sum(c => c.count),
Wins = s.Sum(c => c.mvp),
}).ToList()
: stats.GroupBy(g => g.OPPRACE).Select(s => new DsResponseItem
{
Label = ((Commander)s.Key).ToString(),
Count = s.Sum(c => c.count),
Wins = s.Sum(c => c.mvp),
}).ToList();
int tcount = items.Sum(s => s.Count);
return(new DsResponse()
{
Interest = request.Interest,
Count = request.Player ? tcount : tcount / 6,
AvgDuration = tcount == 0 ? 0 : (int)(stats.Sum(s => s.duration) / tcount),
Items = items
});
}
public DsResponse CommonTrn(DsRequest dsReq)
{
DsResponse dsRes = new DsResponse(dsReq);
switch (dsReq.CommandType)
{
case "C":
dsRes.objResult = IBatisNet2Helper.Instance.Insert(dsReq.CommandId, dsReq.htParam);
break;
case "U":
dsRes.objResult = IBatisNet2Helper.Instance.Update(dsReq.CommandId, dsReq.htParam);
break;
case "D":
dsRes.objResult = IBatisNet2Helper.Instance.Delete(dsReq.CommandId, dsReq.htParam);
break;
case "SP":
;
break;
case null:
case "":
case "R":
default:
dsRes.DtResult = IBatisNet2Helper.Instance.QueryForDataTable(dsReq.CommandId, dsReq.htParam);
break;
}
return(dsRes);
}
private void button2_Click(object sender, EventArgs e)
{
DsResponse dsRes = null;
DsRequest dsReq = new DsRequest();
Hashtable ht = new Hashtable();
try
{
dsReq = new DsRequest();
ht = new Hashtable();
dsReq.CommandId = "POS320401.SetUserInfo";
dsReq.CommandType = "C";
dsReq.htParam = ht;
using (TS.Biz.BizPOS320401 objNTx = new TS.Biz.BizPOS320401())
{
dsRes = objNTx.SetTestTransaction(dsReq);
}
dataGridView1.DataSource = dsRes.DtResult;
}
catch (Exception ex)
{
}
finally
{
dsRes = null;
dsReq = null;
ht = null;
}
}
public static bool AddChartDataSet(ConfigBase config, DsRequest request, DsResponse response)
{
return(request.ChartType switch
{
"Bar" => AddBarDataSet(config as BarConfig, request, response, false),
"Line" => AddLineDataSet(config as LineConfig, request, response as TimelineResponse, true),
"Radar" => AddRadarDataSet(config as RadarConfig, request, response, true),
"Pie" => AddPieDataSet(config as PieConfig, request, response),
_ => false
});
private async Task SetLeaverQuit(DsRequest request, DsResponse response)
{
// response.CountResponse = await GetCountResponse(request);
response.CountResponse = new DsCountResponse()
{
FilteredCount = response.Count,
Leaver = await GetLeaver(request),
Quits = await GetQuits(request)
};
}
public DataTable GetCommonNTx(DsRequest dsR)
{
DataTable dtResult = null;
using (DacPOS320401NTx objNTx = new DacPOS320401NTx())
{
dtResult = objNTx.GetCommonNTx(dsR);
}
return(dtResult);
}
public async Task <ActionResult <DsResponse> > GetCrosstable(DsRequest request)
{
Stopwatch sw = new Stopwatch();
sw.Start();
var response = StatsService.GetCrosstable(request, await GetCmdrStats(request.Player));
sw.Stop();
logger.LogInformation($"Get Crosstable in {sw.ElapsedMilliseconds} ms");
return(response);
}
public async Task <ActionResult <TimelineResponse> > GetDuration(DsRequest request)
{
Stopwatch sw = new Stopwatch();
sw.Start();
var response = await DurationService.GetDuration(context, request);
sw.Stop();
logger.LogInformation($"Get Timeline in {sw.ElapsedMilliseconds} ms");
return(response);
}
public async Task <ActionResult <DsResponse> > GetAntiSynergy(DsRequest request)
{
Stopwatch sw = new Stopwatch();
sw.Start();
// var response = await WinrateService.GetWinrate(request, context);
var response = await SynergyService.GetAntiSynergy(context, request);
sw.Stop();
logger.LogInformation($"Get AntiSynergy in {sw.ElapsedMilliseconds} ms");
return(response);
}
public async Task LoadData(DsRequest Request, bool resetChart = true)
{
await semaphoreSlim.WaitAsync();
try
{
if (isLoading == false)
{
isLoading = true;
await InvokeAsync(() => StateHasChanged());
}
response = await dataService.LoadData(Request);
if (response != null)
{
Request.Responses.Add(response);
isDataAvailable = true;
if (resetChart)
{
SetChartData();
if (Request.doReloadSelected && Request.CmdrsSelected != null)
{
var cmdrsSelected = Request.CmdrsSelected.Where(x => x.Selected && x.Name != Request.Interest);
if (cmdrsSelected.Any())
{
foreach (var cmdr in cmdrsSelected)
{
var cmdrrequest = new DsRequest(Request.Mode, Request.Timespan, Request.Player, cmdr.Name);
var cmdrresponse = await dataService.LoadData(cmdrrequest);
ChartService.AddChartDataSet(_config, cmdrrequest, cmdrresponse);
chartComponent.Update();
}
}
}
}
}
else
{
Info = "Failed loading data :(";
}
}
catch (Exception e)
{
logger.LogError($"failed loading data: {e.Message}");
}
finally
{
semaphoreSlim.Release();
}
isLoading = false;
await InvokeAsync(() => StateHasChanged());
}
public DsResponse CommonTrn(DsRequest dsReq)
{
DsResponse dsRes = null;
using (DacCommon objTrn = new DacCommon())
{
dsRes = objTrn.CommonTrn(dsReq);
}
return(dsRes);
}
public async Task <ActionResult <DsResponse> > GetCrosstable(DsRequest request)
{
Stopwatch sw = new Stopwatch();
sw.Start();
// var response = await CrossTableService.GetCrossTableData(request, context);
var response = await CrossTableService.GetCrosstableFromTimeResults(context, request);
sw.Stop();
logger.LogInformation($"Get Crosstable in {sw.ElapsedMilliseconds} ms");
return(response);
}
private async Task <double> GetQuits(DsRequest request)
{
double leaver;
string memKey = "quits" + request.StartTime.ToString("yyyyMMdd") + request.EndTime.ToString("yyyyMMdd");
if (!memoryCache.TryGetValue(memKey, out leaver))
{
leaver = await StatsService.GetQuits(context, request);
memoryCache.Set(memKey, leaver, CacheService.BuildCacheOptions);
}
return(leaver);
}
public static List <CmdrStats> GetTimeStats(DsRequest request, List <CmdrStats> stats)
{
return(request.Timespan switch
{
"This Month" => stats.Where(x => x.year == DateTime.Today.Year && x.month == DateTime.Today.Month).ToList(),
"Last Month" => stats.Where(x => x.year == DateTime.Today.AddMonths(-1).Year&& x.month == DateTime.Today.AddMonths(-1).Month).ToList(),
"This Year" => stats.Where(x => x.year == DateTime.Today.Year).ToList(),
"Last Year" => stats.Where(x => x.year == DateTime.Today.AddYears(-1).Year).ToList(),
"Last Two Years" => stats.Where(x => x.year == DateTime.Today.Year || x.year == DateTime.Today.AddYears(-1).Year).ToList(),
"ALL" => stats,
"Patch 2.60" => GetTimeStats(new DateTime(2020, 07, 28, 5, 23, 0), DateTime.Today.AddDays(1), stats),
"Custom" => GetTimeStats(request.StartTime, request.EndTime, stats),
_ => stats
});
public static DsResponse GetCrosstable(DsRequest request, List <CmdrStats> cmdrstats)
{
var stats = GetTimeStats(request, cmdrstats);
List <CmdrStats> laststats = new List <CmdrStats>(stats);
if (stats.Any())
{
var last = stats.OrderByDescending(o => o.year).ThenByDescending(o => o.month).Last();
laststats.RemoveAll(x => x.year == last.year && x.month == last.month);
if (DateTime.Today.Day < 16)
{
if (last.month > 1)
{
laststats.RemoveAll(x => x.year == last.year && x.month == last.month - 1);
}
else
{
laststats.RemoveAll(x => x.year == last.year - 1 && x.month == 12);
}
}
}
List <DsResponseItem> lastitems = new List <DsResponseItem>();
if (laststats.Any())
{
lastitems = laststats.GroupBy(g => new { cmdr = g.RACE, opp = g.OPPRACE }).Select(s => new DsResponseItem()
{
Label = $"{(DSData.Commander)s.Key.cmdr} vs {(DSData.Commander)s.Key.opp}",
Count = s.Sum(s => s.count),
Wins = s.Sum(s => s.wins),
}).ToList();
}
var items = stats.GroupBy(g => new { cmdr = g.RACE, opp = g.OPPRACE }).Select(s => new CrosstableResponseItem()
{
Label = $"{(DSData.Commander)s.Key.cmdr} vs {(DSData.Commander)s.Key.opp}",
Count = s.Sum(s => s.count),
Wins = s.Sum(s => s.wins),
OldCount = lastitems.FirstOrDefault(f => f.Label == $"{(DSData.Commander)s.Key.cmdr} vs {(DSData.Commander)s.Key.opp}") != null ? lastitems.FirstOrDefault(f => f.Label == $"{(DSData.Commander)s.Key.cmdr} vs {(DSData.Commander)s.Key.opp}").Count : 0,
OldWins = lastitems.FirstOrDefault(f => f.Label == $"{(DSData.Commander)s.Key.cmdr} vs {(DSData.Commander)s.Key.opp}") != null ? lastitems.FirstOrDefault(f => f.Label == $"{(DSData.Commander)s.Key.cmdr} vs {(DSData.Commander)s.Key.opp}").Wins : 0,
}).OrderBy(o => o.Label).ToList();
return(new CrosstableResponse()
{
Interest = "CrossTable",
Items = items
});
}
protected override Task OnInitializedAsync()
{
cmdrList = DSData.cmdrs.ToList();
playerList = new List <string>()
{
"Global", "Uploaders"
};
cmdrList.Insert(0, "ALL");
if (Request == null)
{
Request = new DsRequest("Winrate", "This Year", playerStats);
}
LoadData(Request);
return(base.OnInitializedAsync());
}
private async Task <double> GetLeaver(DsRequest request)
{
double leaver;
//string memKey = "leaver" + request.StartTime.ToString("yyyyMMdd") + request.EndTime.ToString("yyyyMMdd");
//if (!memoryCache.TryGetValue(memKey, out leaver))
//{
// leaver = await StatsService.GetLeaver(context, request);
// memoryCache.Set(memKey, leaver, CacheService.RankingCacheOptions);
//}
leaver = await StatsService.GetLeaver(context, request);
return(leaver);
}
public static IQueryable <Dsreplay> Filter(sc2dsstatsContext context, DsRequest request)
{
if (request.Filter == null || request.Filter.isDefault)
{
var dreplays = DefaultFilter(context);
dreplays = dreplays.Where(x => x.Gametime >= request.StartTime);
if (request.EndTime != DateTime.Today)
{
dreplays = dreplays.Where(x => x.Gametime <= request.EndTime);
}
return(dreplays);
}
return(GetFilteredReplays(context, request.Filter, request.StartTime, request.EndTime));
}
private static async Task <List <DbStatsResult> > GetData(DsRequest request, sc2dsstatsContext context)
{
var replays = ReplayFilter.DefaultFilter(context);
var reps = request.Player switch
{
false => from r in replays
from p in r.Dsplayers
where r.Gametime >= request.StartTime && r.Gametime <= request.EndTime
select new DbStatsResult()
{
Id = r.Id,
Win = p.Win,
Race = p.Race,
OppRace = p.Opprace,
GameTime = r.Gametime
},
true => from r in replays
from p in r.Dsplayers
where r.Gametime >= request.StartTime && r.Gametime <= request.EndTime &&
p.isPlayer
select new DbStatsResult()
{
Id = r.Id,
Win = p.Win,
Race = p.Race,
OppRace = p.Opprace,
GameTime = r.Gametime
}
};
return(await reps.ToListAsync());
//var dbresults = context.DbStatsResults
// .AsNoTracking()
// .Where(x =>
// x.GameTime >= request.StartTime
// && x.GameTime <= request.EndTime
//);
//if (request.Player)
//{
// dbresults = dbresults.Where(x => x.Player == true);
//}
// return await dbresults.ToListAsync();
}
public async Task <ActionResult <DsResponse> > GetWinrate(DsRequest request)
{
Stopwatch sw = new Stopwatch();
sw.Start();
DsResponse response;
if (request.Filter == null || request.Filter.isDefault)
{
response = await WinrateService.GetWinrateFromTimeResults(context, request);
}
else
{
response = await WinrateService.GetWinrate(context, request);
}
sw.Stop();
logger.LogInformation($"Get Winrate in {sw.ElapsedMilliseconds} ms");
return(response);
}
public DsResponse SetCommonTx(DsRequest dsR)
{
DsResponse dsRes = null;
try
{
dsRes.dtResult = IBatisNet2Helper.Instance.QueryForDataTable("POS320401.GetUserInfo", dsR.htParam);
dsRes.objResult = dsRes.dtResult.Rows.Count;
}
catch (Exception ex)
{
throw ex;
}
finally
{
}
return(dsRes);
}
private async Task <DsCountResponse> GetCountResponse(DsRequest request)
{
Stopwatch sw = new Stopwatch();
sw.Start();
string hash = request.GenHash();
DsCountResponse response;
string memKey = "countresponse" + hash;
if (!memoryCache.TryGetValue(memKey, out response))
{
response = await StatsService.GetCount(context, request);
memoryCache.Set(memKey, response, CacheService.RankingCacheOptions);
cacheService.AddHashKey(memKey);
}
sw.Stop();
logger.LogInformation($"Get count response in {sw.ElapsedMilliseconds} ms");
return(response);
}
public async Task <DsResponse> LoadData(DsRequest request)
{
DsResponse response;
if (request.Filter == null || request.Filter.isDefault)
{
response = request.Mode switch
{
"Winrate" => StatsService.GetWinrate(request, await GetStats(request.Player)),
"Timeline" => StatsService.GetTimeline(new TimelineRequest(request.Mode, request.Timespan, request.Player, request.Interest, request.Versus)
, await GetStats(request.Player)),
"MVP" => request.Player ? await StatsService.GetCustomMvp(request, context) : StatsService.GetMvp(request, await GetStats(request.Player)),
"DPS" => StatsService.GetDps(request, await GetStats(request.Player)),
"Synergy" => await StatsService.GetSynergy(context, request),
"AntiSynergy" => await StatsService.GetAntiSynergy(context, request),
"Duration" => await StatsService.GetDuration(context, request),
"Standard" => await StatsService.GetStandardTeamWinrate(request, context),
_ => StatsService.GetWinrate(request, await GetStats(request.Player))
};
}
else
{
response = request.Mode switch
{
"Winrate" => await StatsService.GetCustomWinrate(request, context),
"Timeline" => await StatsService.GetCustomTimeline(context, new TimelineRequest(request.Mode, request.Timespan, request.Player, request.Interest, request.Versus)),
"MVP" => await StatsService.GetCustomMvp(request, context),
"DPS" => await StatsService.GetCustomDps(request, context),
"Synergy" => await StatsService.GetSynergy(context, request),
"AntiSynergy" => await StatsService.GetAntiSynergy(context, request),
"Duration" => await StatsService.GetDuration(context, request),
"Standard" => await StatsService.GetStandardTeamWinrate(request, context),
_ => await StatsService.GetCustomWinrate(request, context),
};
}
response.CountResponse = await GetCountResponse(request);
return(response);
}
