Restructured the project structure back to the way it was, there's no reasonable way to split the modules

src/NadekoBot/Db/Extensions/ClubExtensions.cs

@@ -0,0 +1,34 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using NadekoBot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class ClubExtensions
+{
+    private static IQueryable<ClubInfo> Include(this DbSet<ClubInfo> clubs)
+        => clubs.Include(x => x.Owner)
+                .Include(x => x.Applicants)
+                .ThenInclude(x => x.User)
+                .Include(x => x.Bans)
+                .ThenInclude(x => x.User)
+                .Include(x => x.Members)
+                .AsQueryable();
+
+    public static ClubInfo GetByOwner(this DbSet<ClubInfo> clubs, ulong userId)
+        => Include(clubs).FirstOrDefault(c => c.Owner.UserId == userId);
+
+    public static ClubInfo GetByOwnerOrAdmin(this DbSet<ClubInfo> clubs, ulong userId)
+        => Include(clubs)
+            .FirstOrDefault(c => c.Owner.UserId == userId || c.Members.Any(u => u.UserId == userId && u.IsClubAdmin));
+
+    public static ClubInfo GetByMember(this DbSet<ClubInfo> clubs, ulong userId)
+        => Include(clubs).FirstOrDefault(c => c.Members.Any(u => u.UserId == userId));
+
+    public static ClubInfo GetByName(this DbSet<ClubInfo> clubs, string name)
+        => Include(clubs)
+            .FirstOrDefault(c => c.Name == name);
+
+    public static List<ClubInfo> GetClubLeaderboardPage(this DbSet<ClubInfo> clubs, int page)
+        => clubs.AsNoTracking().OrderByDescending(x => x.Xp).Skip(page * 9).Take(9).ToList();
+}

src/NadekoBot/Db/Extensions/CurrencyTransactionExtensions.cs

@@ -0,0 +1,20 @@
+#nullable disable
+using LinqToDB.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
+using Nadeko.Bot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class CurrencyTransactionExtensions
+{
+    public static Task<List<CurrencyTransaction>> GetPageFor(
+        this DbSet<CurrencyTransaction> set,
+        ulong userId,
+        int page)
+        => set.ToLinqToDBTable()
+            .Where(x => x.UserId == userId)
+            .OrderByDescending(x => x.DateAdded)
+            .Skip(15 * page)
+            .Take(15)
+            .ToListAsyncLinqToDB();
+}

src/NadekoBot/Db/Extensions/DbExtensions.cs

@@ -0,0 +1,12 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using Nadeko.Bot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class DbExtensions
+{
+    public static T GetById<T>(this DbSet<T> set, int id)
+        where T : DbEntity
+        => set.FirstOrDefault(x => x.Id == id);
+}

src/NadekoBot/Db/Extensions/DiscordUserExtensions.cs

