feat: flesh out member remove responder

Catalogger.Backend/Bot/DiscordUtils.cs

@@ -1,5 +1,6 @@
 using System.Drawing;
 using Remora.Discord.API;
+using Remora.Discord.API.Abstractions.Objects;
 using Remora.Rest.Core;
 
 namespace Catalogger.Backend.Bot;

Catalogger.Backend/Bot/Responders/Guilds/AuditLogResponder.cs

@@ -1,14 +1,20 @@
 using Catalogger.Backend.Cache.InMemoryCache;
+using Newtonsoft.Json;
 using Remora.Discord.API.Abstractions.Gateway.Events;
 using Remora.Discord.Gateway.Responders;
 using Remora.Results;
 
 namespace Catalogger.Backend.Bot.Responders.Guilds;
 
-public class AuditLogResponder(AuditLogCache auditLogCache) : IResponder<IGuildAuditLogEntryCreate>
+public class AuditLogResponder(AuditLogCache auditLogCache, ILogger logger) : IResponder<IGuildAuditLogEntryCreate>
 {
+    private readonly ILogger _logger = logger.ForContext<AuditLogResponder>();
+    
     public Task<Result> RespondAsync(IGuildAuditLogEntryCreate evt, CancellationToken ct = default)
     {
+        _logger.Debug("type: {ActionType}", evt.ActionType);
+        _logger.Debug("{Id}, {Reason}", evt.ID, evt.Reason);
+        
         throw new NotImplementedException();
     }
 }

Catalogger.Backend/Bot/Responders/Guilds/GuildMemberRemoveResponder.cs

@@ -1,10 +1,10 @@
 using Catalogger.Backend.Cache;
 using Catalogger.Backend.Cache.InMemoryCache;
 using Catalogger.Backend.Database;
+using Catalogger.Backend.Database.Queries;
 using Catalogger.Backend.Extensions;
 using Catalogger.Backend.Services;
 using Remora.Discord.API.Abstractions.Gateway.Events;
-using Remora.Discord.API.Abstractions.Rest;
 using Remora.Discord.Extensions.Embeds;
 using Remora.Discord.Gateway.Responders;
 using Remora.Results;
