Added and applied styles for private readonly fields, private fields to Extensions and Common folders.

- Some renamings and code cleanups
- Chained method calls, binary expressions and binary patterns will now break into newlines
- Type param constraints and base constructor calls will be on the new line

src/NadekoBot/Db/Extensions/ClubExtensions.cs

@@ -13,12 +13,13 @@ public static class ClubExtensions
             .ThenInclude(x => x.User)
             .Include(x => x.Users)
             .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.Users.Any(u => u.UserId == userId && u.IsClubAdmin));
+        => Include(clubs)
+            .FirstOrDefault(c => c.Owner.UserId == userId || c.Users.Any(u => u.UserId == userId && u.IsClubAdmin));
 
     public static ClubInfo GetByMember(this DbSet<ClubInfo> clubs, ulong userId)
         => Include(clubs).FirstOrDefault(c => c.Users.Any(u => u.UserId == userId));
@@ -27,17 +28,9 @@ public static class ClubExtensions
         => Include(clubs).FirstOrDefault(c => c.Name.ToUpper() == name.ToUpper() && c.Discrim == discrim);
 
     public static int GetNextDiscrim(this DbSet<ClubInfo> clubs, string name)
-        => Include(clubs)
-            .Where(x => x.Name.ToUpper() == name.ToUpper())
-            .Select(x => x.Discrim)
-            .DefaultIfEmpty()
-            .Max() + 1;
+        => Include(clubs).Where(x => x.Name.ToUpper() == name.ToUpper()).Select(x => x.Discrim).DefaultIfEmpty().Max() +
+           1;
 
     public static List<ClubInfo> GetClubLeaderboardPage(this DbSet<ClubInfo> clubs, int page)
-        => clubs
-            .AsNoTracking()
-            .OrderByDescending(x => x.Xp)
-            .Skip(page * 9)
-            .Take(9)
-            .ToList();
+        => clubs.AsNoTracking().OrderByDescending(x => x.Xp).Skip(page * 9).Take(9).ToList();
 }

src/NadekoBot/Db/Extensions/CustomReactionsExtensions.cs

@@ -10,11 +10,7 @@ public static class CustomReactionsExtensions
         => crs.Delete(x => x.GuildId == guildId);
 
     public static IEnumerable<CustomReaction> ForId(this DbSet<CustomReaction> crs, ulong id)
-        => crs
-            .AsNoTracking()
-            .AsQueryable()
-            .Where(x => x.GuildId == id)
-            .ToArray();
+        => crs.AsNoTracking().AsQueryable().Where(x => x.GuildId == id).ToList();
 
     public static CustomReaction GetByGuildIdAndInput(this DbSet<CustomReaction> crs, ulong? guildId, string input)
         => crs.FirstOrDefault(x => x.GuildId == guildId && x.Trigger.ToUpper() == input);

src/NadekoBot/Db/Extensions/DbExtensions.cs

