Add Discovery Commands and Dependencies

src/CB.Accessors/Contracts/IAllowConfigurationAccessor.cs

@@ -7,12 +7,11 @@
 {
     Task<List<AllowConfigurationDto>> GetAllAsync();
 
     Task<AllowConfigurationDto?> GetByIdAsync(string id);
 
     Task<AllowConfigurationDto> CreateAsync(AllowConfiguration entity);
 
-    Task<AllowConfigurationDto?> UpdateAsync(string id, 
-        AllowConfigurationDto entity);
+    Task<AllowConfigurationDto?> UpdateAsync(AllowConfigurationDto entity);
 
     Task<bool> DeleteAsync(string id);
 }

src/CB.Accessors/Contracts/IRoleConfigurationAccessor.cs

@@ -0,0 +1,17 @@
+using CB.Data.Entities;
+using CB.Shared.Dtos;
+
+namespace CB.Accessors.Contracts;
+
+public interface IRoleConfigurationAccessor
+{
+    Task<List<RoleConfigurationDto>> GetAllAsync();
+
+    Task<RoleConfigurationDto?> GetByIdAsync(string id);
+
+    Task<RoleConfigurationDto> CreateAsync(RoleConfiguration entity);
+
+    Task<RoleConfigurationDto?> UpdateAsync(RoleConfigurationDto entity);
+
+    Task<bool> DeleteAsync(string id);
+}

src/CB.Accessors/Implementations/AllowConfigurationAccessor.cs

@@ -34,12 +34,11 @@ await context
         return mapper.Map<AllowConfigurationDto>(entity);
     }
 
