Add about/community info guidelines/social page

* Update ParserIW6x.js

Application/ApplicationManager.cs

@@ -259,7 +259,11 @@ namespace IW4MAdmin.Application
                     {
                         try
                         {
-                            await server.ProcessUpdatesAsync(_tokenSource.Token).WithWaitCancellation(runningUpdateTasks[server.EndPoint].tokenSource.Token);
+                            if (runningUpdateTasks.ContainsKey(server.EndPoint))
+                            {
+                                await server.ProcessUpdatesAsync(_tokenSource.Token)
+                                    .WithWaitCancellation(runningUpdateTasks[server.EndPoint].tokenSource.Token);
+                            }
                         }
 
                         catch (Exception e)
@@ -353,9 +357,7 @@ namespace IW4MAdmin.Application
 
                 _appConfig.AutoMessages = defaultConfig.AutoMessages;
                 _appConfig.GlobalRules = defaultConfig.GlobalRules;
-                _appConfig.Maps = defaultConfig.Maps;
                 _appConfig.DisallowedClientNames = defaultConfig.DisallowedClientNames;
-                _appConfig.QuickMessages = defaultConfig.QuickMessages;
 
                 //if (newConfig.Servers == null)
                 {
@@ -396,6 +398,18 @@ namespace IW4MAdmin.Application
                     await ConfigHandler.Save();
                 }
 
+#pragma warning disable 618
+                if (_appConfig.Maps != null)
+                {
+                    _appConfig.Maps = null;
+                }
+
+                if (_appConfig.QuickMessages != null)
+                {
+                    _appConfig.QuickMessages = null;
+                }
+#pragma warning restore 618
+
                 var validator = new ApplicationConfigurationValidator();
                 var validationResult = validator.Validate(_appConfig);
 
@@ -410,7 +424,7 @@ namespace IW4MAdmin.Application
 
                 foreach (var serverConfig in _appConfig.Servers)
                 {
-                    Migration.ConfigurationMigration.ModifyLogPath020919(serverConfig);
+                    ConfigurationMigration.ModifyLogPath020919(serverConfig);
 
                     if (serverConfig.RConParserVersion == null || serverConfig.EventParserVersion == null)
                     {

Application/Commands/OfflineMessageCommand.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Threading.Tasks;
+using Data.Abstractions;
+using Data.Models.Client;
+using Data.Models.Misc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using SharedLibraryCore;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Interfaces;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace IW4MAdmin.Application.Commands
+{
+    public class OfflineMessageCommand : Command
+    {
+        private readonly IDatabaseContextFactory _contextFactory;
+        private readonly ILogger _logger;
+        private const short MaxLength = 1024;
+        
+        public OfflineMessageCommand(CommandConfiguration config, ITranslationLookup layout,
+            IDatabaseContextFactory contextFactory, ILogger<IDatabaseContextFactory> logger) : base(config, layout)
+        {
+            Name = "offlinemessage";
+            Description = _translationLookup["COMMANDS_OFFLINE_MESSAGE_DESC"];
+            Alias = "om";
+            Permission = EFClient.Permission.Moderator;
+            RequiresTarget = true;
+            
+            _contextFactory = contextFactory;
+            _logger = logger;
+        }
+
+        public override async Task ExecuteAsync(GameEvent gameEvent)
+        {
+            if (gameEvent.Data.Length > MaxLength)
+            {
+                gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_TOO_LONG"].FormatExt(MaxLength));
+                return;
+            }
+            
+            if (gameEvent.Target.ClientId == gameEvent.Origin.ClientId)
+            {
+                gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_SELF"].FormatExt(MaxLength));
+                return;
+            }
+            
+            if (gameEvent.Target.IsIngame)
+            {
+                gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_INGAME"].FormatExt(gameEvent.Target.Name));
+                return;
+            }
+            
+            await using var context = _contextFactory.CreateContext(enableTracking: false);
+            var server = await context.Servers.FirstAsync(srv => srv.EndPoint == gameEvent.Owner.ToString());
+
+            var newMessage = new EFInboxMessage()
+            {
+                SourceClientId = gameEvent.Origin.ClientId,
+                DestinationClientId = gameEvent.Target.ClientId,
+                ServerId = server.Id,
+                Message = gameEvent.Data,
+            };
+
+            try
+            {
+                context.Set<EFInboxMessage>().Add(newMessage);
+                await context.SaveChangesAsync();
+                gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_SUCCESS"]);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Could not save offline message {@Message}", newMessage);
+                throw;
+            }
+        }
+    }
+}

Application/Commands/ReadMessageCommand.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Data.Abstractions;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using SharedLibraryCore;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Interfaces;
+using EFClient = Data.Models.Client.EFClient;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+
+namespace IW4MAdmin.Application.Commands
+{
+    public class ReadMessageCommand : Command
+    {
+        private readonly IDatabaseContextFactory _contextFactory;
+        private readonly ILogger _logger;
+
+        public ReadMessageCommand(CommandConfiguration config, ITranslationLookup layout,
+            IDatabaseContextFactory contextFactory, ILogger<IDatabaseContextFactory> logger) : base(config, layout)
+        {
+            Name = "readmessage";
+            Description = _translationLookup["COMMANDS_READ_MESSAGE_DESC"];
+            Alias = "rm";
+            Permission = EFClient.Permission.Flagged;
+
+            _contextFactory = contextFactory;
+            _logger = logger;
+        }
+
+        public override async Task ExecuteAsync(GameEvent gameEvent)
+        {
+            try
+            {
+                await using var context = _contextFactory.CreateContext();
+
+                var inboxItems = await context.InboxMessages
+                    .Include(message => message.SourceClient)
+                    .ThenInclude(client => client.CurrentAlias)
+                    .Where(message => message.DestinationClientId == gameEvent.Origin.ClientId)
+                    .Where(message => !message.IsDelivered)
+                    .ToListAsync();
+
+                if (!inboxItems.Any())
+                {
+                    gameEvent.Origin.Tell(_translationLookup["COMMANDS_READ_MESSAGE_NONE"]);
+                    return;
+                }
+
+                var index = 1;
+                foreach (var inboxItem in inboxItems)
+                {
+                    await gameEvent.Origin.Tell(_translationLookup["COMMANDS_READ_MESSAGE_SUCCESS"]
+                            .FormatExt($"{index}/{inboxItems.Count}", inboxItem.SourceClient.CurrentAlias.Name))
+                        .WaitAsync();
+
+                    foreach (var messageFragment in inboxItem.Message.FragmentMessageForDisplay())
+                    {
+                        await gameEvent.Origin.Tell(messageFragment).WaitAsync();
+                    }
+
+                    index++;
+                }
+
+                inboxItems.ForEach(item => { item.IsDelivered = true; });
+
+                context.UpdateRange(inboxItems);
+                await context.SaveChangesAsync();
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Could not retrieve offline messages for {Client}", gameEvent.Origin.ToString());
+                throw;
+            }
+        }
+    }
+}

Application/DefaultSettings.json

@@ -435,8 +435,8 @@
           "Name": "oilrig"
         },
         {
-          "Name": "Village",
-          "Alias": "co_hunted"
+          "Alias": "Village",
+          "Name": "co_hunted"
         }
       ]
     },

Application/Factories/RConConnectionFactory.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Net;
 using SharedLibraryCore.Interfaces;
 using System.Text;
 using Integrations.Cod;
@@ -6,6 +7,7 @@ using Integrations.Source;
 using Integrations.Source.Interfaces;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using SharedLibraryCore.Configuration;
 
 namespace IW4MAdmin.Application.Factories
 {
@@ -26,21 +28,17 @@ namespace IW4MAdmin.Application.Factories
             _serviceProvider = serviceProvider;
         }
 
-        /// <summary>
-        /// creates a new rcon connection instance
-        /// </summary>
-        /// <param name="ipAddress">ip address of the server</param>
-        /// <param name="port">port of the server</param>
-        /// <param name="password">rcon password of the server</param>
-        /// <returns></returns>
-        public IRConConnection CreateConnection(string ipAddress, int port, string password, string rconEngine)
+        /// <inheritdoc/>
+        public IRConConnection CreateConnection(IPEndPoint ipEndpoint, string password, string rconEngine)
         {
             return rconEngine switch
             {
-                "COD" => new CodRConConnection(ipAddress, port, password,
-                    _serviceProvider.GetRequiredService<ILogger<CodRConConnection>>(), GameEncoding),
-                "Source"  => new SourceRConConnection(_serviceProvider.GetRequiredService<ILogger<SourceRConConnection>>(),
-                    _serviceProvider.GetRequiredService<IRConClientFactory>(), ipAddress, port, password),
+                "COD" => new CodRConConnection(ipEndpoint, password,
+                    _serviceProvider.GetRequiredService<ILogger<CodRConConnection>>(), GameEncoding,
+                    _serviceProvider.GetRequiredService<ApplicationConfiguration>()?.ServerConnectionAttempts ?? 6),
+                "Source" => new SourceRConConnection(
+                    _serviceProvider.GetRequiredService<ILogger<SourceRConConnection>>(),
+                    _serviceProvider.GetRequiredService<IRConClientFactory>(), ipEndpoint, password),
                 _ => throw new ArgumentException($"No supported RCon engine available for '{rconEngine}'")
             };
         }

Application/GameEventHandler.cs

@@ -13,6 +13,7 @@ namespace IW4MAdmin.Application
     {
         private readonly EventLog _eventLog;
         private readonly ILogger _logger;
+        private readonly IEventPublisher _eventPublisher;
         private static readonly GameEvent.EventType[] overrideEvents = new[]
         {
             GameEvent.EventType.Connect,
@@ -21,10 +22,11 @@ namespace IW4MAdmin.Application
             GameEvent.EventType.Stop
         };
 
-        public GameEventHandler(ILogger<GameEventHandler> logger)
+        public GameEventHandler(ILogger<GameEventHandler> logger, IEventPublisher eventPublisher)
         {
             _eventLog = new EventLog();
             _logger = logger;
+            _eventPublisher = eventPublisher;
         }
 
         public void HandleEvent(IManager manager, GameEvent gameEvent)
@@ -32,6 +34,7 @@ namespace IW4MAdmin.Application
             if (manager.IsRunning || overrideEvents.Contains(gameEvent.Type))
             {
                 EventApi.OnGameEvent(gameEvent);
+                _eventPublisher.Publish(gameEvent);
                 Task.Factory.StartNew(() => manager.ExecuteEvent(gameEvent));
             }
             else

Application/IW4MServer.cs

@@ -11,6 +11,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Net;
 using System.Runtime.InteropServices;
 using System.Text.RegularExpressions;
 using System.Threading;
@@ -22,6 +23,7 @@ using Serilog.Context;
 using static SharedLibraryCore.Database.Models.EFClient;
 using Data.Models;
 using Data.Models.Server;
+using Microsoft.EntityFrameworkCore;
 using static Data.Models.Client.EFClient;
 
 namespace IW4MAdmin
@@ -308,6 +310,11 @@ namespace IW4MAdmin
                         Console.WriteLine(loc["MANAGER_CONNECTION_REST"].FormatExt($"[{IP}:{Port}]"));
                     }
 
+                    if (!string.IsNullOrEmpty(CustomSayName))
+                    {
+                        await this.SetDvarAsync("sv_sayname", CustomSayName);
+                    }
+
                     Throttled = false;
                 }
 
@@ -341,7 +348,26 @@ namespace IW4MAdmin
                             E.Origin.Tag = clientTag.LinkedMeta.Value;
                         }
 
-                        await E.Origin.OnJoin(E.Origin.IPAddress);
+                        try
+                        {
+                            var factory = _serviceProvider.GetRequiredService<IDatabaseContextFactory>();
+                            await using var context = factory.CreateContext();
+
+                            var messageCount = await context.InboxMessages
+                                .CountAsync(msg => msg.DestinationClientId == E.Origin.ClientId && !msg.IsDelivered);
+      
+                            if (messageCount > 0)
+                            {
+                                E.Origin.Tell(_translationLookup["SERVER_JOIN_OFFLINE_MESSAGES"]);
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            ServerLogger.LogError(ex, "Could not get offline message count for {Client}", E.Origin.ToString());
+                            throw;
+                        }
+                        
+                        await E.Origin.OnJoin(E.Origin.IPAddress, Manager.GetApplicationSettings().Configuration().EnableImplicitAccountLinking);
                     }
                 }
 
@@ -441,7 +467,7 @@ namespace IW4MAdmin
                         Link = E.Target.AliasLink
                     };
 
-                    var addedPenalty = await Manager.GetPenaltyService().Create(newPenalty);
+                    await Manager.GetPenaltyService().Create(newPenalty);
                     E.Target.SetLevel(Permission.Flagged, E.Origin);
                 }
 
@@ -593,7 +619,7 @@ namespace IW4MAdmin
                         {
                             try
                             {
-                                message = Manager.GetApplicationSettings().Configuration()
+                                message = _serviceProvider.GetRequiredService<DefaultSettings>()
                                     .QuickMessages
                                     .First(_qm => _qm.Game == GameName)
                                     .Messages[E.Data.Substring(1)];
@@ -717,7 +743,7 @@ namespace IW4MAdmin
             {
                 try
                 {
-                    await client.OnJoin(origin.IPAddress);
+                    await client.OnJoin(origin.IPAddress, Manager.GetApplicationSettings().Configuration().EnableImplicitAccountLinking);
                 }
 
                 catch (Exception e)
@@ -733,7 +759,7 @@ namespace IW4MAdmin
                 client.Level == Permission.Banned)
             {
                 ServerLogger.LogWarning("{client} state is Unknown (probably kicked), but they are still connected. trying to kick again...", origin.ToString());
-                await client.CanConnect(client.IPAddress);
+                await client.CanConnect(client.IPAddress, Manager.GetApplicationSettings().Configuration().EnableImplicitAccountLinking);
             }
         }
 
@@ -771,8 +797,10 @@ namespace IW4MAdmin
             };
         }
         
