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 async Task <ActionResult <TimelineResponse> > GetTimeline(TimelineRequest request)
{
Stopwatch sw = new Stopwatch();
sw.Start();
TimelineResponse response;
if (request.Filter == null || request.Filter.isDefault)
{
string hash = request.GenHash();
if (!memoryCache.TryGetValue(hash, out response))
{
response = StatsService.GetTimeline(request, await GetCmdrStats(request.Player));
memoryCache.Set(hash, response, CacheService.RankingCacheOptions);
}
else
{
logger.LogInformation("timeline from cache");
}
}
else
{
response = await StatsService.GetCustomTimeline(context, request);
}
await SetLeaverQuit(request, response);
sw.Stop();
logger.LogInformation($"Get Timeline in {sw.ElapsedMilliseconds} ms");
return(response);
}
public async Task GetWithUserTest()
{
// Arrange
var userId = "userId";
var request = new TimelineRequest
{
UserId = userId,
SavedOnly = false
};
var user = new UserModel();
this.userService.GetAsync(userId).Returns(user);
this.statusService.GetUserTimelineAsync(Arg.Any <StatusListParamsModel>())
.Returns(Enumerable.Empty <StatusModel>());
// Act
var resultRaw = await this.timelineController.Get(request);
var result = resultRaw as OkNegotiatedContentResult <TimelineResponse>;
// Assert
Assert.NotNull(result);
Assert.NotNull(result.Content);
Assert.NotNull(result.Content.User);
Assert.Equal(user, result.Content.User);
}
public async Task GetSavedOnlyTest()
{
// Arrange
var request = new TimelineRequest
{
UserId = "userId",
TrimUser = true,
SavedOnly = true
};
var statuses = Enumerable.Empty <StatusModel>();
this.statusService.GetAllSavedAsync(Arg.Any <StatusListParamsModel>())
.Returns(statuses);
// Act
var resultRaw = await this.timelineController.Get(request);
var result = resultRaw as OkNegotiatedContentResult <TimelineResponse>;
// Assert
Assert.NotNull(result);
Assert.NotNull(result.Content);
Assert.NotNull(result.Content.Statuses);
Assert.Equal(statuses, result.Content.Statuses);
}
public override async Task GetTimeline(TimelineRequest request, IServerStreamWriter <TimelineResponse> responseStream, ServerCallContext context)
{
var timestampRanges = new Dictionary <int, TimestampRange>();
// 요청받은 기간 내의 activity만 가져온다.
var activities = from activity in _db.GetActivities()
where activity.Time >= request.Range.Start.ToDateTime() && activity.Time <= request.Range.End.ToDateTime()
where activity.Action == ActionType.Active || activity.Action == ActionType.Idle ||
activity.Action == ActionType.Blur || activity.Action == ActionType.Focus
orderby activity.Time
select activity;
Application applicationNow = null;
await foreach (var activity in activities)
{
var application = await _db.GetAsync <Application>(activity.ApplicationId);
switch (activity.Action)
{
case ActionType.Focus:
applicationNow = application;
break;
case ActionType.Active:
if (applicationNow == null)
{
applicationNow = application;
}
if (!timestampRanges.ContainsKey(applicationNow.Id))
{
timestampRanges[applicationNow.Id] = new TimestampRange()
{
Start = Timestamp.FromDateTimeOffset(activity.Time)
};
}
break;
case ActionType.Blur:
case ActionType.Idle:
if (timestampRanges.ContainsKey(applicationNow.Id))
{
timestampRanges[applicationNow.Id].End = Timestamp.FromDateTimeOffset(activity.Time);
var response = new TimelineResponse()
{
Application = applicationNow.ToRpc(),
Range = timestampRanges[applicationNow.Id]
};
timestampRanges.Remove(applicationNow.Id);
await responseStream.WriteAsync(response);
}
break;
default:
continue;
}
}
}
public async Task GetTestInvalidRequestShouldThrowException()
{
// Arrange
var request = new TimelineRequest {
UserId = null
};
// Act
await Assert.ThrowsAsync <ArgumentException>(
() => this.timelineController.Get(request));
}
public async Task <ActionResult <TimelineResponse> > GetTimeline(TimelineRequest request)
{
Stopwatch sw = new Stopwatch();
sw.Start();
TimelineResponse response;
if (request.Filter == null || request.Filter.isDefault)
{
response = await TimelineService.GetTimelineFromTimeResults(context, request);
}
else
{
response = await TimelineService.GetTimeline(context, request);
}
sw.Stop();
logger.LogInformation($"Get Timeline in {sw.ElapsedMilliseconds} ms");
return(response);
}
public async Task <IHttpActionResult> Get([FromUri] TimelineRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if (string.IsNullOrEmpty(request.UserId))
{
throw new ArgumentException(
"TimelineRequest.UserId is required.");
}
var userTask = request.TrimUser
? Task.FromResult((UserModel)null)
: this.userService.GetAsync(request.UserId);
var statusListParams = new StatusListParamsModel
{
SavedByUserId = this.claimsHelper.GetUserId(),
CreatedByUserId = request.UserId,
MaxId = request.MaxId,
Count = request.Count
};
var statusesTask = request.SavedOnly
? this.statusService.GetAllSavedAsync(statusListParams)
: this.statusService.GetUserTimelineAsync(statusListParams);
await Task.WhenAll(userTask, statusesTask);
var response = new TimelineResponse
{
User = userTask.Result,
Statuses = statusesTask.Result
};
return(Ok(response));
}
public static TimelineResponse GetTimeline(TimelineRequest request, List <CmdrStats> cmdrstats)
{
if (request.Step < 3)
{
request.Step = 3;
}
if (request.smaK < 3)
{
request.smaK = 3;
}
var stats = GetTimeStats(request, cmdrstats);
int tcount = stats.Sum(s => s.count);
TimelineResponse response = new TimelineResponse()
{
Interest = request.Interest,
Count = request.Player ? tcount : tcount / 6,
Versus = request.Versus,
AvgDuration = tcount == 0 ? 0 : (int)(stats.Sum(s => s.duration) / tcount),
Items = new List <DsResponseItem>()
};
DateTime requestTime = request.StartTime;
while (requestTime < request.EndTime)
{
var timeResults = stats.Where(f => f.year == requestTime.Year && f.month == requestTime.Month && f.RACE == (byte)DSData.GetCommander(request.Interest));
if (!timeResults.Any())
{
response.Items.Add(new TimelineResponseItem()
{
Label = $"{requestTime.ToString("yyyy-MM")} (0)",
Count = 0,
Wins = 0
});
}
else
{
int ccount = timeResults.Sum(s => s.count);
response.Items.Add(new TimelineResponseItem()
{
Label = $"{requestTime.ToString("yyyy-MM")} ({ccount})",
Count = ccount,
Wins = timeResults.Sum(s => s.wins)
});
}
requestTime = requestTime.AddMonths(1);
}
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 <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 override Task GetTimeline(TimelineRequest request, IServerStreamWriter <TimelineResponse> responseStream, ServerCallContext context)
{
throw new NotImplementedException();
}
public static async Task <TimelineResponse> GetTimelineFromTimeResults(sc2dsstatsContext context, TimelineRequest request)
{
if (request.Step < 3)
{
request.Step = 3;
}
if (request.smaK < 3)
{
request.smaK = 3;
}
DateTime requestTime = request.StartTime;
List <string> timeRequestStrings = new List <string>();
while (requestTime < request.EndTime)
{
timeRequestStrings.Add(requestTime.ToString("yyyyMM"));
requestTime = requestTime.AddMonths(1);
}
List <DsTimeResult> timeResults = await context.DsTimeResults
.AsNoTracking()
.Where(f =>
f.Cmdr == request.Interest &&
f.Opp == String.Empty &&
timeRequestStrings.Contains(f.Timespan) &&
f.Player == request.Player
)
.ToListAsync();
int tcount = timeResults.Sum(s => s.Count);
TimelineResponse response = new TimelineResponse()
{
Interest = request.Interest,
Count = tcount / 6,
Versus = request.Versus,
AvgDuration = (int)(timeResults.Sum(s => s.Duration) / tcount),
Items = new List <DsResponseItem>()
};
requestTime = request.StartTime;
while (requestTime < request.EndTime)
{
var timeResult = timeResults.SingleOrDefault(f => f.Timespan == requestTime.ToString("yyyyMM"));
if (timeResult == null || timeResult.Count == 0)
{
response.Items.Add(new TimelineResponseItem()
{
Label = $"{requestTime.ToString("yyyy-MM")} (0)",
Count = 0,
Wins = 0
});
}
else
{
response.Items.Add(new TimelineResponseItem()
{
Label = $"{requestTime.ToString("yyyy-MM")} ({timeResult.Count})",
Count = timeResult.Count,
Wins = timeResult.Wins
});
}
requestTime = requestTime.AddMonths(1);
}
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);
}
