Add libraries for EntityFramework

Stats plugin work
Allow plugins to dynamically add EF classes to the context

SharedLibrary/Services/AliasService.cs

@@ -54,11 +54,15 @@ namespace SharedLibrary.Services
 
         public async Task<IList<EFAlias>> Find(Func<EFAlias, bool> expression)
         {
-            using (var context = new DatabaseContext())
-                return await Task.Run(() => context.Aliases
-                .AsNoTracking()
-                .Include(a => a.Link.Children)
-                .Where(expression).ToList());
+            return await Task.Run(() =>
+           {
+               using (var context = new DatabaseContext())
+                   return context.Aliases
+                   .AsNoTracking()
+                   .Include(a => a.Link.Children)
+                   .Where(expression)
+                   .ToList();
+           });
         }
 
         public async Task<EFAlias> Get(int entityID)

SharedLibrary/Services/ClientService.cs

@@ -88,12 +88,15 @@ namespace SharedLibrary.Services
 
         public async Task<IList<EFClient>> Find(Func<EFClient, bool> e)
         {
-            using (var context = new DatabaseContext())
-                return await Task.Run(() => context.Clients
-                      .AsNoTracking()
-                     .Include(c => c.CurrentAlias)
-                     .Include(c => c.AliasLink.Children)
-                     .Where(e).ToList());
+            return await Task.Run(() =>
+            {
+                using (var context = new DatabaseContext())
+                    return context.Clients
+                          .AsNoTracking()
+                         .Include(c => c.CurrentAlias)
+                         .Include(c => c.AliasLink.Children)
+                         .Where(e).ToList();
+            });
         }
 
         public async Task<EFClient> Get(int entityID)
@@ -125,7 +128,7 @@ namespace SharedLibrary.Services
                 // grab the context version of the entity
                 var client = context.Clients
                     .Include(c => c.AliasLink)
-                    .Include(c=> c.CurrentAlias)
+                    .Include(c => c.CurrentAlias)
                     .Single(e => e.ClientId == entity.ClientId);
 
                 // if their level has been changed
@@ -167,12 +170,12 @@ namespace SharedLibrary.Services
 
                 // this is set so future updates don't trigger a new alias add
                 if (entity.CurrentAlias.AliasId == 0)
-                   entity.CurrentAlias.AliasId = client.CurrentAlias.AliasId;
+                    entity.CurrentAlias.AliasId = client.CurrentAlias.AliasId;
                 return client;
             }
         }
 
-#region ServiceSpecific
+        #region ServiceSpecific
         public async Task<IList<EFClient>> GetOwners()
         {
             using (var context = new DatabaseContext())
@@ -230,6 +233,6 @@ namespace SharedLibrary.Services
         {
             throw new NotImplementedException();
         }
-#endregion
+        #endregion
     }
 }

SharedLibrary/Services/GenericRepository.cs

