Async db

build · build · commit 37599d53516c · 2025-10-12T01:09:47.000-04:00
diff --git a/BaroBot/Commands/CategoryCommands/ArchiveCommand.cs b/BaroBot/Commands/CategoryCommands/ArchiveCommand.cs
@@ -22,22 +22,22 @@ public partial class CategoryCommand
     [SlashCommand("archive", "Archives the specified category")]
     public async Task Archive(SocketCategoryChannel socketCategory)
     {
-        Category? category = GetCategory(socketCategory, Context.Guild);
+        Category? category = await GetCategory(socketCategory, Context.Guild);
         if (category == null)
         {
             await RespondAsync("That category is not registered!");
             return;
         }
 
-        GuildConfig? guildConfig = _database.FetchOne<GuildConfig>(config => config.GuildId == Context.Guild.Id);
+        GuildConfig? guildConfig = await _database.FetchOneAsync<GuildConfig>(config => config.GuildId == Context.Guild.Id);
         if (guildConfig is null)
         {
             guildConfig = new GuildConfig(Context.Guild);
-            _database.Save(guildConfig);
+            await _database.SaveAsync(guildConfig);
         }
 
         if (guildConfig.ArchiveCategoryId == 0 ||
-            Context.Guild.GetCategoryChannel(guildConfig.ArchiveCategoryId) is not SocketCategoryChannel archiveCategory)
+            Context.Guild.GetCategoryChannel(guildConfig.ArchiveCategoryId) is not { } archiveCategory)
         {
             await RespondAsync("The archive category is not set.");
             return;
@@ -54,7 +54,7 @@ public async Task Archive(SocketCategoryChannel socketCategory)
         if (role is not null)
             await role.DeleteAsync();
 
-        _database.Delete(category);
+        await _database.DeleteAsync(category);
         await RespondAsync($"Category {category.Name} has been archived.");
     }
 
diff --git a/BaroBot/Commands/CategoryCommands/CategoryCommand.cs b/BaroBot/Commands/CategoryCommands/CategoryCommand.cs
@@ -41,21 +41,21 @@ public CategoryCommand(DatabaseService database, DiscordSocketClient client, Env
         _eventDispatcher = eventEventDispatcher;
     }
 
