IW4M-Admin/SharedLibraryCore/Services/ClientService.cs

320 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;
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 ?
2018-02-23 02:06:13 -05:00
context.Clients.First(c => c.AliasLinkId == existingAlias.LinkId).Level :
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())
{
return context.Clients
.AsNoTracking()
.Include(c => c.CurrentAlias)
.Include(c => c.AliasLink.Children)
.Where(e).ToList();
}
});
}
public async Task<EFClient> Get(int entityID)
{
2017-11-29 19:35:50 -05:00
using (var context = new DatabaseContext())
{
return await context.Clients
2017-11-29 19:35:50 -05:00
.AsNoTracking()
.Include(c => c.CurrentAlias)
.Include(c => c.AliasLink.Children)
.SingleOrDefaultAsync(e => e.ClientId == entityID);
}
}
public async Task<EFClient> GetUnique(long entityAttribute)
{
2017-11-29 19:35:50 -05:00
using (var context = new DatabaseContext())
{
return await context.Clients
2017-11-29 19:35:50 -05:00
.AsNoTracking()
.Include(c => c.CurrentAlias)
.Include(c => c.AliasLink.Children)
.SingleOrDefaultAsync(c => c.NetworkId == (long)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);
// if their level has been changed
if (entity.Level != client.Level)
{
// get all clients that use the same aliasId
var matchingClients = await context.Clients
.Where(c => c.CurrentAliasId == client.CurrentAliasId)
.ToListAsync();
// update all related clients level
matchingClients.ForEach(c => c.Level = (client.Level == Objects.Player.Permission.Banned) ?
client.Level : entity.Level);
}
// 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<bool> IsAuthenticated(int clientIP)
{
using (var context = new DatabaseContext())
{
var iqMatching = from alias in context.Aliases
where alias.IPAddress == clientIP
join client in context.Clients
on alias.LinkId equals client.AliasLinkId
where client.Level > Player.Permission.Trusted
select client;
return (await iqMatching.CountAsync()) > 0;
}
}
public async Task<IList<EFClient>> GetPrivilegedClients()
{
2017-11-29 19:35:50 -05:00
using (var context = new DatabaseContext())
{
return await context.Clients
2017-11-29 19:35:50 -05:00
.AsNoTracking()
.Include(c => c.CurrentAlias)
.Where(c => c.Level >= Player.Permission.Trusted)
2017-11-29 19:35:50 -05:00
.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>();
using (var context = new DatabaseContext())
{
var iqClients = (from alias in context.Aliases
.AsNoTracking()
where alias.Name.ToLower()
.Contains(name.ToLower())
join link in context.AliasLinks
on alias.LinkId equals link.AliasLinkId
join client in context.Clients
.AsNoTracking()
on alias.LinkId equals client.AliasLinkId
select client)
.Distinct()
.Include(c => c.CurrentAlias)
.Include(c => c.AliasLink.Children);
2018-02-23 02:06:13 -05:00
return await iqClients.ToListAsync();
}
}
public async Task<IList<EFClient>> GetClientByIP(int ipAddress)
{
using (var context = new DatabaseContext())
{
var iqClients = (from alias in context.Aliases
.AsNoTracking()
where alias.IPAddress == ipAddress
join link in context.AliasLinks
on alias.LinkId equals link.AliasLinkId
join client in context.Clients
.AsNoTracking()
on alias.LinkId equals client.AliasLinkId
select client)
.Distinct()
.Include(c => c.CurrentAlias)
.Include(c => c.AliasLink.Children);
return await iqClients.ToListAsync();
}
}
public async Task<IList<EFClient>> GetRecentClients(int offset, int count)
{
2017-11-29 19:35:50 -05:00
using (var context = new DatabaseContext())
return await context.Clients
.AsNoTracking()
.Include(c => c.CurrentAlias)
.Include(p => p.AliasLink)
.OrderByDescending(p => p.ClientId)
.Skip(offset)
.Take(count)
.ToListAsync();
}
public async Task<IList<EFClient>> PruneInactivePrivilegedClients(int inactiveDays)
{
2017-11-29 19:35:50 -05:00
using (var context = new DatabaseContext())
{
var inactive = await context.Clients.Where(c => c.Level > Objects.Player.Permission.Flagged)
2017-11-29 19:35:50 -05:00
.AsNoTracking()
.Where(c => (DateTime.UtcNow - c.LastConnection).TotalDays >= inactiveDays)
.ToListAsync();
inactive.ForEach(c => c.Level = Player.Permission.User);
await context.SaveChangesAsync();
return inactive;
}
}
public async Task<int> GetTotalClientsAsync()
{
2017-11-29 19:35:50 -05:00
using (var context = new DatabaseContext())
return await context.Clients
.CountAsync();
}
public Task<EFClient> CreateProxy()
{
throw new NotImplementedException();
}
public async Task<int> GetTotalPlayTime()
{
using (var context = new DatabaseContext())
return await context.Clients.SumAsync(c => c.TotalConnectionTime);
}
#endregion
}
}