public static int GetUnitId(sc2dsstatsContext context, string name)
{
var unit = UnitNames.FirstOrDefault(f => f.Name == name);
if (unit == null)
{
if (context == null)
{
return(-1);
}
else
{
int id = !UnitNames.Any() ? 0 : UnitNames.Last().sId + 1;
unit = new UnitName()
{
sId = id,
Name = name
};
UnitNames.Add(unit);
context.UnitNames.Add(unit);
var info = context.DsInfo.First(f => f.Id == 1);
var now = DateTime.UtcNow;
info.UnitNamesUpdate = new DateTime(now.Year, now.Month, now.Day);
}
}
return(unit.sId);
}
private static async Task <List <DbStatsResult> > GetMVPData(sc2dsstatsContext context, DsRequest request)
{
var replays = ReplayFilter.Filter(context, request);
var results = from r in replays
from p in r.Dsplayers
select new DbStatsResult()
{
Id = r.Id,
Race = p.Race,
OppRace = p.Opprace,
Duration = r.Duration,
Win = p.Win,
Player = p.isPlayer,
MVP = p.Killsum == r.Maxkillsum
};
if (request.Interest != "ALL")
{
results = results.Where(x => x.Race == (byte)DSData.GetCommander(request.Interest));
}
if (request.Player)
{
results = results.Where(x => x.Player);
}
return(await results.ToListAsync());
}
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 static async Task <DsPlayerName> GetPlayerName(sc2dsstatsContext context, DsUploadRequest request)
{
var playerName = await context.DsPlayerNames.FirstOrDefaultAsync(f => f.AppId == request.AppId);
if (playerName == null)
{
playerName = await context.DsPlayerNames.FirstOrDefaultAsync(f => f.Hash == request.Hash);
}
if (playerName == null)
{
var restPlayer = await context.DSRestPlayers.FirstOrDefaultAsync(f => f.Name == request.Hash);
playerName = new DsPlayerName()
{
AppId = request.AppId,
DbId = Guid.NewGuid(),
Hash = request.Hash,
Name = String.Empty,
AppVersion = request.Version,
LatestReplay = restPlayer == null ? new DateTime(2018, 1, 1) : restPlayer.LastRep
};
context.DsPlayerNames.Add(playerName);
}
// TODO DEBUG
// else if (playerName.AppId == new Guid())
// {
playerName.AppId = request.AppId;
// }
playerName.TotlaReplays = request.Total;
playerName.LatestUpload = DateTime.UtcNow;
playerName.AppVersion = request.Version;
await context.SaveChangesAsync();
return(playerName);
}
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);
}
private async Task SetPlayerNames(Dsreplay replay, sc2dsstatsContext context)
{
foreach (var player in replay.Dsplayers.Where(x => x.isPlayer))
{
DsPlayerName playerName;
if (player.Name.Length == 64)
{
playerName = await context.DsPlayerNames.FirstOrDefaultAsync(f => f.Hash == player.Name);
}
else
{
playerName = await context.DsPlayerNames.FirstOrDefaultAsync(f => f.AppId.ToString() == player.Name);
}
if (playerName == null)
{
continue;
}
player.Name = playerName.DbId.ToString();
player.PlayerName = playerName;
if (!playerName.NamesMapped && playerName.AppId != Guid.Empty && !String.IsNullOrEmpty(playerName.Hash))
{
var mapReps = await context.Dsplayers.Where(x => x.Name == playerName.Hash).ToListAsync();
foreach (var pl in mapReps)
{
pl.Name = playerName.DbId.ToString();
pl.PlayerName = playerName;
}
playerName.NamesMapped = true;
}
}
}
public UploadController(sc2dsstatsContext context, ProducerService producerService, CacheService cacheService, ILogger <UploadController> logger)
{
this.context = context;
this.producerService = producerService;
this.cacheService = cacheService;
this.logger = logger;
}
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);
}
}
private async Task <bool> CheckDuplicate(Dsreplay replay, sc2dsstatsContext context)
{
var dbReplay = await context.Dsreplays
.Include(i => i.Dsplayers)
.FirstOrDefaultAsync(f => f.Hash == replay.Hash);
if (dbReplay == null)
{
return(false);
}
foreach (var incPlayer in replay.Dsplayers.Where(x => x.isPlayer))
{
var exPlayer = dbReplay.Dsplayers.FirstOrDefault(f => f.Realpos == incPlayer.Realpos);
if (exPlayer != null && exPlayer.PlayerName == null)
{
exPlayer.PlayerName = incPlayer.PlayerName;
exPlayer.Name = incPlayer.PlayerName.DbId.ToString();
}
}
if (new Version(dbReplay.Version) <= new Version(4, 0) &&
new Version(replay.Version) > new Version(4, 0))
{
dbReplay.Bunker = replay.Bunker;
dbReplay.Cannon = replay.Cannon;
dbReplay.Mid1 = replay.Mid1;
dbReplay.Mid2 = replay.Mid2;
}
return(true);
}
public static void CopyRestPlayerData(sc2dsstatsContext context, DSRestContext restContext)
{
var restPlayers = restContext.DSRestPlayers.AsNoTracking().ToList();
foreach (var restPlayer in restPlayers)
{
var newPlayer = context.DSRestPlayers.FirstOrDefault(f => f.Name == restPlayer.Name);
if (newPlayer == null)
{
newPlayer = new db.DSRestPlayer()
{
Name = restPlayer.Name,
Json = restPlayer.Json,
LastRep = restPlayer.LastRep,
LastUpload = restPlayer.LastUpload,
Data = restPlayer.Data,
Total = restPlayer.Total,
Version = restPlayer.Version
};
context.DSRestPlayers.Add(newPlayer);
}
else
{
if (newPlayer.LastRep < restPlayer.LastRep)
{
newPlayer.LastRep = restPlayer.LastRep;
}
}
}
context.SaveChanges();
}
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 StatsController(sc2dsstatsContext context, IMemoryCache memoryCache, CacheService cacheService, ILogger <StatsController> logger)
{
this.context = context;
this.memoryCache = memoryCache;
this.cacheService = cacheService;
this.logger = logger;
}
public static string ConvertUpgradeString(sc2dsstatsContext context, string upgradeString)
{
StringBuilder sb = new StringBuilder();
if (!String.IsNullOrEmpty(upgradeString))
{
var ups = upgradeString.Split("|");
for (int i = 0; i < ups.Length; i++)
{
int id;
if (int.TryParse(ups[i], out id))
{
var jsonUpgrade = DSData.Upgrades.FirstOrDefault(f => f.ID == id);
if (jsonUpgrade != null)
{
id = GetUpgradeId(context, jsonUpgrade.Name);
}
}
else
{
id = GetUpgradeId(context, ups[i]);
}
sb.Append($"{id}|");
}
if (sb.Length > 0)
{
sb.Remove(sb.Length - 1, 1);
}
}
return(sb.Length == 0 ? null : sb.ToString());
}
public static async Task GetTeammateStats(sc2dsstatsContext context)
{
//select p.name, p.Team, count(*) as c from DSReplays as r
//inner join DSPlayers as p on p.DSReplayID = r.ID
//where 0 = (select t.Team from DSPlayers as t where t.DSReplayID = r.ID and t.name = 'PAX')
//group by p.name, p.Team
//order by c desc
}
public DataService(sc2dsstatsContext context, IMemoryCache memoryCache, IHttpClientFactory clientFactory, IServiceScopeFactory scopeFactory, ILogger <DataService> logger)
{
this.context = context;
this.memoryCache = memoryCache;
this.clientFactory = clientFactory;
this.scopeFactory = scopeFactory;
this.logger = logger;
}
public static (string, string) ConvertUnitStrings(sc2dsstatsContext context, string dsUnitsString, string dbUnitsString)
{
StringBuilder newdsUnitsString = new StringBuilder();
StringBuilder newdbUnitsString = new StringBuilder();
if (!String.IsNullOrEmpty(dsUnitsString))
{
var units = dsUnitsString.Split("|");
for (int i = 0; i < units.Length; i++)
{
var unitcounts = units[i].Split(",");
int id;
if (int.TryParse(unitcounts[0], out id))
{
var jsonUnit = DSData.Units.FirstOrDefault(f => f.ID == id);
if (jsonUnit != null)
{
id = GetUnitId(context, jsonUnit.Name);
}
}
else
{
id = GetUnitId(context, unitcounts[0]);
}
newdsUnitsString.Append($"{id},{unitcounts[1]}|");
}
newdsUnitsString.Remove(newdsUnitsString.Length - 1, 1);
}
if (!String.IsNullOrEmpty(dbUnitsString))
{
var pos = dbUnitsString.Split("|");
for (int i = 0; i < pos.Length; i++)
{
var unitpos = pos[i].Split(",");
int id;
if (int.TryParse(unitpos[0], out id))
{
var jsonUnit = DSData.Units.FirstOrDefault(f => f.ID == id);
if (jsonUnit != null)
{
id = GetUnitId(context, jsonUnit.Name);
}
}
else
{
id = GetUnitId(context, unitpos[0]);
}
newdbUnitsString.Append($"{id},{unitpos[1]},{unitpos[2]}|");
}
if (newdbUnitsString.Length > 0)
{
newdbUnitsString.Remove(newdbUnitsString.Length - 1, 1);
}
}
return(newdsUnitsString.Length == 0 ? null : newdsUnitsString.ToString(), newdbUnitsString.Length == 0 ? null : newdbUnitsString.ToString());
}
public static IQueryable <Dsreplay> DefaultFilter(sc2dsstatsContext context)
{
return(context.Dsreplays
.Include(p => p.Dsplayers)
.AsNoTracking()
.Where(x =>
x.DefaultFilter == true
));
}
public static bool CreateJson(sc2dsstatsContext context, localContext?localContext)
{
try
{
var names = context.UnitNames.Select(s => new NameResponse()
{
sId = s.sId,
Name = s.Name
}).ToList();
var upgrades = context.UpgradeNames.Select(s => new NameResponse()
{
sId = s.sId,
Name = s.Name
});
var unitfile = "../sc2dsstats.app/json/unitnames.json";
var upgradefile = "../sc2dsstats.app/json/upgradenames.json";
File.WriteAllText(unitfile, JsonSerializer.Serialize(names));
File.WriteAllText(upgradefile, JsonSerializer.Serialize(upgrades));
if (localContext != null)
{
localContext.Database.ExecuteSqlRaw("TRUNCATE TABLE unitnames");
localContext.UnitNames.AddRange(names.Select(s => new UnitName()
{
sId = s.sId,
Name = s.Name
}));
localContext.SaveChanges();
localContext.Database.ExecuteSqlRaw("TRUNCATE TABLE upgradenames");
localContext.UpgradeNames.AddRange(upgrades.Select(s => new UpgradeName()
{
sId = s.sId,
Name = s.Name
}));
localContext.SaveChanges();
}
}
catch (Exception ex)
{
Program.logger?.LogError($"failed creating name jsons: {ex.Message}");
return(false);
}
var info = context.DsInfo.First(f => f.Id == 1);
DateTime now = DateTime.UtcNow;
info.UnitNamesUpdate = new DateTime(now.Year, now.Month, now.Day);
info.UpgradeNamesUpdate = new DateTime(now.Year, now.Month, now.Day);
context.SaveChanges();
Program.logger?.LogInformation("Successfully created name jsons with DsInfo update");
return(true);
}
public static async Task <List <DsRankingResponse> > GetRanking(sc2dsstatsContext context)
{
var replays = ReplayFilter.DefaultFilter(context);
replays = replays.Where(x => x.Gametime >= new DateTime(2018, 1, 1));
var players = await GetDatasets(context);
List <DsRankingResponse> rankings = new List <DsRankingResponse>();
foreach (var ent in players)
{
var plReplays = from r in replays
from p in r.Dsplayers
where p.Name == ent.Key
select new RankingHelper()
{
Id = r.Id,
Gametime = r.Gametime,
MVP = r.Maxkillsum == p.Killsum,
WIN = p.Win,
Commander = ((DSData.Commander)p.Race).ToString(),
WithTeammates = r.Dsplayers.Where(x => x.Team == p.Team && x != p && x.isPlayer).Any()
};
var plData = await plReplays.AsSplitQuery().ToListAsync();
if (plData.Count < 20)
{
continue;
}
int maincount = 0;
string main = "";
foreach (var cmdr in DSData.cmdrs)
{
int c = plData.Where(x => x.Commander == cmdr).Count();
if (c > maincount)
{
maincount = c;
main = cmdr;
}
}
rankings.Add(new DsRankingResponse()
{
Playername = !String.IsNullOrEmpty(ent.Value) ? ent.Value : ent.Key,
Games = plData.Count,
Wins = plData.Where(x => x.WIN).Count(),
MVPs = plData.Where(x => x.MVP).Count(),
MainCommander = main,
GamesMain = maincount,
Teamgames = plData.Where(x => x.WithTeammates).Count()
});
}
return(rankings);
}
public static IQueryable <Dsreplay> Filter(sc2dsstatsContext context, DsReplayRequest request)
{
if (request.Filter == null || request.Filter.isDefault)
{
return(DefaultFilter(context));
}
else
{
return(GetFilteredReplays(context, request.Filter, DateTime.MinValue, DateTime.Today));
}
}
public static async Task <DsResponse> GetCrosstableFromTimeResults(sc2dsstatsContext context, DsRequest request)
{
var timestrings = DSData.Timestrings(request.Timespan, true);
var results = await context.DsTimeResults
.AsNoTracking()
.Where(x =>
x.Player == request.Player &&
timestrings.Contains(x.Timespan))
.ToListAsync();
CrosstableResponse response = new CrosstableResponse()
{
Interest = "CrossTable",
Items = new List <CrosstableResponseItem>()
};
var removeMonths = new List <string>()
{
DateTime.Today.ToString("yyyyMM")
};
if (DateTime.Today.Day < 16)
{
removeMonths.Add((DateTime.Today.AddMonths(-1)).ToString("yyyyMM"));
}
foreach (var cmdr in DSData.cmdrs)
{
var cmdrResults = results.Where(x => x.Cmdr == cmdr).ToArray();
foreach (var vs in DSData.cmdrs)
{
if (vs == cmdr)
{
response.Items.Add(new CrosstableResponseItem());
}
else
{
var vsResults = cmdrResults.Where(x => x.Opp == vs).ToArray();
var oldVsResults = vsResults.Where(x => !removeMonths.Contains(x.Timespan)).ToArray();
response.Items.Add(new CrosstableResponseItem()
{
Label = $"{cmdr} vs {vs}",
Count = vsResults.Sum(s => s.Count),
Wins = vsResults.Sum(s => s.Wins),
OldCount = oldVsResults.Sum(s => s.Count),
OldWins = oldVsResults.Sum(s => s.Wins),
});
}
}
}
return(response);
}
private static IQueryable <Dsreplay> GetCountReplays(sc2dsstatsContext context, DsRequest request)
{
var replays = context.Dsreplays.Where(x => x.Gametime > request.StartTime);
if (request.Filter == null)
{
replays = replays.Where(x => new List <int>()
{
(int)Gamemode.Commanders, (int)Gamemode.CommandersHeroic
}.Contains(x.Gamemode));
}
else if (request.Filter.GameModes.Any())
{
replays = replays.Where(x => request.Filter.GameModes.Contains(x.Gamemode));
}
if (request.EndTime != DateTime.Today)
{
replays = replays.Where(x => x.Gametime <= request.EndTime);
}
if (!String.IsNullOrEmpty(request.Interest) && !request.Interest.Equals("ALL"))
{
replays = replays.Include(i => i.Dsplayers);
if (request.Player)
{
replays = from r in replays
from p in r.Dsplayers
where p.isPlayer && p.Race == (byte)DSData.GetCommander(request.Interest)
select r;
}
else
{
replays = from r in replays
from p in r.Dsplayers
where p.Race == (byte)DSData.GetCommander(request.Interest)
select r;
}
replays = replays.Distinct();
}
if (request.Filter != null && request.Filter.Players.Any())
{
replays = from r in replays
from p in r.Dsplayers
where request.Filter.Players.Contains(p.Name)
select r;
if (request.Filter.Players.Count > 0)
{
return(replays.Distinct());
}
}
return(replays);
}
public static async Task <TimelineResponse> GetCustomTimeline(sc2dsstatsContext context, TimelineRequest request)
{
if (request.Step < 3)
{
request.Step = 3;
}
if (request.smaK < 3)
{
request.smaK = 3;
}
var lresults = await GetTimelineData(request, context);
TimelineResponse response = new TimelineResponse()
{
Count = lresults.Select(s => s.Id).Distinct().Count(),
Interest = request.Interest,
Versus = request.Versus,
AvgDuration = lresults.Count == 0 ? 0 : (int)(lresults.Sum(s => s.Duration) / (double)lresults.Count),
Items = new List <DsResponseItem>()
};
DateTime _dateTime = request.StartTime;
while (_dateTime < request.EndTime)
{
DateTime dateTime = _dateTime.AddMonths(1);
var stepResults = lresults.Where(x => x.GameTime >= _dateTime && x.GameTime < dateTime).ToList();
response.Items.Add(new TimelineResponseItem()
{
Label = $"{_dateTime.ToString("yyyy-MM-dd")} ({stepResults.Count})",
Count = stepResults.Count,
Wins = stepResults.Where(x => x.Win == true).Count()
});
_dateTime = dateTime;
}
if (response.Items.Any() && response.Items.Last().Count < 10)
{
response.Items.RemoveAt(response.Items.Count - 1);
}
var sma = new SimpleMovingAverage(request.smaK);
response.SmaData = new List <double>();
response.SmaData = GetNiceLineData(response.Items.Select(s => s.Count == 0 ? 0 : ((double)s.Wins * 100.0 / (double)s.Count)), request.smaK);
return(response);
}
public static async Task <List <DsReplayResponse> > GetReplays(sc2dsstatsContext context, DsReplayRequest request, CancellationToken cancellationToken)
{
var replays = GetQueriableReplays(context, request);
if (request.sortOrders != null && request.sortOrders.Any())
{
foreach (var sortOrder in request.sortOrders)
{
if (sortOrder.Order)
{
replays = replays.AppendOrderBy(sortOrder.Sort);
}
else
{
replays = replays.AppendOrderByDescending(sortOrder.Sort);
}
}
}
else
{
replays = replays.OrderByDescending(o => o.Gametime);
}
replays = replays.Skip(request.Skip).Take(request.Take);
List <DsReplayResponse> replayResponses = new List <DsReplayResponse>();
if (!cancellationToken.IsCancellationRequested)
{
try
{
replayResponses = await replays.Select(s => new DsReplayResponse()
{
Id = s.Id,
Hash = s.Hash,
Races = s.Dsplayers.OrderBy(o => o.Realpos).Select(r => ((Commander)r.Race).ToString()).ToList(),
Players = s.Dsplayers.OrderBy(o => o.Realpos).Select(r => r.Name).ToList(),
Gametime = s.Gametime,
Duration = s.Duration,
PlayerCount = s.Playercount,
GameMode = ((Gamemode)s.Gamemode).ToString(),
MaxLeaver = s.Maxleaver,
MaxKillsum = s.Maxkillsum,
Winner = s.Winner,
DefaultFilter = s.DefaultFilter
}).ToListAsync(cancellationToken);
}
catch (TaskCanceledException)
{
return(replayResponses);
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, sc2dsstatsContext context, ILoggerFactory loggerFactory)
{
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
ApplicationLogging.LoggerFactory = loggerFactory;
context.Database.Migrate();
var path = ElectronService.GetPath().GetAwaiter().GetResult();
DSData.Init(path);
NameService.Init(context, path).GetAwaiter().GetResult();
app.UseResponseCompression();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapBlazorHub();
endpoints.MapFallbackToPage("/_Host");
});
WebPreferences wp = new WebPreferences();
wp.NodeIntegration = false;
Task.Run(async() => await Electron.WindowManager.CreateWindowAsync(new BrowserWindowOptions()
{
AutoHideMenuBar = true,
Width = 1920,
Height = 1080,
X = 0,
Y = 0,
WebPreferences = wp
}));
}
public static async Task <DsResponse> GetDpsFromTimeResults(sc2dsstatsContext context, DsRequest request)
{
var timestrings = DSData.Timestrings(request.Timespan);
var results = context.DsTimeResults.AsNoTracking().Where(x => x.Player == request.Player && timestrings.Contains(x.Timespan));
if (request.Interest == "ALL")
{
results = results.Where(x => x.Opp == String.Empty);
}
else
{
results = results.Where(x => x.Cmdr == request.Interest);
}
var dpsresults = await results.ToListAsync();
int count = dpsresults.Sum(s => s.Count);
var response = new DsResponse()
{
Interest = request.Interest,
Count = request.Player ? count : count / 6,
AvgDuration = (int)(dpsresults.Sum(s => s.Duration) / count),
Items = new List <DsResponseItem>()
};
foreach (var cmdr in DSData.cmdrs)
{
var cmdrresults = (request.Interest == "ALL") switch
{
true => dpsresults.Where(x => x.Cmdr == cmdr).ToList(),
false => dpsresults.Where(x => x.Opp == cmdr).ToList(),
};
var army = cmdrresults.Sum(s => s.Army);
var kills = cmdrresults.Sum(s => s.Kills);
var dpv = army / kills;
response.Items.Add(new DsResponseItem()
{
Label = cmdr,
Count = (int)(dpv * 10000),
Wins = 10000
});
}
return(response);
}
public static async Task <PlayerNameStatsResponse?> GetPlayerStats(sc2dsstatsContext context, string name, CancellationToken token)
{
if (token.IsCancellationRequested)
{
return(null);
}
var player = await context.DsPlayerNames.FirstOrDefaultAsync(f => f.Name == name, token);
var appplayer = await context.DsPlayerNames.FirstOrDefaultAsync(f => f.AppId != Guid.Empty, token);
var plrepsTeam = from r in context.Dsreplays
from p in r.Dsplayers
from a in r.Dsplayers
where a.PlayerName == player
where p.PlayerName == appplayer
where a.Team == p.Team
group a by a.Win into g
select new
{
Win = g.Key,
Games = g.Count(),
};
var plrepsOpp = from r in context.Dsreplays
from p in r.Dsplayers
from a in r.Dsplayers
where a.PlayerName == player
where p.PlayerName == appplayer
where a.Team != p.Team
group a by a.Win into g
select new
{
Win = g.Key,
Games = g.Count(),
};
var teamStats = await plrepsTeam.AsNoTracking().ToListAsync(token);
var oppStats = await plrepsOpp.AsNoTracking().ToListAsync(token);
return(new PlayerNameStatsResponse()
{
TeamGames = teamStats.Sum(s => s.Games),
TeamWins = teamStats.Where(x => x.Win).Sum(s => s.Games),
OppGames = oppStats.Sum(s => s.Games),
OppWins = oppStats.Where(x => x.Win).Sum(s => s.Games)
});
}
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 static async Task <List <PlayerNameResponse> > GetPlayers(sc2dsstatsContext context)
{
var request = from r in context.Dsreplays
from p in r.Dsplayers
group p by p.Name into g
select new PlayerNameResponse()
{
Name = g.Key,
Games = g.Count(),
Wins = g.Count(c => c.Win)
};
return(await request
.AsNoTracking()
.OrderByDescending(o => o.Games)
.ToListAsync());
}