@@ -0,0 +1,146 @@
+using SharedLibrary.Database;
+using System;
+using System.Collections.Generic;
+using System.Data.Entity;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SharedLibrary.Services
+{
+    // https://stackoverflow.com/questions/43677906/crud-operations-with-entityframework-using-generic-type
+    public class GenericRepository<TEntity> where TEntity : class
+    {
+        private dynamic _context;
+        private DbSet<TEntity> _dbSet;
+
+        protected DbContext Context
+        {
+            get
+            {
+                if (_context == null)
+                {
+                    _context = new DatabaseContext();
+                }
+
+                return _context;
+            }
+        }
+
+        protected DbSet<TEntity> DBSet
+        {
+            get
+            {
+                if (_dbSet == null)
+                {
+                    _dbSet = this.Context.Set<TEntity>();
+                }
+
+                return _dbSet;
+            }
+        }
+
+        public virtual IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderExpression = null)
+        {
+            return this.GetQuery(predicate, orderExpression).AsEnumerable();
+        }
+
+        public virtual IQueryable<TEntity> GetQuery(Expression<Func<TEntity, bool>> predicate = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderExpression = null)
+        {
+            IQueryable<TEntity> qry = this.DBSet;
+
+            if (predicate != null)
+                qry = qry.Where(predicate);
+
+            if (orderExpression != null)
+                return orderExpression(qry);
+
+
+            return qry;
+        }
+
+        public virtual void Insert<T>(T entity) where T : class
+        {
+            DbSet<T> dbSet = this.Context.Set<T>();
+            dbSet.Add(entity);
+        }
+
+        public virtual TEntity Insert(TEntity entity)
+        {
+            return this.DBSet.Add(entity);
+        }
+
+        public virtual void Update<T>(T entity) where T : class
+        {
+            DbSet<T> dbSet = this.Context.Set<T>();
+            dbSet.Attach(entity);
+            this.Context.Entry(entity).State = EntityState.Modified;
+        }
+
+        public virtual void Update(TEntity entity)
+        {
+            this.Attach(entity);
+            this.Context.Entry(entity).State = EntityState.Modified;
+        }
+
+        public virtual void Delete<T>(T entity) where T : class
+        {
+            DbSet<T> dbSet = this.Context.Set<T>();
+
+            if (this.Context.Entry(entity).State == EntityState.Detached)
+                dbSet.Attach(entity);
+
+            dbSet.Remove(entity);
+
+        }
+
+        public virtual void Delete(TEntity entity)
+        {
+            if (this.Context.Entry(entity).State == EntityState.Detached)
+                this.Attach(entity);
+
+            this.DBSet.Remove(entity);
+
+        }
+
+        public virtual void Delete<T>(object[] id) where T : class
+        {
+            DbSet<T> dbSet = this.Context.Set<T>();
+            T entity = dbSet.Find(id);
+            dbSet.Attach(entity);
+            dbSet.Remove(entity);
+
+        }
+
+        public virtual void Delete(object id)
+        {
+            TEntity entity = this.DBSet.Find(id);
+            this.Delete(entity);
+        }
+
+
+        public virtual void Attach(TEntity entity)
+        {
+            if (this.Context.Entry(entity).State == EntityState.Detached)
+                this.DBSet.Attach(entity);
+        }
+
+        public virtual void SaveChanges()
+        {
+            this.Context.SaveChanges();
+        }
+
+        public virtual async Task SaveChangesAsync()
+        {
+            try
+            {
+                await this.Context.SaveChangesAsync();
+            }
+            catch (Exception e)
+            {
+                throw e;
+            }
+        }
+    }
+}

SharedLibrary/Services/GenericService.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using SharedLibrary.Database;
+
+namespace SharedLibrary.Services
+{
+   public class GenericService<T> : Interfaces.IEntityService<T>
+    {
+        public async Task<T> Create(T entity)
+        {
+            using (var context = new DatabaseContext())
+            {
+                var dbSet = context.Set(entity.GetType());
+                T addedEntity = (T)dbSet.Add(entity);
+                await context.SaveChangesAsync();
+
+                return addedEntity;
+           }
+        }
+
+        public Task<T> CreateProxy()
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<T> Delete(T entity)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<IList<T>> Find(Func<T, bool> expression)
+        {
+            throw new NotImplementedException();
+        }
+
+        public async Task<T> Get(int entityID)
+        {
+            using (var context = new DatabaseContext())
+            {
+                var dbSet = context.Set(typeof(T));
+                return (T)(await dbSet.FindAsync(entityID));
+            }
+        }
+
+        public async Task<T> Get(params object[] entityKeys)
+        {
+            using (var context = new DatabaseContext())
+            {
+                var dbSet = context.Set(typeof(T));
+                return (T)(await dbSet.FindAsync(entityKeys));
+            }
+        }
+
+        public Task<T> GetUnique(string entityProperty)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<T> Update(T entity)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

SharedLibrary/Services/PenaltyService.cs

@@ -56,15 +56,16 @@ namespace SharedLibrary.Services
 
         public async Task<IList<EFPenalty>> Find(Func<EFPenalty, bool> expression)
         {
-            using (var context = new DatabaseContext())
+            return await Task.Run(() =>
             {
-                return await Task.Run(() => context.Penalties
-                .Include(p => p.Offender)
-                .Include(p => p.Punisher)
-                .Where(expression)
-                .Where(p => p.Active)
-                .ToList());
-            }
+                using (var context = new DatabaseContext())
+                    return context.Penalties
+                    .Include(p => p.Offender)
+                    .Include(p => p.Punisher)
+                    .Where(expression)
+                    .Where(p => p.Active)
+                    .ToList();
+            });
         }
 
         public Task<EFPenalty> Get(int entityID)