IW4M-Admin/SharedLibraryCore/Services/ClientService.cs

310 lines
12 KiB
C#
Raw Normal View History

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
2018-04-08 02:44:42 -04:00
using SharedLibraryCore.Database;
using SharedLibraryCore.Database.Models;
using System.Linq.Expressions;
2018-04-08 02:44:42 -04:00
using SharedLibraryCore.Objects;
using Microsoft.EntityFrameworkCore;
using SharedLibraryCore.Dtos;
2018-04-08 02:44:42 -04:00
namespace SharedLibraryCore.Services
{
2017-11-29 19:35:50 -05:00
public class ClientService : Interfaces.IEntityService<EFClient>
{
public async Task<EFClient> Create(EFClient entity)
{
2017-11-29 19:35:50 -05:00
using (var context = new DatabaseContext())
{
2017-11-29 19:35:50 -05:00
bool hasExistingAlias = false;
// get all aliases by IP
2017-11-29 19:35:50 -05:00
var aliases = await context.Aliases
.Include(a => a.Link)
.Where(a => a.IPAddress == entity.IPAddress)
.ToListAsync();
2017-11-29 19:35:50 -05:00
// see if they have a matching IP + Name but new NetworkId
var existingAlias = aliases.FirstOrDefault(a => a.Name == entity.Name);
2017-11-29 19:35:50 -05:00
// if existing alias matches link them
EFAliasLink aliasLink = existingAlias?.Link;
// if no exact matches find the first IP that matches
aliasLink = aliasLink ?? aliases.FirstOrDefault()?.Link;
// if no exact or IP matches, create new link
aliasLink = aliasLink ?? new EFAliasLink()
{
Active = true,
};
// this has to be set here because we can't evalute it properly later
hasExistingAlias = existingAlias != null;
// if no existing alias create new alias
existingAlias = existingAlias ?? new EFAlias()
{
Active = true,
2017-11-29 19:35:50 -05:00
DateAdded = DateTime.UtcNow,
IPAddress = entity.IPAddress,
Link = aliasLink,
Name = entity.Name,
2017-11-29 19:35:50 -05:00
};
var client = new EFClient()
{
Active = true,
// set the level to the level of the existing client if they have the same IP + Name but new NetworkId
2018-02-21 20:29:23 -05:00
// fixme: issues?
2017-11-29 19:35:50 -05:00
Level = hasExistingAlias ?
(await context.Clients.Where(c => c.AliasLinkId == existingAlias.LinkId)
.OrderByDescending(c => c.Level)
.FirstOrDefaultAsync())?.Level ?? Player.Permission.User :
2018-02-15 23:01:28 -05:00
Player.Permission.User,
FirstConnection = DateTime.UtcNow,
Connections = 1,
LastConnection = DateTime.UtcNow,
Masked = false,
NetworkId = entity.NetworkId,
2017-11-29 19:35:50 -05:00
AliasLink = aliasLink,
CurrentAlias = existingAlias,
};
context.Clients.Add(client);
await context.SaveChangesAsync();
return client;
}
}
public async Task<EFClient> Delete(EFClient entity)
{
2017-11-29 19:35:50 -05:00
using (var context = new DatabaseContext())
{
2017-11-29 19:35:50 -05:00
var client = context.Clients
.Single(e => e.ClientId == entity.ClientId);
entity.Active = false;
context.Entry(entity).State = EntityState.Modified;
await context.SaveChangesAsync();
return entity;
}
}
public async Task<IList<EFClient>> Find(Func<EFClient, bool> e)
{
return await Task.Run(() =>
{
using (var context = new DatabaseContext(true))
{
return context.Clients
.Include(c => c.CurrentAlias)
.Include(c => c.AliasLink.Children)
.Where(e).ToList();
}
});
}
public async Task<EFClient> Get(int entityID)
{
using (var context = new DatabaseContext(true))
{
var iqClient = from client in context.Clients
.Include(c => c.CurrentAlias)
.Include(c => c.AliasLink.Children)
.Include(c => c.Meta)
where client.ClientId == entityID
select new
{
Client = client,
LinkedAccounts = (from linkedClient in context.Clients
where client.AliasLinkId == linkedClient.AliasLinkId
select new
{
linkedClient.ClientId,
linkedClient.NetworkId
})
};
#if DEBUG == true
var clientSql = iqClient.ToSql();
#endif
var foundClient = await iqClient.FirstOrDefaultAsync();
if (foundClient == null)
return null;
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;
}
}
private static readonly Func<DatabaseContext, long, Task<EFClient>> _getUniqueQuery =
EF.CompileAsyncQuery((DatabaseContext context, long networkId) =>
context.Clients
.Include(c => c.CurrentAlias)
.Include(c => c.AliasLink.Children)
.FirstOrDefault(c => c.NetworkId == networkId)
);
public async Task<EFClient> GetUnique(long entityAttribute)
{
using (var context = new DatabaseContext(true))
{
return await _getUniqueQuery(context, entityAttribute);
}
}
public async Task<EFClient> Update(EFClient entity)
{
2017-11-29 19:35:50 -05:00
using (var context = new DatabaseContext())
{
2017-11-29 19:35:50 -05:00
// grab the context version of the entity
var client = context.Clients
.Include(c => c.AliasLink)
.Include(c => c.CurrentAlias)
2017-11-29 19:35:50 -05:00
.Single(e => e.ClientId == entity.ClientId);
2017-11-29 19:35:50 -05:00
// if their level has been changed
if (entity.Level != client.Level)
{
// get all clients that use the same aliasId
var matchingClients = context.Clients
.Where(c => c.CurrentAliasId == client.CurrentAliasId)
// make sure we don't select ourselves twice
.Where(c => c.ClientId != entity.ClientId);
2017-11-29 19:35:50 -05:00
// update all related clients level
await matchingClients.ForEachAsync(c =>
{
c.Level = entity.Level;
});
2017-11-29 19:35:50 -05:00
}
// their alias has been updated and not yet saved
if (entity.CurrentAlias.AliasId == 0)
{
client.CurrentAlias = new EFAlias()
{
Active = true,
DateAdded = DateTime.UtcNow,
IPAddress = entity.CurrentAlias.IPAddress,
Name = entity.CurrentAlias.Name,
Link = client.AliasLink
};
}
2018-03-06 02:22:19 -05:00
else
{
client.CurrentAliasId = entity.CurrentAliasId;
}
2017-11-29 19:35:50 -05:00
// set remaining non-navigation properties that may have been updated
client.Level = entity.Level;
client.LastConnection = entity.LastConnection;
client.Connections = entity.Connections;
client.FirstConnection = entity.FirstConnection;
client.Masked = entity.Masked;
client.TotalConnectionTime = entity.TotalConnectionTime;
client.Password = entity.Password;
client.PasswordSalt = entity.PasswordSalt;
2017-11-29 19:35:50 -05:00
// update in database
await context.SaveChangesAsync();
2017-11-29 19:35:50 -05:00
// this is set so future updates don't trigger a new alias add
if (entity.CurrentAlias.AliasId == 0)
entity.CurrentAlias.AliasId = client.CurrentAlias.AliasId;
2017-11-29 19:35:50 -05:00
return client;
}
}
#region ServiceSpecific
public async Task<IList<EFClient>> GetOwners()
{
2017-11-29 19:35:50 -05:00
using (var context = new DatabaseContext())
return await context.Clients
.Where(c => c.Level == Player.Permission.Owner)
2017-11-29 19:35:50 -05:00
.ToListAsync();
}
public async Task<IList<ClientInfo>> GetPrivilegedClients()
{
using (var context = new DatabaseContext(disableTracking: true))
{
var iqClients = from client in context.Clients
where client.Level >= Player.Permission.Trusted
where client.Active
select new ClientInfo()
{
ClientId = client.ClientId,
Name = client.CurrentAlias.Name,
LinkId = client.AliasLinkId,
Level = client.Level
};
#if DEBUG == true
var clientsSql = iqClients.ToSql();
#endif
return await iqClients.ToListAsync();
}
}
public async Task<IList<EFClient>> GetClientByName(string name)
{
2018-04-21 18:18:20 -04:00
if (name.Length < 3)
return new List<EFClient>();
name = name.ToLower();
using (var context = new DatabaseContext(disableTracking: true))
{
int asIP = name.ConvertToIP();
// hack: so IW4MAdmin and bots don't show up in search results
asIP = asIP == 0 ? int.MaxValue : asIP;
var iqLinkIds = (from alias in context.Aliases
where asIP != int.MaxValue ? alias.IPAddress == asIP : alias.Name.ToLower().Contains(name)
select alias.LinkId);
var linkIds = iqLinkIds.ToList();
var iqClients = context.Clients
.Where(c => linkIds.Contains(c.AliasLinkId))
.Include(c => c.CurrentAlias)
.Include(c => c.AliasLink.Children);
#if DEBUG == true
var iqClientsSql = iqClients.ToSql();
#endif
2018-02-23 02:06:13 -05:00
return await iqClients.ToListAsync();
}
}
public async Task<int> GetTotalClientsAsync()
{
using (var context = new DatabaseContext(true))
2017-11-29 19:35:50 -05:00
return await context.Clients
.CountAsync();
}
public Task<EFClient> CreateProxy()
{
throw new NotImplementedException();
}
public async Task<int> GetTotalPlayTime()
{
using (var context = new DatabaseContext(true))
return await context.Clients.SumAsync(c => c.TotalConnectionTime);
}
#endregion
}
}