Feat/delete messages upto 24 hrs

application/src/main/java/org/togetherjava/tjbot/features/moderation/history/MessageHistoryRoutine.java

@@ -22,7 +22,7 @@
 public class MessageHistoryRoutine implements Routine {
     private static final Logger logger = LoggerFactory.getLogger(MessageHistoryRoutine.class);
     private static final int SCHEDULE_INTERVAL_SECONDS = 30;
-    private static final int EXPIRATION_HOURS = 2;
+    private static final int EXPIRATION_HOURS = 24;
     private final Database database;
 
     /**

application/src/main/java/org/togetherjava/tjbot/features/moderation/history/PurgeHistoryCommand.java

@@ -1,6 +1,5 @@
 package org.togetherjava.tjbot.features.moderation.history;
 
-import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Role;
 import net.dv8tion.jda.api.entities.User;
@@ -9,6 +8,7 @@
 import net.dv8tion.jda.api.interactions.InteractionHook;
 import net.dv8tion.jda.api.interactions.commands.OptionMapping;
 import net.dv8tion.jda.api.interactions.commands.OptionType;
+import net.dv8tion.jda.api.interactions.commands.build.OptionData;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -34,7 +34,10 @@ public class PurgeHistoryCommand extends SlashCommandAdapter {
     private static final String REASON_OPTION = "reason";
     private static final String COMMAND_NAME = "purge-in-channel";
     private static final int PURGE_MESSAGES_AFTER_LIMIT_HOURS = 1;
+    private static final String DURATION = "duration";
+    private static final int PURGE_MESSAGES_AFTER_LIMIT_MAX = 24;
     private final Database database;
+    private final PurgeMessageListener purgeMessageListener;
 
     /**
      * Creates an instance of the command.
@@ -49,10 +52,19 @@ public PurgeHistoryCommand(Database database) {
         String optionUserDescription = "user who's message history you want to purge within %s hr"
             .formatted(PURGE_MESSAGES_AFTER_LIMIT_HOURS);
 
+        String optionDurationDescription = "duration in hours (default: %s, max: %s)"
+            .formatted(PURGE_MESSAGES_AFTER_LIMIT_HOURS, PURGE_MESSAGES_AFTER_LIMIT_MAX);
+
+        OptionData durationData =
+                new OptionData(OptionType.INTEGER, DURATION, optionDurationDescription, false);
+        durationData.setRequiredRange(0, PURGE_MESSAGES_AFTER_LIMIT_MAX);
+
         getData().addOption(OptionType.USER, USER_OPTION, optionUserDescription, true)
             .addOption(OptionType.STRING, REASON_OPTION,
-                    "reason for purging user's message history", true);
+                    "reason for purging user's message history", true)
+            .addOptions(durationData);
         this.database = database;
+        this.purgeMessageListener = new PurgeMessageListener(database);
     }
 
     @Override
@@ -65,13 +77,17 @@ public void onSlashCommand(SlashCommandInteractionEvent event) {
         String reason = Objects.requireNonNull(event.getOption(REASON_OPTION).getAsString(),
                 "reason is null");
 
-        handleHistory(event, author, reason, targetOption, event.getHook());
+        OptionMapping durationMapping = event.getOption(DURATION);
+        int duration = durationMapping == null ? PURGE_MESSAGES_AFTER_LIMIT_HOURS
+                : durationMapping.getAsInt();
+
+        handleHistory(event, author, reason, targetOption, event.getHook(), duration);
     }
 
     private void handleHistory(SlashCommandInteractionEvent event, Member author, String reason,
-            OptionMapping targetOption, InteractionHook hook) {
+            OptionMapping targetOption, InteractionHook hook, int duration) {
         Instant now = Instant.now();
-        Instant purgeMessagesAfter = now.minus(PURGE_MESSAGES_AFTER_LIMIT_HOURS, ChronoUnit.HOURS);
+        Instant purgeMessagesAfter = now.minus(duration, ChronoUnit.HOURS);
 
         User targetUser = targetOption.getAsUser();
         String sourceChannelId = event.getChannel().getId();
@@ -95,54 +111,52 @@ private void handleHistory(SlashCommandInteractionEvent event, Member author, St
                 String messageId = String.valueOf(messageHistoryRecord.getMessageId());
                 messageIdsForDeletion.add(messageId);
                 messageHistoryRecord.delete();
+
+                purgeMessageListener.decrementRecordsCounter();
             });
         } catch (DatabaseException exception) {
             logger.error("unknown error during fetching message history records for {} command",
                     COMMAND_NAME, exception);
         }
 
-        handleDelete(messageIdsForDeletion, event.getJDA(), event.getChannel(), event.getHook(),
-                targetUser, reason, author);
+        handleDelete(messageIdsForDeletion, event.getChannel(), event.getHook(), targetUser, reason,
+                author, duration);
     }
 
-    private void handleDelete(List<String> messageIdsForDeletion, JDA jda,
-            MessageChannelUnion channel, InteractionHook hook, User targetUser, String reason,
-            Member author) {
+    private void handleDelete(List<String> messageIdsForDeletion, MessageChannelUnion channel,
+            InteractionHook hook, User targetUser, String reason, Member author, int duration) {
 
         if (messageIdsForDeletion.isEmpty()) {
-            handleEmptyMessageHistory(hook, targetUser);
+            handleEmptyMessageHistory(hook, targetUser, duration);
             return;
         }
 
         if (hasSingleElement(messageIdsForDeletion)) {
             String messageId = messageIdsForDeletion.get(0);
-            String messageForMod =
-                    "message purged from user %s in this channel.".formatted(targetUser.getName());
-            Objects.requireNonNull(jda.getTextChannelById(channel.getId()), "channel was not found")
-                .deleteMessageById(messageId)
-                .queue();
-
+            String messageForMod = "message purged from user %s in this channel in last %s hrs."
+                .formatted(targetUser.getName(), duration);
+            channel.deleteMessageById(messageId).queue();
             hook.sendMessage(messageForMod).queue();
             return;
         }
 
         int noOfMessagePurged = messageIdsForDeletion.size();
         channel.purgeMessagesById(messageIdsForDeletion);
 
-        String messageForMod = "%s messages purged from user %s in this channel."
-            .formatted(noOfMessagePurged, targetUser.getName());
+        String messageForMod = "%s messages purged from user %s in this channel in last %s hrs."
+            .formatted(noOfMessagePurged, targetUser.getName(), duration);
         hook.sendMessage(messageForMod)
-            .queue(onSuccess -> logger.info("{} purged messages from {} because: {}",
-                    author.getUser(), targetUser, reason));
+            .queue(onSuccess -> logger.info("{} purged messages from {} in {} because: {}",
+                    author.getUser(), targetUser, channel.getName(), reason));
     }
 
     private boolean hasSingleElement(List<String> messageIdsForDeletion) {
         return messageIdsForDeletion.size() == 1;
     }
 
-    private void handleEmptyMessageHistory(InteractionHook hook, User targetUser) {
-        String messageForMod = "%s has no message history in this channel within last %s hr."
-            .formatted(targetUser.getName(), PURGE_MESSAGES_AFTER_LIMIT_HOURS);
+    private void handleEmptyMessageHistory(InteractionHook hook, User targetUser, int duration) {
+        String messageForMod = "%s has no message history in this channel within last %s hrs."
+            .formatted(targetUser.getName(), duration);
 
         hook.sendMessage(messageForMod).queue();
     }

application/src/main/java/org/togetherjava/tjbot/features/moderation/history/PurgeMessageListener.java

@@ -1,11 +1,14 @@
 package org.togetherjava.tjbot.features.moderation.history;
 
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import org.togetherjava.tjbot.db.Database;
 import org.togetherjava.tjbot.features.MessageReceiverAdapter;
 
 import java.time.Instant;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import static org.togetherjava.tjbot.db.generated.Tables.MESSAGE_HISTORY;
 
@@ -14,6 +17,9 @@
  * database.
  */
 public class PurgeMessageListener extends MessageReceiverAdapter {
+    private static final Logger logger = LoggerFactory.getLogger(PurgeMessageListener.class);
+    private static final int MESSAGES_RECORDS_LIMIT = 7500;
+    static AtomicInteger recordsCounter = new AtomicInteger(0);
     private final Database database;
 
     /**
@@ -41,16 +47,35 @@ private void updateHistory(MessageReceivedEvent event) {
         long messageId = event.getMessageIdLong();
         long authorId = event.getAuthor().getIdLong();
 
-        database.write(context -> context.newRecord(MESSAGE_HISTORY)
-            .setSentAt(Instant.now())
-            .setGuildId(guildId)
-            .setChannelId(channelId)
-            .setMessageId(messageId)
-            .setAuthorId(authorId)
-            .insert());
+        if (canWriteToDB()) {
+            database.write(context -> context.newRecord(MESSAGE_HISTORY)
+                .setSentAt(Instant.now())
+                .setGuildId(guildId)
+                .setChannelId(channelId)
+                .setMessageId(messageId)
+                .setAuthorId(authorId)
+                .insert());
+
+            incrementRecordsCounter();
+        } else {
+            logger.warn("purge history reached limit");
+        }
     }
 
     private boolean shouldIgnoreMessages(MessageReceivedEvent event) {
         return event.isWebhookMessage() || event.getAuthor().isBot();
     }
+
+    private boolean canWriteToDB() {
+        return recordsCounter.get() <= MESSAGES_RECORDS_LIMIT;
+    }
+
+    private void incrementRecordsCounter() {
+        recordsCounter.getAndIncrement();
+    }
+
+    void decrementRecordsCounter() {
+        recordsCounter.decrementAndGet();
+    }
+
 }