-        private async Task<long> GetIdForServer(Server server)
+        public override async Task<long> GetIdForServer(Server server = null)
         {
+            server ??= this;
+            
             if ($"{server.IP}:{server.Port.ToString()}" == "66.150.121.184:28965")
             {
                 return 886229536;
@@ -979,10 +1007,13 @@ namespace IW4MAdmin
                 LastMessage = DateTime.Now - start;
                 lastCount = DateTime.Now;
 
+                var appConfig = _serviceProvider.GetService<ApplicationConfiguration>();
                 // update the player history 
-                if ((lastCount - playerCountStart).TotalMinutes >= PlayerHistory.UpdateInterval)
+                if (lastCount - playerCountStart >= appConfig.ServerDataCollectionInterval)
                 {
-                    while (ClientHistory.Count > ((60 / PlayerHistory.UpdateInterval) * 12)) // 12 times a hour for 12 hours
+                    var maxItems = Math.Ceiling(appConfig.MaxClientHistoryTime.TotalMinutes /
+                                                appConfig.ServerDataCollectionInterval.TotalMinutes);
+                    while ( ClientHistory.Count > maxItems) 
                     {
                         ClientHistory.Dequeue();
                     }
@@ -1039,6 +1070,16 @@ namespace IW4MAdmin
 
         public async Task Initialize()
         {
+            try
+            {
+                ResolvedIpEndPoint = new IPEndPoint((await Dns.GetHostAddressesAsync(IP)).First(), Port);
+            }
+            catch (Exception ex)
+            {
+                ServerLogger.LogWarning(ex, "Could not resolve hostname or IP for RCon connection {IP}:{Port}", IP, Port);
+                ResolvedIpEndPoint = new IPEndPoint(IPAddress.Parse(IP), Port);
+            }
+            
             RconParser = Manager.AdditionalRConParsers
                 .FirstOrDefault(_parser => _parser.Version == ServerConfig.RConParserVersion);
 
@@ -1048,7 +1089,7 @@ namespace IW4MAdmin
             RconParser ??= Manager.AdditionalRConParsers[0];
             EventParser ??= Manager.AdditionalEventParsers[0];
 
-            RemoteConnection = RConConnectionFactory.CreateConnection(IP, Port, Password, RconParser.RConEngine);
+            RemoteConnection = RConConnectionFactory.CreateConnection(ResolvedIpEndPoint, Password, RconParser.RConEngine);
             RemoteConnection.SetConfiguration(RconParser);
 
             var version = await this.GetMappedDvarValueOrDefaultAsync<string>("version");
@@ -1081,8 +1122,9 @@ namespace IW4MAdmin
             string mapname = (await this.GetMappedDvarValueOrDefaultAsync<string>("mapname", infoResponse: infoResponse)).Value;
             int maxplayers = (await this.GetMappedDvarValueOrDefaultAsync<int>("sv_maxclients", infoResponse: infoResponse)).Value;
             string gametype = (await this.GetMappedDvarValueOrDefaultAsync<string>("g_gametype", "gametype", infoResponse)).Value;
-            var basepath = (await this.GetMappedDvarValueOrDefaultAsync<string>("fs_basepath"));
-            var basegame = (await this.GetMappedDvarValueOrDefaultAsync<string>("fs_basegame"));
+            var basepath = await this.GetMappedDvarValueOrDefaultAsync<string>("fs_basepath");
+            var basegame = await this.GetMappedDvarValueOrDefaultAsync<string>("fs_basegame");
+            var homepath = await this.GetMappedDvarValueOrDefaultAsync<string>("fs_homepath");
             var game = (await this.GetMappedDvarValueOrDefaultAsync<string>("fs_game", infoResponse: infoResponse));
             var logfile = await this.GetMappedDvarValueOrDefaultAsync<string>("g_log");
             var logsync = await this.GetMappedDvarValueOrDefaultAsync<int>("g_logsync");
@@ -1118,8 +1160,14 @@ namespace IW4MAdmin
             {
                 Manager.GetApplicationSettings().Configuration().ContactUri = Website;
             }
+            
+            var defaultConfig = _serviceProvider.GetRequiredService<DefaultSettings>();
+            var gameMaps = defaultConfig?.Maps?.FirstOrDefault(map => map.Game == GameName);
 
-            InitializeMaps();
+            if (gameMaps != null)
+            {
+                Maps.AddRange(gameMaps.Maps);
+            }
 
             WorkingDirectory = basepath.Value;
             this.Hostname = hostname;
@@ -1177,6 +1225,7 @@ namespace IW4MAdmin
                 {
                     BaseGameDirectory = basegame.Value,
                     BasePathDirectory = basepath.Value,
+                    HomePathDirectory = homepath.Value,
                     GameDirectory = EventParser.Configuration.GameDirectory ?? "",
                     ModDirectory = game.Value ?? "",
                     LogFile = logfile.Value,
@@ -1227,15 +1276,25 @@ namespace IW4MAdmin
         {
             string logPath;
             var workingDirectory = logInfo.BasePathDirectory;
+            
+            bool IsValidGamePath (string path)
+            {
+                var baseGameIsDirectory = !string.IsNullOrWhiteSpace(path) &&
+                                          path.IndexOfAny(Utilities.DirectorySeparatorChars) != -1;
 
-            var baseGameIsDirectory = !string.IsNullOrWhiteSpace(logInfo.BaseGameDirectory) &&
-                logInfo.BaseGameDirectory.IndexOfAny(Utilities.DirectorySeparatorChars) != -1;
+                var baseGameIsRelative = path.FixDirectoryCharacters()
+                    .Equals(logInfo.GameDirectory.FixDirectoryCharacters(), StringComparison.InvariantCultureIgnoreCase);
 
-            var baseGameIsRelative = logInfo.BaseGameDirectory.FixDirectoryCharacters()
-                .Equals(logInfo.GameDirectory.FixDirectoryCharacters(), StringComparison.InvariantCultureIgnoreCase);
+                return baseGameIsDirectory && !baseGameIsRelative;
+            }
 
             // we want to see if base game is provided and it 'looks' like a directory
-            if (baseGameIsDirectory && !baseGameIsRelative)
+            if (IsValidGamePath(logInfo.HomePathDirectory))
+            {
+                workingDirectory = logInfo.HomePathDirectory;
+            }
+            
+            else if (IsValidGamePath(logInfo.BaseGameDirectory))
             {
                 workingDirectory = logInfo.BaseGameDirectory;
             }

Application/Main.cs

@@ -185,6 +185,8 @@ namespace IW4MAdmin.Application
                 ? WebfrontCore.Program.Init(ServerManager, serviceProvider, services, ServerManager.CancellationToken)
                 : Task.CompletedTask;
 
+            var collectionService = serviceProvider.GetRequiredService<IServerDataCollector>();
+
             // we want to run this one on a manual thread instead of letting the thread pool handle it,
             // because we can't exit early from waiting on console input, and it prevents us from restarting
             var inputThread = new Thread(async () => await ReadConsoleInput(logger));
@@ -195,7 +197,8 @@ namespace IW4MAdmin.Application
                 ServerManager.Start(),
                 webfrontTask,
                 serviceProvider.GetRequiredService<IMasterCommunication>()
-                    .RunUploadStatus(ServerManager.CancellationToken)
+                    .RunUploadStatus(ServerManager.CancellationToken),
+                collectionService.BeginCollectionAsync(cancellationToken: ServerManager.CancellationToken)
             };
 
             logger.LogDebug("Starting webfront and input tasks");
@@ -271,6 +274,7 @@ namespace IW4MAdmin.Application
 
             // register the native commands
             foreach (var commandType in typeof(SharedLibraryCore.Commands.QuitCommand).Assembly.GetTypes()
+                .Concat(typeof(Program).Assembly.GetTypes().Where(type => type.Namespace == "IW4MAdmin.Application.Commands"))
                 .Where(_command => _command.BaseType == typeof(Command)))
             {
                 defaultLogger.LogDebug("Registered native command type {name}", commandType.Name);
@@ -332,6 +336,8 @@ namespace IW4MAdmin.Application
             // setup the static resources (config/master api/translations)
             var serviceCollection = new ServiceCollection();
             var appConfigHandler = new BaseConfigurationHandler<ApplicationConfiguration>("IW4MAdminSettings");
+            var defaultConfigHandler = new BaseConfigurationHandler<DefaultSettings>("DefaultSettings");
+            var defaultConfig = defaultConfigHandler.Configuration();
             var appConfig = appConfigHandler.Configuration();
             var masterUri = Utilities.IsDevelopment
                 ? new Uri("http://127.0.0.1:8080")
@@ -360,6 +366,7 @@ namespace IW4MAdmin.Application
 
             serviceCollection
                 .AddBaseLogger(appConfig)
+                .AddSingleton(defaultConfig)
                 .AddSingleton<IServiceCollection>(_serviceProvider => serviceCollection)
                 .AddSingleton<IConfigurationHandler<DefaultSettings>, BaseConfigurationHandler<DefaultSettings>>()
                 .AddSingleton((IConfigurationHandler<ApplicationConfiguration>) appConfigHandler)
@@ -394,6 +401,7 @@ namespace IW4MAdmin.Application
                 .AddSingleton<IResourceQueryHelper<ClientPaginationRequest, UpdatedAliasResponse>,
                     UpdatedAliasResourceQueryHelper>()
                 .AddSingleton<IResourceQueryHelper<ChatSearchQuery, MessageResponse>, ChatResourceQueryHelper>()
+                .AddSingleton<IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse>, ConnectionsResourceQueryHelper>()
                 .AddTransient<IParserPatternMatcher, ParserPatternMatcher>()
                 .AddSingleton<IRemoteAssemblyHandler, RemoteAssemblyHandler>()
                 .AddSingleton<IMasterCommunication, MasterCommunication>()
@@ -406,6 +414,9 @@ namespace IW4MAdmin.Application
                 .AddSingleton<IHitInfoBuilder, HitInfoBuilder>()
                 .AddSingleton(typeof(ILookupCache<>), typeof(LookupCache<>))
                 .AddSingleton(typeof(IDataValueCache<,>), typeof(DataValueCache<,>))
+                .AddSingleton<IServerDataViewer, ServerDataViewer>()
+                .AddSingleton<IServerDataCollector, ServerDataCollector>()
+                .AddSingleton<IEventPublisher, EventPublisher>()
                 .AddSingleton(translationLookup)
                 .AddDatabaseContextOptions(appConfig);
 

Application/Meta/ConnectionsResourceQueryHelper.cs

@@ -0,0 +1,60 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Data.Abstractions;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using SharedLibraryCore.Dtos.Meta.Responses;
+using SharedLibraryCore.Helpers;
+using SharedLibraryCore.Interfaces;
+using SharedLibraryCore.QueryHelper;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace IW4MAdmin.Application.Meta
+{
+    public class
+        ConnectionsResourceQueryHelper : IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse>
+    {
+        private readonly ILogger _logger;
+        private readonly IDatabaseContextFactory _contextFactory;
+
+        public ConnectionsResourceQueryHelper(ILogger<ConnectionsResourceQueryHelper> logger,
+            IDatabaseContextFactory contextFactory)
+        {
+            _contextFactory = contextFactory;
+            _logger = logger;
+        }
+
+        public async Task<ResourceQueryHelperResult<ConnectionHistoryResponse>> QueryResource(
+            ClientPaginationRequest query)
+        {
+            _logger.LogDebug("{Class} {@Request}", nameof(ConnectionsResourceQueryHelper), query);
+
+            await using var context = _contextFactory.CreateContext(enableTracking: false);
+
+            var iqConnections = context.ConnectionHistory.AsNoTracking()
+                .Where(history => query.ClientId == history.ClientId)
+                .Where(history => history.CreatedDateTime < query.Before)
+                .OrderByDescending(history => history.CreatedDateTime);
+
+            var connections = await iqConnections.Select(history => new ConnectionHistoryResponse
+                {
+                    MetaId = history.ClientConnectionId,
+                    ClientId = history.ClientId,
+                    Type = MetaType.ConnectionHistory,
+                    ShouldDisplay = true,
+                    When = history.CreatedDateTime,
+                    ServerName = history.Server.HostName,
+                    ConnectionType = history.ConnectionType
+                })
+                .ToListAsync();
+
+            _logger.LogDebug("{Class} retrieved {Number} items", nameof(ConnectionsResourceQueryHelper),
+                connections.Count);
+
+            return new ResourceQueryHelperResult<ConnectionHistoryResponse>
+            {
+                Results = connections
+            };
+        }
+    }
+}

Application/Meta/MetaRegistration.cs

@@ -20,11 +20,14 @@ namespace IW4MAdmin.Application.Meta
         private readonly IResourceQueryHelper<ClientPaginationRequest, ReceivedPenaltyResponse> _receivedPenaltyHelper;
         private readonly IResourceQueryHelper<ClientPaginationRequest, AdministeredPenaltyResponse> _administeredPenaltyHelper;
         private readonly IResourceQueryHelper<ClientPaginationRequest, UpdatedAliasResponse> _updatedAliasHelper;
+        private readonly IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse>
+            _connectionHistoryHelper;
 
         public MetaRegistration(ILogger<MetaRegistration> logger, IMetaService metaService, ITranslationLookup transLookup, IEntityService<EFClient> clientEntityService,
             IResourceQueryHelper<ClientPaginationRequest, ReceivedPenaltyResponse> receivedPenaltyHelper,
             IResourceQueryHelper<ClientPaginationRequest, AdministeredPenaltyResponse> administeredPenaltyHelper,
-            IResourceQueryHelper<ClientPaginationRequest, UpdatedAliasResponse> updatedAliasHelper)
+            IResourceQueryHelper<ClientPaginationRequest, UpdatedAliasResponse> updatedAliasHelper,
+            IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse> connectionHistoryHelper)
         {
             _logger = logger;
             _transLookup = transLookup;
@@ -33,6 +36,7 @@ namespace IW4MAdmin.Application.Meta
             _receivedPenaltyHelper = receivedPenaltyHelper;
             _administeredPenaltyHelper = administeredPenaltyHelper;
             _updatedAliasHelper = updatedAliasHelper;
+            _connectionHistoryHelper = connectionHistoryHelper;
         }
 
         public void Register()
@@ -41,6 +45,7 @@ namespace IW4MAdmin.Application.Meta
             _metaService.AddRuntimeMeta<ClientPaginationRequest, ReceivedPenaltyResponse>(MetaType.ReceivedPenalty, GetReceivedPenaltiesMeta);
             _metaService.AddRuntimeMeta<ClientPaginationRequest, AdministeredPenaltyResponse>(MetaType.Penalized, GetAdministeredPenaltiesMeta);
             _metaService.AddRuntimeMeta<ClientPaginationRequest, UpdatedAliasResponse>(MetaType.AliasUpdate, GetUpdatedAliasMeta);
+            _metaService.AddRuntimeMeta<ClientPaginationRequest, ConnectionHistoryResponse>(MetaType.ConnectionHistory, GetConnectionHistoryMeta);
         }
 
         private async Task<IEnumerable<InformationResponse>> GetProfileMeta(ClientPaginationRequest request)
@@ -163,5 +168,11 @@ namespace IW4MAdmin.Application.Meta
             var aliases = await _updatedAliasHelper.QueryResource(request);
             return aliases.Results;
         }
+        
+        private async Task<IEnumerable<ConnectionHistoryResponse>> GetConnectionHistoryMeta(ClientPaginationRequest request)
+        {
+            var connections = await _connectionHistoryHelper.QueryResource(request);
+            return connections.Results;
+        }
     }
 }

Application/Meta/ReceivedPenaltyResourceQueryHelper.cs

@@ -1,10 +1,12 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using Data.Abstractions;
 using Data.Models;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using SharedLibraryCore;
+using SharedLibraryCore.Configuration;
 using SharedLibraryCore.Dtos.Meta.Responses;
 using SharedLibraryCore.Helpers;
 using SharedLibraryCore.Interfaces;
@@ -21,11 +23,14 @@ namespace IW4MAdmin.Application.Meta
     {
         private readonly ILogger _logger;
         private readonly IDatabaseContextFactory _contextFactory;
+        private readonly ApplicationConfiguration _appConfig;
 
-        public ReceivedPenaltyResourceQueryHelper(ILogger<ReceivedPenaltyResourceQueryHelper> logger, IDatabaseContextFactory contextFactory)
+        public ReceivedPenaltyResourceQueryHelper(ILogger<ReceivedPenaltyResourceQueryHelper> logger, 
+            IDatabaseContextFactory contextFactory, ApplicationConfiguration appConfig)
         {
             _contextFactory = contextFactory;
             _logger = logger;
+            _appConfig = appConfig;
         }
 
         public async Task<ResourceQueryHelperResult<ReceivedPenaltyResponse>> QueryResource(ClientPaginationRequest query)
@@ -35,15 +40,40 @@ namespace IW4MAdmin.Application.Meta
 
             var linkId = await ctx.Clients.AsNoTracking()
                     .Where(_client => _client.ClientId == query.ClientId)
-                    .Select(_client => _client.AliasLinkId)
+                    .Select(_client => new {_client.AliasLinkId, _client.CurrentAliasId })
                     .FirstOrDefaultAsync();
 
             var iqPenalties = ctx.Penalties.AsNoTracking()
-                .Where(_penalty => _penalty.OffenderId == query.ClientId || (linkedPenaltyType.Contains(_penalty.Type) && _penalty.LinkId == linkId))
-                .Where(_penalty => _penalty.When < query.Before)
-                .OrderByDescending(_penalty => _penalty.When);
+                .Where(_penalty => _penalty.OffenderId == query.ClientId ||
+                                   linkedPenaltyType.Contains(_penalty.Type) && _penalty.LinkId == linkId.AliasLinkId);
 
-            var penalties = await iqPenalties
+            IQueryable<EFPenalty> iqIpLinkedPenalties = null;
+            
+            if (!_appConfig.EnableImplicitAccountLinking)
+            {
+                var usedIps = await ctx.Aliases.AsNoTracking()
+                    .Where(alias => (alias.LinkId == linkId.AliasLinkId || alias.AliasId == linkId.CurrentAliasId) && alias.IPAddress != null)
+                    .Select(alias => alias.IPAddress).ToListAsync();
+
+                var aliasedIds = await ctx.Aliases.AsNoTracking().Where(alias => usedIps.Contains(alias.IPAddress))
+                    .Select(alias => alias.LinkId)
+                    .ToListAsync();
+
+                iqIpLinkedPenalties = ctx.Penalties.AsNoTracking()
+                    .Where(penalty =>
+                        linkedPenaltyType.Contains(penalty.Type) && aliasedIds.Contains(penalty.LinkId));
+            }
+
+            var iqAllPenalties = iqPenalties;
+            
+            if (iqIpLinkedPenalties != null)
+            {
+                iqAllPenalties = iqPenalties.Union(iqIpLinkedPenalties);
+            }
+
+             var penalties = await iqAllPenalties
+                .Where(_penalty => _penalty.When < query.Before)
+                .OrderByDescending(_penalty => _penalty.When)
                 .Take(query.Count)
                 .Select(_penalty => new ReceivedPenaltyResponse()
                 {

Application/Migration/DatabaseHousekeeping.cs

@@ -4,8 +4,6 @@ using System.Threading;
 using System.Threading.Tasks;
 using Data.Abstractions;
 using Data.Models.Client.Stats;
-using SharedLibraryCore.Database;
-using SharedLibraryCore.Interfaces;
 
 namespace IW4MAdmin.Application.Migration
 {

Application/Misc/EventPublisher.cs

@@ -0,0 +1,44 @@
+using System;
+using Microsoft.Extensions.Logging;
+using SharedLibraryCore;
+using SharedLibraryCore.Interfaces;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace IW4MAdmin.Application.Misc
+{
+    public class EventPublisher : IEventPublisher
+    {
+        public event EventHandler<GameEvent> OnClientDisconnect;
+        public event EventHandler<GameEvent> OnClientConnect;
+
+        private readonly ILogger _logger;
+
+        public EventPublisher(ILogger<EventPublisher> logger)
+        {
+            _logger = logger;
+        }
+
+        public void Publish(GameEvent gameEvent)
+        {
+            _logger.LogDebug("Handling publishing event of type {EventType}", gameEvent.Type);
+
+            try
+            {
+                if (gameEvent.Type == GameEvent.EventType.Connect)
+                {
+                    OnClientConnect?.Invoke(this, gameEvent);
+                }
+
+                if (gameEvent.Type == GameEvent.EventType.Disconnect)
+                {
+                    OnClientDisconnect?.Invoke(this, gameEvent);
+                }
+            }
+
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Could not publish event of type {EventType}", gameEvent.Type);
+            }
+        }
+    }
+}

Application/Misc/LogPathGeneratorInfo.cs

@@ -19,6 +19,12 @@ namespace IW4MAdmin.Application.Misc
         /// </summary>
         public string BasePathDirectory { get; set; } = "";
 
+        /// <summary>
+        /// directory for local storage
+        /// <remarks>fs_homepath</remarks>
+        /// </summary>
+        public string HomePathDirectory { get; set; } = "";
+
         /// <summary>
         /// overide game directory
         /// <remarks>plugin driven</remarks>

Application/Misc/ServerDataCollector.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Data.Abstractions;
+using Data.Models;
+using Data.Models.Client;
+using Data.Models.Client.Stats.Reference;
+using Data.Models.Server;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using SharedLibraryCore;
+using SharedLibraryCore.Configuration;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+using SharedLibraryCore.Interfaces;
+
+namespace IW4MAdmin.Application.Misc
+{
+    /// <inheritdoc/>
+    public class ServerDataCollector : IServerDataCollector
+    {
+        private readonly ILogger _logger;
+        private readonly IManager _manager;
+        private readonly IDatabaseContextFactory _contextFactory;
+        private readonly ApplicationConfiguration _appConfig;
+        private readonly IEventPublisher _eventPublisher;
+
+        private bool _inProgress;
+        private TimeSpan _period;
+
+        public ServerDataCollector(ILogger<ServerDataCollector> logger, ApplicationConfiguration appConfig,
+            IManager manager, IDatabaseContextFactory contextFactory, IEventPublisher eventPublisher)
+        {
+            _logger = logger;
+            _appConfig = appConfig;
+            _manager = manager;
+            _contextFactory = contextFactory;
+            _eventPublisher = eventPublisher;
+
+            _eventPublisher.OnClientConnect += SaveConnectionInfo;
+            _eventPublisher.OnClientDisconnect += SaveConnectionInfo;
+        }
+
+        ~ServerDataCollector()
+        {
+            _eventPublisher.OnClientConnect -= SaveConnectionInfo;
+            _eventPublisher.OnClientDisconnect -= SaveConnectionInfo;
+        }
+
+        public async Task BeginCollectionAsync(TimeSpan? period = null, CancellationToken cancellationToken = default)
+        {
+            if (_inProgress)
+            {
+                throw new InvalidOperationException($"{nameof(ServerDataCollector)} is already collecting data");
+            }
+
+            _logger.LogDebug("Initializing data collection with {Name}", nameof(ServerDataCollector));
+            _inProgress = true;
+            _period = period ?? (Utilities.IsDevelopment
+                ? TimeSpan.FromMinutes(1)
+                : _appConfig.ServerDataCollectionInterval);
+
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                try
+                {
+                    await Task.Delay(_period, cancellationToken);
+                    _logger.LogDebug("{Name} is collecting server data", nameof(ServerDataCollector));
+
+                    var data = await BuildCollectionData(cancellationToken);
+                    await SaveData(data, cancellationToken);
+                }
+                catch (TaskCanceledException)
+                {
+                    _logger.LogInformation("Shutdown requested for {Name}", nameof(ServerDataCollector));
+                    return;
+                }
+
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Unexpected error encountered collecting server data for {Name}",
+                        nameof(ServerDataCollector));
+                }
+            }
+        }
+
+        private async Task<IEnumerable<EFServerSnapshot>> BuildCollectionData(CancellationToken token)
+        {
+            var data = await Task.WhenAll(_manager.GetServers()
+                .Select(async server => new EFServerSnapshot
+                {
+                    CapturedAt = DateTime.UtcNow,
+                    PeriodBlock = (int) (DateTimeOffset.UtcNow - DateTimeOffset.UnixEpoch).TotalMinutes,
+                    ServerId = await server.GetIdForServer(),
+                    MapId = await GetOrCreateMap(server.CurrentMap.Name, (Reference.Game) server.GameName, token),
+                    ClientCount = server.ClientNum
+                }));
+
+            return data;
+        }
+
+        private async Task<int> GetOrCreateMap(string mapName, Reference.Game game, CancellationToken token)
+        {
+            await using var context = _contextFactory.CreateContext();
+            var existingMap =
+                await context.Maps.FirstOrDefaultAsync(map => map.Name == mapName && map.Game == game, token);
+
+            if (existingMap != null)
+            {
+                return existingMap.MapId;
+            }
+
+            var newMap = new EFMap
+            {
+                Name = mapName,
+                Game = game
+            };
+
+            context.Maps.Add(newMap);
+            await context.SaveChangesAsync(token);
+
+            return newMap.MapId;
+        }
+
+        private async Task SaveData(IEnumerable<EFServerSnapshot> snapshots, CancellationToken token)
+        {
+            await using var context = _contextFactory.CreateContext();
+            context.ServerSnapshots.AddRange(snapshots);
+            await context.SaveChangesAsync(token);
+        }
+
+        private void SaveConnectionInfo(object sender, GameEvent gameEvent)
+        {
+            using var context = _contextFactory.CreateContext(enableTracking: false);
+            context.ConnectionHistory.Add(new EFClientConnectionHistory
+            {
+                ClientId = gameEvent.Origin.ClientId,
+                ServerId = gameEvent.Owner.GetIdForServer().Result,
+                ConnectionType = gameEvent.Type == GameEvent.EventType.Connect
+                    ? Reference.ConnectionType.Connect
+                    : Reference.ConnectionType.Disconnect
+            });
+            context.SaveChanges();
+        }
+    }
+}

Application/Misc/ServerDataViewer.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Data.Abstractions;
+using Data.Models.Client;
+using Data.Models.Server;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using SharedLibraryCore;
+using SharedLibraryCore.Dtos;
+using SharedLibraryCore.Interfaces;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace IW4MAdmin.Application.Misc
+{
+    /// <inheritdoc/>
+    public class ServerDataViewer : IServerDataViewer
+    {
+        private readonly ILogger _logger;
+        private readonly IDataValueCache<EFServerSnapshot, (int?, DateTime?)> _snapshotCache;
+        private readonly IDataValueCache<EFClient, (int, int)> _serverStatsCache;
+        private readonly IDataValueCache<EFServerSnapshot, List<ClientHistoryInfo>> _clientHistoryCache;
+
+        private readonly TimeSpan? _cacheTimeSpan =
+            Utilities.IsDevelopment ? TimeSpan.FromSeconds(1) : (TimeSpan?) TimeSpan.FromMinutes(1);
+
+        public ServerDataViewer(ILogger<ServerDataViewer> logger, IDataValueCache<EFServerSnapshot, (int?, DateTime?)> snapshotCache,
+            IDataValueCache<EFClient, (int, int)> serverStatsCache,
+            IDataValueCache<EFServerSnapshot, List<ClientHistoryInfo>> clientHistoryCache)
+        {
+            _logger = logger;
+            _snapshotCache = snapshotCache;
+            _serverStatsCache = serverStatsCache;
+            _clientHistoryCache = clientHistoryCache;
+        }
+
+        public async Task<(int?, DateTime?)> MaxConcurrentClientsAsync(long? serverId = null, TimeSpan? overPeriod = null,
+            CancellationToken token = default)
+        {
+            _snapshotCache.SetCacheItem(async (snapshots, cancellationToken) =>
+            {
+                var oldestEntry = overPeriod.HasValue
+                    ? DateTime.UtcNow - overPeriod.Value
+                    : DateTime.UtcNow.AddDays(-1);
+                
+                int? maxClients;
+                DateTime? maxClientsTime;
+
+                if (serverId != null)
+                {
+                    var clients = await snapshots.Where(snapshot => snapshot.ServerId == serverId)
+                        .Where(snapshot => snapshot.CapturedAt >= oldestEntry)
+                        .OrderByDescending(snapshot => snapshot.ClientCount)
+                        .Select(snapshot => new
+                        {
+                            snapshot.ClientCount,
+                            snapshot.CapturedAt
+                        })
+                        .FirstOrDefaultAsync(cancellationToken);
+
+                    maxClients = clients?.ClientCount;
+                    maxClientsTime = clients?.CapturedAt;
+                }
+
+                else
+                {
+                    var clients = await snapshots.Where(snapshot => snapshot.CapturedAt >= oldestEntry)
+                        .GroupBy(snapshot => snapshot.PeriodBlock)
+                        .Select(grp => new
+                        {
+                            ClientCount = grp.Sum(snapshot => (int?) snapshot.ClientCount),
+                            Time = grp.Max(snapshot => (DateTime?) snapshot.CapturedAt)
+                        })
+                        .OrderByDescending(snapshot => snapshot.ClientCount)
+                        .FirstOrDefaultAsync(cancellationToken);
+                    
+                    maxClients = clients?.ClientCount;
+                    maxClientsTime = clients?.Time;
+                }
+
+                _logger.LogDebug("Max concurrent clients since {Start} is {Clients}", oldestEntry, maxClients);
+
+                return (maxClients, maxClientsTime);
+            }, nameof(MaxConcurrentClientsAsync), _cacheTimeSpan);
+
+            try
+            {
+                return await _snapshotCache.GetCacheItem(nameof(MaxConcurrentClientsAsync), token);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Could not retrieve data for {Name}", nameof(MaxConcurrentClientsAsync));
+                return (null, null);
+            }
+        }
+
+        public async Task<(int, int)> ClientCountsAsync(TimeSpan? overPeriod = null, CancellationToken token = default)
+        {
+            _serverStatsCache.SetCacheItem(async (set, cancellationToken) =>
+            {
+                var count = await set.CountAsync(cancellationToken);
+                var startOfPeriod =
+                    DateTime.UtcNow.AddHours(-overPeriod?.TotalHours ?? -24);
+                var recentCount = await set.CountAsync(client => client.LastConnection >= startOfPeriod,
+                    cancellationToken);
+
+                return (count, recentCount);
+            }, nameof(_serverStatsCache), _cacheTimeSpan);
+
+            try
+            {
+                return await _serverStatsCache.GetCacheItem(nameof(_serverStatsCache), token);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Could not retrieve data for {Name}", nameof(ClientCountsAsync));
+                return (0, 0);
+            }
+        }
+
+        public async Task<IEnumerable<ClientHistoryInfo>> ClientHistoryAsync(TimeSpan? overPeriod = null, CancellationToken token = default)
+        {
+            _clientHistoryCache.SetCacheItem(async (set, cancellationToken) =>
+            {
+                var oldestEntry = overPeriod.HasValue
+                    ? DateTime.UtcNow - overPeriod.Value
+                    : DateTime.UtcNow.AddHours(-12);
+
+                var history = await set.Where(snapshot => snapshot.CapturedAt >= oldestEntry)
+                    .Select(snapshot =>
+                        new
+                        {
+                            snapshot.ServerId,
+                            snapshot.CapturedAt,
+                            snapshot.ClientCount
+                        })
+                    .OrderBy(snapshot => snapshot.CapturedAt)
+                    .ToListAsync(cancellationToken);
+
+                return history.GroupBy(snapshot => snapshot.ServerId).Select(byServer => new ClientHistoryInfo
+                {
+                    ServerId = byServer.Key,
+                    ClientCounts = byServer.Select(snapshot => new ClientCountSnapshot()
+                        {Time = snapshot.CapturedAt, ClientCount = snapshot.ClientCount}).ToList()
+                }).ToList();
+            }, nameof(_clientHistoryCache), TimeSpan.MaxValue);
+
+            try
+            {
+                return await _clientHistoryCache.GetCacheItem(nameof(_clientHistoryCache), token);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Could not retrieve data for {Name}", nameof(ClientHistoryAsync));
+                return Enumerable.Empty<ClientHistoryInfo>();
+            }
+        }
+    }
+}

Data/Abstractions/IAuditFields.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace Data.Abstractions
+{
+    public class IAuditFields
+    {
+        DateTime CreatedDateTime { get; set; }
+        DateTime? UpdatedDateTime { get; set; } 
+    }
+}

Data/Abstractions/IDataValueCache.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
 
@@ -6,7 +7,7 @@ namespace Data.Abstractions
 {
     public interface IDataValueCache<T, V> where T : class
     {
-        void SetCacheItem(Func<DbSet<T>, Task<V>> itemGetter, string keyName, TimeSpan? expirationTime = null);
-        Task<V> GetCacheItem(string keyName);
+        void SetCacheItem(Func<DbSet<T>, CancellationToken, Task<V>> itemGetter, string keyName, TimeSpan? expirationTime = null);
+        Task<V> GetCacheItem(string keyName, CancellationToken token = default);
     }
 }

Data/Context/DatabaseContext.cs

@@ -7,6 +7,7 @@ using Data.Models;
 using Data.Models.Client;
 using Data.Models.Client.Stats;
 using Data.Models.Client.Stats.Reference;
+using Data.Models.Misc;
 using Data.Models.Server;
 
 namespace Data.Context
@@ -35,6 +36,14 @@ namespace Data.Context
         public DbSet<EFWeapon> Weapons { get; set; }
         public DbSet<EFWeaponAttachment> WeaponAttachments { get; set; }
         public DbSet<EFMap> Maps { get; set; }
+        
+        #endregion
+
+        #region MISC
+
+        public DbSet<EFInboxMessage> InboxMessages { get; set; }
+        public DbSet<EFServerSnapshot> ServerSnapshots { get;set; }
+        public DbSet<EFClientConnectionHistory> ConnectionHistory { get; set; }
 
         #endregion
 
@@ -121,11 +130,15 @@ namespace Data.Context
                     .OnDelete(DeleteBehavior.SetNull);
             });
 