-    public async Task<AllowConfigurationDto?> UpdateAsync(string id, 
-        AllowConfigurationDto updated)
+    public async Task<AllowConfigurationDto?> UpdateAsync(AllowConfigurationDto updated)
     {
         var allowConfiguration = await context
             .AllowConfigurations
-            .FindAsync(id)
+            .FirstOrDefaultAsync( x => x.GuildId == updated.GuildId)
             .ConfigureAwait(false);
 
         if (allowConfiguration == null)

src/CB.Accessors/Implementations/RoleConfigurationAccessor.cs

@@ -0,0 +1,79 @@
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using CB.Accessors.Contracts;
+using CB.Data;
+using CB.Data.Entities;
+using CB.Shared.Dtos;
+using Microsoft.EntityFrameworkCore;
+
+namespace CB.Accessors.Implementations;
+
+public class RoleConfigurationAccessor(CbContext context, 
+    IMapper mapper) 
+    : IRoleConfigurationAccessor
+{
+    public Task<List<RoleConfigurationDto>> GetAllAsync() =>  context
+            .RoleConfigurations
+            .AsNoTracking()
+            .ProjectTo<RoleConfigurationDto>(mapper.ConfigurationProvider)
+            .ToListAsync();
+
+    public Task<RoleConfigurationDto?> GetByIdAsync(string id) => context.RoleConfigurations
+            .AsNoTracking()
+            .Where(g => g.GuildId == id)
+            .ProjectTo<RoleConfigurationDto>(mapper.ConfigurationProvider)
+            .FirstOrDefaultAsync();
+
+    public async Task<RoleConfigurationDto> CreateAsync(RoleConfiguration entity)
+    {
+        context.RoleConfigurations.Add(entity);
+        await context
+            .SaveChangesAsync()
+            .ConfigureAwait(false);
+
+        return mapper.Map<RoleConfigurationDto>(entity);
+    }
+
+    public async Task<RoleConfigurationDto?> UpdateAsync(RoleConfigurationDto updated)
+    {
+        var roleConfiguration = await context
+            .RoleConfigurations
+            .FirstOrDefaultAsync(x => x.GuildId == updated.GuildId)
+            .ConfigureAwait(false);
+
+        if (roleConfiguration == null)
+        {
+            return null;
+        }
+
+        roleConfiguration.DiscoveryRoleId = updated.DiscoveryRoleId;
+        roleConfiguration.JoinRoleId = updated.JoinRoleId;
+        roleConfiguration.LiveDiscoveryRoleId = updated.LiveDiscoveryRoleId;
+
+        await context
+            .SaveChangesAsync()
+            .ConfigureAwait(false);
+
+        return mapper.Map<RoleConfigurationDto>(roleConfiguration);
+    }
+
+    public async Task<bool> DeleteAsync(string id)
+    {
+        var roleConfiguration = await context
+            .RoleConfigurations
+            .FindAsync(id)
+            .ConfigureAwait(false);
+
+        if (roleConfiguration == null)
+        {
+            return false;
+        }
+
+        context.RoleConfigurations.Remove(roleConfiguration);
+        await context
+            .SaveChangesAsync()
+            .ConfigureAwait(false);
+
+        return true;
+    }
+}

src/CB.Bot/Commands/Application/DiscoverySlashCommands.cs

@@ -0,0 +1,84 @@
+using CB.Accessors.Contracts;
+using Discord;
+using Discord.Interactions;
+
+// ReSharper disable UnusedMember.Local
+// ReSharper disable UnusedMember.Global
+
+namespace CB.Bot.Commands.Application;
+
+[Group("discovery", "Discovery commands")]
+public class DiscoverySlashCommands(IGuildAccessor guildAccessor,
+    IRoleConfigurationAccessor roleConfigurationAccessor,
+    IAllowConfigurationAccessor allowConfigurationAccessor) : BaseSlashCommands
+{
+[SlashCommand(
+        "enable",
+        "Configure server 'Discovery' setting",
+        false,
+        RunMode.Async)]
+    private async Task DiscoveryEnableConfigurationAsync(IRole role = null)
+    {
+        await DoStuff(true, role);
+    }
+
+    [SlashCommand(
+        "disable",
+        "Configure server 'Discovery' setting",
+        false,
+        RunMode.Async)]
+    private async Task DiscoveryDisableConfigurationAsync()
+    {
+        await DoStuff(false);
+    }
+
+    private async Task DoStuff(bool isEnabled,
+        IRole role = null)
+    {
+        await SocketInteraction.DeferAsync(true);
+
+        if (!await IsUserAdmin())
+        {
+            return;
+        }
+
+        var guildChannel = (IGuildChannel)SocketInteraction.Channel;
+        var guild = await guildAccessor.GetByIdAsync(guildChannel.Guild.Id.ToString());
+        if (guild == null)
+        {
+            await SocketInteraction.FollowupAsync(
+                "Sorry, unable to configure Discovery for this guild. Contact support.", ephemeral: true);
+            return;
+        }
+
+        string message;
+        if (!isEnabled)
+        {
+            guild.RoleConfiguration.DiscoveryRoleId = null;
+            guild.AllowConfiguration.AllowLiveDiscovery = false;
+            message = "Discovery has been set to `Disabled`.";
+        }
+        else
+        {
+            if (role != null)
+            {
+                guild.RoleConfiguration.DiscoveryRoleId = role.Id.ToString();
+                guild.AllowConfiguration.AllowLiveDiscovery = true;
+
+                message = $"Discovery has been set to role {role.Name}.";
+            }
+            else
+            {
+                guild.RoleConfiguration.DiscoveryRoleId = null;
+                guild.AllowConfiguration.AllowLiveDiscovery = true;
+
+                message = "Discovery has been set to .. literally everyone!";
+            }
+        }
+
+        await roleConfigurationAccessor.UpdateAsync(guild.RoleConfiguration);
+        await allowConfigurationAccessor.UpdateAsync(guild.AllowConfiguration);
+
+        await SocketInteraction.FollowupAsync(message, ephemeral: true);
+    }
+}

src/CB.Bot/Services/MessageInteractionService.cs

@@ -183,7 +183,7 @@ private async Task ProcessAllowDropdownAsync(ISocketMessageChannel channel,
             }
         }
 
-        await _allowConfigurationAccessor.UpdateAsync(guild.Id, guild.AllowConfiguration);
+        await _allowConfigurationAccessor.UpdateAsync(guild.AllowConfiguration);
         await _guildConfigurationAccessor.UpdateAsync(guild.Id, guild.GuildConfiguration);
 
         await message.FollowupAsync(response.ToString(), ephemeral: true);

src/CB.Data/CbContext.cs

@@ -16,6 +16,7 @@ public class CbContext(DbContextOptions<CbContext> options) : DbContext(options)
     public DbSet<Guild> Guilds => Set<Guild>();
     public DbSet<GuildConfiguration> GuildConfigurations => Set<GuildConfiguration>();
     public DbSet<LiveEmbed> LiveEmbeds => Set<LiveEmbed>();
+    public DbSet<RoleConfiguration> RoleConfigurations => Set<RoleConfiguration>();
     public DbSet<User> Users => Set<User>();
     public DbSet<VodEmbed> VodEmbeds => Set<VodEmbed>();