@@ -0,0 +1,125 @@
+#nullable disable
+using LinqToDB;
+using LinqToDB.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
+using NadekoBot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class DiscordUserExtensions
+{
+    public static Task<DiscordUser> GetByUserIdAsync(
+        this IQueryable<DiscordUser> set,
+        ulong userId)
+        => set.FirstOrDefaultAsyncLinqToDB(x => x.UserId == userId);
+
+    public static void EnsureUserCreated(
+        this DbContext ctx,
+        ulong userId,
+        string username,
+        string discrim,
+        string avatarId)
+        => ctx.GetTable<DiscordUser>()
+            .InsertOrUpdate(
+                () => new()
+                {
+                    UserId = userId,
+                    Username = username,
+                    Discriminator = discrim,
+                    AvatarId = avatarId,
+                    TotalXp = 0,
+                    CurrencyAmount = 0
+                },
+                old => new()
+                {
+                    Username = username,
+                    Discriminator = discrim,
+                    AvatarId = avatarId
+                },
+                () => new()
+                {
+                    UserId = userId
+                });
+
+    public static Task EnsureUserCreatedAsync(
+        this DbContext ctx,
+        ulong userId)
+        => ctx.GetTable<DiscordUser>()
+            .InsertOrUpdateAsync(
+                () => new()
+                {
+                    UserId = userId,
+                    Username = "Unknown",
+                    Discriminator = "????",
+                    AvatarId = string.Empty,
+                    TotalXp = 0,
+                    CurrencyAmount = 0
+                },
+                old => new()
+                {
+                },
+                () => new()
+                {
+                    UserId = userId
+                });
+
+    //temp is only used in updatecurrencystate, so that i don't overwrite real usernames/discrims with Unknown
+    public static DiscordUser GetOrCreateUser(
+        this DbContext ctx,
+        ulong userId,
+        string username,
+        string discrim,
+        string avatarId,
+        Func<IQueryable<DiscordUser>, IQueryable<DiscordUser>> includes = null)
+    {
+        ctx.EnsureUserCreated(userId, username, discrim, avatarId);
+
+        IQueryable<DiscordUser> queryable = ctx.Set<DiscordUser>();
+        if (includes is not null)
+            queryable = includes(queryable);
+        return queryable.First(u => u.UserId == userId);
+    }
+
+
+    public static int GetUserGlobalRank(this DbSet<DiscordUser> users, ulong id)
+        => users.AsQueryable()
+               .Where(x => x.TotalXp
+                           > users.AsQueryable().Where(y => y.UserId == id).Select(y => y.TotalXp).FirstOrDefault())
+               .Count()
+           + 1;
+
+    public static DiscordUser[] GetUsersXpLeaderboardFor(this DbSet<DiscordUser> users, int page, int perPage)
+        => users.AsQueryable().OrderByDescending(x => x.TotalXp).Skip(page * perPage).Take(perPage).AsEnumerable()
+            .ToArray();
+
+    public static Task<List<DiscordUser>> GetTopRichest(
+        this DbSet<DiscordUser> users,
+        ulong botId,
+        int page = 0, int perPage = 9)
+        => users.AsQueryable()
+            .Where(c => c.CurrencyAmount > 0 && botId != c.UserId)
+            .OrderByDescending(c => c.CurrencyAmount)
+            .Skip(page * perPage)
+            .Take(perPage)
+            .ToListAsyncLinqToDB();
+
+    public static async Task<long> GetUserCurrencyAsync(this DbSet<DiscordUser> users, ulong userId)
+        => (await users.FirstOrDefaultAsyncLinqToDB(x => x.UserId == userId))?.CurrencyAmount ?? 0;
+
+    public static void RemoveFromMany(this DbSet<DiscordUser> users, IEnumerable<ulong> ids)
+    {
+        var items = users.AsQueryable().Where(x => ids.Contains(x.UserId));
+        foreach (var item in items)
+            item.CurrencyAmount = 0;
+    }
+
+    public static decimal GetTotalCurrency(this DbSet<DiscordUser> users)
+        => users.Sum((Func<DiscordUser, decimal>)(x => x.CurrencyAmount));
+
+    public static decimal GetTopOnePercentCurrency(this DbSet<DiscordUser> users, ulong botId)
+        => users.AsQueryable()
+            .Where(x => x.UserId != botId)
+            .OrderByDescending(x => x.CurrencyAmount)
+            .Take(users.Count() / 100 == 0 ? 1 : users.Count() / 100)
+            .Sum(x => x.CurrencyAmount);
+}

src/NadekoBot/Db/Extensions/GuildConfigExtensions.cs

