public static async Task <List <DbStatsResult> > GetTimelineData(TimelineRequest request, sc2dsstatsContext context)
{
var replays = ReplayFilter.Filter(context, request);
var results = from r in replays
from p in r.Dsplayers
where p.Race == (byte)DSData.GetCommander(request.Interest)
select new DbStatsResult()
{
Id = r.Id,
Win = p.Win,
GameTime = r.Gametime,
Player = p.isPlayer,
OppRace = p.Opprace
};
if (request.Player)
{
results = results.Where(x => x.Player);
}
if (request.Versus != "ALL")
{
results = results.Where(x => x.OppRace == (byte)DSData.GetCommander(request.Versus));
}
return(await results.ToListAsync());
}
public void ReplayFilter_in_Warn_mode_should_warn_about_messages_from_several_old_writers()
{
var filter = Sys.ActorOf(ReplayFilter.Props(TestActor, ReplayFilterMode.Warn, 100, 10, false));
EventFilter.Warning(start: "Invalid replayed event").Expect(3, () =>
{
filter.Tell(_m1);
var m2B = new ReplayedMessage(WithWriter(_m2.Persistent, WriterB));
filter.Tell(m2B);
var m3C = new ReplayedMessage(WithWriter(_m3.Persistent, WriterC));
filter.Tell(m3C);
filter.Tell(_m2);
filter.Tell(_m3);
var m3B = new ReplayedMessage(WithWriter(_m3.Persistent, WriterB));
filter.Tell(m3B);
var m4C = new ReplayedMessage(WithWriter(_m3.Persistent, WriterC));
filter.Tell(m4C);
filter.Tell(_successMsg);
ExpectMsg(_m1);
ExpectMsg(m2B);
ExpectMsg(m3C);
ExpectMsg(_m2);
ExpectMsg(_m3);
ExpectMsg(m3B);
ExpectMsg(m4C);
ExpectMsg(_successMsg);
});
}
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 OOTransport(bool initiator, CipherState <CipherType> c1, CipherState <CipherType> c2)
{
Exceptions.ThrowIfNull(c1, nameof(c1));
this.initiator = initiator;
this.c1 = c1;
this.c2 = c2;
filter = new ReplayFilterNoBitshift();
}
private void InsertReplay(DsReplayDto replay, List <string> playerNames)
{
var dbReplay = new Dsreplay(replay);
dbReplay.Dsplayers.Where(x => playerNames.Contains(x.Name)).ToList().ForEach(x => x.isPlayer = true);
ReplayFilter.SetDefaultFilter(new List <Dsreplay>()
{
dbReplay
});
DbService.SetMid(dbReplay);
insertService.AddReplay(dbReplay);
}
protected override async Task HandleReplayMessages(ReplayMessages req, OracleCommand command, IActorContext context)
{
var replaySettings = Setup.ReplayFilterSettings;
var replyTo = replaySettings.IsEnabled
? context.ActorOf(ReplayFilter.Props(req.PersistentActor, replaySettings.Mode, replaySettings.WindowSize, replaySettings.MaxOldWriters, replaySettings.IsDebug))
: req.PersistentActor;
var persistenceId = req.PersistenceId;
NotifyNewPersistenceIdAdded(persistenceId);
try
{
var highestSequenceNr = await ReadHighestSequenceNr(persistenceId, command);
var toSequenceNr = Math.Min(req.ToSequenceNr, highestSequenceNr);
command.CommandText = ByPersistenceIdSql;
command.Parameters.Clear();
AddParameter(command, ":PersistenceId", OracleDbType.NVarchar2, persistenceId);
AddParameter(command, ":FromSequenceNr", OracleDbType.Int64, req.FromSequenceNr);
AddParameter(command, ":ToSequenceNr", OracleDbType.Int64, toSequenceNr);
using (var reader = await command.ExecuteReaderAsync())
{
var i = 0L;
while (i++ < req.Max && await reader.ReadAsync())
{
var persistent = ReadEvent(reader);
if (persistent.IsDeleted)
{
continue;
}
foreach (var adaptedRepresentation in AdaptFromJournal(persistent))
{
replyTo.Tell(new ReplayedMessage(adaptedRepresentation), ActorRefs.NoSender);
}
}
}
var response = new RecoverySuccess(highestSequenceNr);
replyTo.Tell(response, ActorRefs.NoSender);
}
catch (Exception cause)
{
var response = new ReplayMessagesFailure(cause);
replyTo.Tell(response, ActorRefs.NoSender);
}
}
public static void GetTimeResultsAsJson(sc2dsstatsContext context, ILogger logger)
{
var replays = ReplayFilter.DefaultFilter(context);
var results = replays
.Include(i => i.Dsplayers)
.Select(s => UploadService.GetTimeResultValues(s)).ToList().SelectMany(s => s).ToList();
logger.LogInformation($"Got results: {results.Count} - serializing ...");
File.WriteAllText("/data/results.json", JsonSerializer.Serialize(results, new JsonSerializerOptions()
{
WriteIndented = false
}));
}
public static void SetMengskTestReplaysDefaultToFalse(sc2dsstatsContext context)
{
var replays = ReplayFilter.DefaultFilter(context);
var testReplays = from r in replays
from p in r.Dsplayers
where p.Race == (byte)DSData.Commander.Mengsk && r.Gametime < new DateTime(2020, 07, 28, 5, 23, 0)
select r;
foreach (var replay in testReplays)
{
replay.DefaultFilter = false;
}
context.SaveChanges();
}
public void ReplayFilter_in_RepairByDiscardOld_mode_should_pass_on_all_replayed_messages_when_switching_writer()
{
var filter = Sys.ActorOf(ReplayFilter.Props(TestActor, ReplayFilterMode.RepairByDiscardOld, 100, 10, false));
filter.Tell(_m1);
filter.Tell(_m2);
var m32 = new ReplayedMessage(WithWriter(_m3.Persistent, WriterB));
filter.Tell(m32);
filter.Tell(_successMsg);
ExpectMsg(_m1);
ExpectMsg(_m2);
ExpectMsg(m32);
ExpectMsg(_successMsg);
}
public void ReplayFilter_in_Fail_mode_should_fail_when_message_with_same_SequenceNo_from_old_overlapping_writer()
{
var filter = Sys.ActorOf(ReplayFilter.Props(TestActor, ReplayFilterMode.Fail, 100, 10, false));
EventFilter.Error(start: "Invalid replayed event").ExpectOne(() =>
{
filter.Tell(_m1);
filter.Tell(_m2);
filter.Tell(_m3);
var m3B = new ReplayedMessage(WithWriter(_m3.Persistent, WriterB));
filter.Tell(m3B); // same as SequenceNo as m3, but from WriterB
filter.Tell(_successMsg);
ExpectMsg <ReplayMessagesFailure>(m => m.Cause is IllegalStateException);
});
}
public void ReplayFilter_in_RepairByDiscardOld_mode_should_pass_on_all_replayed_messages_when_previously_no_writer_id_was_given_but_now_is_and_then_stop()
{
var filter = Sys.ActorOf(ReplayFilter.Props(TestActor, ReplayFilterMode.RepairByDiscardOld, 2, 10, true));
filter.Tell(_n1);
filter.Tell(_n2);
filter.Tell(_m3);
filter.Tell(_successMsg);
ExpectMsg(_n1);
ExpectMsg(_n2);
ExpectMsg(_m3);
ExpectMsg(_successMsg);
Watch(filter);
ExpectTerminated(filter);
}
public void ReplayFilter_in_RepairByDiscardOld_mode_should_pass_on_all_replayed_messages_and_then_stop()
{
var filter = Sys.ActorOf(ReplayFilter.Props(TestActor, ReplayFilterMode.RepairByDiscardOld, 2, 10, false));
filter.Tell(_m1);
filter.Tell(_m2);
filter.Tell(_m3);
filter.Tell(_successMsg);
ExpectMsg(_m1);
ExpectMsg(_m2);
ExpectMsg(_m3);
ExpectMsg(_successMsg);
Watch(filter);
ExpectTerminated(filter);
}
public void ReplayFilter_in_RepairByDiscardOld_mode_should_discard_message_with_same_SequenceNo_from_old_overlapping_writer()
{
var filter = Sys.ActorOf(ReplayFilter.Props(TestActor, ReplayFilterMode.RepairByDiscardOld, 100, 10, false));
EventFilter.Warning(start: "Invalid replayed event").ExpectOne(() =>
{
filter.Tell(_m1);
filter.Tell(_m2);
filter.Tell(_m3);
var m3B = new ReplayedMessage(WithWriter(_m3.Persistent, WriterB));
filter.Tell(m3B); // same SequenceNo as m3, but from WriterB
filter.Tell(_successMsg);
ExpectMsg(_m1);
ExpectMsg(_m2);
ExpectMsg(m3B); // discard m3, because same SequenceNo from new writer
ExpectMsg(_successMsg);
});
}
public async Task <DateTime?> Produce(string gzipbase64String, string nameHash)
{
try
{
var replays = JsonSerializer.Deserialize <List <DsReplayDto> >(await DSData.UnzipAsync(gzipbase64String)).OrderByDescending(o => o.GAMETIME);
if (replays.Any())
{
var dsreplays = replays.Select(s => new Dsreplay(s)).ToList();
dsreplays.SelectMany(s => s.Dsplayers).Where(x => x.Name == "player").ToList().ForEach(f => { f.Name = nameHash; f.isPlayer = true; });
ReplayFilter.SetDefaultFilter(dsreplays);
Produce(dsreplays);
return(dsreplays.First().Gametime);
}
}
catch (Exception ex)
{
logger.LogError($"failed producing data: {ex.Message}");
}
return(null);
}
public void ReplayFilter_in_RepairByDiscardOld_mode_should_discard_messages_from_old_writer_after_switching_writer()
{
var filter = Sys.ActorOf(ReplayFilter.Props(TestActor, ReplayFilterMode.RepairByDiscardOld, 100, 10, false));
EventFilter.Warning(start: "Invalid replayed event").Expect(2, () =>
{
filter.Tell(_m1);
filter.Tell(_m2);
var m3B = new ReplayedMessage(WithWriter(_m3.Persistent, WriterB));
filter.Tell(m3B);
filter.Tell(_m3);
filter.Tell(_m4);
filter.Tell(_successMsg);
ExpectMsg(_m1);
ExpectMsg(_m2);
ExpectMsg(m3B);
// discard m3, m4
ExpectMsg(_successMsg);
});
}
public async Task <DateTime?> Produce(IFormFile file, string nameHash)
{
List <DsReplayDto> replays;
using (var stream = new MemoryStream((int)file.Length))
{
await file.CopyToAsync(stream);
replays = await Decompress(stream);
}
if (replays.Any())
{
var dsreplays = replays.Select(s => new Dsreplay(s)).ToList();
dsreplays.SelectMany(s => s.Dsplayers).Where(x => x.Name == "player").ToList().ForEach(f => { f.Name = nameHash; f.isPlayer = true; });
ReplayFilter.SetDefaultFilter(dsreplays);
Produce(dsreplays);
return(dsreplays.First().Gametime);
}
return(null);
}
public static async Task <DsResponse> GetSynergy(sc2dsstatsContext context, DsRequest request)
{
var replays = ReplayFilter.Filter(context, request);
var synergy = request.Player
? from r in replays
from p in r.Dsplayers
from t in r.Dsplayers
where p.isPlayer && p.Race == (byte)DSData.GetCommander(request.Interest) && t.Team == p.Team && t.Id != p.Id
group new { r, p } by t.Race into g
select new DsResponseItem()
{
Label = ((DSData.Commander)g.Key).ToString(),
Count = g.Count(),
Wins = g.Count(c => c.p.Win),
}
: from r in replays
from p in r.Dsplayers
from t in r.Dsplayers
where p.Race == (byte)DSData.GetCommander(request.Interest) && t.Team == p.Team && t.Id != p.Id
group new { r, p } by t.Race into g
select new DsResponseItem()
{
Label = ((DSData.Commander)g.Key).ToString(),
Count = g.Count(),
Wins = g.Count(c => c.p.Win),
};
var items = await synergy.ToListAsync();
items = items.Where(x => DSData.cmdrs.Contains(x.Label)).OrderBy(o => o.Label).ToList();
return(new DsResponse()
{
Interest = request.Interest,
Count = items.Sum(s => s.Count),
Items = items
});
}
public static async Task <DsResponse> GetCustomMvp(DsRequest request, sc2dsstatsContext context)
{
var replays = ReplayFilter.Filter(context, request);
var responses = (request.Player, request.Interest == "ALL") switch
{
(false, true) => from r in replays
from p in r.Dsplayers
group new { r, p } by new { race = p.Race } into g
select new DsResponseItem()
{
Label = ((Commander)g.Key.race).ToString(),
Count = g.Count(),
Wins = g.Count(c => c.p.Killsum == c.r.Maxkillsum),
duration = g.Sum(s => s.r.Duration)
},
(false, false) => from r in replays
from p in r.Dsplayers
where p.Race == (byte)DSData.GetCommander(request.Interest)
group new { r, p } by new { race = p.Opprace } into g
select new DsResponseItem()
{
Label = ((Commander)g.Key.race).ToString(),
Count = g.Count(),
Wins = g.Count(c => c.p.Killsum == c.r.Maxkillsum),
duration = g.Sum(s => s.r.Duration)
},
(true, true) => from r in replays
from p in r.Dsplayers
where p.isPlayer
group new { r, p } by new { race = p.Race } into g
select new DsResponseItem()
{
Label = ((Commander)g.Key.race).ToString(),
Count = g.Count(),
Wins = g.Count(c => c.p.Killsum == c.r.Maxkillsum),
duration = g.Sum(s => s.r.Duration)
},
(true, false) => from r in replays
from p in r.Dsplayers
where p.isPlayer && p.Race == (byte)DSData.GetCommander(request.Interest)
group new { r, p } by new { race = p.Opprace } into g
select new DsResponseItem()
{
Label = ((Commander)g.Key.race).ToString(),
Count = g.Count(),
Wins = g.Count(c => c.p.Killsum == c.r.Maxkillsum),
duration = g.Sum(s => s.r.Duration)
}
};
var items = await responses.ToListAsync();
items = items.Where(x => DSData.cmdrs.Contains(x.Label)).ToList();
int tcount = items.Sum(s => s.Count);
return(new DsResponse()
{
Interest = request.Interest,
Count = tcount / 6,
AvgDuration = tcount == 0 ? 0 : (int)(items.Sum(s => s.duration) / tcount),
Items = items
});
}
public static async Task <TimelineResponse> GetDuration(sc2dsstatsContext context, DsRequest request)
{
var replays = ReplayFilter.Filter(context, request);
replays = replays.Where(x => x.Gametime >= request.StartTime);
if (request.EndTime != DateTime.Today)
{
replays = replays.Where(x => x.Gametime <= request.EndTime);
}
var results = request.Player switch
{
true => from r in replays
from p in r.Dsplayers
where p.Race == (byte)DSData.GetCommander(request.Interest) && p.isPlayer
select new
{
r.Id,
r.Duration,
p.Win
},
false => from r in replays
from p in r.Dsplayers
where p.Race == (byte)DSData.GetCommander(request.Interest)
select new
{
r.Id,
r.Duration,
p.Win
}
};
var lresults = await results.ToListAsync();
TimelineResponse response = new TimelineResponse()
{
Interest = request.Interest,
Count = lresults.Select(s => s.Id).Distinct().Count(),
AvgDuration = lresults.Count == 0 ? 0 : (int)(lresults.Sum(s => s.Duration) / lresults.Count),
Items = new List <DsResponseItem>()
};
if (lresults.Any())
{
for (int i = 0; i < DSData.durations.Length; i++)
{
int startd = 0;
if (i > 0)
{
Match m = d_rx.Match(DSData.durations[i]);
if (m.Success)
{
startd = int.Parse(m.Value);
}
}
int endd = startd + 3;
if (i == 0)
{
endd = 8;
}
if (i == DSData.durations.Length - 1)
{
endd = 200;
}
var ilresults = lresults.Where(x => x.Duration > startd * 60 && x.Duration < endd * 60).ToList();
response.Items.Add(new DsResponseItem()
{
Label = $"{DSData.durations[i]} min ({ilresults.Count})",
Count = ilresults.Count,
Wins = ilresults.Where(x => x.Win == true).Count()
});
}
}
var sma = new SimpleMovingAverage(4);
response.SmaData = new List <double>();
response.SmaData = TimelineService.GetNiceLineData(response.Items.Select(s => s.Count == 0 ? 0 : ((double)s.Wins * 100.0 / (double)s.Count)), 4);
return(response);
}
}
public static async Task <DsPlayerStats> GetPlayerStats(sc2dsstatsContext context, string playerName)
{
var replays = ReplayFilter.DefaultFilter(context);
Guid guid;
DsPlayerName player;
if (Guid.TryParse(playerName, out guid))
{
player = await context.DsPlayerNames.FirstOrDefaultAsync(f => f.DbId.Equals(guid));
}
else
{
player = await context.DsPlayerNames.FirstOrDefaultAsync(f => f.Name == playerName);
}
if (player == null)
{
return(null);
}
var stats = from r in replays
from p in r.Dsplayers
where p.PlayerName == player
group p by p.Race into g
select new DsResponseItem
{
Label = ((DSData.Commander)g.Key).ToString(),
Count = g.Count(),
Wins = g.Count(s => s.Win)
};
var items = await stats.ToListAsync();
items = items.Where(x => DSData.cmdrs.Contains(x.Label)).OrderByDescending(o => o.Winrate).ToList();
var matchups = from r in replays
from p in r.Dsplayers
where p.PlayerName == player && Enum.GetValues <DSData.Commander>().Select(s => (byte)s).Contains(p.Race) && Enum.GetValues <DSData.Commander>().Select(s => (byte)s).Contains(p.Opprace)
group p by new { cmdr = p.Race, opp = p.Opprace } into g
select new DsResponseItem
{
Label = $"{((DSData.Commander)g.Key.cmdr).ToString()} vs {((DSData.Commander)g.Key.opp).ToString()}",
Count = g.Count(),
Wins = g.Count(s => s.Win)
};
var lmatchups = await matchups.ToListAsync();
return(new DsPlayerStats()
{
Winrate = new DsResponse()
{
Count = items.Sum(s => s.Count),
Items = items
},
Matchups = new DsResponse()
{
Count = lmatchups.Sum(s => s.Count),
Items = lmatchups
}
});
}
public static async Task <DsPlayerStats> GetPlayerStats(sc2dsstatsContext context, List <string> playerNames)
{
// Console.WriteLine($"Most played Commander is {mostplayed.cmdr} ({(mostplayed.count * 100 / (double)count).ToString("N2")})");
// Console.WriteLine($"Least played Commander is {leastplayed.cmdr} ({(leastplayed.count * 100 / (double)count).ToString("N2")})");
var replays = ReplayFilter.DefaultFilter(context);
var stats = from r in replays
from p in r.Dsplayers
where playerNames.Contains(p.Name)
group p by p.Race into g
select new DsResponseItem
{
Label = ((DSData.Commander)g.Key).ToString(),
Count = g.Count(),
Wins = g.Count(s => s.Win)
};
var items = await stats.ToListAsync();
items = items.Where(x => DSData.cmdrs.Contains(x.Label)).OrderByDescending(o => o.Winrate).ToList();
// Console.WriteLine($"Best cmdr is {bestcmdr.cmdr} ({(bestcmdr.wins * 100 / (double)bestcmdr.count).ToString("N2")})");
// Console.WriteLine($"Worst cmdr is {worstcmdr.cmdr} ({(worstcmdr.wins * 100 / (double)worstcmdr.count).ToString("N2")})");
var matchups = from r in replays
from p in r.Dsplayers
where playerNames.Contains(p.Name) && Enum.GetValues <DSData.Commander>().Select(s => (byte)s).Contains(p.Race) && Enum.GetValues <DSData.Commander>().Select(s => (byte)s).Contains(p.Opprace)
group p by new { cmdr = p.Race, opp = p.Opprace } into g
select new DsResponseItem
{
Label = $"{((DSData.Commander)g.Key.cmdr).ToString()} vs {((DSData.Commander)g.Key.opp).ToString()}",
Count = g.Count(),
Wins = g.Count(s => s.Win)
};
var lmatchups = await matchups.ToListAsync();
// Console.WriteLine($"Best matchup is {bestmatchup.matchup.cmdr} vs {bestmatchup.matchup.opp} ({(bestmatchup.wins * 100 / (double)bestmatchup.count).ToString("N2")})");
// Console.WriteLine($"Worst matchup is {worstmatchup.matchup.cmdr} vs {worstmatchup.matchup.opp} ({(worstmatchup.wins * 100 / (double)worstmatchup.count).ToString("N2")})");
return(new DsPlayerStats()
{
Winrate = new DsResponse()
{
Count = items.Sum(s => s.Count),
Items = items
},
Matchups = new DsResponse()
{
Count = lmatchups.Sum(s => s.Count),
Items = lmatchups
}
});
// var poss = from r in replays
// from p in r.Dsplayers
// where playerNames.Contains(p.Name) && p.Opprace != null
// group p by p.Pos into g
// select new
// {
// pos = g.Key,
// count = g.Count(),
// wins = g.Count(s => s.Win)
// };
// var lposs = await poss.ToListAsync();
// if (lposs.Any())
// {
// foreach (var pos in lposs.OrderBy(o => o.pos))
// {
// Console.WriteLine($"Pos: {pos.pos} => {(pos.wins * 100 / (double)pos.count).ToString("N2")}");
// }
// }
}
