[AB-xxx] reworking moderation commands to use more defer logic, so that they do not time out anymore

removed message command condition, as it seemed unused
2026-03-11 01:36:33 +00:00 · 2025-02-23 21:13:27 +01:00
parent 33ad3bdc5d
commit ec78a0d856
14 changed files with 193 additions and 108 deletions
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Ban.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Ban.java
@@ -12,6 +12,7 @@ import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.service.UserService;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.core.utils.ParseUtils;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
@@ -21,6 +22,7 @@ import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.InteractionHook;
 import net.dv8tion.jda.api.interactions.commands.OptionType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -29,6 +31,7 @@ import java.time.Duration;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import org.springframework.transaction.annotation.Transactional;

 import static dev.sheldan.abstracto.moderation.model.BanResult.NOTIFICATION_FAILED;
 import static dev.sheldan.abstracto.moderation.service.BanService.BAN_EFFECT_KEY;
@@ -59,6 +62,9 @@ public class Ban extends AbstractConditionableCommand {
    @Autowired
    private UserService userService;

+    @Autowired
+    private Ban self;
+
    @Override
    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
        String reason = slashCommandParameterService.getCommandOption(REASON_PARAMETER, event, String.class, String.class);
@@ -69,35 +75,57 @@ public class Ban extends AbstractConditionableCommand {
        } else {
            duration = null;
        }
+
        if(slashCommandParameterService.hasCommandOptionWithFullType(USER_PARAMETER, event, OptionType.USER)) {
            Member member = slashCommandParameterService.getCommandOption(USER_PARAMETER, event, User.class, Member.class);
-            return banService.banUserWithNotification(ServerUser.fromMember(member), reason, ServerUser.fromMember(event.getMember()), event.getGuild(), duration)
-                    .thenCompose(banResult -> {
-                        if(banResult == NOTIFICATION_FAILED) {
-                            String errorNotification = templateService.renderSimpleTemplate(BAN_NOTIFICATION_NOT_POSSIBLE, event.getGuild().getIdLong());
-                            return interactionService.replyString(errorNotification, event);
-                        } else {
-                            return interactionService.replyEmbed(BAN_RESPONSE, event);
-                        }
-                    })
-                    .thenApply(aVoid -> CommandResult.fromSuccess());
+            return event.deferReply().submit()
+                .thenCompose((hook) -> self.banMember(event, member, reason, duration, hook))
+                .thenApply(commandResult -> CommandResult.fromSuccess());
        } else {
            String userIdStr = slashCommandParameterService.getCommandOption(USER_PARAMETER, event, User.class, String.class);
            Long userId = Long.parseLong(userIdStr);
-            return userService.retrieveUserForId(userId)
-                    .thenCompose(user -> banService.banUserWithNotification(ServerUser.fromId(event.getGuild().getIdLong(), userId), reason, ServerUser.fromMember(event.getMember()), event.getGuild(), duration))
-                    .thenCompose(banResult -> {
-                        if(banResult == NOTIFICATION_FAILED) {
-                            String errorNotification = templateService.renderSimpleTemplate(BAN_NOTIFICATION_NOT_POSSIBLE, event.getGuild().getIdLong());
-                            return interactionService.replyString(errorNotification, event);
-                        } else {
-                            return interactionService.replyEmbed(BAN_RESPONSE, event);
-                        }
-                    })
-                    .thenApply(banResult -> CommandResult.fromSuccess());
+            return event.deferReply().submit()
+                .thenCompose((hook) -> self.banViaUserId(event, userId, reason, duration, hook))
+                .thenApply(commandResult -> CommandResult.fromSuccess());
        }
    }

