Feat/purge messages upto 24 hrs in current channel

PP.md

@@ -55,7 +55,7 @@ For example, **TJ-Bot** may associate your `user_id` with a `message_id` and a `
 
 **TJ-Bot** may further store data that you explicitly provided for **TJ-Bot** to offer its services. For example the reason of a moderative action when using its moderation commands.
 
-Furthermore, upon utilization of our help service, `user_id`s and `channel_id`s are stored to track when/how many questions a user asks. The data may be stored for up to **30** days. 
+Furthermore, upon utilization of our help service, `user_id`s and `channel_id`s and `timestamp`s are stored to track when/how many questions a user asks. The data may be stored for up to **30** days. 
 
 The stored data is not linked to any information that is personally identifiable.
 

application/src/main/java/org/togetherjava/tjbot/features/Features.java

@@ -31,6 +31,9 @@
 import org.togetherjava.tjbot.features.moderation.audit.AuditCommand;
 import org.togetherjava.tjbot.features.moderation.audit.ModAuditLogRoutine;
 import org.togetherjava.tjbot.features.moderation.audit.ModAuditLogWriter;
+import org.togetherjava.tjbot.features.moderation.history.MessageHistoryRoutine;
+import org.togetherjava.tjbot.features.moderation.history.PurgeHistoryCommand;
+import org.togetherjava.tjbot.features.moderation.history.PurgeMessageListener;
 import org.togetherjava.tjbot.features.moderation.modmail.ModMailCommand;
 import org.togetherjava.tjbot.features.moderation.scam.ScamBlocker;
 import org.togetherjava.tjbot.features.moderation.scam.ScamHistoryPurgeRoutine;
@@ -106,6 +109,7 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
             .add(new AutoPruneHelperRoutine(config, helpSystemHelper, modAuditLogWriter, database));
         features.add(new HelpThreadAutoArchiver(helpSystemHelper));
         features.add(new LeftoverBookmarksCleanupRoutine(bookmarksSystem));
+        features.add(new MessageHistoryRoutine(database));
 
         // Message receivers
         features.add(new TopHelpersMessageListener(database, config));
@@ -119,6 +123,7 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         features.add(new CodeMessageManualDetection(codeMessageHandler));
         features.add(new SlashCommandEducator());
         features.add(new PinnedNotificationRemover(config));
+        features.add(new PurgeMessageListener(database));
 
         // Event receivers
         features.add(new RejoinModerationRoleListener(actionsStore, config));
@@ -159,6 +164,7 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         features.add(new BookmarksCommand(bookmarksSystem));
         features.add(new ChatGptCommand(chatGptService));
         features.add(new JShellCommand(jshellEval));
+        features.add(new PurgeHistoryCommand(database));
 
         FeatureBlacklist<Class<?>> blacklist = blacklistConfig.normal();
         return features.stream().filter(f -> blacklist.isEnabled(f.getClass())).toList();

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

@@ -0,0 +1,25 @@
+package org.togetherjava.tjbot.features.moderation.history;
+
+/**
+ * Holds duration constants used for both purge history command and message history routine.
+ */
+public enum Duration {
+    // All new/existing options for duration in PurgeHistoryCommand should be within max and min
+    // duration
+    PURGE_HISTORY_MAX_DURATION(24),
+    PURGE_HISTORY_MIN_DURATION(1),
+    PURGE_HISTORY_THREE_HOURS(3),
+    PURGE_HISTORY_SIX_HOURS(6),
+    PURGE_HISTORY_TWELVE_HOURS(12),
+    PURGE_HISTORY_TWENTY_FOUR_HOURS(24);
+
+    private final int hours;
+
+    Duration(int hours) {
+        this.hours = hours;
+    }
+
+    public int getHours() {
+        return hours;
+    }
+}

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

@@ -0,0 +1,64 @@
+package org.togetherjava.tjbot.features.moderation.history;
+
+import net.dv8tion.jda.api.JDA;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.togetherjava.tjbot.db.Database;
+import org.togetherjava.tjbot.db.generated.tables.records.MessageHistoryRecord;
+import org.togetherjava.tjbot.features.Routine;
+
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
+
+import static org.togetherjava.tjbot.db.generated.Tables.MESSAGE_HISTORY;
+
+/**
+ * Routine that deletes records from message_history post expiration hours.
+ */
+public final 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 = Duration.PURGE_HISTORY_MAX_DURATION.getHours();
+    private final Database database;
+
+    /**
+     * Creates a new instance.
+     *
+     * @param database the database that contains records of messages to be purged.
+     */
+    public MessageHistoryRoutine(Database database) {
+        this.database = database;
+    }
+
+
+    @Override
+    public Schedule createSchedule() {
+        return new Schedule(ScheduleMode.FIXED_RATE, 0, SCHEDULE_INTERVAL_SECONDS,
+                TimeUnit.SECONDS);
+    }
+
+    @Override
+    public void runRoutine(JDA jda) {
+        Instant now = Instant.now();
+        Instant preExpirationHours = now.minus(EXPIRATION_HOURS, ChronoUnit.HOURS);
+
+        Stream<MessageHistoryRecord> messageRecords =
+                database.writeAndProvide(context -> context.selectFrom(MESSAGE_HISTORY)
+                    .where(MESSAGE_HISTORY.SENT_AT.lessThan(preExpirationHours))
+                    .stream());
+
+        try (messageRecords) {
+            messageRecords.forEach(messageRecord -> {
+                messageRecord.delete();
+                PurgeMessageListener.decrementRecordsCounterByOne();
+            });
+        } catch (Exception exception) {
+            logger.error(
+                    "Unknown error happened during delete operation during message history routine",
+                    exception);
+        }
+    }
+}

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

@@ -0,0 +1,175 @@
+package org.togetherjava.tjbot.features.moderation.history;
+
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+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;
+
+import org.togetherjava.tjbot.db.Database;
+import org.togetherjava.tjbot.db.DatabaseException;
+import org.togetherjava.tjbot.db.generated.tables.records.MessageHistoryRecord;
+import org.togetherjava.tjbot.features.CommandVisibility;
+import org.togetherjava.tjbot.features.SlashCommandAdapter;
+
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import static org.togetherjava.tjbot.db.generated.Tables.MESSAGE_HISTORY;
+
+public final class PurgeHistoryCommand extends SlashCommandAdapter {
+
+    private static final Logger logger = LoggerFactory.getLogger(PurgeHistoryCommand.class);
+    private static final String USER_OPTION = "user";
+    private static final String REASON_OPTION = "reason";
+    private static final String COMMAND_NAME = "purge-in-channel";
+    private static final int PURGE_MESSAGES_DEFAULT_DURATION =
+            Duration.PURGE_HISTORY_MIN_DURATION.getHours();
+    private static final String DURATION = "duration";
+    private final Database database;
+
+    /**
+     * Creates an instance of the command.
+     *
+     * @param database the database to retrieve message records of a target user
+     */
+
+    public PurgeHistoryCommand(Database database) {
+        super(COMMAND_NAME, "purge message history of user in same channel",
+                CommandVisibility.GUILD);
+
+        String optionUserDescription = "user who's message history you want to purge within %s hr"
+            .formatted(PURGE_MESSAGES_DEFAULT_DURATION);
+
+        String optionDurationDescription =
+                "duration in hours (default: %s)".formatted(PURGE_MESSAGES_DEFAULT_DURATION);
+
+        OptionData durationData =
+                new OptionData(OptionType.INTEGER, DURATION, optionDurationDescription, false);
+        durationData.addChoice("last 3 hrs", Duration.PURGE_HISTORY_THREE_HOURS.getHours())
+            .addChoice("last 6 hrs", Duration.PURGE_HISTORY_SIX_HOURS.getHours())
+            .addChoice("last 12 hrs", Duration.PURGE_HISTORY_TWELVE_HOURS.getHours())
+            .addChoice("last 24 hrs", Duration.PURGE_HISTORY_TWENTY_FOUR_HOURS.getHours());
+
+        getData().addOption(OptionType.USER, USER_OPTION, optionUserDescription, true)
+            .addOption(OptionType.STRING, REASON_OPTION,
+                    "reason for purging user's message history", true)
+            .addOptions(durationData);
+        this.database = database;
+    }
+
+    @Override
+    public void onSlashCommand(SlashCommandInteractionEvent event) {
+        event.deferReply(true).queue();
+
+        OptionMapping targetOption =
+                Objects.requireNonNull(event.getOption(USER_OPTION), "target is null");
+        Member author = Objects.requireNonNull(event.getMember(), "author is null");
+        String reason = Objects.requireNonNull(event.getOption(REASON_OPTION).getAsString(),
+                "reason is null");
+
+        OptionMapping durationMapping = event.getOption(DURATION);
+        int duration = durationMapping == null ? PURGE_MESSAGES_DEFAULT_DURATION
+                : durationMapping.getAsInt();
+
+        handleHistory(event, author, reason, targetOption, event.getHook(), duration);
+    }
+
+    private void handleHistory(SlashCommandInteractionEvent event, Member author, String reason,
+            OptionMapping targetOption, InteractionHook hook, int duration) {
+        Instant now = Instant.now();
+        Instant purgeMessagesAfter = now.minus(duration, ChronoUnit.HOURS);
+
+        User targetUser = targetOption.getAsUser();
+        String sourceChannelId = event.getChannel().getId();
+
+        if (!validateHierarchy(author, targetOption)) {
+            hook.sendMessage("Cannot purge history of user with a higher role than you").queue();
+            return;
+        }
+
+        List<String> messageIdsForDeletion = new ArrayList<>();
+
+        Stream<MessageHistoryRecord> fetchedMessageHistory =
+                database.writeAndProvide(context -> context.selectFrom(MESSAGE_HISTORY)
+                    .where(MESSAGE_HISTORY.AUTHOR_ID.equal(targetUser.getIdLong())
+                        .and(MESSAGE_HISTORY.CHANNEL_ID.equal(Long.valueOf(sourceChannelId)))
+                        .and(MESSAGE_HISTORY.SENT_AT.greaterOrEqual(purgeMessagesAfter)))
+                    .stream());
+
+        try (fetchedMessageHistory) {
+            fetchedMessageHistory.forEach(messageHistoryRecord -> {
+                String messageId = String.valueOf(messageHistoryRecord.getMessageId());
+                messageIdsForDeletion.add(messageId);
+                messageHistoryRecord.delete();
+
+                PurgeMessageListener.decrementRecordsCounterByOne();
+            });
+        } catch (DatabaseException exception) {
+            logger.error("unknown error during fetching message history records for {} command",
+                    COMMAND_NAME, exception);
+        }
+
+        handleDelete(messageIdsForDeletion, event.getChannel(), event.getHook(), targetUser, reason,
+                author, duration);
+    }
+
+    private void handleDelete(List<String> messageIdsForDeletion, MessageChannelUnion channel,
+            InteractionHook hook, User targetUser, String reason, Member author, int duration) {
+
+        if (messageIdsForDeletion.isEmpty()) {
+            handleEmptyMessageHistory(hook, targetUser, duration);
+            return;
+        }
+
+        if (hasSingleElement(messageIdsForDeletion)) {
+            String messageId = messageIdsForDeletion.get(0);
+            String messageForMod = "message purged from user %s in this channel within last %s hr."
+                .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 within last %s hrs."
+            .formatted(noOfMessagePurged, targetUser.getName(), duration);
+        hook.sendMessage(messageForMod)
+            .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, int duration) {
+        String messageForMod = "%s has no message history in this channel within last %s hrs."
+            .formatted(targetUser.getName(), duration);
+
+        hook.sendMessage(messageForMod).queue();
+    }
+
+    private boolean validateHierarchy(Member author, OptionMapping target) {
+        int highestRole = 0;
+        Role targetUserRole = Objects
+            .requireNonNull(target.getAsMember(), "target user for purge command is not a member")
+            .getRoles()
+            .get(highestRole);
+        Role authorRole = author.getRoles().get(highestRole);
+
+        return targetUserRole.getPosition() >= authorRole.getPosition();
+    }
+}