IW4M-Admin/Application/QueryHelpers/ClientResourceQueryHelper.cs
2023-04-05 09:54:57 -05:00

291 lines
10 KiB
C#

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using Data.Abstractions;
using Data.Models;
using Microsoft.EntityFrameworkCore;
using SharedLibraryCore;
using SharedLibraryCore.Dtos;
using SharedLibraryCore.Helpers;
using SharedLibraryCore.Interfaces;
using WebfrontCore.QueryHelpers.Models;
using EFClient = Data.Models.Client.EFClient;
namespace IW4MAdmin.Application.QueryHelpers;
public class ClientResourceQueryHelper : IResourceQueryHelper<ClientResourceRequest, ClientResourceResponse>
{
private readonly IDatabaseContextFactory _contextFactory;
private readonly IGeoLocationService _geoLocationService;
private class ClientAlias
{
public EFClient Client { get; set; }
public EFAlias Alias { get; set; }
}
public ClientResourceQueryHelper(IDatabaseContextFactory contextFactory, IGeoLocationService geoLocationService)
{
_contextFactory = contextFactory;
_geoLocationService = geoLocationService;
}
public async Task<ResourceQueryHelperResult<ClientResourceResponse>> QueryResource(ClientResourceRequest query)
{
await using var context = _contextFactory.CreateContext(false);
var iqAliases = context.Aliases.AsQueryable();
var iqClients = context.Clients.AsQueryable();
var iqClientAliases = iqClients.Join(iqAliases, client => client.AliasLinkId, alias => alias.LinkId,
(client, alias) => new ClientAlias { Client = client, Alias = alias });
return await StartFromClient(query, iqClientAliases, iqClients);
}
private async Task<ResourceQueryHelperResult<ClientResourceResponse>> StartFromClient(ClientResourceRequest query,
IQueryable<ClientAlias> clientAliases, IQueryable<EFClient> iqClients)
{
if (!string.IsNullOrWhiteSpace(query.ClientGuid))
{
clientAliases = SearchByGuid(query, clientAliases);
}
if (query.ClientLevel is not null)
{
clientAliases = SearchByLevel(query, clientAliases);
}
if (query.ClientConnected is not null)
{
clientAliases = SearchByLastConnection(query, clientAliases);
}
if (query.GameName is not null)
{
clientAliases = SearchByGame(query, clientAliases);
}
if (!string.IsNullOrWhiteSpace(query.ClientName))
{
clientAliases = SearchByName(query, clientAliases);
}
if (!string.IsNullOrWhiteSpace(query.ClientIp))
{
clientAliases = SearchByIp(query, clientAliases);
}
var iqGroupedClientAliases = clientAliases.GroupBy(a => new { a.Client.ClientId, a.Client.LastConnection });
iqGroupedClientAliases = query.Direction == SortDirection.Descending
? iqGroupedClientAliases.OrderByDescending(clientAlias => clientAlias.Key.LastConnection)
: iqGroupedClientAliases.OrderBy(clientAlias => clientAlias.Key.LastConnection);
var clientIds = iqGroupedClientAliases.Select(g => g.Key.ClientId)
.Skip(query.Offset)
.Take(query.Count);
// this pulls in more records than we need, but it's more efficient than ordering grouped entities
var clientLookups = await clientAliases
.Where(clientAlias => clientIds.Contains(clientAlias.Client.ClientId))
.Select(clientAlias => new ClientResourceResponse
{
ClientId = clientAlias.Client.ClientId,
AliasId = clientAlias.Alias.AliasId,
LinkId = clientAlias.Client.AliasLinkId,
CurrentClientName = clientAlias.Client.CurrentAlias.Name,
MatchedClientName = clientAlias.Alias.Name,
CurrentClientIp = clientAlias.Client.CurrentAlias.IPAddress,
MatchedClientIp = clientAlias.Alias.IPAddress,
ClientLevel = clientAlias.Client.Level.ToLocalizedLevelName(),
ClientLevelValue = clientAlias.Client.Level,
LastConnection = clientAlias.Client.LastConnection,
Game = clientAlias.Client.GameName
})
.ToListAsync();
var groupClients = clientLookups.GroupBy(x => x.ClientId);
var orderedClients = query.Direction == SortDirection.Descending
? groupClients.OrderByDescending(SearchByAliasLocal(query.ClientName, query.ClientIp))
: groupClients.OrderBy(SearchByAliasLocal(query.ClientName, query.ClientIp));
var clients = orderedClients.Select(client => client.First()).ToList();
await ProcessAliases(query, clients);
return new ResourceQueryHelperResult<ClientResourceResponse>
{
Results = clients
};
}
private async Task ProcessAliases(ClientResourceRequest query, IEnumerable<ClientResourceResponse> clients)
{
await Parallel.ForEachAsync(clients, new ParallelOptions { MaxDegreeOfParallelism = 15 },
async (client, token) =>
{
if (!query.IncludeGeolocationData || client.CurrentClientIp is null)
{
return;
}
var geolocationData = await _geoLocationService.Locate(client.CurrentClientIp.ConvertIPtoString());
client.ClientCountryCode = geolocationData.CountryCode;
if (!string.IsNullOrWhiteSpace(client.ClientCountryCode))
{
client.ClientCountryDisplayName = geolocationData.Country;
}
});
}
private static Func<IGrouping<int, ClientResourceResponse>, DateTime> SearchByAliasLocal(string clientName,
string ipAddress)
{
return group =>
{
ClientResourceResponse match = null;
var lowercaseClientName = clientName?.ToLower();
if (!string.IsNullOrWhiteSpace(lowercaseClientName))
{
match = group.ToList().FirstOrDefault(SearchByNameLocal(lowercaseClientName));
}
if (match is null && !string.IsNullOrWhiteSpace(ipAddress))
{
match = group.ToList().FirstOrDefault(SearchByIpLocal(ipAddress));
}
return (match ?? group.First()).LastConnection;
};
}
private static Func<ClientResourceResponse, bool> SearchByNameLocal(string clientName)
{
return clientResourceResponse =>
clientResourceResponse.MatchedClientName.Contains(clientName);
}
private static Func<ClientResourceResponse, bool> SearchByIpLocal(string clientIp)
{
return clientResourceResponse => clientResourceResponse.MatchedClientIp.ConvertIPtoString().Contains(clientIp);
}
private static IQueryable<ClientAlias> SearchByName(ClientResourceRequest query,
IQueryable<ClientAlias> clientAliases)
{
var lowerCaseQueryName = query.ClientName.ToLower();
clientAliases = clientAliases.Where(query.IsExactClientName
? ExactNameMatch(lowerCaseQueryName)
: LikeNameMatch(lowerCaseQueryName));
return clientAliases;
}
private static Expression<Func<ClientAlias, bool>> LikeNameMatch(string lowerCaseQueryName)
{
return clientAlias => EF.Functions.Like(
clientAlias.Alias.SearchableName,
$"%{lowerCaseQueryName}%") || EF.Functions.Like(
clientAlias.Alias.Name.ToLower(),
$"%{lowerCaseQueryName}%");
}
private static Expression<Func<ClientAlias, bool>> ExactNameMatch(string lowerCaseQueryName)
{
return clientAlias =>
lowerCaseQueryName == clientAlias.Alias.Name || lowerCaseQueryName == clientAlias.Alias.SearchableName;
}
private static IQueryable<ClientAlias> SearchByIp(ClientResourceRequest query,
IQueryable<ClientAlias> clientAliases)
{
var ipString = query.ClientIp.Trim();
var ipAddress = ipString.ConvertToIP();
if (ipAddress != null && ipString.Split('.').Length == 4 && query.IsExactClientIp)
{
clientAliases = clientAliases.Where(clientAlias =>
clientAlias.Alias.IPAddress != null && clientAlias.Alias.IPAddress == ipAddress);
}
else
{
clientAliases = clientAliases.Where(clientAlias =>
EF.Functions.Like(clientAlias.Alias.SearchableIPAddress, $"{ipString}%"));
}
return clientAliases;
}
private static IQueryable<ClientAlias> SearchByGuid(ClientResourceRequest query,
IQueryable<ClientAlias> clients)
{
var guidString = query.ClientGuid.Trim();
var parsedGuids = new List<long>();
long guid = 0;
try
{
guid = guidString.ConvertGuidToLong(NumberStyles.HexNumber, false, 0);
}
catch
{
// ignored
}
if (guid != 0)
{
parsedGuids.Add(guid);
}
try
{
guid = guidString.ConvertGuidToLong(NumberStyles.Integer, false, 0);
}
catch
{
// ignored
}
if (guid != 0)
{
parsedGuids.Add(guid);
}
if (!parsedGuids.Any())
{
return clients;
}
clients = clients.Where(client => parsedGuids.Contains(client.Client.NetworkId));
return clients;
}
private static IQueryable<ClientAlias> SearchByLevel(ClientResourceRequest query, IQueryable<ClientAlias> clients)
{
clients = clients.Where(clientAlias => clientAlias.Client.Level == query.ClientLevel);
return clients;
}
private static IQueryable<ClientAlias> SearchByLastConnection(ClientResourceRequest query,
IQueryable<ClientAlias> clients)
{
clients = clients.Where(clientAlias => clientAlias.Client.LastConnection >= query.ClientConnected);
return clients;
}
private static IQueryable<ClientAlias> SearchByGame(ClientResourceRequest query, IQueryable<ClientAlias> clients)
{
clients = clients.Where(clientAlias => clientAlias.Client.GameName == query.GameName);
return clients;
}
}