diff --git a/src/FilterLists.Services/FilterList/FilterListService.cs b/src/FilterLists.Services/FilterList/FilterListService.cs
index 6cddccfa5..a05321826 100644
--- a/src/FilterLists.Services/FilterList/FilterListService.cs
+++ b/src/FilterLists.Services/FilterList/FilterListService.cs
@@ -9,29 +9,27 @@
 namespace FilterLists.Services.FilterList
 {
     [UsedImplicitly]
-    public class FilterListService
+    public class FilterListService : Service
     {
-        private readonly FilterListsDbContext _filterListsDbContext;
-
-        public FilterListService(FilterListsDbContext filterListsDbContext)
+        public FilterListService(FilterListsDbContext dbContext) : base(dbContext)
         {
-            _filterListsDbContext = filterListsDbContext;
+            DbContext = dbContext;
         }
 
         public async Task<IEnumerable<ListSummaryDto>> GetAllSummariesAsync()
         {
-            return await _filterListsDbContext.FilterLists.AsNoTracking()
-                                              .OrderBy(x => x.Name)
-                                              .ProjectTo<ListSummaryDto>()
-                                              .ToListAsync();
+            return await DbContext.FilterLists.AsNoTracking()
+                                  .OrderBy(x => x.Name)
+                                  .ProjectTo<ListSummaryDto>()
+                                  .ToListAsync();
         }
 
         public async Task<ListDetailsDto> GetDetailsAsync(int id)
         {
-            return await _filterListsDbContext.FilterLists.AsNoTracking()
-                                              .ProjectTo<ListDetailsDto>()
-                                              .FirstAsync(x => x.Id == id)
-                                              .FilterParentListFromMaintainerAdditionalLists();
+            return await DbContext.FilterLists.AsNoTracking()
+                                  .ProjectTo<ListDetailsDto>()
+                                  .FirstAsync(x => x.Id == id)
+                                  .FilterParentListFromMaintainerAdditionalLists();
         }
     }
 }
\ No newline at end of file
diff --git a/src/FilterLists.Services/RuleService.cs b/src/FilterLists.Services/RuleService.cs
new file mode 100644
index 000000000..2b9933e0d
--- /dev/null
+++ b/src/FilterLists.Services/RuleService.cs
@@ -0,0 +1,23 @@
+using System.Linq;
+using System.Threading.Tasks;
+using FilterLists.Data;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace FilterLists.Services
+{
+    [UsedImplicitly]
+    public class RuleService : Service
+    {
+        public RuleService(FilterListsDbContext dbContext) : base(dbContext)
+        {
+            DbContext = dbContext;
+        }
+
+        public async Task<int> GetCountAllActiveRules() => await DbContext
+                                                                 .SnapshotRules.AsNoTracking()
+                                                                 .Where(x => x.RemovedBySnapshotId == null)
+                                                                 .GroupBy(x => x.RuleId)
+                                                                 .CountAsync();
+    }
+}
\ No newline at end of file
diff --git a/src/FilterLists.Services/Seed/SeedService.cs b/src/FilterLists.Services/Seed/SeedService.cs
index c64423c5b..49af0c788 100644
--- a/src/FilterLists.Services/Seed/SeedService.cs
+++ b/src/FilterLists.Services/Seed/SeedService.cs
@@ -10,37 +10,35 @@
 namespace FilterLists.Services.Seed
 {
     [UsedImplicitly]
-    public class SeedService
+    public class SeedService : Service
     {
-        private readonly FilterListsDbContext _filterListsDbContext;
-
-        public SeedService(FilterListsDbContext filterListsDbContext)
+        public SeedService(FilterListsDbContext dbContext) : base(dbContext)
         {
-            _filterListsDbContext = filterListsDbContext;
+            DbContext = dbContext;
         }
 
         public async Task<IEnumerable<TSeedDto>> GetAllAsync<TEntity, TSeedDto>() where TEntity : class =>
-            await _filterListsDbContext.Set<TEntity>().AsNoTracking().ProjectTo<TSeedDto>().ToArrayAsync();
+            await DbContext.Set<TEntity>().AsNoTracking().ProjectTo<TSeedDto>().ToArrayAsync();
 
         public async Task<IEnumerable<TSeedDto>> GetAllAsync<TEntity, TSeedDto>(PropertyInfo primarySort)
             where TEntity : class
         {
-            return await _filterListsDbContext.Set<TEntity>()
-                                              .OrderBy(x => primarySort.GetValue(x, null))
-                                              .AsNoTracking()
-                                              .ProjectTo<TSeedDto>()
-                                              .ToArrayAsync();
+            return await DbContext.Set<TEntity>()
+                                  .OrderBy(x => primarySort.GetValue(x, null))
+                                  .AsNoTracking()
+                                  .ProjectTo<TSeedDto>()
+                                  .ToArrayAsync();
         }
 
         public async Task<IEnumerable<TSeedDto>> GetAllAsync<TEntity, TSeedDto>(PropertyInfo primarySort,
             PropertyInfo secondarySort) where TEntity : class
         {
-            return await _filterListsDbContext.Set<TEntity>()
-                                              .OrderBy(x => primarySort.GetValue(x, null))
-                                              .ThenBy(x => secondarySort.GetValue(x, null))
-                                              .AsNoTracking()
-                                              .ProjectTo<TSeedDto>()
-                                              .ToArrayAsync();
+            return await DbContext.Set<TEntity>()
+                                  .OrderBy(x => primarySort.GetValue(x, null))
+                                  .ThenBy(x => secondarySort.GetValue(x, null))
+                                  .AsNoTracking()
+                                  .ProjectTo<TSeedDto>()
+                                  .ToArrayAsync();
         }
     }
 }