@@ -5,6 +5,7 @@ namespace NadekoBot.Db;
 
 public static class DbExtensions
 {
-    public static T GetById<T>(this DbSet<T> set, int id) where T: DbEntity
+    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

@@ -8,10 +8,15 @@ namespace NadekoBot.Db;
 
 public static class DiscordUserExtensions
 {
-    public static void EnsureUserCreated(this NadekoContext ctx, ulong userId, string username, string discrim, string avatarId)
-        => ctx.DiscordUser
-            .ToLinqToDBTable()
-            .InsertOrUpdate(() => new()
+    public static void EnsureUserCreated(
+        this NadekoContext ctx,
+        ulong userId,
+        string username,
+        string discrim,
+        string avatarId)
+        => ctx.DiscordUser.ToLinqToDBTable()
+            .InsertOrUpdate(
+                () => new()
                 {
                     UserId = userId,
                     Username = username,
@@ -20,36 +25,44 @@ public static class DiscordUserExtensions
                     TotalXp = 0,
                     CurrencyAmount = 0
                 },
-                old => new()
-                {
-                    Username = username,
-                    Discriminator = discrim,
-                    AvatarId = avatarId,
-                }, () => new()
-                {
-                    UserId = userId
-                });
+                old => new() { Username = username, Discriminator = discrim, AvatarId = avatarId, },
+                () => 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 NadekoContext ctx, ulong userId, string username, string discrim, string avatarId)
+    public static DiscordUser GetOrCreateUser(
+        this NadekoContext ctx,
+        ulong userId,
+        string username,
+        string discrim,
+        string avatarId)
     {
-        ctx.EnsureUserCreated(userId, username, discrim, avatarId);
-        return ctx.DiscordUser
-            .Include(x => x.Club)
+        ctx.EnsureUserCreated(userId,
+            username,
+            discrim,
+            avatarId
+        );
+        return ctx.DiscordUser.Include(x => x.Club)
             .First(u => u.UserId == userId);
     }
 
     public static DiscordUser GetOrCreateUser(this NadekoContext ctx, IUser original)
-        => ctx.GetOrCreateUser(original.Id, original.Username, original.Discriminator, original.AvatarId);
+        => ctx.GetOrCreateUser(original.Id,
+            original.Username,
+            original.Discriminator,
+            original.AvatarId
+        );
 
     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;
+               .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)
         => users.AsQueryable()
@@ -59,7 +72,11 @@ public static class DiscordUserExtensions
             .AsEnumerable()
             .ToArray();
 
-    public static List<DiscordUser> GetTopRichest(this DbSet<DiscordUser> users, ulong botId, int count, int page = 0)
+    public static List<DiscordUser> GetTopRichest(
+        this DbSet<DiscordUser> users,
+        ulong botId,
+        int count,
+        int page = 0)
         => users.AsQueryable()
             .Where(c => c.CurrencyAmount > 0 && botId != c.UserId)
             .OrderByDescending(c => c.CurrencyAmount)
@@ -67,40 +84,44 @@ public static class DiscordUserExtensions
             .Take(count)
             .ToList();
 
-    public static List<DiscordUser> GetTopRichest(this DbSet<DiscordUser> users, ulong botId, int count)
-        => users.AsQueryable()
-            .Where(c => c.CurrencyAmount > 0 && botId != c.UserId)
-            .OrderByDescending(c => c.CurrencyAmount)
-            .Take(count)
-            .ToList();
-
-    public static long GetUserCurrency(this DbSet<DiscordUser> users, ulong userId) =>
-        users.AsNoTracking()
-            .FirstOrDefault(x => x.UserId == userId)
-            ?.CurrencyAmount ?? 0;
+    public static long GetUserCurrency(this DbSet<DiscordUser> users, ulong userId)
+        => users.AsNoTracking()
+               .FirstOrDefault(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));
+        var items = users.AsQueryable()
+            .Where(x => ids.Contains(x.UserId));
         foreach (var item in items)
         {
             item.CurrencyAmount = 0;
         }
     }
 
-    public static bool TryUpdateCurrencyState(this NadekoContext ctx, ulong userId, string name, string discrim, string avatarId, long amount, bool allowNegative = false)
+    public static bool TryUpdateCurrencyState(
+        this NadekoContext ctx,
+        ulong userId,
+        string name,
+        string discrim,
+        string avatarId,
+        long amount,
+        bool allowNegative = false)
     {
         if (amount == 0)
             return true;
 
         // if remove - try to remove if he has more or equal than the amount
         // and return number of rows > 0 (was there a change)
-        if (amount < 0 && !allowNegative)
+        if (amount < 0 &&
+            !allowNegative)
         {
             var rows = ctx.Database.ExecuteSqlInterpolated($@"
 UPDATE DiscordUser
 SET CurrencyAmount=CurrencyAmount+{amount}
-WHERE UserId={userId} AND CurrencyAmount>={-amount};");
+WHERE UserId={userId} AND CurrencyAmount>={-amount};"
+            );
             return rows > 0;
         }
 
@@ -110,7 +131,8 @@ WHERE UserId={userId} AND CurrencyAmount>={-amount};");
             var rows = ctx.Database.ExecuteSqlInterpolated($@"
 UPDATE DiscordUser
 SET CurrencyAmount=CurrencyAmount+{amount}
-WHERE UserId={userId};");
+WHERE UserId={userId};"
+            );
             return rows > 0;
         }
 
@@ -118,22 +140,22 @@ WHERE UserId={userId};");
         // if it exists, sum current amount with the new one, if it doesn't
         // he just has the new amount
         var updatedUserData = !string.IsNullOrWhiteSpace(name);