@@ -15,9 +15,9 @@ public class GuildMemberRemoveResponder(
     ILogger logger,
     DatabaseContext db,
     IMemberCache memberCache,
-    UserCache userCache,
+    RoleCache roleCache,
     WebhookExecutorService webhookExecutor,
-    IDiscordRestGuildAPI guildApi) : IResponder<IGuildMemberRemove>
+    AuditLogEnrichedResponderService auditLogEnrichedResponderService) : IResponder<IGuildMemberRemove>
 {
     private readonly ILogger _logger = logger.ForContext<GuildMemberAddResponder>();
 
@@ -25,6 +25,9 @@ public class GuildMemberRemoveResponder(
     {
         try
         {
+            // spin events that Discord doesn't send us all the data for off to another responder
+            _ = auditLogEnrichedResponderService.RespondAsync(evt);
+
             var embed = new EmbedBuilder()
                 .WithTitle("Member left")
                 .WithAuthor(evt.User.Tag(), iconUrl: evt.User.AvatarUrl())
@@ -33,12 +36,41 @@ public class GuildMemberRemoveResponder(
                 .WithFooter($"ID: {evt.User.ID}")
                 .WithCurrentTimestamp();
 
-            var member = await memberCache.TryGetAsync(evt.GuildID, evt.User.ID);
+            var guildConfig = await db.GetGuildAsync(evt.GuildID, ct);
-            if (member != null)
-            {
 
+            var member = await memberCache.TryGetAsync(evt.GuildID, evt.User.ID);
+            if (member == null)
+            {
+                _logger.Information(
+                    "Guild member {UserId} in {GuildId} left but wasn't in the cache, sending limited embed",
+                    evt.User.ID, evt.GuildID);
+                webhookExecutor.QueueLog(guildConfig, LogChannelType.GuildMemberRemove, embed.Build().GetOrThrow());
+                return Result.Success;
             }
 
+            embed.Description +=
+                $"\njoined <t:{member.JoinedAt.ToUnixTimeSeconds()}>\n({member.JoinedAt.Prettify()} ago)";
+
+            // get the member's roles, sort them, and turn them into mentions
+            var guildRoles = roleCache.GuildRoles(evt.GuildID);
+            var roles = guildRoles.Sorted(member.Roles).ToList();
+
+            var roleMentions = "";
+            foreach (var (idx, role) in roles.Select((r, i) => (i, r)))
+            {
+                if (roleMentions.Length > 900)
+                {
+                    roleMentions += $"\n(too many roles to list, showing {idx}/{roles.Count})";
+                    break;
+                }
+
+                roleMentions += $"<@&{role.ID}>";
+                if (idx != roles.Count - 1) roleMentions += ", ";
+            }
+
+            embed.AddField("Roles", roleMentions, inline: false);
+
+            webhookExecutor.QueueLog(guildConfig, LogChannelType.GuildMemberRemove, embed.Build().GetOrThrow());
             return Result.Success;
         }
         finally

Catalogger.Backend/Cache/InMemoryCache/AuditLogCache.cs

@@ -6,16 +6,30 @@ namespace Catalogger.Backend.Cache.InMemoryCache;
 
 public class AuditLogCache
 {
-    private readonly ConcurrentDictionary<(Snowflake, Snowflake), ModactionData> _kicks = new();
+    private readonly ConcurrentDictionary<(Snowflake GuildId, Snowflake TargetId), ActionData> _kicks = new();
-    private readonly ConcurrentDictionary<(Snowflake, Snowflake), ModactionData> _bans = new();
+    private readonly ConcurrentDictionary<(Snowflake GuildId, Snowflake TargetId), ActionData> _bans = new();
 
     public void SetKick(Snowflake guildId, string targetId, Snowflake moderatorId, Optional<string> reason)
     {
         if (!DiscordSnowflake.TryParse(targetId, out var targetUser))
             throw new CataloggerError("Target ID was not a valid snowflake");
 
-        _kicks[(guildId, targetUser.Value)] = new ModactionData(moderatorId, reason.OrDefault());
+        _kicks[(guildId, targetUser.Value)] = new ActionData(moderatorId, reason.OrDefault());
     }
 
-    public record struct ModactionData(Snowflake ModeratorId, string? Reason);
+    public bool TryGetKick(Snowflake guildId, Snowflake targetId, out ActionData data) =>
+        _kicks.TryGetValue((guildId, targetId), out data);
+
+    public void SetBan(Snowflake guildId, string targetId, Snowflake moderatorId, Optional<string> reason)
+    {
+        if (!DiscordSnowflake.TryParse(targetId, out var targetUser))
+            throw new CataloggerError("Target ID was not a valid snowflake");
+
+        _bans[(guildId, targetUser.Value)] = new ActionData(moderatorId, reason.OrDefault());
+    }
+    
+    public bool TryGetBan(Snowflake guildId, Snowflake targetId, out ActionData data) =>
+        _bans.TryGetValue((guildId, targetId), out data);
+
+    public record struct ActionData(Snowflake ModeratorId, string? Reason);
 }

Catalogger.Backend/Catalogger.Backend.csproj

@@ -27,6 +27,7 @@
         <PackageReference Include="prometheus-net" Version="8.2.1" />
         <PackageReference Include="prometheus-net.AspNetCore" Version="8.2.1" />
         <PackageReference Include="Remora.Discord" Version="2024.2.0"/>
+<!--        <ProjectReference Include="../../Remora.Discord/Remora.Discord/Remora.Discord.csproj" />-->
         <PackageReference Include="Serilog" Version="4.0.1"/>
         <PackageReference Include="Serilog.AspNetCore" Version="8.0.1"/>
         <PackageReference Include="Serilog.Extensions.Hosting" Version="8.0.0"/>

Catalogger.Backend/Extensions/DiscordExtensions.cs

@@ -82,5 +82,19 @@ public static class DiscordExtensions
         return (userId, guildId);
     }
     
+    /// <summary>
+    /// Sorts a list of roles by their position in the Discord interface.
+    /// </summary>
+    /// <param name="roles">The list of guild roles to filter.</param>
+    /// <param name="filterByIds">An optional list of role IDs to return, from a member object or similar.
+    /// If null, the entire list is returned.</param>
+    /// <returns></returns>
+    public static IEnumerable<IRole> Sorted(this IEnumerable<IRole> roles,
+        IEnumerable<Snowflake>? filterByIds = null)
+    {
+        var sorted = roles.OrderByDescending(r => r.Position);
+        return filterByIds != null ? sorted.Where(r => filterByIds.Contains(r.ID)) : sorted;
+    }
+
     public class DiscordRestException(string message) : Exception(message);
 }

Catalogger.Backend/Extensions/StartupExtensions.cs

@@ -73,9 +73,11 @@ public static class StartupExtensions
         .AddSingleton<RoleCache>()
         .AddSingleton<ChannelCache>()
         .AddSingleton<UserCache>()
+        .AddSingleton<AuditLogCache>()
         .AddSingleton<PluralkitApiService>()
         .AddScoped<IEncryptionService, EncryptionService>()
         .AddSingleton<MetricsCollectionService>()
+        .AddSingleton<AuditLogEnrichedResponderService>()
         .AddScoped<MessageRepository>()
         .AddSingleton<WebhookExecutorService>()
         .AddSingleton<PkMessageHandler>()

Catalogger.Backend/Services/AuditLogEnrichedResponderService.cs

@@ -0,0 +1,37 @@
+using Catalogger.Backend.Cache.InMemoryCache;
+using Remora.Discord.API.Abstractions.Gateway.Events;
+using Remora.Results;
+
+namespace Catalogger.Backend.Services;
+
+public class AuditLogEnrichedResponderService(AuditLogCache auditLogCache, ILogger logger)
+{
+    private readonly ILogger _logger = logger.ForContext<AuditLogEnrichedResponderService>();
+
+    public async Task<Result> RespondAsync(IGuildMemberRemove evt)
+    {
+        // give a second or so for the audit log to catch up
+        await Task.Delay(1000);
+
+        if (auditLogCache.TryGetKick(evt.GuildID, evt.User.ID, out var kickData))
+            return await HandleKickAsync(evt, kickData);
+
+        if (auditLogCache.TryGetBan(evt.GuildID, evt.User.ID, out var banData))
+            return await HandleBanAsync(evt, banData);
+
+        _logger.Debug("Guild member remove event for guild {GuildId}/user {UserId} didn't match an audit log entry",
+            evt.GuildID, evt.User.ID);
+
+        return Result.Success;
+    }
+
+    private async Task<Result> HandleKickAsync(IGuildMemberRemove evt, AuditLogCache.ActionData kickData)
+    {
+        return Result.Success;
+    }
+
+    private async Task<Result> HandleBanAsync(IGuildMemberRemove evt, AuditLogCache.ActionData banData)
+    {
+        return Result.Success;
+    }
+}