@@ -0,0 +1,229 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using NadekoBot.Db.Models;
+
+using Nadeko.Bot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class GuildConfigExtensions
+{
+    private static List<WarningPunishment> DefaultWarnPunishments
+        => new()
+        {
+            new()
+            {
+                Count = 3,
+                Punishment = PunishmentAction.Kick
+            },
+            new()
+            {
+                Count = 5,
+                Punishment = PunishmentAction.Ban
+            }
+        };
+
+    /// <summary>
+    ///     Gets full stream role settings for the guild with the specified id.
+    /// </summary>
+    /// <param name="ctx">Db Context</param>
+    /// <param name="guildId">Id of the guild to get stream role settings for.</param>
+    /// <returns>Guild'p stream role settings</returns>
+    public static StreamRoleSettings GetStreamRoleSettings(this DbContext ctx, ulong guildId)
+    {
+        var conf = ctx.GuildConfigsForId(guildId,
+            set => set.Include(y => y.StreamRole)
+                .Include(y => y.StreamRole.Whitelist)
+                .Include(y => y.StreamRole.Blacklist));
+
+        if (conf.StreamRole is null)
+            conf.StreamRole = new();
+
+        return conf.StreamRole;
+    }
+
+    private static IQueryable<GuildConfig> IncludeEverything(this DbSet<GuildConfig> configs)
+        => configs.AsQueryable()
+            .AsSplitQuery()
+            .Include(gc => gc.CommandCooldowns)
+            .Include(gc => gc.FollowedStreams)
+            .Include(gc => gc.StreamRole)
+            .Include(gc => gc.XpSettings)
+            .ThenInclude(x => x.ExclusionList)
+            .Include(gc => gc.DelMsgOnCmdChannels);
+
+    public static IEnumerable<GuildConfig> GetAllGuildConfigs(
+        this DbSet<GuildConfig> configs,
+        IReadOnlyList<ulong> availableGuilds)
+        => configs.IncludeEverything().AsNoTracking().Where(x => availableGuilds.Contains(x.GuildId)).ToList();
+
+    /// <summary>
+    ///     Gets and creates if it doesn't exist a config for a guild.
+    /// </summary>
+    /// <param name="ctx">Context</param>
+    /// <param name="guildId">Id of the guide</param>
+    /// <param name="includes">Use to manipulate the set however you want. Pass null to include everything</param>
+    /// <returns>Config for the guild</returns>
+    public static GuildConfig GuildConfigsForId(
+        this DbContext ctx,
+        ulong guildId,
+        Func<DbSet<GuildConfig>, IQueryable<GuildConfig>> includes)
+    {
+        GuildConfig config;
+
+        if (includes is null)
+            config = ctx.Set<GuildConfig>().IncludeEverything().FirstOrDefault(c => c.GuildId == guildId);
+        else
+        {
+            var set = includes(ctx.Set<GuildConfig>());
+            config = set.FirstOrDefault(c => c.GuildId == guildId);
+        }
+
+        if (config is null)
+        {
+            ctx.Set<GuildConfig>().Add(config = new()
+            {
+                GuildId = guildId,
+                Permissions = Permissionv2.GetDefaultPermlist,
+                WarningsInitialized = true,
+                WarnPunishments = DefaultWarnPunishments
+            });
+            ctx.SaveChanges();
+        }
+
+        if (!config.WarningsInitialized)
+        {
+            config.WarningsInitialized = true;
+            config.WarnPunishments = DefaultWarnPunishments;
+        }
+
+        return config;
+
+        // ctx.GuildConfigs
+        //    .ToLinqToDBTable()
+        //    .InsertOrUpdate(() => new()
+        //        {
+        //            GuildId = guildId,
+        //            Permissions = Permissionv2.GetDefaultPermlist,
+        //            WarningsInitialized = true,
+        //            WarnPunishments = DefaultWarnPunishments
+        //        },
+        //        _ => new(),
+        //        () => new()
+        //        {
+        //            GuildId = guildId
+        //        });
+        //
+        // if(includes is null)
+        // return ctx.GuildConfigs
+        //    .ToLinqToDBTable()
+        //    .First(x => x.GuildId == guildId);
+    }
+
+    public static LogSetting LogSettingsFor(this DbContext ctx, ulong guildId)
+    {
+        var logSetting = ctx.Set<LogSetting>()
+            .AsQueryable()
+            .Include(x => x.LogIgnores)
+            .Where(x => x.GuildId == guildId)
+            .FirstOrDefault();
+
+        if (logSetting is null)
+        {
+            ctx.Set<LogSetting>()
+                .Add(logSetting = new()
+                {
+                    GuildId = guildId
+                });
+            ctx.SaveChanges();
+        }
+
+        return logSetting;
+    }
+
+    public static IEnumerable<GuildConfig> PermissionsForAll(this DbSet<GuildConfig> configs, List<ulong> include)
+    {
+        var query = configs.AsQueryable().Where(x => include.Contains(x.GuildId)).Include(gc => gc.Permissions);
+
+        return query.ToList();
+    }
+
+    public static GuildConfig GcWithPermissionsFor(this DbContext ctx, ulong guildId)
+    {
+        var config = ctx.Set<GuildConfig>().AsQueryable()
+            .Where(gc => gc.GuildId == guildId)
+            .Include(gc => gc.Permissions)
+            .FirstOrDefault();
+
+        if (config is null) // if there is no guildconfig, create new one
+        {
+            ctx.Set<GuildConfig>().Add(config = new()
+            {
+                GuildId = guildId,
+                Permissions = Permissionv2.GetDefaultPermlist
+            });
+            ctx.SaveChanges();
+        }
+        else if (config.Permissions is null || !config.Permissions.Any()) // if no perms, add default ones
+        {
+            config.Permissions = Permissionv2.GetDefaultPermlist;
+            ctx.SaveChanges();
+        }
+
+        return config;
+    }
+
+    public static IEnumerable<FollowedStream> GetFollowedStreams(this DbSet<GuildConfig> configs)
+        => configs.AsQueryable().Include(x => x.FollowedStreams).SelectMany(gc => gc.FollowedStreams).ToArray();
+
+    public static IEnumerable<FollowedStream> GetFollowedStreams(this DbSet<GuildConfig> configs, List<ulong> included)
+        => configs.AsQueryable()
+            .Where(gc => included.Contains(gc.GuildId))
+            .Include(gc => gc.FollowedStreams)
+            .SelectMany(gc => gc.FollowedStreams)
+            .ToList();
+
+    public static void SetCleverbotEnabled(this DbSet<GuildConfig> configs, ulong id, bool cleverbotEnabled)
+    {
+        var conf = configs.FirstOrDefault(gc => gc.GuildId == id);
+
+        if (conf is null)
+            return;
+
+        conf.CleverbotEnabled = cleverbotEnabled;
+    }
+
+    public static XpSettings XpSettingsFor(this DbContext ctx, ulong guildId)
+    {
+        var gc = ctx.GuildConfigsForId(guildId,
+            set => set.Include(x => x.XpSettings)
+                .ThenInclude(x => x.RoleRewards)
+                .Include(x => x.XpSettings)
+                .ThenInclude(x => x.CurrencyRewards)
+                .Include(x => x.XpSettings)
+                .ThenInclude(x => x.ExclusionList));
+
+        if (gc.XpSettings is null)
+            gc.XpSettings = new();
+
+        return gc.XpSettings;
+    }
+
+    public static IEnumerable<GeneratingChannel> GetGeneratingChannels(this DbSet<GuildConfig> configs)
+        => configs.AsQueryable()
+            .Include(x => x.GenerateCurrencyChannelIds)
+            .Where(x => x.GenerateCurrencyChannelIds.Any())
+            .SelectMany(x => x.GenerateCurrencyChannelIds)
+            .Select(x => new GeneratingChannel
+            {
+                ChannelId = x.ChannelId,
+                GuildId = x.GuildConfig.GuildId
+            })
+            .ToArray();
+
+    public class GeneratingChannel
+    {
+        public ulong GuildId { get; set; }
+        public ulong ChannelId { get; set; }
+    }
+}

