Lots more stuff

src/NadekoBot/Db/Extensions/ClubExtensions.cs

@@ -1,34 +0,0 @@
-#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

@@ -1,20 +0,0 @@
-#nullable disable
-using LinqToDB.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Services.Database.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

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

@@ -1,130 +0,0 @@
-#nullable disable
-using LinqToDB;
-using LinqToDB.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Db.Models;
-using NadekoBot.Services.Database;
-
-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 NadekoContext ctx,
-        ulong userId,
-        string username,
-        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
-                  });
-
-    public static Task EnsureUserCreatedAsync(
-        this NadekoContext ctx,
-        ulong userId)
-        => ctx.DiscordUser
-              .ToLinqToDBTable()
-              .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 NadekoContext 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.DiscordUser;
-        if (includes is not null)
-            queryable = includes(queryable);
-        return queryable.First(u => u.UserId == userId);
-    }
-
-    public static DiscordUser GetOrCreateUser(this NadekoContext ctx, IUser original, Func<IQueryable<DiscordUser>, IQueryable<DiscordUser>> includes = null)
-        => ctx.GetOrCreateUser(original.Id, original.Username, original.Discriminator, original.AvatarId, includes);
-
-    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)
-        => users.AsQueryable().OrderByDescending(x => x.TotalXp).Skip(page * 9).Take(9).AsEnumerable().ToArray();
-
-    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)
-                .Skip(page * 9)
-                .Take(count)
-                .ToList();
-
-    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

@@ -1,227 +0,0 @@
-#nullable disable
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Db.Models;
-using NadekoBot.Services.Database;
-using NadekoBot.Services.Database.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 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));
-
-        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,
-        List<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 NadekoContext ctx,
-        ulong guildId,
-        Func<DbSet<GuildConfig>, IQueryable<GuildConfig>> includes)
-    {
-        GuildConfig config;
-
-        if (includes is null)
-            config = ctx.GuildConfigs.IncludeEverything().FirstOrDefault(c => c.GuildId == guildId);
-        else
-        {
-            var set = includes(ctx.GuildConfigs);
-            config = set.FirstOrDefault(c => c.GuildId == guildId);
-        }
-
-        if (config is null)
-        {
-            ctx.GuildConfigs.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 NadekoContext ctx, ulong guildId)
-    {
-        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.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 NadekoContext ctx, ulong guildId)
-    {
-        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.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 NadekoContext 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/MusicPlayerSettingsExtensions.cs

@@ -1,27 +0,0 @@
-#nullable disable
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Services.Database.Models;
-
-namespace NadekoBot.Db;
-
-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);
-
-        if (toReturn is null)
-        {
-            var newSettings = new MusicPlayerSettings
-            {
-                GuildId = guildId,
-                PlayerRepeat = PlayerRepeatType.Queue
-            };
-
-            await settings.AddAsync(newSettings);
-            return newSettings;
-        }
-
-        return toReturn;
-    }
-}

src/NadekoBot/Db/Extensions/MusicPlaylistExtensions.cs

@@ -1,19 +0,0 @@
-#nullable disable
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Services.Database.Models;
-
-namespace NadekoBot.Db;
-
-public static class MusicPlaylistExtensions
-{
-    public static List<MusicPlaylist> GetPlaylistsOnPage(this DbSet<MusicPlaylist> playlists, int num)
-    {
-        if (num < 1)
-            throw new ArgumentOutOfRangeException(nameof(num));
-
-        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);
-}

src/NadekoBot/Db/Extensions/NadekoExpressionExtensions.cs

@@ -1,15 +0,0 @@
-#nullable disable
-using LinqToDB;
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Services.Database.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/PollExtensions.cs

