wip: guild member remove

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

@@ -0,0 +1,14 @@
+using Catalogger.Backend.Cache.InMemoryCache;
+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 Task<Result> RespondAsync(IGuildAuditLogEntryCreate evt, CancellationToken ct = default)
+    {
+        throw new NotImplementedException();
+    }
+}

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

@@ -0,0 +1,49 @@
+using Catalogger.Backend.Cache;
+using Catalogger.Backend.Cache.InMemoryCache;
+using Catalogger.Backend.Database;
+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;
+
+namespace Catalogger.Backend.Bot.Responders.Guilds;
+
+public class GuildMemberRemoveResponder(
+    ILogger logger,
+    DatabaseContext db,
+    IMemberCache memberCache,
+    UserCache userCache,
+    WebhookExecutorService webhookExecutor,
+    IDiscordRestGuildAPI guildApi) : IResponder<IGuildMemberRemove>
+{
+    private readonly ILogger _logger = logger.ForContext<GuildMemberAddResponder>();
+    
+    public async Task<Result> RespondAsync(IGuildMemberRemove evt, CancellationToken ct = default)
+    {
+        try
+        {
+            var embed = new EmbedBuilder()
+                .WithTitle("Member left")
+                .WithAuthor(evt.User.Tag(), iconUrl: evt.User.AvatarUrl())
+                .WithColour(DiscordUtils.Orange)
+                .WithDescription($"<@{evt.User.ID}>")
+                .WithFooter($"ID: {evt.User.ID}")
+                .WithCurrentTimestamp();
+            
+            var member = await memberCache.TryGetAsync(evt.GuildID, evt.User.ID);
+            if (member != null)
+            {
+                
+            }
+
+            return Result.Success;
+        }
+        finally
+        {
+            await memberCache.RemoveAsync(evt.GuildID, evt.User.ID);
+        }
+    }
+}

Catalogger.Backend/Cache/IMemberCache.cs

@@ -8,6 +8,7 @@ public interface IMemberCache
     public Task<IGuildMember?> TryGetAsync(Snowflake guildId, Snowflake userId);
     public Task SetAsync(Snowflake guildId, IGuildMember member);
     public Task SetManyAsync(Snowflake guildId, IReadOnlyList<IGuildMember> members);
+    public Task RemoveAsync(Snowflake guildId, Snowflake userId);
     public Task<bool> IsGuildCachedAsync(Snowflake guildId);
     public Task MarkAsCachedAsync(Snowflake guildId);
     public Task MarkAsUncachedAsync(Snowflake guildId);

Catalogger.Backend/Cache/InMemoryCache/AuditLogCache.cs

@@ -0,0 +1,21 @@
+using System.Collections.Concurrent;
+using Remora.Discord.API;
+using Remora.Rest.Core;
+
+namespace Catalogger.Backend.Cache.InMemoryCache;
+
+public class AuditLogCache
+{
+    private readonly ConcurrentDictionary<(Snowflake, Snowflake), ModactionData> _kicks = new();
+    private readonly ConcurrentDictionary<(Snowflake, Snowflake), ModactionData> _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());
+    }
+
+    public record struct ModactionData(Snowflake ModeratorId, string? Reason);
+}

Catalogger.Backend/Cache/InMemoryCache/InMemoryMemberCache.cs

@@ -19,7 +19,7 @@ public class InMemoryMemberCache : IMemberCache
     public Task SetAsync(Snowflake guildId, IGuildMember member)
     {
         if (!member.User.IsDefined())
-            throw new CataloggerError("Member with undefined User passed to RedisMemberCache.SetAsync");
+            throw new CataloggerError("Member with undefined User passed to InMemoryMemberCache.SetAsync");
         _members[(guildId, member.User.Value.ID)] = member;
         return Task.CompletedTask;
     }
@@ -30,6 +30,12 @@ public class InMemoryMemberCache : IMemberCache
             await SetAsync(guildId, member);
     }
 
+    public Task RemoveAsync(Snowflake guildId, Snowflake userId)
+    {
+        _members.Remove((guildId, userId), out _);
+        return Task.CompletedTask;
+    }
+
     public Task<bool> IsGuildCachedAsync(Snowflake guildId) => Task.FromResult(_guilds.ContainsKey(guildId));
 
     public Task MarkAsCachedAsync(Snowflake guildId)

Catalogger.Backend/Cache/RedisCache/RedisMemberCache.cs

@@ -31,6 +31,9 @@ public class RedisMemberCache(RedisService redisService) : IMemberCache
         await redisService.SetHashAsync(GuildMembersKey(guildId), redisMembers, m => m.User.Id.ToString());
     }
 
+    public async Task RemoveAsync(Snowflake guildId, Snowflake userId) =>
+        await redisService.GetDatabase().HashDeleteAsync(GuildMembersKey(guildId), userId.ToString());
+
     public async Task<bool> IsGuildCachedAsync(Snowflake guildId) =>
         await redisService.GetDatabase().SetContainsAsync(GuildCacheKey, guildId.ToString());