src/NadekoBot/Db/Extensions/NadekoExpressionExtensions.cs

@@ -0,0 +1,15 @@
+#nullable disable
+using LinqToDB;
+using Microsoft.EntityFrameworkCore;
+using Nadeko.Bot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class NadekoExpressionExtensions
+{
+    public static int ClearFromGuild(this DbSet<NadekoExpression> exprs, ulong guildId)
+        => exprs.Delete(x => x.GuildId == guildId);
+
+    public static IEnumerable<NadekoExpression> ForId(this DbSet<NadekoExpression> exprs, ulong id)
+        => exprs.AsNoTracking().AsQueryable().Where(x => x.GuildId == id).ToList();
+}

src/NadekoBot/Db/Extensions/QuoteExtensions.cs

@@ -0,0 +1,53 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using Nadeko.Bot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class QuoteExtensions
+{
+    public static IEnumerable<Quote> GetForGuild(this DbSet<Quote> quotes, ulong guildId)
+        => quotes.AsQueryable().Where(x => x.GuildId == guildId);
+
+    public static IReadOnlyCollection<Quote> GetGroup(
+        this DbSet<Quote> quotes,
+        ulong guildId,
+        int page,
+        OrderType order)
+    {
+        var q = quotes.AsQueryable().Where(x => x.GuildId == guildId);
+        if (order == OrderType.Keyword)
+            q = q.OrderBy(x => x.Keyword);
+        else
+            q = q.OrderBy(x => x.Id);
+
+        return q.Skip(15 * page).Take(15).ToArray();
+    }
+
+    public static async Task<Quote> GetRandomQuoteByKeywordAsync(
+        this DbSet<Quote> quotes,
+        ulong guildId,
+        string keyword)
+    {
+        return (await quotes.AsQueryable().Where(q => q.GuildId == guildId && q.Keyword == keyword).ToArrayAsync())
+            .RandomOrDefault();
+    }
+
+    public static async Task<Quote> SearchQuoteKeywordTextAsync(
+        this DbSet<Quote> quotes,
+        ulong guildId,
+        string keyword,
+        string text)
+    {
+        return (await quotes.AsQueryable()
+                            .Where(q => q.GuildId == guildId
+                                        && (keyword == null || q.Keyword == keyword)
+                                        && (EF.Functions.Like(q.Text.ToUpper(), $"%{text.ToUpper()}%")
+                                            || EF.Functions.Like(q.AuthorName, text)))
+                            .ToArrayAsync())
+               .RandomOrDefault();
+    }
+
+    public static void RemoveAllByKeyword(this DbSet<Quote> quotes, ulong guildId, string keyword)
+        => quotes.RemoveRange(quotes.AsQueryable().Where(x => x.GuildId == guildId && x.Keyword.ToUpper() == keyword));
+}

