Added defer reply to mod commands (#750)

Author: Taz03

application/src/main/java/org/togetherjava/tjbot/commands/moderation/BanCommand.java

@@ -72,15 +72,14 @@ public BanCommand(ModerationActionsStore actionsStore) {
         this.actionsStore = Objects.requireNonNull(actionsStore);
     }
 
-    private static RestAction<InteractionHook> handleAlreadyBanned(Guild.Ban ban,
-            IReplyCallback event) {
+    private static RestAction<Message> handleAlreadyBanned(Guild.Ban ban, InteractionHook hook) {
         String reason = ban.getReason();
         String reasonText =
                 reason == null || reason.isBlank() ? "" : " (reason: %s)".formatted(reason);
 
         String message = "The user '%s' is already banned%s.".formatted(ban.getUser().getAsTag(),
                 reasonText);
-        return event.reply(message).setEphemeral(true);
+        return hook.sendMessage(message).setEphemeral(true);
     }
 
     private static RestAction<Boolean> sendDm(ISnowflake target,
@@ -115,8 +114,8 @@ private static MessageEmbed sendFeedback(boolean hasSentDm, User target, Member
                 durationText + dmNoticeText, reason);
     }
 
-    private static Optional<RestAction<InteractionHook>> handleNotAlreadyBannedResponse(
-            Throwable alreadyBannedFailure, IReplyCallback event, Guild guild, User target) {
+    private static Optional<RestAction<Message>> handleNotAlreadyBannedResponse(
+            Throwable alreadyBannedFailure, InteractionHook hook, Guild guild, User target) {
         if (alreadyBannedFailure instanceof ErrorResponseException errorResponseException) {
             if (errorResponseException.getErrorResponse() == ErrorResponse.UNKNOWN_BAN) {
                 return Optional.empty();
@@ -125,7 +124,7 @@ private static Optional<RestAction<InteractionHook>> handleNotAlreadyBannedRespo
             if (errorResponseException.getErrorResponse() == ErrorResponse.MISSING_PERMISSIONS) {
                 logger.error("The bot does not have the '{}' permission on the guild '{}'.",
                         Permission.BAN_MEMBERS, guild.getName());
-                return Optional.of(event.reply(
+                return Optional.of(hook.sendMessage(
                         "I can not ban users in this guild since I do not have the %s permission."
                             .formatted(Permission.BAN_MEMBERS))
                     .setEphemeral(true));
@@ -134,18 +133,18 @@ private static Optional<RestAction<InteractionHook>> handleNotAlreadyBannedRespo
         logger.warn(LogMarkers.SENSITIVE,
                 "Something unexpected went wrong while trying to ban the user '{}'.",
                 target.getAsTag(), alreadyBannedFailure);
-        return Optional.of(event.reply("Failed to ban the user due to an unexpected problem.")
+        return Optional.of(hook.sendMessage("Failed to ban the user due to an unexpected problem.")
             .setEphemeral(true));
     }
 
-    private RestAction<InteractionHook> banUserFlow(User target, Member author,
+    private RestAction<Message> banUserFlow(User target, Member author,
             @Nullable ModerationUtils.TemporaryData temporaryData, String reason,
             int deleteHistoryDays, Guild guild, SlashCommandInteractionEvent event) {
         return sendDm(target, temporaryData, reason, guild, event)
             .flatMap(hasSentDm -> banUser(target, author, temporaryData, reason, deleteHistoryDays,
                     guild).map(banResult -> hasSentDm))
             .map(hasSentDm -> sendFeedback(hasSentDm, target, author, temporaryData, reason))
-            .flatMap(event::replyEmbeds);
+            .flatMap(event.getHook()::sendMessageEmbeds);
     }
 
     private AuditableRestAction<Void> banUser(User target, Member author,
@@ -208,14 +207,16 @@ public void onSlashCommand(SlashCommandInteractionEvent event) {
         int deleteHistoryDays = Math
             .toIntExact(Objects.requireNonNull(event.getOption(DELETE_HISTORY_OPTION)).getAsLong());
 
+        event.deferReply().queue();
+        InteractionHook hook = event.getHook();
         // Ban the user, but only if not already banned
         guild.retrieveBan(target).mapToResult().flatMap(alreadyBanned -> {
             if (alreadyBanned.isSuccess()) {
-                return handleAlreadyBanned(alreadyBanned.get(), event);
+                return handleAlreadyBanned(alreadyBanned.get(), hook);
             }
 
             return handleNotAlreadyBannedResponse(
-                    Objects.requireNonNull(alreadyBanned.getFailure()), event, guild, target)
+                    Objects.requireNonNull(alreadyBanned.getFailure()), hook, guild, target)
                         .orElseGet(() -> banUserFlow(target, author, temporaryData.orElse(null),
                                 reason, deleteHistoryDays, guild, event));
         }).queue();

application/src/main/java/org/togetherjava/tjbot/commands/moderation/KickCommand.java

@@ -60,11 +60,13 @@ private static void handleAbsentTarget(IReplyCallback event) {
 
     private void kickUserFlow(Member target, Member author, String reason, Guild guild,
             SlashCommandInteractionEvent event) {
+        event.deferReply().queue();
+
         sendDm(target, reason, guild, event)
             .flatMap(hasSentDm -> kickUser(target, author, reason, guild)
                 .map(kickResult -> hasSentDm))
             .map(hasSentDm -> sendFeedback(hasSentDm, target, author, reason))
-            .flatMap(event::replyEmbeds)
+            .flatMap(event.getHook()::sendMessageEmbeds)
             .queue();
     }
 

application/src/main/java/org/togetherjava/tjbot/commands/moderation/MuteCommand.java

@@ -115,11 +115,13 @@ private AuditableRestAction<Void> muteUser(Member target, Member author,
     private void muteUserFlow(Member target, Member author,
             @Nullable ModerationUtils.TemporaryData temporaryData, String reason, Guild guild,
             SlashCommandInteractionEvent event) {
+        event.deferReply().queue();
+
         sendDm(target, temporaryData, reason, guild, event)
             .flatMap(hasSentDm -> muteUser(target, author, temporaryData, reason, guild)
                 .map(result -> hasSentDm))
             .map(hasSentDm -> sendFeedback(hasSentDm, target, author, temporaryData, reason))
-            .flatMap(event::replyEmbeds)
+            .flatMap(event.getHook()::sendMessageEmbeds)
             .queue();
     }
 

application/src/main/java/org/togetherjava/tjbot/commands/moderation/QuarantineCommand.java

@@ -100,11 +100,13 @@ private AuditableRestAction<Void> quarantineUser(Member target, Member author, S
 
     private void quarantineUserFlow(Member target, Member author, String reason, Guild guild,
             SlashCommandInteractionEvent event) {
+        event.deferReply().queue();
+
         sendDm(target, reason, guild, event)
             .flatMap(hasSentDm -> quarantineUser(target, author, reason, guild)
                 .map(result -> hasSentDm))
             .map(hasSentDm -> sendFeedback(hasSentDm, target, author, reason))
-            .flatMap(event::replyEmbeds)
+            .flatMap(event.getHook()::sendMessageEmbeds)
             .queue();
     }
 

application/src/main/java/org/togetherjava/tjbot/commands/moderation/WarnCommand.java

@@ -2,7 +2,6 @@
 
 import net.dv8tion.jda.api.entities.*;
 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.requests.RestAction;
@@ -46,14 +45,17 @@ public WarnCommand(ModerationActionsStore actionsStore) {
         this.actionsStore = Objects.requireNonNull(actionsStore);
     }
 
-    private RestAction<InteractionHook> warnUserFlow(User target, Member author, String reason,
-            Guild guild, SlashCommandInteractionEvent event) {
-        return dmUser(target, reason, guild, event).map(hasSentDm -> {
+    private void warnUserFlow(User target, Member author, String reason, Guild guild,
+            SlashCommandInteractionEvent event) {
+        event.deferReply().queue();
+
+        dmUser(target, reason, guild, event).map(hasSentDm -> {
             warnUser(target, author, reason, guild);
             return hasSentDm;
         })
             .map(hasSentDm -> sendFeedback(hasSentDm, target, author, reason))
-            .flatMap(event::replyEmbeds);
+            .flatMap(event.getHook()::sendMessageEmbeds)
+            .queue();
     }
 
     private static RestAction<Boolean> dmUser(ISnowflake target, String reason, Guild guild,
@@ -99,7 +101,7 @@ public void onSlashCommand(SlashCommandInteractionEvent event) {
             return;
         }
 
-        warnUserFlow(targetOption.getAsUser(), author, reason, guild, event).queue();
+        warnUserFlow(targetOption.getAsUser(), author, reason, guild, event);
     }
 
     private boolean handleChecks(Member bot, Member author, @Nullable Member target, String reason,