IW4M-Admin/SharedLibraryCore/Services/ClientService.cs

955 lines
39 KiB
C#
Raw Normal View History

2022-01-26 11:32:16 -05:00
using System;
using System.Collections.Generic;
2022-01-26 11:32:16 -05:00
using System.Globalization;
using System.Linq;
2022-02-23 10:32:59 -05:00
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Data.Abstractions;
using Data.Context;
2022-01-26 11:32:16 -05:00
using Data.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Serilog.Context;
2022-01-26 11:32:16 -05:00
using SharedLibraryCore.Configuration;
using SharedLibraryCore.Database.Models;
using SharedLibraryCore.Dtos;
using SharedLibraryCore.Helpers;
using SharedLibraryCore.Interfaces;
using static Data.Models.Client.EFClient;
using ILogger = Microsoft.Extensions.Logging.ILogger;
2018-04-08 02:44:42 -04:00
namespace SharedLibraryCore.Services
{
public class ClientService : IEntityService<EFClient>, IResourceQueryHelper<FindClientRequest, FindClientResult>
{
private static readonly Func<DatabaseContext, long, Reference.Game, Task<EFClient>> GetUniqueQuery =
EF.CompileAsyncQuery((DatabaseContext context, long networkId, Reference.Game game) =>
2022-01-26 11:32:16 -05:00
context.Clients
.Select(client => new EFClient
2022-01-26 11:32:16 -05:00
{
ClientId = client.ClientId,
AliasLinkId = client.AliasLinkId,
Level = client.Level,
Connections = client.Connections,
FirstConnection = client.FirstConnection,
LastConnection = client.LastConnection,
Masked = client.Masked,
NetworkId = client.NetworkId,
TotalConnectionTime = client.TotalConnectionTime,
AliasLink = client.AliasLink,
Password = client.Password,
2022-06-15 21:19:22 -04:00
PasswordSalt = client.PasswordSalt,
GameName = client.GameName
2022-01-26 11:32:16 -05:00
})
.FirstOrDefault(client => client.NetworkId == networkId && client.GameName == game)
2022-01-26 11:32:16 -05:00
);
private readonly ApplicationConfiguration _appConfig;
private readonly IDatabaseContextFactory _contextFactory;
private readonly ILogger _logger;
private readonly IGeoLocationService _geoLocationService;
2022-01-26 11:32:16 -05:00
public ClientService(ILogger<ClientService> logger, IDatabaseContextFactory databaseContextFactory,
ApplicationConfiguration appConfig, IGeoLocationService geoLocationService)
{
_contextFactory = databaseContextFactory;
_logger = logger;
_appConfig = appConfig;
_geoLocationService = geoLocationService;
}
public async Task<EFClient> Create(EFClient entity)
{
2021-09-17 12:19:17 -04:00
entity.Name = entity.Name.CapClientName(EFAlias.MAX_NAME_LENGTH);
2022-01-26 11:32:16 -05:00
if (!_appConfig.EnableImplicitAccountLinking)
{
return await HandleNewCreate(entity);
}
2022-01-26 11:32:16 -05:00
await using var context = _contextFactory.CreateContext();
using (LogContext.PushProperty("Server", entity?.CurrentServer?.ToString()))
{
int? linkId = null;
int? aliasId = null;
if (entity.IPAddress != null)
{
var existingAliases = await context.Aliases
.Select(_alias => new { _alias.AliasId, _alias.LinkId, _alias.IPAddress, _alias.Name })
.Where(_alias => _alias.IPAddress == entity.IPAddress)
.ToListAsync();
if (existingAliases.Count > 0)
{
linkId = existingAliases.OrderBy(_alias => _alias.LinkId).First().LinkId;
2022-01-26 11:32:16 -05:00
_logger.LogDebug("[create] client with new GUID {entity} has existing link {linkId}",
entity.ToString(), linkId);
var existingExactAlias = existingAliases.FirstOrDefault(_alias => _alias.Name == entity.Name);
if (existingExactAlias != null)
{
2022-01-26 11:32:16 -05:00
_logger.LogDebug("[create] client with new GUID {entity} has existing alias {aliasId}",
entity.ToString(), existingExactAlias.AliasId);
aliasId = existingExactAlias.AliasId;
}
}
}
2022-01-26 11:32:16 -05:00
var client = new EFClient
{
Level = Permission.User,
FirstConnection = DateTime.UtcNow,
LastConnection = DateTime.UtcNow,
2022-04-22 17:03:34 -04:00
NetworkId = entity.NetworkId,
GameName = (Reference.Game)entity.CurrentServer.GameName
};
_logger.LogDebug("[create] adding {entity} to context", entity.ToString());
2022-01-26 11:32:16 -05:00
// they're just using a new GUID
if (aliasId.HasValue)
{
2022-01-26 11:32:16 -05:00
_logger.LogDebug("[create] setting {entity}'s alias id and linkid to ({aliasId}, {linkId})",
entity.ToString(), aliasId, linkId);
client.CurrentAliasId = aliasId.Value;
client.AliasLinkId = linkId.Value;
}
// link was found but they don't have an exact alias
else if (!aliasId.HasValue && linkId.HasValue)
{
2022-01-26 11:32:16 -05:00
_logger.LogDebug("[create] setting {entity}'s linkid to {linkId}, but creating new alias",
entity.ToString(), linkId);
client.AliasLinkId = linkId.Value;
2022-01-26 11:32:16 -05:00
client.CurrentAlias = new EFAlias
{
Name = entity.Name,
2019-08-02 19:04:34 -04:00
SearchableName = entity.Name.StripColors().ToLower(),
DateAdded = DateTime.UtcNow,
IPAddress = entity.IPAddress,
LinkId = linkId.Value
};
}
// brand new players (supposedly)
else
{
_logger.LogDebug("[create] creating new Link and Alias for {entity}", entity.ToString());
var link = new EFAliasLink();
2022-01-26 11:32:16 -05:00
var alias = new EFAlias
{
Name = entity.Name,
2019-08-02 19:04:34 -04:00
SearchableName = entity.Name.StripColors().ToLower(),
DateAdded = DateTime.UtcNow,
IPAddress = entity.IPAddress,
Link = link
};
client.AliasLink = link;
client.CurrentAlias = alias;
}
context.Clients.Add(client);
await context.SaveChangesAsync();
return client;
}
}
2022-01-26 11:32:16 -05:00
public Task<EFClient> Delete(EFClient entity)
{
throw new NotImplementedException();
}
public Task<IList<EFClient>> Find(Func<EFClient, bool> e)
{
throw new NotImplementedException();
}
public async Task<EFClient> Get(int entityId)
{
await using var context = _contextFactory.CreateContext(false);
2022-02-01 19:20:29 -05:00
var client = await context.Clients
2022-01-26 11:32:16 -05:00
.Select(_client => new EFClient
{
ClientId = _client.ClientId,
GameName = _client.GameName,
2022-01-26 11:32:16 -05:00
AliasLinkId = _client.AliasLinkId,
Level = _client.Level,
Connections = _client.Connections,
FirstConnection = _client.FirstConnection,
LastConnection = _client.LastConnection,
Masked = _client.Masked,
NetworkId = _client.NetworkId,
CurrentAlias = new EFAlias
{
Name = _client.CurrentAlias.Name,
IPAddress = _client.CurrentAlias.IPAddress
},
2022-02-01 19:20:29 -05:00
TotalConnectionTime = _client.TotalConnectionTime,
AliasLink = new EFAliasLink
{
AliasLinkId = _client.AliasLinkId,
Children = _client.AliasLink.Children
},
LinkedAccounts = new Dictionary<int, long>()
{
{_client.ClientId, _client.NetworkId}
}
2022-01-26 11:32:16 -05:00
})
2022-02-01 19:20:29 -05:00
.FirstOrDefaultAsync(_client => _client.ClientId == entityId);
2022-01-26 11:32:16 -05:00
if (client == null)
{
return null;
}
2022-02-01 19:20:29 -05:00
if (!_appConfig.EnableImplicitAccountLinking)
2022-01-26 11:32:16 -05:00
{
2022-02-01 19:20:29 -05:00
return client;
}
2022-01-26 11:32:16 -05:00
var foundClient = new
{
Client = client,
LinkedAccounts = await context.Clients.Where(_client => _client.AliasLinkId == client.AliasLinkId)
.Select(_linkedClient => new
{
_linkedClient.ClientId,
_linkedClient.NetworkId
})
.ToListAsync()
};
foundClient.Client.LinkedAccounts = new Dictionary<int, long>();
// todo: find out the best way to do this
// I'm doing this here because I don't know the best way to have multiple awaits in the query
foreach (var linked in foundClient.LinkedAccounts)
foundClient.Client.LinkedAccounts.Add(linked.ClientId, linked.NetworkId);
return foundClient.Client;
}
public virtual async Task<EFClient> GetUnique(long entityAttribute, object altKey = null)
2022-01-26 11:32:16 -05:00
{
await using var context = _contextFactory.CreateContext(false);
2022-06-15 21:19:22 -04:00
return await GetUniqueQuery(context, entityAttribute, (Reference.Game)altKey);
2022-01-26 11:32:16 -05:00
}
public async Task<EFClient> Update(EFClient temporalClient)
{
if (temporalClient.ClientId < 1)
{
_logger.LogDebug(
"[update] {client} needs to be updated but they do not have a valid client id, ignoring..",
temporalClient.ToString());
// note: we never do anything with the result of this so we can safely return null
return null;
}
await using var context = _contextFactory.CreateContext();
// grab the context version of the entity
var entity = context.Clients
.First(client => client.ClientId == temporalClient.ClientId);
if (temporalClient.LastConnection > entity.LastConnection)
{
entity.LastConnection = temporalClient.LastConnection;
}
if (temporalClient.Connections > entity.Connections)
{
entity.Connections = temporalClient.Connections;
}
entity.Masked = temporalClient.Masked;
if (temporalClient.TotalConnectionTime > entity.TotalConnectionTime)
{
entity.TotalConnectionTime = temporalClient.TotalConnectionTime;
}
if (temporalClient.Password != null)
{
entity.Password = temporalClient.Password;
}
if (temporalClient.PasswordSalt != null)
{
entity.PasswordSalt = temporalClient.PasswordSalt;
}
if (entity.GameName == Reference.Game.UKN && temporalClient.GameName != entity.GameName)
2022-08-20 11:42:34 -04:00
{
entity.GameName = temporalClient.GameName;
}
2022-04-22 17:03:34 -04:00
2022-01-26 11:32:16 -05:00
// update in database
await context.SaveChangesAsync();
return entity.ToPartialClient();
}
/// <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(false);
IQueryable<Data.Models.Client.EFClient> iqClients = null;
if (!string.IsNullOrEmpty(query.Xuid))
{
var networkId = query.Xuid.ConvertGuidToLong(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;
}
private async Task<EFClient> HandleNewCreate(EFClient entity)
{
2022-01-26 11:32:16 -05:00
await using var context = _contextFactory.CreateContext();
using (LogContext.PushProperty("Server", entity.CurrentServer?.ToString()))
{
var existingAlias = await context.Aliases
2022-01-26 11:32:16 -05:00
.Select(alias => new { alias.AliasId, alias.LinkId, alias.IPAddress, alias.Name })
.Where(alias => alias.IPAddress != null && alias.IPAddress == entity.IPAddress &&
alias.Name == entity.Name)
.FirstOrDefaultAsync();
var client = new EFClient
{
Level = Permission.User,
FirstConnection = DateTime.UtcNow,
LastConnection = DateTime.UtcNow,
2022-04-22 17:03:34 -04:00
NetworkId = entity.NetworkId,
GameName = (Reference.Game)entity.CurrentServer.GameName
};
2022-01-26 11:32:16 -05:00
if (existingAlias == null)
{
2022-01-26 11:32:16 -05:00
_logger.LogDebug("[{Method}] creating new Link and Alias for {Entity}", nameof(HandleNewCreate),
entity.ToString());
var link = new EFAliasLink();
var alias = new EFAlias
{
Name = entity.Name,
SearchableName = entity.Name.StripColors().ToLower(),
DateAdded = DateTime.UtcNow,
IPAddress = entity.IPAddress,
Link = link
};
client.CurrentAlias = alias;
client.AliasLink = link;
}
else
{
2022-01-26 11:32:16 -05:00
_logger.LogDebug(
"[{Method}] associating new GUID {Guid} with new exact alias match with linkId {LinkId} for {Entity}",
nameof(HandleNewCreate), entity.GuidString, existingAlias.LinkId, entity.ToString());
2022-01-26 11:32:16 -05:00
var alias = new EFAlias
{
Name = existingAlias.Name,
SearchableName = entity.Name.StripColors().ToLower(),
DateAdded = DateTime.UtcNow,
IPAddress = entity.IPAddress,
LinkId = existingAlias.LinkId
};
client.CurrentAlias = alias;
client.AliasLinkId = existingAlias.LinkId;
}
2022-01-26 11:32:16 -05:00
context.Clients.Add(client);
await context.SaveChangesAsync();
return client;
}
}
2022-01-26 11:32:16 -05:00
private async Task UpdateAlias(string originalName, int? ip, Data.Models.Client.EFClient entity,
DatabaseContext context)
{
{
2022-01-26 11:32:16 -05:00
var name = originalName.CapClientName(EFAlias.MAX_NAME_LENGTH);
// entity is the tracked db context item
// get all aliases by IP address and LinkId
var iqAliases = context.Aliases
.Include(a => a.Link)
// we only want alias that have the same IP address or share a link
2022-01-26 11:32:16 -05:00
.Where(_alias => _alias.IPAddress == ip || _alias.LinkId == entity.AliasLinkId);
var aliases = await iqAliases.ToListAsync();
var currentIPs = aliases.Where(_a2 => _a2.IPAddress != null).Select(_a2 => _a2.IPAddress).Distinct();
var floatingIPAliases = await context.Aliases.Where(_alias => currentIPs.Contains(_alias.IPAddress))
.ToListAsync();
aliases.AddRange(floatingIPAliases);
// see if they have a matching IP + Name but new NetworkId
var existingExactAlias = aliases.OrderBy(_alias => _alias.LinkId)
.FirstOrDefault(a => a.Name == name && a.IPAddress == ip);
2022-01-26 11:32:16 -05:00
var hasExactAliasMatch = existingExactAlias != null;
// if existing alias matches link them
var newAliasLink = existingExactAlias?.Link;
// if no exact matches find the first IP or LinkId that matches
newAliasLink = newAliasLink ?? aliases.OrderBy(_alias => _alias.LinkId).FirstOrDefault()?.Link;
// if no matches are found, use our current one ( it will become permanent )
newAliasLink = newAliasLink ?? entity.AliasLink;
2022-01-26 11:32:16 -05:00
var hasExistingAlias = aliases.Count > 0;
var isAliasLinkUpdated = newAliasLink.AliasLinkId != entity.AliasLink.AliasLinkId;
await context.SaveChangesAsync();
2022-01-26 11:32:16 -05:00
var distinctLinkCount = aliases.Select(_alias => _alias.LinkId).Distinct().Count();
// this happens when the link we found is different than the one we create before adding an IP
if (isAliasLinkUpdated || distinctLinkCount > 1)
{
_logger.LogDebug(
"[updatealias] found a link for {entity} so we are updating link from {oldAliasLinkId} to {newAliasLinkId}",
entity.ToString(), entity.AliasLink.AliasLinkId, newAliasLink.AliasLinkId);
var completeAliasLinkIds = aliases.Select(_item => _item.LinkId)
.Append(entity.AliasLinkId)
.Distinct()
.ToList();
_logger.LogDebug("[updatealias] updating aliasLinks {links} for IP {ip} to {linkId}",
string.Join(',', completeAliasLinkIds), ip, newAliasLink.AliasLinkId);
// update all the clients that have the old alias link
await context.Clients
.Where(_client => completeAliasLinkIds.Contains(_client.AliasLinkId))
.ForEachAsync(_client => _client.AliasLinkId = newAliasLink.AliasLinkId);
// we also need to update all the penalties or they get deleted
// scenario
// link1 joins with ip1
// link2 joins with ip2,
// link2 receives penalty
// link2 joins with ip1
// pre existing link for link2 detected
// link2 is deleted
// link2 penalties are orphaned
await context.Penalties
2022-02-22 18:09:50 -05:00
.Where(_penalty => completeAliasLinkIds.Contains(_penalty.LinkId ?? -1))
.ForEachAsync(_penalty => _penalty.LinkId = newAliasLink.AliasLinkId);
entity.AliasLink = newAliasLink;
entity.AliasLinkId = newAliasLink.AliasLinkId;
// update all previous aliases
await context.Aliases
.Where(_alias => completeAliasLinkIds.Contains(_alias.LinkId))
.ForEachAsync(_alias => _alias.LinkId = newAliasLink.AliasLinkId);
await context.SaveChangesAsync();
// we want to delete the now inactive alias
if (newAliasLink.AliasLinkId != entity.AliasLinkId)
{
context.AliasLinks.Remove(entity.AliasLink);
await context.SaveChangesAsync();
}
}
// the existing alias matches ip and name, so we can just ignore the temporary one
if (hasExactAliasMatch)
{
_logger.LogDebug("[updatealias] {entity} has exact alias match", entity.ToString());
var oldAlias = entity.CurrentAlias;
entity.CurrentAliasId = existingExactAlias.AliasId;
entity.CurrentAlias = existingExactAlias;
await context.SaveChangesAsync();
// the alias is the same so we can just remove it
if (oldAlias.AliasId != existingExactAlias.AliasId && oldAlias.AliasId > 0)
{
await context.Clients
.Where(_client => _client.CurrentAliasId == oldAlias.AliasId)
.ForEachAsync(_client => _client.CurrentAliasId = existingExactAlias.AliasId);
await context.SaveChangesAsync();
if (context.Entry(oldAlias).State != EntityState.Deleted)
{
_logger.LogDebug(
"[updatealias] {entity} has exact alias match, so we're going to try to remove aliasId {aliasId} with linkId {linkId}",
entity.ToString(), oldAlias.AliasId, oldAlias.LinkId);
context.Aliases.Remove(oldAlias);
await context.SaveChangesAsync();
}
}
}
// theres no exact match, but they've played before with the GUID or IP
else
{
_logger.LogDebug("[updatealias] {entity} is using a new alias", entity.ToString());
2022-01-26 11:32:16 -05:00
var newAlias = new EFAlias
{
DateAdded = DateTime.UtcNow,
IPAddress = ip,
LinkId = newAliasLink.AliasLinkId,
Name = name,
SearchableName = name.StripColors().ToLower(),
2022-01-26 11:32:16 -05:00
Active = true
};
entity.CurrentAlias = newAlias;
entity.CurrentAliasId = 0;
await context.SaveChangesAsync();
}
}
}
private async Task UpdateAliasNew(string originalName, int? ip, Data.Models.Client.EFClient entity,
DatabaseContext context)
{
var name = originalName.CapClientName(EFAlias.MAX_NAME_LENGTH);
2022-01-26 11:32:16 -05:00
var existingAliases = await context.Aliases
2022-01-26 11:32:16 -05:00
.Where(alias => alias.Name == name && alias.LinkId == entity.AliasLinkId ||
2021-08-14 21:43:20 -04:00
alias.Name == name && alias.IPAddress != null && alias.IPAddress == ip)
.ToListAsync();
var defaultAlias = existingAliases.FirstOrDefault(alias => alias.IPAddress == null);
var existingExactAlias =
existingAliases.FirstOrDefault(alias => alias.IPAddress != null && alias.IPAddress == ip);
if (defaultAlias != null && existingExactAlias == null)
{
defaultAlias.IPAddress = ip;
entity.CurrentAlias = defaultAlias;
entity.CurrentAliasId = defaultAlias.AliasId;
await context.SaveChangesAsync();
return;
}
if (existingExactAlias != null && entity.AliasLinkId == existingExactAlias.LinkId)
{
entity.CurrentAlias = existingExactAlias;
entity.CurrentAliasId = existingExactAlias.AliasId;
2021-09-04 13:33:25 -04:00
await context.SaveChangesAsync();
2022-01-26 11:32:16 -05:00
_logger.LogDebug(
"[{Method}] client {Client} already has an existing exact alias, so we are not making changes",
nameof(UpdateAliasNew), entity.ToString());
return;
}
2022-01-26 11:32:16 -05:00
_logger.LogDebug("[{Method}] {Entity} is using a new alias", nameof(UpdateAliasNew), entity.ToString());
2022-01-26 11:32:16 -05:00
var newAlias = new EFAlias
{
DateAdded = DateTime.UtcNow,
IPAddress = ip,
LinkId = entity.AliasLinkId,
Name = name,
SearchableName = name.StripColors().ToLower(),
2022-01-26 11:32:16 -05:00
Active = true
};
entity.CurrentAlias = newAlias;
await context.SaveChangesAsync();
entity.CurrentAliasId = newAlias.AliasId;
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// updates the permission level of the given target to the given permission level
/// </summary>
/// <param name="newPermission"></param>
/// <param name="temporalClient"></param>
/// <param name="origin"></param>
/// <returns></returns>
public virtual async Task UpdateLevel(Permission newPermission, EFClient temporalClient, EFClient origin)
{
await using var context = _contextFactory.CreateContext();
var entity = await context.Clients
.Where(client => client.ClientId == temporalClient.ClientId)
.FirstAsync();
_logger.LogInformation("Updating {ClientId} from {OldPermission} to {NewPermission} ",
temporalClient.ClientId, entity.Level, newPermission);
entity.Level = newPermission;
await context.SaveChangesAsync();
temporalClient.Level = newPermission;
}
public async Task UpdateAlias(EFClient temporalClient)
{
2022-01-26 11:32:16 -05:00
await using var context = _contextFactory.CreateContext();
var entity = context.Clients
.Include(c => c.AliasLink)
.Include(c => c.CurrentAlias)
.First(e => e.ClientId == temporalClient.ClientId);
if (_appConfig.EnableImplicitAccountLinking)
{
await UpdateAlias(temporalClient.Name, temporalClient.IPAddress, entity, context);
}
else
{
await UpdateAliasNew(temporalClient.Name, temporalClient.IPAddress, entity, context);
}
temporalClient.CurrentAlias = entity.CurrentAlias;
temporalClient.CurrentAliasId = entity.CurrentAliasId;
temporalClient.AliasLink = entity.AliasLink;
temporalClient.AliasLinkId = entity.AliasLinkId;
}
2022-01-26 11:32:16 -05:00
/// <summary>
/// retrieves the number of times the given client id has been reported
/// </summary>
/// <param name="clientId">client id to search for report counts of</param>
/// <returns></returns>
public async Task<int> GetClientReportCount(int clientId)
{
2022-01-26 11:32:16 -05:00
await using var context = _contextFactory.CreateContext(false);
return await context.Penalties
.Where(_penalty => _penalty.Active)
.Where(_penalty => _penalty.OffenderId == clientId)
.Where(_penalty => _penalty.Type == EFPenalty.PenaltyType.Report)
.CountAsync();
}
2022-01-26 11:32:16 -05:00
/// <summary>
/// indicates if the given clientid can be autoflagged
/// </summary>
/// <param name="clientId"></param>
/// <returns></returns>
public async Task<bool> CanBeAutoFlagged(int clientId)
{
await using var context = _contextFactory.CreateContext(false);
2022-01-26 11:32:16 -05:00
var now = DateTime.UtcNow;
var hasExistingAutoFlag = await context.Penalties
.Where(_penalty => _penalty.Active)
.Where(_penalty => _penalty.OffenderId == clientId)
.Where(_penalty => _penalty.Type == EFPenalty.PenaltyType.Flag)
.Where(_penalty => _penalty.PunisherId == 1)
.Where(_penalty => _penalty.Expires == null || _penalty.Expires > now)
.AnyAsync();
2022-01-26 11:32:16 -05:00
var hasUnflag = await context.Penalties
.Where(_penalty => _penalty.Active)
.Where(_penalty => _penalty.OffenderId == clientId)
.Where(_penalty => _penalty.Type == EFPenalty.PenaltyType.Unflag)
.AnyAsync();
2019-06-12 11:27:15 -04:00
2022-01-26 11:32:16 -05:00
return !hasExistingAutoFlag && !hasUnflag;
}
2022-01-26 11:32:16 -05:00
/// <summary>
/// Unlinks shared GUID account into its own separate account
/// </summary>
/// <param name="clientId"></param>
/// <returns></returns>
public async Task UnlinkClient(int clientId)
{
await using var ctx = _contextFactory.CreateContext();
var newLink = new EFAliasLink { Active = true };
ctx.AliasLinks.Add(newLink);
await ctx.SaveChangesAsync();
2022-01-26 11:32:16 -05:00
var client = await ctx.Clients.Include(_client => _client.CurrentAlias)
.FirstAsync(_client => _client.ClientId == clientId);
client.AliasLinkId = newLink.AliasLinkId;
client.Level = Permission.User;
2022-01-26 11:32:16 -05:00
await ctx.Aliases.Where(_alias =>
_alias.IPAddress == client.CurrentAlias.IPAddress && _alias.IPAddress != null)
.ForEachAsync(_alias => _alias.LinkId = newLink.AliasLinkId);
2017-11-29 19:35:50 -05:00
2022-01-26 11:32:16 -05:00
if (!_appConfig.EnableImplicitAccountLinking)
{
2022-01-26 11:32:16 -05:00
var clientIdsByIp = await ctx.Clients.Where(c =>
client.CurrentAlias.IPAddress != null &&
c.CurrentAlias.IPAddress == client.CurrentAlias.IPAddress)
.Select(c => c.ClientId)
.ToListAsync();
await ctx.Penalties.Where(penalty =>
clientIdsByIp.Contains(penalty.OffenderId)
&& new[]
{
EFPenalty.PenaltyType.Ban, EFPenalty.PenaltyType.TempBan, EFPenalty.PenaltyType.Flag
}.Contains(penalty.Type)
&& penalty.Expires == null)
.ForEachAsync(penalty => penalty.Expires = DateTime.UtcNow);
}
2022-01-26 11:32:16 -05:00
await ctx.SaveChangesAsync();
}
#region ServiceSpecific
2022-01-26 11:32:16 -05:00
public async Task<IList<EFClient>> GetOwners()
{
await using var context = _contextFactory.CreateContext(false);
return await context.Clients
.Where(c => c.Level == Permission.Owner)
.Select(c => c.ToPartialClient())
.ToListAsync();
}
public async Task<bool> HasOwnerAsync(CancellationToken token)
{
await using var context = _contextFactory.CreateContext(false);
return await context.Clients.AnyAsync(client => client.Level == Permission.Owner, token);
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// retrieves the number of owners
/// (client level is owner)
/// </summary>
/// <returns></returns>
public virtual async Task<int> GetOwnerCount()
{
await using var context = _contextFactory.CreateContext(false);
return await context.Clients
.CountAsync(_client => _client.Level == Permission.Owner);
}
2019-08-02 19:04:34 -04:00
public async Task<EFClient> GetClientForLogin(int clientId)
{
await using var context = _contextFactory.CreateContext(false);
return await context.Clients
.Select(client => new EFClient
{
NetworkId = client.NetworkId,
ClientId = client.ClientId,
2022-01-26 11:32:16 -05:00
CurrentAlias = new EFAlias
2019-08-02 19:04:34 -04:00
{
Name = client.CurrentAlias.Name
},
Password = client.Password,
PasswordSalt = client.PasswordSalt,
GameName = client.GameName,
Level = client.Level
})
.FirstAsync(client => client.ClientId == clientId);
2019-08-02 19:04:34 -04:00
}
public async Task<List<EFClient>> GetPrivilegedClients(bool includeName = true)
{
await using var context = _contextFactory.CreateContext(false);
var iqClients = from client in context.Clients.AsNoTracking()
2022-01-26 11:32:16 -05:00
where client.Level >= Permission.Trusted
where client.Active
select new EFClient
{
AliasLinkId = client.AliasLinkId,
CurrentAlias = client.CurrentAlias,
ClientId = client.ClientId,
Level = client.Level,
Password = client.Password,
PasswordSalt = client.PasswordSalt,
NetworkId = client.NetworkId,
LastConnection = client.LastConnection,
Masked = client.Masked,
GameName = client.GameName
2022-01-26 11:32:16 -05:00
};
return await iqClients.ToListAsync();
}
2019-04-25 22:05:35 -04:00
public async Task<IList<PlayerInfo>> FindClientsByIdentifier(string identifier)
{
var trimmedIdentifier = identifier?.Trim();
2022-04-04 15:27:22 -04:00
if (trimmedIdentifier == null || trimmedIdentifier.Length < _appConfig.MinimumNameLength)
{
2019-04-25 22:05:35 -04:00
return new List<PlayerInfo>();
}
2018-04-21 18:18:20 -04:00
await using var context = _contextFactory.CreateContext(false);
long? networkId = null;
try
{
2022-01-26 11:32:16 -05:00
networkId = trimmedIdentifier.ConvertGuidToLong(NumberStyles.HexNumber);
}
catch
{
2022-02-23 10:32:59 -05:00
// ignored
}
2022-01-26 11:32:16 -05:00
var ipAddress = trimmedIdentifier.ConvertToIP();
2019-04-25 22:05:35 -04:00
2022-01-26 11:32:16 -05:00
var iqLinkIds = context.Aliases.Where(_alias => _alias.Active);
2019-04-25 22:05:35 -04:00
2022-02-23 10:32:59 -05:00
// we want to query for the IP Address
2022-04-04 15:27:22 -04:00
if (ipAddress != null && trimmedIdentifier.Split('.').Length == 3)
{
iqLinkIds = iqLinkIds.Where(_alias => _alias.IPAddress == ipAddress);
}
// want to find them by name (wildcard)
else
{
2022-01-26 11:32:16 -05:00
iqLinkIds = iqLinkIds.Where(_alias => EF.Functions.Like(_alias.SearchableName ?? _alias.Name.ToLower(),
2022-04-04 15:27:22 -04:00
$"%{trimmedIdentifier.ToLower()}%") || EF.Functions.Like(_alias.SearchableIPAddress, $"{trimmedIdentifier}%"));
}
var linkIds = await iqLinkIds
.Select(_alias => _alias.LinkId)
.ToListAsync();
2019-08-02 19:04:34 -04:00
// get all the clients that match the alias link or the network id
var iqClients = context.Clients
.Where(_client => _client.Active);
2022-02-23 10:32:59 -05:00
var match = Regex.Match(trimmedIdentifier ?? "", "\"(.+)\"");
2022-02-23 10:32:59 -05:00
if (match.Success)
{
iqClients = iqClients.Where(client =>
client.CurrentAlias.SearchableName.ToLower().Equals(match.Groups[1].ToString().ToLower()));
}
else
{
2022-06-16 19:44:49 -04:00
iqClients = iqClients.Where(client => networkId == client.NetworkId || linkIds.Contains(client.AliasLinkId));
}
if (ipAddress is not null && !_appConfig.EnableImplicitAccountLinking)
{
iqClients = iqClients.Union(context.Clients.Where(client => client.CurrentAlias.IPAddress == ipAddress));
2022-02-23 10:32:59 -05:00
}
// we want to project our results
2022-06-16 19:44:49 -04:00
var iqClientProjection = iqClients.OrderByDescending(client => client.LastConnection)
.Select(client => new PlayerInfo
2019-04-25 22:05:35 -04:00
{
Name = client.CurrentAlias.Name,
LevelInt = (int)client.Level,
LastConnection = client.LastConnection,
ClientId = client.ClientId,
IPAddress = client.CurrentAlias.IPAddress.HasValue
? client.CurrentAlias.SearchableIPAddress
: "",
Game = client.GameName
});
2018-02-23 02:06:13 -05:00
var clients = await iqClientProjection.ToListAsync();
// this is so we don't try to evaluate this in the linq to entities query
foreach (var client in clients)
2022-06-16 19:44:49 -04:00
{
client.Level = ((Permission)client.LevelInt).ToLocalizedLevelName();
2022-06-16 19:44:49 -04:00
}
return clients;
2018-02-23 02:06:13 -05:00
}
public async Task<int> GetTotalClientsAsync()
{
await using var context = _contextFactory.CreateContext(false);
return await context.Clients
.CountAsync();
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// Returns the number of clients seen today
/// </summary>
/// <returns></returns>
public async Task<int> GetRecentClientCount()
{
await using var context = _contextFactory.CreateContext(false);
var startOfPeriod = DateTime.UtcNow.AddHours(-24);
var iqQuery = context.Clients.Where(_client => _client.LastConnection >= startOfPeriod);
return await iqQuery.CountAsync();
}
/// <summary>
2022-01-26 11:32:16 -05:00
/// gets the 10 most recently added clients to IW4MAdmin
/// </summary>
/// <returns></returns>
2022-04-25 17:12:25 -04:00
public async Task<IList<PlayerInfo>> GetRecentClients(PaginationRequest request)
{
var startOfPeriod = DateTime.UtcNow.AddHours(-24);
await using var context = _contextFactory.CreateContext(false);
var iqClients = context.Clients
.Where(client => client.CurrentAlias.IPAddress != null)
.Where(client => client.FirstConnection >= startOfPeriod)
.OrderByDescending(client => client.FirstConnection)
.Select(client => new PlayerInfo
{
ClientId = client.ClientId,
Name = client.CurrentAlias.Name,
IPAddress = client.CurrentAlias.IPAddress.ConvertIPtoString(),
LastConnection = client.FirstConnection
2022-04-25 17:12:25 -04:00
})
.Skip(request.Offset)
.Take(request.Count);
var clientList = await iqClients.ToListAsync();
foreach (var client in clientList)
{
client.GeoLocationInfo = await _geoLocationService.Locate(client.IPAddress);
}
return clientList;
}
2022-07-20 11:32:26 -04:00
public async Task<string> GetClientNameById(int clientId)
{
await using var context = _contextFactory.CreateContext();
var match = await context.Clients.Select(client => new { client.CurrentAlias.Name, client.ClientId })
.FirstOrDefaultAsync(client => client.ClientId == clientId);
return match?.Name;
}
2022-01-26 11:32:16 -05:00
#endregion
}
}