Add collision detection for simultaneous warning commands

Author: Erisa

Commands/DebugCmds.cs

@@ -310,6 +310,17 @@ public async Task ThrowNRE(TextCommandContext ctx, bool catchAsWarning = false)
                 }
             }
 
+            [Command("warningcache")]
+            [Description("Dump the most recent manual warning")]
+            public async Task WarningCacheCmd(TextCommandContext ctx)
+            {
+                if (WarningHelpers.mostRecentWarning is null)
+                {
+                    await ctx.RespondAsync("No cached warning found.");
+                    return;
+                }
+                await ctx.RespondAsync(await StringHelpers.CodeOrHasteBinAsync(JsonConvert.SerializeObject(WarningHelpers.mostRecentWarning, Formatting.Indented), "json"));
+            }
         }
 
         class OverridesCmd

Commands/WarningCmds.cs

@@ -24,6 +24,32 @@ public async Task WarnSlashCommand(SlashCommandContext ctx,
          [Parameter("channel"), Description("The channel to warn the user in, implied if not supplied.")] DiscordChannel channel = null
         )
         {
+            // collision detection
+            if (mostRecentWarning is not null && user.Id == mostRecentWarning.TargetUserId)
+            {
+                var timeSinceLastWarning = DateTime.UtcNow.Subtract(mostRecentWarning.WarnTimestamp);
+                if (timeSinceLastWarning <= TimeSpan.FromSeconds(5))
+                {
+                    var response = new DiscordInteractionResponseBuilder()
+                            .WithContent($"{Program.cfgjson.Emoji.Error} {user.Mention} was already warned a few seconds ago, refusing yours to prevent collisions. If your warning is unrelated, try again in a few seconds.")
+                            .AsEphemeral(true);
+                    if (!mostRecentWarning.Stub)
+                        response.AddEmbed(await FancyWarnEmbedAsync(mostRecentWarning, detailed: true));
+
+                    await ctx.RespondAsync(response);
+                    return;
+                }
+            }
+
+            // this gets updated with a full warning object later, shove a stub in for now
+            mostRecentWarning = new()
+            {
+                TargetUserId = user.Id,
+                ModUserId = ctx.User.Id,
+                WarnTimestamp = DateTime.Now,
+                Stub = true // make it clear this isn't a real warning
+            };
+
             // Initial response to avoid the 3 second timeout, will edit later.
             await ctx.DeferResponseAsync(true);
 
@@ -367,6 +393,28 @@ public async Task WarnCmd(
             [RemainingText, Description("The reason for giving this warning.")] string reason = null
         )
         {
+            // collision detection
+            if (mostRecentWarning is not null && targetUser.Id == mostRecentWarning.TargetUserId)
+            {
+                var timeSinceLastWarning = DateTime.UtcNow.Subtract(mostRecentWarning.WarnTimestamp);
+                if (timeSinceLastWarning <= TimeSpan.FromSeconds(5))
+                {
+                    await ctx.Message.DeleteAsync();
+                    var resp = await ctx.Channel.SendMessageAsync($"{Program.cfgjson.Emoji.BSOD} I was asked to warn someone twice within a few seconds, but I'm not going to. If I'm wrong, try again in a few seconds.");
+                    await Task.Delay(5000);
+                    await resp.DeleteAsync();
+                    return;
+                }
+            }
+
+            // this gets updated with a full warning object later, shove a stub in for now
+            mostRecentWarning = new(){
+                TargetUserId = targetUser.Id,
+                ModUserId = ctx.User.Id,
+                WarnTimestamp = DateTime.Now,
+                Stub = true // make it clear this isn't a real warning
+            };
+
             DiscordMember targetMember;
             try
             {

Helpers/WarningHelpers.cs

@@ -2,6 +2,8 @@
 {
     public class WarningHelpers
     {
+        public static UserWarning mostRecentWarning;
+
         public static async Task<DiscordEmbed> GenerateWarningsEmbedAsync(DiscordUser targetUser)
         {
             var warningsOutput = (await Program.db.HashGetAllAsync(targetUser.Id.ToString()))
@@ -233,9 +235,16 @@ public static async Task<UserWarning> GiveWarningAsync(DiscordUser targetUser, D
 
             Program.db.HashSet(targetUser.Id.ToString(), warning.WarningId, JsonConvert.SerializeObject(warning));
 
+            // Now that the warning is in DM, prevent future collisions by caching it.
+            if (!modUser.IsBot)
+            {
+                mostRecentWarning = warning;
             // If warning is automatic (if responsible moderator is a bot), add to list so the context message can be more-easily deleted later
-            if (modUser.IsBot)
+            }
+            else
+            {
                 Program.db.HashSet("automaticWarnings", warningId, JsonConvert.SerializeObject(warning));
+            }
 
             LogChannelHelper.LogMessageAsync("mod",
                 new DiscordMessageBuilder()

Structs.cs

@@ -28,6 +28,9 @@ public class UserWarning
 
         [JsonProperty("type")]
         public WarningType Type { get; set; }
+
+        [JsonProperty("stub")]
+        public bool Stub { get; set; } = false;
     }
 
     public class MessageReference