feat: add GuildPurgeService (per-guild data purge)

Author: HandyS11

src/RustPlusBot.Features.Workspace/Teardown/GuildPurgeService.cs

@@ -0,0 +1,38 @@
+using Microsoft.EntityFrameworkCore;
+using RustPlusBot.Persistence;
+using RustPlusBot.Persistence.Servers;
+
+namespace RustPlusBot.Features.Workspace.Teardown;
+
+/// <summary>Purges a guild: tears down provisioned channels, then deletes its domain rows.</summary>
+/// <param name="context">The bot database context.</param>
+/// <param name="servers">Server management (RemoveAsync cascades all per-server rows).</param>
+/// <param name="teardown">Removes provisioned Discord channels/categories/messages.</param>
+internal sealed class GuildPurgeService(
+    BotDbContext context,
+    IServerService servers,
+    IWorkspaceTeardownService teardown) : IGuildPurgeService
+{
+    /// <inheritdoc />
+    public async Task PurgeGuildAsync(ulong guildId, CancellationToken cancellationToken = default)
+    {
+        // 1) Delete provisioned Discord channels/categories/messages (Discord side + records).
+        await teardown.ResetGuildAsync(guildId, cancellationToken).ConfigureAwait(false);
+
+        // 2) Remove each server; the RustServer FK cascade clears its per-server rows
+        //    (connection state, command/map settings, switches, alarms, storage monitors, credentials).
+        var known = await servers.ListAsync(guildId, cancellationToken).ConfigureAwait(false);
+        foreach (var server in known)
+        {
+            await servers.RemoveAsync(guildId, server.Id, cancellationToken).ConfigureAwait(false);
+        }
+
+        // 3) Delete guild-keyed rows that have no cascade FK to RustServer.
+        await context.EventSubscriptions.Where(e => e.GuildId == guildId)
+            .ExecuteDeleteAsync(cancellationToken).ConfigureAwait(false);
+        await context.PairedEntities.Where(p => p.GuildId == guildId)
+            .ExecuteDeleteAsync(cancellationToken).ConfigureAwait(false);
+        await context.GuildSettings.Where(g => g.GuildId == guildId)
+            .ExecuteDeleteAsync(cancellationToken).ConfigureAwait(false);
+    }
+}

src/RustPlusBot.Features.Workspace/Teardown/IGuildPurgeService.cs

@@ -0,0 +1,11 @@
+namespace RustPlusBot.Features.Workspace.Teardown;
+
+/// <summary>Deletes all of a guild's data: provisioned channels plus its domain rows.</summary>
+internal interface IGuildPurgeService
+{
+    /// <summary>Purges one guild back to a just-joined state (channels + servers + guild-scoped rows).</summary>
+    /// <param name="guildId">The guild to purge.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when the guild's data has been removed.</returns>
+    Task PurgeGuildAsync(ulong guildId, CancellationToken cancellationToken = default);
+}

src/RustPlusBot.Features.Workspace/WorkspaceServiceCollectionExtensions.cs

@@ -51,6 +51,7 @@ public static IServiceCollection AddWorkspace(this IServiceCollection services)
         services.AddScoped<WorkspaceTeardownService>();
         services.AddScoped<IWorkspaceTeardownService>(sp => sp.GetRequiredService<WorkspaceTeardownService>());
         services.AddScoped<IServerWorkspaceRemover>(sp => sp.GetRequiredService<WorkspaceTeardownService>());
+        services.AddScoped<IGuildPurgeService, GuildPurgeService>();
 
         // Options (Host binds the "Workspace" section; default = danger commands off).
         services.AddOptions<WorkspaceOptions>();

tests/RustPlusBot.Features.Workspace.Tests/Teardown/GuildPurgeServiceTests.cs

@@ -0,0 +1,91 @@
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using NSubstitute;
+using RustPlusBot.Domain.Connections;
+using RustPlusBot.Domain.Entities;
+using RustPlusBot.Domain.Events;
+using RustPlusBot.Domain.Guilds;
+using RustPlusBot.Domain.Servers;
+using RustPlusBot.Domain.Switches;
+using RustPlusBot.Features.Workspace.Teardown;
+using RustPlusBot.Persistence;
+using RustPlusBot.Persistence.Servers;
+
+namespace RustPlusBot.Features.Workspace.Tests.Teardown;
+
+public sealed class GuildPurgeServiceTests
+{
+    private static BotDbContext NewContext(SqliteConnection connection)
+    {
+        var options = new DbContextOptionsBuilder<BotDbContext>().UseSqlite(connection).Options;
+        var context = new BotDbContext(options);
+        context.Database.Migrate();
+        return context;
+    }
+
+    [Fact]
+    public async Task PurgeGuild_RemovesTargetGuildRows_AndLeavesOtherGuildIntact()
+    {
+        var connection = new SqliteConnection("DataSource=:memory:");
+        await connection.OpenAsync();
+        await using var _ = connection;
+        await using var context = NewContext(connection);
+
+        var serverA = new RustServer
+        {
+            GuildId = 1, Name = "A", Ip = "a", Port = 1
+        };
+        var serverB = new RustServer
+        {
+            GuildId = 2, Name = "B", Ip = "b", Port = 2
+        };
+        context.RustServers.AddRange(serverA, serverB);
+        context.SmartSwitches.Add(new SmartSwitch
+        {
+            GuildId = 1, ServerId = serverA.Id, EntityId = 10, Name = "sw"
+        });
+        context.ConnectionStates.Add(new ConnectionState
+        {
+            RustServerId = serverA.Id, GuildId = 1, Status = ConnectionStatus.Connected
+        });
+        context.EventSubscriptions.Add(new EventSubscription
+        {
+            GuildId = 1, RustServerId = serverA.Id, EventKey = "cargo"
+        });
+        context.EventSubscriptions.Add(new EventSubscription
+        {
+            GuildId = 2, RustServerId = serverB.Id, EventKey = "cargo"
+        });
+        context.PairedEntities.Add(new PairedEntity
+        {
+            GuildId = 1, RustServerId = serverA.Id, EntityId = 5, Name = "dev"
+        });
+        context.GuildSettings.Add(new GuildSettings
+        {
+            GuildId = 1, Culture = "en"
+        });
+        context.GuildSettings.Add(new GuildSettings
+        {
+            GuildId = 2, Culture = "fr"
+        });
+        await context.SaveChangesAsync();
+
+        var teardown = Substitute.For<IWorkspaceTeardownService>();
+        var service = new GuildPurgeService(context, new ServerService(context), teardown);
+
+        await service.PurgeGuildAsync(1);
+
+        await teardown.Received(1).ResetGuildAsync(1, Arg.Any<CancellationToken>());
+        Assert.Empty(await context.RustServers.Where(s => s.GuildId == 1).ToListAsync());
+        Assert.Empty(await context.SmartSwitches.ToListAsync());
+        Assert.Empty(await context.ConnectionStates.ToListAsync());
+        Assert.Empty(await context.EventSubscriptions.Where(e => e.GuildId == 1).ToListAsync());
+        Assert.Empty(await context.PairedEntities.Where(p => p.GuildId == 1).ToListAsync());
+        Assert.Empty(await context.GuildSettings.Where(g => g.GuildId == 1).ToListAsync());
+
+        // Guild 2 untouched.
+        Assert.Single(await context.RustServers.Where(s => s.GuildId == 2).ToListAsync());
+        Assert.Single(await context.EventSubscriptions.Where(e => e.GuildId == 2).ToListAsync());
+        Assert.Single(await context.GuildSettings.Where(g => g.GuildId == 2).ToListAsync());
+    }
+}