-        name = name ?? "Unknown";
-        discrim = discrim ?? "????";
-        avatarId = avatarId ?? "";
+        name ??= "Unknown";
+        discrim ??= "????";
+        avatarId ??= "";
 
         // just update the amount, there is no new user data
         if (!updatedUserData)
         {
-            var rows = ctx.Database.ExecuteSqlInterpolated($@"
+            ctx.Database.ExecuteSqlInterpolated($@"
 UPDATE OR IGNORE DiscordUser
 SET CurrencyAmount=CurrencyAmount+{amount}
 WHERE UserId={userId};
 
 INSERT OR IGNORE INTO DiscordUser (UserId, Username, Discriminator, AvatarId, CurrencyAmount, TotalXp)
 VALUES ({userId}, {name}, {discrim}, {avatarId}, {amount}, 0);
-");
-                
+"
+            );
         }
         else
         {
@@ -147,14 +169,15 @@ WHERE UserId={userId};
 
 INSERT OR IGNORE INTO DiscordUser (UserId, Username, Discriminator, AvatarId, CurrencyAmount, TotalXp)
 VALUES ({userId}, {name}, {discrim}, {avatarId}, {amount}, 0);
-");
+"
+            );
         }
+
         return true;
     }
 
     public static decimal GetTotalCurrency(this DbSet<DiscordUser> users)
-        => users
-            .Sum((Func<DiscordUser, decimal>)(x => x.CurrencyAmount));
+        => users.Sum((Func<DiscordUser, decimal>)(x => x.CurrencyAmount));
 
     public static decimal GetTopOnePercentCurrency(this DbSet<DiscordUser> users, ulong botId)
         => users.AsQueryable()

src/NadekoBot/Db/Extensions/GuildConfigExtensions.cs

@@ -12,7 +12,7 @@ public static class GuildConfigExtensions
         public ulong GuildId { get; set; }
         public ulong ChannelId { get; set; }
     }
-        
+
     /// <summary>
     /// Gets full stream role settings for the guild with the specified id.
     /// </summary>
