Applied codestyle to all .cs files

src/NadekoBot/Db/Extensions/ClubExtensions.cs

@@ -1,4 +1,4 @@
-#nullable disable
+#nullable disable
 using Microsoft.EntityFrameworkCore;
 using NadekoBot.Db.Models;
 
@@ -8,12 +8,12 @@ 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.Users)
-            .AsQueryable();
+                .Include(x => x.Applicants)
+                .ThenInclude(x => x.User)
+                .Include(x => x.Bans)
+                .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);
@@ -29,9 +29,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();
-}
+}

src/NadekoBot/Db/Extensions/CurrencyTransactionExtensions.cs

@@ -1,4 +1,4 @@
-#nullable disable
+#nullable disable
 using Microsoft.EntityFrameworkCore;
 using NadekoBot.Services.Database.Models;
 
@@ -8,10 +8,10 @@ public static class CurrencyTransactionExtensions
 {
     public static List<CurrencyTransaction> GetPageFor(this DbSet<CurrencyTransaction> set, ulong userId, int page)
         => set.AsQueryable()
-            .AsNoTracking()
-            .Where(x => x.UserId == userId)
-            .OrderByDescending(x => x.DateAdded)
-            .Skip(15 * page)
-            .Take(15)
-            .ToList();
-}
+              .AsNoTracking()
+              .Where(x => x.UserId == userId)
+              .OrderByDescending(x => x.DateAdded)
+              .Skip(15 * page)
+              .Take(15)
+              .ToList();
+}

src/NadekoBot/Db/Extensions/CustomReactionsExtensions.cs

@@ -1,6 +1,6 @@
-#nullable disable
-using Microsoft.EntityFrameworkCore;
+#nullable disable
 using LinqToDB;
+using Microsoft.EntityFrameworkCore;
 using NadekoBot.Services.Database.Models;
 
 namespace NadekoBot.Db;
@@ -15,4 +15,4 @@ public static class CustomReactionsExtensions
 
     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

@@ -1,4 +1,4 @@
-#nullable disable
+#nullable disable
 using Microsoft.EntityFrameworkCore;
 using NadekoBot.Services.Database.Models;
 
@@ -9,4 +9,4 @@ 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

@@ -1,8 +1,8 @@
-#nullable disable
-using NadekoBot.Db.Models;
-using Microsoft.EntityFrameworkCore;
+#nullable disable
 using LinqToDB;
 using LinqToDB.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
+using NadekoBot.Db.Models;
 using NadekoBot.Services.Database;
 
 namespace NadekoBot.Db;
@@ -16,19 +16,18 @@ public static class DiscordUserExtensions
         string discrim,
         string avatarId)
         => ctx.DiscordUser.ToLinqToDBTable()
-            .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 }
-            );
+              .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 });
 
     //temp is only used in updatecurrencystate, so that i don't overwrite real usernames/discrims with Unknown
     public static DiscordUser GetOrCreateUser(
@@ -38,40 +37,22 @@ public static class DiscordUserExtensions
         string discrim,
         string avatarId)
     {
-        ctx.EnsureUserCreated(userId,
-            username,
-            discrim,
-            avatarId
-        );
-        return ctx.DiscordUser.Include(x => x.Club)
-            .First(u => u.UserId == userId);
+        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()
-            .OrderByDescending(x => x.TotalXp)
-            .Skip(page * 9)
-            .Take(9)
-            .AsEnumerable()
-            .ToArray();
+        => users.AsQueryable().OrderByDescending(x => x.TotalXp).Skip(page * 9).Take(9).AsEnumerable().ToArray();
 
     public static List<DiscordUser> GetTopRichest(
         this DbSet<DiscordUser> users,
@@ -79,26 +60,19 @@ public static class DiscordUserExtensions
         int count,
         int page = 0)
         => users.AsQueryable()
-            .Where(c => c.CurrencyAmount > 0 && botId != c.UserId)
-            .OrderByDescending(c => c.CurrencyAmount)
-            .Skip(page * 9)
-            .Take(count)
-            .ToList();
+                .Where(c => c.CurrencyAmount > 0 && botId != c.UserId)
+                .OrderByDescending(c => c.CurrencyAmount)
+                .Skip(page * 9)
+                .Take(count)
+                .ToList();
 
     public static long GetUserCurrency(this DbSet<DiscordUser> users, ulong userId)
-        => users.AsNoTracking()
-               .FirstOrDefault(x => x.UserId == userId)
-               ?.CurrencyAmount ??
-           0;
+        => 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));
-        foreach (var item in items)
-        {
-            item.CurrencyAmount = 0;
-        }
+        var items = users.AsQueryable().Where(x => ids.Contains(x.UserId));
+        foreach (var item in items) item.CurrencyAmount = 0;
     }
 
     public static bool TryUpdateCurrencyState(
@@ -115,14 +89,12 @@ public static class DiscordUserExtensions
 
         // 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;
         }
 
