Features/add command to reset activity for a help thread

application/src/main/java/org/togetherjava/tjbot/commands/help/HelpThreadActivityUpdater.java

@@ -1,8 +1,11 @@
 package org.togetherjava.tjbot.commands.help;
 
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
 import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.MessageHistory;
 import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.entities.channel.concrete.ForumChannel;
 import net.dv8tion.jda.api.entities.channel.concrete.ThreadChannel;
@@ -13,6 +16,7 @@
 
 import org.togetherjava.tjbot.commands.Routine;
 
+import java.time.temporal.ChronoUnit;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -30,8 +34,14 @@ public final class HelpThreadActivityUpdater implements Routine {
     private static final Logger logger = LoggerFactory.getLogger(HelpThreadActivityUpdater.class);
     private static final int SCHEDULE_MINUTES = 30;
     private static final int ACTIVITY_DETERMINE_MESSAGE_LIMIT = 11;
-
+    private static final int PERSIST_DURATION_VALUE = 12;
+    private static final ChronoUnit PERSIST_DURATION_UNIT = ChronoUnit.HOURS;
     private final HelpSystemHelper helper;
+    public static final Cache<MessageChannel, String> manuallyResetChannelActivityCache =
+            Caffeine.newBuilder()
+                .maximumSize(1_000)
+                .expireAfterWrite(PERSIST_DURATION_VALUE, TimeUnit.of(PERSIST_DURATION_UNIT))
+                .build();
 
     /**
      * Creates a new instance.
@@ -70,15 +80,27 @@ private void updateActivityForGuild(Guild guild) {
         activeThreads.forEach(this::updateActivityForThread);
     }
 
-    private void updateActivityForThread(ThreadChannel threadChannel) {
+    void updateActivityForThread(ThreadChannel threadChannel) {
         determineActivity(threadChannel)
             .flatMap(threadActivity -> helper.changeChannelActivity(threadChannel, threadActivity))
             .queue();
     }
 
     private static RestAction<HelpSystemHelper.ThreadActivity> determineActivity(
             MessageChannel channel) {
-        return channel.getHistory().retrievePast(ACTIVITY_DETERMINE_MESSAGE_LIMIT).map(messages -> {
+        String mostRecentMessageId = manuallyResetChannelActivityCache.getIfPresent(channel);
+        RestAction<List<Message>> restActionMessages;
+
+        if (mostRecentMessageId != null) {
+            MessageHistory.MessageRetrieveAction historyAfter =
+                    channel.getHistoryAfter(mostRecentMessageId, ACTIVITY_DETERMINE_MESSAGE_LIMIT);
+            restActionMessages = historyAfter.map(MessageHistory::getRetrievedHistory);
+        } else {
+            restActionMessages =
+                    channel.getHistory().retrievePast(ACTIVITY_DETERMINE_MESSAGE_LIMIT);
+        }
+
+        return restActionMessages.map(messages -> {
             if (messages.size() >= ACTIVITY_DETERMINE_MESSAGE_LIMIT) {
                 // There are likely even more messages, but we hit the limit
                 return HelpSystemHelper.ThreadActivity.HIGH;

application/src/main/java/org/togetherjava/tjbot/commands/help/HelpThreadCommand.java

@@ -3,10 +3,7 @@
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
 import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.entities.Guild;
-import net.dv8tion.jda.api.entities.Message;
-import net.dv8tion.jda.api.entities.MessageEmbed;
-import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.entities.*;
 import net.dv8tion.jda.api.entities.channel.concrete.ThreadChannel;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import net.dv8tion.jda.api.interactions.InteractionHook;
@@ -31,6 +28,8 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static org.togetherjava.tjbot.commands.help.HelpThreadActivityUpdater.manuallyResetChannelActivityCache;
+
 /**
  * Implements the {@code /help-thread} command, used to maintain certain aspects of help threads,
  * such as renaming or closing them.
@@ -42,6 +41,8 @@ public final class HelpThreadCommand extends SlashCommandAdapter {
     private static final String CHANGE_CATEGORY_OPTION = "category";
     public static final String CHANGE_TITLE_SUBCOMMAND = "title";
     private static final String CHANGE_TITLE_OPTION = "title";
+    private static final String CLOSE_SUBCOMMAND = "close";
+    private static final String RESET_ACTIVITY_SUBCOMMAND = "reset-activity";
     public static final String CHANGE_SUBCOMMAND_GROUP = "change";
     public static final String COMMAND_NAME = "help-thread";
 
@@ -80,6 +81,7 @@ public HelpThreadCommand(Config config, HelpSystemHelper helper) {
         getData().addSubcommandGroups(changeCommands);
 
         getData().addSubcommands(Subcommand.CLOSE.toSubcommandData());
+        getData().addSubcommands(Subcommand.RESET_ACTIVITY.toSubcommandData());
 
         this.helper = helper;
 
@@ -92,9 +94,9 @@ public HelpThreadCommand(Config config, HelpSystemHelper helper) {
         subcommandToCooldownCache = new EnumMap<>(streamSubcommands()
             .filter(Subcommand::hasCooldown)
             .collect(Collectors.toMap(Function.identity(), any -> createCooldownCache.get())));
-        subcommandToEventHandler = new EnumMap<>(
-                Map.of(Subcommand.CHANGE_CATEGORY, this::changeCategory, Subcommand.CHANGE_TITLE,
-                        this::changeTitle, Subcommand.CLOSE, this::closeThread));
+        subcommandToEventHandler = new EnumMap<>(Map.of(Subcommand.CHANGE_CATEGORY,
+                this::changeCategory, Subcommand.CHANGE_TITLE, this::changeTitle, Subcommand.CLOSE,
+                this::closeThread, Subcommand.RESET_ACTIVITY, this::resetActivity));
     }
 
     @Override
@@ -195,9 +197,26 @@ private void closeThread(SlashCommandInteractionEvent event, ThreadChannel helpT
             .setColor(HelpSystemHelper.AMBIENT_COLOR)
             .build();
 
+        manuallyResetChannelActivityCache.invalidate(helpThread);
         event.replyEmbeds(embed).flatMap(any -> helpThread.getManager().setArchived(true)).queue();
     }
 
+    private void resetActivity(SlashCommandInteractionEvent event, ThreadChannel helpThread) {
+        refreshCooldownFor(Subcommand.RESET_ACTIVITY, helpThread);
+
+        List<Message> messages = helpThread.getIterableHistory()
+            .stream()
+            .sorted(Comparator.comparing(ISnowflake::getTimeCreated).reversed())
+            .toList();
+
+        manuallyResetChannelActivityCache.put(helpThread, messages.get(0).getId());
+
+        HelpThreadActivityUpdater helpThreadActivityUpdater = new HelpThreadActivityUpdater(helper);
+        helpThreadActivityUpdater.updateActivityForThread(helpThread);
+
+        event.reply("Activities have been reset.").queue();
+    }
+
     private static Stream<Subcommand> streamSubcommands() {
         return Arrays.stream(Subcommand.values());
     }
@@ -206,7 +225,9 @@ enum Subcommand {
         CHANGE_CATEGORY(CHANGE_CATEGORY_SUBCOMMAND, "Change the category of this help thread",
                 Cooldown.YES),
         CHANGE_TITLE(CHANGE_TITLE_SUBCOMMAND, "Change the title of this help thread", Cooldown.YES),
-        CLOSE("close", "Close this help thread", Cooldown.YES);
+        CLOSE(CLOSE_SUBCOMMAND, "Close this help thread", Cooldown.YES),
+        RESET_ACTIVITY(RESET_ACTIVITY_SUBCOMMAND, "resets the activity in a help thread",
+                Cooldown.YES);
 
         private final String commandName;
         private final String description;