@@ -21,31 +21,27 @@ public static class GuildConfigExtensions
     /// <returns>Guild'p stream role settings</returns>
     public static StreamRoleSettings GetStreamRoleSettings(this NadekoContext ctx, ulong guildId)
     {
-        var conf = ctx.GuildConfigsForId(guildId, set => set.Include(y => y.StreamRole)
-            .Include(y => y.StreamRole.Whitelist)
-            .Include(y => y.StreamRole.Blacklist));
+        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 List<WarningPunishment> DefaultWarnPunishments =>
-        new() {
-            new() {
-                Count = 3,
-                Punishment = PunishmentAction.Kick
-            },
-            new() {
-                Count = 5,
-                Punishment = PunishmentAction.Ban
-            }
+
+    private static List<WarningPunishment> DefaultWarnPunishments
+        => new()
+        {
+            new() { Count = 3, Punishment = PunishmentAction.Kick },
+            new() { Count = 5, Punishment = PunishmentAction.Ban }
         };
 
     private static IQueryable<GuildConfig> IncludeEverything(this DbSet<GuildConfig> configs)
-        => configs
-            .AsQueryable()
+        => configs.AsQueryable()
             .AsSplitQuery()
             .Include(gc => gc.CommandCooldowns)
             .Include(gc => gc.FollowedStreams)
@@ -56,9 +52,10 @@ public static class GuildConfigExtensions
             .Include(gc => gc.ReactionRoleMessages)
             .ThenInclude(x => x.ReactionRoles);
 
-    public static IEnumerable<GuildConfig> GetAllGuildConfigs(this DbSet<GuildConfig> configs, List<ulong> availableGuilds)
-        => configs
-            .IncludeEverything()
+    public static IEnumerable<GuildConfig> GetAllGuildConfigs(
+        this DbSet<GuildConfig> configs,
+        List<ulong> availableGuilds)
+        => configs.IncludeEverything()
             .AsNoTracking()
             .Where(x => availableGuilds.Contains(x.GuildId))
             .ToList();
@@ -70,15 +67,16 @@ public static class GuildConfigExtensions
     /// <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 NadekoContext ctx, ulong guildId, Func<DbSet<GuildConfig>, IQueryable<GuildConfig>> includes)
+    public static GuildConfig GuildConfigsForId(
+        this NadekoContext ctx,
+        ulong guildId,
+        Func<DbSet<GuildConfig>, IQueryable<GuildConfig>> includes)
     {
         GuildConfig config;
 
         if (includes is null)
         {
-            config = ctx
-                .GuildConfigs
-                .IncludeEverything()
+            config = ctx.GuildConfigs.IncludeEverything()
                 .FirstOrDefault(c => c.GuildId == guildId);
         }
         else
@@ -90,12 +88,13 @@ public static class GuildConfigExtensions
         if (config is null)
         {
             ctx.GuildConfigs.Add(config = new()
-            {
-                GuildId = guildId,
-                Permissions = Permissionv2.GetDefaultPermlist,
-                WarningsInitialized = true,
-                WarnPunishments = DefaultWarnPunishments,
-            });
+                {
+                    GuildId = guildId,
+                    Permissions = Permissionv2.GetDefaultPermlist,
+                    WarningsInitialized = true,
+                    WarnPunishments = DefaultWarnPunishments,
+                }
+            );
             ctx.SaveChanges();
         }
 
@@ -110,21 +109,17 @@ public static class GuildConfigExtensions
 
     public static LogSetting LogSettingsFor(this NadekoContext ctx, ulong guildId)
     {
-        var logSetting = ctx.LogSettings
-            .AsQueryable()
+        var logSetting = ctx.LogSettings.AsQueryable()
             .Include(x => x.LogIgnores)
             .Where(x => x.GuildId == guildId)
             .FirstOrDefault();
 
         if (logSetting is null)
         {
-            ctx.LogSettings.Add(logSetting = new ()
-            {
-                GuildId = guildId
-            });
+            ctx.LogSettings.Add(logSetting = new() { GuildId = guildId });
             ctx.SaveChanges();
         }
-            
+
         return logSetting;
     }
 
@@ -139,23 +134,18 @@ public static class GuildConfigExtensions
 
     public static GuildConfig GcWithPermissionsv2For(this NadekoContext ctx, ulong guildId)
     {
-        var config = ctx
-            .GuildConfigs
-            .AsQueryable()
+        var config = ctx.GuildConfigs.AsQueryable()
             .Where(gc => gc.GuildId == guildId)
             .Include(gc => gc.Permissions)
             .FirstOrDefault();
 
         if (config is null) // if there is no guildconfig, create new one
         {
-            ctx.GuildConfigs.Add(config = new()
-            {
-                GuildId = guildId,
-                Permissions = Permissionv2.GetDefaultPermlist
-            });
+            ctx.GuildConfigs.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
+        else if (config.Permissions is null ||
+                 !config.Permissions.Any()) // if no perms, add default ones
         {
             config.Permissions = Permissionv2.GetDefaultPermlist;
             ctx.SaveChanges();
@@ -165,8 +155,7 @@ public static class GuildConfigExtensions
     }
 
     public static IEnumerable<FollowedStream> GetFollowedStreams(this DbSet<GuildConfig> configs)
-        => configs
-            .AsQueryable()
+        => configs.AsQueryable()
             .Include(x => x.FollowedStreams)
             .SelectMany(gc => gc.FollowedStreams)
             .ToArray();
@@ -196,7 +185,8 @@ public static class GuildConfigExtensions
                 .Include(x => x.XpSettings)
                 .ThenInclude(x => x.CurrencyRewards)
                 .Include(x => x.XpSettings)
-                .ThenInclude(x => x.ExclusionList));
+                .ThenInclude(x => x.ExclusionList)
+        );
 
         if (gc.XpSettings is null)
             gc.XpSettings = new XpSettings();
@@ -205,15 +195,10 @@ public static class GuildConfigExtensions
     }
 
     public static IEnumerable<GeneratingChannel> GetGeneratingChannels(this DbSet<GuildConfig> configs)
-        => configs
-            .AsQueryable()
+        => 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
-            })
+            .Select(x => new GeneratingChannel() { ChannelId = x.ChannelId, GuildId = x.GuildConfig.GuildId })
             .ToArray();
 }

src/NadekoBot/Db/Extensions/MusicPlayerSettingsExtensions.cs

