/// <inheritdoc/>
public async Task <ResourceQueryHelperResult <StatsInfoResult> > QueryResource(StatsInfoRequest query)
{
var result = new ResourceQueryHelperResult <StatsInfoResult>();
using var context = _contextFactory.CreateContext(enableTracking: false);
// we need to get the ratings separately because there's not explicit FK
var ratings = await context.Set <EFClientRatingHistory>()
.Where(_ratingHistory => _ratingHistory.ClientId == query.ClientId)
.SelectMany(_ratingHistory => _ratingHistory.Ratings.Where(_rating => _rating.ServerId != null && _rating.Newest)
.Select(_rating => new
{
_rating.ServerId,
_rating.Ranking,
_rating.When
}))
.ToListAsync();
var iqStats = context.Set <EFClientStatistics>()
.Where(_stats => _stats.ClientId == query.ClientId)
.Select(_stats => new StatsInfoResult
{
Name = _stats.Client.CurrentAlias.Name,
ServerId = _stats.ServerId,
Kills = _stats.Kills,
Deaths = _stats.Deaths,
Performance = Math.Round((_stats.EloRating + _stats.Skill) / 2.0, 2),
ScorePerMinute = _stats.SPM,
LastPlayed = _stats.Client.LastConnection,
TotalSecondsPlayed = _stats.TimePlayed,
ServerGame = _stats.Server.GameName.ToString(),
ServerName = _stats.Server.HostName,
});
var queryResults = await iqStats.ToListAsync();
// add the rating query's results to the full query
foreach (var eachResult in queryResults)
{
var rating = ratings.FirstOrDefault(_rating => _rating.ServerId == eachResult.ServerId);
eachResult.Ranking = rating?.Ranking ?? 0;
eachResult.LastPlayed = rating?.When ?? eachResult.LastPlayed;
}
result.Results = queryResults;
result.RetrievedResultCount = queryResults.Count;
result.TotalResultCount = result.RetrievedResultCount;
return(result);
}
public async Task Test_StatsController_ClientStats_NotFound()
{
var queryResult = new ResourceQueryHelperResult <StatsInfoResult>()
{
Results = new List <StatsInfoResult>()
};
A.CallTo(() => fakeStatsQueryHelper.QueryResource(A <StatsInfoRequest> .Ignored))
.Returns(Task.FromResult(queryResult));
var result = await statsController.ClientStats(1);
Assert.IsInstanceOf <NotFoundResult>(result);
}
/// <summary>
/// find clients matching the given query
/// </summary>
/// <param name="query">query filters</param>
/// <returns></returns>
public async Task <ResourceQueryHelperResult <FindClientResult> > QueryResource(FindClientRequest query)
{
var result = new ResourceQueryHelperResult <FindClientResult>();
await using var context = _contextFactory.CreateContext(enableTracking: false);
IQueryable <Data.Models.Client.EFClient> iqClients = null;
if (!string.IsNullOrEmpty(query.Xuid))
{
var networkId = query.Xuid.ConvertGuidToLong(System.Globalization.NumberStyles.HexNumber);
iqClients = context.Clients.Where(_client => _client.NetworkId == networkId);
}
else if (!string.IsNullOrEmpty(query.Name))
{
iqClients = context.Clients
.Where(_client =>
EF.Functions.Like(_client.CurrentAlias.Name.ToLower(), $"%{query.Name.ToLower()}%"));
}
if (query.Direction == SortDirection.Ascending)
{
iqClients = iqClients.OrderBy(_client => _client.LastConnection);
}
else
{
iqClients = iqClients.OrderByDescending(_client => _client.LastConnection);
}
var queryResults = await iqClients
.Select(_client => new FindClientResult
{
ClientId = _client.ClientId,
Xuid = _client.NetworkId.ToString("X"),
Name = _client.CurrentAlias.Name
})
.Skip(query.Offset)
.Take(query.Count)
.ToListAsync();
result.TotalResultCount = await iqClients.CountAsync();
result.Results = queryResults;
result.RetrievedResultCount = queryResults.Count;
return(result);
}
public async Task Test_StatsController_ClientStats_Happy()
{
var client = ClientGenerators.CreateBasicClient(null);
var query = new StatsInfoRequest
{
ClientId = client.ClientId
};
var queryResult = new ResourceQueryHelperResult <StatsInfoResult>()
{
Results = new[]
{
new StatsInfoResult
{
Deaths = 1,
Kills = 1,
LastPlayed = DateTime.Now,
Performance = 100,
Ranking = 10,
ScorePerMinute = 500,
ServerGame = "IW4",
ServerId = 123,
ServerName = "IW4Host",
TotalSecondsPlayed = 100
}
},
TotalResultCount = 1,
RetrievedResultCount = 1
};
A.CallTo(() => fakeStatsQueryHelper.QueryResource(A <StatsInfoRequest> .Ignored))
.Returns(Task.FromResult(queryResult));
var result = await statsController.ClientStats(query.ClientId.Value);
Assert.IsInstanceOf <OkObjectResult>(result);
var viewResult = (result as OkObjectResult).Value as IEnumerable <StatsInfoResult>;
Assert.NotNull(viewResult);
Assert.AreEqual(queryResult.Results, viewResult);
}
/// <inheritdoc/>
public async Task <ResourceQueryHelperResult <MessageResponse> > QueryResource(ChatSearchQuery query)
{
if (query == null)
{
throw new ArgumentException("Query must be specified");
}
var result = new ResourceQueryHelperResult <MessageResponse>();
await using var context = _contextFactory.CreateContext(enableTracking: false);
if (serverCache == null)
{
serverCache = await context.Set <EFServer>().ToListAsync();
}
if (int.TryParse(query.ServerId, out int serverId))
{
query.ServerId = serverCache.FirstOrDefault(_server => _server.ServerId == serverId)?.EndPoint ?? query.ServerId;
}
var iqMessages = context.Set <EFClientMessage>()
.Where(_message => _message.TimeSent >= query.SentAfter)
.Where(_message => _message.TimeSent < query.SentBefore);
if (query.ClientId != null)
{
iqMessages = iqMessages.Where(_message => _message.ClientId == query.ClientId.Value);
}
if (query.ServerId != null)
{
iqMessages = iqMessages.Where(_message => _message.Server.EndPoint == query.ServerId);
}
if (!string.IsNullOrEmpty(query.MessageContains))
{
iqMessages = iqMessages.Where(_message => EF.Functions.Like(_message.Message.ToLower(), $"%{query.MessageContains.ToLower()}%"));
}
var iqResponse = iqMessages
.Select(_message => new MessageResponse
{
ClientId = _message.ClientId,
ClientName = query.IsProfileMeta ? "" : _message.Client.CurrentAlias.Name,
ServerId = _message.ServerId,
When = _message.TimeSent,
Message = _message.Message,
ServerName = query.IsProfileMeta ? "" : _message.Server.HostName,
GameName = _message.Server.GameName == null ? Server.Game.IW4 : (Server.Game)_message.Server.GameName.Value,
SentIngame = _message.SentIngame
});
if (query.Direction == SharedLibraryCore.Dtos.SortDirection.Descending)
{
iqResponse = iqResponse.OrderByDescending(_message => _message.When);
}
else
{
iqResponse = iqResponse.OrderBy(_message => _message.When);
}
var resultList = await iqResponse
.Skip(query.Offset)
.Take(query.Count)
.ToListAsync();
foreach (var message in resultList)
{
message.IsHidden = serverCache.Any(server => server.ServerId == message.ServerId && server.IsPasswordProtected);
if (!message.Message.IsQuickMessage())
{
continue;
}
try
{
var quickMessages = _defaultSettings
.QuickMessages
.First(_qm => _qm.Game == message.GameName);
message.Message = quickMessages.Messages[message.Message.Substring(1)];
message.IsQuickMessage = true;
}
catch
{
message.Message = message.Message.Substring(1);
}
}
result.TotalResultCount = await iqResponse.CountAsync();
result.Results = resultList;
result.RetrievedResultCount = resultList.Count;
return(result);
}