@@ -1,34 +0,0 @@
-#nullable disable
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Services.Database;
-using NadekoBot.Services.Database.Models;
-
-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();
-
-    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);
-
-        if (p is null)
-            return;
-
-        if (p.Votes is not null)
-        {
-            ctx.RemoveRange(p.Votes);
-            p.Votes.Clear();
-        }
-
-        if (p.Answers is not null)
-        {
-            ctx.RemoveRange(p.Answers);
-            p.Answers.Clear();
-        }
-
-        ctx.Poll.Remove(p);
-    }
-}

src/NadekoBot/Db/Extensions/QuoteExtensions.cs

@@ -1,57 +0,0 @@
-#nullable disable
-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);
-
-    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)
-    {
-        var rng = new NadekoRandom();
-        return (await quotes.AsQueryable().Where(q => q.GuildId == guildId && q.Keyword == keyword).ToListAsync())
-               .OrderBy(_ => rng.Next())
-               .FirstOrDefault();
-    }
-
-    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
-                                        && (keyword == null || q.Keyword == keyword)
-                                        && (EF.Functions.Like(q.Text.ToUpper(), $"%{text.ToUpper()}%")
-                                            || EF.Functions.Like(q.AuthorName, text)))
-                            .ToListAsync())
-               .OrderBy(_ => 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));
-}

src/NadekoBot/Db/Extensions/ReminderExtensions.cs

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

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

@@ -1,63 +0,0 @@
-#nullable disable
-using LinqToDB;
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Services.Database;
-using NadekoBot.Services.Database.Models;
-
-namespace NadekoBot.Db;
-
-public static class UserXpExtensions
-{
-    public static UserXpStats GetOrCreateUserXpStats(this NadekoContext ctx, ulong guildId, ulong userId)
-    {
-        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
-            });
-        }
-
-        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);
-}

src/NadekoBot/Db/Extensions/WaifuExtensions.cs

@@ -1,145 +0,0 @@
-#nullable disable
-using LinqToDB;
-using LinqToDB.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Db.Models;
-using NadekoBot.Services.Database;
-using NadekoBot.Services.Database.Models;
-
-namespace NadekoBot.Db;
-
-public class WaifuInfoStats
-{
-    public int WaifuId { get; init; }
-    public string FullName { get; init; }
-    public long 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 static class WaifuExtensions
-{
-    public static WaifuInfo ByWaifuUserId(
-        this DbSet<WaifuInfo> waifus,
-        ulong userId,
-        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);
-        }
-
-        return includes(waifus).AsQueryable().FirstOrDefault(wi => wi.Waifu.UserId == userId);
-    }
-
-    public static IEnumerable<WaifuLbResult> GetTop(this DbSet<WaifuInfo> waifus, int count, int skip = 0)
-    {
-        if (count < 0)
-            throw new ArgumentOutOfRangeException(nameof(count));
-        if (count == 0)
-            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();
-    }
-
-    public static decimal GetTotalValue(this DbSet<WaifuInfo> waifus)
-        => 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();
-
-    public static async Task<WaifuInfoStats> GetWaifuInfoAsync(this NadekoContext ctx, ulong userId)
-    {
-        await ctx.WaifuInfo
-                 .ToLinqToDBTable()
-                 .InsertOrUpdateAsync(() => new()
-                     {
-                         AffinityId = null,
-                         ClaimerId = null,
-                         Price = 1,
-                         WaifuId = ctx.DiscordUser.Where(x => x.UserId == userId).Select(x => x.Id).First()
-                     },
-                     _ => new(),
-                     () => new()
-                     {
-                         WaifuId = ctx.DiscordUser.Where(x => x.UserId == userId).Select(x => x.Id).First()
-                     });
-
-        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
-                          {
-                              WaifuId = w.WaifuId,
-                              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,
-                          })
-                          .FirstOrDefault();
-
-        if (toReturn is null)
-            return null;
-
-        return toReturn;
-    }
-}

src/NadekoBot/Db/Extensions/WarningExtensions.cs

@@ -1,60 +0,0 @@
-#nullable disable
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Services.Database.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();
-}