@@ -132,8 +104,7 @@ 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;
         }
 
@@ -147,7 +118,6 @@ WHERE UserId={userId};"
 
         // just update the amount, there is no new user data
         if (!updatedUserData)
-        {
             ctx.Database.ExecuteSqlInterpolated($@"
 UPDATE OR IGNORE DiscordUser
 SET CurrencyAmount=CurrencyAmount+{amount}
@@ -155,11 +125,8 @@ WHERE UserId={userId};
 
 INSERT OR IGNORE INTO DiscordUser (UserId, Username, Discriminator, AvatarId, CurrencyAmount, TotalXp)
 VALUES ({userId}, {name}, {discrim}, {avatarId}, {amount}, 0);
-"
-            );
-        }
+");
         else
-        {
             ctx.Database.ExecuteSqlInterpolated($@"
 UPDATE OR IGNORE DiscordUser
 SET CurrencyAmount=CurrencyAmount+{amount},
@@ -170,9 +137,7 @@ WHERE UserId={userId};
 
 INSERT OR IGNORE INTO DiscordUser (UserId, Username, Discriminator, AvatarId, CurrencyAmount, TotalXp)
 VALUES ({userId}, {name}, {discrim}, {avatarId}, {amount}, 0);
-"
-            );
-        }
+");
 
         return true;
     }
@@ -182,8 +147,8 @@ VALUES ({userId}, {name}, {discrim}, {avatarId}, {amount}, 0);
 
     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);
-}
+                .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

@@ -1,21 +1,22 @@
 #nullable disable
-using NadekoBot.Services.Database.Models;
 using Microsoft.EntityFrameworkCore;
-using NadekoBot.Services.Database;
 using NadekoBot.Db.Models;
+using NadekoBot.Services.Database;
+using NadekoBot.Services.Database.Models;
 
 namespace NadekoBot.Db;
 
 public static class GuildConfigExtensions
 {
-    public class GeneratingChannel
-    {
-        public ulong GuildId { get; set; }
-        public ulong ChannelId { get; set; }
-    }
+    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.
+    ///     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>
@@ -24,9 +25,8 @@ public static class GuildConfigExtensions
     {
         var conf = ctx.GuildConfigsForId(guildId,
             set => set.Include(y => y.StreamRole)
-                .Include(y => y.StreamRole.Whitelist)
-                .Include(y => y.StreamRole.Blacklist)
-        );
+                      .Include(y => y.StreamRole.Whitelist)
+                      .Include(y => y.StreamRole.Blacklist));
 
         if (conf.StreamRole is null)
             conf.StreamRole = new();
@@ -34,35 +34,25 @@ public static class GuildConfigExtensions
         return conf.StreamRole;
     }
 
-    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()
-            .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)
-            .Include(gc => gc.ReactionRoleMessages)
-            .ThenInclude(x => x.ReactionRoles);
+                  .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)
+                  .Include(gc => gc.ReactionRoleMessages)
+                  .ThenInclude(x => x.ReactionRoles);
 
     public static IEnumerable<GuildConfig> GetAllGuildConfigs(
         this DbSet<GuildConfig> configs,
         List<ulong> availableGuilds)
-        => configs.IncludeEverything()
-            .AsNoTracking()
-            .Where(x => availableGuilds.Contains(x.GuildId))
-            .ToList();
+        => configs.IncludeEverything().AsNoTracking().Where(x => availableGuilds.Contains(x.GuildId)).ToList();
 
     /// <summary>
-    /// Gets and creates if it doesn't exist a config for a guild.
+    ///     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>
@@ -77,8 +67,7 @@ public static class GuildConfigExtensions
 
         if (includes is null)
         {
-            config = ctx.GuildConfigs.IncludeEverything()
-                .FirstOrDefault(c => c.GuildId == guildId);
+            config = ctx.GuildConfigs.IncludeEverything().FirstOrDefault(c => c.GuildId == guildId);
         }
         else
         {
@@ -89,13 +78,12 @@ 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();
         }
 