@@ -7,17 +7,12 @@ public static class MusicPlayerSettingsExtensions
 {
     public static async Task<MusicPlayerSettings> ForGuildAsync(this DbSet<MusicPlayerSettings> settings, ulong guildId)
     {
-        var toReturn = await settings
-            .AsQueryable()
+        var toReturn = await settings.AsQueryable()
             .FirstOrDefaultAsync(x => x.GuildId == guildId);
 
         if (toReturn is null)
         {
-            var newSettings = new MusicPlayerSettings()
-            {
-                GuildId = guildId,
-                PlayerRepeat = PlayerRepeatType.Queue
-            };
+            var newSettings = new MusicPlayerSettings() { GuildId = guildId, PlayerRepeat = PlayerRepeatType.Queue };
 
             await settings.AddAsync(newSettings);
             return newSettings;

src/NadekoBot/Db/Extensions/MusicPlaylistExtensions.cs

@@ -10,16 +10,14 @@ public static class MusicPlaylistExtensions
         if (num < 1)
             throw new IndexOutOfRangeException();
 
-        return playlists
-            .AsQueryable()
+        return playlists.AsQueryable()
             .Skip((num - 1) * 20)
             .Take(20)
             .Include(pl => pl.Songs)
             .ToList();
     }
 
-    public static MusicPlaylist GetWithSongs(this DbSet<MusicPlaylist> playlists, int id) => 
-        playlists
-            .Include(mpl => mpl.Songs)
+    public static MusicPlaylist GetWithSongs(this DbSet<MusicPlaylist> playlists, int id)
+        => playlists.Include(mpl => mpl.Songs)
             .FirstOrDefault(mpl => mpl.Id == id);
 }

src/NadekoBot/Db/Extensions/PollExtensions.cs

@@ -13,27 +13,25 @@ public static class PollExtensions
 
     public static void RemovePoll(this NadekoContext ctx, int id)
     {
-        var p = ctx
-            .Poll
-            .Include(x => x.Answers)
+        var p = ctx.Poll.Include(x => x.Answers)
             .Include(x => x.Votes)
             .FirstOrDefault(x => x.Id == id);
 
         if (p is null)
             return;
-            
+
         if (p.Votes != null)
         {
             ctx.RemoveRange(p.Votes);
             p.Votes.Clear();
         }
-            
+
         if (p.Answers != null)
         {
             ctx.RemoveRange(p.Answers);
             p.Answers.Clear();
         }
-            
+
         ctx.Poll.Remove(p);
     }
 }

src/NadekoBot/Db/Extensions/QuoteExtensions.cs

@@ -6,43 +6,58 @@ 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);
+        => quotes.AsQueryable()
+            .Where(x => x.GuildId == guildId);
 
-    public static IEnumerable<Quote> GetGroup(this DbSet<Quote> quotes, ulong guildId, int page, OrderType order)
+    public static IEnumerable<Quote> GetGroup(
+        this DbSet<Quote> quotes,
+        ulong guildId,
+        int page,
+        OrderType order)
     {
-        var q = quotes.AsQueryable().Where(x => x.GuildId == guildId);
+        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();
+        return q.Skip(15 * page)
+            .Take(15)
+            .ToArray();
     }
 
-    public static async Task<Quote> GetRandomQuoteByKeywordAsync(this DbSet<Quote> quotes, ulong guildId, string keyword)
+    public static async Task<Quote> GetRandomQuoteByKeywordAsync(
+        this DbSet<Quote> quotes,
+        ulong guildId,
+        string keyword)
     {
         var rng = new NadekoRandom();
         return (await quotes.AsQueryable()
                 .Where(q => q.GuildId == guildId && q.Keyword == keyword)
-                .ToListAsync())
-            .OrderBy(q => rng.Next())
+                .ToListAsync()).OrderBy(q => rng.Next())
             .FirstOrDefault();
     }
 
-    public static async Task<Quote> SearchQuoteKeywordTextAsync(this DbSet<Quote> quotes, ulong guildId, string keyword, string text)
+    public static async Task<Quote> SearchQuoteKeywordTextAsync(
+        this DbSet<Quote> quotes,
+        ulong guildId,
+        string keyword,
+        string text)
     {
         var rngk = new NadekoRandom();
         return (await quotes.AsQueryable()
-                .Where(q => q.GuildId == guildId
-                            && q.Keyword == keyword
-                            && EF.Functions.Like(q.Text.ToUpper(), $"%{text.ToUpper()}%")
+                .Where(q => q.GuildId == guildId &&
+                            q.Keyword == keyword &&
+                            EF.Functions.Like(q.Text.ToUpper(), $"%{text.ToUpper()}%")
                     // && q.Text.Contains(text, StringComparison.OrdinalIgnoreCase)
                 )
-                .ToListAsync())
-            .OrderBy(q => rngk.Next())
+                .ToListAsync()).OrderBy(q => rngk.Next())
             .FirstOrDefault();
     }
 
     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));