+            modelBuilder.Entity<EFClientConnectionHistory>(ent => ent.HasIndex(history => history.CreatedDateTime));
+
             // force full name for database conversion
             modelBuilder.Entity<EFClient>().ToTable("EFClients");
             modelBuilder.Entity<EFAlias>().ToTable("EFAlias");
             modelBuilder.Entity<EFAliasLink>().ToTable("EFAliasLinks");
             modelBuilder.Entity<EFPenalty>().ToTable("EFPenalties");
+            modelBuilder.Entity<EFServerSnapshot>().ToTable(nameof(EFServerSnapshot));
+            modelBuilder.Entity<EFClientConnectionHistory>().ToTable(nameof(EFClientConnectionHistory));
 
             Models.Configuration.StatsModelConfiguration.Configure(modelBuilder);
 

Data/Data.csproj

@@ -8,7 +8,7 @@
     <PackageId>RaidMax.IW4MAdmin.Data</PackageId>
     <Title>RaidMax.IW4MAdmin.Data</Title>
     <Authors />
-    <PackageVersion>1.0.3</PackageVersion>
+    <PackageVersion>1.0.7</PackageVersion>
   </PropertyGroup>
   
   <ItemGroup>

Data/Helpers/DataValueCache.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Data.Abstractions;
 using Microsoft.EntityFrameworkCore;
@@ -19,36 +20,39 @@ namespace Data.Helpers
             public string Key { get; set; }
             public DateTime LastRetrieval { get; set; }
             public TimeSpan ExpirationTime { get; set; }
-            public Func<DbSet<T>, Task<V>> Getter { get; set; }
+            public Func<DbSet<T>, CancellationToken, Task<V>> Getter { get; set; }
             public V Value { get; set; }
-            public bool IsExpired => (DateTime.Now - LastRetrieval.Add(ExpirationTime)).TotalSeconds > 0;
+
+            public bool IsExpired => ExpirationTime != TimeSpan.MaxValue &&
+                                     (DateTime.Now - LastRetrieval.Add(ExpirationTime)).TotalSeconds > 0;
         }
-        
+
         public DataValueCache(ILogger<DataValueCache<T, V>> logger, IDatabaseContextFactory contextFactory)
         {
             _logger = logger;
             _contextFactory = contextFactory;
         }
-        
-        public void SetCacheItem(Func<DbSet<T>, Task<V>> getter, string key, TimeSpan? expirationTime = null)
+
+        public void SetCacheItem(Func<DbSet<T>, CancellationToken, Task<V>> getter, string key,
+            TimeSpan? expirationTime = null)
         {
             if (_cacheStates.ContainsKey(key))
             {
                 _logger.LogDebug("Cache key {key} is already added", key);
                 return;
             }
-                 
+
             var state = new CacheState()
             {
                 Key = key,
                 Getter = getter,
                 ExpirationTime = expirationTime ?? TimeSpan.FromMinutes(DefaultExpireMinutes)
             };
-  
+
             _cacheStates.Add(key, state);
         }
