Implement pardoned warnings (#302)

* Implement pardoning warnings

Adds `isPardoned` attribute to warnings; adds /pardon and /unpardon; pardoned warnings are listed separately in !warnings output

* Exclude pardoned warnings from totals in !warnings

* Implement automatic pardoning on ban for compromised account

Automatically pardons warnings issued within last 12 hours when ban is for a compromised account

* Fix error from copy-pasting

* Fix warnings embed truncation

Make truncation dynamic based on what will fit in the embed

* Accept review suggestion

Co-authored-by: Erisa A <[email protected]>

* Use 0 as default value for compromisedAccountBanAutoPardonHours

* Show warning pardon status in warning autocomplete

* Always show pardoned field in warning embeds, add option to show inline

* Add warning autocomplete providers for pardoned & unpardoned warnings

Shifted logic for getting warnings to suggest into a single function that all 3 warning autocomplete providers use

---------

Co-authored-by: Erisa A <[email protected]>

Author: FloatingMilkshake

Commands/BanCmds.cs

@@ -468,7 +468,26 @@ public async Task EditBanCmd(TextCommandContext ctx,
             else
                 ban.ExpireTime = ban.ActionTime + banDuration;
             ban.Reason = reason;
-
+            
+            // If ban is for a compromised account, add to list so the context message can be more-easily deleted later
+            // and pardon any automatic warnings issued within the last 12 hours
+            if (ban.Reason.ToLower().Contains("compromised"))
+            {
+                Program.redis.HashSet("compromisedAccountBans", targetUser.Id, JsonConvert.SerializeObject(ban));
+                
+                var warnings = (await Program.redis.HashGetAllAsync(targetUser.Id.ToString())).Select(x => JsonConvert.DeserializeObject<UserWarning>(x.Value)).ToList();
+                foreach (var warning in warnings)
+                {
+                    if (warning.Type == WarningType.Warning
+                        && (warning.ModUserId == Program.discord.CurrentUser.Id || (await Program.discord.GetUserAsync(warning.ModUserId)).IsBot)
+                        && (DateTime.Now - warning.WarnTimestamp).TotalHours < Program.cfgjson.CompromisedAccountBanAutoPardonHours)
+                    {
+                        warning.IsPardoned = true;
+                        await Program.redis.HashSetAsync(warning.TargetUserId.ToString(), warning.WarningId, JsonConvert.SerializeObject(warning));
+                    }
+                }
+            }
+            
             var guild = await Program.discord.GetGuildAsync(ban.ServerId);
 
             var contextMessage = await DiscordHelpers.GetMessageFromReferenceAsync(ban.ContextMessageReference);

Commands/WarningCmds.cs

@@ -181,38 +181,70 @@ internal partial class WarningsAutocompleteProvider : IAutoCompleteProvider
         {
             public async ValueTask<IEnumerable<DiscordAutoCompleteChoice>> AutoCompleteAsync(AutoCompleteContext ctx)
             {
-                var list = new List<DiscordAutoCompleteChoice>();
-
-                var useroption = ctx.Options.FirstOrDefault(x => x.Name == "user");
-                if (useroption == default)
-                {
-                    return list;
-                }
+                return await GetWarningsForAutocompleteAsync(ctx);
+            }
+        }
+        
+        internal partial class PardonedWarningsAutocompleteProvider : IAutoCompleteProvider
+        {
+            public async ValueTask<IEnumerable<DiscordAutoCompleteChoice>> AutoCompleteAsync(AutoCompleteContext ctx)
+            {
+                return await GetWarningsForAutocompleteAsync(ctx, pardonedOnly: true);
+            }
+        }
+        
+        internal partial class UnpardonedWarningsAutocompleteProvider : IAutoCompleteProvider
+        {
+            public async ValueTask<IEnumerable<DiscordAutoCompleteChoice>> AutoCompleteAsync(AutoCompleteContext ctx)
+            {
+                return await GetWarningsForAutocompleteAsync(ctx, excludePardoned: true);
+            }
+        }
+        
+        private static async Task<List<DiscordAutoCompleteChoice>> GetWarningsForAutocompleteAsync(AutoCompleteContext ctx, bool excludePardoned = false, bool pardonedOnly = false)
+        {
+            if (excludePardoned && pardonedOnly)
+                throw new ArgumentException("Cannot simultaneously exclude pardoned warnings from autocomplete suggestions and only show pardoned warnings.");
+            
+            var list = new List<DiscordAutoCompleteChoice>();
 
-                var user = await ctx.Client.GetUserAsync((ulong)useroption.Value);
+            var useroption = ctx.Options.FirstOrDefault(x => x.Name == "user");
+            if (useroption == default)
+            {
+                return list;
+            }
 
-                var warnings = (await Program.redis.HashGetAllAsync(user.Id.ToString()))
-                    .Where(x => JsonConvert.DeserializeObject<UserWarning>(x.Value).Type == WarningType.Warning).ToDictionary(
-                   x => x.Name.ToString(),
-                  x => JsonConvert.DeserializeObject<UserWarning>(x.Value)
-                 ).OrderByDescending(x => x.Value.WarningId);
+            var user = await ctx.Client.GetUserAsync((ulong)useroption.Value);
 
-                foreach (var warning in warnings)
-                {
-                    if (list.Count >= 25)
-                        break;
+            var warnings = (await Program.redis.HashGetAllAsync(user.Id.ToString()))
+                .Where(x => JsonConvert.DeserializeObject<UserWarning>(x.Value).Type == WarningType.Warning).ToDictionary(
+                    x => x.Name.ToString(),
+                    x => JsonConvert.DeserializeObject<UserWarning>(x.Value)
+                ).OrderByDescending(x => x.Value.WarningId);
 
-                    string warningString = $"{StringHelpers.Pad(warning.Value.WarningId)} - {StringHelpers.Truncate(warning.Value.WarnReason, 29, true)} - {TimeHelpers.TimeToPrettyFormat(DateTime.UtcNow - warning.Value.WarnTimestamp, true)}";
+            foreach (var warning in warnings)
+            {
+                if (list.Count >= 25)
+                    break;
 
-                    var focusedOption = ctx.Options.FirstOrDefault(option => option.Focused);
-                    if (focusedOption is not null)
-                        if (warning.Value.WarnReason.Contains((string)focusedOption.Value) || warningString.ToLower().Contains(focusedOption.Value.ToString().ToLower()))
-                            list.Add(new DiscordAutoCompleteChoice(warningString, StringHelpers.Pad(warning.Value.WarningId)));
+                string warningString = $"{StringHelpers.Pad(warning.Value.WarningId)} - {StringHelpers.Truncate(warning.Value.WarnReason, 29, true)} - {TimeHelpers.TimeToPrettyFormat(DateTime.UtcNow - warning.Value.WarnTimestamp, true)}";
+                if (warning.Value.IsPardoned)
+                {
+                    if (excludePardoned)
+                        continue;
+                    
+                    warningString += " (pardoned)";
                 }
+                else if (pardonedOnly)
+                    continue;
 
-                return list;
-                //return Task.FromResult((IEnumerable<DiscordAutoCompleteChoice>)list);
+                var focusedOption = ctx.Options.FirstOrDefault(option => option.Focused);
+                if (focusedOption is not null)
+                    if (warning.Value.WarnReason.Contains((string)focusedOption.Value) || warningString.ToLower().Contains(focusedOption.Value.ToString().ToLower()))
+                        list.Add(new DiscordAutoCompleteChoice(warningString, StringHelpers.Pad(warning.Value.WarningId)));
             }
+
+            return list;
         }
 
         [Command("warndetails")]
@@ -379,6 +411,130 @@ await ctx.FollowupAsync(new DiscordFollowupMessageBuilder().WithContent($"{Progr
                     .AddEmbed(await FancyWarnEmbedAsync(GetWarning(user.Id, warnId), userID: user.Id)));
             }
         }
+        
+        [Command("pardon")]
+        [Description("Pardon a warning.")]
+        [AllowedProcessors(typeof(SlashCommandProcessor))]
+        [RequireHomeserverPerm(ServerPermLevel.TrialModerator), RequirePermissions(DiscordPermission.ModerateMembers)]
+        public async Task PardonSlashCommand(SlashCommandContext ctx,
+            [Parameter("user"), Description("The user to pardon a warning for.")] DiscordUser user,
+            [SlashAutoCompleteProvider(typeof(UnpardonedWarningsAutocompleteProvider))][Parameter("warning"), Description("Type to search! Find the warning you want to pardon.")] string warning,
+            [Parameter("public"), Description("Whether to show the output publicly. Default: false")] bool showPublic = false)
+        {
+            if (warning.Contains(' '))
+            {
+                warning = warning.Split(' ')[0];
+            }
+
+            long warnId;
+            try
+            {
+                warnId = Convert.ToInt64(warning);
+            }
+            catch
+            {
+                await ctx.RespondAsync($"{Program.cfgjson.Emoji.Error} Looks like your warning option was invalid! Give it another go?", ephemeral: true);
+                return;
+            }
+
+            var warningObject = GetWarning(user.Id, warnId);
+
+            if (warningObject is null)
+                await ctx.RespondAsync($"{Program.cfgjson.Emoji.Error} I couldn't find a warning for that user with that ID! Please check again.", ephemeral: true);
+            else if (warningObject.Type == WarningType.Note)
+            {
+                await ctx.RespondAsync($"{Program.cfgjson.Emoji.Error} That's a note, not a warning! Make sure you've got the right warning ID.", ephemeral: true);
+            }
+            else if ((await GetPermLevelAsync(ctx.Member)) == ServerPermLevel.TrialModerator && warningObject.ModUserId != ctx.User.Id && warningObject.ModUserId != ctx.Client.CurrentUser.Id)
+            {
+                await ctx.RespondAsync($"{Program.cfgjson.Emoji.Error} {ctx.User.Mention}, as a Trial Moderator you cannot edit or delete warnings that aren't issued by you or the bot!", ephemeral: true);
+            }
+            else
+            {
+                await ctx.DeferResponseAsync(ephemeral: !showPublic);
+                
+                if (warningObject.IsPardoned)
+                {
+                    await ctx.FollowupAsync($"{Program.cfgjson.Emoji.Error} That warning has already been pardoned!");
+                    return;
+                }
+
+                warningObject.IsPardoned = true;
+                await Program.redis.HashSetAsync(warningObject.TargetUserId.ToString(), warningObject.WarningId.ToString(), JsonConvert.SerializeObject(warningObject));
+
+                await LogChannelHelper.LogMessageAsync("mod",
+                    new DiscordMessageBuilder()
+                        .WithContent($"{Program.cfgjson.Emoji.Information} Warning pardoned:" +
+                        $"`{StringHelpers.Pad(warnId)}` (belonging to {user.Mention})")
+                        .AddEmbed(await FancyWarnEmbedAsync(GetWarning(user.Id, warnId), true, userID: user.Id))
+                );
+
+                await ctx.FollowupAsync(new DiscordFollowupMessageBuilder().WithContent($"{Program.cfgjson.Emoji.Information} Successfully pardoned warning `{StringHelpers.Pad(warnId)}` (belonging to {user.Mention})")
+                    .AddEmbed(await FancyWarnEmbedAsync(GetWarning(user.Id, warnId), userID: user.Id, showPardonedInline: true)));
+            }
+        }
+        
+        [Command("unpardon")]
+        [Description("Unpardon a warning.")]
+        [AllowedProcessors(typeof(SlashCommandProcessor))]
+        [RequireHomeserverPerm(ServerPermLevel.TrialModerator), RequirePermissions(DiscordPermission.ModerateMembers)]
+        public async Task UnpardonSlashCommand(SlashCommandContext ctx,
+            [Parameter("user"), Description("The user to unpardon a warning for.")] DiscordUser user,
+            [SlashAutoCompleteProvider(typeof(PardonedWarningsAutocompleteProvider))][Parameter("warning"), Description("Type to search! Find the warning you want to unpardon.")] string warning,
+            [Parameter("public"), Description("Whether to show the output publicly. Default: false")] bool showPublic = false)
+        {
+            if (warning.Contains(' '))
+            {
+                warning = warning.Split(' ')[0];
+            }
+
+            long warnId;
+            try
+            {
+                warnId = Convert.ToInt64(warning);
+            }
+            catch
+            {
+                await ctx.RespondAsync($"{Program.cfgjson.Emoji.Error} Looks like your warning option was invalid! Give it another go?", ephemeral: true);
+                return;
+            }
+
+            var warningObject = GetWarning(user.Id, warnId);
+
+            if (warningObject is null)
+                await ctx.RespondAsync($"{Program.cfgjson.Emoji.Error} I couldn't find a warning for that user with that ID! Please check again.", ephemeral: true);
+            else if (warningObject.Type == WarningType.Note)
+            {
+                await ctx.RespondAsync($"{Program.cfgjson.Emoji.Error} That's a note, not a warning! Make sure you've got the right warning ID.", ephemeral: true);
+            }
+            else if ((await GetPermLevelAsync(ctx.Member)) == ServerPermLevel.TrialModerator && warningObject.ModUserId != ctx.User.Id && warningObject.ModUserId != ctx.Client.CurrentUser.Id)
+            {
+                await ctx.RespondAsync($"{Program.cfgjson.Emoji.Error} {ctx.User.Mention}, as a Trial Moderator you cannot edit or delete warnings that aren't issued by you or the bot!", ephemeral: true);
+            }
+            else
+            {
+                await ctx.DeferResponseAsync(ephemeral: !showPublic);
+                
+                if (!warningObject.IsPardoned)
+                {
+                    await ctx.FollowupAsync($"{Program.cfgjson.Emoji.Error} That warning isn't pardoned!");
+                    return;
+                }
+
+                warningObject.IsPardoned = false;
+                await Program.redis.HashSetAsync(warningObject.TargetUserId.ToString(), warningObject.WarningId.ToString(), JsonConvert.SerializeObject(warningObject));
+
+                await LogChannelHelper.LogMessageAsync("mod",
+                    new DiscordMessageBuilder()
+                        .WithContent($"{Program.cfgjson.Emoji.Information} Warning unpardoned:" +
+                        $"`{StringHelpers.Pad(warnId)}` (belonging to {user.Mention})")
+                        .AddEmbed(await FancyWarnEmbedAsync(GetWarning(user.Id, warnId), true, userID: user.Id))
+                );
+
+                await ctx.FollowupAsync(new DiscordFollowupMessageBuilder().WithContent($"{Program.cfgjson.Emoji.Information} Successfully unpardoned warning `{StringHelpers.Pad(warnId)}` (belonging to {user.Mention})")
+                    .AddEmbed(await FancyWarnEmbedAsync(GetWarning(user.Id, warnId), userID: user.Id, showPardonedInline: true)));
+            }
+        }
 
         [
             Command("warntextcmd"),

Helpers/BanHelpers.cs

@@ -94,8 +94,24 @@ public static async Task<bool> BanFromServerAsync(ulong targetUserId, string rea
             MostRecentBan = newBan;
 
             // If ban is for a compromised account, add to list so the context message can be more-easily deleted later
+            // and pardon any automatic warnings issued within the last 12 hours
             if (compromisedAccount)
+            {
                 Program.redis.HashSet("compromisedAccountBans", targetUserId, JsonConvert.SerializeObject(newBan));
+                
+                var warnings = (await Program.redis.HashGetAllAsync(targetUserId.ToString())).Select(x => JsonConvert.DeserializeObject<UserWarning>(x.Value)).ToList();
+                foreach (var warning in warnings)
+                {
+                    if (warning.Type == WarningType.Warning
+                        && (warning.ModUserId == Program.discord.CurrentUser.Id || (await Program.discord.GetUserAsync(warning.ModUserId)).IsBot)
+                        && (DateTime.Now - warning.WarnTimestamp).TotalHours < Program.cfgjson.CompromisedAccountBanAutoPardonHours
+                        && !warning.IsPardoned)
+                    {
+                        warning.IsPardoned = true;
+                        await Program.redis.HashSetAsync(warning.TargetUserId.ToString(), warning.WarningId, JsonConvert.SerializeObject(warning));
+                    }
+                }
+            }
 
             try
             {

Helpers/MuteHelpers.cs

@@ -81,7 +81,7 @@ public static (int MuteHours, int WarnsSinceThreshold) GetHoursToMuteFor(Diction
             {
                 UserWarning entryWarning = entry.Value;
                 TimeSpan span = DateTime.UtcNow - entryWarning.WarnTimestamp;
-                if (span <= timeToCheck)
+                if (span <= timeToCheck && !entryWarning.IsPardoned)
                     warnsSinceThreshold += 1;
             }