+        => quotes.RemoveRange(quotes.AsQueryable()
+            .Where(x => x.GuildId == guildId && x.Keyword.ToUpper() == keyword)
+        );
 }

src/NadekoBot/Db/Extensions/ReminderExtensions.cs

@@ -5,7 +5,9 @@ namespace NadekoBot.Db;
 
 public static class ReminderExtensions
 {
-    public static IEnumerable<Reminder> GetIncludedReminders(this DbSet<Reminder> reminders, IEnumerable<ulong> guildIds) 
+    public static IEnumerable<Reminder> GetIncludedReminders(
+        this DbSet<Reminder> reminders,
+        IEnumerable<ulong> guildIds)
         => reminders.AsQueryable()
             .Where(x => guildIds.Contains(x.ServerId) || x.ServerId == 0)
             .ToList();
@@ -16,7 +18,7 @@ public static class ReminderExtensions
             .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)

src/NadekoBot/Db/Extensions/SelfAssignableRolesExtensions.cs

@@ -16,8 +16,8 @@ public static class SelfAssignableRolesExtensions
         return true;
     }
 
-    public static IEnumerable<SelfAssignedRole> GetFromGuild(this DbSet<SelfAssignedRole> roles, ulong guildId) 
-        =>  roles.AsQueryable()
+    public static IEnumerable<SelfAssignedRole> GetFromGuild(this DbSet<SelfAssignedRole> roles, ulong guildId)
+        => roles.AsQueryable()
             .Where(s => s.GuildId == guildId)
             .ToArray();
 }

src/NadekoBot/Db/Extensions/UserXpExtensions.cs