-    private Category? GetCategory(SocketCategoryChannel categoryChannel, SocketGuild guild)
+    private async Task<Category?> GetCategory(SocketCategoryChannel categoryChannel, SocketGuild guild)
     {
-        return _database.FetchOne<Category>(category =>
+        return await _database.FetchOneAsync<Category>(category =>
             category.CategoryId == categoryChannel.Id && category.GuildId == guild.Id);
     }
 
-    private Category? GetCategory(string categoryName, SocketGuild guild)
+    private async Task<Category?> GetCategory(string categoryName, SocketGuild guild)
     {
-        return _database.FetchOne<Category>(category =>
+        return await _database.FetchOneAsync<Category>(category =>
             string.Equals(category.Name, categoryName, StringComparison.OrdinalIgnoreCase) && category.GuildId == guild.Id);
     }
 
-    private Category? GetCategory(IRole role, SocketGuild guild)
+    private async Task<Category?> GetCategory(IRole role, SocketGuild guild)
     {
-        return _database.FetchOne<Category>(category =>
+        return await _database.FetchOneAsync<Category>(category =>
             category.RoleId == role.Id && category.GuildId == guild.Id);
     }
 }
diff --git a/BaroBot/Commands/CategoryCommands/CreateCommand.cs b/BaroBot/Commands/CategoryCommands/CreateCommand.cs
@@ -34,7 +34,8 @@ public async Task Create(
         [Summary("game-id", "The ID of the steam game this category is associated with")]
         int gameId = 0)
     {
-        if (GetCategory(name, Context.Guild) != null)
+        Category? existingCategory = await GetCategory(name, Context.Guild);
+        if (existingCategory != null)
         {
             await RespondAsync("A category with that name already exists!");
             return;
@@ -63,7 +64,7 @@ await Context.Guild.CreateVoiceChannelAsync(voiceChannel, properties =>
         });
 
         Category category = new Category(restCategory, restRole, gameId);
-        _database.Save(category);
+        await _database.SaveAsync(category);
         await _eventDispatcher.RaiseCategoryCreatedAsync(new CategoryCreatedEvent(category));
 
         await RespondAsync($"Category '{name}' created!");
diff --git a/BaroBot/Commands/CategoryCommands/ImportCommand.cs b/BaroBot/Commands/CategoryCommands/ImportCommand.cs
@@ -30,21 +30,21 @@ public async Task Import(
         [Summary("game-id", "The ID of the steam game this category is associated with")]
         int gameId = 0)
     {
-        Category? category = GetCategory(socketCategory, Context.Guild);
+        Category? category = await GetCategory(socketCategory, Context.Guild);
         if (category != null)
         {
             await RespondAsync("That category is already registered!");
             return;
         }
 
-        category = GetCategory(role, Context.Guild);
+        category = await GetCategory(role, Context.Guild);
         if (category != null)
         {
             await RespondAsync("That role is already registered!");
             return;
         }
 
-        _database.Save(new Category(socketCategory, role, gameId));
+        await _database.SaveAsync(new Category(socketCategory, role, gameId));
         await RespondAsync($"Category '{socketCategory.Name}' imported!");
     }
 }
diff --git a/BaroBot/Commands/CategoryCommands/IpCommand.cs b/BaroBot/Commands/CategoryCommands/IpCommand.cs
@@ -33,7 +33,7 @@ public async Task Ip(
         [Summary("resolve-on-query", "Whether it should be resolved when it is queried.")]
         bool resolveOnQuery = false)
     {
-        Category? category = GetCategory(socketCategory, Context.Guild);
+        Category? category = await GetCategory(socketCategory, Context.Guild);
         if (category == null)
         {
             await RespondAsync("That category is not registered!");
@@ -54,7 +54,7 @@ public async Task Ip(
 
         category.Ip = ip;
         category.ResolveIpOnQuery = resolveOnQuery;
-        _database.Upsert(category);
+        await _database.UpsertAsync(category);
         await RespondAsync($"Set {connectionString} as the connection to this categories server.", ephemeral: true);
     }
 
diff --git a/BaroBot/Commands/CategoryCommands/RemoveCommand.cs b/BaroBot/Commands/CategoryCommands/RemoveCommand.cs
@@ -23,20 +23,20 @@ public async Task Remove(
         [Summary("category", "The category to remove")]
         SocketCategoryChannel socketCategory)
     {
-        Category? category = GetCategory(socketCategory, Context.Guild);
+        Category? category = await GetCategory(socketCategory, Context.Guild);
         if (category == null)
         {
             await RespondAsync("That category is not registered!");
             return;
         }
 
-        if (!await category.Delete(_client))
+        if (!await category.DeleteAsync(_client))
         {
             await RespondAsync("An error occurred while deleting the category.");
             return;
         }
 
-        _database.Delete(category);
+        await _database.DeleteAsync(category);
         await RespondAsync($"Category '{category.Name}' removed!");
     }
 
@@ -50,20 +50,20 @@ public async Task Remove(
         [Summary("category", "The category to remove")]
         string socketCategory)
     {
-        Category? category = GetCategory(socketCategory, Context.Guild);
+        Category? category = await GetCategory(socketCategory, Context.Guild);
         if (category == null)
         {
             await RespondAsync("That category is not registered!");
             return;
         }
 
-        if (!await category.Delete(_client))
+        if (!await category.DeleteAsync(_client))
         {
             await RespondAsync("An error occurred while deleting the category.");
             return;
         }
 
-        _database.Delete(category);
+        await _database.DeleteAsync(category);
         await RespondAsync($"Category '{category.Name}' removed!");
     }
 }
diff --git a/BaroBot/Commands/CategoryCommands/SteamIdCommand.cs b/BaroBot/Commands/CategoryCommands/SteamIdCommand.cs
@@ -28,21 +28,21 @@ public async Task GameId(
         [Summary("game-id", "The new id")]
         int gameId)
     {
-        Category? category = GetCategory(socketCategory, Context.Guild);
+        Category? category = await GetCategory(socketCategory, Context.Guild);
         if (category is null)
         {
             await RespondAsync("That category is not registered!");
             return;
         }
 
         category.GameId = gameId;
-        _database.Update(category);
+        await _database.UpdateAsync(category);
 
         foreach (var user in Context.Guild.Users)
         {
             try
             {
-                SteamLink? steamLink = _database.FetchOne<SteamLink>(x => x.UserId == user.Id);
+                SteamLink? steamLink = await _database.FetchOneAsync<SteamLink>(x => x.UserId == user.Id);
                 if (steamLink is null || !steamLink.UpdateAutomatically)
                     continue;
 
diff --git a/BaroBot/Commands/IpCommand.cs b/BaroBot/Commands/IpCommand.cs
@@ -49,7 +49,7 @@ public async Task Execute()
             return;
         }
 
-        Category? category = _database.FetchOne<Category>(category => category.CategoryId == categoryChannel.Id && category.GuildId == Context.Guild.Id);
+        Category? category = await _database.FetchOneAsync<Category>(category => category.CategoryId == categoryChannel.Id && category.GuildId == Context.Guild.Id);
         if (category is null)
         {
             await RespondAsync("Unable to locate the target category.");
diff --git a/BaroBot/Commands/RentGeneratorCommand.cs b/BaroBot/Commands/RentGeneratorCommand.cs
@@ -38,7 +38,7 @@ public RentGeneratorCommand(DatabaseService database)
     public async Task Execute([Summary("name", "The name of the rent generator")] string name)
     {
         RestVoiceChannel restVoiceChannel = await Context.Guild.CreateVoiceChannelAsync(name);
-        _database.Save(new RentGenerator(restVoiceChannel));
+        await _database.SaveAsync(new RentGenerator(restVoiceChannel));
         await RespondAsync($"Created a rent generator with the name '{name}'");
     }
 }
diff --git a/BaroBot/Commands/RoleCommands/ListCommand.cs b/BaroBot/Commands/RoleCommands/ListCommand.cs
@@ -25,7 +25,7 @@ public async Task List()
             return;
         }
 
-        Embed? availableRoles = AvailableRoles(Context.User);
+        Embed? availableRoles = await AvailableRoles(Context.User);
         if (availableRoles == null)
         {
             await RespondAsync("There are no toggleable roles available in this server.");
diff --git a/BaroBot/Commands/RoleCommands/RoleCommand.cs b/BaroBot/Commands/RoleCommands/RoleCommand.cs
@@ -31,9 +31,9 @@ public RoleCommand(DatabaseService database)
         _database = database;
     }
 
-    private Embed? AvailableRoles(SocketUser user)
+    private async Task<Embed?> AvailableRoles(SocketUser user)
     {
-        IEnumerable<Category> categories = _database.Fetch<Category>(category => category.GuildId == Context.Guild.Id);
+        IEnumerable<Category> categories = await _database.FetchAsync<Category>(category => category.GuildId == Context.Guild.Id);
         if (!categories.Any())
             return null;
 
diff --git a/BaroBot/Commands/RoleCommands/ToggleCommand.cs b/BaroBot/Commands/RoleCommands/ToggleCommand.cs
@@ -28,10 +28,10 @@ public async Task Toggle([Summary("role", "The role to add or remove")] IRole ro
             return;
         }
 
-        Category? category = _database.FetchOne<Category>(category => category.RoleId == role.Id && category.GuildId == Context.Guild.Id);
+        Category? category = await _database.FetchOneAsync<Category>(category => category.RoleId == role.Id && category.GuildId == Context.Guild.Id);
         if (category == null)
         {
-            Embed? availableRoles = AvailableRoles(Context.User);
+            Embed? availableRoles = await AvailableRoles(Context.User);
             if (availableRoles == null)
             {
                 await RespondAsync("There are no toggleable roles available in this server.");
diff --git a/BaroBot/Commands/SteamCommands/LinkCommand.cs b/BaroBot/Commands/SteamCommands/LinkCommand.cs
@@ -33,19 +33,19 @@ public async Task Link(
             return;
         }
 
-        SteamLink? existingLink = _database.FetchOne<SteamLink>(x => x.UserId == Context.User.Id);
+        SteamLink? existingLink = await _database.FetchOneAsync<SteamLink>(x => x.UserId == Context.User.Id);
         if (existingLink is not null)
         {
             existingLink.SteamId = id;
             existingLink.KnownGames = knownGames;
             existingLink.UpdateAutomatically = autoSync;
-            _database.Update(existingLink);
+            await _database.UpdateAsync(existingLink);
             await RespondAsync("Successfully updated link!");
             return;
         }
 
         SteamLink steamLink = new SteamLink(Context.User.Id, id, knownGames, autoSync);
-        _database.Save(steamLink);
+        await _database.SaveAsync(steamLink);
         await RespondAsync("Successfully created link!");
     }
 }
diff --git a/BaroBot/Commands/SteamCommands/SyncCommand.cs b/BaroBot/Commands/SteamCommands/SyncCommand.cs
@@ -23,7 +23,7 @@ public partial class SteamCommand
     [SlashCommand("sync", "WARNING! This command overrides all current roles and grants roles based off owned games")]
     public async Task Sync()
     {
-        SteamLink? existingLink = _database.FetchOne<SteamLink>(x => x.UserId == Context.User.Id);
+        SteamLink? existingLink = await _database.FetchOneAsync<SteamLink>(x => x.UserId == Context.User.Id);
         if (existingLink is null)
         {
             await RespondAsync("No steam link found.");
@@ -41,7 +41,7 @@ public async Task Sync()
         List<IRole> toAdd = new();
 
         SocketGuildUser socketGuildUser = Context.Guild.GetUser(Context.User.Id);
-        IEnumerable<Category> categories = _database.Fetch<Category>(x => x.GuildId == Context.Guild.Id);
+        IEnumerable<Category> categories = await _database.FetchAsync<Category>(x => x.GuildId == Context.Guild.Id);
         foreach (var category in categories)
         {
             if (category.GameId == 0)
diff --git a/BaroBot/Commands/SteamCommands/ToggleCommand.cs b/BaroBot/Commands/SteamCommands/ToggleCommand.cs
@@ -22,15 +22,15 @@ public partial class SteamCommand
     [SlashCommand("toggle", "Toggles the automatic addition of roles when categories are created")]
     public async Task Toggle()
     {
-        SteamLink? existingLink = _database.FetchOne<SteamLink>(x => x.UserId == Context.User.Id);
+        SteamLink? existingLink = await _database.FetchOneAsync<SteamLink>(x => x.UserId == Context.User.Id);
         if (existingLink is null)
         {
             await RespondAsync("No steam link found.");
             return;
         }
 
         existingLink.UpdateAutomatically = !existingLink.UpdateAutomatically;
-        _database.Update(existingLink);
+        await _database.UpdateAsync(existingLink);
 
         await RespondAsync(existingLink.UpdateAutomatically ? UpdatingResponse : NotUpdatingResponse);
     }
diff --git a/BaroBot/Database/Domain/Category.cs b/BaroBot/Database/Domain/Category.cs
@@ -123,7 +123,7 @@ public Category(SocketCategoryChannel category, IRole role, int gameId)
     /// </summary>
     /// <param name="client">An instance of the current <see cref="DiscordSocketClient"/>.</param>
     /// <returns>A value indicating whether the category was successfully deleted.</returns>
-    public virtual async Task<bool> Delete(DiscordSocketClient client)
+    public virtual async Task<bool> DeleteAsync(DiscordSocketClient client)
     {
         SocketGuild? guild = client.GetGuild(GuildId);
         if (guild is null)
diff --git a/BaroBot/Database/UserTypes/IntListJsonType.cs b/BaroBot/Database/UserTypes/IntListJsonType.cs
@@ -73,5 +73,4 @@ public object DeepCopy(object value) =>
             return new List<int>();
         }
     }
-
 }
diff --git a/BaroBot/GuildConfiguration/Commands/ArchiveCategoryCommand.cs b/BaroBot/GuildConfiguration/Commands/ArchiveCategoryCommand.cs
@@ -23,9 +23,9 @@ public async Task ArchiveCategory(
         [Summary("category", "The category to move archived channels to")]
         SocketCategoryChannel category)
     {
-        GuildConfig guildConfig = GetOrCreateConfig(Context.Guild);
+        GuildConfig guildConfig = await GetOrCreateConfig(Context.Guild);
         guildConfig.ArchiveCategoryId = category.Id;
-        database.Upsert(guildConfig);
+        await database.UpsertAsync(guildConfig);
         await RespondAsync($"Set '{category.Name}' as the archive category!");
     }
 }
diff --git a/BaroBot/GuildConfiguration/Commands/ConfigureCommand.cs b/BaroBot/GuildConfiguration/Commands/ConfigureCommand.cs
@@ -31,13 +31,13 @@ public ConfigureCommand(DatabaseService database)
         this.database = database;
     }
 
-    private GuildConfig GetOrCreateConfig(SocketGuild guild)
+    private async Task<GuildConfig> GetOrCreateConfig(SocketGuild guild)
     {
-        GuildConfig? guildConfig = database.FetchOne<GuildConfig>(config => config.GuildId == guild.Id);
+        GuildConfig? guildConfig = await database.FetchOneAsync<GuildConfig>(config => config.GuildId == guild.Id);
         if (guildConfig is null)
         {
             guildConfig = new GuildConfig(guild);
-            database.Save(guildConfig);
+            await database.SaveAsync(guildConfig);
         }
 
         return guildConfig;
diff --git a/BaroBot/GuildConfiguration/Commands/LogChannelCommand.cs b/BaroBot/GuildConfiguration/Commands/LogChannelCommand.cs
@@ -23,9 +23,9 @@ public async Task LogChannel(
         [Summary("channel", "The channel to send chat logs to")]
         SocketTextChannel textChannel)
     {
-        GuildConfig guildConfig = GetOrCreateConfig(Context.Guild);
+        GuildConfig guildConfig = await GetOrCreateConfig(Context.Guild);
         guildConfig.LogChannelId = textChannel.Id;
-        database.Upsert(guildConfig);
+        await database.UpsertAsync(guildConfig);
         await RespondAsync($"Set {textChannel.Mention} as the log channel!");
     }
 }
diff --git a/BaroBot/Services/DatabaseService.cs b/BaroBot/Services/DatabaseService.cs
diff --git a/BaroBot/Services/MessageLoggingService.cs b/BaroBot/Services/MessageLoggingService.cs
diff --git a/BaroBot/Services/RentGeneratorService.cs b/BaroBot/Services/RentGeneratorService.cs
diff --git a/BaroBot/Services/SteamLinkService.cs b/BaroBot/Services/SteamLinkService.cs

Original file line number	Diff line number	Diff line change
`@@ -22,22 +22,22 @@ public partial class CategoryCommand`
`22`	`22`	`[SlashCommand("archive", "Archives the specified category")]`
`23`	`23`	`public async Task Archive(SocketCategoryChannel socketCategory)`
`24`	`24`	`{`
`25`		`- Category? category = GetCategory(socketCategory, Context.Guild);`
	`25`	`+ Category? category = await GetCategory(socketCategory, Context.Guild);`
`26`	`26`	`if (category == null)`
`27`	`27`	`{`
`28`	`28`	`await RespondAsync("That category is not registered!");`
`29`	`29`	`return;`
`30`	`30`	`}`
`31`	`31`
`32`		`- GuildConfig? guildConfig = _database.FetchOne<GuildConfig>(config => config.GuildId == Context.Guild.Id);`
	`32`	`+ GuildConfig? guildConfig = await _database.FetchOneAsync<GuildConfig>(config => config.GuildId == Context.Guild.Id);`
`33`	`33`	`if (guildConfig is null)`
`34`	`34`	`{`
`35`	`35`	`guildConfig = new GuildConfig(Context.Guild);`
`36`		`- _database.Save(guildConfig);`
	`36`	`+ await _database.SaveAsync(guildConfig);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`if (guildConfig.ArchiveCategoryId == 0 \|\|`
`40`		`- Context.Guild.GetCategoryChannel(guildConfig.ArchiveCategoryId) is not SocketCategoryChannel archiveCategory)`
	`40`	`+ Context.Guild.GetCategoryChannel(guildConfig.ArchiveCategoryId) is not { } archiveCategory)`
`41`	`41`	`{`
`42`	`42`	`await RespondAsync("The archive category is not set.");`
`43`	`43`	`return;`
`@@ -54,7 +54,7 @@ public async Task Archive(SocketCategoryChannel socketCategory)`
`54`	`54`	`if (role is not null)`
`55`	`55`	`await role.DeleteAsync();`
`56`	`56`
`57`		`- _database.Delete(category);`
	`57`	`+ await _database.DeleteAsync(category);`
`58`	`58`	`await RespondAsync($"Category {category.Name} has been archived.");`
`59`	`59`	`}`
`60`	`60`
Original file line number	Diff line number	Diff line change
`@@ -41,21 +41,21 @@ public CategoryCommand(DatabaseService database, DiscordSocketClient client, Env`
`41`	`41`	`_eventDispatcher = eventEventDispatcher;`
`42`	`42`	`}`
`43`	`43`
`44`		`- private Category? GetCategory(SocketCategoryChannel categoryChannel, SocketGuild guild)`
	`44`	`+ private async Task<Category?> GetCategory(SocketCategoryChannel categoryChannel, SocketGuild guild)`
`45`	`45`	`{`
`46`		`- return _database.FetchOne<Category>(category =>`
	`46`	`+ return await _database.FetchOneAsync<Category>(category =>`
`47`	`47`	`category.CategoryId == categoryChannel.Id && category.GuildId == guild.Id);`
`48`	`48`	`}`
`49`	`49`
`50`		`- private Category? GetCategory(string categoryName, SocketGuild guild)`
	`50`	`+ private async Task<Category?> GetCategory(string categoryName, SocketGuild guild)`
`51`	`51`	`{`
`52`		`- return _database.FetchOne<Category>(category =>`
	`52`	`+ return await _database.FetchOneAsync<Category>(category =>`
`53`	`53`	`string.Equals(category.Name, categoryName, StringComparison.OrdinalIgnoreCase) && category.GuildId == guild.Id);`
`54`	`54`	`}`
`55`	`55`
`56`		`- private Category? GetCategory(IRole role, SocketGuild guild)`
	`56`	`+ private async Task<Category?> GetCategory(IRole role, SocketGuild guild)`
`57`	`57`	`{`
`58`		`- return _database.FetchOne<Category>(category =>`
	`58`	`+ return await _database.FetchOneAsync<Category>(category =>`
`59`	`59`	`category.RoleId == role.Id && category.GuildId == guild.Id);`
`60`	`60`	`}`
`61`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,21 +30,21 @@ public async Task Import(`
`30`	`30`	`[Summary("game-id", "The ID of the steam game this category is associated with")]`
`31`	`31`	`int gameId = 0)`
`32`	`32`	`{`
`33`		`- Category? category = GetCategory(socketCategory, Context.Guild);`
	`33`	`+ Category? category = await GetCategory(socketCategory, Context.Guild);`
`34`	`34`	`if (category != null)`
`35`	`35`	`{`
`36`	`36`	`await RespondAsync("That category is already registered!");`
`37`	`37`	`return;`
`38`	`38`	`}`
`39`	`39`
`40`		`- category = GetCategory(role, Context.Guild);`
	`40`	`+ category = await GetCategory(role, Context.Guild);`
`41`	`41`	`if (category != null)`
`42`	`42`	`{`
`43`	`43`	`await RespondAsync("That role is already registered!");`
`44`	`44`	`return;`
`45`	`45`	`}`
`46`	`46`
`47`		`- _database.Save(new Category(socketCategory, role, gameId));`
	`47`	`+ await _database.SaveAsync(new Category(socketCategory, role, gameId));`
`48`	`48`	`await RespondAsync($"Category '{socketCategory.Name}' imported!");`
`49`	`49`	`}`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public async Task Ip(`
`33`	`33`	`[Summary("resolve-on-query", "Whether it should be resolved when it is queried.")]`
`34`	`34`	`bool resolveOnQuery = false)`
`35`	`35`	`{`
`36`		`- Category? category = GetCategory(socketCategory, Context.Guild);`
	`36`	`+ Category? category = await GetCategory(socketCategory, Context.Guild);`
`37`	`37`	`if (category == null)`
`38`	`38`	`{`
`39`	`39`	`await RespondAsync("That category is not registered!");`
`@@ -54,7 +54,7 @@ public async Task Ip(`
`54`	`54`
`55`	`55`	`category.Ip = ip;`
`56`	`56`	`category.ResolveIpOnQuery = resolveOnQuery;`
`57`		`- _database.Upsert(category);`
	`57`	`+ await _database.UpsertAsync(category);`
`58`	`58`	`await RespondAsync($"Set {connectionString} as the connection to this categories server.", ephemeral: true);`
`59`	`59`	`}`
`60`	`60`
Original file line number	Diff line number	Diff line change
`@@ -23,20 +23,20 @@ public async Task Remove(`
`23`	`23`	`[Summary("category", "The category to remove")]`
`24`	`24`	`SocketCategoryChannel socketCategory)`
`25`	`25`	`{`
`26`		`- Category? category = GetCategory(socketCategory, Context.Guild);`
	`26`	`+ Category? category = await GetCategory(socketCategory, Context.Guild);`
`27`	`27`	`if (category == null)`
`28`	`28`	`{`
`29`	`29`	`await RespondAsync("That category is not registered!");`
`30`	`30`	`return;`
`31`	`31`	`}`
`32`	`32`
`33`		`- if (!await category.Delete(_client))`
	`33`	`+ if (!await category.DeleteAsync(_client))`
`34`	`34`	`{`
`35`	`35`	`await RespondAsync("An error occurred while deleting the category.");`
`36`	`36`	`return;`
`37`	`37`	`}`
`38`	`38`
`39`		`- _database.Delete(category);`
	`39`	`+ await _database.DeleteAsync(category);`
`40`	`40`	`await RespondAsync($"Category '{category.Name}' removed!");`
`41`	`41`	`}`
`42`	`42`
`@@ -50,20 +50,20 @@ public async Task Remove(`
`50`	`50`	`[Summary("category", "The category to remove")]`
`51`	`51`	`string socketCategory)`
`52`	`52`	`{`
`53`		`- Category? category = GetCategory(socketCategory, Context.Guild);`
	`53`	`+ Category? category = await GetCategory(socketCategory, Context.Guild);`
`54`	`54`	`if (category == null)`
`55`	`55`	`{`
`56`	`56`	`await RespondAsync("That category is not registered!");`
`57`	`57`	`return;`
`58`	`58`	`}`
`59`	`59`
`60`		`- if (!await category.Delete(_client))`
	`60`	`+ if (!await category.DeleteAsync(_client))`
`61`	`61`	`{`
`62`	`62`	`await RespondAsync("An error occurred while deleting the category.");`
`63`	`63`	`return;`
`64`	`64`	`}`
`65`	`65`
`66`		`- _database.Delete(category);`
	`66`	`+ await _database.DeleteAsync(category);`
`67`	`67`	`await RespondAsync($"Category '{category.Name}' removed!");`
`68`	`68`	`}`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,21 +28,21 @@ public async Task GameId(`
`28`	`28`	`[Summary("game-id", "The new id")]`
`29`	`29`	`int gameId)`
`30`	`30`	`{`
`31`		`- Category? category = GetCategory(socketCategory, Context.Guild);`
	`31`	`+ Category? category = await GetCategory(socketCategory, Context.Guild);`
`32`	`32`	`if (category is null)`
`33`	`33`	`{`
`34`	`34`	`await RespondAsync("That category is not registered!");`
`35`	`35`	`return;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`category.GameId = gameId;`
`39`		`- _database.Update(category);`
	`39`	`+ await _database.UpdateAsync(category);`
`40`	`40`
`41`	`41`	`foreach (var user in Context.Guild.Users)`
`42`	`42`	`{`
`43`	`43`	`try`
`44`	`44`	`{`
`45`		`- SteamLink? steamLink = _database.FetchOne<SteamLink>(x => x.UserId == user.Id);`
	`45`	`+ SteamLink? steamLink = await _database.FetchOneAsync<SteamLink>(x => x.UserId == user.Id);`
`46`	`46`	`if (steamLink is null \|\| !steamLink.UpdateAutomatically)`
`47`	`47`	`continue;`
`48`	`48`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ public async Task Execute()`
`49`	`49`	`return;`
`50`	`50`	`}`
`51`	`51`
`52`		`- Category? category = _database.FetchOne<Category>(category => category.CategoryId == categoryChannel.Id && category.GuildId == Context.Guild.Id);`
	`52`	`+ Category? category = await _database.FetchOneAsync<Category>(category => category.CategoryId == categoryChannel.Id && category.GuildId == Context.Guild.Id);`
`53`	`53`	`if (category is null)`
`54`	`54`	`{`
`55`	`55`	`await RespondAsync("Unable to locate the target category.");`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public RentGeneratorCommand(DatabaseService database)`
`38`	`38`	`public async Task Execute([Summary("name", "The name of the rent generator")] string name)`
`39`	`39`	`{`
`40`	`40`	`RestVoiceChannel restVoiceChannel = await Context.Guild.CreateVoiceChannelAsync(name);`
`41`		`- _database.Save(new RentGenerator(restVoiceChannel));`
	`41`	`+ await _database.SaveAsync(new RentGenerator(restVoiceChannel));`
`42`	`42`	`await RespondAsync($"Created a rent generator with the name '{name}'");`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public async Task List()`
`25`	`25`	`return;`
`26`	`26`	`}`
`27`	`27`
`28`		`- Embed? availableRoles = AvailableRoles(Context.User);`
	`28`	`+ Embed? availableRoles = await AvailableRoles(Context.User);`
`29`	`29`	`if (availableRoles == null)`
`30`	`30`	`{`
`31`	`31`	`await RespondAsync("There are no toggleable roles available in this server.");`