@@ -111,9 +99,9 @@ public static class GuildConfigExtensions
     public static LogSetting LogSettingsFor(this NadekoContext ctx, ulong guildId)
     {
         var logSetting = ctx.LogSettings.AsQueryable()
-            .Include(x => x.LogIgnores)
-            .Where(x => x.GuildId == guildId)
-            .FirstOrDefault();
+                            .Include(x => x.LogIgnores)
+                            .Where(x => x.GuildId == guildId)
+                            .FirstOrDefault();
 
         if (logSetting is null)
         {
@@ -126,9 +114,7 @@ public static class GuildConfigExtensions
 
     public static IEnumerable<GuildConfig> Permissionsv2ForAll(this DbSet<GuildConfig> configs, List<ulong> include)
     {
-        var query = configs.AsQueryable()
-            .Where(x => include.Contains(x.GuildId))
-            .Include(gc => gc.Permissions);
+        var query = configs.AsQueryable().Where(x => include.Contains(x.GuildId)).Include(gc => gc.Permissions);
 
         return query.ToList();
     }
@@ -136,17 +122,16 @@ public static class GuildConfigExtensions
     public static GuildConfig GcWithPermissionsv2For(this NadekoContext ctx, ulong guildId)
     {
         var config = ctx.GuildConfigs.AsQueryable()
-            .Where(gc => gc.GuildId == guildId)
-            .Include(gc => gc.Permissions)
-            .FirstOrDefault();
+                        .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.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();
@@ -156,17 +141,14 @@ public static class GuildConfigExtensions
     }
 
     public static IEnumerable<FollowedStream> GetFollowedStreams(this DbSet<GuildConfig> configs)
-        => configs.AsQueryable()
-            .Include(x => x.FollowedStreams)
-            .SelectMany(gc => gc.FollowedStreams)
-            .ToArray();
+        => 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();
+                  .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)
     {
@@ -182,24 +164,29 @@ public static class GuildConfigExtensions
     {
         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)
-        );
+                      .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 XpSettings();
+            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();
-}
+                  .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/MusicPlayerSettingsExtensions.cs

@@ -1,4 +1,4 @@
-#nullable disable
+#nullable disable
 using Microsoft.EntityFrameworkCore;
 using NadekoBot.Services.Database.Models;
 
@@ -8,12 +8,11 @@ public static class MusicPlayerSettingsExtensions
 {
     public static async Task<MusicPlayerSettings> ForGuildAsync(this DbSet<MusicPlayerSettings> settings, ulong guildId)
     {
-        var toReturn = await settings.AsQueryable()
-            .FirstOrDefaultAsync(x => x.GuildId == guildId);
+        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;
@@ -21,4 +20,4 @@ public static class MusicPlayerSettingsExtensions
 
         return toReturn;
     }
-}
+}

src/NadekoBot/Db/Extensions/MusicPlaylistExtensions.cs

@@ -1,4 +1,4 @@
-#nullable disable
+#nullable disable
 using Microsoft.EntityFrameworkCore;
 using NadekoBot.Services.Database.Models;
 
@@ -11,14 +11,9 @@ public static class MusicPlaylistExtensions
         if (num < 1)
             throw new IndexOutOfRangeException();
 
-        return playlists.AsQueryable()
-            .Skip((num - 1) * 20)
-            .Take(20)
-            .Include(pl => pl.Songs)
-            .ToList();
+        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)
-            .FirstOrDefault(mpl => mpl.Id == id);
-}
+        => playlists.Include(mpl => mpl.Songs).FirstOrDefault(mpl => mpl.Id == id);
+}

src/NadekoBot/Db/Extensions/PollExtensions.cs

@@ -1,4 +1,4 @@
-#nullable disable
+#nullable disable
 using Microsoft.EntityFrameworkCore;
 using NadekoBot.Services.Database;
 using NadekoBot.Services.Database.Models;