+    @Transactional
+    public CompletableFuture<Void> banViaUserId(SlashCommandInteractionEvent event, Long userId, String reason,
+                                                                               Duration duration, InteractionHook hook) {
+        return userService.retrieveUserForId(userId)
+            .thenCompose(user -> banService.banUserWithNotification(ServerUser.fromId(event.getGuild().getIdLong(), userId), reason,
+                ServerUser.fromId(event.getGuild().getIdLong(), event.getUser().getIdLong()), event.getGuild(), duration))
+            .thenCompose(banResult -> {
+                if (banResult == NOTIFICATION_FAILED) {
+                    String errorNotification = templateService.renderSimpleTemplate(BAN_NOTIFICATION_NOT_POSSIBLE, event.getGuild().getIdLong());
+                    return interactionService.replyString(errorNotification, hook)
+                        .thenAccept(message -> {
+                        });
+                } else {
+                    return FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(BAN_RESPONSE, new Object(), hook));
+                }
+            });
+    }
+
+    @Transactional
+    public CompletableFuture<Void> banMember(SlashCommandInteractionEvent event, Member member, String reason,
+                                                                               Duration duration, InteractionHook hook) {
+        return banService.banUserWithNotification(ServerUser.fromMember(member), reason,
+                ServerUser.fromId(event.getGuild().getIdLong(), event.getUser().getIdLong()), event.getGuild(),
+                duration)
+            .thenCompose(banResult -> {
+                if (banResult == NOTIFICATION_FAILED) {
+                    String errorNotification = templateService.renderSimpleTemplate(BAN_NOTIFICATION_NOT_POSSIBLE, event.getGuild().getIdLong());
+                    return interactionService.replyString(errorNotification, hook)
+                        .thenAccept(message -> {
+                        });
+                } else {
+                    return FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(BAN_RESPONSE, new Object(), hook));
+                }
+            });
+    }
+
    @Override
    public CommandConfiguration getConfiguration() {
        Parameter userParameter = Parameter
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/DecayAllWarnings.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/DecayAllWarnings.java
@@ -4,21 +4,25 @@ import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
-import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandService;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
+import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
 import dev.sheldan.abstracto.moderation.service.WarnService;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import org.springframework.transaction.annotation.Transactional;

@Component
 public class DecayAllWarnings extends AbstractConditionableCommand {
@@ -33,13 +37,22 @@ public class DecayAllWarnings extends AbstractConditionableCommand {
     private ServerManagementService serverManagementService;

     @Autowired
-     private InteractionService interactionService;
+     private SlashCommandService slashCommandService;
+
+     @Autowired
+     private DecayAllWarnings self;

    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        return warnService.decayAllWarningsForServer(server)
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        return self.decayAllWarnings(event)
+            .thenCompose(hook -> slashCommandService.completeConfirmableCommand(event, DECAY_ALL_WARNINGS_RESPONSE))
+            .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Transactional
+    public CompletableFuture<Void> decayAllWarnings(SlashCommandInteractionEvent hook) {
+        AServer server = serverManagementService.loadServer(hook.getInteraction().getGuild());
+        return warnService.decayAllWarningsForServer(server);
    }

    @Override
@@ -50,11 +63,21 @@ public class DecayAllWarnings extends AbstractConditionableCommand {
                .templated(true)
                .build();

+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .rootCommandName(ModerationSlashCommandNames.WARN_DECAY)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
+            .commandName("decayall")
+            .build();
+
        return CommandConfiguration.builder()
                .name(DECAY_ALL_WARNINGS_COMMAND)
                .module(ModerationModuleDefinition.MODERATION)
                .templated(true)
                .async(true)
+                .slashCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
                .requiresConfirmation(true)
                .supportsEmbedException(true)
                .causesReaction(true)
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/DecayWarnings.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/DecayWarnings.java
@@ -4,25 +4,32 @@ import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandService;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
+import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
 import dev.sheldan.abstracto.moderation.service.WarnService;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import org.springframework.transaction.annotation.Transactional;

@Component
 public class DecayWarnings extends AbstractConditionableCommand {

    private static final String DECAY_WARNINGS_COMMAND = "decayWarnings";
+    private static final String DECAY_WARNINGS_RESPONSE = "decayWarnings_response";

    @Autowired
    private WarnService warnService;
@@ -30,11 +37,23 @@ public class DecayWarnings extends AbstractConditionableCommand {
    @Autowired
    private ServerManagementService serverManagementService;

+    @Autowired
+    private DecayWarnings self;
+
+    @Autowired
+    private SlashCommandService slashCommandService;
+
    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        return warnService.decayWarningsForServer(server)
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        return self.decayAllWarnings(event)
+            .thenCompose(hook -> slashCommandService.completeConfirmableCommand(event, DECAY_WARNINGS_RESPONSE))
+            .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Transactional
+    public CompletableFuture<Void> decayAllWarnings(SlashCommandInteractionEvent event) {
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        return warnService.decayWarningsForServer(server);
    }

    @Override
@@ -45,12 +64,22 @@ public class DecayWarnings extends AbstractConditionableCommand {
                .templated(true)
                .build();

+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .rootCommandName(ModerationSlashCommandNames.WARN_DECAY)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
+            .commandName("decay")
+            .build();
+
        return CommandConfiguration.builder()
                .name(DECAY_WARNINGS_COMMAND)
                .module(ModerationModuleDefinition.MODERATION)
                .templated(true)
                .requiresConfirmation(true)
                .async(true)
+                .slashCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
                .supportsEmbedException(true)
                .causesReaction(true)
                .parameters(parameters)
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Infractions.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Infractions.java
@@ -14,12 +14,12 @@ import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParame
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
-import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.PaginatorService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
@@ -28,9 +28,11 @@ import dev.sheldan.abstracto.moderation.model.database.InfractionParameter;
 import dev.sheldan.abstracto.moderation.model.template.command.InfractionEntry;
 import dev.sheldan.abstracto.moderation.model.template.command.InfractionsModel;
 import dev.sheldan.abstracto.moderation.service.management.InfractionManagementService;
+import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.InteractionHook;
 import net.dv8tion.jda.api.interactions.commands.OptionType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -40,6 +42,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
+import org.springframework.transaction.annotation.Transactional;

@Component
 public class Infractions extends AbstractConditionableCommand {
@@ -61,9 +64,6 @@ public class Infractions extends AbstractConditionableCommand {
    @Autowired
    private TemplateService templateService;

-    @Autowired
-    private ChannelService channelService;
-
    @Autowired
    private PaginatorService paginatorService;

@@ -73,29 +73,39 @@ public class Infractions extends AbstractConditionableCommand {
    @Autowired
    private SlashCommandParameterService slashCommandParameterService;

+    @Autowired
+    private Infractions self;
+
    @Override
    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        return event.deferReply().submit()
+            .thenCompose(interactionHook -> self.showInfractions(interactionHook, event));
+    }
+
+    @Transactional
+    public CompletableFuture<CommandResult> showInfractions(InteractionHook hook, SlashCommandInteractionEvent event) {
        List<Infraction> infractions;
+        Guild guild = hook.getInteraction().getGuild();
        if(slashCommandParameterService.hasCommandOptionWithFullType(USER_PARAMETER, event, OptionType.USER)) {
            Member member = slashCommandParameterService.getCommandOption(USER_PARAMETER, event, User.class, Member.class);
-            if(!member.getGuild().equals(event.getGuild())) {
+            if(!member.getGuild().equals(guild)) {
                throw new EntityGuildMismatchException();
            }
            infractions = infractionManagementService.getInfractionsForUser(userInServerManagementService.loadOrCreateUser(member));
        } else if(slashCommandParameterService.hasCommandOptionWithFullType(USER_PARAMETER, event, OptionType.STRING)){
            String userIdStr = slashCommandParameterService.getCommandOption(USER_PARAMETER, event, User.class, String.class);
            Long userId = Long.parseLong(userIdStr);
-            AUserInAServer userInServer = userInServerManagementService.loadOrCreateUser(event.getGuild().getIdLong(), userId);
+            AUserInAServer userInServer = userInServerManagementService.loadOrCreateUser(guild.getIdLong(), userId);
            infractions = infractionManagementService.getInfractionsForUser(userInServer);

        } else {
-            AServer server = serverManagementService.loadServer(event.getGuild());
+            AServer server = serverManagementService.loadServer(guild);
            infractions = infractionManagementService.getInfractionsForServer(server);
        }
        if(infractions.isEmpty()) {
-            MessageToSend messageToSend = templateService.renderEmbedTemplate(NO_INFRACTIONS_TEMPLATE_KEY, new Object(), event.getGuild().getIdLong());
-            return interactionService.replyMessageToSend(messageToSend, event)
-                    .thenApply(interactionHook -> CommandResult.fromSuccess());
+            MessageToSend messageToSend = templateService.renderEmbedTemplate(NO_INFRACTIONS_TEMPLATE_KEY, new Object(), guild.getIdLong());
+            return FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(messageToSend, hook))
+                .thenApply(interactionHook -> CommandResult.fromSuccess());

        } else {
            List<InfractionEntry> convertedInfractions = fromInfractions(infractions);
@@ -103,8 +113,8 @@ public class Infractions extends AbstractConditionableCommand {
                    .builder()
                    .entries(convertedInfractions)
                    .build();
-            return paginatorService.createPaginatorFromTemplate(INFRACTIONS_RESPONSE_TEMPLATE, model, event)
-                    .thenApply(unused -> CommandResult.fromSuccess());
+            return paginatorService.sendPaginatorToInteraction(INFRACTIONS_RESPONSE_TEMPLATE, model, hook)
+                .thenApply(unused -> CommandResult.fromSuccess());
        }
    }

--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Kick.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Kick.java
@@ -14,6 +14,7 @@ import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
@@ -61,10 +62,10 @@ public class Kick extends AbstractConditionableCommand {
        } else {
            reason = templateService.renderSimpleTemplate(KICK_DEFAULT_REASON_TEMPLATE, event.getGuild().getIdLong());
        }
-
-        return kickService.kickMember(member, event.getMember(), reason)
-                .thenCompose(unused -> interactionService.replyEmbed(KICK_RESPONSE, event))
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+        return event.deferReply().submit()
+            .thenCompose(interactionHook -> kickService.kickMember(member, event.getMember(), reason)
+            .thenCompose(unused -> FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(KICK_RESPONSE, event, interactionHook))))
+            .thenApply(o -> CommandResult.fromSuccess());
    }

    @Override
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Mute.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Mute.java
@@ -12,6 +12,7 @@ import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.models.ServerChannelMessage;
 import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.core.utils.ParseUtils;
 import dev.sheldan.abstracto.core.utils.SnowflakeUtils;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
@@ -76,15 +77,16 @@ public class Mute extends AbstractConditionableCommand {
                .build();
        ServerUser userToMute = ServerUser.fromMember(targetMember);
        ServerUser mutingUser = ServerUser.fromMember(event.getMember());
-        return muteService.muteMemberWithLog(userToMute, mutingUser, reason, duration, event.getGuild(), commandMessage)
+        return event.deferReply().submit()
+            .thenCompose(hook -> muteService.muteMemberWithLog(userToMute, mutingUser, reason, duration, event.getGuild(), commandMessage)
                .thenCompose(muteResult -> {
                    if(muteResult == NOTIFICATION_FAILED) {
-                        return interactionService.replyEmbed(MUTE_NOTIFICATION_NOT_POSSIBLE_TEMPLATE_KEY, new Object(), event);
+                        return FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(MUTE_NOTIFICATION_NOT_POSSIBLE_TEMPLATE_KEY, new Object(), hook));
                    } else {
-                        return interactionService.replyEmbed(MUTE_RESPONSE, event);
+                        return FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(MUTE_RESPONSE, event, hook));
                    }
                })
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+            .thenApply(aVoid -> CommandResult.fromSuccess()));
    }

    @Override
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Mutes.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Mutes.java
@@ -15,8 +15,7 @@ import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.PaginatorService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.core.templating.model.MessageToSend;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
@@ -26,6 +25,7 @@ import dev.sheldan.abstracto.moderation.model.template.command.MutesModel;
 import dev.sheldan.abstracto.moderation.service.management.MuteManagementService;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.InteractionHook;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
@@ -50,9 +50,6 @@ public class Mutes extends AbstractConditionableCommand {
    @Autowired
    private UserInServerManagementService userInServerManagementService;

-    @Autowired
-    private TemplateService templateService;
-
    @Autowired
    private MuteEntryConverter muteEntryConverter;

@@ -69,16 +66,23 @@ public class Mutes extends AbstractConditionableCommand {
    private InteractionService interactionService;

    @Transactional
-    public CompletableFuture<Void> renderMutes(SlashCommandInteractionEvent event, List<MuteEntry> mutes) {
+    public CompletableFuture<Void> renderMutes(InteractionHook event, List<MuteEntry> mutes) {
        MutesModel model = MutesModel
                .builder()
                .mutes(mutes)
                .build();
-        return paginatorService.createPaginatorFromTemplate(MUTES_DISPLAY_TEMPLATE_KEY, model, event);
+        return paginatorService.sendPaginatorToInteraction(MUTES_DISPLAY_TEMPLATE_KEY, model, event);
    }

    @Override
    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        return event.deferReply().submit()
+            .thenCompose((hook) -> self.loadAndRenderMutes(event, hook))
+            .thenApply(u -> CommandResult.fromSuccess());
+    }
+
+    @Transactional
+    public CompletableFuture<Void> loadAndRenderMutes(SlashCommandInteractionEvent event, InteractionHook hook) {
        List<dev.sheldan.abstracto.moderation.model.database.Mute> mutesToDisplay;
        if(!slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER, event)) {
            AServer server = serverManagementService.loadServer(event.getGuild().getIdLong());
@@ -91,13 +95,10 @@ public class Mutes extends AbstractConditionableCommand {
            mutesToDisplay = muteManagementService.getAllMutesOf(userInServerManagementService.loadOrCreateUser(memberParameter));
        }
        if(mutesToDisplay.isEmpty()) {
-            MessageToSend messageToSend = templateService.renderEmbedTemplate(NO_MUTES_TEMPLATE_KEY, new Object(), event.getGuild().getIdLong());
-            return interactionService.replyMessageToSend(messageToSend, event)
-                    .thenApply(unused -> CommandResult.fromSuccess());
+            return FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(NO_MUTES_TEMPLATE_KEY, new Object(), hook));
        } else {
            return muteEntryConverter.fromMutes(mutesToDisplay)
-                    .thenCompose(muteEntries -> self.renderMutes(event, muteEntries)
-                            .thenApply(unused -> CommandResult.fromIgnored()));
+                    .thenCompose(muteEntries -> self.renderMutes(hook, muteEntries));
        }
    }

--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/UserNotes.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/UserNotes.java
@@ -16,6 +16,7 @@ import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
@@ -26,12 +27,14 @@ import dev.sheldan.abstracto.moderation.model.template.command.NoteEntryModel;
 import dev.sheldan.abstracto.moderation.service.management.UserNoteManagementService;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.InteractionHook;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import org.springframework.transaction.annotation.Transactional;

@Component
 public class UserNotes extends AbstractConditionableCommand {
@@ -56,8 +59,18 @@ public class UserNotes extends AbstractConditionableCommand {
    @Autowired
    private InteractionService interactionService;

+    @Autowired
+    private UserNotes self;
+
    @Override
    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        return event.deferReply().submit()
+            .thenCompose((hook) -> self.loadAndRenderUserNotes(event, hook))
+            .thenApply(u -> CommandResult.fromSuccess());
+    }
+
+    @Transactional
+    public CompletableFuture<Void> loadAndRenderUserNotes(SlashCommandInteractionEvent event, InteractionHook hook) {
        List<UserNote> userNotes;

        ListNotesModel model = ListNotesModel
@@ -84,8 +97,7 @@ public class UserNotes extends AbstractConditionableCommand {
        CompletableFuture<List<NoteEntryModel>> listCompletableFuture = userNotesConverter.fromNotes(userNotes);
        return listCompletableFuture.thenCompose(noteEntryModels -> {
            model.setUserNotes(noteEntryModels);
-            return interactionService.replyEmbed(USER_NOTES_RESPONSE_TEMPLATE, model, event)
-                    .thenApply(interactionHook -> CommandResult.fromSuccess());
+            return FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(USER_NOTES_RESPONSE_TEMPLATE, model, hook));
        });
    }

--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Warn.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Warn.java
@@ -13,6 +13,7 @@ import dev.sheldan.abstracto.core.exception.EntityGuildMismatchException;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.models.ServerChannelMessage;
 import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.core.utils.SnowflakeUtils;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
@@ -85,9 +86,10 @@ public class Warn extends AbstractConditionableCommand {
                .channelId(event.getChannel().getIdLong())
                .messageId(SnowflakeUtils.createSnowFlake())
                .build();
-        return warnService.warnUserWithLog(event.getGuild(), ServerUser.fromMember(member), ServerUser.fromMember(event.getMember()), reason, commandMessage)
-                .thenCompose(unused -> interactionService.replyEmbed(WARN_RESPONSE, event))
-                .thenApply(warning -> CommandResult.fromSuccess());
+        return event.deferReply().submit()
+            .thenCompose((hook) -> warnService.warnUserWithLog(event.getGuild(), ServerUser.fromMember(member), ServerUser.fromMember(event.getMember()), reason, commandMessage)
+                    .thenCompose((unused) -> FutureUtils.toSingleFutureGeneric(interactionService.sendEmbed(WARN_RESPONSE, hook))))
+                .thenApply(unused -> CommandResult.fromSuccess());
    }

    @Override
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Warnings.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Warnings.java
@@ -15,8 +15,7 @@ import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.PaginatorService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.core.templating.model.MessageToSend;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
@@ -27,6 +26,7 @@ import dev.sheldan.abstracto.moderation.model.template.command.WarningsModel;
 import dev.sheldan.abstracto.moderation.service.management.WarnManagementService;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.InteractionHook;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
@@ -60,9 +60,6 @@ public class Warnings extends AbstractConditionableCommand {
    @Autowired
    private Warnings self;

-    @Autowired
-    private TemplateService templateService;
-
    @Autowired
    private SlashCommandParameterService slashCommandParameterService;

@@ -70,17 +67,24 @@ public class Warnings extends AbstractConditionableCommand {
    private InteractionService interactionService;

    @Transactional
-    public CompletableFuture<Void> renderWarnings(SlashCommandInteractionEvent event, List<WarnEntry> warnEntries) {
+    public CompletableFuture<Void> renderWarnings(InteractionHook event, List<WarnEntry> warnEntries) {
        WarningsModel model = WarningsModel
                .builder()
                .warnings(warnEntries)
                .build();

-        return paginatorService.createPaginatorFromTemplate(WARNINGS_RESPONSE_TEMPLATE, model, event);
+        return paginatorService.sendPaginatorToInteraction(WARNINGS_RESPONSE_TEMPLATE, model, event);
    }

    @Override
    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        return event.deferReply().submit()
+            .thenCompose((hook) -> self.loadAndRenderWarnings(event, hook))
+            .thenApply(u -> CommandResult.fromSuccess());
+    }
+
+    @Transactional
+    public CompletableFuture<Void> loadAndRenderWarnings(SlashCommandInteractionEvent event, InteractionHook hook) {
        List<Warning> warnsToDisplay;
        if(slashCommandParameterService.hasCommandOption(USER_PARAMETER, event)) {
            Member member = slashCommandParameterService.getCommandOption(USER_PARAMETER, event, Member.class);
@@ -93,14 +97,10 @@ public class Warnings extends AbstractConditionableCommand {
            warnsToDisplay = warnManagementService.getAllWarningsOfServer(server);
        }
        if(warnsToDisplay.isEmpty()) {
-            MessageToSend messageToSend = templateService.renderEmbedTemplate(NO_WARNINGS_TEMPLATE_KEY, new Object(), event.getGuild().getIdLong());
-            return interactionService.replyMessageToSend(messageToSend, event)
-                    .thenApply(interactionHook -> CommandResult.fromSuccess());
-
+            return FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(NO_WARNINGS_TEMPLATE_KEY, new Object(), hook));
        } else {
            return warnEntryConverter.fromWarnings(warnsToDisplay)
-                    .thenCompose(warnEntries -> self.renderWarnings(event, warnEntries))
-                    .thenApply(unused -> CommandResult.fromIgnored());
+                .thenCompose(warnEntries -> self.renderWarnings(hook, warnEntries));
        }
    }

--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/MuteServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/MuteServiceBean.java
@@ -166,6 +166,7 @@ public class MuteServiceBean implements MuteService {
    }

    @Override
+    @Transactional
    public CompletableFuture<MuteResult> muteMemberWithLog(ServerUser userToMute, ServerUser mutingUser, String reason, Duration duration, Guild guild, ServerChannelMessage origin) {
        return muteMemberWithLog(userToMute, mutingUser, reason, duration, guild, origin, null);
    }
--- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/AbstractConditionableCommand.java
+++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/AbstractConditionableCommand.java
@@ -35,13 +35,10 @@ public abstract class AbstractConditionableCommand implements ConditionalCommand
    @Autowired
    private CommandCoolDownCondition coolDownCondition;

-    @Autowired
-    private MessageCommandCondition messageCommandCondition;
-
    @Override
    public List<CommandCondition> getConditions() {
        return new ArrayList<>(Arrays.asList(adminModeCondition, featureEnabledCondition, commandDisabledCondition,
-                commandDisallowedCondition, featureModeCondition, coolDownCondition, messageCommandCondition));
+                commandDisallowedCondition, featureModeCondition, coolDownCondition));
    }

    protected void checkParameters(CommandContext context) {
--- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/MessageCommandCondition.java
+++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/MessageCommandCondition.java
@@ -1,18 +0,0 @@
-package dev.sheldan.abstracto.core.command.condition;
-
-import dev.sheldan.abstracto.core.command.Command;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import org.springframework.stereotype.Component;
-
-@Component
-public class MessageCommandCondition implements CommandCondition {
-
-    @Override
-    public ConditionResult shouldExecute(CommandContext commandContext, Command command) {
-        if(command.getConfiguration().isSupportsMessageCommand()) {
-            return ConditionResult.builder().result(true).build();
-        } else {
-            return ConditionResult.builder().result(false).reportResult(false).build();
-        }
-    }
-}
--- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/config/CommandConfiguration.java
+++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/config/CommandConfiguration.java
@@ -41,9 +41,6 @@ public class CommandConfiguration {
    @Builder.Default
    private List<EffectConfig> effects = new ArrayList<>();

-    @Builder.Default
-    private boolean supportsMessageCommand = true;
-
    @Builder.Default
    private boolean slashCommandOnly = false;