huge commit for advanced stats feature.

broke data out into its own library.
may be breaking changes with existing plugins

Data/Helpers/DataValueCache.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Data.Abstractions;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace Data.Helpers
+{
+    public class DataValueCache<T, V> : IDataValueCache<T, V> where T : class
+    {
+        private readonly ILogger _logger;
+        private readonly IDatabaseContextFactory _contextFactory;
+        private readonly Dictionary<string, CacheState> _cacheStates = new Dictionary<string, CacheState>();
+        private const int DefaultExpireMinutes = 15;
+
+        private class CacheState
+        {
+            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 V Value { get; set; }
+            public bool IsExpired => (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)
+        {
+            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)
+        {
+            if (!_cacheStates.ContainsKey(keyName))
+            {
+                throw new ArgumentException("No cache found for key {key}", keyName);
+            }
+
+            var state = _cacheStates[keyName];
+
+            if (state.IsExpired)
+            {
+                await RunCacheUpdate(state);
+            }
+
+            return state.Value;
+        }
+
+        private async Task RunCacheUpdate(CacheState state)
+        {
+            try
+            {
+                await using var context = _contextFactory.CreateContext(false);
+                var set = context.Set<T>();
+                var value = await state.Getter(set);
+                state.Value = value;
+                state.LastRetrieval = DateTime.Now;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Could not get cached value for {key}", state.Key);
+            }
+        }
+    }
+}

Data/Helpers/LookupCache.cs

@@ -0,0 +1,114 @@
+using Data.Abstractions;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace Data.Helpers
+{
+    public class LookupCache<T> : ILookupCache<T> where T : class, IUniqueId
+    {
+        private readonly ILogger _logger;
+        private readonly IDatabaseContextFactory _contextFactory;
+        private Dictionary<long, T> _cachedItems;
+        private readonly SemaphoreSlim _onOperation = new SemaphoreSlim(1, 1);
+
+        public LookupCache(ILogger<LookupCache<T>> logger, IDatabaseContextFactory contextFactory)
+        {
+            _logger = logger;
+            _contextFactory = contextFactory;
+        }
+
+        public async Task<T> AddAsync(T item)
+        {
+            await _onOperation.WaitAsync();
+            T existingItem = null;
+
+            if (_cachedItems.ContainsKey(item.Id))
+            {
+                existingItem = _cachedItems[item.Id];
+            }
+
+            if (existingItem != null)
+            {
+                _logger.LogDebug("Cached item already added for {type} {id} {value}", typeof(T).Name, item.Id,
+                    item.Value);
+                _onOperation.Release();
+                return existingItem;
+            }
+
+            try
+            {
+                _logger.LogDebug("Adding new {type} with {id} {value}", typeof(T).Name, item.Id, item.Value);
+                await using var context = _contextFactory.CreateContext();
+                context.Set<T>().Add(item);
+                await context.SaveChangesAsync();
+                _cachedItems.Add(item.Id, item);
+                return item;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Could not add item to cache for {type}", typeof(T).Name);
+                throw new Exception("Could not add item to cache");
+            }
+            finally
+            {
+                if (_onOperation.CurrentCount == 0)
+                {
+                    _onOperation.Release();
+                }
+            }
+        }
+
+        public async Task<T> FirstAsync(Func<T, bool> query)
+        {
+            await _onOperation.WaitAsync();
+
+            try
+            {
+                var cachedResult = _cachedItems.Values.Where(query);
+
+                if (cachedResult.Any())
+                {
+                    return cachedResult.FirstOrDefault();
+                }
+            }
+
+            catch
+            {
+            }
+
+            finally
+            {
+                if (_onOperation.CurrentCount == 0)
+                {
+                    _onOperation.Release(1);
+                }
+            }
+
+            return null;
+        }
+
+        public IEnumerable<T> GetAll()
+        {
+            return _cachedItems.Values;
+        }
+
+        public async Task InitializeAsync()
+        {
+            try
+            {
+                await using var context = _contextFactory.CreateContext();
+                _cachedItems = await context.Set<T>().ToDictionaryAsync(item => item.Id);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Could not initialize caching for {cacheType}", typeof(T).Name);
+            }
+        }
+    }
+}