@@ -8,15 +8,11 @@ namespace NadekoBot.Db;
 public static class PollExtensions
 {
     public static IEnumerable<Poll> GetAllPolls(this DbSet<Poll> polls)
-        => polls.Include(x => x.Answers)
-            .Include(x => x.Votes)
-            .ToArray();
+        => polls.Include(x => x.Answers).Include(x => x.Votes).ToArray();
 
     public static void RemovePoll(this NadekoContext ctx, int id)
     {
-        var p = ctx.Poll.Include(x => x.Answers)
-            .Include(x => x.Votes)
-            .FirstOrDefault(x => x.Id == id);
+        var p = ctx.Poll.Include(x => x.Answers).Include(x => x.Votes).FirstOrDefault(x => x.Id == id);
 
         if (p is null)
             return;
@@ -35,4 +31,4 @@ public static class PollExtensions
 
         ctx.Poll.Remove(p);
     }
-}
+}

src/NadekoBot/Db/Extensions/QuoteExtensions.cs

@@ -1,14 +1,13 @@
 #nullable disable
-using NadekoBot.Services.Database.Models;
 using Microsoft.EntityFrameworkCore;
+using NadekoBot.Services.Database.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);
+        => quotes.AsQueryable().Where(x => x.GuildId == guildId);
 
     public static IEnumerable<Quote> GetGroup(
         this DbSet<Quote> quotes,
@@ -16,16 +15,13 @@ public static class QuoteExtensions
         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(
@@ -34,10 +30,9 @@ public static class QuoteExtensions
         string keyword)
     {
         var rng = new NadekoRandom();
-        return (await quotes.AsQueryable()
-                .Where(q => q.GuildId == guildId && q.Keyword == keyword)
-                .ToListAsync()).OrderBy(q => rng.Next())
-            .FirstOrDefault();
+        return (await quotes.AsQueryable().Where(q => q.GuildId == guildId && q.Keyword == keyword).ToListAsync())
+               .OrderBy(q => rng.Next())
+               .FirstOrDefault();
     }
 
     public static async Task<Quote> SearchQuoteKeywordTextAsync(
@@ -48,17 +43,15 @@ public static class QuoteExtensions
     {
         var rngk = new NadekoRandom();
         return (await quotes.AsQueryable()
-                .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())
-            .FirstOrDefault();
+                            .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())
+                                           .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

@@ -1,6 +1,6 @@
-#nullable disable
-using NadekoBot.Services.Database.Models;
+#nullable disable
 using Microsoft.EntityFrameworkCore;
+using NadekoBot.Services.Database.Models;
 
 namespace NadekoBot.Db;
 
@@ -9,21 +9,15 @@ 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();
+        => 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);
+        => 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);
-}
+                    .Where(x => x.ServerId == serverId)
+                    .OrderBy(x => x.DateAdded)
+                    .Skip(page * 10)
+                    .Take(10);
+}

src/NadekoBot/Db/Extensions/SelfAssignableRolesExtensions.cs

@@ -1,6 +1,6 @@
-#nullable disable
-using NadekoBot.Services.Database.Models;
+#nullable disable
 using Microsoft.EntityFrameworkCore;
+using NadekoBot.Services.Database.Models;
 
 namespace NadekoBot.Db;
 
@@ -18,7 +18,5 @@ public static class SelfAssignableRolesExtensions
     }
 
     public static IEnumerable<SelfAssignedRole> GetFromGuild(this DbSet<SelfAssignedRole> roles, ulong guildId)
-        => roles.AsQueryable()
-            .Where(s => s.GuildId == guildId)
-            .ToArray();
-}
+        => roles.AsQueryable().Where(s => s.GuildId == guildId).ToArray();
+}

src/NadekoBot/Db/Extensions/UserXpExtensions.cs

@@ -1,6 +1,6 @@
-#nullable disable
-using Microsoft.EntityFrameworkCore;
+#nullable disable
 using LinqToDB;
+using Microsoft.EntityFrameworkCore;
 using NadekoBot.Services.Database;
 using NadekoBot.Services.Database.Models;
 
@@ -13,33 +13,30 @@ public static class UserXpExtensions
         var usr = ctx.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,
-                }
-            );
-        }
+            {
+                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();
+              .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();
+              .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)
         //            @"SELECT COUNT(*) + 1
@@ -49,20 +46,19 @@ public static class UserXpExtensions
         //	WHERE UserId = @p2 AND GuildId = @p1
         //	LIMIT 1));";
         => xps.AsQueryable()
-               .AsNoTracking()
-               .Where(x => x.GuildId == guildId &&
-                           x.Xp + x.AwardedXp >
-                           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;
+                               .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);
-}
+}

