public async Task <IActionResult> GetMatchPlayedStatus(GetStatsModel statsModel)
{
var data = await _repoServiceFactory.MatchRepoService.FindAsync(statsModel.Start, statsModel.End);
var interval = new TimeSpan(0, 0, statsModel.LenghtInSec);
var dict = new Dictionary <DateTime, decimal>();
for (DateTime a = statsModel.Start; a < statsModel.End; a += interval)
{
var rake1 = data.Where(user => user.Created > a && user.Created < (a + interval)).ToList();
dict.Add(a, rake1.Count);
}
var res = new StatsResponse
{
End = statsModel.End,
Start = statsModel.Start,
Text = "Matches played",
Values = new List <Dictionary <string, object> >()
};
foreach (var point in dict)
{
var dict1 = new Dictionary <string, object>
{
{ "Value", point.Value },
{ "Time", point.Key },
};
res.Values.Add(dict1);
}
return(Ok(res));
}
public async Task <StatsResponse> GetStatsAsync(CancellationToken cancellationToken)
{
var output = new StatsResponse();
using (var dbConnection = Connection())
{
dbConnection.Open();
var results = await dbConnection.QueryAsync <Result>(_totalsSql);
//Total image
output.TopStats.AddRange(results);
}
using (var dbConnection = Connection())
{
dbConnection.Open();
var results = await dbConnection.QueryAsync <Result>(_keywordsSql);
//Total image
output.TopKeywords.AddRange(results);
}
output.AsOf = DateTime.Now;
return(output);
}
public async Task GetPlayerStatsAsync_ShouldRaiseArgumentException_WhenNoPlayerNameProvided()
{
//Arrange
var client = new PUBGStatsClient("dummy");
//Act
StatsResponse responseTask = await client.GetPlayerStatsAsync(null).ConfigureAwait(false);
}
public async Task <IActionResult> GetState()
{
GameStatsModel stats = await _seeBattleGameService.GetGameStats();
StatsResponse response = _contractMapper.Map(stats);
return(new JsonResult(response));
}
internal StatsEventArgs(StatsResponse response)
{
Players = response.Players;
PlayingPlayers = response.PlayingPlayers;
Uptime = new TimeSpan(response.Uptime);
Memory = response.Memory;
Frames = response.Frames;
Cpu = response.Cpu;
}
public OkObjectResult Get()
{
var stats = new StatsResponse
{
Total = _statsProvider.GetJobCount(),
Average = _statsProvider.GetAverageProcessTimeInMilliseconds()
};
return(Ok(stats));
}
public void TestGetStats()
{
Mock <IDatastore> mockDatastore = new Mock <IDatastore>();
mockDatastore.Setup(_statsExpectation).Returns(_jsonData);
WhmcsApi instance = new WhmcsApi("User", "Pass", "Website", mockDatastore.Object);
StatsResponse stats = instance.GetStats();
Assert.Equal("123", stats.OrdersYesterdayPending);
}
public async Task <IActionResult> Rake(GetStatsModel getStatsModel)
{
var res = new StatsResponse
{
End = getStatsModel.End,
Text = "All combined",
Start = getStatsModel.Start,
Values = new List <Dictionary <string, object> >()
};
var data = await _repoServiceFactory.RakeItemRepoService.GetAll();
var rake = data.Where(r => r.Received > getStatsModel.Start && r.Received < getStatsModel.End).ToList();
var interval = new TimeSpan(0, 0, getStatsModel.LenghtInSec);
var itemDescIds = rake.Select(i => i.DescriptionId).ToList();
var itemDescriptions = await _repoServiceFactory.ItemDescriptionRepoService.FindAsync(itemDescIds);
var list = new List <RakeAndItemDescripton>();
foreach (var itemDescription in itemDescriptions)
{
foreach (var item in rake)
{
if (item.DescriptionId != itemDescription.Id)
{
continue;
}
list.Add(new RakeAndItemDescripton {
RakeItem = item, ItemDescription = itemDescription
});
}
}
for (var a = getStatsModel.Start; a < getStatsModel.End; a += interval)
{
var rake1 = list.Where(r => r.RakeItem.Received > a && r.RakeItem.Received < (a + interval)).ToList();
var sum = rake1.Sum(r => r.ItemDescription.Value);
res.Values.Add(new Dictionary <string, object>
{
{ "Value", sum },
{ "Time", a },
});
}
return(Ok(res));
}
public void GetPlayerStatsAsync_ShouldRaiseArgumentException_WhenNoPlayerNameProvided()
{
//Arrange
var client = new PUBGStatsClient("dummy");
//Act
try
{
StatsResponse responseTask = client.GetPlayerStatsAsync(null).Result;
}
catch (Exception e)
{
//Assert
//In case of awaitable tasks, aggregate exception is thrown, which should contain expected ArgumentException.
Assert.IsInstanceOfType(e.InnerException, typeof(ArgumentException));
}
}
public async Task <IActionResult> GetCosts([FromRoute] string period, [FromQuery] long vehicleId)
{
StatsPeriod periodValue;
if (!Enum.TryParse(period, true, out periodValue))
{
return(NotFound());
}
var stats = new StatsResponse()
{
FuelCost = await _statsService.GetCost(periodValue, vehicleId, ExpenseType.Fuel),
FuelUsage = await _statsService.GetFuelUsage(periodValue, vehicleId),
InsuranceCost = await _statsService.GetCost(periodValue, vehicleId, ExpenseType.Insurance),
OtherCost = await _statsService.GetCost(periodValue, vehicleId, ExpenseType.Other),
ServiceCost = await _statsService.GetCost(periodValue, vehicleId, ExpenseType.Service),
SparePartCost = await _statsService.GetCost(periodValue, vehicleId, ExpenseType.SparePart),
Total = await _statsService.GetCost(periodValue, vehicleId)
};
return(Ok(stats));
}
public async void Should_Return_OkObjectResult_with_one_Stat()
{
//Arrange
var expectedResult = new Stats()
{
StatsId = 1, Time = 20
};
var finalResult = new StatsResponse()
{
StatsId = 1, Time = 30
};
StatsRepository
.Setup(x => x.Get(expectedResult.StatsId))
.ReturnsAsync(expectedResult).Verifiable();
UnitofWorkMock
.Setup(m => m.Stats)
.Returns(StatsRepository.Object);
MapperMock
.Setup(m => m.Map <StatsResponse>(expectedResult))
.Returns(finalResult);
//Act
var result = await _uut.Get(expectedResult.StatsId);
//Assert
StatsRepository.Verify();
MapperMock.VerifyAll();
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(finalResult, okResult.Value);
}
public async Task <IActionResult> Rake(GetStatsModel getRakeModel, string gameModeType)
{
var gameMode = await _repoServiceFactory.GameModeRepoService.Find(gameModeType);
if (gameMode == null)
{
return(BadRequest($"No game mode found for type {gameModeType}"));
}
var data = await _repoServiceFactory.RakeItemRepoService.FindFromGameModeIdAsync(new List <int>
{
gameMode.Id
});
var rake = data.Where(r => r.Received > getRakeModel.Start && r.Received < getRakeModel.End).ToList();
var interval = new TimeSpan(0, 0, getRakeModel.LenghtInSec);
var itemDescIds = rake.Select(i => i.DescriptionId).ToList();
var itemDescriptions = await _repoServiceFactory.ItemDescriptionRepoService.FindAsync(itemDescIds);
var list = new List <RakeAndItemDescripton>();
foreach (var itemDescription in itemDescriptions)
{
foreach (var item in rake)
{
if (item.DescriptionId != itemDescription.Id)
{
continue;
}
list.Add(new RakeAndItemDescripton {
RakeItem = item, ItemDescription = itemDescription
});
}
}
var dict = new Dictionary <DateTime, decimal>();
for (DateTime a = getRakeModel.Start; a < getRakeModel.End; a += interval)
{
var rake1 = list.Where(r => r.RakeItem.Received > a && r.RakeItem.Received < (a + interval)).ToList();
dict.Add(a, rake1.Sum(r => r.ItemDescription.Value));
}
var res = new StatsResponse
{
End = getRakeModel.End,
Text = gameMode.Type,
Start = getRakeModel.Start,
Values = new List <Dictionary <string, object> >()
};
foreach (var point in dict)
{
var dict1 = new Dictionary <string, object>
{
{ "Value", point.Value },
{ "Time", point.Key },
};
res.Values.Add(dict1);
}
return(Ok(res));
}
private void ProcessStats(ref Utf8JsonReader reader, out StatsResponse statsResponse)
{
// {"playingPlayers":0,"op":"stats",
// "memory":{"reservable":1234567890,"used":1234567890,"free":1234567890,"allocated":1234567890},
// "players":0,"cpu":{"cores":4,"systemLoad":0,"lavalinkLoad":0.27354256456787324},"uptime":33731}
statsResponse = new StatsResponse();
if (reader.ValueTextEquals("playingPlayers") && reader.Read())
{
statsResponse.Players = reader.GetInt32();
}
while (reader.Read())
{
if (reader.TokenType == JsonTokenType.EndObject)
{
break;
}
if (reader.TokenType != JsonTokenType.PropertyName)
{
continue;
}
// MEMORY OBJECT
if (reader.ValueTextEquals("memory") && reader.Read())
{
var memory = new Memory();
while (reader.Read())
{
if (reader.TokenType == JsonTokenType.EndObject)
{
break;
}
if (reader.ValueTextEquals("free") && reader.Read())
{
memory.Free = reader.GetInt32();
}
else if (reader.ValueTextEquals("used") && reader.Read())
{
memory.Used = reader.GetInt32();
}
else if (reader.ValueTextEquals("allocated") && reader.Read())
{
memory.Allocated = reader.GetInt32();
}
else if (reader.ValueTextEquals("reservable") && reader.Read())
{
memory.Reservable = reader.GetInt32();
}
}
statsResponse.Memory = memory;
}
else if (reader.ValueTextEquals("players") && reader.Read())
{
statsResponse.Players = reader.GetInt32();
}
// CPU RESPOSNE
else if (reader.ValueTextEquals("cpu") && reader.Read())
{
var cpu = new Cpu();
while (reader.Read())
{
if (reader.TokenType == JsonTokenType.EndObject)
{
break;
}
if (reader.ValueTextEquals("cores") && reader.Read())
{
cpu.Cores = reader.GetInt32();
}
else if (reader.ValueTextEquals("systemLoad") && reader.Read())
{
cpu.SystemLoad = reader.GetDouble();
}
else if (reader.ValueTextEquals("lavalinkLoad") && reader.Read())
{
cpu.LavalinkLoad = reader.GetDouble();
}
}
statsResponse.Cpu = cpu;
}
else if (reader.ValueTextEquals("uptime") && reader.Read())
{
statsResponse.Uptime = reader.GetInt64();
}
// FRAMES (MIGHT THROW EXCEPTION)
else if (reader.ValueTextEquals("frames"))
{
var frames = new Frames();
while (reader.Read())
{
if (reader.TokenType == JsonTokenType.EndObject)
{
break;
}
if (reader.ValueTextEquals("sent") && reader.Read())
{
frames.Sent = reader.GetInt32();
}
else if (reader.ValueTextEquals("nulled") && reader.Read())
{
frames.Nulled = reader.GetInt32();
}
else if (reader.ValueTextEquals("deficit") && reader.Read())
{
frames.Deficit = reader.GetInt32();
}
}
statsResponse.Frames = frames;
}
}
}
public EventStats(StatsResponse stats)
{
Stats = stats;
}