\ No newline at end of file
diff --git a/src/FilterLists.Services/Service.cs b/src/FilterLists.Services/Service.cs
new file mode 100644
index 000000000..1aff547bd
--- /dev/null
+++ b/src/FilterLists.Services/Service.cs
@@ -0,0 +1,16 @@
+using FilterLists.Data;
+using JetBrains.Annotations;
+
+namespace FilterLists.Services
+{
+    [UsedImplicitly]
+    public class Service
+    {
+        protected FilterListsDbContext DbContext;
+
+        public Service(FilterListsDbContext dbContext)
+        {
+            DbContext = dbContext;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/FilterLists.Services/Snapshot/SnapshotService.cs b/src/FilterLists.Services/Snapshot/SnapshotService.cs
index df3a473a5..1fc9430aa 100644
--- a/src/FilterLists.Services/Snapshot/SnapshotService.cs
+++ b/src/FilterLists.Services/Snapshot/SnapshotService.cs
@@ -10,15 +10,14 @@
 namespace FilterLists.Services.Snapshot
 {
     [UsedImplicitly]
-    public class SnapshotService
+    public class SnapshotService : Service
     {
         //TODO: update algorithm to support non-standard list sizes and formats (#200, #201)
         private readonly List<int> _ignoreLists = new List<int> {48, 149, 173, 185, 186, 187, 188, 189, 352};
-        private readonly FilterListsDbContext dbContext;
 
-        public SnapshotService(FilterListsDbContext dbContext)
+        public SnapshotService(FilterListsDbContext dbContext) : base(dbContext)
         {
-            this.dbContext = dbContext;
+            DbContext = dbContext;
         }
 
         public async Task CaptureAsync(int batchSize)
@@ -31,14 +30,14 @@ public async Task CaptureAsync(int batchSize)
 
         private void RollbackIncompletedSnapshots()
         {
-            var incompleteSnapshots = dbContext.Snapshots.Where(ss => ss.IsCompleted == false);
-            dbContext.Snapshots.RemoveRange(incompleteSnapshots);
+            var incompleteSnapshots = DbContext.Snapshots.Where(ss => ss.IsCompleted == false);
+            DbContext.Snapshots.RemoveRange(incompleteSnapshots);
             //TODO: don't assume that SnapshotDe.DedupSnapshotRules() didn't partially complete
         }
 
         private async Task<IEnumerable<FilterListViewUrlDto>> GetListsToCapture(int batchSize)
         {
-            return await dbContext
+            return await DbContext
                          .FilterLists
                          .Where(list =>
                              (!list.Snapshots.Any() ||
@@ -58,7 +57,7 @@ private async Task<IEnumerable<FilterListViewUrlDto>> GetListsToCapture(int batc
 
         private IEnumerable<SnapshotDe> GetSnapshots(IEnumerable<FilterListViewUrlDto> lists)
         {
-            return lists.Select(list => new SnapshotDe(dbContext, list));
+            return lists.Select(list => new SnapshotDe(DbContext, list));
         }
 
         private static async Task SaveSnapshots(IEnumerable<SnapshotDe> snapshots)