@@ -14,20 +14,17 @@ public static class UserXpExtensions
         if (usr is null)
         {
             ctx.Add(usr = new()
-            {
-                Xp = 0,
-                UserId = userId,
-                NotifyOnLevelUp = XpNotificationLocation.None,
-                GuildId = guildId,
-            });
+                {
+                    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()
+        => xps.AsQueryable()
             .AsNoTracking()
             .Where(x => x.GuildId == guildId)
             .OrderByDescending(x => x.Xp + x.AwardedXp)
@@ -36,8 +33,7 @@ public static class UserXpExtensions
             .ToList();
 
     public static List<UserXpStats> GetTopUserXps(this DbSet<UserXpStats> xps, ulong guildId, int count)
-        => xps
-            .AsQueryable()
+        => xps.AsQueryable()
             .AsNoTracking()
             .Where(x => x.GuildId == guildId)
             .OrderByDescending(x => x.Xp + x.AwardedXp)
@@ -51,15 +47,17 @@ public static class UserXpExtensions
         //	FROM UserXpStats
         //	WHERE UserId = @p2 AND GuildId = @p1
         //	LIMIT 1));";
-        => 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;
+        => 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);

src/NadekoBot/Db/Extensions/WaifuExtensions.cs

@@ -7,21 +7,24 @@ namespace NadekoBot.Db;
 
 public class WaifuInfoStats
 {
-    public string FullName { get; set; }
-    public int Price { get; set; }
-    public string ClaimerName { get; set; }
-    public string AffinityName { get; set; }
-    public int AffinityCount { get; set; }
-    public int DivorceCount { get; set; }
-    public int ClaimCount { get; set; }
-    public List<WaifuItem> Items { get; set; }
-    public List<string> Claims { get; set; }
-    public List<string> Fans { get; set; }
+    public string FullName { get; init; }
+    public int Price { get; init; }
+    public string ClaimerName { get; init; }
+    public string AffinityName { get; init; }
+    public int AffinityCount { get; init; }
+    public int DivorceCount { get; init; }
+    public int ClaimCount { get; init; }
+    public List<WaifuItem> Items { get; init; }
+    public List<string> Claims { get; init; }
+    public List<string> Fans { get; init; }
 }
-    
+
 public static class WaifuExtensions
 {
-    public static WaifuInfo ByWaifuUserId(this DbSet<WaifuInfo> waifus, ulong userId, Func<DbSet<WaifuInfo>, IQueryable<WaifuInfo>> includes = null)
+    public static WaifuInfo ByWaifuUserId(
+        this DbSet<WaifuInfo> waifus,
+        ulong userId,
+        Func<DbSet<WaifuInfo>, IQueryable<WaifuInfo>> includes = null)
     {
         if (includes is null)
         {
@@ -51,31 +54,28 @@ public static class WaifuExtensions
             .Skip(skip)
             .Take(count)
             .Select(x => new WaifuLbResult
-            {
-                Affinity = x.Affinity == null ? null : x.Affinity.Username,
-                AffinityDiscrim = x.Affinity == null ? null : x.Affinity.Discriminator,
-                Claimer = x.Claimer == null ? null : x.Claimer.Username,
-                ClaimerDiscrim = x.Claimer == null ? null : x.Claimer.Discriminator,
-                Username = x.Waifu.Username,
-                Discrim = x.Waifu.Discriminator,
-                Price = x.Price,
-            })
+                {
+                    Affinity = x.Affinity == null ? null : x.Affinity.Username,
+                    AffinityDiscrim = x.Affinity == null ? null : x.Affinity.Discriminator,
+                    Claimer = x.Claimer == null ? null : x.Claimer.Username,
+                    ClaimerDiscrim = x.Claimer == null ? null : x.Claimer.Discriminator,
+                    Username = x.Waifu.Username,
+                    Discrim = x.Waifu.Discriminator,
+                    Price = x.Price,
+                }
+            )
             .ToList();
-
     }
 
     public static decimal GetTotalValue(this DbSet<WaifuInfo> waifus)
-        => waifus
-            .AsQueryable()
+        => waifus.AsQueryable()
             .Where(x => x.ClaimerId != null)
             .Sum(x => x.Price);
 
     public static ulong GetWaifuUserId(this DbSet<WaifuInfo> waifus, ulong ownerId, string name)
-        => waifus
-            .AsQueryable()
+        => waifus.AsQueryable()
             .AsNoTracking()
-            .Where(x => x.Claimer.UserId == ownerId
-                        && x.Waifu.Username + "#" + x.Waifu.Discriminator == name)
+            .Where(x => x.Claimer.UserId == ownerId && x.Waifu.Username + "#" + x.Waifu.Discriminator == name)
             .Select(x => x.Waifu.UserId)
             .FirstOrDefault();
 
@@ -83,74 +83,64 @@ public static class WaifuExtensions
     {
         ctx.Database.ExecuteSqlInterpolated($@"
 INSERT OR IGNORE INTO WaifuInfo (AffinityId, ClaimerId, Price, WaifuId)
-VALUES ({null}, {null}, {1}, (SELECT Id FROM DiscordUser WHERE UserId={userId}));");
+VALUES ({null}, {null}, {1}, (SELECT Id FROM DiscordUser WHERE UserId={userId}));"
+        );
 
-        var toReturn = ctx.WaifuInfo
-            .AsQueryable()
-            .Where(w => w.WaifuId == ctx.Set<DiscordUser>()
-                .AsQueryable()
-                .Where(u => u.UserId == userId)
-                .Select(u => u.Id).FirstOrDefault())
+        var toReturn = ctx.WaifuInfo.AsQueryable()
+            .Where(w => w.WaifuId ==
+                        ctx.Set<DiscordUser>()
+                            .AsQueryable()
+                            .Where(u => u.UserId == userId)
+                            .Select(u => u.Id)
+                            .FirstOrDefault()
+            )
             .Select(w => new WaifuInfoStats
-            {
-                FullName = ctx.Set<DiscordUser>()
-                    .AsQueryable()
-                    .Where(u => u.UserId == userId)
-                    .Select(u => u.Username + "#" + u.Discriminator)
-                    .FirstOrDefault(),
-
-                AffinityCount = ctx.Set<WaifuUpdate>()
-                    .AsQueryable()
-                    .Count(x => x.UserId == w.WaifuId &&
-                                x.UpdateType == WaifuUpdateType.AffinityChanged &&
-                                x.NewId != null),
-
-                AffinityName = ctx.Set<DiscordUser>()
-                    .AsQueryable()
-                    .Where(u => u.Id == w.AffinityId)
-                    .Select(u => u.Username + "#" + u.Discriminator)
-                    .FirstOrDefault(),
-
-                ClaimCount = ctx.WaifuInfo
-                    .AsQueryable()
-                    .Count(x => x.ClaimerId == w.WaifuId),
-
-                ClaimerName = ctx.Set<DiscordUser>()
-                    .AsQueryable()
-                    .Where(u => u.Id == w.ClaimerId)
-                    .Select(u => u.Username + "#" + u.Discriminator)
-                    .FirstOrDefault(),
-
-                DivorceCount = ctx
-                    .Set<WaifuUpdate>()
-                    .AsQueryable()
-                    .Count(x => x.OldId == w.WaifuId &&
-                                x.NewId == null &&
-                                x.UpdateType == WaifuUpdateType.Claimed),
-
-                Price = w.Price,
-
-                Claims = ctx.WaifuInfo
-                    .AsQueryable()
-                    .Include(x => x.Waifu)
-                    .Where(x => x.ClaimerId == w.WaifuId)
-                    .Select(x => x.Waifu.Username + "#" + x.Waifu.Discriminator)
-                    .ToList(),
-
-                Fans = ctx.WaifuInfo
-                    .AsQueryable()
-                    .Include(x => x.Waifu)
-                    .Where(x => x.AffinityId == w.WaifuId)
-                    .Select(x => x.Waifu.Username + "#" + x.Waifu.Discriminator)
-                    .ToList(),
-                    
-                Items = w.Items,
-            })
+                {
+                    FullName = ctx.Set<DiscordUser>()
+                        .AsQueryable()
+                        .Where(u => u.UserId == userId)
+                        .Select(u => u.Username + "#" + u.Discriminator)
+                        .FirstOrDefault(),
+                    AffinityCount = ctx.Set<WaifuUpdate>()
+                        .AsQueryable()
+                        .Count(x => x.UserId == w.WaifuId &&
+                                    x.UpdateType == WaifuUpdateType.AffinityChanged &&
+                                    x.NewId != null
+                        ),
+                    AffinityName = ctx.Set<DiscordUser>()
+                        .AsQueryable()
+                        .Where(u => u.Id == w.AffinityId)
+                        .Select(u => u.Username + "#" + u.Discriminator)
+                        .FirstOrDefault(),
+                    ClaimCount = ctx.WaifuInfo.AsQueryable()
+                        .Count(x => x.ClaimerId == w.WaifuId),
+                    ClaimerName = ctx.Set<DiscordUser>()
+                        .AsQueryable()
+                        .Where(u => u.Id == w.ClaimerId)
+                        .Select(u => u.Username + "#" + u.Discriminator)
+                        .FirstOrDefault(),
+                    DivorceCount = ctx.Set<WaifuUpdate>()
+                        .AsQueryable()
+                        .Count(x => x.OldId == w.WaifuId && x.NewId == null && x.UpdateType == WaifuUpdateType.Claimed),
+                    Price = w.Price,
+                    Claims = ctx.WaifuInfo.AsQueryable()
+                        .Include(x => x.Waifu)
+                        .Where(x => x.ClaimerId == w.WaifuId)
+                        .Select(x => x.Waifu.Username + "#" + x.Waifu.Discriminator)
+                        .ToList(),
+                    Fans = ctx.WaifuInfo.AsQueryable()
+                        .Include(x => x.Waifu)
+                        .Where(x => x.AffinityId == w.WaifuId)
+                        .Select(x => x.Waifu.Username + "#" + x.Waifu.Discriminator)
+                        .ToList(),
+                    Items = w.Items,
+                }
+            )
             .FirstOrDefault();
 
         if (toReturn is null)
             return null;
-            
+
         return toReturn;
     }
 }

src/NadekoBot/Db/Extensions/WarningExtensions.cs

@@ -14,17 +14,24 @@ public static class WarningExtensions
         return query.ToArray();
     }
 
-    public static bool Forgive(this DbSet<Warning> warnings, ulong guildId, ulong userId, string mod, int index)
+    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)
+        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)
+        if (warn is null ||
+            warn.Forgiven)
             return false;
 
         warn.Forgiven = true;
@@ -32,17 +39,25 @@ public static class WarningExtensions
         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)
+    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;
+                    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();
+        => warnings.AsQueryable()
+            .Where(x => x.GuildId == id)
+            .ToArray();
 }