-        
-        public async Task<V> GetCacheItem(string keyName)
+
+        public async Task<V> GetCacheItem(string keyName, CancellationToken cancellationToken = default)
         {
             if (!_cacheStates.ContainsKey(keyName))
             {
@@ -57,21 +61,21 @@ namespace Data.Helpers
 
             var state = _cacheStates[keyName];
 
-            if (state.IsExpired)
+            if (state.IsExpired || state.Value == null)
             {
-                await RunCacheUpdate(state);
+                await RunCacheUpdate(state, cancellationToken);
             }
 
             return state.Value;
         }
 
-        private async Task RunCacheUpdate(CacheState state)
+        private async Task RunCacheUpdate(CacheState state, CancellationToken token)
         {
             try
             {
                 await using var context = _contextFactory.CreateContext(false);
                 var set = context.Set<T>();
-                var value = await state.Getter(set);
+                var value = await state.Getter(set, token);
                 state.Value = value;
                 state.LastRetrieval = DateTime.Now;
             }

Data/Migrations/MySql/20210709010749_AddEFInboxMessage.cs

@@ -0,0 +1,70 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Data.Migrations.MySql
+{
+    public partial class AddEFInboxMessage : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "InboxMessages",
+                columns: table => new
+                {
+                    InboxMessageId = table.Column<int>(nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    CreatedDateTime = table.Column<DateTime>(nullable: false),
+                    UpdatedDateTime = table.Column<DateTime>(nullable: true),
+                    SourceClientId = table.Column<int>(nullable: false),
+                    DestinationClientId = table.Column<int>(nullable: false),
+                    ServerId = table.Column<long>(nullable: true),
+                    Message = table.Column<string>(nullable: true),
+                    IsDelivered = table.Column<bool>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_InboxMessages", x => x.InboxMessageId);
+                    table.ForeignKey(
+                        name: "FK_InboxMessages_EFClients_DestinationClientId",
+                        column: x => x.DestinationClientId,
+                        principalTable: "EFClients",
+                        principalColumn: "ClientId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_InboxMessages_EFServers_ServerId",
+                        column: x => x.ServerId,
+                        principalTable: "EFServers",
+                        principalColumn: "ServerId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_InboxMessages_EFClients_SourceClientId",
+                        column: x => x.SourceClientId,
+                        principalTable: "EFClients",
+                        principalColumn: "ClientId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_InboxMessages_DestinationClientId",
+                table: "InboxMessages",
+                column: "DestinationClientId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_InboxMessages_ServerId",
+                table: "InboxMessages",
+                column: "ServerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_InboxMessages_SourceClientId",
+                table: "InboxMessages",
+                column: "SourceClientId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "InboxMessages");
+        }
+    }
+}

Data/Migrations/MySql/20210826222452_AddEFServerSnapshot.cs

@@ -0,0 +1,58 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Data.Migrations.MySql
+{
+    public partial class AddEFServerSnapshot : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "EFServerSnapshot",
+                columns: table => new
+                {
+                    ServerSnapshotId = table.Column<long>(nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    Active = table.Column<bool>(nullable: false),
+                    CapturedAt = table.Column<DateTime>(nullable: false),
+                    PeriodBlock = table.Column<int>(nullable: false),
+                    ServerId = table.Column<long>(nullable: false),
+                    MapId = table.Column<int>(nullable: false),
+                    ClientCount = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_EFServerSnapshot", x => x.ServerSnapshotId);
+                    table.ForeignKey(
+                        name: "FK_EFServerSnapshot_EFMaps_MapId",
+                        column: x => x.MapId,
+                        principalTable: "EFMaps",
+                        principalColumn: "MapId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_EFServerSnapshot_EFServers_ServerId",
+                        column: x => x.ServerId,
+                        principalTable: "EFServers",
+                        principalColumn: "ServerId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFServerSnapshot_MapId",
+                table: "EFServerSnapshot",
+                column: "MapId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFServerSnapshot_ServerId",
+                table: "EFServerSnapshot",
+                column: "ServerId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "EFServerSnapshot");
+        }
+    }
+}

Data/Migrations/MySql/20210831231006_AddEFClientConnectionHistory.cs

@@ -0,0 +1,62 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Data.Migrations.MySql
+{
+    public partial class AddEFClientConnectionHistory : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "EFClientConnectionHistory",
+                columns: table => new
+                {
+                    ClientConnectionId = table.Column<long>(nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    CreatedDateTime = table.Column<DateTime>(nullable: false),
+                    UpdatedDateTime = table.Column<DateTime>(nullable: true),
+                    ClientId = table.Column<int>(nullable: false),
+                    ServerId = table.Column<long>(nullable: false),
+                    ConnectionType = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_EFClientConnectionHistory", x => x.ClientConnectionId);
+                    table.ForeignKey(
+                        name: "FK_EFClientConnectionHistory_EFClients_ClientId",
+                        column: x => x.ClientId,
+                        principalTable: "EFClients",
+                        principalColumn: "ClientId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_EFClientConnectionHistory_EFServers_ServerId",
+                        column: x => x.ServerId,
+                        principalTable: "EFServers",
+                        principalColumn: "ServerId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientConnectionHistory_ClientId",
+                table: "EFClientConnectionHistory",
+                column: "ClientId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientConnectionHistory_CreatedDateTime",
+                table: "EFClientConnectionHistory",
+                column: "CreatedDateTime");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientConnectionHistory_ServerId",
+                table: "EFClientConnectionHistory",
+                column: "ServerId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "EFClientConnectionHistory");
+        }
+    }
+}

Data/Migrations/MySql/MySqlDatabaseContextModelSnapshot.cs

@@ -95,6 +95,38 @@ namespace Data.Migrations.MySql
                     b.ToTable("EFClients");
                 });
 
+            modelBuilder.Entity("Data.Models.Client.EFClientConnectionHistory", b =>
+                {
+                    b.Property<long>("ClientConnectionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ConnectionType")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<long>("ServerId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("UpdatedDateTime")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ClientConnectionId");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("CreatedDateTime");
+
+                    b.HasIndex("ServerId");
+
+                    b.ToTable("EFClientConnectionHistory");
+                });
+
             modelBuilder.Entity("Data.Models.Client.EFClientKill", b =>
                 {
                     b.Property<long>("KillId")
@@ -935,6 +967,44 @@ namespace Data.Migrations.MySql
                     b.ToTable("EFPenalties");
                 });
 
+            modelBuilder.Entity("Data.Models.Misc.EFInboxMessage", b =>
+                {
+                    b.Property<int>("InboxMessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DestinationClientId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsDelivered")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Message")
+                        .HasColumnType("longtext CHARACTER SET utf8mb4");
+
+                    b.Property<long?>("ServerId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SourceClientId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("UpdatedDateTime")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("InboxMessageId");
+
+                    b.HasIndex("DestinationClientId");
+
+                    b.HasIndex("ServerId");
+
+                    b.HasIndex("SourceClientId");
+
+                    b.ToTable("InboxMessages");
+                });
+
             modelBuilder.Entity("Data.Models.Server.EFServer", b =>
                 {
                     b.Property<long>("ServerId")
@@ -963,6 +1033,39 @@ namespace Data.Migrations.MySql
                     b.ToTable("EFServers");
                 });
 
+            modelBuilder.Entity("Data.Models.Server.EFServerSnapshot", b =>
+                {
+                    b.Property<long>("ServerSnapshotId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("CapturedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ClientCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MapId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodBlock")
+                        .HasColumnType("int");
+
+                    b.Property<long>("ServerId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("ServerSnapshotId");
+
+                    b.HasIndex("MapId");
+
+                    b.HasIndex("ServerId");
+
+                    b.ToTable("EFServerSnapshot");
+                });
+
             modelBuilder.Entity("Data.Models.Server.EFServerStatistics", b =>
                 {
                     b.Property<int>("StatisticId")
@@ -1038,6 +1141,21 @@ namespace Data.Migrations.MySql
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Data.Models.Client.EFClientConnectionHistory", b =>
+                {
+                    b.HasOne("Data.Models.Client.EFClient", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Data.Models.Server.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Data.Models.Client.EFClientKill", b =>
                 {
                     b.HasOne("Data.Models.Client.EFClient", "Attacker")
@@ -1282,6 +1400,40 @@ namespace Data.Migrations.MySql
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Data.Models.Misc.EFInboxMessage", b =>
+                {
+                    b.HasOne("Data.Models.Client.EFClient", "DestinationClient")
+                        .WithMany()
+                        .HasForeignKey("DestinationClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Data.Models.Server.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId");
+
+                    b.HasOne("Data.Models.Client.EFClient", "SourceClient")
+                        .WithMany()
+                        .HasForeignKey("SourceClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Data.Models.Server.EFServerSnapshot", b =>
+                {
+                    b.HasOne("Data.Models.Client.Stats.Reference.EFMap", "Map")
+                        .WithMany()
+                        .HasForeignKey("MapId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Data.Models.Server.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Data.Models.Server.EFServerStatistics", b =>
                 {
                     b.HasOne("Data.Models.Server.EFServer", "Server")

Data/Migrations/Postgresql/20210709010920_AddEFInboxMessage.cs

@@ -0,0 +1,70 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace Data.Migrations.Postgresql
+{
+    public partial class AddEFInboxMessage : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "InboxMessages",
+                columns: table => new
+                {
+                    InboxMessageId = table.Column<int>(nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
+                    CreatedDateTime = table.Column<DateTime>(nullable: false),
+                    UpdatedDateTime = table.Column<DateTime>(nullable: true),
+                    SourceClientId = table.Column<int>(nullable: false),
+                    DestinationClientId = table.Column<int>(nullable: false),
+                    ServerId = table.Column<long>(nullable: true),
+                    Message = table.Column<string>(nullable: true),
+                    IsDelivered = table.Column<bool>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_InboxMessages", x => x.InboxMessageId);
+                    table.ForeignKey(
+                        name: "FK_InboxMessages_EFClients_DestinationClientId",
+                        column: x => x.DestinationClientId,
+                        principalTable: "EFClients",
+                        principalColumn: "ClientId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_InboxMessages_EFServers_ServerId",
+                        column: x => x.ServerId,
+                        principalTable: "EFServers",
+                        principalColumn: "ServerId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_InboxMessages_EFClients_SourceClientId",
+                        column: x => x.SourceClientId,
+                        principalTable: "EFClients",
+                        principalColumn: "ClientId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_InboxMessages_DestinationClientId",
+                table: "InboxMessages",
+                column: "DestinationClientId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_InboxMessages_ServerId",
+                table: "InboxMessages",
+                column: "ServerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_InboxMessages_SourceClientId",
+                table: "InboxMessages",
+                column: "SourceClientId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "InboxMessages");
+        }
+    }
+}

Data/Migrations/Postgresql/20210826222523_AddEFServerSnapshot.cs

@@ -0,0 +1,58 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace Data.Migrations.Postgresql
+{
+    public partial class AddEFServerSnapshot : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "EFServerSnapshot",
+                columns: table => new
+                {
+                    ServerSnapshotId = table.Column<long>(nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
+                    Active = table.Column<bool>(nullable: false),
+                    CapturedAt = table.Column<DateTime>(nullable: false),
+                    PeriodBlock = table.Column<int>(nullable: false),
+                    ServerId = table.Column<long>(nullable: false),
+                    MapId = table.Column<int>(nullable: false),
+                    ClientCount = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_EFServerSnapshot", x => x.ServerSnapshotId);
+                    table.ForeignKey(
+                        name: "FK_EFServerSnapshot_EFMaps_MapId",
+                        column: x => x.MapId,
+                        principalTable: "EFMaps",
+                        principalColumn: "MapId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_EFServerSnapshot_EFServers_ServerId",
+                        column: x => x.ServerId,
+                        principalTable: "EFServers",
+                        principalColumn: "ServerId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFServerSnapshot_MapId",
+                table: "EFServerSnapshot",
+                column: "MapId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFServerSnapshot_ServerId",
+                table: "EFServerSnapshot",
+                column: "ServerId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "EFServerSnapshot");
+        }
+    }
+}

Data/Migrations/Postgresql/20210831231031_AddEFClientConnectionHistory.cs

@@ -0,0 +1,62 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace Data.Migrations.Postgresql
+{
+    public partial class AddEFClientConnectionHistory : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "EFClientConnectionHistory",
+                columns: table => new
+                {
+                    ClientConnectionId = table.Column<long>(nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn),
+                    CreatedDateTime = table.Column<DateTime>(nullable: false),
+                    UpdatedDateTime = table.Column<DateTime>(nullable: true),
+                    ClientId = table.Column<int>(nullable: false),
+                    ServerId = table.Column<long>(nullable: false),
+                    ConnectionType = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_EFClientConnectionHistory", x => x.ClientConnectionId);
+                    table.ForeignKey(
+                        name: "FK_EFClientConnectionHistory_EFClients_ClientId",
+                        column: x => x.ClientId,
+                        principalTable: "EFClients",
+                        principalColumn: "ClientId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_EFClientConnectionHistory_EFServers_ServerId",
+                        column: x => x.ServerId,
+                        principalTable: "EFServers",
+                        principalColumn: "ServerId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientConnectionHistory_ClientId",
+                table: "EFClientConnectionHistory",
+                column: "ClientId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientConnectionHistory_CreatedDateTime",
+                table: "EFClientConnectionHistory",
+                column: "CreatedDateTime");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientConnectionHistory_ServerId",
+                table: "EFClientConnectionHistory",
+                column: "ServerId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "EFClientConnectionHistory");
+        }
+    }
+}

Data/Migrations/Postgresql/PostgresqlDatabaseContextModelSnapshot.cs

@@ -99,6 +99,39 @@ namespace Data.Migrations.Postgresql
                     b.ToTable("EFClients");
                 });
 
+            modelBuilder.Entity("Data.Models.Client.EFClientConnectionHistory", b =>
+                {
+                    b.Property<long>("ClientConnectionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn);
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ConnectionType")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<long>("ServerId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("UpdatedDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.HasKey("ClientConnectionId");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("CreatedDateTime");
+
+                    b.HasIndex("ServerId");
+
+                    b.ToTable("EFClientConnectionHistory");
+                });
+
             modelBuilder.Entity("Data.Models.Client.EFClientKill", b =>
                 {
                     b.Property<long>("KillId")
@@ -958,6 +991,45 @@ namespace Data.Migrations.Postgresql
                     b.ToTable("EFPenalties");
                 });
 
+            modelBuilder.Entity("Data.Models.Misc.EFInboxMessage", b =>
+                {
+                    b.Property<int>("InboxMessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn);
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int>("DestinationClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsDelivered")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Message")
+                        .HasColumnType("text");
+
+                    b.Property<long?>("ServerId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SourceClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.HasKey("InboxMessageId");
+
+                    b.HasIndex("DestinationClientId");
+
+                    b.HasIndex("ServerId");
+
+                    b.HasIndex("SourceClientId");
+
+                    b.ToTable("InboxMessages");
+                });
+
             modelBuilder.Entity("Data.Models.Server.EFServer", b =>
                 {
                     b.Property<long>("ServerId")
@@ -986,6 +1058,40 @@ namespace Data.Migrations.Postgresql
                     b.ToTable("EFServers");
                 });
 
+            modelBuilder.Entity("Data.Models.Server.EFServerSnapshot", b =>
+                {
+                    b.Property<long>("ServerSnapshotId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn);
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("CapturedAt")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int>("ClientCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MapId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PeriodBlock")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("ServerId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("ServerSnapshotId");
+
+                    b.HasIndex("MapId");
+
+                    b.HasIndex("ServerId");
+
+                    b.ToTable("EFServerSnapshot");
+                });
+
             modelBuilder.Entity("Data.Models.Server.EFServerStatistics", b =>
                 {
                     b.Property<int>("StatisticId")
@@ -1063,6 +1169,21 @@ namespace Data.Migrations.Postgresql
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Data.Models.Client.EFClientConnectionHistory", b =>
+                {
+                    b.HasOne("Data.Models.Client.EFClient", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Data.Models.Server.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Data.Models.Client.EFClientKill", b =>
                 {
                     b.HasOne("Data.Models.Client.EFClient", "Attacker")
@@ -1307,6 +1428,40 @@ namespace Data.Migrations.Postgresql
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Data.Models.Misc.EFInboxMessage", b =>
+                {
+                    b.HasOne("Data.Models.Client.EFClient", "DestinationClient")
+                        .WithMany()
+                        .HasForeignKey("DestinationClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Data.Models.Server.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId");
+
+                    b.HasOne("Data.Models.Client.EFClient", "SourceClient")
+                        .WithMany()
+                        .HasForeignKey("SourceClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Data.Models.Server.EFServerSnapshot", b =>
+                {
+                    b.HasOne("Data.Models.Client.Stats.Reference.EFMap", "Map")
+                        .WithMany()
+                        .HasForeignKey("MapId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Data.Models.Server.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Data.Models.Server.EFServerStatistics", b =>
                 {
                     b.HasOne("Data.Models.Server.EFServer", "Server")

Data/Migrations/Sqlite/20210703141113_AddEFInboxMessage.cs

@@ -0,0 +1,69 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Data.Migrations.Sqlite
+{
+    public partial class AddEFInboxMessage : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "InboxMessages",
+                columns: table => new
+                {
+                    InboxMessageId = table.Column<int>(nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    CreatedDateTime = table.Column<DateTime>(nullable: false),
+                    UpdatedDateTime = table.Column<DateTime>(nullable: true),
+                    SourceClientId = table.Column<int>(nullable: false),
+                    DestinationClientId = table.Column<int>(nullable: false),
+                    ServerId = table.Column<long>(nullable: true),
+                    Message = table.Column<string>(nullable: true),
+                    IsDelivered = table.Column<bool>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_InboxMessages", x => x.InboxMessageId);
+                    table.ForeignKey(
+                        name: "FK_InboxMessages_EFClients_DestinationClientId",
+                        column: x => x.DestinationClientId,
+                        principalTable: "EFClients",
+                        principalColumn: "ClientId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_InboxMessages_EFServers_ServerId",
+                        column: x => x.ServerId,
+                        principalTable: "EFServers",
+                        principalColumn: "ServerId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_InboxMessages_EFClients_SourceClientId",
+                        column: x => x.SourceClientId,
+                        principalTable: "EFClients",
+                        principalColumn: "ClientId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_InboxMessages_DestinationClientId",
+                table: "InboxMessages",
+                column: "DestinationClientId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_InboxMessages_ServerId",
+                table: "InboxMessages",
+                column: "ServerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_InboxMessages_SourceClientId",
+                table: "InboxMessages",
+                column: "SourceClientId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "InboxMessages");
+        }
+    }
+}

Data/Migrations/Sqlite/20210826222412_AddEFServerSnapshot.cs

@@ -0,0 +1,57 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Data.Migrations.Sqlite
+{
+    public partial class AddEFServerSnapshot : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "EFServerSnapshot",
+                columns: table => new
+                {
+                    ServerSnapshotId = table.Column<long>(nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Active = table.Column<bool>(nullable: false),
+                    CapturedAt = table.Column<DateTime>(nullable: false),
+                    PeriodBlock = table.Column<int>(nullable: false),
+                    ServerId = table.Column<long>(nullable: false),
+                    MapId = table.Column<int>(nullable: false),
+                    ClientCount = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_EFServerSnapshot", x => x.ServerSnapshotId);
+                    table.ForeignKey(
+                        name: "FK_EFServerSnapshot_EFMaps_MapId",
+                        column: x => x.MapId,
+                        principalTable: "EFMaps",
+                        principalColumn: "MapId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_EFServerSnapshot_EFServers_ServerId",
+                        column: x => x.ServerId,
+                        principalTable: "EFServers",
+                        principalColumn: "ServerId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFServerSnapshot_MapId",
+                table: "EFServerSnapshot",
+                column: "MapId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFServerSnapshot_ServerId",
+                table: "EFServerSnapshot",
+                column: "ServerId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "EFServerSnapshot");
+        }
+    }
+}

Data/Migrations/Sqlite/20210831230904_AddEFClientConnectionHistory.cs

@@ -0,0 +1,61 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Data.Migrations.Sqlite
+{
+    public partial class AddEFClientConnectionHistory : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "EFClientConnectionHistory",
+                columns: table => new
+                {
+                    ClientConnectionId = table.Column<long>(nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    CreatedDateTime = table.Column<DateTime>(nullable: false),
+                    UpdatedDateTime = table.Column<DateTime>(nullable: true),
+                    ClientId = table.Column<int>(nullable: false),
+                    ServerId = table.Column<long>(nullable: false),
+                    ConnectionType = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_EFClientConnectionHistory", x => x.ClientConnectionId);
+                    table.ForeignKey(
+                        name: "FK_EFClientConnectionHistory_EFClients_ClientId",
+                        column: x => x.ClientId,
+                        principalTable: "EFClients",
+                        principalColumn: "ClientId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_EFClientConnectionHistory_EFServers_ServerId",
+                        column: x => x.ServerId,
+                        principalTable: "EFServers",
+                        principalColumn: "ServerId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientConnectionHistory_ClientId",
+                table: "EFClientConnectionHistory",
+                column: "ClientId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientConnectionHistory_CreatedDateTime",
+                table: "EFClientConnectionHistory",
+                column: "CreatedDateTime");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientConnectionHistory_ServerId",
+                table: "EFClientConnectionHistory",
+                column: "ServerId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "EFClientConnectionHistory");
+        }
+    }
+}

Data/Migrations/Sqlite/SqliteDatabaseContextModelSnapshot.cs

@@ -94,6 +94,38 @@ namespace Data.Migrations.Sqlite
                     b.ToTable("EFClients");
                 });
 
+            modelBuilder.Entity("Data.Models.Client.EFClientConnectionHistory", b =>
+                {
+                    b.Property<long>("ClientConnectionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ConnectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("ServerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("UpdatedDateTime")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ClientConnectionId");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("CreatedDateTime");
+
+                    b.HasIndex("ServerId");
+
+                    b.ToTable("EFClientConnectionHistory");
+                });
+
             modelBuilder.Entity("Data.Models.Client.EFClientKill", b =>
                 {
                     b.Property<long>("KillId")
@@ -934,6 +966,44 @@ namespace Data.Migrations.Sqlite
                     b.ToTable("EFPenalties");
                 });
 
+            modelBuilder.Entity("Data.Models.Misc.EFInboxMessage", b =>
+                {
+                    b.Property<int>("InboxMessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("DestinationClientId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsDelivered")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Message")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long?>("ServerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SourceClientId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("UpdatedDateTime")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("InboxMessageId");
+
+                    b.HasIndex("DestinationClientId");
+
+                    b.HasIndex("ServerId");
+
+                    b.HasIndex("SourceClientId");
+
+                    b.ToTable("InboxMessages");
+                });
+
             modelBuilder.Entity("Data.Models.Server.EFServer", b =>
                 {
                     b.Property<long>("ServerId")
@@ -962,6 +1032,39 @@ namespace Data.Migrations.Sqlite
                     b.ToTable("EFServers");
                 });
 
+            modelBuilder.Entity("Data.Models.Server.EFServerSnapshot", b =>
+                {
+                    b.Property<long>("ServerSnapshotId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CapturedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ClientCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MapId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PeriodBlock")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("ServerId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ServerSnapshotId");
+
+                    b.HasIndex("MapId");
+
+                    b.HasIndex("ServerId");
+
+                    b.ToTable("EFServerSnapshot");
+                });
+
             modelBuilder.Entity("Data.Models.Server.EFServerStatistics", b =>
                 {
                     b.Property<int>("StatisticId")
@@ -1037,6 +1140,21 @@ namespace Data.Migrations.Sqlite
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Data.Models.Client.EFClientConnectionHistory", b =>
+                {
+                    b.HasOne("Data.Models.Client.EFClient", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Data.Models.Server.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Data.Models.Client.EFClientKill", b =>
                 {
                     b.HasOne("Data.Models.Client.EFClient", "Attacker")
@@ -1281,6 +1399,40 @@ namespace Data.Migrations.Sqlite
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Data.Models.Misc.EFInboxMessage", b =>
+                {
+                    b.HasOne("Data.Models.Client.EFClient", "DestinationClient")
+                        .WithMany()
+                        .HasForeignKey("DestinationClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Data.Models.Server.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId");
+
+                    b.HasOne("Data.Models.Client.EFClient", "SourceClient")
+                        .WithMany()
+                        .HasForeignKey("SourceClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Data.Models.Server.EFServerSnapshot", b =>
+                {
+                    b.HasOne("Data.Models.Client.Stats.Reference.EFMap", "Map")
+                        .WithMany()
+                        .HasForeignKey("MapId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Data.Models.Server.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Data.Models.Server.EFServerStatistics", b =>
                 {
                     b.HasOne("Data.Models.Server.EFServer", "Server")

Data/Models/AuditFields.cs

@@ -1,9 +1,10 @@
 using System;
 using System.ComponentModel.DataAnnotations;
+using Data.Abstractions;
 
 namespace Stats.Models
 {
-    public class AuditFields
+    public class AuditFields : IAuditFields
     {
         [Required]
         public DateTime CreatedDateTime { get; set; } = DateTime.UtcNow;

Data/Models/Client/EFClientConnectionHistory.cs

@@ -0,0 +1,25 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using Data.Models.Server;
+using Stats.Models;
+
+namespace Data.Models.Client
+{
+    public class EFClientConnectionHistory : AuditFields
+    {
+        [Key] 
+        public long ClientConnectionId { get; set; }
+
+        public int ClientId { get; set; }
+        
+        [ForeignKey(nameof(ClientId))]
+        public EFClient Client { get;set; }
+        
+        public long ServerId { get; set; }
+        
+        [ForeignKey(nameof(ServerId))]
+        public EFServer Server { get;set; }
+        
+        public Reference.ConnectionType ConnectionType { get; set; }
+    }
+}

Data/Models/Misc/EFInboxMessage.cs

@@ -0,0 +1,35 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using Data.Models.Client;
+using Data.Models.Server;
+using Stats.Models;
+
+namespace Data.Models.Misc
+{
+    public class EFInboxMessage : AuditFields
+    {
+        [Key]
+        public int InboxMessageId { get; set; }
+        
+        [Required]
+        public int SourceClientId { get; set; }
+        
+        [ForeignKey(nameof(SourceClientId))]
+        public EFClient SourceClient { get; set; }
+        
+        [Required]
+        public int DestinationClientId { get; set; }
+        
+        [ForeignKey(nameof(DestinationClientId))]
+        public EFClient DestinationClient { get; set; }
+        
+        public long? ServerId { get; set; }
+        
+        [ForeignKey(nameof(ServerId))]
+        public EFServer Server { get; set; }
+
+        public string Message { get; set; }
+        
+        public bool IsDelivered { get; set; }
+    }
+}

Data/Models/Reference.cs

@@ -17,5 +17,11 @@
             SHG1 = 9,
             CSGO = 10
         }
+        
+        public enum ConnectionType
+        {
+            Connect,
+            Disconnect
+        }
     }
 }

Data/Models/Server/EFServerSnapshot.cs

@@ -0,0 +1,36 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using Data.Models.Client.Stats.Reference;
+
+namespace Data.Models.Server
+{
+    public class EFServerSnapshot : SharedEntity
+    {
+        [Key]
+        public long ServerSnapshotId { get; set; }
+        
+        public DateTime CapturedAt { get; set; }
+        
+        /// <summary>
+        /// Specifies at which time block during a period the snapshot occured
+        /// | 1:00      | 1:05      | 1:10      |
+        /// | 5 minutes | 5 minutes | 5 minutes |
+        /// | 0         | 1         | 2         | 
+        /// </summary>
+        public int PeriodBlock { get; set; }
+
+        [Required]
+        public long ServerId { get; set; }
+        
+        [ForeignKey(nameof(ServerId))]
+        public EFServer Server { get; set; }
+        
+        public int MapId { get; set; }
+        
+        [ForeignKey(nameof(MapId))]
+        public EFMap Map { get; set; }
+        
+        public int ClientCount { get; set; }
+    }
+}

GameFiles/IW5/storage/iw5/scripts/README.MD

@@ -0,0 +1,23 @@
+# IW5
+
+This expands IW4M-Admins's Anti-cheat to Plutonium IW5
+## Installation
+
+Add ``_customcallbacks.gsc`` into the scripts folder. (%localappdata%\Plutonium\storage\iw5\scripts)
+
+For more info check out Chase's [how-to guide](https://forum.plutonium.pw/topic/10738/tutorial-loading-custom-gsc-scripts).
+
+You need to add this to you ``StatsPluginSettings.json`` found in your IW4M-Admin configuration folder.
+
+```
+      "IW5": {
+        "Recoil": [
+          "iw5_1887_mp.*",
+          "turret_minigun_mp"
+        ],
+        "Button": [
+          ".*akimbo.*"
+        ]
+      }
+```
+[Example](https://imgur.com/Ji9AafI)

GameFiles/IW5/storage/iw5/scripts/_customcallbacks.gsc

@@ -0,0 +1,249 @@
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+#include common_scripts\utility;
+
+init()
+{
+	Print("IW4MADMIN Anti-Cheat Loaded");
+	SetDvarIfUninitialized( "sv_customcallbacks", true );
+	SetDvarIfUninitialized( "sv_framewaittime", 0.05 );
+	SetDvarIfUninitialized( "sv_additionalwaittime", 0.1 );
+	SetDvarIfUninitialized( "sv_maxstoredframes", 12 );
+	SetDvarIfUninitialized( "sv_printradarupdates", 0 );
+	SetDvarIfUninitialized( "sv_printradar_updateinterval", 500 );
+	SetDvarIfUninitialized( "sv_iw4madmin_url", "http://127.0.0.1:1624" );
+	
+	level thread onPlayerConnect();
+	if (getDvarInt("sv_printradarupdates") == 1)
+	{
+		level thread runRadarUpdates();
+	}
+	
+	level waittill( "prematch_over" );
+	level.callbackPlayerKilled = ::Callback_PlayerKilled;
+	level.callbackPlayerDamage = ::Callback_PlayerDamage;
+	level.callbackPlayerDisconnect = ::Callback_PlayerDisconnect;
+}
+
+onPlayerConnect( player )
+{
+	for( ;; )
+	{
+		level waittill( "connected", player );	
+		player setClientDvar("cl_demo_enabled", 1);
+		player thread waitForFrameThread();
+		player thread waitForAttack();
+	}
+}
+
+waitForAttack()
+{
+	self endon( "disconnect" );
+	
+	self.lastAttackTime = 0;
+	
+	for( ;; )
+	{
+		self notifyOnPlayerCommand( "player_shot", "+attack" );
+		self waittill( "player_shot" );
+		
+		self.lastAttackTime = getTime();
+	}
+}
+
+runRadarUpdates()
+{
+	interval = int(getDvar("sv_printradar_updateinterval"));
+
+	for ( ;; )
+	{
+		for ( i = 0; i <= 17; i++ )
+		{
+			player = level.players[i];
+
+			if ( isDefined( player ) )
+			{
+				payload = player.guid + ";" + player.origin + ";" + player getPlayerAngles() + ";" + player.team + ";" + player.kills + ";" + player.deaths + ";" + player.score + ";" + player GetCurrentWeapon() + ";" + player.health + ";" + isAlive(player) + ";" + player.timePlayed["total"];
+				logPrint( "LiveRadar;" + payload + "\n" );
+			}	
+		}
+
+		wait( interval / 1000 );
+	}	
+}
+
+hitLocationToBone( hitloc )
+{
+	switch( hitloc )
+	{
+		case "helmet":
+			return "j_helmet";
+		case "head":
+			return "j_head";
+		case "neck":
+			return "j_neck";
+		case "torso_upper":
+			return "j_spineupper";
+		case "torso_lower":
+			return "j_spinelower";
+		case "right_arm_upper":
+			return "j_shoulder_ri";
+		case "left_arm_upper":
+			return "j_shoulder_le";
+		case "right_arm_lower":
+			return "j_elbow_ri";
+		case "left_arm_lower":
+			return "j_elbow_le";
+		case "right_hand":
+			return "j_wrist_ri";
+		case "left_hand":
+			return "j_wrist_le";
+		case "right_leg_upper":
+			return "j_hip_ri";
+		case "left_leg_upper":
+			return "j_hip_le";
+		case "right_leg_lower":
+			return "j_knee_ri";
+		case "left_leg_lower":
+			return "j_knee_le";
+		case "right_foot":
+			return "j_ankle_ri";
+		case "left_foot":
+			return "j_ankle_le";
+		default:
+			return "tag_origin";
+	}
+}
+
+waitForFrameThread()
+{
+	self endon( "disconnect" );
+	
+	self.currentAnglePosition = 0;
+	self.anglePositions = [];
+
+	for (i = 0; i < getDvarInt( "sv_maxstoredframes" ); i++)
+	{
+		self.anglePositions[i] = self getPlayerAngles();
+	}
+		
+	for( ;; )
+	{
+		self.anglePositions[self.currentAnglePosition] = self getPlayerAngles();
+		wait( getDvarFloat( "sv_framewaittime" ) );	
+		self.currentAnglePosition = (self.currentAnglePosition + 1) % getDvarInt( "sv_maxstoredframes" );
+	}
+}
+
+waitForAdditionalAngles( logString, beforeFrameCount, afterFrameCount )
+{
+	currentIndex = self.currentAnglePosition;
+	wait( 0.05 * afterFrameCount );
+	
+	self.angleSnapshot = [];
+	
+	for( j = 0; j < self.anglePositions.size; j++ )
+	{
+		self.angleSnapshot[j] = self.anglePositions[j];
+	}
+
+	anglesStr = "";
+	collectedFrames = 0;
+	i = currentIndex - beforeFrameCount;
+
+	while (collectedFrames < beforeFrameCount)
+	{
+		fixedIndex = i;
+		if (i < 0)
+		{
+			fixedIndex = self.angleSnapshot.size - abs(i);
+		}
+		anglesStr += self.angleSnapshot[int(fixedIndex)] + ":";
+		collectedFrames++;
+		i++;
+	}
+
+	if (i == currentIndex)
+	{
+		anglesStr += self.angleSnapshot[i] + ":";
+		i++;
+	}
+
+	collectedFrames = 0;
+
+	while (collectedFrames < afterFrameCount)
+	{
+		fixedIndex = i;
+		if (i > self.angleSnapshot.size - 1)
+		{
+			fixedIndex = i % self.angleSnapshot.size;
+		}
+		anglesStr += self.angleSnapshot[int(fixedIndex)] + ":";
+		collectedFrames++;
+		i++;
+	}
+
+	lastAttack = int(getTime()) - int(self.lastAttackTime);
+	isAlive = isAlive(self);
+
+	logPrint(logString + ";" + anglesStr + ";" + isAlive + ";" + lastAttack + "\n" ); 
+}
+
+vectorScale( vector, scale )
+{
+	return ( vector[0] * scale, vector[1] * scale, vector[2] * scale );
+}
+
+Process_Hit( type, attacker, sHitLoc, sMeansOfDeath, iDamage, sWeapon )
+{
+	if (sMeansOfDeath == "MOD_FALLING" || !isPlayer(attacker))
+	{
+		return;
+	}
+
+	victim = self;
+	_attacker = attacker;
+
+	if ( !isPlayer( attacker ) && isDefined( attacker.owner ) )
+	{
+		_attacker = attacker.owner;
+	}
+
+	else if( !isPlayer( attacker ) && sMeansOfDeath == "MOD_FALLING" )
+	{
+		_attacker = victim;
+	}
+	
+	location = victim GetTagOrigin( hitLocationToBone( sHitLoc ) );
+	isKillstreakKill = !isPlayer( attacker ) || isKillstreakWeapon( sWeapon );
+
+	logLine = "Script" + type + ";" + _attacker.guid + ";" + victim.guid + ";" + _attacker GetTagOrigin("tag_eye") + ";" + location + ";" + iDamage + ";" + sWeapon + ";" + sHitLoc + ";" + sMeansOfDeath + ";" + _attacker getPlayerAngles() + ";" + int(gettime()) + ";" + isKillstreakKill + ";" +  _attacker playerADS() + ";0;0";
+	attacker thread waitForAdditionalAngles( logLine, 2, 2 );
+}
+
+Callback_PlayerDamage( eInflictor, attacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, psOffsetTime )
+{
+	if ( self.health - iDamage > 0 )
+	{
+		isFriendlyFire = level.teamBased && isDefined( attacker ) && ( self != attacker ) && isDefined( attacker.team ) && ( self.pers[ "team" ] == attacker.team );
+		
+		if ( !isFriendlyFire )
+		{
+			self Process_Hit( "Damage", attacker, sHitLoc, sMeansOfDeath, iDamage, sWeapon );
+		}
+	}
+
+	self maps\mp\gametypes\_damage::Callback_PlayerDamage( eInflictor, attacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, psOffsetTime );
+}
+
+Callback_PlayerKilled( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration )
+{
+	Process_Hit( "Kill", attacker, sHitLoc, sMeansOfDeath, iDamage, sWeapon );
+	self maps\mp\gametypes\_damage::Callback_PlayerKilled( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration );
+}
+
+Callback_PlayerDisconnect()
+{
+	level notify( "disconnected", self );
+	self maps\mp\gametypes\_playerlogic::Callback_PlayerDisconnect();
+}

GameFiles/PT6/README.MD

@@ -0,0 +1,35 @@
+# T6
+
+This brings IW4M-Admins's Anti-cheat to Plutonium T6
+The following limitations are known:
+* Can't get the recoil from weapons fire; you have to disable this detection type manually.
+* in extreme cases it can produce false positives for Snap and Offset detection.
+
+## Installation
+
+
+Move `_customcallbacks.gsc` to `%localappdata%\Plutonium\storage\t6\scripts\mp\`
+
+Add this to the WeaponNameParserConfigurations List in the StatsPluginSettings.json file:
+
+```
+    {
+      "Game": "T6",
+      "Delimiters": [
+        "_",
+        "+"
+      ],
+      "WeaponSuffix": "mp",
+      "WeaponPrefix": null
+    }
+```
+
+Now create the following entry for __EVERY__ T6 server you are using this on in the ServerDetectionTypes list:
+
+```
+    "1270014976": [
+        "Offset",
+        "Strain",
+        "Snap"
+      ]
+```

GameFiles/PT6/storage/t6/scripts/mp/_customcallbacks.gsc.src

@@ -3,24 +3,6 @@
 #include common_scripts\utility;
 
 init()
-{
-	level.clientid = 0;
-	level thread onplayerconnect();
-    level thread IW4MA_init();
-}
-
-onplayerconnect()
-{
-	for ( ;; )
-	{
-		level waittill( "connecting", player );
-		player.clientid = level.clientid;
-		level.clientid++;
-	}
-}
-
-
-IW4MA_init()
 {
 	SetDvarIfUninitialized( "sv_customcallbacks", true );
 	SetDvarIfUninitialized( "sv_framewaittime", 0.05 );
@@ -29,53 +11,52 @@ IW4MA_init()
 	SetDvarIfUninitialized( "sv_printradarupdates", 0 );
 	SetDvarIfUninitialized( "sv_printradar_updateinterval", 500 );
 	SetDvarIfUninitialized( "sv_iw4madmin_url", "http://127.0.0.1:1624" );
-	
-	level thread IW4MA_onPlayerConnect();
+
+	level thread onPlayerConnect();
 	if (getDvarInt("sv_printradarupdates") == 1)
 	{
 		level thread runRadarUpdates();
 	}
-	
+
 	level waittill( "prematch_over" );
 	level.callbackPlayerKilled = ::Callback_PlayerKilled;
 	level.callbackPlayerDamage = ::Callback_PlayerDamage;
 	level.callbackPlayerDisconnect = ::Callback_PlayerDisconnect;
 }
 
-//Does not exist in T6
+//It's called slightly different in T6
+//set_dvar_if_unset(dvar, val, reset)
 SetDvarIfUninitialized(dvar, val)
 {
-	curval = getDvar(dvar);
-	if (curval == "")
-		SetDvar(dvar,val);
+	set_dvar_if_unset(dvar,val);
 }
 
-IW4MA_onPlayerConnect( player )
+onPlayerConnect( player )
 {
 	for( ;; )
 	{
 		level waittill( "connected", player );	
 		player thread waitForFrameThread();
-		//player thread waitForAttack();
+		player thread waitForAttack();
 	}
 }
 
 
-//Does not work in T6
-/*waitForAttack()
+//Got added to T6 on April 2020
+waitForAttack()
 {
 	self endon( "disconnect" );
-	
+
 	self.lastAttackTime = 0;
-	
+
 	for( ;; )
 	{
 		self notifyOnPlayerCommand( "player_shot", "+attack" );
 		self waittill( "player_shot" );
-		
+
 		self.lastAttackTime = getTime();
 	}
-}*/
+}
 
 runRadarUpdates()
 {
@@ -95,7 +76,7 @@ runRadarUpdates()
 		}
 
 		wait( interval / 1000 );
-	}	
+	}
 }
 
 hitLocationToBone( hitloc )
@@ -144,7 +125,7 @@ hitLocationToBone( hitloc )
 waitForFrameThread()
 {
 	self endon( "disconnect" );
-	
+
 	self.currentAnglePosition = 0;
 	self.anglePositions = [];
 
@@ -152,7 +133,7 @@ waitForFrameThread()
 	{
 		self.anglePositions[i] = self getPlayerAngles();
 	}
-		
+
 	for( ;; )
 	{
 		self.anglePositions[self.currentAnglePosition] = self getPlayerAngles();
@@ -165,9 +146,9 @@ waitForAdditionalAngles( logString, beforeFrameCount, afterFrameCount )
 {
 	currentIndex = self.currentAnglePosition;
 	wait( 0.05 * afterFrameCount );
-	
+
 	self.angleSnapshot = [];
-	
+
 	for( j = 0; j < self.anglePositions.size; j++ )
 	{
 		self.angleSnapshot[j] = self.anglePositions[j];
@@ -209,7 +190,7 @@ waitForAdditionalAngles( logString, beforeFrameCount, afterFrameCount )
 		i++;
 	}
 
-	lastAttack = 100;//int(getTime()) - int(self.lastAttackTime);
+	lastAttack = int(getTime()) - int(self.lastAttackTime);
 	isAlive = isAlive(self);
 
 	logPrint(logString + ";" + anglesStr + ";" + isAlive + ";" + lastAttack + "\n" ); 
@@ -261,7 +242,7 @@ Callback_PlayerDamage( eInflictor, attacker, iDamage, iDFlags, sMeansOfDeath, sW
 	{
 		return;
 	}
-		
+
 	if ( self.health - iDamage > 0 )
 	{
 		self Process_Hit( "Damage", attacker, sHitLoc, sMeansOfDeath, iDamage, sWeapon );

Integrations/Cod/CodRConConnection.cs

@@ -31,13 +31,15 @@ namespace Integrations.Cod
         private IRConParserConfiguration config;
         private readonly ILogger _log;
         private readonly Encoding _gameEncoding;
+        private readonly int _retryAttempts;
 
-        public CodRConConnection(string ipAddress, int port, string password, ILogger<CodRConConnection> log, Encoding gameEncoding)
+        public CodRConConnection(IPEndPoint ipEndpoint, string password, ILogger<CodRConConnection> log, Encoding gameEncoding, int retryAttempts)
         {
-            Endpoint = new IPEndPoint(IPAddress.Parse(ipAddress), port);
-            _gameEncoding = gameEncoding;
             RConPassword = password;
+            _gameEncoding = gameEncoding;
             _log = log;
+            Endpoint = ipEndpoint;
+            _retryAttempts = retryAttempts;
         }
 
         public void SetConfiguration(IRConParser parser)
@@ -137,7 +139,7 @@ namespace Integrations.Cod
                     _log.LogInformation(
                         "Retrying RCon message ({connectionAttempts}/{allowedConnectionFailures} attempts) with parameters {payload}", 
                         connectionState.ConnectionAttempts, 
-                        StaticHelpers.AllowedConnectionFails, parameters);
+                        _retryAttempts, parameters);
                 }
             }
             using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)
@@ -155,7 +157,7 @@ namespace Integrations.Cod
                 bool exceptionCaught = false;
 
                 _log.LogDebug("Sending {payloadLength} bytes to [{endpoint}] ({connectionAttempts}/{allowedConnectionFailures})",
-                payload.Length, Endpoint, connectionState.ConnectionAttempts, StaticHelpers.AllowedConnectionFails);
+                payload.Length, Endpoint, connectionState.ConnectionAttempts, _retryAttempts);
 
                 try
                 {
@@ -173,7 +175,7 @@ namespace Integrations.Cod
                 catch
                 {
                     // we want to retry with a delay
-                    if (connectionState.ConnectionAttempts < StaticHelpers.AllowedConnectionFails)
+                    if (connectionState.ConnectionAttempts < _retryAttempts)
                     {
                         exceptionCaught = true;
                         await Task.Delay(StaticHelpers.SocketTimeout(connectionState.ConnectionAttempts));

Integrations/Source/Interfaces/IRConClientFactory.cs

@@ -1,9 +1,10 @@
-using RconSharp;
+using System.Net;
+using RconSharp;
 
 namespace Integrations.Source.Interfaces
 {
     public interface IRConClientFactory
     {
-        RconClient CreateClient(string hostname, int port);
+        RconClient CreateClient(IPEndPoint ipEndPoint);
     }
 }

Integrations/Source/RConClientFactory.cs

@@ -1,13 +1,14 @@
-using Integrations.Source.Interfaces;
+using System.Net;
+using Integrations.Source.Interfaces;
 using RconSharp;
 
 namespace Integrations.Source
 {
     public class RConClientFactory : IRConClientFactory
     {
-        public RconClient CreateClient(string hostname, int port)
+        public RconClient CreateClient(IPEndPoint ipEndPoint)
         {
-            return RconClient.Create(hostname, port);
+            return RconClient.Create(ipEndPoint.Address.ToString(), ipEndPoint.Port);
         }
     }
 }

Integrations/Source/SourceRConConnection.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using System.Net;
 using System.Net.Sockets;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,8 +21,7 @@ namespace Integrations.Source
     {
         private readonly ILogger _logger;
         private readonly string _password;
-        private readonly string _hostname;
-        private readonly int _port;
+        private readonly IPEndPoint _ipEndPoint;
         private readonly IRConClientFactory _rconClientFactory;
         private readonly SemaphoreSlim _activeQuery;
 
@@ -34,13 +34,12 @@ namespace Integrations.Source
         private bool _needNewSocket = true;
 
         public SourceRConConnection(ILogger<SourceRConConnection> logger, IRConClientFactory rconClientFactory,
-            string hostname, int port, string password)
+            IPEndPoint ipEndPoint, string password)
         {
             _rconClientFactory = rconClientFactory;
             _password = password;
-            _hostname = hostname;
-            _port = port;
             _logger = logger;
+            _ipEndPoint = ipEndPoint;
             _activeQuery = new SemaphoreSlim(1, 1);
         }
 
@@ -67,12 +66,12 @@ namespace Integrations.Source
                         // ignored
                     }
 
-                    _rconClient = _rconClientFactory.CreateClient(_hostname, _port);
+                    _rconClient = _rconClientFactory.CreateClient(_ipEndPoint);
                     _authenticated = false;
                     _needNewSocket = false;
                 }
 
-                using (LogContext.PushProperty("Server", $"{_hostname}:{_port}"))
+                using (LogContext.PushProperty("Server", _ipEndPoint.ToString()))
                 {
                     _logger.LogDebug("Connecting to RCon socket");
                 }
@@ -90,7 +89,7 @@ namespace Integrations.Source
                 parameters = parameters.ReplaceUnfriendlyCharacters();
                 parameters = parameters.StripColors();
 
-                using (LogContext.PushProperty("Server", $"{_hostname}:{_port}"))
+                using (LogContext.PushProperty("Server", _ipEndPoint.ToString()))
                 {
                     _logger.LogDebug("Sending query {Type} with parameters \"{Parameters}\"", type, parameters);
                 }
@@ -98,7 +97,7 @@ namespace Integrations.Source
                 var response = await _rconClient.ExecuteCommandAsync(parameters, multiPacket)
                     .WithTimeout(ConnectionTimeout);
 
-                using (LogContext.PushProperty("Server", $"{_hostname}:{_port}"))
+                using (LogContext.PushProperty("Server", $"{_ipEndPoint}"))
                 {
                     _logger.LogDebug("Received RCon response {Response}", response);
                 }
@@ -115,7 +114,7 @@ namespace Integrations.Source
 
             catch (SocketException ex)
             {
-                using (LogContext.PushProperty("Server", $"{_hostname}:{_port}"))
+                using (LogContext.PushProperty("Server", _ipEndPoint.ToString()))
                 {
                     _logger.LogError(ex, "Socket exception encountered while attempting to communicate with server");
                 }
@@ -128,7 +127,7 @@ namespace Integrations.Source
             catch (Exception ex) when (ex.GetType() != typeof(NetworkException) &&
                                        ex.GetType() != typeof(ServerException))
             {
-                using (LogContext.PushProperty("Server", $"{_hostname}:{_port}"))
+                using (LogContext.PushProperty("Server", _ipEndPoint.ToString()))
                 {
                     _logger.LogError(ex, "Could not execute RCon query {Parameters}", parameters);
                 }
@@ -160,7 +159,7 @@ namespace Integrations.Source
         {
             if (!_authenticated)
             {
-                using (LogContext.PushProperty("Server", $"{_hostname}:{_port}"))
+                using (LogContext.PushProperty("Server", _ipEndPoint.ToString()))
                 {
                     _logger.LogDebug("Authenticating to RCon socket");
                 }
@@ -170,7 +169,7 @@ namespace Integrations.Source
 
                 if (!_authenticated)
                 {
-                    using (LogContext.PushProperty("Server", $"{_hostname}:{_port}"))
+                    using (LogContext.PushProperty("Server", _ipEndPoint.ToString()))
                     {
                         _logger.LogError("Could not login to server");
                     }

Plugins/AutomessageFeed/AutomessageFeed.csproj

@@ -10,7 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SyndicationFeed.ReaderWriter" Version="1.0.2" />
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.6.29.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.8.31.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Plugins/IW4ScriptCommands/IW4ScriptCommands.csproj

@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.6.29.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.8.31.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Plugins/LiveRadar/Controllers/RadarController.cs

@@ -5,6 +5,7 @@ using SharedLibraryCore;
 using SharedLibraryCore.Dtos;
 using SharedLibraryCore.Interfaces;
 using System.Linq;
+using Microsoft.AspNetCore.Http;
 
 namespace LiveRadar.Web.Controllers
 {
@@ -48,16 +49,22 @@ namespace LiveRadar.Web.Controllers
         public IActionResult Map(long? serverId = null)
         {
             var server = serverId == null ? _manager.GetServers().FirstOrDefault() : _manager.GetServers().FirstOrDefault(_server => _server.EndPoint == serverId);
+            
+            if (server == null)
+            {
+                return NotFound();
+            }
+            
             var map = _config.Maps.FirstOrDefault(_map => _map.Name == server.CurrentMap.Name);
 
-            if (map != null)
+            if (map == null)
             {
-                map.Alias = server.CurrentMap.Alias;
-                return Json(map);
+                // occurs if we don't recognize the map
+                return StatusCode(StatusCodes.Status422UnprocessableEntity);
             }
-
-            // occurs if we don't recognize the map
-            return StatusCode(500);
+            
+            map.Alias = server.CurrentMap.Alias;
+            return Json(map);
         }
 
         [HttpGet]

Plugins/LiveRadar/LiveRadar.csproj

@@ -23,7 +23,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.6.29.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.8.31.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Plugins/Login/Login.csproj

@@ -19,7 +19,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.6.29.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.8.31.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Plugins/ProfanityDeterment/ProfanityDeterment.csproj

@@ -16,7 +16,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.6.29.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.8.31.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Plugins/ScriptPlugins/ParserCSGO.js

@@ -3,7 +3,7 @@ let eventParser;
 
 const plugin = {
     author: 'RaidMax',
-    version: 0.2,
+    version: 0.3,
     name: 'CS:GO Parser',
     engine: 'Source',
     isParser: true,
@@ -46,6 +46,7 @@ const plugin = {
         rconParser.Configuration.DefaultDvarValues.Add('version', this.engine);
         rconParser.Configuration.DefaultDvarValues.Add('fs_basepath', '');
         rconParser.Configuration.DefaultDvarValues.Add('fs_basegame', '');
+        rconParser.Configuration.DefaultDvarValues.Add('fs_homepath', '');
         rconParser.Configuration.DefaultDvarValues.Add('g_log', '');
         rconParser.Configuration.DefaultDvarValues.Add('net_ip', 'localhost');
         
@@ -66,14 +67,14 @@ const plugin = {
         rconParser.Configuration.CommandPrefixes.Say            = 'say {0}';
         rconParser.Configuration.CommandPrefixes.Tell           = 'say [{0}] {1}'; // no tell exists in vanilla
         
-        eventParser.Configuration.Say.Pattern = '^"(.+)<(\\d+)><(.+)><(.*?)>" say "(.*)"$';
+        eventParser.Configuration.Say.Pattern = '^"(.+)<(\\d+)><(.+)><(.*?)>" (?:say|say_team) "(.*)"$';
         eventParser.Configuration.Say.AddMapping(5, 1);
         eventParser.Configuration.Say.AddMapping(3, 2);
         eventParser.Configuration.Say.AddMapping(1, 3);
         eventParser.Configuration.Say.AddMapping(7, 4);
         eventParser.Configuration.Say.AddMapping(13, 5);
         
-        eventParser.Configuration.Kill.Pattern = '"(.+)<(\\d+)><(.+)><(.*)>" \\[-?\\d+ -?\\d+ -?\\d+\\] killed "(.+)<(\\d+)><(.+)><(.*)>" \\[-?\\d+ -?\\d+ -?\\d+\\] with "(\\S*)"(.*)$';
+        eventParser.Configuration.Kill.Pattern = '^"(.+)<(\\d+)><(.+)><(.*)>" \\[-?\\d+ -?\\d+ -?\\d+\\] killed "(.+)<(\\d+)><(.+)><(.*)>" \\[-?\\d+ -?\\d+ -?\\d+\\] with "(\\S*)" *(?:\\((\\w+)((?: ).+)?\\))?$';
         eventParser.Configuration.Kill.AddMapping(5, 1);
         eventParser.Configuration.Kill.AddMapping(3, 2);
         eventParser.Configuration.Kill.AddMapping(1, 3);
@@ -83,6 +84,7 @@ const plugin = {
         eventParser.Configuration.Kill.AddMapping(2, 7);
         eventParser.Configuration.Kill.AddMapping(8, 8);
         eventParser.Configuration.Kill.AddMapping(9, 9);
+        eventParser.Configuration.Kill.AddMapping(12, 10);
         
         eventParser.Configuration.Time.Pattern = '^L [01]\\d/[0-3]\\d/\\d+ - [0-2]\\d:[0-5]\\d:[0-5]\\d:';
 

Plugins/ScriptPlugins/ParserCSGOSM.js

@@ -3,7 +3,7 @@ let eventParser;
 
 const plugin = {
     author: 'RaidMax',
-    version: 0.2,
+    version: 0.3,
     name: 'CS:GO (SourceMod) Parser',
     engine: 'Source',
     isParser: true,
@@ -46,6 +46,7 @@ const plugin = {
         rconParser.Configuration.DefaultDvarValues.Add('version', this.engine);
         rconParser.Configuration.DefaultDvarValues.Add('fs_basepath', '');
         rconParser.Configuration.DefaultDvarValues.Add('fs_basegame', '');
+        rconParser.Configuration.DefaultDvarValues.Add('fs_homepath', '');
         rconParser.Configuration.DefaultDvarValues.Add('g_log', '');
         rconParser.Configuration.DefaultDvarValues.Add('net_ip', 'localhost');
 
@@ -66,14 +67,14 @@ const plugin = {
         rconParser.Configuration.CommandPrefixes.Say            = 'sm_say {0}';
         rconParser.Configuration.CommandPrefixes.Tell           = 'sm_psay #{0} "{1}"';
 
-        eventParser.Configuration.Say.Pattern = '^"(.+)<(\\d+)><(.+)><(.*?)>" say "(.*)"$';
+        eventParser.Configuration.Say.Pattern = '^"(.+)<(\\d+)><(.+)><(.*?)>" (?:say|say_team) "(.*)"$';
         eventParser.Configuration.Say.AddMapping(5, 1);
         eventParser.Configuration.Say.AddMapping(3, 2);
         eventParser.Configuration.Say.AddMapping(1, 3);
         eventParser.Configuration.Say.AddMapping(7, 4);
         eventParser.Configuration.Say.AddMapping(13, 5);
 
-        eventParser.Configuration.Kill.Pattern = '"(.+)<(\\d+)><(.+)><(.*)>" \\[-?\\d+ -?\\d+ -?\\d+\\] killed "(.+)<(\\d+)><(.+)><(.*)>" \\[-?\\d+ -?\\d+ -?\\d+\\] with "(\\S*)"(.*)$';
+        eventParser.Configuration.Kill.Pattern = '^"(.+)<(\\d+)><(.+)><(.*)>" \\[-?\\d+ -?\\d+ -?\\d+\\] killed "(.+)<(\\d+)><(.+)><(.*)>" \\[-?\\d+ -?\\d+ -?\\d+\\] with "(\\S*)" *(?:\\((\\w+)((?: ).+)?\\))?$';
         eventParser.Configuration.Kill.AddMapping(5, 1);
         eventParser.Configuration.Kill.AddMapping(3, 2);
         eventParser.Configuration.Kill.AddMapping(1, 3);
@@ -83,6 +84,7 @@ const plugin = {
         eventParser.Configuration.Kill.AddMapping(2, 7);
         eventParser.Configuration.Kill.AddMapping(8, 8);
         eventParser.Configuration.Kill.AddMapping(9, 9);
+        eventParser.Configuration.Kill.AddMapping(12, 10);
 
         eventParser.Configuration.Time.Pattern = '^L [01]\\d/[0-3]\\d/\\d+ - [0-2]\\d:[0-5]\\d:[0-5]\\d:';
 

Plugins/ScriptPlugins/ParserIW6x.js

@@ -2,8 +2,8 @@ var rconParser;
 var eventParser;
 
 var plugin = {
-    author: 'Xerxes, RaidMax',
-    version: 0.2,
+    author: 'Xerxes, RaidMax, st0rm',
+    version: 0.3,
     name: 'IW6x Parser',
     isParser: true,
 
@@ -27,14 +27,12 @@ var plugin = {
         rconParser.Configuration.Status.AddMapping(102, 4);
         rconParser.Configuration.Status.AddMapping(103, 5);
         rconParser.Configuration.Status.AddMapping(104, 6);
-        rconParser.Configuration.DefaultDvarValues.Add('g_log', 'games_mp.log'); // todo: remove this once proper log support is implemented
-        rconParser.Configuration.DefaultDvarValues.Add('g_logsync', '1'); // todo: remove this once proper log support is implemented
 
         rconParser.Version = 'IW6 MP 3.15 build 2 Sat Sep 14 2013 03:58:30PM win64';
         rconParser.GameName = 4; // IW6
         eventParser.Version = 'IW6 MP 3.15 build 2 Sat Sep 14 2013 03:58:30PM win64';
         eventParser.GameName = 4; // IW6
-        eventParser.Configuration.GameDirectory = 'iw6x';
+        eventParser.Configuration.GameDirectory = '';
     },
 
     onUnloadAsync: function () {

Plugins/ScriptPlugins/ParserPIW5.js

@@ -3,7 +3,7 @@ var eventParser;
 
 var plugin = {
     author: 'RaidMax',
-    version: 0.8,
+    version: 0.9,
     name: 'Plutonium IW5 Parser',
     isParser: true,
 
@@ -34,6 +34,8 @@ var plugin = {
         rconParser.Configuration.Status.AddMapping(102, 4);
         rconParser.Configuration.Status.AddMapping(103, 5);
         rconParser.Configuration.Status.AddMapping(104, 6);
+        // basegame should not contain an absolute directory, but alas...
+        rconParser.Configuration.OverrideDvarNameMapping.Add('fs_homepath', 'fs_basegame');
 
         rconParser.IsOneLog = true;
         rconParser.Version = 'IW5 MP 1.9 build 388110 Fri Sep 14 00:04:28 2012 win-x86';

Plugins/ScriptPlugins/ParserPT6.js

@@ -3,7 +3,7 @@ var eventParser;
 
 var plugin = {
     author: 'RaidMax, Xerxes',
-    version: 0.10,
+    version: 1.0,
     name: 'Plutonium T6 Parser',
     isParser: true,
 
@@ -37,7 +37,7 @@ var plugin = {
         rconParser.Configuration.Status.AddMapping(104, 5);
         rconParser.Configuration.Status.AddMapping(105, 6);
         
-        eventParser.Configuration.GameDirectory = 't6';
+        eventParser.Configuration.GameDirectory = '';
         eventParser.Configuration.GuidNumberStyle = 7; // Integer
 
         rconParser.Version = 'Call of Duty Multiplayer - Ship COD_T6_S MP build 1.0.44 CL(1759941) CODPCAB2 CEG Fri May 9 19:19:19 2014 win-x86 813e66d5';

Plugins/ScriptPlugins/ParserT7.js

@@ -33,6 +33,7 @@ var plugin = {
         rconParser.Configuration.DefaultDvarValues.Add('g_gametype', '');
         rconParser.Configuration.DefaultDvarValues.Add('fs_basepath', '');
         rconParser.Configuration.DefaultDvarValues.Add('fs_basegame', '');
+        rconParser.Configuration.DefaultDvarValues.Add('fs_homepath', '');
         rconParser.Configuration.DefaultDvarValues.Add('fs_game', '');
 
         rconParser.Configuration.Status.AddMapping(105, 6); // ip address

Plugins/Stats/Cheat/Detection.cs

@@ -529,6 +529,7 @@ namespace IW4MAdmin.Plugins.Stats.Cheat
                 StrainAngleBetween = Strain.LastDistance,
                 TimeSinceLastEvent = (int)Strain.LastDeltaTime,
                 WeaponReference = hit.WeaponReference,
+                HitLocationReference = hit.GetAdditionalProperty<string>("HitLocationReference"),
                 SessionSnapHits = sessionSnapHits,
                 SessionAverageSnapValue = sessionAverageSnapAmount
             };

Plugins/Stats/Client/Abstractions/IHitInfoBuilder.cs

@@ -1,10 +1,11 @@
 using IW4MAdmin.Plugins.Stats.Client.Game;
 using SharedLibraryCore;
+using SharedLibraryCore.Interfaces;
 
 namespace Stats.Client.Abstractions
 {
     public interface IHitInfoBuilder
     {
-        HitInfo Build(string[] log, int entityId, bool isSelf, bool isVictim, Server.Game gameName);
+        HitInfo Build(string[] log, ParserRegex parserRegex, int entityId, bool isSelf, bool isVictim, Server.Game gameName);
     }
 }

Plugins/Stats/Client/HitCalculator.cs

@@ -170,9 +170,9 @@ namespace IW4MAdmin.Plugins.Stats.Client
                 return;
             }
 
-            var attackerHitInfo = _hitInfoBuilder.Build(match.Values.Skip(1).ToArray(), gameEvent.Origin.ClientId,
+            var attackerHitInfo = _hitInfoBuilder.Build(match.Values.ToArray(), eventRegex, gameEvent.Origin.ClientId,
                 gameEvent.Origin.ClientId == gameEvent.Target.ClientId, false, gameEvent.Owner.GameName);
-            var victimHitInfo = _hitInfoBuilder.Build(match.Values.Skip(1).ToArray(), gameEvent.Target.ClientId,
+            var victimHitInfo = _hitInfoBuilder.Build(match.Values.ToArray(), eventRegex, gameEvent.Target.ClientId,
                 gameEvent.Origin.ClientId == gameEvent.Target.ClientId, true, gameEvent.Owner.GameName);
 
             foreach (var hitInfo in new[] {attackerHitInfo, victimHitInfo})
@@ -241,8 +241,6 @@ namespace IW4MAdmin.Plugins.Stats.Client
             }
         }
 
-      
-
         private async Task<IEnumerable<EFClientHitStatistic>> RunTasksForHitInfo(HitInfo hitInfo, long? serverId)
         {
             var weapon = await GetOrAddWeapon(hitInfo.Weapon, hitInfo.Game);

Plugins/Stats/Client/HitInfoBuilder.cs

@@ -6,6 +6,7 @@ using Microsoft.Extensions.Logging;
 using SharedLibraryCore;
 using SharedLibraryCore.Interfaces;
 using Stats.Client.Abstractions;
+using Stats.Client.Game;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
 
 namespace Stats.Client
@@ -22,7 +23,8 @@ namespace Stats.Client
             _logger = logger;
         }
 
-        public HitInfo Build(string[] log, int entityId, bool isSelf, bool isVictim, Server.Game gameName)
+        public HitInfo Build(string[] log, ParserRegex parserRegex, int entityId, bool isSelf, bool isVictim,
+            Server.Game gameName)
         {
             var eventType = log[(uint) ParserRegex.GroupType.EventType].First();
             HitType hitType;
@@ -45,27 +47,37 @@ namespace Stats.Client
                 hitType = eventType == 'D' ? HitType.Damage : HitType.Kill;
             }
 
+            var damage = 0;
+            try
+            {
+                damage = Math.Min(MaximumDamage,
+                    log.Length > parserRegex.GroupMapping[ParserRegex.GroupType.Damage]
+                        ? int.Parse(log[parserRegex.GroupMapping[ParserRegex.GroupType.Damage]])
+                        : 0);
+            }
+            catch
+            {
+                // ignored
+            }
+
             var hitInfo = new HitInfo()
             {
                 EntityId = entityId,
                 IsVictim = isVictim,
                 HitType = hitType,
-                Damage = Math.Min(MaximumDamage,
-                    log.Length > (uint) ParserRegex.GroupType.Damage
-                        ? int.Parse(log[(uint) ParserRegex.GroupType.Damage])
-                        : 0),
-                Location = log.Length > (uint) ParserRegex.GroupType.HitLocation
-                    ? log[(uint) ParserRegex.GroupType.HitLocation]
+                Damage = damage,
+                Location = log.Length > parserRegex.GroupMapping[ParserRegex.GroupType.HitLocation]
+                    ? log[parserRegex.GroupMapping[ParserRegex.GroupType.HitLocation]]
                     : "Unknown",
-                Weapon = log.Length == 10 ? _weaponNameParser.Parse(log[8], gameName) 
-                     : _weaponNameParser.Parse(log[(uint) ParserRegex.GroupType.Weapon], gameName),
-                MeansOfDeath = log.Length > (uint) ParserRegex.GroupType.MeansOfDeath
-                    ? log[(uint) ParserRegex.GroupType.MeansOfDeath]
+                Weapon = log.Length > parserRegex.GroupMapping[ParserRegex.GroupType.Weapon]
+                    ? _weaponNameParser.Parse(log[parserRegex.GroupMapping[ParserRegex.GroupType.Weapon]], gameName)
+                    : new WeaponInfo {Name = "Unknown"},
+                MeansOfDeath = log.Length > parserRegex.GroupMapping[ParserRegex.GroupType.MeansOfDeath]
+                    ? log[parserRegex.GroupMapping[ParserRegex.GroupType.MeansOfDeath]]
                     : "Unknown",
                 Game = (Reference.Game) gameName
             };
 
-            //_logger.LogDebug("Generated new hitInfo {@hitInfo}", hitInfo);
             return hitInfo;
         }
     }

Plugins/Stats/Client/ServerDistributionCalculator.cs

@@ -45,7 +45,7 @@ namespace Stats.Client
         public async Task Initialize()
         {
             await LoadServers();
-            _distributionCache.SetCacheItem((async set =>
+            _distributionCache.SetCacheItem((async (set, token) =>
             {
                 var validPlayTime = _configurationHandler.Configuration()?.TopPlayersMinPlayTime ?? 3600 * 3;
 
@@ -70,7 +70,7 @@ namespace Stats.Client
                 return distributions;
             }), DistributionCacheKey, Utilities.IsDevelopment ? TimeSpan.FromMinutes(5) : TimeSpan.FromHours(1));
             
-            _maxZScoreCache.SetCacheItem(async set =>
+            _maxZScoreCache.SetCacheItem(async (set, token) =>
             {
                 var validPlayTime = _configurationHandler.Configuration()?.TopPlayersMinPlayTime ?? 3600 * 3;
 
@@ -78,7 +78,7 @@ namespace Stats.Client
                     .Where(AdvancedClientStatsResourceQueryHelper.GetRankingFunc(validPlayTime))
                     .Where(s => s.Skill > 0)
                     .Where(s => s.EloRating > 0)
-                    .MaxAsync(s => (double?)s.ZScore);
+                    .MaxAsync(s => (double?)s.ZScore, token);
                 return zScore ?? 0;
             }, MaxZScoreCacheKey, Utilities.IsDevelopment ? TimeSpan.FromMinutes(5) : TimeSpan.FromMinutes(30));
 

Plugins/Stats/Helpers/ChatResourceQueryHelper.cs

@@ -24,14 +24,14 @@ namespace Stats.Helpers
     {
         private readonly IDatabaseContextFactory _contextFactory;
         private readonly ILogger _logger;
-        private readonly ApplicationConfiguration _appConfig;
+        private readonly DefaultSettings _defaultSettings;
         private List<EFServer> serverCache;
 
-        public ChatResourceQueryHelper(ILogger<ChatResourceQueryHelper> logger, IDatabaseContextFactory contextFactory, ApplicationConfiguration appConfig)
+        public ChatResourceQueryHelper(ILogger<ChatResourceQueryHelper> logger, IDatabaseContextFactory contextFactory, DefaultSettings defaultSettings)
         {
             _contextFactory = contextFactory;
             _logger = logger;
-            _appConfig = appConfig;
+            _defaultSettings = defaultSettings;
         }
 
         /// <inheritdoc/>
@@ -106,20 +106,22 @@ namespace Stats.Helpers
             {
                 message.IsHidden = serverCache.Any(server => server.ServerId == message.ServerId && server.IsPasswordProtected);
 
-                if (message.Message.IsQuickMessage())
+                if (!message.Message.IsQuickMessage())
                 {
-                    try
-                    {
-                        var quickMessages = _appConfig
-                            .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);
-                    }
+                    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);
                 }
             }
 

Plugins/Stats/Helpers/StatManager.cs

@@ -178,6 +178,7 @@ namespace IW4MAdmin.Plugins.Stats.Helpers
                     KDR = s.Sum(c => (c.Kills / (double) (c.Deaths == 0 ? 1 : c.Deaths)) * c.TimePlayed) /
                           s.Sum(c => c.TimePlayed),
                     TotalTimePlayed = s.Sum(c => c.TimePlayed),
+                    UpdatedAt = s.Max(c => c.UpdatedAt)
                 })
                 .ToListAsync();
 
@@ -190,9 +191,9 @@ namespace IW4MAdmin.Plugins.Stats.Helpers
                 Deaths = s.Deaths,
                 Kills = s.Kills,
                 KDR = Math.Round(s.KDR, 2),
-                LastSeen = (DateTime.UtcNow - rankingsDict[s.ClientId].First().LastConnection)
+                LastSeen = (DateTime.UtcNow - (s.UpdatedAt ?? rankingsDict[s.ClientId].Last().LastConnection))
                     .HumanizeForCurrentCulture(1, TimeUnit.Week, TimeUnit.Second, ",", false),
-                LastSeenValue = (DateTime.UtcNow - rankingsDict[s.ClientId].First().LastConnection),
+                LastSeenValue = DateTime.UtcNow - (s.UpdatedAt ?? rankingsDict[s.ClientId].Last().LastConnection),
                 Name = rankingsDict[s.ClientId].First().Name,
                 Performance = Math.Round(rankingsDict[s.ClientId].Last().PerformanceMetric ?? 0, 2),
                 RatingChange = (rankingsDict[s.ClientId].First().Ranking -
@@ -639,6 +640,8 @@ namespace IW4MAdmin.Plugins.Stats.Helpers
                     TimeSinceLastAttack = long.Parse(lastAttackTime),
                     GameName = (int) attacker.CurrentServer.GameName
                 };
+                
+                hit.SetAdditionalProperty("HitLocationReference", hitLoc);
 
                 if (hit.HitLoc == (int) IW4Info.HitLocation.shield)
                 {

Plugins/Stats/Helpers/StatsResourceQueryHelper.cs

@@ -51,7 +51,7 @@ namespace Stats.Helpers
                     Deaths = _stats.Deaths,
                     Performance = Math.Round(_stats.EloRating * 1/3.0 + _stats.Skill * 2/3.0, 2),
                     ScorePerMinute = _stats.SPM,
-                    LastPlayed = _stats.Client.LastConnection,
+                    LastPlayed = _stats.UpdatedAt ?? _stats.Client.LastConnection,
                     TotalSecondsPlayed = _stats.TimePlayed,
                     ServerGame = _stats.Server.GameName.ToString(),
                     ServerName = _stats.Server.HostName,

Plugins/Stats/Stats.csproj

@@ -17,7 +17,7 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.6.29.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.8.31.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Plugins/Welcome/Welcome.csproj

@@ -20,7 +20,7 @@
   </Target>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.6.29.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.8.31.1" PrivateAssets="All" />
   </ItemGroup>
 
 </Project>

SharedLibraryCore/BaseController.cs

@@ -57,6 +57,7 @@ namespace SharedLibraryCore
             ViewBag.Version = Manager.Version;
             ViewBag.IsFluid = false;
             ViewBag.EnableColorCodes = Manager.GetApplicationSettings().Configuration().EnableColorCodes;
+            ViewBag.Language = Utilities.CurrentLocalization.Culture.TwoLetterISOLanguageName;
 
             Client ??= new EFClient()
             {
@@ -125,14 +126,20 @@ namespace SharedLibraryCore
                 SignInAsync(new ClaimsPrincipal(claimsIdentity)).Wait();
             }
 
+            var communityName = Manager.GetApplicationSettings().Configuration().CommunityInformation?.Name;
+            var shouldUseCommunityName = !string.IsNullOrWhiteSpace(communityName) && !communityName.Contains("IW4MAdmin");
+            
             ViewBag.Authorized = Authorized;
             ViewBag.Url = Manager.GetApplicationSettings().Configuration().WebfrontUrl;
             ViewBag.User = Client;
+            ViewBag.Version = Manager.Version;
             ViewBag.SocialLink = SocialLink ?? "";
             ViewBag.SocialTitle = SocialTitle;
             ViewBag.Pages = Pages;
             ViewBag.Localization = Utilities.CurrentLocalization.LocalizationIndex;
-            ViewBag.CustomBranding = Manager.GetApplicationSettings().Configuration().WebfrontCustomBranding ?? "IW4MAdmin";
+            ViewBag.CustomBranding = shouldUseCommunityName
+                ? communityName
+                : Manager.GetApplicationSettings().Configuration().WebfrontCustomBranding ?? "IW4MAdmin";
             ViewBag.EnableColorCodes = Manager.GetApplicationSettings().Configuration().EnableColorCodes;
             ViewBag.EnablePrivilegedUserPrivacy = Manager.GetApplicationSettings().Configuration().EnablePrivilegedUserPrivacy;
 

SharedLibraryCore/Commands/RunAsCommand.cs

@@ -35,7 +35,7 @@ namespace SharedLibraryCore.Commands
 
             if (!gameEvent.CanPerformActionOnTarget())
             {
-                gameEvent.Origin.Tell(_translationLookup["COMMANDS_RUN_AS_FAIL_PERM"]);
+                gameEvent.Origin.Tell(_translationLookup["COMMANDS_RUN_AS_FAIL_PERM"].FormatExt(gameEvent.Target.Name));
                 return;
             }
 
@@ -53,11 +53,18 @@ namespace SharedLibraryCore.Commands
             gameEvent.Owner.Manager.AddEvent(impersonatedCommandEvent);
 
             var result = await impersonatedCommandEvent.WaitAsync(Utilities.DefaultCommandTimeout, gameEvent.Owner.Manager.CancellationToken);
+            await result.WaitAsync(Utilities.DefaultCommandTimeout, gameEvent.Owner.Manager.CancellationToken);
 
             // remove the added command response
-            foreach (var output in result.Output)
+            // todo: something weird happening making this change required
+            var responses = gameEvent.Owner.Manager.ProcessingEvents
+                .Where(ev => ev.Value.CorrelationId == impersonatedCommandEvent.CorrelationId)
+                .SelectMany(ev => ev.Value.Output)
+                .ToList();
+            
+            foreach (var output in responses)
             {
-                gameEvent.Origin.Tell(_translationLookup["COMMANDS_RUN_AS_SUCCESS"].FormatExt(output));
+                await gameEvent.Origin.Tell(_translationLookup["COMMANDS_RUN_AS_SUCCESS"].FormatExt(output)).WaitAsync();
             }
         }
     }

SharedLibraryCore/Configuration/ApplicationConfiguration.cs

@@ -4,12 +4,16 @@ using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
+using Newtonsoft.Json;
 using static Data.Models.Client.EFClient;
 
 namespace SharedLibraryCore.Configuration
 {
     public class ApplicationConfiguration : IBaseConfiguration
     {
+        [ConfigurationIgnore]
+        public CommunityInformationConfiguration CommunityInformation { get; set; } = new CommunityInformationConfiguration();
+            
         [LocalizedDisplayName("SETUP_ENABLE_WEBFRONT")]
         [ConfigurationLinked("WebfrontBindUrl", "ManualWebfrontUrl", "WebfrontPrimaryColor", "WebfrontSecondaryColor",
             "WebfrontCustomBranding")]
@@ -134,11 +138,25 @@ namespace SharedLibraryCore.Configuration
             TimeSpan.FromDays(30)
         };
 
+        [ConfigurationIgnore]
         [LocalizedDisplayName("WEBFRONT_CONFIGURATION_PRESET_BAN_REASONS")]
         public Dictionary<string, string> PresetPenaltyReasons { get; set; } = new Dictionary<string, string>
             {{"afk", "Away from keyboard"}, {"ci", "Connection interrupted. Reconnect"}};
         [LocalizedDisplayName(("WEBFRONT_CONFIGURATION_ENABLE_PRIVILEGED_USER_PRIVACY"))]
         public bool EnablePrivilegedUserPrivacy { get; set; }
+
+        [ConfigurationIgnore]
+        public bool EnableImplicitAccountLinking { get; set; } = false;
+
+        [ConfigurationIgnore] 
+        public TimeSpan MaxClientHistoryTime { get; set; } = TimeSpan.FromHours(12);
+
+        [ConfigurationIgnore] 
+        public TimeSpan ServerDataCollectionInterval { get; set; } = TimeSpan.FromMinutes(5);
+
+        public int ServerConnectionAttempts { get; set; } = 6;
+        
+        [ConfigurationIgnore]
         public Dictionary<Permission, string> OverridePermissionLevelNames { get; set; } = Enum
             .GetValues(typeof(Permission))
             .Cast<Permission>()
@@ -149,10 +167,13 @@ namespace SharedLibraryCore.Configuration
         [ConfigurationIgnore] public int MinimumNameLength { get; set; } = 3;
         [ConfigurationIgnore] public string Id { get; set; }
         [ConfigurationIgnore] public string SubscriptionId { get; set; }
+        [Obsolete("Moved to DefaultSettings")]
         [ConfigurationIgnore] public MapConfiguration[] Maps { get; set; }
+        [Obsolete("Moved to DefaultSettings")]
         [ConfigurationIgnore] public QuickMessageConfiguration[] QuickMessages { get; set; }
 
         [ConfigurationIgnore]
+        [JsonIgnore]
         public string WebfrontUrl => string.IsNullOrEmpty(ManualWebfrontUrl)
             ? WebfrontBindUrl?.Replace("0.0.0.0", "127.0.0.1")
             : ManualWebfrontUrl;

SharedLibraryCore/Configuration/CommunityInformationConfiguration.cs

@@ -0,0 +1,40 @@
+namespace SharedLibraryCore.Configuration
+{
+    public class CommunityInformationConfiguration
+    {
+        public string Name { get; set; } = "IW4MAdmin - Configure In IW4MAdminSettings.json";
+        public string Description { get; set; } =
+            "IW4MAdmin is an administration tool for IW4x, Pluto T6, Pluto IW5, CoD4x, TeknoMW3, and most Call of Duty® dedicated servers. It allows complete control of your server; from changing maps, to banning players, IW4MAdmin monitors and records activity on your server(s). With plugin support, extending its functionality is a breeze.";
+        public bool EnableBanner { get; set; } = true;
+
+        public SocialAccountConfiguration[] SocialAccounts { get; set; } =
+        {
+            new SocialAccountConfiguration
+            {
+                Title = "IW4MAdmin Website",
+                Url = "https://raidmax.org/IW4MAdmin",
+                IconId = "oi-globe"
+            },
+            new SocialAccountConfiguration
+            {
+                Title = "IW4MAdmin Github",
+                Url = "https://github.com/RaidMax/IW4M-Admin/",
+                IconUrl = "github.svg"
+            },
+            new SocialAccountConfiguration
+            {
+                Title = "IW4MAdmin Youtube",
+                Url = "https://www.youtube.com/watch?v=xpxEO4Qi0cQ",
+                IconUrl = "https://raw.githubusercontent.com/edent/SuperTinyIcons/master/images/svg/youtube.svg"
+            }
+        };
+    }
+
+    public class SocialAccountConfiguration
+    {
+        public string Title { get; set; }
+        public string Url { get; set; }
+        public string IconUrl { get; set; }
+        public string IconId { get; set; }
+    }
+}

SharedLibraryCore/Configuration/ServerConfiguration.cs

@@ -87,12 +87,8 @@ namespace SharedLibraryCore.Configuration
 
             while (string.IsNullOrEmpty(IPAddress))
             {
-                string input = Utilities.PromptString(loc["SETUP_SERVER_IP"]);
-
-                if (System.Net.IPAddress.TryParse(input, out System.Net.IPAddress ip))
-                {
-                    IPAddress = input;
-                }
+                var input = Utilities.PromptString(loc["SETUP_SERVER_IP"]);
+                IPAddress = input;
             }
 
             Port = Utilities.PromptInt(loc["SETUP_SERVER_PORT"], null, 1, ushort.MaxValue);

SharedLibraryCore/Configuration/Validation/ServerConfigurationValidator.cs

@@ -10,10 +10,6 @@ namespace SharedLibraryCore.Configuration.Validation
     {
         public ServerConfigurationValidator()
         {
-            RuleFor(_server => _server.IPAddress)
-                .NotEmpty()
-                .Must(_address => IPAddress.TryParse(_address, out _));
-
             RuleFor(_server => _server.Port)
                 .InclusiveBetween(1, ushort.MaxValue);
 

SharedLibraryCore/Dtos/ClientHistoryInfo.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+
+namespace SharedLibraryCore.Dtos
+{
+    public class ClientHistoryInfo
+    {
+        public long ServerId { get; set; }
+        public List<ClientCountSnapshot> ClientCounts { get; set; }
+    }
+
+    public class ClientCountSnapshot
+    {
+        public DateTime Time { get; set; }
+        public string TimeString => Time.ToString("yyyy-MM-ddTHH:mm:ssZ");
+        public int ClientCount { get; set; }
+    }
+}

SharedLibraryCore/Dtos/IW4MAdminInfo.cs

@@ -1,4 +1,5 @@
-using static SharedLibraryCore.Server;
+using System;
+using static SharedLibraryCore.Server;
 
 namespace SharedLibraryCore.Dtos
 {
@@ -8,6 +9,8 @@ namespace SharedLibraryCore.Dtos
         public int RecentClientCount { get; set; }
         public int TotalOccupiedClientSlots { get; set; }
         public int TotalAvailableClientSlots { get; set; }
+        public int MaxConcurrentClients { get; set; }
+        public DateTime MaxConcurrentClientsTime { get; set; }
 
         /// <summary>
         /// specifies the game name filter

SharedLibraryCore/Dtos/Meta/Responses/BaseMetaResponse.cs

@@ -1,13 +1,11 @@
 using SharedLibraryCore.Interfaces;
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace SharedLibraryCore.Dtos.Meta.Responses
 {
     public class BaseMetaResponse : IClientMeta, IClientMetaResponse
     {
-        public int MetaId { get; set; }
+        public long MetaId { get; set; }
         public int ClientId { get; set; }
         public MetaType Type { get; set; }
         public DateTime When { get; set; }

SharedLibraryCore/Dtos/Meta/Responses/ConnectionHistoryResponse.cs

@@ -0,0 +1,10 @@
+using Data.Models;
+
+namespace SharedLibraryCore.Dtos.Meta.Responses
+{
+    public class ConnectionHistoryResponse : BaseMetaResponse
+    {
+        public string ServerName { get; set; }
+        public Reference.ConnectionType ConnectionType { get; set; }
+    }
+}

SharedLibraryCore/Dtos/ServerInfo.cs

@@ -17,6 +17,7 @@ namespace SharedLibraryCore.Dtos
         public List<ChatInfo> ChatHistory { get; set; }
         public List<PlayerInfo> Players { get; set; }
         public Helpers.PlayerHistory[] PlayerHistory { get; set; }
+        public List<ClientCountSnapshot> ClientCountHistory { get; set; }
         public long ID { get; set; }
         public bool Online { get; set; }
         public string ConnectProtocolUrl { get; set; }

SharedLibraryCore/Helpers/PlayerHistory.cs

@@ -1,4 +1,5 @@
 using System;
+using SharedLibraryCore.Dtos;
 
 namespace SharedLibraryCore.Helpers
 {
@@ -31,5 +32,14 @@ namespace SharedLibraryCore.Helpers
         /// Used by CanvasJS as a point on the y axis
         /// </summary>
         public int y { get; }
+
+        public ClientCountSnapshot ToClientCountSnapshot()
+        {
+            return new ClientCountSnapshot
+            {
+                ClientCount = y,
+                Time = When
+            };
+        }
     }
 }

SharedLibraryCore/Interfaces/IClientMeta.cs

@@ -26,6 +26,7 @@ namespace SharedLibraryCore.Interfaces
         ChatMessage,
         Penalized,
         ReceivedPenalty,
-        QuickMessage
+        QuickMessage,
+        ConnectionHistory
     }
 }

SharedLibraryCore/Interfaces/IClientMetaResponse.cs

@@ -7,6 +7,6 @@ namespace SharedLibraryCore.Interfaces
     public interface IClientMetaResponse
     {
         int ClientId { get;}
-        int MetaId { get; }
+        long MetaId { get; }
     }
 }

SharedLibraryCore/Interfaces/IEventPublisher.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace SharedLibraryCore.Interfaces
+{
+    public interface IEventPublisher
+    {
+        event EventHandler<GameEvent> OnClientDisconnect;
+        event EventHandler<GameEvent> OnClientConnect;
+
+        void Publish(GameEvent gameEvent);
+    }
+}

SharedLibraryCore/Interfaces/IRConConnectionFactory.cs

@@ -1,4 +1,6 @@
-namespace SharedLibraryCore.Interfaces
+using System.Net;
+
+namespace SharedLibraryCore.Interfaces
 {
     /// <summary>
     /// defines the capabilities of an RCon connection factory
@@ -8,11 +10,10 @@
         /// <summary>
         /// creates an rcon connection instance
         /// </summary>
-        /// <param name="ipAddress">ip address of the server</param>
-        /// <param name="port">port of the server</param>
+        /// <param name="ipEndpoint">ip address and port of the server</param>
         /// <param name="password"> password of the server</param>
         /// <param name="rconEngine">engine to create the rcon connection to</param>
         /// <returns>instance of rcon connection</returns>
-        IRConConnection CreateConnection(string ipAddress, int port, string password, string rconEngine);
+        IRConConnection CreateConnection(IPEndPoint ipEndpoint, string password, string rconEngine);
     }
 }

SharedLibraryCore/Interfaces/IServerDataCollector.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharedLibraryCore.Interfaces
+{
+    public interface IServerDataCollector
+    {
+        /// <summary>
+        /// Begins to collection on servers for analytical purposes
+        /// </summary>
+        /// <param name="period">interval at which to collect data</param>
+        /// <param name="cancellationToken">Token</param>
+        /// <returns>Task</returns>
+        Task BeginCollectionAsync(TimeSpan? period = null, CancellationToken cancellationToken = default);
+    }
+}

SharedLibraryCore/Interfaces/IServerDataViewer.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using SharedLibraryCore.Dtos;
+using SharedLibraryCore.Helpers;
+
+namespace SharedLibraryCore.Interfaces
+{
+    /// <summary>
+    /// Exposes methods to get analytical data about server(s)
+    /// </summary>
+    public interface IServerDataViewer
+    {
+        /// <summary>
+        /// Retrieves the max concurrent clients over a give time period for all servers or given server id
+        /// </summary>
+        /// <param name="serverId">ServerId to query on</param>
+        /// <param name="overPeriod">how far in the past to search</param>
+        /// <param name="token">CancellationToken</param>
+        /// <returns></returns>
+        Task<(int?, DateTime?)> MaxConcurrentClientsAsync(long? serverId = null, TimeSpan? overPeriod = null, CancellationToken token = default);
+        
+        /// <summary>
+        /// Gets the total number of clients connected and total clients connected in the given time frame
+        /// </summary>
+        /// <param name="overPeriod">how far in the past to search</param>
+        /// <param name="token">CancellationToken</param>
+        /// <returns></returns>
+        Task<(int, int)> ClientCountsAsync(TimeSpan? overPeriod = null, CancellationToken token = default);
+
+        /// <summary>
+        /// Retrieves the client count and history over the given period
+        /// </summary>
+        /// <param name="overPeriod">how far in the past to search</param>
+        /// <param name="token">CancellationToken</param>
+        /// <returns></returns>
+        Task<IEnumerable<ClientHistoryInfo>> ClientHistoryAsync(TimeSpan? overPeriod = null, CancellationToken token = default);
+    }
+}

SharedLibraryCore/PartialEntities/EFClient.cs

@@ -457,7 +457,8 @@ namespace SharedLibraryCore.Database.Models
 
             using (LogContext.PushProperty("Server", CurrentServer?.ToString()))
             {
-                if (string.IsNullOrWhiteSpace(Name) || CleanedName.Replace(" ", "").Length <
+                var nameToCheck = CurrentServer.IsCodGame() ? CleanedName : Name;
+                if (string.IsNullOrWhiteSpace(Name) || nameToCheck.Replace(" ", "").Length <
                     (CurrentServer?.Manager?.GetApplicationSettings()?.Configuration()?.MinimumNameLength ?? 3))
                 {
                     Utilities.DefaultLogger.LogInformation("Kicking {Client} because their name is too short", ToString());
@@ -524,12 +525,12 @@ namespace SharedLibraryCore.Database.Models
             }
         }
 
-        public async Task OnJoin(int? ipAddress)
+        public async Task OnJoin(int? ipAddress, bool enableImplicitLinking)
         {
             using (LogContext.PushProperty("Server", CurrentServer?.ToString()))
             {
                 Utilities.DefaultLogger.LogInformation("Client {client} is joining the game from {source}", ToString(), ipAddress.HasValue ? "Status" : "Log");
-
+                
                 if (ipAddress != null)
                 {
                     IPAddress = ipAddress;
@@ -537,7 +538,7 @@ namespace SharedLibraryCore.Database.Models
                     await CurrentServer.Manager.GetClientService().UpdateAlias(this);
                     await CurrentServer.Manager.GetClientService().Update(this);
 
-                    bool canConnect = await CanConnect(ipAddress);
+                    var canConnect = await CanConnect(ipAddress, enableImplicitLinking);
 
                     if (!canConnect)
                     {
@@ -569,7 +570,7 @@ namespace SharedLibraryCore.Database.Models
             }
         }
 
-        public async Task<bool> CanConnect(int? ipAddress)
+        public async Task<bool> CanConnect(int? ipAddress, bool enableImplicitLinking)
         {
             using (LogContext.PushProperty("Server", CurrentServer?.ToString()))
             {
@@ -597,12 +598,12 @@ namespace SharedLibraryCore.Database.Models
                     if (Level != Permission.Banned)
                     {
                         Utilities.DefaultLogger.LogInformation(
-                            "Client {client} is banned, but using a new GUID, we we're updating their level and kicking them",
+                            "Client {client} has a ban penalty, but they're using a new GUID, we we're updating their level and kicking them",
                             ToString());
                         await SetLevel(Permission.Banned, autoKickClient).WaitAsync(Utilities.DefaultCommandTimeout,
                             CurrentServer.Manager.CancellationToken);
                     }
-
+                    
                     Utilities.DefaultLogger.LogInformation("Kicking {client} because they are banned", ToString());
                     Kick(loc["WEBFRONT_PENALTY_LIST_BANNED_REASON"], autoKickClient, banPenalty);
                     return false;

SharedLibraryCore/RCon/StaticHelpers.cs

@@ -64,9 +64,5 @@ namespace SharedLibraryCore.RCon
         /// interval in milliseconds to wait before sending the next RCon request
         /// </summary>
         public static readonly int FloodProtectionInterval = 750;
-        /// <summary>
-        /// how many failed connection attempts before aborting connection
-        /// </summary>
-        public static readonly int AllowedConnectionFails = 5;
     }
 }

SharedLibraryCore/Server.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
@@ -58,7 +59,9 @@ namespace SharedLibraryCore
             InitializeAutoMessages();
         }
 
-        public long EndPoint => Convert.ToInt64($"{IP.Replace(".", "")}{Port}");
+        public long EndPoint => IPAddress.TryParse(IP, out _) 
+            ? Convert.ToInt64($"{IP.Replace(".", "")}{Port}") 
+            : $"{IP.Replace(".", "")}{Port}".GetStableHashCode();
 
         /// <summary>
         /// Returns list of all current players
@@ -251,17 +254,6 @@ namespace SharedLibraryCore
         /// </summary>
         abstract public void InitializeTokens();
 
-        /// <summary>
-        /// Read the map configuration
-        /// </summary>
-        protected void InitializeMaps()
-        {
-            Maps = new List<Map>();
-            var gameMaps = Manager.GetApplicationSettings().Configuration().Maps.FirstOrDefault(m => m.Game == GameName);
-            if (gameMaps != null)
-                Maps.AddRange(gameMaps.Maps);
-        }
-
         /// <summary>
         /// Initialize the messages to be broadcasted
         /// </summary>
@@ -292,6 +284,8 @@ namespace SharedLibraryCore
             }
         }
 
+        public abstract Task<long> GetIdForServer(Server server = null);
+
         // Objects
         public IManager Manager { get; protected set; }
         [Obsolete]
@@ -314,7 +308,7 @@ namespace SharedLibraryCore
         {
             get
             {
-                return Clients.Where(p => p != null/* && !p.IsBot*/).Count();
+                return Clients.ToArray().Count(p => p != null && !p.IsBot);
             }
         }
         public int MaxClients { get; protected set; }
@@ -331,7 +325,11 @@ namespace SharedLibraryCore
         public SemaphoreSlim EventProcessing { get; private set; }
 
         // Internal
+        /// <summary>
+        /// this is actually the hostname now
+        /// </summary>
         public string IP { get; protected set; }
+        public IPEndPoint ResolvedIpEndPoint { get; protected set; }
         public string Version { get; protected set; }
         public bool IsInitialized { get; set; }
         protected readonly ILogger ServerLogger;
@@ -349,6 +347,6 @@ namespace SharedLibraryCore
 
         // only here for performance
         private readonly bool CustomSayEnabled;
-        private readonly string CustomSayName;
+        protected readonly string CustomSayName;
     }
 }