src/NadekoBot/Db/Extensions/WaifuExtensions.cs

@@ -1,8 +1,8 @@
-#nullable disable
+#nullable disable
 using Microsoft.EntityFrameworkCore;
+using NadekoBot.Db.Models;
 using NadekoBot.Services.Database;
 using NadekoBot.Services.Database.Models;
-using NadekoBot.Db.Models;
 
 namespace NadekoBot.Db;
 
@@ -28,17 +28,13 @@ public static class WaifuExtensions
         Func<DbSet<WaifuInfo>, IQueryable<WaifuInfo>> includes = null)
     {
         if (includes is null)
-        {
             return waifus.Include(wi => wi.Waifu)
-                .Include(wi => wi.Affinity)
-                .Include(wi => wi.Claimer)
-                .Include(wi => wi.Items)
-                .FirstOrDefault(wi => wi.Waifu.UserId == userId);
-        }
+                         .Include(wi => wi.Affinity)
+                         .Include(wi => wi.Claimer)
+                         .Include(wi => wi.Items)
+                         .FirstOrDefault(wi => wi.Waifu.UserId == userId);
 
-        return includes(waifus)
-            .AsQueryable()
-            .FirstOrDefault(wi => wi.Waifu.UserId == userId);
+        return includes(waifus).AsQueryable().FirstOrDefault(wi => wi.Waifu.UserId == userId);
     }
 
     public static IEnumerable<WaifuLbResult> GetTop(this DbSet<WaifuInfo> waifus, int count, int skip = 0)
@@ -49,99 +45,98 @@ public static class WaifuExtensions
             return new List<WaifuLbResult>();
 
         return waifus.Include(wi => wi.Waifu)
-            .Include(wi => wi.Affinity)
-            .Include(wi => wi.Claimer)
-            .OrderByDescending(wi => wi.Price)
-            .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,
-                }
-            )
-            .ToList();
+                     .Include(wi => wi.Affinity)
+                     .Include(wi => wi.Claimer)
+                     .OrderByDescending(wi => wi.Price)
+                     .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
+                     })
+                     .ToList();
     }
 
     public static decimal GetTotalValue(this DbSet<WaifuInfo> waifus)
-        => waifus.AsQueryable()
-            .Where(x => x.ClaimerId != null)
-            .Sum(x => x.Price);
+        => 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()
-            .AsNoTracking()
-            .Where(x => x.Claimer.UserId == ownerId && x.Waifu.Username + "#" + x.Waifu.Discriminator == name)
-            .Select(x => x.Waifu.UserId)
-            .FirstOrDefault();
+                 .AsNoTracking()
+                 .Where(x => x.Claimer.UserId == ownerId && x.Waifu.Username + "#" + x.Waifu.Discriminator == name)
+                 .Select(x => x.Waifu.UserId)
+                 .FirstOrDefault();
 
     public static WaifuInfoStats GetWaifuInfo(this NadekoContext ctx, ulong userId)
     {
         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()
-            )
-            .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,
-                }
-            )
-            .FirstOrDefault();
+                          .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
+                          })
+                          .FirstOrDefault();
 
         if (toReturn is null)
             return null;
 
         return toReturn;
     }
-}
+}

src/NadekoBot/Db/Extensions/WarningExtensions.cs

@@ -1,6 +1,6 @@
-#nullable disable
-using NadekoBot.Services.Database.Models;
+#nullable disable
 using Microsoft.EntityFrameworkCore;
+using NadekoBot.Services.Database.Models;
 
 namespace NadekoBot.Db;
 
@@ -9,8 +9,8 @@ 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);
+                            .Where(x => x.GuildId == guildId && x.UserId == userId)
+                            .OrderByDescending(x => x.DateAdded);
 
         return query.ToArray();
     }
@@ -26,13 +26,12 @@ public static class WarningExtensions
             throw new ArgumentOutOfRangeException(nameof(index));
 
         var warn = warnings.AsQueryable()
-            .Where(x => x.GuildId == guildId && x.UserId == userId)
-            .OrderByDescending(x => x.DateAdded)
-            .Skip(index)
-            .FirstOrDefault();
+                           .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;
@@ -46,19 +45,16 @@ public static class WarningExtensions
         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;
-                    }
-                }
-            );
+                         .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();
-}
+        => warnings.AsQueryable().Where(x => x.GuildId == id).ToArray();
+}