src/NadekoBot/Db/Extensions/ReminderExtensions.cs

@@ -0,0 +1,23 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using Nadeko.Bot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class ReminderExtensions
+{
+    public static IEnumerable<Reminder> GetIncludedReminders(
+        this DbSet<Reminder> reminders,
+        IEnumerable<ulong> guildIds)
+        => reminders.AsQueryable().Where(x => guildIds.Contains(x.ServerId) || x.ServerId == 0).ToList();
+
+    public static IEnumerable<Reminder> RemindersFor(this DbSet<Reminder> reminders, ulong userId, int page)
+        => reminders.AsQueryable().Where(x => x.UserId == userId).OrderBy(x => x.DateAdded).Skip(page * 10).Take(10);
+
+    public static IEnumerable<Reminder> RemindersForServer(this DbSet<Reminder> reminders, ulong serverId, int page)
+        => reminders.AsQueryable()
+                    .Where(x => x.ServerId == serverId)
+                    .OrderBy(x => x.DateAdded)
+                    .Skip(page * 10)
+                    .Take(10);
+}

src/NadekoBot/Db/Extensions/SelfAssignableRolesExtensions.cs

@@ -0,0 +1,22 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using Nadeko.Bot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class SelfAssignableRolesExtensions
+{
+    public static bool DeleteByGuildAndRoleId(this DbSet<SelfAssignedRole> roles, ulong guildId, ulong roleId)
+    {
+        var role = roles.FirstOrDefault(s => s.GuildId == guildId && s.RoleId == roleId);
+
+        if (role is null)
+            return false;
+
+        roles.Remove(role);
+        return true;
+    }
+
+    public static IReadOnlyCollection<SelfAssignedRole> GetFromGuild(this DbSet<SelfAssignedRole> roles, ulong guildId)
+        => roles.AsQueryable().Where(s => s.GuildId == guildId).ToArray();
+}

src/NadekoBot/Db/Extensions/UserXpExtensions.cs

