Hi

src/Nadeko.Bot.Db/Extensions/DiscordUserExtensions.cs

@@ -3,7 +3,6 @@ using LinqToDB;
 using LinqToDB.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore;
 using NadekoBot.Db.Models;
-using NadekoBot.Services.Database;
 
 namespace NadekoBot.Db;
 
@@ -15,12 +14,12 @@ public static class DiscordUserExtensions
         => set.FirstOrDefaultAsyncLinqToDB(x => x.UserId == userId);
     
     public static void EnsureUserCreated(
-        this NadekoContext ctx,
+        this DbContext ctx,
         ulong userId,
         string username,
         string discrim,
         string avatarId)
-        => ctx.DiscordUser.ToLinqToDBTable()
+        => ctx.GetTable<DiscordUser>()
               .InsertOrUpdate(
                   () => new()
                   {
@@ -43,10 +42,9 @@ public static class DiscordUserExtensions
                   });
 
     public static Task EnsureUserCreatedAsync(
-        this NadekoContext ctx,
+        this NadekoBaseContext ctx,
         ulong userId)
-        => ctx.DiscordUser
-              .ToLinqToDBTable()
+        => ctx.GetTable<DiscordUser>()
               .InsertOrUpdateAsync(
                   () => new()
                   {
@@ -68,7 +66,7 @@ public static class DiscordUserExtensions
     
     //temp is only used in updatecurrencystate, so that i don't overwrite real usernames/discrims with Unknown
     public static DiscordUser GetOrCreateUser(
-        this NadekoContext ctx,
+        this NadekoBaseContext ctx,
         ulong userId,
         string username,
         string discrim,
@@ -77,7 +75,7 @@ public static class DiscordUserExtensions
     {
         ctx.EnsureUserCreated(userId, username, discrim, avatarId);
 
-        IQueryable<DiscordUser> queryable = ctx.DiscordUser;
+        IQueryable<DiscordUser> queryable = ctx.Set<DiscordUser>();
         if (includes is not null)
             queryable = includes(queryable);
         return queryable.First(u => u.UserId == userId);

src/Nadeko.Bot.Db/Extensions/GuildConfigExtensions.cs

@@ -29,12 +29,12 @@ public static class GuildConfigExtensions
     /// <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)
+    public static StreamRoleSettings GetStreamRoleSettings(this NadekoBaseContext ctx, ulong guildId)
     {
         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();
@@ -44,13 +44,13 @@ public static class GuildConfigExtensions
 
     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);
+            .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,
@@ -65,23 +65,23 @@ public static class GuildConfigExtensions
     /// <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,
+        this NadekoBaseContext ctx,
         ulong guildId,
         Func<DbSet<GuildConfig>, IQueryable<GuildConfig>> includes)
     {
         GuildConfig config;
 
         if (includes is null)
-            config = ctx.GuildConfigs.IncludeEverything().FirstOrDefault(c => c.GuildId == guildId);
+            config = ctx.Set<GuildConfig>().IncludeEverything().FirstOrDefault(c => c.GuildId == guildId);
         else
         {
-            var set = includes(ctx.GuildConfigs);
+            var set = includes(ctx.Set<GuildConfig>());
             config = set.FirstOrDefault(c => c.GuildId == guildId);
         }
 
         if (config is null)
         {
-            ctx.GuildConfigs.Add(config = new()
+            ctx.Set<GuildConfig>().Add(config = new()
             {
                 GuildId = guildId,
                 Permissions = Permissionv2.GetDefaultPermlist,
@@ -120,19 +120,21 @@ public static class GuildConfigExtensions
         //    .First(x => x.GuildId == guildId);
     }
 
-    public static LogSetting LogSettingsFor(this NadekoContext ctx, ulong guildId)
+    public static LogSetting LogSettingsFor(this NadekoBaseContext ctx, ulong guildId)
     {
-        var logSetting = ctx.LogSettings.AsQueryable()
-                            .Include(x => x.LogIgnores)
-                            .Where(x => x.GuildId == guildId)
-                            .FirstOrDefault();
+        var logSetting = ctx.Set<LogSetting>()
+            .AsQueryable()
+            .Include(x => x.LogIgnores)
+            .Where(x => x.GuildId == guildId)
+            .FirstOrDefault();
 
         if (logSetting is null)
         {
-            ctx.LogSettings.Add(logSetting = new()
-            {
-                GuildId = guildId
-            });
+            ctx.Set<LogSetting>()
+                .Add(logSetting = new()
+                {
+                    GuildId = guildId
+                });
             ctx.SaveChanges();
         }
 
@@ -146,16 +148,16 @@ public static class GuildConfigExtensions
         return query.ToList();
     }
 
-    public static GuildConfig GcWithPermissionsFor(this NadekoContext ctx, ulong guildId)
+    public static GuildConfig GcWithPermissionsFor(this NadekoBaseContext ctx, ulong guildId)
     {
-        var config = ctx.GuildConfigs.AsQueryable()
-                        .Where(gc => gc.GuildId == guildId)
-                        .Include(gc => gc.Permissions)
-                        .FirstOrDefault();
+        var config = ctx.Set<GuildConfig>().AsQueryable()
+            .Where(gc => gc.GuildId == guildId)
+            .Include(gc => gc.Permissions)
+            .FirstOrDefault();
 
         if (config is null) // if there is no guildconfig, create new one
         {
-            ctx.GuildConfigs.Add(config = new()
+            ctx.Set<GuildConfig>().Add(config = new()
             {
                 GuildId = guildId,
                 Permissions = Permissionv2.GetDefaultPermlist
@@ -176,10 +178,10 @@ public static class GuildConfigExtensions
 
     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)
     {
@@ -191,15 +193,15 @@ public static class GuildConfigExtensions
         conf.CleverbotEnabled = cleverbotEnabled;
     }
 
-    public static XpSettings XpSettingsFor(this NadekoContext ctx, ulong guildId)
+    public static XpSettings XpSettingsFor(this NadekoBaseContext 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));
+                .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();
@@ -209,15 +211,15 @@ public static class GuildConfigExtensions
 
     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
     {

src/Nadeko.Bot.Db/Migrations/MigrationQueries.cs

@@ -1,48 +0,0 @@
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Migrations;
-
-namespace NadekoBot.Migrations;
-
-public static class MigrationQueries
-{
-    public static void MigrateRero(MigrationBuilder migrationBuilder)
-    {
-        if (migrationBuilder.IsMySql())
-        {
-            migrationBuilder.Sql(
-                """
-                    INSERT IGNORE into reactionroles(guildid, channelid, messageid, emote, roleid, `group`, levelreq, dateadded)
-                    select guildid, channelid, messageid, emotename, roleid, exclusive, 0, reactionrolemessage.dateadded
-                    from reactionrole
-                    left join reactionrolemessage on reactionrolemessage.id = reactionrole.reactionrolemessageid
-                    left join guildconfigs on reactionrolemessage.guildconfigid = guildconfigs.id;
-                    """);
-        }
-        else if (migrationBuilder.IsSqlite())
-        {
-            migrationBuilder.Sql(
-                """
-                    insert or ignore into reactionroles(guildid, channelid, messageid, emote, roleid, 'group', levelreq, dateadded)
-                    select guildid, channelid, messageid, emotename, roleid, exclusive, 0, reactionrolemessage.dateadded
-                    from reactionrole
-                    left join reactionrolemessage on reactionrolemessage.id = reactionrole.reactionrolemessageid
-                    left join guildconfigs on reactionrolemessage.guildconfigid = guildconfigs.id;
-                    """);
-        }
-        else if (migrationBuilder.IsNpgsql())
-        {
-            migrationBuilder.Sql("""
-                insert into reactionroles(guildid, channelid, messageid, emote, roleid, "group", levelreq, dateadded)
-                            select guildid, channelid, messageid, emotename, roleid, exclusive::int, 0, reactionrolemessage.dateadded
-                                from reactionrole
-                                left join reactionrolemessage on reactionrolemessage.id = reactionrole.reactionrolemessageid
-                            left join guildconfigs on reactionrolemessage.guildconfigid = guildconfigs.id
-                            ON CONFLICT DO NOTHING;
-                """);
-        }
-        else
-        {
-            throw new NotSupportedException("This database provider doesn't have an implementation for MigrateRero");
-        }
-    }
-}

src/Nadeko.Bot.Db/Models/CommandAlias.cs

@@ -1,8 +0,0 @@
-#nullable disable
-namespace NadekoBot.Services.Database.Models;
-
-public class CommandAlias : DbEntity
-{
-    public string Trigger { get; set; }
-    public string Mapping { get; set; }
-}

src/Nadeko.Bot.Db/MysqlContext.cs

@@ -1,38 +0,0 @@
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Db.Models;
-
-namespace NadekoBot.Services.Database;
-
-public sealed class MysqlContext : NadekoContext
-{
-    private readonly string _connStr;
-    private readonly string _version;
-
-    protected override string CurrencyTransactionOtherIdDefaultValue
-        => "NULL";
-
-    public MysqlContext(string connStr = "Server=localhost", string version = "8.0")
-    {
-        _connStr = connStr;
-        _version = version;
-    }
-
-    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
-    {
-        base.OnConfiguring(optionsBuilder);
-        optionsBuilder
-            .UseLowerCaseNamingConvention()
-            .UseMySql(_connStr, ServerVersion.Parse(_version));
-    }
-
-    protected override void OnModelCreating(ModelBuilder modelBuilder)
-    {
-        base.OnModelCreating(modelBuilder);
-        
-        // mysql is case insensitive by default
-        // we can set binary collation to change that
-        modelBuilder.Entity<ClubInfo>()
-                    .Property(x => x.Name)
-                    .UseCollation("utf8mb4_bin");
-    }
-}

src/Nadeko.Bot.Db/NadekoBaseContext.cs

@@ -0,0 +1,7 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace NadekoBot.Db;
+
+public abstract class NadekoBaseContext : DbContext
+{
+}

src/Nadeko.Bot.Db/NadekoContext.cs

@@ -1,490 +0,0 @@
-#nullable disable
-using Microsoft.EntityFrameworkCore;
-using NadekoBot.Db.Models;
-using NadekoBot.Services.Database.Models;
-
-// ReSharper disable UnusedAutoPropertyAccessor.Global
-
-namespace NadekoBot.Services.Database;
-
-public abstract class NadekoContext : DbContext
-{
-    public DbSet<GuildConfig> GuildConfigs { get; set; }
-
-    public DbSet<Quote> Quotes { get; set; }
-    public DbSet<Reminder> Reminders { get; set; }
-    public DbSet<SelfAssignedRole> SelfAssignableRoles { get; set; }
-    public DbSet<MusicPlaylist> MusicPlaylists { get; set; }
-    public DbSet<NadekoExpression> Expressions { get; set; }
-    public DbSet<CurrencyTransaction> CurrencyTransactions { get; set; }
-    public DbSet<WaifuUpdate> WaifuUpdates { get; set; }
-    public DbSet<WaifuItem> WaifuItem { get; set; }
-    public DbSet<Warning> Warnings { get; set; }
-    public DbSet<UserXpStats> UserXpStats { get; set; }
-    public DbSet<ClubInfo> Clubs { get; set; }
-    public DbSet<ClubBans> ClubBans { get; set; }
-    public DbSet<ClubApplicants> ClubApplicants { get; set; }
-
-
-    //logging
-    public DbSet<LogSetting> LogSettings { get; set; }
-    public DbSet<IgnoredVoicePresenceChannel> IgnoredVoicePresenceCHannels { get; set; }
-    public DbSet<IgnoredLogItem> IgnoredLogChannels { get; set; }
-
-    public DbSet<RotatingPlayingStatus> RotatingStatus { get; set; }
-    public DbSet<BlacklistEntry> Blacklist { get; set; }
-    public DbSet<AutoCommand> AutoCommands { get; set; }
-    public DbSet<RewardedUser> RewardedUsers { get; set; }
-    public DbSet<PlantedCurrency> PlantedCurrency { get; set; }
-    public DbSet<BanTemplate> BanTemplates { get; set; }
-    public DbSet<DiscordPermOverride> DiscordPermOverrides { get; set; }
-    public DbSet<DiscordUser> DiscordUser { get; set; }
-    public DbSet<MusicPlayerSettings> MusicPlayerSettings { get; set; }
-    public DbSet<Repeater> Repeaters { get; set; }
-    public DbSet<Poll> Poll { get; set; }
-    public DbSet<WaifuInfo> WaifuInfo { get; set; }
-    public DbSet<ImageOnlyChannel> ImageOnlyChannels { get; set; }
-    public DbSet<NsfwBlacklistedTag> NsfwBlacklistedTags { get; set; }
-    public DbSet<AutoTranslateChannel> AutoTranslateChannels { get; set; }
-    public DbSet<AutoTranslateUser> AutoTranslateUsers { get; set; }
-
-    public DbSet<Permissionv2> Permissions { get; set; }
-
-    public DbSet<BankUser> BankUsers { get; set; }
-
-    public DbSet<ReactionRoleV2> ReactionRoles { get; set; }
-
-    public DbSet<PatronUser> Patrons { get; set; }
-
-    public DbSet<PatronQuota> PatronQuotas { get; set; }
-    
-    public DbSet<StreamOnlineMessage> StreamOnlineMessages { get; set; }
-
-
-    #region Mandatory Provider-Specific Values
-
-    protected abstract string CurrencyTransactionOtherIdDefaultValue { get; }
-
-    #endregion
-
-    protected override void OnModelCreating(ModelBuilder modelBuilder)
-    {
-        #region QUOTES
-
-        var quoteEntity = modelBuilder.Entity<Quote>();
-        quoteEntity.HasIndex(x => x.GuildId);
-        quoteEntity.HasIndex(x => x.Keyword);
-
-        #endregion
-
-        #region GuildConfig
-
-        var configEntity = modelBuilder.Entity<GuildConfig>();
-        configEntity.HasIndex(c => c.GuildId)
-                    .IsUnique();
-
-        configEntity.Property(x => x.VerboseErrors)
-                    .HasDefaultValue(true);
-
-        modelBuilder.Entity<AntiSpamSetting>().HasOne(x => x.GuildConfig).WithOne(x => x.AntiSpamSetting);
-
-        modelBuilder.Entity<AntiRaidSetting>().HasOne(x => x.GuildConfig).WithOne(x => x.AntiRaidSetting);
-
-        modelBuilder.Entity<GuildConfig>()
-                    .HasOne(x => x.AntiAltSetting)
-                    .WithOne()
-                    .HasForeignKey<AntiAltSetting>(x => x.GuildConfigId)
-                    .OnDelete(DeleteBehavior.Cascade);
-
-        modelBuilder.Entity<FeedSub>()
-                    .HasAlternateKey(x => new
-                    {
-                        x.GuildConfigId,
-                        x.Url
-                    });
-
-        modelBuilder.Entity<PlantedCurrency>().HasIndex(x => x.MessageId).IsUnique();
-
-        modelBuilder.Entity<PlantedCurrency>().HasIndex(x => x.ChannelId);
-
-        configEntity.HasIndex(x => x.WarnExpireHours).IsUnique(false);
-
-        #endregion
-
-        #region streamrole
-
-        modelBuilder.Entity<StreamRoleSettings>().HasOne(x => x.GuildConfig).WithOne(x => x.StreamRole);
-
-        #endregion
-
-        #region Self Assignable Roles
-
-        var selfassignableRolesEntity = modelBuilder.Entity<SelfAssignedRole>();
-
-        selfassignableRolesEntity.HasIndex(s => new
-                                 {
-                                     s.GuildId,
-                                     s.RoleId
-                                 })
-                                 .IsUnique();
-
-        selfassignableRolesEntity.Property(x => x.Group).HasDefaultValue(0);
-
-        #endregion
-
-        #region MusicPlaylists
-
-        var musicPlaylistEntity = modelBuilder.Entity<MusicPlaylist>();
-
-        musicPlaylistEntity.HasMany(p => p.Songs).WithOne().OnDelete(DeleteBehavior.Cascade);
-
-        #endregion
-
-        #region Waifus
-
-        var wi = modelBuilder.Entity<WaifuInfo>();
-        wi.HasOne(x => x.Waifu).WithOne();
-
-        wi.HasIndex(x => x.Price);
-        wi.HasIndex(x => x.ClaimerId);
-        // wi.HasMany(x => x.Items)
-        //     .WithOne()
-        //     .OnDelete(DeleteBehavior.Cascade);
-
-        #endregion
-
-        #region DiscordUser
-
-        modelBuilder.Entity<DiscordUser>(du =>
-        {
-            du.Property(x => x.IsClubAdmin)
-              .HasDefaultValue(false);
-
-            du.Property(x => x.NotifyOnLevelUp)
-              .HasDefaultValue(XpNotificationLocation.None);
-
-            du.Property(x => x.TotalXp)
-              .HasDefaultValue(0);
-
-            du.Property(x => x.CurrencyAmount)
-              .HasDefaultValue(0);
-
-            du.HasAlternateKey(w => w.UserId);
-            du.HasOne(x => x.Club)
-              .WithMany(x => x.Members)
-              .IsRequired(false)
-              .OnDelete(DeleteBehavior.NoAction);
-
-            du.HasIndex(x => x.TotalXp);
-            du.HasIndex(x => x.CurrencyAmount);
-            du.HasIndex(x => x.UserId);
-        });
-
-        #endregion
-
-        #region Warnings
-
-        modelBuilder.Entity<Warning>(warn =>
-        {
-            warn.HasIndex(x => x.GuildId);
-            warn.HasIndex(x => x.UserId);
-            warn.HasIndex(x => x.DateAdded);
-            warn.Property(x => x.Weight).HasDefaultValue(1);
-        });
-
-        #endregion
-
-        #region XpStats
-
-        var xps = modelBuilder.Entity<UserXpStats>();
-        xps.HasIndex(x => new
-           {
-               x.UserId,
-               x.GuildId
-           })
-           .IsUnique();
-
-        xps.HasIndex(x => x.UserId);
-        xps.HasIndex(x => x.GuildId);
-        xps.HasIndex(x => x.Xp);
-        xps.HasIndex(x => x.AwardedXp);
-
-        #endregion
-
-        #region XpSettings
-
-        modelBuilder.Entity<XpSettings>().HasOne(x => x.GuildConfig).WithOne(x => x.XpSettings);
-
-        #endregion
-
-        #region XpRoleReward
-
-        modelBuilder.Entity<XpRoleReward>()
-                    .HasIndex(x => new
-                    {
-                        x.XpSettingsId,
-                        x.Level
-                    })
-                    .IsUnique();
-
-        #endregion
-
-        #region Club
-
-        var ci = modelBuilder.Entity<ClubInfo>();
-        ci.HasOne(x => x.Owner)
-          .WithOne()
-          .HasForeignKey<ClubInfo>(x => x.OwnerId)
-          .OnDelete(DeleteBehavior.SetNull);
-
-        ci.HasAlternateKey(x => new
-        {
-            x.Name
-        });
-
-        #endregion
-
-        #region ClubManytoMany
-
-        modelBuilder.Entity<ClubApplicants>()
-                    .HasKey(t => new
-                    {
-                        t.ClubId,
-                        t.UserId
-                    });
-
-        modelBuilder.Entity<ClubApplicants>()
-                    .HasOne(pt => pt.User)
-                    .WithMany();
-
-        modelBuilder.Entity<ClubApplicants>()
-                    .HasOne(pt => pt.Club)
-                    .WithMany(x => x.Applicants);
-
-        modelBuilder.Entity<ClubBans>()
-                    .HasKey(t => new
-                    {
-                        t.ClubId,
-                        t.UserId
-                    });
-
-        modelBuilder.Entity<ClubBans>()
-                    .HasOne(pt => pt.User)
-                    .WithMany();
-
-        modelBuilder.Entity<ClubBans>()
-                    .HasOne(pt => pt.Club)
-                    .WithMany(x => x.Bans);
-
-        #endregion
-
-        #region Polls
-
-        modelBuilder.Entity<Poll>().HasIndex(x => x.GuildId).IsUnique();
-
-        #endregion
-
-        #region CurrencyTransactions
-
-        modelBuilder.Entity<CurrencyTransaction>(e =>
-        {
-            e.HasIndex(x => x.UserId)
-             .IsUnique(false);
-
-            e.Property(x => x.OtherId)
-             .HasDefaultValueSql(CurrencyTransactionOtherIdDefaultValue);
-
-            e.Property(x => x.Type)
-             .IsRequired();
-
-            e.Property(x => x.Extra)
-             .IsRequired();
-        });
-
-        #endregion
-
-        #region Reminders
-
-        modelBuilder.Entity<Reminder>().HasIndex(x => x.When);
-
-        #endregion
-
-        #region GroupName
-
-        modelBuilder.Entity<GroupName>()
-                    .HasIndex(x => new
-                    {
-                        x.GuildConfigId,
-                        x.Number
-                    })
-                    .IsUnique();
-
-        modelBuilder.Entity<GroupName>()
-                    .HasOne(x => x.GuildConfig)
-                    .WithMany(x => x.SelfAssignableRoleGroupNames)
-                    .IsRequired();
-
-        #endregion
-
-        #region BanTemplate
-
-        modelBuilder.Entity<BanTemplate>().HasIndex(x => x.GuildId).IsUnique();
-        modelBuilder.Entity<BanTemplate>()
-            .Property(x => x.PruneDays)
-            .HasDefaultValue(null)
-            .IsRequired(false);
-
-        #endregion
-
-        #region Perm Override
-
-        modelBuilder.Entity<DiscordPermOverride>()
-                    .HasIndex(x => new
-                    {
-                        x.GuildId,
-                        x.Command
-                    })
-                    .IsUnique();
-
-        #endregion
-
-        #region Music
-
-        modelBuilder.Entity<MusicPlayerSettings>().HasIndex(x => x.GuildId).IsUnique();
-
-        modelBuilder.Entity<MusicPlayerSettings>().Property(x => x.Volume).HasDefaultValue(100);
-
-        #endregion
-
-        #region Reaction roles
-
-        modelBuilder.Entity<ReactionRoleV2>(rr2 =>
-        {
-            rr2.HasIndex(x => x.GuildId)
-               .IsUnique(false);
-
-            rr2.HasIndex(x => new
-               {
-                   x.MessageId,
-                   x.Emote
-               })
-               .IsUnique();
-        });
-
-        #endregion
-
-        #region LogSettings
-
-        modelBuilder.Entity<LogSetting>(ls => ls.HasIndex(x => x.GuildId).IsUnique());
-
-        modelBuilder.Entity<LogSetting>(ls => ls
-                                              .HasMany(x => x.LogIgnores)
-                                              .WithOne(x => x.LogSetting)
-                                              .OnDelete(DeleteBehavior.Cascade));
-
-        modelBuilder.Entity<IgnoredLogItem>(ili => ili
-                                                   .HasIndex(x => new
-                                                   {
-                                                       x.LogSettingId,
-                                                       x.LogItemId,
-                                                       x.ItemType
-                                                   })
-                                                   .IsUnique());
-
-        #endregion
-
-        modelBuilder.Entity<ImageOnlyChannel>(ioc => ioc.HasIndex(x => x.ChannelId).IsUnique());
-
-        modelBuilder.Entity<NsfwBlacklistedTag>(nbt => nbt.HasIndex(x => x.GuildId).IsUnique(false));
-
-        var atch = modelBuilder.Entity<AutoTranslateChannel>();
-        atch.HasIndex(x => x.GuildId).IsUnique(false);
-
-        atch.HasIndex(x => x.ChannelId).IsUnique();
-
-        atch.HasMany(x => x.Users).WithOne(x => x.Channel).OnDelete(DeleteBehavior.Cascade);
-
-        modelBuilder.Entity<AutoTranslateUser>(atu => atu.HasAlternateKey(x => new
-        {
-            x.ChannelId,
-            x.UserId
-        }));
-
-        #region BANK
-
-        modelBuilder.Entity<BankUser>(bu => bu.HasIndex(x => x.UserId).IsUnique());
-
-        #endregion
-
-
-        #region Patron
-
-        // currency rewards
-        var pr = modelBuilder.Entity<RewardedUser>();
-        pr.HasIndex(x => x.PlatformUserId).IsUnique();
-
-        // patrons
-        // patrons are not identified by their user id, but by their platform user id
-        // as multiple accounts (even maybe on different platforms) could have
-        // the same account connected to them
-        modelBuilder.Entity<PatronUser>(pu =>
-        {
-            pu.HasIndex(x => x.UniquePlatformUserId).IsUnique();
-            pu.HasKey(x => x.UserId);
-        });
-
-        // quotes are per user id
-        modelBuilder.Entity<PatronQuota>(pq =>
-        {
-            pq.HasIndex(x => x.UserId).IsUnique(false);
-            pq.HasKey(x => new
-            {
-                x.UserId,
-                x.FeatureType,
-                x.Feature
-            });
-        });
-
-        #endregion
- 
-        #region Xp Item Shop
-
-        modelBuilder.Entity<XpShopOwnedItem>(
-            x =>
-            {
-                // user can own only one of each item
-                x.HasIndex(model => new
-                    {
-                        model.UserId,
-                        model.ItemType,
-                        model.ItemKey
-                    })
-                    .IsUnique();
-            });
-
-        #endregion
-        
-        #region AutoPublish
-
-        modelBuilder.Entity<AutoPublishChannel>(apc => apc
-            .HasIndex(x => x.GuildId)
-            .IsUnique());
-
-        #endregion
-        
-        #region GamblingStats
-
-        modelBuilder.Entity<GamblingStats>(gs => gs
-            .HasIndex(x => x.Feature)
-            .IsUnique());
-
-        #endregion
-    }
-
-// #if DEBUG
-//     private static readonly ILoggerFactory _debugLoggerFactory = LoggerFactory.Create(x => x.AddConsole());
-//
-//     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
-//         => optionsBuilder.UseLoggerFactory(_debugLoggerFactory);
-// #endif
-}

src/Nadeko.Bot.Db/PostgreSqlContext.cs

@@ -1,26 +0,0 @@
-using Microsoft.EntityFrameworkCore;
-
-namespace NadekoBot.Services.Database;
-
-public sealed class PostgreSqlContext : NadekoContext
-{
-    private readonly string _connStr;
-
-    protected override string CurrencyTransactionOtherIdDefaultValue
-        => "NULL";
-
-    public PostgreSqlContext(string connStr = "Host=localhost")
-    {
-        _connStr = connStr;
-    }
-
-    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
-    {
-        AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
-        
-        base.OnConfiguring(optionsBuilder);
-        optionsBuilder
-            .UseLowerCaseNamingConvention()
-            .UseNpgsql(_connStr);
-    }
-}

src/Nadeko.Bot.Db/SqliteContext.cs

@@ -1,26 +0,0 @@
-using Microsoft.Data.Sqlite;
-using Microsoft.EntityFrameworkCore;
-
-namespace NadekoBot.Services.Database;
-
-public sealed class SqliteContext : NadekoContext
-{
-    private readonly string _connectionString;
-
-    protected override string CurrencyTransactionOtherIdDefaultValue
-        => "NULL";
-
-    public SqliteContext(string connectionString = "Data Source=data/NadekoBot.db", int commandTimeout = 60)
-    {
-        _connectionString = connectionString;
-        Database.SetCommandTimeout(commandTimeout);
-    }
-
-    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
-    {
-        base.OnConfiguring(optionsBuilder);
-        var builder = new SqliteConnectionStringBuilder(_connectionString);
-        builder.DataSource = Path.Combine(AppContext.BaseDirectory, builder.DataSource);
-        optionsBuilder.UseSqlite(builder.ToString());
-    }
-}