@@ -0,0 +1,72 @@
+#nullable disable
+using LinqToDB;
+using LinqToDB.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
+
+using Nadeko.Bot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class UserXpExtensions
+{
+    public static UserXpStats GetOrCreateUserXpStats(this DbContext ctx, ulong guildId, ulong userId)
+    {
+        var usr = ctx.Set<UserXpStats>().FirstOrDefault(x => x.UserId == userId && x.GuildId == guildId);
+
+        if (usr is null)
+        {
+            ctx.Add(usr = new()
+            {
+                Xp = 0,
+                UserId = userId,
+                NotifyOnLevelUp = XpNotificationLocation.None,
+                GuildId = guildId
+            });
+        }
+
+        return usr;
+    }
+
+    public static List<UserXpStats> GetUsersFor(this DbSet<UserXpStats> xps, ulong guildId, int page)
+        => xps.AsQueryable()
+              .AsNoTracking()
+              .Where(x => x.GuildId == guildId)
+              .OrderByDescending(x => x.Xp + x.AwardedXp)
+              .Skip(page * 9)
+              .Take(9)
+              .ToList();
+
+    public static List<UserXpStats> GetTopUserXps(this DbSet<UserXpStats> xps, ulong guildId, int count)
+        => xps.AsQueryable()
+              .AsNoTracking()
+              .Where(x => x.GuildId == guildId)
+              .OrderByDescending(x => x.Xp + x.AwardedXp)
+              .Take(count)
+              .ToList();
+
+    public static int GetUserGuildRanking(this DbSet<UserXpStats> xps, ulong userId, ulong guildId)
+        => xps.AsQueryable()
+              .AsNoTracking()
+              .Where(x => x.GuildId == guildId
+                          && x.Xp + x.AwardedXp
+                          > xps.AsQueryable()
+                               .Where(y => y.UserId == userId && y.GuildId == guildId)
+                               .Select(y => y.Xp + y.AwardedXp)
+                               .FirstOrDefault())
+              .Count()
+           + 1;
+
+    public static void ResetGuildUserXp(this DbSet<UserXpStats> xps, ulong userId, ulong guildId)
+        => xps.Delete(x => x.UserId == userId && x.GuildId == guildId);
+
+    public static void ResetGuildXp(this DbSet<UserXpStats> xps, ulong guildId)
+        => xps.Delete(x => x.GuildId == guildId);
+    
+    public static async Task<LevelStats> GetLevelDataFor(this ITable<UserXpStats> userXp, ulong guildId, ulong userId)
+            => await userXp
+                     .Where(x => x.GuildId == guildId && x.UserId == userId)
+                     .FirstOrDefaultAsyncLinqToDB() is UserXpStats uxs
+                ? new(uxs.Xp + uxs.AwardedXp)
+                : new(0);
+    
+}

src/NadekoBot/Db/Extensions/WarningExtensions.cs

@@ -0,0 +1,60 @@
+#nullable disable
+using Microsoft.EntityFrameworkCore;
+using Nadeko.Bot.Db.Models;
+
+namespace NadekoBot.Db;
+
+public static class WarningExtensions
+{
+    public static Warning[] ForId(this DbSet<Warning> warnings, ulong guildId, ulong userId)
+    {
+        var query = warnings.AsQueryable()
+                            .Where(x => x.GuildId == guildId && x.UserId == userId)
+                            .OrderByDescending(x => x.DateAdded);
+
+        return query.ToArray();
+    }
+
+    public static bool Forgive(
+        this DbSet<Warning> warnings,
+        ulong guildId,
+        ulong userId,
+        string mod,
+        int index)
+    {
+        if (index < 0)
+            throw new ArgumentOutOfRangeException(nameof(index));
+
+        var warn = warnings.AsQueryable()
+                           .Where(x => x.GuildId == guildId && x.UserId == userId)
+                           .OrderByDescending(x => x.DateAdded)
+                           .Skip(index)
+                           .FirstOrDefault();
+
+        if (warn is null || warn.Forgiven)
+            return false;
+
+        warn.Forgiven = true;
+        warn.ForgivenBy = mod;
+        return true;
+    }
+
+    public static async Task ForgiveAll(
+        this DbSet<Warning> warnings,
+        ulong guildId,
+        ulong userId,
+        string mod)
+        => await warnings.AsQueryable()
+                         .Where(x => x.GuildId == guildId && x.UserId == userId)
+                         .ForEachAsync(x =>
+                         {
+                             if (x.Forgiven != true)
+                             {
+                                 x.Forgiven = true;
+                                 x.ForgivenBy = mod;
+                             }
+                         });
+
+    public static Warning[] GetForGuild(this DbSet<Warning> warnings, ulong id)
+        => warnings.AsQueryable().Where(x => x.GuildId == id).ToArray();
+}