[AB-xxx] updating JDA version

.env

@@ -1,2 +1,2 @@
 REGISTRY_PREFIX=harbor.sheldan.dev/abstracto/
-VERSION=1.5.25
+VERSION=1.5.26

.github/workflows/release_manual.yml

@@ -1,5 +1,8 @@
 name: Publishes a new version of abstracto
 on: workflow_dispatch
+permissions:
+  packages: write
+  contents: write
 jobs:
   publish:
     runs-on: ubuntu-latest
@@ -16,6 +19,12 @@ jobs:
         id: version
         working-directory: ./abstracto-application
         run: echo "version=$(mvn -q -Dexec.executable="echo" -Dexec.args='${project.version}' --non-recursive exec:exec | cut -d- -f1)" >> $GITHUB_ENV
+      - name: Create a Release
+        uses: elgohr/Github-Release-Action@v5
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          title: Release of version ${{ env.version }}
       - name: Release maven packages
         uses: qcastel/github-actions-maven-release@v1.12.41
         env:

README.md

@@ -12,7 +12,7 @@ An example implementation of this bot can be seen [here](https://github.com/Shel
 
 
 ## Technologies
-* [JDA](https://github.com/DV8FromTheWorld/JDA/) The Discord API Wrapper in the version 5.0.0-beta.13
+* [JDA](https://github.com/DV8FromTheWorld/JDA/) The Discord API Wrapper in the version 5.0.0-beta.21
 * [Spring boot](https://github.com/spring-projects/spring-boot) is used as a framework to create standalone application in Java with Java EE methods. (including dependency injection and more)
 * [Hibernate](https://github.com/hibernate/hibernate-orm) is used as a reference implementation of JPA.
 * [Freemarker](https://github.com/apache/freemarker) is used as a templating engine. This is used to provide internationalization for user facing text and enable dynamic embed configuration.

abstracto-application/abstracto-modules/anti-raid/anti-raid-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>anti-raid</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/anti-raid/anti-raid-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>anti-raid</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/anti-raid/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>assignable-roles</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>assignable-roles</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <artifactId>assignable-roles-int</artifactId>

abstracto-application/abstracto-modules/assignable-roles/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>abstracto-modules</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/custom-command/custom-command-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>custom-command</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/custom-command/custom-command-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>custom-command</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/custom-command/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/dynamic-activity/dynamic-activity-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>dynamic-activity</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/dynamic-activity/dynamic-activity-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>dynamic-activity</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/dynamic-activity/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/entertainment/entertainment-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>entertainment</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/entertainment/entertainment-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>entertainment</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/entertainment/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>experience-tracking</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -38,6 +38,11 @@
             <version>${project.version}</version>
         </dependency>
 
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>dev.sheldan.abstracto.core</groupId>
             <artifactId>core-int</artifactId>

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/AddLevelAction.java

@@ -0,0 +1,193 @@
+package dev.sheldan.abstracto.experience.command;
+
+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.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+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.experience.config.ExperienceFeatureDefinition;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureMode;
+import dev.sheldan.abstracto.experience.config.ExperienceSlashCommandNames;
+import dev.sheldan.abstracto.experience.exception.LevelActionNotFoundException;
+import dev.sheldan.abstracto.experience.listener.LevelActionListener;
+import dev.sheldan.abstracto.experience.model.LevelActionPayload;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.service.LevelActionService;
+import dev.sheldan.abstracto.experience.service.management.LevelActionManagementService;
+import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+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.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+@Slf4j
+public class AddLevelAction extends AbstractConditionableCommand {
+
+    private static final String COMMAND_NAME = "addLevelAction";
+    private static final String ACTION_PARAMETER_NAME = "action";
+    private static final String LEVEL_PARAMETER_NAME = "level";
+    private static final String PARAMETER_PARAMETER_NAME = "parameter";
+    private static final String MEMBER_PARAMETER_NAME = "member";
+
+    private static final String RESPONSE_TEMPLATE = "addLevelAction_response";
+
+    @Autowired
+    private LevelActionManagementService levelActionManagementService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private LevelActionService levelActionService;
+
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Autowired
+    private UserExperienceManagementService userExperienceManagementService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String actionName = slashCommandParameterService.getCommandOption(ACTION_PARAMETER_NAME, event, String.class);
+        LevelActionListener listener = levelActionService.getLevelActionListenerForName(actionName)
+                .orElseThrow(LevelActionNotFoundException::new);
+        AUserInAServer aUserInAServer;
+        if(slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER_NAME, event)) {
+            Member member = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER_NAME, event, Member.class);
+            aUserInAServer = userInServerManagementService.loadOrCreateUser(member);
+        } else {
+            aUserInAServer = null;
+        }
+        Integer level = slashCommandParameterService.getCommandOption(LEVEL_PARAMETER_NAME, event, Integer.class);
+        String parameter = slashCommandParameterService.getCommandOption(PARAMETER_PARAMETER_NAME, event, String.class);
+        LevelActionPayload payload = listener.createPayload(event.getGuild(), parameter);
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        log.info("Adding level action {} for level {} in server {}.", actionName, level, event.getGuild().getId());
+        AUserExperience userExperience = null;
+        if(aUserInAServer != null) {
+            Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(aUserInAServer.getUserInServerId());
+            userExperience = aUserExperienceOptional.orElseGet(() -> {
+                AUserExperience user = userExperienceManagementService.createUserInServer(aUserInAServer);
+                return userExperienceManagementService.saveUser(user);
+            });
+        }
+        levelActionManagementService.createLevelAction(level, server, actionName, userExperience, payload);
+        return interactionService.replyEmbed(RESPONSE_TEMPLATE, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ACTION_PARAMETER_NAME)) {
+            String input = event.getFocusedOption().getValue().toLowerCase();
+            List<String> availableLevelActions = levelActionService.getAvailableLevelActions()
+                    .stream()
+                    .map(String::toLowerCase)
+                    .toList();
+            if(!input.isEmpty()) {
+                return availableLevelActions.stream().filter(s -> s.startsWith(input)).toList();
+            } else {
+                return availableLevelActions;
+            }
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter actionParameter = Parameter
+                .builder()
+                .name(ACTION_PARAMETER_NAME)
+                .templated(true)
+                .type(String.class)
+                .supportsAutoComplete(true)
+                .build();
+
+        Parameter levelParameter = Parameter
+                .builder()
+                .name(LEVEL_PARAMETER_NAME)
+                .templated(true)
+                .type(Integer.class)
+                .build();
+
+        Parameter parameterParameter = Parameter
+                .builder()
+                .name(PARAMETER_PARAMETER_NAME)
+                .templated(true)
+                .type(String.class)
+                .build();
+
+        Parameter memberParameter = Parameter
+                .builder()
+                .name(MEMBER_PARAMETER_NAME)
+                .templated(true)
+                .optional(true)
+                .type(Member.class)
+                .build();
+
+        List<Parameter> parameters = Arrays.asList(levelParameter, actionParameter, parameterParameter, memberParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .groupName("levelAction")
+                .commandName("add")
+                .build();
+
+        return CommandConfiguration.builder()
+                .name(COMMAND_NAME)
+                .module(ExperienceModuleDefinition.EXPERIENCE)
+                .templated(true)
+                .slashCommandConfig(slashCommandConfig)
+                .supportsEmbedException(true)
+                .slashCommandOnly(true)
+                .causesReaction(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ExperienceFeatureDefinition.EXPERIENCE;
+    }
+
+    @Override
+    public List<FeatureMode> getFeatureModeLimitations() {
+        return Arrays.asList(ExperienceFeatureMode.LEVEL_ACTION);
+    }
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/RemoveLevelAction.java

@@ -0,0 +1,171 @@
+package dev.sheldan.abstracto.experience.command;
+
+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.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+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.experience.config.ExperienceFeatureDefinition;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureMode;
+import dev.sheldan.abstracto.experience.config.ExperienceSlashCommandNames;
+import dev.sheldan.abstracto.experience.exception.LevelActionNotFoundException;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.service.management.LevelActionManagementService;
+import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+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.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+@Component
+@Slf4j
+public class RemoveLevelAction extends AbstractConditionableCommand {
+
+    private static final String COMMAND_NAME = "removeLevelAction";
+    private static final String ACTION_PARAMETER_NAME = "action";
+    private static final String LEVEL_PARAMETER_NAME = "level";
+    private static final String MEMBER_PARAMETER_NAME = "member";
+
+    private static final String RESPONSE_TEMPLATE = "removeLevelAction_response";
+
+    @Autowired
+    private LevelActionManagementService levelActionManagementService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Autowired
+    private UserExperienceManagementService userExperienceManagementService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String actionName = slashCommandParameterService.getCommandOption(ACTION_PARAMETER_NAME, event, String.class);
+        AUserExperience userExperience = null;
+        if(slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER_NAME, event)) {
+            Member member = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER_NAME, event, Member.class);
+            AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(member);
+            userExperience = userExperienceManagementService.findUserInServer(aUserInAServer);
+        }
+        Integer level = slashCommandParameterService.getCommandOption(LEVEL_PARAMETER_NAME, event, Integer.class);
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        log.info("Removing level action {} for level {} in server {}.", actionName, level, event.getGuild().getId());
+        if(levelActionManagementService.getLevelAction(actionName, level, server, userExperience).isEmpty()) {
+            throw new LevelActionNotFoundException();
+        }
+        levelActionManagementService.deleteLevelAction(level, server, actionName, userExperience);
+        return interactionService.replyEmbed(RESPONSE_TEMPLATE, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ACTION_PARAMETER_NAME)) {
+            String input = event.getFocusedOption().getValue().toLowerCase();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            Set<String> availableLevelActions = levelActionManagementService.getLevelActionsOfServer(server)
+                    .stream()
+                    .map(levelAction -> levelAction.getAction().toLowerCase())
+                    .collect(Collectors.toSet());
+            if(!input.isEmpty()) {
+                return availableLevelActions.stream().filter(s -> s.startsWith(input)).toList();
+            } else {
+                return new ArrayList<>(availableLevelActions);
+            }
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter actionParameter = Parameter
+                .builder()
+                .name(ACTION_PARAMETER_NAME)
+                .templated(true)
+                .type(String.class)
+                .supportsAutoComplete(true)
+                .build();
+
+        Parameter levelParameter = Parameter
+                .builder()
+                .name(LEVEL_PARAMETER_NAME)
+                .templated(true)
+                .type(Integer.class)
+                .build();
+
+        Parameter memberParameter = Parameter
+                .builder()
+                .name(MEMBER_PARAMETER_NAME)
+                .templated(true)
+                .optional(true)
+                .type(Member.class)
+                .build();
+
+        List<Parameter> parameters = Arrays.asList(levelParameter, actionParameter, memberParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .groupName("levelAction")
+                .commandName("remove")
+                .build();
+
+        return CommandConfiguration.builder()
+                .name(COMMAND_NAME)
+                .module(ExperienceModuleDefinition.EXPERIENCE)
+                .templated(true)
+                .slashCommandConfig(slashCommandConfig)
+                .supportsEmbedException(true)
+                .slashCommandOnly(true)
+                .causesReaction(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ExperienceFeatureDefinition.EXPERIENCE;
+    }
+
+    @Override
+    public List<FeatureMode> getFeatureModeLimitations() {
+        return Arrays.asList(ExperienceFeatureMode.LEVEL_ACTION);
+    }
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/ShowLevelActions.java

@@ -0,0 +1,79 @@
+package dev.sheldan.abstracto.experience.command;
+
+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.execution.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureMode;
+import dev.sheldan.abstracto.experience.config.ExperienceSlashCommandNames;
+import dev.sheldan.abstracto.experience.model.template.LevelActionsDisplay;
+import dev.sheldan.abstracto.experience.service.LevelActionService;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class ShowLevelActions extends AbstractConditionableCommand {
+
+    private static final String COMMAND_NAME = "showLevelActions";
+    private static final String TEMPLATE_KEY = "showLevelActions_response";
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private LevelActionService levelActionService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        LevelActionsDisplay levelActionsToDisplay = levelActionService.getLevelActionsToDisplay(event.getGuild());
+        return interactionService.replyEmbed(TEMPLATE_KEY, levelActionsToDisplay, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .groupName("levelAction")
+                .commandName("show")
+                .build();
+
+        return CommandConfiguration.builder()
+                .name(COMMAND_NAME)
+                .module(ExperienceModuleDefinition.EXPERIENCE)
+                .templated(true)
+                .slashCommandConfig(slashCommandConfig)
+                .supportsEmbedException(true)
+                .slashCommandOnly(true)
+                .causesReaction(true)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public List<FeatureMode> getFeatureModeLimitations() {
+        return Arrays.asList(ExperienceFeatureMode.LEVEL_ACTION);
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ExperienceFeatureDefinition.EXPERIENCE;
+    }
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/AddMemberToChannelLevelAction.java

@@ -0,0 +1,55 @@
+package dev.sheldan.abstracto.experience.listener;
+
+import com.google.gson.Gson;
+import dev.sheldan.abstracto.core.utils.ParseUtils;
+import dev.sheldan.abstracto.experience.model.*;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.database.LevelAction;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class AddMemberToChannelLevelAction implements LevelActionListener {
+
+    public static final String ADD_MEMBER_TO_CHANNEL_ABOVE_LEVEL = "add_member_to_channel_above_level";
+
+    @Autowired
+    private Gson gson;
+
+    @Override
+    public void apply(AUserExperience userExperience, LevelAction levelAction, MemberActionModification container) {
+        AddMemberToChannelLevelActionPayload payload = (AddMemberToChannelLevelActionPayload) levelAction.getLoadedPayload();
+        log.info("Adding member {} to channel {} in server {}.", userExperience.getUser().getUserReference().getId(), payload.getChannelId(), userExperience.getServer().getId());
+        container.getChannelsToAdd().add(payload.getChannelId());
+        container.getChannelsToRemove().remove(payload.getChannelId());
+    }
+
+    @Override
+    public void prepareAction(LevelAction levelAction) {
+        levelAction.setLoadedPayload(gson.fromJson(levelAction.getPayload(), AddMemberToChannelLevelActionPayload.class));
+    }
+
+    @Override
+    public AddMemberToChannelLevelActionPayload createPayload(Guild guild, String input) {
+        GuildChannel channel = ParseUtils.parseGuildChannelFromText(input, guild);
+        return AddMemberToChannelLevelActionPayload
+                .builder()
+                .channelId(channel.getIdLong())
+                .build();
+    }
+
+    @Override
+    public String getName() {
+        return ADD_MEMBER_TO_CHANNEL_ABOVE_LEVEL;
+    }
+
+    @Override
+    public boolean shouldExecute(AUserExperience aUserExperience, LevelAction levelAction) {
+        return aUserExperience.getLevelOrDefault() >= levelAction.getLevel().getLevel();
+    }
+
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/AddRoleLevelAction.java

@@ -0,0 +1,55 @@
+package dev.sheldan.abstracto.experience.listener;
+
+import com.google.gson.Gson;
+import dev.sheldan.abstracto.core.utils.ParseUtils;
+import dev.sheldan.abstracto.experience.model.*;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.database.LevelAction;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Role;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class AddRoleLevelAction implements LevelActionListener {
+
+    public static final String ADD_ROLE_ABOVE_LEVEL = "add_role_above_level";
+
+    @Autowired
+    private Gson gson;
+
+    @Override
+    public void apply(AUserExperience userExperience, LevelAction levelAction, MemberActionModification container) {
+        AddRoleLevelActionPayload payload = (AddRoleLevelActionPayload) levelAction.getLoadedPayload();
+        log.info("Adding role {} to user {} in server {}.", payload.getRoleId(), userExperience.getUser().getUserReference().getId(), userExperience.getServer().getId());
+        container.getRolesToAdd().add(payload.getRoleId());
+        container.getRolesToRemove().remove(payload.getRoleId());
+    }
+
+    @Override
+    public void prepareAction(LevelAction levelAction) {
+        levelAction.setLoadedPayload(gson.fromJson(levelAction.getPayload(), AddRoleLevelActionPayload.class));
+    }
+
+    @Override
+    public LevelActionPayload createPayload(Guild guild, String input) {
+        Role role = ParseUtils.parseRoleFromText(input, guild);
+        return AddRoleLevelActionPayload
+                .builder()
+                .roleId(role.getIdLong())
+                .build();
+    }
+
+    @Override
+    public String getName() {
+        return ADD_ROLE_ABOVE_LEVEL;
+    }
+
+    @Override
+    public boolean shouldExecute(AUserExperience aUserExperience, LevelAction levelAction) {
+        return aUserExperience.getLevelOrDefault() >= levelAction.getLevel().getLevel();
+    }
+
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/JoiningUserRoleListener.java

@@ -6,10 +6,13 @@ import dev.sheldan.abstracto.core.listener.async.jda.AsyncJoinListener;
 import dev.sheldan.abstracto.core.listener.sync.jda.JoinListener;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.models.listener.MemberJoinModel;
+import dev.sheldan.abstracto.core.service.FeatureModeService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureMode;
 import dev.sheldan.abstracto.experience.model.database.AUserExperience;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
+import dev.sheldan.abstracto.experience.service.LevelActionService;
 import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.Member;
@@ -35,6 +38,12 @@ public class JoiningUserRoleListener implements AsyncJoinListener {
     @Autowired
     private UserInServerManagementService userInServerManagementService;
 
+    @Autowired
+    private FeatureModeService featureModeService;
+
+    @Autowired
+    private LevelActionService levelActionService;
+
     @Override
     public DefaultListenerResult execute(MemberJoinModel model) {
         if(model.getMember().isPending()) {
@@ -43,12 +52,24 @@ public class JoiningUserRoleListener implements AsyncJoinListener {
         }
         Optional<AUserInAServer> userInAServerOptional = userInServerManagementService.loadUserOptional(model.getServerId(), model.getJoiningUser().getUserId());
         userInAServerOptional.ifPresent(aUserInAServer -> {
-            Optional<AUserExperience> userExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(aUserInAServer.getUserInServerId());
+            Long userInServerId = aUserInAServer.getUserInServerId();
+            Optional<AUserExperience> userExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInServerId);
             if(userExperienceOptional.isPresent()) {
                 log.info("User {} joined {} with previous experience. Setting up experience role again (if necessary).", model.getJoiningUser().getUserId(), model.getServerId());
-                userExperienceService.syncForSingleUser(userExperienceOptional.get(), model.getMember(), true).thenAccept(result ->
+                AUserExperience aUserExperience = userExperienceOptional.get();
+                userExperienceService.syncForSingleUser(aUserExperience, model.getMember(), true).thenAccept(result ->
                         log.info("Finished re-assigning experience for re-joining user {} in server {}.", model.getJoiningUser().getUserId(), model.getServerId())
                 );
+                if(featureModeService.featureModeActive(ExperienceFeatureDefinition.EXPERIENCE, aUserInAServer.getServerReference() , ExperienceFeatureMode.LEVEL_ACTION)) {
+                    levelActionService.applyLevelActionsToUser(aUserExperience)
+                            .thenAccept(unused -> {
+                                log.info("Executed level actions for user {}.", userInServerId);
+                            })
+                            .exceptionally(throwable -> {
+                                log.warn("Failed to execute level actions for user {}.", userInServerId, throwable);
+                                return null;
+                            });
+                }
             } else {
                 log.info("Joined user {} in server {} does not have any previous experience. Not setting up anything.", model.getJoiningUser().getUserId(), model.getServerId());
             }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/MemberPendingRoleListener.java

@@ -5,10 +5,13 @@ import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncUpdatePendingListener;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.models.listener.MemberUpdatePendingModel;
+import dev.sheldan.abstracto.core.service.FeatureModeService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureMode;
 import dev.sheldan.abstracto.experience.model.database.AUserExperience;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
+import dev.sheldan.abstracto.experience.service.LevelActionService;
 import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.Member;
@@ -34,16 +37,34 @@ public class MemberPendingRoleListener implements AsyncUpdatePendingListener {
     @Autowired
     private UserInServerManagementService userInServerManagementService;
 
+    @Autowired
+    private FeatureModeService featureModeService;
+
+    @Autowired
+    private LevelActionService levelActionService;
+
     @Override
     public DefaultListenerResult execute(MemberUpdatePendingModel model) {
         Optional<AUserInAServer> userInAServerOptional = userInServerManagementService.loadUserOptional(model.getServerId(), model.getUser().getUserId());
         userInAServerOptional.ifPresent(aUserInAServer -> {
-            Optional<AUserExperience> userExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(aUserInAServer.getUserInServerId());
+            Long userInServerId = aUserInAServer.getUserInServerId();
+            Optional<AUserExperience> userExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInServerId);
             if(userExperienceOptional.isPresent()) {
                 log.info("User {} updated pending status {} with previous experience. Setting up experience role again (if necessary).", model.getUser().getUserId(), model.getServerId());
-                userExperienceService.syncForSingleUser(userExperienceOptional.get(), model.getMember(), true).thenAccept(result ->
+                AUserExperience aUserExperience = userExperienceOptional.get();
+                userExperienceService.syncForSingleUser(aUserExperience, model.getMember(), true).thenAccept(result ->
                         log.info("Finished re-assigning experience for update pending user {} in server {}.", model.getUser().getUserId(), model.getServerId())
                 );
+                if(featureModeService.featureModeActive(ExperienceFeatureDefinition.EXPERIENCE, aUserInAServer.getServerReference() , ExperienceFeatureMode.LEVEL_ACTION)) {
+                    levelActionService.applyLevelActionsToUser(aUserExperience)
+                            .thenAccept(unused -> {
+                                log.info("Executed level actions for user {}.", userInServerId);
+                            })
+                            .exceptionally(throwable -> {
+                                log.warn("Failed to execute level actions for user {}.", userInServerId, throwable);
+                                return null;
+                            });
+                }
             } else {
                 log.info("Member updating pending {} in server {} does not have any previous experience. Not setting up anything.", model.getUser().getUserId(), model.getServerId());
             }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/RemoveMemberFromChannelLevelAction.java

@@ -0,0 +1,55 @@
+package dev.sheldan.abstracto.experience.listener;
+
+import com.google.gson.Gson;
+import dev.sheldan.abstracto.core.utils.ParseUtils;
+import dev.sheldan.abstracto.experience.model.RemoveMemberFromChannelLevelActionPayload;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.database.LevelAction;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class RemoveMemberFromChannelLevelAction implements LevelActionListener {
+
+    public static final String REMOVE_MEMBER_FROM_CHANNEL_ABOVE_LEVEL = "remove_member_from_channel_above_level";
+
+    @Autowired
+    private Gson gson;
+
+    @Override
+    public void apply(AUserExperience userExperience, LevelAction levelAction, MemberActionModification container) {
+        RemoveMemberFromChannelLevelActionPayload payload = (RemoveMemberFromChannelLevelActionPayload) levelAction.getLoadedPayload();
+        log.info("Removing member {} from channel {} in server {}.", userExperience.getUser().getUserReference().getId(), payload.getChannelId(), userExperience.getServer().getId());
+        container.getChannelsToRemove().add(payload.getChannelId());
+        container.getChannelsToAdd().remove(payload.getChannelId());
+    }
+
+    @Override
+    public void prepareAction(LevelAction levelAction) {
+        levelAction.setLoadedPayload(gson.fromJson(levelAction.getPayload(), RemoveMemberFromChannelLevelActionPayload.class));
+    }
+
+    @Override
+    public RemoveMemberFromChannelLevelActionPayload createPayload(Guild guild, String input) {
+        GuildChannel channel = ParseUtils.parseGuildChannelFromText(input, guild);
+        return RemoveMemberFromChannelLevelActionPayload
+                .builder()
+                .channelId(channel.getIdLong())
+                .build();
+    }
+
+    @Override
+    public String getName() {
+        return REMOVE_MEMBER_FROM_CHANNEL_ABOVE_LEVEL;
+    }
+
+    @Override
+    public boolean shouldExecute(AUserExperience aUserExperience, LevelAction levelAction) {
+        return aUserExperience.getLevelOrDefault() >= levelAction.getLevel().getLevel();
+    }
+
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/RemoveRoleLevelAction.java

@@ -0,0 +1,56 @@
+package dev.sheldan.abstracto.experience.listener;
+
+import com.google.gson.Gson;
+import dev.sheldan.abstracto.core.utils.ParseUtils;
+import dev.sheldan.abstracto.experience.model.*;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.database.LevelAction;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Role;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class RemoveRoleLevelAction implements LevelActionListener {
+
+    public static final String REMOVE_ROLE_ABOVE_LEVEL = "remove_role_above_level";
+
+    @Autowired
+    private Gson gson;
+
+    @Override
+    public void apply(AUserExperience userExperience, LevelAction levelAction, MemberActionModification container) {
+        RemoveRoleLevelActionPayload payload = (RemoveRoleLevelActionPayload) levelAction.getLoadedPayload();
+        log.info("Removing role {} from user {} in server {}.", payload.getRoleId(), userExperience.getUser().getUserReference().getId(), userExperience.getServer().getId());
+        container.getRolesToRemove().add(payload.getRoleId());
+        container.getRolesToAdd().remove(payload.getRoleId());
+    }
+
+
+    @Override
+    public void prepareAction(LevelAction levelAction) {
+        levelAction.setLoadedPayload(gson.fromJson(levelAction.getPayload(), RemoveRoleLevelActionPayload.class));
+    }
+
+    @Override
+    public LevelActionPayload createPayload(Guild guild, String input) {
+        Role role = ParseUtils.parseRoleFromText(input, guild);
+        return RemoveRoleLevelActionPayload
+                .builder()
+                .roleId(role.getIdLong())
+                .build();
+    }
+
+    @Override
+    public String getName() {
+        return REMOVE_ROLE_ABOVE_LEVEL;
+    }
+
+    @Override
+    public boolean shouldExecute(AUserExperience aUserExperience, LevelAction levelAction) {
+        return aUserExperience.getLevelOrDefault() >= levelAction.getLevel().getLevel();
+    }
+
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/model/AddMemberToChannelLevelActionPayload.java

@@ -0,0 +1,10 @@
+package dev.sheldan.abstracto.experience.model;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class AddMemberToChannelLevelActionPayload implements LevelActionPayload {
+    private Long channelId;
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/model/AddRoleLevelActionPayload.java

@@ -0,0 +1,10 @@
+package dev.sheldan.abstracto.experience.model;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class AddRoleLevelActionPayload implements LevelActionPayload {
+    private Long roleId;
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/model/RemoveMemberFromChannelLevelActionPayload.java

@@ -0,0 +1,10 @@
+package dev.sheldan.abstracto.experience.model;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class RemoveMemberFromChannelLevelActionPayload implements LevelActionPayload {
+    private Long channelId;
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/model/RemoveRoleLevelActionPayload.java

@@ -0,0 +1,10 @@
+package dev.sheldan.abstracto.experience.model;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class RemoveRoleLevelActionPayload implements LevelActionPayload {
+    private Long roleId;
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/repository/LevelActionRepository.java

@@ -0,0 +1,22 @@
+package dev.sheldan.abstracto.experience.repository;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.experience.model.database.AExperienceLevel;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.database.LevelAction;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface LevelActionRepository extends JpaRepository<LevelAction, Long> {
+    List<LevelAction> findByServerAndAffectedUserIsNullOrServerAndAffectedUser(AServer server, AServer server2, AUserExperience user);
+    Optional<LevelAction> findByServerAndActionAndLevelOrAffectedUserAndLevelAndAction(AServer server, String action, AExperienceLevel level, AUserExperience user, AExperienceLevel level2, String action2);
+    List<LevelAction> findByServer(AServer server);
+
+    void deleteByLevelAndActionAndServer(AExperienceLevel level, String action, AServer server);
+    void deleteByLevelAndActionAndAffectedUser(AExperienceLevel level, String action, AUserExperience affectedUser);
+
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/AUserExperienceServiceBean.java

@@ -104,6 +104,9 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     @Autowired
     private FeatureModeService featureModeService;
 
+    @Autowired
+    private LevelActionService levelActionService;
+
     @Autowired
     private AUserExperienceServiceBean self;
 
@@ -306,25 +309,26 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
             log.debug("User {} has a experience disable role in server {} - not giving any experience.", member.getIdLong(), serverId);
             return;
         }
-        List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
-        levels.sort(Comparator.comparing(AExperienceLevel::getExperienceNeeded));
-
-        Long minExp = configService.getLongValueOrConfigDefault(ExperienceFeatureConfig.MIN_EXP_KEY, serverId);
-        Long maxExp = configService.getLongValueOrConfigDefault(ExperienceFeatureConfig.MAX_EXP_KEY, serverId);
-        Double multiplier = configService.getDoubleValueOrConfigDefault(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverId);
-        Long experienceRange = maxExp - minExp + 1;
-        Long gainedExperience = (secureRandom.nextInt(experienceRange.intValue()) + minExp);
-        gainedExperience = (long) Math.floor(gainedExperience * multiplier);
-
-        List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
-        roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
-
         AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(member);
         Long userInServerId = userInAServer.getUserInServerId();
-        log.debug("Handling {}. The user might gain {}.", userInServerId, gainedExperience);
         Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInAServer.getUserInServerId());
         AUserExperience aUserExperience = aUserExperienceOptional.orElseGet(() -> userExperienceManagementService.createUserInServer(userInAServer));
         if(Boolean.FALSE.equals(aUserExperience.getExperienceGainDisabled())) {
+            List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
+            levels.sort(Comparator.comparing(AExperienceLevel::getExperienceNeeded));
+
+            Long minExp = configService.getLongValueOrConfigDefault(ExperienceFeatureConfig.MIN_EXP_KEY, serverId);
+            Long maxExp = configService.getLongValueOrConfigDefault(ExperienceFeatureConfig.MAX_EXP_KEY, serverId);
+            Double multiplier = configService.getDoubleValueOrConfigDefault(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverId);
+            Long experienceRange = maxExp - minExp + 1;
+            Long gainedExperience = (secureRandom.nextInt(experienceRange.intValue()) + minExp);
+            gainedExperience = (long) Math.floor(gainedExperience * multiplier);
+
+            List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
+            roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
+
+            log.debug("Handling {}. The user gains {}.", userInServerId, gainedExperience);
+
             Long oldExperience = aUserExperience.getExperience();
             Long newExperienceCount = oldExperience + gainedExperience;
             aUserExperience.setExperience(newExperienceCount);
@@ -332,7 +336,8 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
             RoleCalculationResult result = RoleCalculationResult
                     .builder()
                     .build();
-            if(!Objects.equals(newLevel.getLevel(), aUserExperience.getCurrentLevel().getLevel())) {
+            boolean userChangesLevel = !Objects.equals(newLevel.getLevel(), aUserExperience.getCurrentLevel().getLevel());
+            if(userChangesLevel) {
                 Integer oldLevel = aUserExperience.getCurrentLevel() != null ? aUserExperience.getCurrentLevel().getLevel() : 0;
                 log.info("User {} in server {} changed level. New {}, Old {}.", member.getIdLong(),
                         member.getGuild().getIdLong(), newLevel.getLevel(),
@@ -367,7 +372,17 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
                 aUserExperience.setCurrentExperienceRole(calculatedNewRole);
             }
             aUserExperience.setMessageCount(aUserExperience.getMessageCount() + 1L);
-            if(!aUserExperienceOptional.isPresent()) {
+            if(userChangesLevel && featureModeService.featureModeActive(ExperienceFeatureDefinition.EXPERIENCE, server, ExperienceFeatureMode.LEVEL_ACTION)) {
+                levelActionService.applyLevelActionsToUser(aUserExperience)
+                    .thenAccept(unused -> {
+                        log.info("Executed level actions for user {}.", userInServerId);
+                    })
+                    .exceptionally(throwable -> {
+                        log.warn("Failed to execute level actions for user {}.", userInServerId, throwable);
+                        return null;
+                    });
+            }
+            if(aUserExperienceOptional.isEmpty()) {
                 userExperienceManagementService.saveUser(aUserExperience);
             }
             if(!Objects.equals(result.getOldRoleId(), result.getNewRoleId())) {
@@ -375,7 +390,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
                     roleService.updateRolesIds(member, Arrays.asList(result.getOldRoleId()), Arrays.asList(result.getNewRoleId())).thenAccept(unused -> {
                         log.debug("Removed role {} from and added role {} to member {} in server {}.", result.getOldRoleId(), result.getNewRoleId(), member.getIdLong(), member.getGuild().getIdLong());
                     }).exceptionally(throwable -> {
-                        log.warn("Failed to remove role {} from and add role {} to  member {} in server {}.", result.getOldRoleId(), member.getIdLong(), member.getGuild().getIdLong(), throwable);
+                        log.warn("Failed to remove role {} from and add role {} to  member {} in server {}.", result.getOldRoleId(), result.getNewRoleId(), member.getIdLong(), member.getGuild().getIdLong(), throwable);
                         return null;
                     });
                 } else {
@@ -383,7 +398,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
                         roleService.removeRoleFromMemberAsync(member, result.getOldRoleId()).thenAccept(unused -> {
                             log.debug("Removed role {} from member {} in server {}.", result.getOldRoleId(), member.getIdLong(), member.getGuild().getIdLong());
                         }).exceptionally(throwable -> {
-                            log.warn("Failed to remove role {} from {} member {} in server {}.", result.getOldRoleId(), member.getIdLong(), member.getGuild().getIdLong(), throwable);
+                            log.warn("Failed to remove role {} from member {} in server {}.", result.getOldRoleId(), member.getIdLong(), member.getGuild().getIdLong(), throwable);
                             return null;
                         });
                     }
@@ -391,7 +406,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
                         roleService.addRoleToMemberAsync(member, result.getNewRoleId()).thenAccept(unused -> {
                             log.debug("Added role {} to member {} in server {}.", result.getNewRoleId(), member.getIdLong(), member.getGuild().getIdLong());
                         }).exceptionally(throwable -> {
-                            log.warn("Failed to add role {} to {} member {} in server {}.", result.getOldRoleId(), member.getIdLong(), member.getGuild().getIdLong(), throwable);
+                            log.warn("Failed to add role {} to member {} in server {}.", result.getOldRoleId(), member.getIdLong(), member.getGuild().getIdLong(), throwable);
                             return null;
                         });
                     }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/LevelActionServiceBean.java

@@ -0,0 +1,170 @@
+package dev.sheldan.abstracto.experience.service;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.GuildService;
+import dev.sheldan.abstracto.core.service.RoleService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.utils.CompletableFutureList;
+import dev.sheldan.abstracto.experience.listener.LevelActionListener;
+import dev.sheldan.abstracto.experience.listener.MemberActionModification;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.database.LevelAction;
+import dev.sheldan.abstracto.experience.model.template.LevelActionDisplay;
+import dev.sheldan.abstracto.experience.model.template.LevelActionsDisplay;
+import dev.sheldan.abstracto.experience.service.management.LevelActionManagementService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.Permission;
+import net.dv8tion.jda.api.entities.Guild;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@Component
+@Slf4j
+public class LevelActionServiceBean implements LevelActionService {
+
+    @Autowired
+    private LevelActionManagementService levelActionManagementService;
+
+    @Autowired(required = false)
+    private List<LevelActionListener> levelActions = new ArrayList<>();
+
+    @Autowired
+    private RoleService roleService;
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Autowired
+    private GuildService guildService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Override
+    public CompletableFuture<Void> applyLevelActionsToUser(AUserExperience user) {
+        if(levelActions == null || levelActions.isEmpty()) {
+            return CompletableFuture.completedFuture(null);
+        }
+        List<LevelAction> levelActionsOfUserInServer = levelActionManagementService.getLevelActionsOfUserInServer(user);
+        if(levelActionsOfUserInServer.isEmpty()) {
+            log.info("No actions available - no actions executed.");
+            return CompletableFuture.completedFuture(null);
+        }
+
+        Map<Integer, List<LevelAction>> actionConfigMap = new HashMap<>();
+
+        levelActionsOfUserInServer.forEach(levelAction -> {
+            if(levelAction.getLevel().getLevel() > user.getLevelOrDefault()) {
+                return;
+            }
+            if(actionConfigMap.containsKey(levelAction.getLevel().getLevel())) {
+                actionConfigMap.get(levelAction.getLevel().getLevel()).add(levelAction);
+            } else {
+                List<LevelAction> levelLevelActions = new ArrayList<>();
+                levelLevelActions.add(levelAction);
+                actionConfigMap.put(levelAction.getLevel().getLevel(), levelLevelActions);
+            }
+        });
+
+        Map<String, LevelActionListener> actionStringListenerMap = levelActions
+                .stream()
+                .collect(Collectors.toMap(a -> a.getName().toLowerCase(), Function.identity()));
+
+        List<Integer> levels = actionConfigMap
+                .keySet()
+                .stream()
+                .sorted()
+                .toList();
+
+        log.debug("Performing actions for {} levels.", levels.size());
+
+        MemberActionModification modification = MemberActionModification
+                .builder()
+                .build();
+        levels.forEach(level -> {
+            List<LevelAction> actionsOnLevel = actionConfigMap.get(level);
+            actionsOnLevel.forEach(levelAction -> {
+                LevelActionListener listener = actionStringListenerMap.get(levelAction.getAction().toLowerCase());
+                listener.prepareAction(levelAction);
+                listener.apply(user, levelAction, modification);
+            });
+        });
+
+        return evaluateModifications(user, modification);
+    }
+
+    private CompletableFuture<Void> evaluateModifications(AUserExperience user, MemberActionModification modification) {
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        Long userId = user.getUser().getUserReference().getId();
+        log.info("Updating user {}, rolesToAdd: {}, rolesToRemove: {}",
+                userId, modification.getRolesToAdd().size(), modification.getRolesToRemove().size());
+        if(!modification.getRolesToAdd().isEmpty() || !modification.getRolesToRemove().isEmpty()) {
+            CompletableFuture<Void> roleFuture = roleService.updateRolesIds(user.getUser(), new ArrayList<>(modification.getRolesToAdd()), new ArrayList<>(modification.getRolesToRemove()));
+            futures.add(roleFuture);
+        }
+        log.info("Updating user {}, channelsToAdd: {}, channelsToRemove: {}.", userId, modification.getChannelsToAdd().size(), modification.getChannelsToRemove().size());
+        Guild guild = guildService.getGuildById(user.getServer().getId());
+        EnumSet<Permission> permissions = EnumSet.of(Permission.VIEW_CHANNEL, Permission.MESSAGE_SEND);
+        modification.getChannelsToAdd().forEach(channelId -> {
+            futures.add(channelService.addMemberViewToChannel(guild, channelId, userId, permissions));
+        });
+        modification.getChannelsToRemove().forEach(channelId -> {
+            futures.add(channelService.removeChannelOverrideForMember(guild, channelId, userId));
+        });
+        if(!futures.isEmpty()) {
+            return new CompletableFutureList<>(futures).getMainFuture();
+        } else {
+            log.info("Actions resulted in no actions performed.");
+            return CompletableFuture.completedFuture(null);
+        }
+    }
+
+    @Override
+    public List<String> getAvailableLevelActions() {
+        return levelActions
+                .stream()
+                .map(LevelActionListener::getName)
+                .map(String::toLowerCase)
+                .toList();
+    }
+
+    @Override
+    public Optional<LevelActionListener> getLevelActionListenerForName(String name) {
+        return levelActions
+                .stream()
+                .filter(levelActionListener -> levelActionListener.getName().equalsIgnoreCase(name))
+                .findFirst();
+    }
+
+    @Override
+    public Optional<LevelAction> getLevelAction(AUserExperience userExperience, String action, Integer level) {
+        return Optional.empty();
+    }
+
+    @Override
+    public LevelActionsDisplay getLevelActionsToDisplay(Guild guild) {
+        AServer server = serverManagementService.loadServer(guild);
+        List<LevelActionDisplay> actions = levelActionManagementService.getLevelActionsOfServer(server)
+                .stream().map(levelAction -> LevelActionDisplay
+                        .builder()
+                        .actionKey(levelAction.getAction().toLowerCase())
+                        .level(levelAction.getLevel().getLevel())
+                        .parameters(levelAction.getPayload())
+                        .member(levelAction.getAffectedUser() != null ? MemberDisplay.fromAUserInAServer(levelAction.getAffectedUser().getUser()) : null)
+                        .build())
+                .toList();
+        return LevelActionsDisplay
+                .builder()
+                .actions(actions)
+                .build();
+    }
+
+
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/LevelActionManagementServiceBean.java

@@ -0,0 +1,75 @@
+package dev.sheldan.abstracto.experience.service.management;
+
+import com.google.gson.Gson;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.experience.model.LevelActionPayload;
+import dev.sheldan.abstracto.experience.model.database.AExperienceLevel;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.database.LevelAction;
+import dev.sheldan.abstracto.experience.repository.LevelActionRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Optional;
+
+@Component
+public class LevelActionManagementServiceBean implements LevelActionManagementService {
+
+    @Autowired
+    private LevelActionRepository levelActionRepository;
+
+    @Autowired
+    private ExperienceLevelManagementService experienceLevelManagementService;
+
+    @Autowired
+    private Gson gson;
+
+    @Override
+    public LevelAction createLevelAction(Integer level, AServer server, String action, AUserExperience user, String payload) {
+        AExperienceLevel experienceLevel = experienceLevelManagementService.getLevel(level);
+        LevelAction levelAction = LevelAction
+                .builder()
+                .action(action)
+                .affectedUser(user)
+                .payload(payload)
+                .server(server)
+                .level(experienceLevel)
+                .build();
+        return levelActionRepository.save(levelAction);
+    }
+
+    @Override
+    public void deleteLevelAction(Integer level, AServer server, String action, AUserExperience user) {
+        AExperienceLevel experienceLevel = experienceLevelManagementService.getLevel(level);
+        if(user == null) {
+            levelActionRepository.deleteByLevelAndActionAndServer(experienceLevel, action, server);
+        } else {
+            levelActionRepository.deleteByLevelAndActionAndAffectedUser(experienceLevel, action, user);
+        }
+    }
+
+    @Override
+    public LevelAction createLevelAction(Integer level, AServer server, String action, AUserExperience user, LevelActionPayload actionPayload) {
+        String payload = gson.toJson(actionPayload);
+        return createLevelAction(level, server, action, user, payload);
+    }
+
+    @Override
+    public List<LevelAction> getLevelActionsOfUserInServer(AUserExperience aUserInAServer) {
+        return levelActionRepository.findByServerAndAffectedUserIsNullOrServerAndAffectedUser(aUserInAServer.getServer(),
+                aUserInAServer.getServer(), aUserInAServer);
+    }
+
+    @Override
+    public List<LevelAction> getLevelActionsOfServer(AServer server) {
+        return levelActionRepository.findByServer(server);
+    }
+
+    @Override
+    public Optional<LevelAction> getLevelAction(String action, Integer level, AServer server, AUserExperience aUserExperience) {
+        AExperienceLevel experienceLevel = experienceLevelManagementService.getLevel(level);
+        return levelActionRepository.findByServerAndActionAndLevelOrAffectedUserAndLevelAndAction(server, action.toLowerCase(),
+                experienceLevel, aUserExperience, experienceLevel, action.toLowerCase());
+    }
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/resources/experience-config.properties

@@ -13,4 +13,8 @@ abstracto.systemConfigs.expCooldownSeconds.longValue=60
 
 abstracto.featureModes.levelUpNotification.featureName=experience
 abstracto.featureModes.levelUpNotification.mode=levelUpNotification
-abstracto.featureModes.levelUpNotification.enabled=false
+abstracto.featureModes.levelUpNotification.enabled=false
+
+abstracto.featureModes.levelAction.featureName=experience
+abstracto.featureModes.levelAction.mode=levelAction
+abstracto.featureModes.levelAction.enabled=false

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/resources/migrations/1.5.26/collection.xml

@@ -0,0 +1,7 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                     xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.26.xsd" >
+    <include file="tables/tables.xml" relativeToChangelogFile="true"/>
+    <include file="seedData/data.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/resources/migrations/1.5.26/seedData/command.xml

@@ -0,0 +1,25 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                     xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.26.xsd" >
+    <property name="experienceModule" value="(SELECT id FROM module WHERE name = 'experience')"/>
+    <property name="experienceFeature" value="(SELECT id FROM feature WHERE key = 'experience')"/>
+    <changeSet  author="Sheldan" id="experience-levelAction-commands">
+        <insert tableName="command">
+            <column name="name" value="addLevelAction"/>
+            <column name="module_id" valueComputed="${experienceModule}"/>
+            <column name="feature_id" valueComputed="${experienceFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="removeLevelAction"/>
+            <column name="module_id" valueComputed="${experienceModule}"/>
+            <column name="feature_id" valueComputed="${experienceFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="showLevelActions"/>
+            <column name="module_id" valueComputed="${experienceModule}"/>
+            <column name="feature_id" valueComputed="${experienceFeature}"/>
+        </insert>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/resources/migrations/1.5.26/seedData/data.xml

@@ -0,0 +1,6 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                     xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.26.xsd" >
+    <include file="command.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/resources/migrations/1.5.26/tables/level_action.xml

@@ -0,0 +1,49 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                     xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.26.xsd" >
+    <changeSet author="Sheldan" id="level_action-table">
+        <createTable tableName="level_action">
+            <column name="id" type="BIGINT" autoIncrement="true">
+                <constraints nullable="false" primaryKey="true" primaryKeyName="pk_level_action"/>
+            </column>
+            <column name="action" type="VARCHAR(128)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="payload" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="affected_user_id" type="BIGINT">
+                <constraints nullable="true"/>
+            </column>
+            <column name="created" type="TIMESTAMP WITHOUT TIME ZONE">
+                <constraints nullable="false"/>
+            </column>
+            <column name="updated" type="TIMESTAMP WITHOUT TIME ZONE"/>
+            <column name="level_id" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="server_id" type="BIGINT">
+                <constraints nullable="false"/>
+            </column>
+        </createTable>
+        <addForeignKeyConstraint baseColumnNames="level_id" baseTableName="level_action" constraintName="fk_level_action_level" deferrable="false"
+                                 initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="level"
+                                 referencedTableName="experience_level" validate="true"/>
+        <addForeignKeyConstraint baseColumnNames="affected_user_id" baseTableName="level_action" constraintName="fk_level_action_user" deferrable="false"
+                                 initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="id"
+                                 referencedTableName="user_experience" validate="true"/>
+        <addForeignKeyConstraint baseColumnNames="server_id" baseTableName="level_action" constraintName="fk_level_action_server" deferrable="false"
+                                 initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="id" referencedTableName="server"
+                                 validate="true"/>
+        <sql>
+            DROP TRIGGER IF EXISTS level_action_update_trigger ON level_action;
+            CREATE TRIGGER level_action_update_trigger BEFORE UPDATE ON level_action FOR EACH ROW EXECUTE PROCEDURE update_trigger_procedure();
+        </sql>
+        <sql>
+            DROP TRIGGER IF EXISTS level_action_insert_trigger ON level_action;
+            CREATE TRIGGER level_action_insert_trigger BEFORE INSERT ON level_action FOR EACH ROW EXECUTE PROCEDURE insert_trigger_procedure();
+        </sql>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/resources/migrations/1.5.26/tables/tables.xml

@@ -0,0 +1,8 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                     xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.26.xsd" >
+
+    <include file="level_action.xml" relativeToChangelogFile="true"/>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/resources/migrations/experience-changeLog.xml

@@ -6,4 +6,5 @@
     <include file="1.2.15/collection.xml" relativeToChangelogFile="true"/>
     <include file="1.4.8/collection.xml" relativeToChangelogFile="true"/>
     <include file="1.4.17/collection.xml" relativeToChangelogFile="true"/>
+    <include file="1.5.26/collection.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>experience-tracking</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/config/ExperienceFeatureConfig.java

@@ -8,6 +8,7 @@ import org.springframework.stereotype.Component;
 import java.util.Arrays;
 import java.util.List;
 
+import static dev.sheldan.abstracto.experience.config.ExperienceFeatureMode.LEVEL_ACTION;
 import static dev.sheldan.abstracto.experience.config.ExperienceFeatureMode.LEVEL_UP_NOTIFICATION;
 
 /**
@@ -46,6 +47,6 @@ public class ExperienceFeatureConfig implements FeatureConfig {
 
     @Override
     public List<FeatureMode> getAvailableModes() {
-        return Arrays.asList(LEVEL_UP_NOTIFICATION);
+        return Arrays.asList(LEVEL_UP_NOTIFICATION, LEVEL_ACTION);
     }
 }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/config/ExperienceFeatureMode.java

@@ -5,7 +5,8 @@ import lombok.Getter;
 
 @Getter
 public enum ExperienceFeatureMode implements FeatureMode {
-    LEVEL_UP_NOTIFICATION("levelUpNotification");
+    LEVEL_UP_NOTIFICATION("levelUpNotification"),
+    LEVEL_ACTION("levelAction");
 
     private final String key;
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/exception/LevelActionNotFoundException.java

@@ -0,0 +1,21 @@
+package dev.sheldan.abstracto.experience.exception;
+
+import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
+import dev.sheldan.abstracto.core.templating.Templatable;
+
+public class LevelActionNotFoundException extends AbstractoRunTimeException implements Templatable {
+
+    public LevelActionNotFoundException() {
+        super("Level action not found.");
+    }
+
+    @Override
+    public String getTemplateName() {
+        return "level_action_not_found_exception";
+    }
+
+    @Override
+    public Object getTemplateModel() {
+        return new Object();
+    }
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/listener/LevelActionListener.java

@@ -0,0 +1,21 @@
+package dev.sheldan.abstracto.experience.listener;
+
+import dev.sheldan.abstracto.experience.model.LevelActionPayload;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.database.LevelAction;
+import net.dv8tion.jda.api.entities.Guild;
+import org.springframework.stereotype.Component;
+
+@Component
+public interface LevelActionListener {
+    String getName();
+
+    void apply(AUserExperience userExperience, LevelAction levelAction, MemberActionModification container);
+
+    boolean shouldExecute(AUserExperience aUserExperience, LevelAction levelAction);
+
+    void prepareAction(LevelAction levelAction);
+
+
+    LevelActionPayload createPayload(Guild guild, String input);
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/listener/MemberActionModification.java

@@ -0,0 +1,23 @@
+package dev.sheldan.abstracto.experience.listener;
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.HashSet;
+import java.util.Set;
+
+@Getter
+@Builder
+public class MemberActionModification {
+    @Builder.Default
+    private Set<Long> rolesToRemove = new HashSet<>();
+
+    @Builder.Default
+    private Set<Long> rolesToAdd =  new HashSet<>();
+
+    @Builder.Default
+    private Set<Long> channelsToRemove =  new HashSet<>();
+
+    @Builder.Default
+    private Set<Long> channelsToAdd =  new HashSet<>();
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/model/LevelActionPayload.java

@@ -0,0 +1,4 @@
+package dev.sheldan.abstracto.experience.model;
+
+public interface LevelActionPayload {
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/model/database/LevelAction.java

@@ -0,0 +1,53 @@
+package dev.sheldan.abstracto.experience.model.database;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.experience.model.LevelActionPayload;
+import jakarta.persistence.*;
+import lombok.*;
+
+import java.time.Instant;
+
+@Builder
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "level_action")
+@Getter
+@Setter
+@EqualsAndHashCode
+public class LevelAction {
+
+    @Id
+    @Column(name = "id", nullable = false)
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "level_id", nullable = false)
+    private AExperienceLevel level;
+
+    @Column(name = "action", nullable = false)
+    private String action;
+
+    @Column(name = "payload", nullable = false)
+    private String payload;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "affected_user_id")
+    private AUserExperience affectedUser;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "server_id", nullable = false)
+    private AServer server;
+
+    @Column(name = "created", nullable = false, insertable = false, updatable = false)
+    private Instant created;
+
+    @Column(name = "updated", insertable = false, updatable = false)
+    private Instant updated;
+
+    @Builder.Default
+    @Transient
+    private LevelActionPayload loadedPayload = null;
+
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/model/template/LevelActionDisplay.java

@@ -0,0 +1,14 @@
+package dev.sheldan.abstracto.experience.model.template;
+
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class LevelActionDisplay {
+    private String actionKey;
+    private Integer level;
+    private MemberDisplay member;
+    private String parameters;
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/model/template/LevelActionsDisplay.java

@@ -0,0 +1,12 @@
+package dev.sheldan.abstracto.experience.model.template;
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+@Builder
+public class LevelActionsDisplay {
+    private List<LevelActionDisplay> actions;
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/service/LevelActionService.java

@@ -0,0 +1,21 @@
+package dev.sheldan.abstracto.experience.service;
+
+import dev.sheldan.abstracto.experience.listener.LevelActionListener;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.database.LevelAction;
+import dev.sheldan.abstracto.experience.model.template.LevelActionsDisplay;
+import net.dv8tion.jda.api.entities.Guild;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+public interface LevelActionService {
+    CompletableFuture<Void> applyLevelActionsToUser(AUserExperience user);
+    List<String> getAvailableLevelActions();
+    Optional<LevelActionListener> getLevelActionListenerForName(String name);
+
+    Optional<LevelAction> getLevelAction(AUserExperience userExperience, String action, Integer level);
+
+    LevelActionsDisplay getLevelActionsToDisplay(Guild guild);
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/service/management/LevelActionManagementService.java

@@ -0,0 +1,20 @@
+package dev.sheldan.abstracto.experience.service.management;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.experience.model.LevelActionPayload;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.database.LevelAction;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface LevelActionManagementService {
+    LevelAction createLevelAction(Integer level, AServer server, String action, AUserExperience user, String parameters);
+    void deleteLevelAction(Integer level, AServer server, String action, AUserExperience user);
+    LevelAction createLevelAction(Integer level, AServer server, String action, AUserExperience user, LevelActionPayload actionPayload);
+
+    List<LevelAction> getLevelActionsOfUserInServer(AUserExperience aUserInAServer);
+    List<LevelAction> getLevelActionsOfServer(AServer server);
+
+    Optional<LevelAction> getLevelAction(String action, Integer level, AServer server, AUserExperience aUserExperience);
+}

abstracto-application/abstracto-modules/experience-tracking/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>abstracto-modules</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/giveaway/giveaway-impl/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>giveaway</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
 
     <artifactId>giveaway-impl</artifactId>

abstracto-application/abstracto-modules/giveaway/giveaway-int/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>giveaway</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
 
     <artifactId>giveaway-int</artifactId>

abstracto-application/abstracto-modules/giveaway/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>abstracto-modules</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
 
     <artifactId>giveaway</artifactId>

abstracto-application/abstracto-modules/image-generation/image-generation-impl/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <artifactId>image-generation</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
 
     <artifactId>image-generation-impl</artifactId>

abstracto-application/abstracto-modules/image-generation/image-generation-int/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <artifactId>image-generation</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
 
     <artifactId>image-generation-int</artifactId>

abstracto-application/abstracto-modules/image-generation/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>abstracto-modules</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
 
     <artifactId>image-generation</artifactId>

abstracto-application/abstracto-modules/invite-filter/invite-filter-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>invite-filter</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/invite-filter/invite-filter-impl/src/main/java/dev/sheldan/abstracto/invitefilter/service/InviteLinkFilterServiceBean.java

@@ -21,6 +21,8 @@ import dev.sheldan.abstracto.invitefilter.model.template.listener.DeletedInvite;
 import dev.sheldan.abstracto.invitefilter.model.template.listener.DeletedInvitesNotificationModel;
 import dev.sheldan.abstracto.invitefilter.service.management.AllowedInviteLinkManagement;
 import dev.sheldan.abstracto.invitefilter.service.management.FilteredInviteLinkManagement;
+import dev.sheldan.abstracto.moderation.model.ModerationActionButton;
+import dev.sheldan.abstracto.moderation.service.ModerationActionService;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
@@ -78,6 +80,9 @@ public class InviteLinkFilterServiceBean implements InviteLinkFilterService {
     @Autowired
     private RoleImmunityService roleImmunityService;
 
+    @Autowired(required = false)
+    private ModerationActionService moderationActionService;
+
     private static final Pattern INVITE_CODE_PATTERN = Pattern.compile("(?<code>[a-z0-9-]+)", Pattern.CASE_INSENSITIVE);
 
     public static final String INVITE_FILTER_METRIC = "invite.filter";
@@ -230,10 +235,18 @@ public class InviteLinkFilterServiceBean implements InviteLinkFilterService {
             log.info("Post target {} not defined for server {} - not sending invite link deletion notification.", InviteFilterPostTarget.INVITE_DELETE_LOG.getKey(), serverId);
             return CompletableFuture.completedFuture(null);
         }
+        boolean moderationActionsEnabled = featureModeService.featureModeActive(InviteFilterFeatureDefinition.INVITE_FILTER, serverId, InviteFilterMode.FILTER_MODERATION_ACTIONS);
+        List<ModerationActionButton> moderationActionComponents = new ArrayList<>();
+        if(moderationActionsEnabled && moderationActionService != null) {
+            ServerUser reportedServerUser = ServerUser.fromMember(message.getMember());
+            List<ModerationActionButton> moderationActions = moderationActionService.getModerationActionButtons(reportedServerUser);
+            moderationActionComponents.addAll(moderationActions);
+        }
         DeletedInvitesNotificationModel model = DeletedInvitesNotificationModel
                 .builder()
                 .author(message.getMember())
                 .guild(message.getGuild())
+                .moderationActionComponents(moderationActionComponents)
                 .message(message)
                 .channel(message.getChannel())
                 .invites(groupInvites(codes))

abstracto-application/abstracto-modules/invite-filter/invite-filter-impl/src/main/resources/invite-filter-config.properties

@@ -11,3 +11,6 @@ abstracto.featureModes.filterNotifications.featureName=inviteFilter
 abstracto.featureModes.filterNotifications.mode=filterNotifications
 abstracto.featureModes.filterNotifications.enabled=true
 
+abstracto.featureModes.filterModerationActions.featureName=inviteFilter
+abstracto.featureModes.filterModerationActions.mode=filterModerationActions
+abstracto.featureModes.filterModerationActions.enabled=false

abstracto-application/abstracto-modules/invite-filter/invite-filter-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>invite-filter</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -15,6 +15,12 @@
             <artifactId>core-int</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>dev.sheldan.abstracto.modules</groupId>
+            <artifactId>moderation-int</artifactId>
+            <version>1.5.27-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
 
 </project>

abstracto-application/abstracto-modules/invite-filter/invite-filter-int/src/main/java/dev/sheldan/abstracto/invitefilter/config/InviteFilterFeatureConfig.java

@@ -23,6 +23,6 @@ public class InviteFilterFeatureConfig implements FeatureConfig {
 
     @Override
     public List<FeatureMode> getAvailableModes() {
-        return Arrays.asList(InviteFilterMode.FILTER_NOTIFICATIONS, InviteFilterMode.TRACK_USES);
+        return Arrays.asList(InviteFilterMode.values());
     }
 }

abstracto-application/abstracto-modules/invite-filter/invite-filter-int/src/main/java/dev/sheldan/abstracto/invitefilter/config/InviteFilterMode.java

@@ -5,7 +5,7 @@ import lombok.Getter;
 
 @Getter
 public enum InviteFilterMode implements FeatureMode {
-    TRACK_USES("trackUses"), FILTER_NOTIFICATIONS("filterNotifications");
+    TRACK_USES("trackUses"), FILTER_NOTIFICATIONS("filterNotifications"), FILTER_MODERATION_ACTIONS("filterModerationActions");
 
     private final String key;
 

abstracto-application/abstracto-modules/invite-filter/invite-filter-int/src/main/java/dev/sheldan/abstracto/invitefilter/model/template/listener/DeletedInvitesNotificationModel.java

@@ -1,5 +1,6 @@
 package dev.sheldan.abstracto.invitefilter.model.template.listener;
 
+import dev.sheldan.abstracto.moderation.model.ModerationActionButton;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
@@ -17,4 +18,5 @@ public class DeletedInvitesNotificationModel {
     private Member author;
     private Message message;
     private List<DeletedInvite> invites;
+    private List<ModerationActionButton> moderationActionComponents;
 }

abstracto-application/abstracto-modules/invite-filter/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/link-embed/link-embed-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>link-embed</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/link-embed/link-embed-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>link-embed</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/link-embed/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/logging/logging-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>logging</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/logging/logging-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>logging</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/logging/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/moderation/moderation-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>moderation</artifactId>
-        <version>1.5.25</version>
+        <version>1.5.27-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Ban.java

@@ -8,7 +8,7 @@ import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
-import dev.sheldan.abstracto.core.service.ChannelService;
+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.ParseUtils;
@@ -70,7 +70,7 @@ public class Ban extends AbstractConditionableCommand {
         }
         if(slashCommandParameterService.hasCommandOptionWithFullType(USER_PARAMETER, event, OptionType.USER)) {
             Member member = slashCommandParameterService.getCommandOption(USER_PARAMETER, event, User.class, Member.class);
-            return banService.banUserWithNotification(member.getUser(), reason, event.getMember(), duration)
+            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());
@@ -84,7 +84,7 @@ public class Ban extends AbstractConditionableCommand {
             String userIdStr = slashCommandParameterService.getCommandOption(USER_PARAMETER, event, User.class, String.class);
             Long userId = Long.parseLong(userIdStr);
             return userService.retrieveUserForId(userId)
-                    .thenCompose(user -> banService.banUserWithNotification(user, reason, event.getMember(), duration))
+                    .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());

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Kick.java

@@ -2,20 +2,21 @@ package dev.sheldan.abstracto.moderation.command;
 
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.condition.CommandCondition;
-import dev.sheldan.abstracto.core.command.config.*;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.EffectConfig;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.exception.EntityGuildMismatchException;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
 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.model.template.command.KickLogModel;
 import dev.sheldan.abstracto.moderation.service.KickServiceBean;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -47,30 +48,6 @@ public class Kick extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        Member member = (Member) parameters.get(0);
-        if(!member.getGuild().equals(commandContext.getGuild())) {
-            throw new EntityGuildMismatchException();
-        }
-        String defaultReason = templateService.renderSimpleTemplate(KICK_DEFAULT_REASON_TEMPLATE, commandContext.getGuild().getIdLong());
-        String reason = parameters.size() == 2 ? (String) parameters.get(1) : defaultReason;
-
-        KickLogModel kickLogModel = KickLogModel
-                .builder()
-                .kickedUser(member)
-                .reason(reason)
-                .guild(commandContext.getGuild())
-                .channel(commandContext.getChannel())
-                .member(commandContext.getAuthor())
-                .build();
-        kickLogModel.setKickedUser(member);
-        kickLogModel.setReason(reason);
-        return kickService.kickMember(member, reason, kickLogModel)
-                .thenApply(aVoid -> CommandResult.fromSuccess());
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Member member = slashCommandParameterService.getCommandOption(USER_PARAMETER, event, Member.class);
@@ -84,17 +61,7 @@ public class Kick extends AbstractConditionableCommand {
             reason = templateService.renderSimpleTemplate(KICK_DEFAULT_REASON_TEMPLATE, event.getGuild().getIdLong());
         }
 
-        KickLogModel kickLogModel = KickLogModel
-                .builder()
-                .kickedUser(member)
-                .reason(reason)
-                .guild(event.getGuild())
-                .channel(event.getGuildChannel())
-                .member(event.getMember())
-                .build();
-        kickLogModel.setKickedUser(member);
-        kickLogModel.setReason(reason);
-        return kickService.kickMember(member, reason, kickLogModel)
+        return kickService.kickMember(member, event.getMember(), reason)
                 .thenCompose(unused -> interactionService.replyEmbed(KICK_RESPONSE, event))
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
@@ -143,6 +110,7 @@ public class Kick extends AbstractConditionableCommand {
                 .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .async(true)
+                .slashCommandOnly(true)
                 .effects(effectConfig)
                 .causesReaction(true)
                 .parameters(parameters)

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Mute.java

@@ -10,12 +10,17 @@ import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParame
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 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.service.ChannelService;
+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.core.utils.ParseUtils;
+import dev.sheldan.abstracto.core.utils.SnowflakeUtils;
 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.model.template.command.MuteContext;
 import dev.sheldan.abstracto.moderation.service.MuteService;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
@@ -24,17 +29,18 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.time.Duration;
-import java.time.Instant;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
+import static dev.sheldan.abstracto.moderation.model.MuteResult.NOTIFICATION_FAILED;
 import static dev.sheldan.abstracto.moderation.service.MuteService.MUTE_EFFECT_KEY;
 
 @Component
 public class Mute extends AbstractConditionableCommand {
 
     private static final String MUTE_DEFAULT_REASON_TEMPLATE = "mute_default_reason";
+    public static final String MUTE_NOTIFICATION_NOT_POSSIBLE_TEMPLATE_KEY = "mute_notification_not_possible";
     private static final String DURATION_PARAMETER = "duration";
     private static final String MUTE_COMMAND = "mute";
     private static final String USER_PARAMETER = "user";
@@ -53,6 +59,9 @@ public class Mute extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
+    @Autowired
+    private ChannelService channelService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
@@ -64,15 +73,19 @@ public class Mute extends AbstractConditionableCommand {
         Duration duration = (Duration) parameters.get(1);
         String defaultReason = templateService.renderSimpleTemplate(MUTE_DEFAULT_REASON_TEMPLATE, guild.getIdLong());
         String reason = parameters.size() == 3 ? (String) parameters.get(2) : defaultReason;
-        MuteContext muteLogModel = MuteContext
-                .builder()
-                .muteTargetDate(Instant.now().plus(duration))
-                .mutedUser(member)
-                .channelId(commandContext.getChannel().getIdLong())
-                .reason(reason)
-                .mutingUser(commandContext.getAuthor())
-                .build();
-        return muteService.muteMemberWithLog(muteLogModel)
+        ServerUser userToMute = ServerUser.fromMember(member);
+        ServerUser mutingUser = ServerUser.fromMember(commandContext.getAuthor());
+        Long serverId = commandContext.getGuild().getIdLong();
+        ServerChannelMessage serverChannelMessage = ServerChannelMessage.fromMessage(commandContext.getMessage());
+        return muteService.muteMemberWithLog(userToMute, mutingUser, reason, duration, commandContext.getGuild(), serverChannelMessage)
+                .thenCompose(muteResult -> {
+                    if(muteResult == NOTIFICATION_FAILED) {
+                        MessageToSend errorNotification = templateService.renderEmbedTemplate(MUTE_NOTIFICATION_NOT_POSSIBLE_TEMPLATE_KEY, new Object(), serverId);
+                        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(errorNotification, commandContext.getChannel()));
+                    } else {
+                        return CompletableFuture.completedFuture(null);
+                    }
+                })
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 
@@ -88,16 +101,23 @@ public class Mute extends AbstractConditionableCommand {
         } else {
             reason = templateService.renderSimpleTemplate(MUTE_DEFAULT_REASON_TEMPLATE, guild.getIdLong());
         }
-        MuteContext muteLogModel = MuteContext
+        Long serverId = event.getGuild().getIdLong();
+        ServerChannelMessage commandMessage = ServerChannelMessage
                 .builder()
-                .muteTargetDate(Instant.now().plus(duration))
-                .mutedUser(targetMember)
-                .reason(reason)
+                .serverId(serverId)
                 .channelId(event.getChannel().getIdLong())
-                .mutingUser(event.getMember())
+                .messageId(SnowflakeUtils.createSnowFlake())
                 .build();
-        return muteService.muteMemberWithLog(muteLogModel)
-                .thenCompose(unused -> interactionService.replyEmbed(MUTE_RESPONSE, event))
+        ServerUser userToMute = ServerUser.fromMember(targetMember);
+        ServerUser mutingUser = ServerUser.fromMember(event.getMember());
+        return 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);
+                    } else {
+                        return interactionService.replyEmbed(MUTE_RESPONSE, event);
+                    }
+                })
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/UnBan.java

@@ -11,6 +11,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 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.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
@@ -50,7 +51,7 @@ public class UnBan extends AbstractConditionableCommand {
         String userIdStr = (String) parameters.get(0);
         Long userId = Long.parseLong(userIdStr);
         return userService.retrieveUserForId(userId)
-                .thenCompose(user -> banService.unBanUserWithNotification(user, commandContext.getAuthor()))
+                .thenCompose(user -> banService.unBanUserWithNotification(userId, ServerUser.fromMember(commandContext.getAuthor()), commandContext.getGuild()))
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 
@@ -59,7 +60,7 @@ public class UnBan extends AbstractConditionableCommand {
         String userIdStr = slashCommandParameterService.getCommandOption(USER_PARAMETER, event, String.class);
         Long userId = Long.parseLong(userIdStr);
         return userService.retrieveUserForId(userId)
-                .thenCompose(user -> banService.unBanUserWithNotification(user, event.getMember()))
+                .thenCompose(user -> banService.unBanUserWithNotification(userId, ServerUser.fromMember(event.getMember()), event.getGuild()))
                 .thenCompose(unused -> interactionService.replyEmbed(UN_BAN_RESPONSE, event))
                 .thenApply(interactionHook -> CommandResult.fromSuccess());
     }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/UnMute.java

@@ -11,7 +11,7 @@ import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParame
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.exception.EntityGuildMismatchException;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
-import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
@@ -52,8 +52,9 @@ public class UnMute extends AbstractConditionableCommand {
         if(!member.getGuild().equals(commandContext.getGuild())) {
             throw new EntityGuildMismatchException();
         }
-        AUserInAServer userToUnMute = userInServerManagementService.loadOrCreateUser(member);
-        return muteService.unMuteUser(userToUnMute, commandContext.getAuthor()).thenApply(aVoid ->
+        ServerUser userToUnmute = ServerUser.fromMember(member);
+        ServerUser unMutingMember = ServerUser.fromMember(commandContext.getAuthor());
+        return muteService.unMuteUser(userToUnmute, unMutingMember, commandContext.getGuild()).thenApply(aVoid ->
             CommandResult.fromSuccess()
         );
     }
@@ -64,8 +65,9 @@ public class UnMute extends AbstractConditionableCommand {
         if(!targetMember.getGuild().equals(event.getGuild())) {
             throw new EntityGuildMismatchException();
         }
-        AUserInAServer userToUnMute = userInServerManagementService.loadOrCreateUser(targetMember);
-        return muteService.unMuteUser(userToUnMute, event.getMember())
+        ServerUser userToUnmute = ServerUser.fromMember(targetMember);
+        ServerUser unMutingMember = ServerUser.fromMember(event.getMember());
+        return muteService.unMuteUser(userToUnmute, unMutingMember, event.getGuild())
                 .thenCompose(unused -> interactionService.replyEmbed(UN_MUTE_RESPONSE, event))
                 .thenApply(interactionHook -> CommandResult.fromSuccess());
     }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/Warn.java

@@ -10,10 +10,12 @@ import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParame
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 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.SnowflakeUtils;
 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.model.template.command.WarnContext;
 import dev.sheldan.abstracto.moderation.service.WarnService;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import lombok.extern.slf4j.Slf4j;
@@ -59,16 +61,8 @@ public class Warn extends AbstractConditionableCommand {
         }
         String defaultReason = templateService.renderSimpleTemplate(WARN_DEFAULT_REASON_TEMPLATE, commandContext.getGuild().getIdLong());
         String reason = parameters.size() == 2 ? (String) parameters.get(1) : defaultReason;
-        WarnContext warnLogModel = WarnContext
-                .builder()
-                .reason(reason)
-                .warnedMember(member)
-                .channel(commandContext.getChannel())
-                .member(commandContext.getAuthor())
-                .guild(commandContext.getGuild())
-                .message(commandContext.getMessage())
-                .build();
-        return warnService.warnUserWithLog(warnLogModel)
+        ServerChannelMessage commandMessage = ServerChannelMessage.fromMessage(commandContext.getMessage());
+        return warnService.warnUserWithLog(commandContext.getGuild(), ServerUser.fromMember(member), ServerUser.fromMember(commandContext.getAuthor()), reason, commandMessage)
                 .thenApply(warning -> CommandResult.fromSuccess());
     }
 
@@ -84,15 +78,13 @@ public class Warn extends AbstractConditionableCommand {
         } else {
             reason = templateService.renderSimpleTemplate(WARN_DEFAULT_REASON_TEMPLATE, event.getGuild().getIdLong());
         }
-        WarnContext warnLogModel = WarnContext
+        ServerChannelMessage commandMessage = ServerChannelMessage
                 .builder()
-                .reason(reason)
-                .warnedMember(member)
-                .member(event.getMember())
-                .channel(event.getGuildChannel())
-                .guild(event.getGuild())
+                .serverId(event.getGuild().getIdLong())
+                .channelId(event.getChannel().getIdLong())
+                .messageId(SnowflakeUtils.createSnowFlake())
                 .build();
-        return warnService.warnUserWithLog(warnLogModel)
+        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());
     }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/BanModerationActionListener.java

@@ -0,0 +1,114 @@
+package dev.sheldan.abstracto.moderation.listener;
+
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.interaction.ComponentPayloadManagementService;
+import dev.sheldan.abstracto.core.interaction.ComponentService;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListener;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerModel;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerResult;
+import dev.sheldan.abstracto.core.interaction.modal.ModalConfigPayload;
+import dev.sheldan.abstracto.core.interaction.modal.ModalService;
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.model.interaction.ModerationActionBanPayload;
+import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionBanModalModel;
+import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionPayloadModel;
+import dev.sheldan.abstracto.moderation.service.ModerationActionServiceBean;
+import jakarta.transaction.Transactional;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class BanModerationActionListener implements ButtonClickedListener {
+
+    @Autowired
+    private ModalService modalService;
+
+    @Autowired
+    private ComponentService componentService;
+
+    @Autowired
+    private ComponentPayloadManagementService componentPayloadManagementService;
+
+    @Autowired
+    private BanModerationActionListener self;
+
+    private static final String BAN_REASON_MODERATION_ACTION_MODAL = "moderationAction_ban";
+    public static final String BAN_MODAL_ORIGIN = "BAN_MODERATION_ACTION_ORIGIN";
+
+    @Override
+    public ButtonClickedListenerResult execute(ButtonClickedListenerModel model) {
+        ModerationActionPayloadModel payload = (ModerationActionPayloadModel) model.getDeserializedPayload();
+        if(ModerationActionServiceBean.BAN_ACTION.equals(payload.getAction())) {
+            log.info("Handling ban button interaction by user {} in server {} for user {}.",
+                    payload.getUser().getUserId(), payload.getUser().getServerId(), model.getEvent().getMember().getIdLong());
+            String modalId = componentService.generateComponentId();
+            String reasonInputId = componentService.generateComponentId();
+            String durationInputId = componentService.generateComponentId();
+            ModerationActionBanModalModel modalModel = ModerationActionBanModalModel
+                    .builder()
+                    .modalId(modalId)
+                    .durationComponentId(durationInputId)
+                    .reasonComponentId(reasonInputId)
+                    .build();
+            modalService.replyModal(model.getEvent(), BAN_REASON_MODERATION_ACTION_MODAL, modalModel).thenAccept(unused -> {
+                log.info("Returned ban reason moderation action modal for user {} towards user {} in server {}.",
+                        payload.getUser().getUserId(), model.getEvent().getMember().getIdLong(), model.getServerId());
+                self.persistBanModerationActionPayload(payload.getUser(), reasonInputId, modalId);
+            }).exceptionally(throwable -> {
+                log.error("Failed to show modal for ban moderation action.", throwable);
+                return null;
+            });
+            return ButtonClickedListenerResult.ACKNOWLEDGED;
+        } else {
+            return ButtonClickedListenerResult.IGNORED;
+
+        }
+    }
+
+    @Transactional
+    public void persistBanModerationActionPayload(ServerUser userToBan, String reasonInput, String modalId) {
+        ModerationActionBanPayload payload = ModerationActionBanPayload
+                .builder()
+                .bannedUserId(userToBan.getUserId())
+                .serverId(userToBan.getServerId())
+                .reasonInputId(reasonInput)
+                .modalId(modalId)
+                .build();
+        ModalConfigPayload payloadConfig = ModalConfigPayload
+                .builder()
+                .modalPayload(payload)
+                .origin(BAN_MODAL_ORIGIN)
+                .payloadType(payload.getClass())
+                .modalId(modalId)
+                .build();
+        componentPayloadManagementService.createModalPayload(payloadConfig, userToBan.getServerId());
+    }
+
+    @Override
+    public Boolean handlesEvent(ButtonClickedListenerModel model) {
+        if(ModerationActionServiceBean.MODERATION_ACTION_ORIGIN.equals(model.getOrigin())){
+            ModerationActionPayloadModel payload = (ModerationActionPayloadModel) model.getDeserializedPayload();
+            return ModerationActionServiceBean.BAN_ACTION.equals(payload.getAction());
+        }
+        return false;
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ModerationFeatureDefinition.MODERATION;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.MEDIUM;
+    }
+
+    @Override
+    public Boolean autoAcknowledgeEvent() {
+        return false;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/BanModerationActionModalListener.java

@@ -0,0 +1,113 @@
+package dev.sheldan.abstracto.moderation.listener;
+
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.interaction.InteractionExceptionService;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListener;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListenerModel;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListenerResult;
+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.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.model.interaction.ModerationActionBanPayload;
+import dev.sheldan.abstracto.moderation.service.BanService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.interactions.modals.ModalMapping;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+
+@Component
+@Slf4j
+public class BanModerationActionModalListener implements ModalInteractionListener {
+
+    private static final String KICK_MODERATION_ACTION_MODAL_RESPONSE_TEMPLATE = "moderationAction_ban_response";
+    private static final String DEFAULT_BAN_REASON_TEMPLATE_KEY = "ban_default_reason";
+
+    @Autowired
+    private BanService banService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private InteractionExceptionService interactionExceptionService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Override
+    public Boolean handlesEvent(ModalInteractionListenerModel model) {
+        return BanModerationActionListener.BAN_MODAL_ORIGIN.equals(model.getOrigin());
+    }
+
+    @Override
+    public ModalInteractionListenerResult execute(ModalInteractionListenerModel model) {
+        ModerationActionBanPayload payload = (ModerationActionBanPayload) model.getDeserializedPayload();
+        ServerUser userBeingBanned = ServerUser
+                .builder()
+                .userId(payload.getBannedUserId())
+                .serverId(payload.getServerId())
+                .build();
+
+        ServerUser kickingUser = ServerUser.fromMember(model.getEvent().getMember());
+
+        String duration = model
+                .getEvent()
+                .getValues()
+                .stream()
+                .filter(modalMapping -> modalMapping.getId().equals(payload.getDurationInputId()))
+                .map(ModalMapping::getAsString)
+                .findFirst()
+                .orElse(null);
+        Duration messageDeletionDuration;
+        if(duration != null) {
+            messageDeletionDuration = ParseUtils.parseDuration(duration.trim());
+        } else {
+            messageDeletionDuration = null;
+        }
+        String reason;
+        String tempReason = model
+                .getEvent()
+                .getValues()
+                .stream()
+                .filter(modalMapping -> modalMapping.getId().equals(payload.getDurationInputId()))
+                .map(ModalMapping::getAsString)
+                .findFirst()
+                .orElse(null);
+        if(StringUtils.isBlank(tempReason)) {
+            reason = templateService.renderSimpleTemplate(DEFAULT_BAN_REASON_TEMPLATE_KEY);
+        } else {
+            reason = tempReason;
+        }
+        log.debug("Handling ban moderation action modal interaction by user {} in server {}.", kickingUser.getUserId(), kickingUser.getServerId());
+        model.getEvent().deferReply(true).queue(interactionHook -> {
+            banService.banUserWithNotification(userBeingBanned, reason, kickingUser, model.getEvent().getGuild(), messageDeletionDuration)
+                    .thenCompose((future) -> FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(KICK_MODERATION_ACTION_MODAL_RESPONSE_TEMPLATE, new Object(), model.getEvent().getInteraction().getHook())))
+                    .thenAccept(unused -> {
+                log.info("Kicked user {} from server {}. Performed by user {}.", userBeingBanned.getUserId(), kickingUser.getServerId(), kickingUser.getUserId());
+            }).exceptionally(throwable -> {
+                interactionExceptionService.reportExceptionToInteraction(throwable, model, this);
+                log.error("Failed to kick user {} from server {}. Performed by user {}.", userBeingBanned.getUserId(), kickingUser.getServerId(), kickingUser.getUserId(), throwable);
+                return null;
+            });
+        });
+
+        return ModalInteractionListenerResult.ACKNOWLEDGED;
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ModerationFeatureDefinition.MODERATION;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.MEDIUM;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/HoneyPotRoleAddedListener.java

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.config.ListenerPriority;
 import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.listener.sync.jda.RoleAddedListener;
 import dev.sheldan.abstracto.core.models.ConditionContextInstance;
+import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.models.listener.RoleAddedModel;
 import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
@@ -23,6 +24,7 @@ import net.dv8tion.jda.api.entities.Member;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.time.Duration;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
 import java.util.HashMap;
@@ -77,7 +79,8 @@ public class HoneyPotRoleAddedListener implements RoleAddedListener {
                         .roleDisplay(RoleDisplay.fromRole(model.getRole()))
                         .build();
                 String banReason = templateService.renderTemplate(HONEYPOT_BAN_REASON_TEMPLATE, reasonModel);
-                banService.banUserWithNotification(model.getTargetMember().getUser(), banReason, model.getTargetMember().getGuild().getSelfMember(), null).thenAccept(banResult -> {
+                banService.banUserWithNotification(model.getTargetUser(), banReason, ServerUser.fromMember(model.getTargetMember().getGuild().getSelfMember()),
+                        model.getTargetMember().getGuild(), Duration.ofDays(7)).thenAccept(banResult -> {
                     log.info("Banned user {} in guild {} due to role {}.", model.getTargetUser().getUserId(), model.getTargetUser().getServerId(), model.getRoleId());
                 }).exceptionally(throwable -> {
                     log.error("Failed to ban user {} in guild {} due to role {}.", model.getTargetUser().getUserId(), model.getTargetUser().getServerId(), model.getRoleId(), throwable);

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/KickModerationActionListener.java

@@ -0,0 +1,111 @@
+package dev.sheldan.abstracto.moderation.listener;
+
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.interaction.ComponentPayloadManagementService;
+import dev.sheldan.abstracto.core.interaction.ComponentService;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListener;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerModel;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerResult;
+import dev.sheldan.abstracto.core.interaction.modal.ModalConfigPayload;
+import dev.sheldan.abstracto.core.interaction.modal.ModalService;
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.model.interaction.ModerationActionKickPayload;
+import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionKickModalModel;
+import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionPayloadModel;
+import dev.sheldan.abstracto.moderation.service.ModerationActionServiceBean;
+import jakarta.transaction.Transactional;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class KickModerationActionListener implements ButtonClickedListener {
+
+    @Autowired
+    private ModalService modalService;
+
+    @Autowired
+    private ComponentService componentService;
+
+    @Autowired
+    private ComponentPayloadManagementService componentPayloadManagementService;
+
+    @Autowired
+    private KickModerationActionListener self;
+
+    private static final String KICK_REASON_MODERATION_ACTION_MODAL = "moderationAction_kick";
+    public static final String KICK_MODAL_ORIGIN = "KICK_MODERATION_ACTION_ORIGIN";
+
+    @Override
+    public ButtonClickedListenerResult execute(ButtonClickedListenerModel model) {
+        ModerationActionPayloadModel payload = (ModerationActionPayloadModel) model.getDeserializedPayload();
+        if(ModerationActionServiceBean.KICK_ACTION.equals(payload.getAction())) {
+            log.info("Handling kick button interaction by user {} in server {} for user {}.",
+                    payload.getUser().getUserId(), payload.getUser().getServerId(), model.getEvent().getMember().getIdLong());
+            String modalId = componentService.generateComponentId();
+            String reasonInputId = componentService.generateComponentId();
+            ModerationActionKickModalModel modalModel = ModerationActionKickModalModel
+                    .builder()
+                    .modalId(modalId)
+                    .reasonComponentId(reasonInputId)
+                    .build();
+            modalService.replyModal(model.getEvent(), KICK_REASON_MODERATION_ACTION_MODAL, modalModel).thenAccept(unused -> {
+                log.info("Returned kick reason moderation action modal for user {} towards user {} in server {}.",
+                        payload.getUser().getUserId(), model.getEvent().getMember().getIdLong(), model.getServerId());
+                self.persistKickModerationActionPayload(payload.getUser(), reasonInputId, modalId);
+            }).exceptionally(throwable -> {
+                log.error("Failed to show modal for kick moderation action.", throwable);
+                return null;
+            });
+            return ButtonClickedListenerResult.ACKNOWLEDGED;
+        } else {
+            return ButtonClickedListenerResult.IGNORED;
+        }
+    }
+
+    @Transactional
+    public void persistKickModerationActionPayload(ServerUser userToKick, String reasonInput, String modalId) {
+        ModerationActionKickPayload payload = ModerationActionKickPayload
+                .builder()
+                .kickedUserId(userToKick.getUserId())
+                .serverId(userToKick.getServerId())
+                .reasonInputId(reasonInput)
+                .modalId(modalId)
+                .build();
+        ModalConfigPayload payloadConfig = ModalConfigPayload
+                .builder()
+                .modalPayload(payload)
+                .origin(KICK_MODAL_ORIGIN)
+                .payloadType(payload.getClass())
+                .modalId(modalId)
+                .build();
+        componentPayloadManagementService.createModalPayload(payloadConfig, userToKick.getServerId());
+    }
+
+    @Override
+    public Boolean handlesEvent(ButtonClickedListenerModel model) {
+        if(ModerationActionServiceBean.MODERATION_ACTION_ORIGIN.equals(model.getOrigin())){
+            ModerationActionPayloadModel payload = (ModerationActionPayloadModel) model.getDeserializedPayload();
+            return ModerationActionServiceBean.KICK_ACTION.equals(payload.getAction());
+        }
+        return false;
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ModerationFeatureDefinition.MODERATION;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.MEDIUM;
+    }
+
+    @Override
+    public Boolean autoAcknowledgeEvent() {
+        return false;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/KickModerationActionModalListener.java

@@ -0,0 +1,83 @@
+package dev.sheldan.abstracto.moderation.listener;
+
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.interaction.InteractionExceptionService;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListener;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListenerModel;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListenerResult;
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.model.interaction.ModerationActionKickPayload;
+import dev.sheldan.abstracto.moderation.service.KickService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.interactions.modals.ModalMapping;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class KickModerationActionModalListener implements ModalInteractionListener {
+
+    private static final String KICK_MODERATION_ACTION_MODAL_RESPONSE_TEMPLATE = "moderationAction_kick_response";
+
+    @Autowired
+    private KickService kickService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private InteractionExceptionService interactionExceptionService;
+
+    @Override
+    public Boolean handlesEvent(ModalInteractionListenerModel model) {
+        return KickModerationActionListener.KICK_MODAL_ORIGIN.equals(model.getOrigin());
+    }
+
+    @Override
+    public ModalInteractionListenerResult execute(ModalInteractionListenerModel model) {
+        ModerationActionKickPayload payload = (ModerationActionKickPayload) model.getDeserializedPayload();
+        ServerUser userBeingKicked = ServerUser
+                .builder()
+                .userId(payload.getKickedUserId())
+                .serverId(payload.getServerId())
+                .build();
+
+        ServerUser kickingUser = ServerUser.fromMember(model.getEvent().getMember());
+        String reason = model
+                .getEvent()
+                .getValues()
+                .stream()
+                .filter(modalMapping -> modalMapping.getId().equals(payload.getReasonInputId()))
+                .map(ModalMapping::getAsString)
+                .findFirst()
+                .orElse(null);
+        log.debug("Handling kick moderation action modal interaction by user {} in server {}.", kickingUser.getUserId(), kickingUser.getServerId());
+        model.getEvent().deferReply(true).queue(interactionHook -> {
+            kickService.kickMember(model.getEvent().getGuild(), userBeingKicked, reason, kickingUser)
+                    .thenCompose((future) -> FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(KICK_MODERATION_ACTION_MODAL_RESPONSE_TEMPLATE, new Object(), model.getEvent().getInteraction().getHook())))
+                    .thenAccept(unused -> {
+                log.info("Kicked user {} from server {}. Performed by user {}.", userBeingKicked.getUserId(), kickingUser.getServerId(), kickingUser.getUserId());
+            }).exceptionally(throwable -> {
+                interactionExceptionService.reportExceptionToInteraction(throwable, model, this);
+                log.error("Failed to kick user {} from server {}. Performed by user {}.", userBeingKicked.getUserId(), kickingUser.getServerId(), kickingUser.getUserId(), throwable);
+                return null;
+            });
+        });
+
+        return ModalInteractionListenerResult.ACKNOWLEDGED;
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ModerationFeatureDefinition.MODERATION;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.MEDIUM;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/MemberTimeoutListener.java

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncMemberTimeoutUpdatedListener;
 import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.listener.MemberTimeoutUpdatedModel;
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
@@ -116,8 +117,8 @@ public class MemberTimeoutListener implements AsyncMemberTimeoutUpdatedListener
                         .builder()
                         .muteTargetDate(model.getNewTimeout() != null ? model.getNewTimeout().toInstant() : null)
                         .oldMuteTargetDate(model.getOldTimeout() != null ? model.getOldTimeout().toInstant() : null)
-                        .mutingUser(future.isCompletedExceptionally() ? null : future.join())
-                        .mutedUser(model.getMember())
+                        .mutingUser(future.isCompletedExceptionally() ? null : MemberDisplay.fromMember(future.join()))
+                        .mutedUser(MemberDisplay.fromMember(model.getMember()))
                         .reason(reason)
                         .build();
                 MessageToSend message = templateService.renderEmbedTemplate(MuteServiceBean.MUTE_LOG_TEMPLATE, muteLogModel, guild.getIdLong());

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/MuteModerationActionListener.java

@@ -0,0 +1,114 @@
+package dev.sheldan.abstracto.moderation.listener;
+
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.interaction.ComponentPayloadManagementService;
+import dev.sheldan.abstracto.core.interaction.ComponentService;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListener;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerModel;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerResult;
+import dev.sheldan.abstracto.core.interaction.modal.ModalConfigPayload;
+import dev.sheldan.abstracto.core.interaction.modal.ModalService;
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.model.interaction.ModerationActionMutePayload;
+import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionMuteModalModel;
+import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionPayloadModel;
+import dev.sheldan.abstracto.moderation.service.ModerationActionServiceBean;
+import jakarta.transaction.Transactional;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class MuteModerationActionListener implements ButtonClickedListener {
+
+    @Autowired
+    private ComponentService componentService;
+
+    @Autowired
+    private ModalService modalService;
+
+    @Autowired
+    private ComponentPayloadManagementService componentPayloadManagementService;
+
+    @Autowired
+    private MuteModerationActionListener self;
+
+    private static final String MUTE_REASON_MODERATION_ACTION_MODAL = "moderationAction_mute";
+    public static final String MUTE_MODAL_ORIGIN = "MUTE_MODERATION_ACTION_ORIGIN";
+
+    @Override
+    public ButtonClickedListenerResult execute(ButtonClickedListenerModel model) {
+        ModerationActionPayloadModel payload = (ModerationActionPayloadModel) model.getDeserializedPayload();
+        if(ModerationActionServiceBean.MUTE_ACTION.equals(payload.getAction())) {
+            log.info("Handling mute button interaction by user {} in server {} for user {}.",
+                    payload.getUser().getUserId(), payload.getUser().getServerId(), model.getEvent().getMember().getIdLong());
+            String modalId = componentService.generateComponentId();
+            String reasonInputId = componentService.generateComponentId();
+            String durationInputId = componentService.generateComponentId();
+            ModerationActionMuteModalModel modalModel = ModerationActionMuteModalModel
+                    .builder()
+                    .modalId(modalId)
+                    .durationComponentId(durationInputId)
+                    .reasonComponentId(reasonInputId)
+                    .build();
+            modalService.replyModal(model.getEvent(), MUTE_REASON_MODERATION_ACTION_MODAL, modalModel).thenAccept(unused -> {
+                log.info("Returned mute reason moderation action modal for user {} towards user {} in server {}.",
+                        payload.getUser().getUserId(), model.getEvent().getMember().getIdLong(), model.getServerId());
+                self.persistMuteModerationActionPayload(payload.getUser(), reasonInputId, modalId, durationInputId);
+            }).exceptionally(throwable -> {
+                log.error("Failed to show modal for mute moderation action.", throwable);
+                return null;
+            });
+            return ButtonClickedListenerResult.ACKNOWLEDGED;
+        } else {
+            return ButtonClickedListenerResult.IGNORED;
+        }
+    }
+
+    @Transactional
+    public void persistMuteModerationActionPayload(ServerUser userToMute, String reasonInput, String modalId, String durationInputId) {
+        ModerationActionMutePayload payload = ModerationActionMutePayload
+                .builder()
+                .mutedUserId(userToMute.getUserId())
+                .serverId(userToMute.getServerId())
+                .reasonInputId(reasonInput)
+                .durationInputId(durationInputId)
+                .modalId(modalId)
+                .build();
+        ModalConfigPayload payloadConfig = ModalConfigPayload
+                .builder()
+                .modalPayload(payload)
+                .origin(MUTE_MODAL_ORIGIN)
+                .payloadType(payload.getClass())
+                .modalId(modalId)
+                .build();
+        componentPayloadManagementService.createModalPayload(payloadConfig, userToMute.getServerId());
+    }
+
+    @Override
+    public Boolean handlesEvent(ButtonClickedListenerModel model) {
+        if(ModerationActionServiceBean.MODERATION_ACTION_ORIGIN.equals(model.getOrigin())){
+            ModerationActionPayloadModel payload = (ModerationActionPayloadModel) model.getDeserializedPayload();
+            return ModerationActionServiceBean.MUTE_ACTION.equals(payload.getAction());
+        }
+        return false;
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ModerationFeatureDefinition.MUTING;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.MEDIUM;
+    }
+
+    @Override
+    public Boolean autoAcknowledgeEvent() {
+        return false;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/MuteModerationActionModalListener.java

@@ -0,0 +1,117 @@
+package dev.sheldan.abstracto.moderation.listener;
+
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.interaction.InteractionExceptionService;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListener;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListenerModel;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListenerResult;
+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.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.model.interaction.ModerationActionMutePayload;
+import dev.sheldan.abstracto.moderation.service.MuteService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.interactions.modals.ModalMapping;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+
+import static dev.sheldan.abstracto.moderation.command.Mute.MUTE_NOTIFICATION_NOT_POSSIBLE_TEMPLATE_KEY;
+import static dev.sheldan.abstracto.moderation.model.MuteResult.NOTIFICATION_FAILED;
+
+@Component
+@Slf4j
+public class MuteModerationActionModalListener implements ModalInteractionListener {
+
+    private static final String MUTE_MODERATION_ACTION_MODAL_RESPONSE_TEMPLATE = "moderationAction_mute_response";
+
+    @Autowired
+    private MuteService muteService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Autowired
+    private InteractionExceptionService interactionExceptionService;
+
+    @Override
+    public Boolean handlesEvent(ModalInteractionListenerModel model) {
+        return MuteModerationActionListener.MUTE_MODAL_ORIGIN.equals(model.getOrigin());
+    }
+
+    @Override
+    public ModalInteractionListenerResult execute(ModalInteractionListenerModel model) {
+        ModerationActionMutePayload payload = (ModerationActionMutePayload) model.getDeserializedPayload();
+        ServerUser userBeingMuted = ServerUser
+                .builder()
+                .userId(payload.getMutedUserId())
+                .serverId(payload.getServerId())
+                .build();
+
+        ServerUser mutingUser = ServerUser.fromMember(model.getEvent().getMember());
+        String reason = model
+                .getEvent()
+                .getValues()
+                .stream()
+                .filter(modalMapping -> modalMapping.getId().equals(payload.getReasonInputId()))
+                .map(ModalMapping::getAsString)
+                .findFirst()
+                .orElse(null);
+
+        String duration = model
+                .getEvent()
+                .getValues()
+                .stream()
+                .filter(modalMapping -> modalMapping.getId().equals(payload.getDurationInputId()))
+                .map(ModalMapping::getAsString)
+                .findFirst()
+                .orElse(null);
+        Duration muteDuration;
+        if(duration != null) {
+            muteDuration = ParseUtils.parseDuration(duration.trim());
+        } else {
+            muteDuration = Duration.ofDays(Member.MAX_TIME_OUT_LENGTH);
+        }
+        ServerChannelMessage serverChannelMessage = ServerChannelMessage.fromMessage(model.getEvent().getMessage());
+        log.debug("Handling mute moderation action modal interaction by user {} in server {}.", mutingUser.getUserId(), mutingUser.getServerId());
+        model.getEvent().deferReply(true).queue(interactionHook -> {
+            muteService.muteMemberWithLog(userBeingMuted, mutingUser, reason, muteDuration, model.getEvent().getGuild(), serverChannelMessage)
+                    .thenCompose((future) -> {
+                        if(future == NOTIFICATION_FAILED) {
+                            return FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(MUTE_NOTIFICATION_NOT_POSSIBLE_TEMPLATE_KEY, new Object(), model.getEvent().getInteraction().getHook()));
+                        } else {
+                            return FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(MUTE_MODERATION_ACTION_MODAL_RESPONSE_TEMPLATE, new Object(), model.getEvent().getInteraction().getHook()));
+                        }
+                    })
+                    .thenAccept(unused -> {
+                log.info("Muted user {} in server {}. Performed by user {}.", userBeingMuted.getUserId(), mutingUser.getServerId(), mutingUser.getUserId());
+            }).exceptionally(throwable -> {
+                interactionExceptionService.reportExceptionToInteraction(throwable, model, this);
+                log.error("Failed to mute user {} in server {}. Performed by user {}.", userBeingMuted.getUserId(), mutingUser.getServerId(), mutingUser.getUserId(), throwable);
+                return null;
+            });
+        });
+
+        return ModalInteractionListenerResult.ACKNOWLEDGED;
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ModerationFeatureDefinition.MUTING;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.MEDIUM;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/WarnModerationActionListener.java

@@ -0,0 +1,111 @@
+package dev.sheldan.abstracto.moderation.listener;
+
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.interaction.ComponentPayloadManagementService;
+import dev.sheldan.abstracto.core.interaction.ComponentService;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListener;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerModel;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerResult;
+import dev.sheldan.abstracto.core.interaction.modal.ModalConfigPayload;
+import dev.sheldan.abstracto.core.interaction.modal.ModalService;
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.model.interaction.ModerationActionWarnPayload;
+import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionPayloadModel;
+import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionWarnModalModel;
+import dev.sheldan.abstracto.moderation.service.ModerationActionServiceBean;
+import jakarta.transaction.Transactional;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class WarnModerationActionListener implements ButtonClickedListener {
+
+    @Autowired
+    private ModalService modalService;
+
+    @Autowired
+    private ComponentService componentService;
+
+    @Autowired
+    private ComponentPayloadManagementService componentPayloadManagementService;
+
+    @Autowired
+    private WarnModerationActionListener self;
+
+    private static final String WARN_REASON_MODERATION_ACTION_MODAL = "moderationAction_warn";
+    public static final String WARN_MODAL_ORIGIN = "WARN_MODERATION_ACTION_ORIGIN";
+
+    @Override
+    public ButtonClickedListenerResult execute(ButtonClickedListenerModel model) {
+        ModerationActionPayloadModel payload = (ModerationActionPayloadModel) model.getDeserializedPayload();
+        if(ModerationActionServiceBean.WARN_ACTION.equals(payload.getAction())) {
+            log.info("Handling warn button interaction by user {} in server {} for user {}.",
+                    payload.getUser().getUserId(), payload.getUser().getServerId(), model.getEvent().getMember().getIdLong());
+            String modalId = componentService.generateComponentId();
+            String reasonInputId = componentService.generateComponentId();
+            ModerationActionWarnModalModel modalModel = ModerationActionWarnModalModel
+                    .builder()
+                    .modalId(modalId)
+                    .reasonComponentId(reasonInputId)
+                    .build();
+            modalService.replyModal(model.getEvent(), WARN_REASON_MODERATION_ACTION_MODAL, modalModel).thenAccept(unused -> {
+                log.info("Returned warn reason moderation action modal for user {} towards user {} in server {}.",
+                        payload.getUser().getUserId(), model.getEvent().getMember().getIdLong(), model.getServerId());
+                self.persistWarnModerationActionPayload(payload.getUser(), reasonInputId, modalId);
+            }).exceptionally(throwable -> {
+                log.error("Failed to show modal for warn moderation action.", throwable);
+                return null;
+            });
+            return ButtonClickedListenerResult.ACKNOWLEDGED;
+        } else {
+            return ButtonClickedListenerResult.IGNORED;
+        }
+    }
+
+    @Transactional
+    public void persistWarnModerationActionPayload(ServerUser userToWarn, String reasonInput, String modalId) {
+        ModerationActionWarnPayload payload = ModerationActionWarnPayload
+                .builder()
+                .warnedUserId(userToWarn.getUserId())
+                .serverId(userToWarn.getServerId())
+                .reasonInputId(reasonInput)
+                .modalId(modalId)
+                .build();
+        ModalConfigPayload payloadConfig = ModalConfigPayload
+                .builder()
+                .modalPayload(payload)
+                .origin(WARN_MODAL_ORIGIN)
+                .payloadType(payload.getClass())
+                .modalId(modalId)
+                .build();
+        componentPayloadManagementService.createModalPayload(payloadConfig, userToWarn.getServerId());
+    }
+
+    @Override
+    public Boolean handlesEvent(ButtonClickedListenerModel model) {
+        if(ModerationActionServiceBean.MODERATION_ACTION_ORIGIN.equals(model.getOrigin())){
+            ModerationActionPayloadModel payload = (ModerationActionPayloadModel) model.getDeserializedPayload();
+            return ModerationActionServiceBean.WARN_ACTION.equals(payload.getAction());
+        }
+        return false;
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ModerationFeatureDefinition.WARNING;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.MEDIUM;
+    }
+
+    @Override
+    public Boolean autoAcknowledgeEvent() {
+        return false;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/WarnModerationActionModalListener.java

@@ -0,0 +1,98 @@
+package dev.sheldan.abstracto.moderation.listener;
+
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.interaction.InteractionExceptionService;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListener;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListenerModel;
+import dev.sheldan.abstracto.core.interaction.modal.listener.ModalInteractionListenerResult;
+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.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.model.interaction.ModerationActionWarnPayload;
+import dev.sheldan.abstracto.moderation.service.WarnService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.interactions.modals.ModalMapping;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import static dev.sheldan.abstracto.moderation.command.Warn.WARN_DEFAULT_REASON_TEMPLATE;
+
+@Component
+@Slf4j
+public class WarnModerationActionModalListener implements ModalInteractionListener {
+
+    private static final String WARN_MODERATION_ACTION_MODAL_RESPONSE_TEMPLATE = "moderationAction_warn_response";
+
+    @Autowired
+    private WarnService warnService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Autowired
+    private InteractionExceptionService interactionExceptionService;
+
+    @Override
+    public Boolean handlesEvent(ModalInteractionListenerModel model) {
+        return WarnModerationActionListener.WARN_MODAL_ORIGIN.equals(model.getOrigin());
+    }
+
+    @Override
+    public ModalInteractionListenerResult execute(ModalInteractionListenerModel model) {
+        ModerationActionWarnPayload payload = (ModerationActionWarnPayload) model.getDeserializedPayload();
+        ServerUser userBeingWarned = ServerUser
+                .builder()
+                .userId(payload.getWarnedUserId())
+                .serverId(payload.getServerId())
+                .build();
+
+        ServerUser warningUser = ServerUser.fromMember(model.getEvent().getMember());
+        String reason;
+        String tempReason = model
+                .getEvent()
+                .getValues()
+                .stream()
+                .filter(modalMapping -> modalMapping.getId().equals(payload.getReasonInputId()))
+                .map(ModalMapping::getAsString)
+                .findFirst()
+                .orElse(null);
+        if(StringUtils.isBlank(tempReason)) {
+            reason = templateService.renderSimpleTemplate(WARN_DEFAULT_REASON_TEMPLATE, model.getServerId());
+        } else {
+            reason = tempReason;
+        }
+        ServerChannelMessage serverChannelMessage = ServerChannelMessage.fromMessage(model.getEvent().getMessage());
+        log.debug("Handling warn moderation action modal interaction by user {} in server {}.", warningUser.getUserId(), warningUser.getServerId());
+        model.getEvent().deferReply(true).queue(interactionHook -> {
+            warnService.warnUserWithLog(model.getEvent().getGuild(), userBeingWarned, warningUser, reason, serverChannelMessage)
+                    .thenCompose((future) -> FutureUtils.toSingleFutureGeneric(interactionService.sendMessageToInteraction(WARN_MODERATION_ACTION_MODAL_RESPONSE_TEMPLATE, new Object(), model.getEvent().getInteraction().getHook())))
+                    .thenAccept(unused -> {
+                log.info("Warned user {} in server {}. Performed by user {}.", userBeingWarned.getUserId(), warningUser.getServerId(), warningUser.getUserId());
+            }).exceptionally(throwable -> {
+                interactionExceptionService.reportExceptionToInteraction(throwable, model, this);
+                log.error("Failed to warn user {} from server {}. Performed by user {}.", userBeingWarned.getUserId(), warningUser.getServerId(), warningUser.getUserId(), throwable);
+                return null;
+            });
+        });
+
+        return ModalInteractionListenerResult.ACKNOWLEDGED;
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ModerationFeatureDefinition.WARNING;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.MEDIUM;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/infraction/BanReasonUpdatedListener.java

@@ -4,6 +4,8 @@ import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.config.ListenerPriority;
 import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import dev.sheldan.abstracto.core.models.template.display.UserDisplay;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.MessageService;
@@ -85,8 +87,8 @@ public class BanReasonUpdatedListener implements InfractionUpdatedDescriptionLis
                 .orElse(Duration.ZERO);
         BanLog banLog = BanLog
                 .builder()
-                .bannedUser(infractionUser.isCompletedExceptionally() ? null : infractionUser.join())
-                .banningMember(infractionCreator.isCompletedExceptionally() ? null : infractionCreator.join())
+                .bannedUser(infractionUser.isCompletedExceptionally() ? null : UserDisplay.fromUser(infractionUser.join()))
+                .banningMember(infractionCreator.isCompletedExceptionally() ? null : MemberDisplay.fromMember(infractionCreator.join()))
                 .deletionDuration(deletionDuration)
                 .reason(model.getNewDescription())
                 .build();

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/infraction/WarnReasonUpdatedListener.java

@@ -4,6 +4,7 @@ import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.config.ListenerPriority;
 import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.GuildService;
 import dev.sheldan.abstracto.core.service.MemberService;
@@ -14,7 +15,7 @@ import dev.sheldan.abstracto.moderation.listener.InfractionUpdatedDescriptionLis
 import dev.sheldan.abstracto.moderation.model.database.Infraction;
 import dev.sheldan.abstracto.moderation.model.database.Warning;
 import dev.sheldan.abstracto.moderation.model.listener.InfractionDescriptionEventModel;
-import dev.sheldan.abstracto.moderation.model.template.command.WarnContext;
+import dev.sheldan.abstracto.moderation.model.template.command.WarnLogModel;
 import dev.sheldan.abstracto.moderation.service.WarnServiceBean;
 import dev.sheldan.abstracto.moderation.service.management.InfractionManagementService;
 import dev.sheldan.abstracto.moderation.service.management.WarnManagementService;
@@ -82,15 +83,14 @@ public class WarnReasonUpdatedListener implements InfractionUpdatedDescriptionLi
         Guild guild = guildService.getGuildById(model.getServerId());
         Infraction infraction = infractionManagementService.loadInfraction(model.getInfractionId());
         GuildMessageChannel messageChannel = channelService.getMessageChannelFromServer(model.getServerId(), infraction.getLogChannel().getId());
-        WarnContext context = WarnContext
+        WarnLogModel context = WarnLogModel
                 .builder()
-                .warnedMember(warnedUser.isCompletedExceptionally() ? null : warnedUser.join())
-                .member(warningUser.isCompletedExceptionally() ? null : warningUser.join())
+                .warnedMember(warnedUser.isCompletedExceptionally() ? null : MemberDisplay.fromMember(warnedUser.join()))
+                .warningMember(warningUser.isCompletedExceptionally() ? null : MemberDisplay.fromMember(warningUser.join()))
                 .reason(model.getNewDescription())
                 .warnId(warnId)
-                .guild(guild)
                 .build();
-        MessageToSend message = warnService.renderMessageModel(context);
+        MessageToSend message = warnService.renderMessageModel(context, guild.getIdLong());
         messageService.editMessageInChannel(messageChannel, message, infraction.getLogMessageId())
                 .thenAccept(unused1 -> returningFuture.complete(DefaultListenerResult.PROCESSED))
                 .exceptionally(throwable1 -> {

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/BanServiceBean.java

@@ -1,6 +1,9 @@
 package dev.sheldan.abstracto.moderation.service;
 
+import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import dev.sheldan.abstracto.core.models.template.display.UserDisplay;
 import dev.sheldan.abstracto.core.service.*;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
@@ -60,32 +63,31 @@ public class BanServiceBean implements BanService {
     private InfractionService infractionService;
 
     @Override
-    public CompletableFuture<BanResult> banUserWithNotification(User user, String reason, Member banningMember, Duration deletionDuration) {
+    public CompletableFuture<BanResult> banUserWithNotification(ServerUser userToBeBanned, String reason, ServerUser banningUser, Guild guild, Duration deletionDuration) {
         BanLog banLog = BanLog
                 .builder()
-                .bannedUser(user)
-                .banningMember(banningMember)
+                .bannedUser(UserDisplay.fromServerUser(userToBeBanned))
+                .banningMember(MemberDisplay.fromServerUser(banningUser))
                 .deletionDuration(deletionDuration)
                 .reason(reason)
                 .build();
-        Guild guild = banningMember.getGuild();
         BanResult[] result = {BanResult.SUCCESSFUL};
-        return sendBanNotification(user, reason, guild)
+        return sendBanNotification(userToBeBanned, reason, guild)
                 .exceptionally(throwable -> {
                     result[0] = BanResult.NOTIFICATION_FAILED;
                     return null;
                 })
-                .thenCompose(unused -> banUser(guild, user, deletionDuration, reason))
+                .thenCompose(unused -> banUser(guild, userToBeBanned, deletionDuration, reason))
                 .thenCompose(unused -> sendBanLogMessage(banLog, guild.getIdLong()))
-                .thenAccept(banLogMessage -> self.evaluateAndStoreInfraction(user, guild, reason, banningMember, banLogMessage, deletionDuration))
+                .thenAccept(banLogMessage -> self.evaluateAndStoreInfraction(userToBeBanned, guild, reason, banningUser, banLogMessage, deletionDuration))
                 .thenApply(unused -> result[0]);
     }
 
     @Transactional
-    public CompletableFuture<Long> evaluateAndStoreInfraction(User user, Guild guild, String reason, Member banningMember, Message banLogMessage, Duration deletionDuration) {
+    public CompletableFuture<Long> evaluateAndStoreInfraction(ServerUser user, Guild guild, String reason, ServerUser banningMember, Message banLogMessage, Duration deletionDuration) {
         if(featureFlagService.getFeatureFlagValue(ModerationFeatureDefinition.INFRACTIONS, guild.getIdLong())) {
             Long infractionPoints = configService.getLongValueOrConfigDefault(ModerationFeatureConfig.BAN_INFRACTION_POINTS, guild.getIdLong());
-            AUserInAServer bannedUser = userInServerManagementService.loadOrCreateUser(guild.getIdLong(), user.getIdLong());
+            AUserInAServer bannedUser = userInServerManagementService.loadOrCreateUser(guild.getIdLong(), user.getUserId());
             AUserInAServer banningUser = userInServerManagementService.loadOrCreateUser(banningMember);
             Map<String, String> parameters = new HashMap<>();
             if(deletionDuration == null) {
@@ -99,47 +101,46 @@ public class BanServiceBean implements BanService {
         }
     }
 
-    private CompletableFuture<Void> sendBanNotification(User user, String reason, Guild guild) {
+    private CompletableFuture<Void> sendBanNotification(ServerUser serverUser, String reason, Guild guild) {
         BanNotificationModel model = BanNotificationModel
                 .builder()
                 .serverName(guild.getName())
                 .reason(reason)
                 .build();
         String message = templateService.renderTemplate(BAN_NOTIFICATION, model, guild.getIdLong());
-        return messageService.sendMessageToUser(user, message).thenAccept(message1 -> {});
+        return messageService.sendMessageToUser(serverUser, message).thenAccept(message1 -> {});
     }
 
     @Override
-    public CompletableFuture<Void> unBanUserWithNotification(User user, Member unBanningMember) {
-        Guild guild = unBanningMember.getGuild();
+    public CompletableFuture<Void> unBanUserWithNotification(Long userId, ServerUser unBanningMember, Guild guild) {
         UnBanLog banLog = UnBanLog
                 .builder()
-                .bannedUser(user)
-                .unBanningMember(unBanningMember)
+                .bannedUser(UserDisplay.fromId(userId))
+                .unBanningMember(MemberDisplay.fromServerUser(unBanningMember))
                 .build();
-        return unbanUser(guild, user)
+        return unbanUser(guild, userId)
                 .thenCompose(unused -> self.sendUnBanLogMessage(banLog, guild.getIdLong(), UN_BAN_LOG_TEMPLATE));
     }
 
     @Override
-    public CompletableFuture<Void> banUser(Guild guild, User user, Duration deletionDuration, String reason) {
-        log.info("Banning user {} in guild {}.", user.getIdLong(), guild.getId());
+    public CompletableFuture<Void> banUser(Guild guild, ServerUser userToBeBanned, Duration deletionDuration, String reason) {
+        log.info("Banning user {} in guild {}.", userToBeBanned.getUserId(), guild.getId());
         if(deletionDuration == null || deletionDuration.isNegative()) {
             deletionDuration = Duration.ZERO;
         }
-        return guild.ban(user, (int) deletionDuration.getSeconds(), TimeUnit.SECONDS).reason(reason).submit();
+        return guild.ban(UserSnowflake.fromId(userToBeBanned.getUserId()), (int) deletionDuration.getSeconds(), TimeUnit.SECONDS).reason(reason).submit();
     }
 
     @Override
-    public CompletableFuture<Void> unbanUser(Guild guild, User user) {
-        log.info("Unbanning user {} in guild {}.", user.getIdLong(), guild.getId());
-        return guild.unban(user).submit();
+    public CompletableFuture<Void> unbanUser(Guild guild, Long userId) {
+        log.info("Unbanning user {} in guild {}.", userId, guild.getId());
+        return guild.unban(UserSnowflake.fromId(userId)).submit();
     }
 
     @Override
-    public CompletableFuture<Void> softBanUser(Guild guild, User user, Duration delDays) {
+    public CompletableFuture<Void> softBanUser(Guild guild, ServerUser user, Duration delDays) {
         return banUser(guild, user, delDays, "")
-                .thenCompose(unused -> unbanUser(guild, user));
+                .thenCompose(unused -> unbanUser(guild, user.getUserId()));
     }
 
     public CompletableFuture<Message> sendBanLogMessage(BanLog banLog, Long guildId) {

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/KickServiceBean.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.moderation.service;
 
+import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
 import dev.sheldan.abstracto.core.service.ConfigService;
 import dev.sheldan.abstracto.core.service.FeatureFlagService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
@@ -17,6 +19,7 @@ import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.UserSnowflake;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
@@ -52,31 +55,72 @@ public class KickServiceBean implements KickService {
     private KickServiceBean self;
 
     @Override
-    public CompletableFuture<Void> kickMember(Member member, String reason, KickLogModel kickLogModel)  {
-        Guild guild = member.getGuild();
-        log.info("Kicking user {} from guild {}", member.getUser().getIdLong(), guild.getIdLong());
-        CompletableFuture<Void> kickFuture = guild.kick(member, reason).submit();
-        CompletableFuture<Message> logFuture = this.sendKickLog(kickLogModel);
+    public CompletableFuture<Void> kickMember(Member kickedMember, Member kickingMember, String reason)  {
+        Guild guild = kickedMember.getGuild();
+        log.info("Kicking user {} from guild {}", kickedMember.getUser().getIdLong(), guild.getIdLong());
+        CompletableFuture<Void> kickFuture = guild.kick(kickedMember, reason).submit();
+        CompletableFuture<Message> logFuture = sendKickLog(kickedMember, kickingMember, reason, guild.getIdLong());
         return CompletableFuture.allOf(kickFuture, logFuture)
-                .thenAccept(unused -> self.storeInfraction(member, reason, kickLogModel, guild, logFuture.join()));
+                .thenAccept(unused -> self.storeInfraction(kickedMember, kickingMember, reason, logFuture.join(), guild.getIdLong()));
+    }
+
+    @Override
+    public CompletableFuture<Void> kickMember(Guild guild, ServerUser kickedUser, String reason, ServerUser kickingUser) {
+        CompletableFuture<Void> kickFuture = guild.kick(UserSnowflake.fromId(kickedUser.getUserId())).submit();
+        CompletableFuture<Message> logFuture = sendKickLog(kickedUser, kickingUser, reason, guild.getIdLong());
+        return CompletableFuture.allOf(kickFuture, logFuture)
+                .thenAccept(unused -> self.storeInfraction(kickedUser, kickingUser, reason, logFuture.join(), guild.getIdLong()));
     }
 
     @Transactional
-    public CompletableFuture<Long> storeInfraction(Member member, String reason, KickLogModel kickLogModel, Guild guild, Message logMessage) {
-        if(featureFlagService.getFeatureFlagValue(ModerationFeatureDefinition.INFRACTIONS, guild.getIdLong())) {
-            Long infractionPoints = configService.getLongValueOrConfigDefault(ModerationFeatureConfig.KICK_INFRACTION_POINTS, guild.getIdLong());
+    public CompletableFuture<Long> storeInfraction(Member member, Member kickingMember, String reason, Message logMessage, Long serverId) {
+        if(featureFlagService.getFeatureFlagValue(ModerationFeatureDefinition.INFRACTIONS, serverId)) {
+            Long infractionPoints = configService.getLongValueOrConfigDefault(ModerationFeatureConfig.KICK_INFRACTION_POINTS, serverId);
             AUserInAServer kickedUser = userInServerManagementService.loadOrCreateUser(member);
-            AUserInAServer kickingUser = userInServerManagementService.loadOrCreateUser(kickLogModel.getMember());
+            AUserInAServer kickingUser = userInServerManagementService.loadOrCreateUser(kickingMember);
             return infractionService.createInfractionWithNotification(kickedUser, infractionPoints, KICK_INFRACTION_TYPE, reason, kickingUser, logMessage).thenApply(Infraction::getId);
         } else {
             return CompletableFuture.completedFuture(null);
         }
     }
 
-    private CompletableFuture<Message> sendKickLog(KickLogModel kickLogModel)  {
-        MessageToSend warnLogMessage = templateService.renderEmbedTemplate(KICK_LOG_TEMPLATE, kickLogModel, kickLogModel.getGuild().getIdLong());
-        log.debug("Sending kick log message in guild {}.", kickLogModel.getGuild().getIdLong());
-        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(warnLogMessage, ModerationPostTarget.KICK_LOG, kickLogModel.getGuild().getIdLong());
+    @Transactional
+    public CompletableFuture<Long> storeInfraction(ServerUser member, ServerUser kickingMember, String reason, Message logMessage, Long serverId) {
+        if(featureFlagService.getFeatureFlagValue(ModerationFeatureDefinition.INFRACTIONS, serverId)) {
+            Long infractionPoints = configService.getLongValueOrConfigDefault(ModerationFeatureConfig.KICK_INFRACTION_POINTS, serverId);
+            AUserInAServer kickedUser = userInServerManagementService.loadOrCreateUser(member);
+            AUserInAServer kickingUser = userInServerManagementService.loadOrCreateUser(kickingMember);
+            return infractionService.createInfractionWithNotification(kickedUser, infractionPoints, KICK_INFRACTION_TYPE, reason, kickingUser, logMessage).thenApply(Infraction::getId);
+        } else {
+            return CompletableFuture.completedFuture(null);
+        }
+    }
+
+    private CompletableFuture<Message> sendKickLog(Member kickedMember, Member kickingMember, String reason, Long serverId)  {
+        KickLogModel kickLogModel = KickLogModel
+                .builder()
+                .kickedMember(MemberDisplay.fromMember(kickedMember))
+                .kickingMember(MemberDisplay.fromMember(kickingMember))
+                .reason(reason)
+                .build();
+        return sendKicklog(serverId, kickLogModel);
+    }
+
+    private CompletableFuture<Message> sendKickLog(ServerUser kickedMember, ServerUser kickingMember, String reason, Long serverId)  {
+        KickLogModel kickLogModel = KickLogModel
+                .builder()
+                .kickedMember(MemberDisplay.fromServerUser(kickedMember))
+                .kickingMember(MemberDisplay.fromServerUser(kickingMember))
+                .reason(reason)
+                .build();
+        return sendKicklog(serverId, kickLogModel);
+    }
+
+    private CompletableFuture<Message> sendKicklog(Long serverId, KickLogModel kickLogModel) {
+        MessageToSend warnLogMessage = templateService.renderEmbedTemplate(KICK_LOG_TEMPLATE, kickLogModel, serverId);
+        log.debug("Sending kick log message in guild {}.", serverId);
+        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(warnLogMessage, ModerationPostTarget.KICK_LOG, serverId);
         return FutureUtils.toSingleFutureGeneric(messageFutures).thenApply(unused -> messageFutures.get(0).join());
     }
+
 }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/ModerationActionServiceBean.java

@@ -0,0 +1,95 @@
+package dev.sheldan.abstracto.moderation.service;
+
+import dev.sheldan.abstracto.core.interaction.ComponentPayloadService;
+import dev.sheldan.abstracto.core.interaction.ComponentService;
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.FeatureFlagService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.model.ModerationActionButton;
+import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionPayloadModel;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Component
+@Slf4j
+public class ModerationActionServiceBean implements ModerationActionService {
+
+    public static final String WARN_ACTION = "warn";
+    public static final String MUTE_ACTION = "mute";
+    public static final String KICK_ACTION = "kick";
+    public static final String BAN_ACTION = "ban";
+
+    public static final String MODERATION_ACTION_ORIGIN = "moderationAction";
+
+
+    @Autowired
+    private FeatureFlagService featureFlagService;
+
+    @Autowired
+    private ComponentService componentService;
+
+    @Autowired
+    private ComponentPayloadService componentPayloadService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Override
+    public List<ModerationActionButton> getModerationActionButtons(ServerUser serverUser) {
+        AServer server = serverManagementService.loadServer(serverUser.getServerId());
+        boolean mutingEnabled = featureFlagService.getFeatureFlagValue(ModerationFeatureDefinition.MUTING, serverUser.getServerId());
+        boolean moderationEnabled = featureFlagService.getFeatureFlagValue(ModerationFeatureDefinition.MODERATION, serverUser.getServerId());
+        boolean warningsEnabled = featureFlagService.getFeatureFlagValue(ModerationFeatureDefinition.WARNING, serverUser.getServerId());
+        List<ModerationActionButton> buttons = new ArrayList<>();
+        if(warningsEnabled) {
+            String warnButtonId = componentService.generateComponentId();
+            ModerationActionPayloadModel warnPayload = ModerationActionPayloadModel.forAction(WARN_ACTION, serverUser);
+            componentPayloadService.createButtonPayload(warnButtonId, warnPayload, MODERATION_ACTION_ORIGIN, server);
+            ModerationActionButton warnAction = ModerationActionButton
+                    .builder()
+                    .componentId(warnButtonId)
+                    .action(WARN_ACTION)
+                    .build();
+            buttons.add(warnAction);
+        }
+        if(mutingEnabled) {
+            String muteButtonId = componentService.generateComponentId();
+            ModerationActionPayloadModel mutePayload = ModerationActionPayloadModel.forAction(MUTE_ACTION, serverUser);
+            componentPayloadService.createButtonPayload(muteButtonId, mutePayload, MODERATION_ACTION_ORIGIN, server);
+            ModerationActionButton muteAction = ModerationActionButton
+                    .builder()
+                    .componentId(muteButtonId)
+                    .action(MUTE_ACTION)
+                    .build();
+            buttons.add(muteAction);
+        }
+        if(moderationEnabled) {
+            String kickButtonId = componentService.generateComponentId();
+            String banButtonId = componentService.generateComponentId();
+            ModerationActionPayloadModel kickPayload = ModerationActionPayloadModel.forAction(KICK_ACTION, serverUser);
+            ModerationActionPayloadModel banPayload = ModerationActionPayloadModel.forAction(BAN_ACTION, serverUser);
+            componentPayloadService.createButtonPayload(kickButtonId, kickPayload, MODERATION_ACTION_ORIGIN, server);
+            componentPayloadService.createButtonPayload(banButtonId, banPayload, MODERATION_ACTION_ORIGIN, server);
+            ModerationActionButton kickAction = ModerationActionButton
+                    .builder()
+                    .componentId(kickButtonId)
+                    .action(KICK_ACTION)
+                    .build();
+            buttons.add(kickAction);
+            ModerationActionButton banAction = ModerationActionButton
+                    .builder()
+                    .componentId(banButtonId)
+                    .action(BAN_ACTION)
+                    .build();
+            buttons.add(banAction);
+        }
+        log.info("Attaching {} buttons to moderation action for user {} in server {}.", buttons.size(), serverUser.getUserId(), serverUser.getServerId());
+        return buttons;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/MuteServiceBean.java

@@ -1,11 +1,12 @@
 package dev.sheldan.abstracto.moderation.service;
 
 import dev.sheldan.abstracto.core.models.AServerAChannelMessage;
-import dev.sheldan.abstracto.core.models.FullUserInServer;
+import dev.sheldan.abstracto.core.models.ServerChannelMessage;
 import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 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.*;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
@@ -17,9 +18,9 @@ import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefiniti
 import dev.sheldan.abstracto.moderation.config.feature.MutingFeatureConfig;
 import dev.sheldan.abstracto.moderation.config.posttarget.MutingPostTarget;
 import dev.sheldan.abstracto.moderation.exception.NoMuteFoundException;
+import dev.sheldan.abstracto.moderation.model.MuteResult;
 import dev.sheldan.abstracto.moderation.model.database.Infraction;
 import dev.sheldan.abstracto.moderation.model.database.Mute;
-import dev.sheldan.abstracto.moderation.model.template.command.MuteContext;
 import dev.sheldan.abstracto.moderation.model.template.command.MuteListenerModel;
 import dev.sheldan.abstracto.moderation.model.template.command.MuteNotification;
 import dev.sheldan.abstracto.moderation.model.template.command.UnMuteLog;
@@ -28,9 +29,7 @@ import dev.sheldan.abstracto.scheduling.model.JobParameters;
 import dev.sheldan.abstracto.scheduling.service.SchedulerService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.Guild;
-import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Message;
-import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Component;
@@ -87,9 +86,6 @@ public class MuteServiceBean implements MuteService {
     @Autowired
     private ServerManagementService serverManagementService;
 
-    @Autowired
-    private ChannelService channelService;
-
     @Autowired
     private FeatureFlagService featureFlagService;
 
@@ -104,68 +100,39 @@ public class MuteServiceBean implements MuteService {
     public static final String MUTE_COUNTER_KEY = "MUTES";
 
     @Override
-    public CompletableFuture<Void> muteMember(Member memberToMute, String reason, Instant unMuteDate, Long channelId) {
-        FullUserInServer mutedUser = FullUserInServer
+    public CompletableFuture<MuteResult> muteUserInServer(Guild guild, ServerUser userBeingMuted, String reason, Duration duration) {
+        Long serverId = guild.getIdLong();
+        Instant targetDate = Instant.now().plus(duration);
+        MuteNotification muteNotificationModel = MuteNotification
                 .builder()
-                    .aUserInAServer(userInServerManagementService.loadOrCreateUser(memberToMute))
-                .member(memberToMute)
-                .build();
-        return muteUserInServer(mutedUser, reason, unMuteDate, channelId);
-    }
-
-    @Override
-    public CompletableFuture<Void> muteUserInServer(FullUserInServer userBeingMuted, String reason, Instant unMuteDate, Long channelId) {
-        Member memberBeingMuted = userBeingMuted.getMember();
-        List<CompletableFuture<Void>> futures = new ArrayList<>();
-
-        futures.add(memberService.timeoutUser(userBeingMuted.getMember(), unMuteDate));
-        Guild guild = memberBeingMuted.getGuild();
-        if(memberBeingMuted.getVoiceState() != null && memberBeingMuted.getVoiceState().getChannel() != null) {
-            futures.add(guild.kickVoiceMember(memberBeingMuted).submit());
-        }
-        MuteNotification muteNotification = MuteNotification
-                .builder()
-                .muteTargetDate(unMuteDate)
+                .muteTargetDate(targetDate)
                 .reason(reason)
                 .serverName(guild.getName())
                 .build();
-        futures.add(sendMuteNotification(memberBeingMuted, muteNotification, channelId));
-        return FutureUtils.toSingleFutureGeneric(futures);
-    }
-
-    private CompletableFuture<Void> sendMuteNotification(Member memberBeingMuted, MuteNotification muteNotification, Long channelId) {
+        MuteResult[] result = {MuteResult.SUCCESSFUL};
         log.info("Notifying the user about the mute.");
-        CompletableFuture<Void> notificationFuture = new CompletableFuture<>();
-        Long guildId = memberBeingMuted.getGuild().getIdLong();
-        String muteNotificationMessage = templateService.renderTemplate(MUTE_NOTIFICATION_TEMPLATE, muteNotification, guildId);
-        CompletableFuture<Message> messageCompletableFuture = messageService.sendMessageToUser(memberBeingMuted.getUser(), muteNotificationMessage);
-        messageCompletableFuture.exceptionally(throwable -> {
-            GuildMessageChannel feedBackChannel = channelService.getMessageChannelFromServer(guildId, channelId);
-            channelService.sendTextToChannel(throwable.getMessage(), feedBackChannel).whenComplete((exceptionMessage, innerThrowable) -> {
-                notificationFuture.complete(null);
-                log.info("Successfully notified user {} in server {} about mute.", memberBeingMuted.getId(), memberBeingMuted.getGuild().getId());
-            }).exceptionally(throwable1 -> {
-                notificationFuture.completeExceptionally(throwable1);
-                return null;
-            });
-            return null;
-        });
-        messageCompletableFuture.thenAccept(message1 ->
-            notificationFuture.complete(null)
-        );
-        return notificationFuture;
+        String muteNotificationMessage = templateService.renderTemplate(MUTE_NOTIFICATION_TEMPLATE, muteNotificationModel, serverId);
+        return messageService.sendMessageToUser(userBeingMuted, muteNotificationMessage)
+                .exceptionally(throwable -> {
+                    log.warn("Failed to notify about mute", throwable);
+                    result[0] = MuteResult.NOTIFICATION_FAILED;
+                    return null;
+                })
+                .thenCompose(unused -> memberService.timeoutMember(guild, userBeingMuted, duration, reason))
+                .thenApply(message -> result[0]);
     }
 
-    private void createMuteObject(MuteContext muteContext, String triggerKey, Long infractionId) {
-        AChannel channel = channelManagementService.loadChannel(muteContext.getChannelId());
+    private void createMuteObject(ServerUser userToMute, ServerUser mutingUser, String reason, Instant targetDate, Long muteId,
+                                  String triggerKey, Long infractionId, ServerChannelMessage serverChannelMessage) {
+        AChannel channel = channelManagementService.loadChannel(serverChannelMessage.getChannelId());
         AServerAChannelMessage origin = AServerAChannelMessage
                 .builder()
                 .channel(channel)
                 .server(channel.getServer())
                 .build();
-        AUserInAServer userInServerBeingMuted = userInServerManagementService.loadOrCreateUser(muteContext.getMutedUser());
-        AUserInAServer userInServerMuting = userInServerManagementService.loadOrCreateUser(muteContext.getMutingUser());
-        muteManagementService.createMute(userInServerBeingMuted, userInServerMuting, muteContext.getReason(), muteContext.getMuteTargetDate(), origin, triggerKey, muteContext.getMuteId(), infractionId);
+        AUserInAServer userInServerBeingMuted = userInServerManagementService.loadOrCreateUser(userToMute);
+        AUserInAServer userInServerMuting = userInServerManagementService.loadOrCreateUser(mutingUser);
+        muteManagementService.createMute(userInServerBeingMuted, userInServerMuting, reason, targetDate, origin, triggerKey, muteId, infractionId);
     }
 
     @Override
@@ -200,27 +167,30 @@ public class MuteServiceBean implements MuteService {
     }
 
     @Override
-    public CompletableFuture<Void> muteMemberWithLog(MuteContext context) {
-        log.debug("Muting member {} in server {}.", context.getMutedUser().getId(), context.getMutedUser().getGuild().getId());
-        AServer server = serverManagementService.loadOrCreate(context.getMutedUser().getGuild().getIdLong());
-        Long nextCounterValue = counterService.getNextCounterValue(server, MUTE_COUNTER_KEY);
-        context.setMuteId(nextCounterValue);
-        return muteMember(context.getMutedUser(), context.getReason(), context.getMuteTargetDate(), context.getChannelId())
-                .thenCompose(unused -> self.sendMuteLog(context))
-                .thenCompose(logMessage -> self.evaluateAndStoreInfraction(context, logMessage))
-                .thenAccept(infractionId -> self.persistMute(context, infractionId));
+    public CompletableFuture<MuteResult> muteMemberWithLog(ServerUser userToMute, ServerUser mutingUser, String reason, Duration duration, Guild guild, ServerChannelMessage origin) {
+        Long serverId = userToMute.getServerId();
+        Instant targetDate = Instant.now().plus(duration);
+        log.debug("Muting member {} in server {}.", userToMute.getUserId(), serverId);
+        AServer server = serverManagementService.loadOrCreate(serverId);
+        Long muteId = counterService.getNextCounterValue(server, MUTE_COUNTER_KEY);
+        CompletableFuture<MuteResult> result = muteUserInServer(guild, userToMute, reason, duration);
+        return result
+                .thenCompose(unused -> self.sendMuteLog(userToMute, mutingUser, duration, reason))
+                .thenCompose(logMessage -> self.evaluateAndStoreInfraction(userToMute, mutingUser, reason, targetDate, logMessage))
+                .thenAccept(infractionId -> self.persistMute(userToMute, mutingUser, targetDate, muteId, reason, infractionId, origin))
+                .thenApply(unused -> result.join());
     }
 
     @Transactional
-    public CompletableFuture<Long> evaluateAndStoreInfraction(MuteContext context, Message logMessage) {
-        Guild guild = context.getMutedUser().getGuild();
-        if(featureFlagService.getFeatureFlagValue(ModerationFeatureDefinition.INFRACTIONS, guild.getIdLong())) {
-            Long infractionPoints = configService.getLongValueOrConfigDefault(MutingFeatureConfig.MUTE_INFRACTION_POINTS, guild.getIdLong());
-            AUserInAServer mutedUser = userInServerManagementService.loadOrCreateUser(context.getMutedUser());
-            AUserInAServer mutingUser = userInServerManagementService.loadOrCreateUser(context.getMutingUser());
+    public CompletableFuture<Long> evaluateAndStoreInfraction(ServerUser userToMute, ServerUser mutingUser, String reason, Instant targetDate, Message logMessage) {
+        Long serverId = userToMute.getServerId();
+        if(featureFlagService.getFeatureFlagValue(ModerationFeatureDefinition.INFRACTIONS, serverId)) {
+            Long infractionPoints = configService.getLongValueOrConfigDefault(MutingFeatureConfig.MUTE_INFRACTION_POINTS, serverId);
+            AUserInAServer mutedUserInAServer = userInServerManagementService.loadOrCreateUser(userToMute);
+            AUserInAServer mutingUserInAServer = userInServerManagementService.loadOrCreateUser(mutingUser);
             Map<String, String> parameters = new HashMap<>();
-            parameters.put(INFRACTION_PARAMETER_DURATION_KEY, templateService.renderDuration(Duration.between(Instant.now(), context.getMuteTargetDate()), guild.getIdLong()));
-            return infractionService.createInfractionWithNotification(mutedUser, infractionPoints, MUTE_INFRACTION_TYPE, context.getReason(), mutingUser, parameters, logMessage)
+            parameters.put(INFRACTION_PARAMETER_DURATION_KEY, templateService.renderDuration(Duration.between(Instant.now(), targetDate), serverId));
+            return infractionService.createInfractionWithNotification(mutedUserInAServer, infractionPoints, MUTE_INFRACTION_TYPE, reason, mutingUserInAServer, parameters, logMessage)
                     .thenApply(Infraction::getId);
         } else {
             return CompletableFuture.completedFuture(null);
@@ -228,26 +198,28 @@ public class MuteServiceBean implements MuteService {
     }
 
     @Transactional
-    public void persistMute(MuteContext context, Long infractionId) {
-        completelyUnMuteMember(context.getMutedUser());
-        String triggerKey = startUnMuteJobFor(context.getMuteTargetDate(), context.getMuteId(), context.getMutedUser().getGuild().getIdLong());
-        createMuteObject(context, triggerKey, infractionId);
+    public void persistMute(ServerUser userToMute, ServerUser mutingUser, Instant targetDate, Long muteId, String reason, Long infractionId, ServerChannelMessage origin) {
+        completelyUnMuteMember(userToMute);
+        String triggerKey = startUnMuteJobFor(targetDate, muteId, userToMute.getServerId());
+        createMuteObject(userToMute, mutingUser, reason, targetDate, muteId, triggerKey, infractionId, origin);
     }
 
     @Transactional
-    public CompletableFuture<Message> sendMuteLog(MuteContext muteLogModel)  {
+    public CompletableFuture<Message> sendMuteLog(ServerUser userBeingMuted, ServerUser mutingUser, Duration duration, String reason)  {
+        Instant targetDate = Instant.now().plus(duration);
         MuteListenerModel model = MuteListenerModel
                 .builder()
-                .mutedUser(muteLogModel.getMutedUser())
-                .mutingUser(muteLogModel.getMutingUser())
-                .channelId(muteLogModel.getChannelId())
+                .mutedUser(MemberDisplay.fromServerUser(userBeingMuted))
+                .mutingUser(MemberDisplay.fromServerUser(mutingUser))
                 .oldMuteTargetDate(null)
-                .muteTargetDate(muteLogModel.getMuteTargetDate())
-                .reason(muteLogModel.getReason())
+                .duration(duration)
+                .muteTargetDate(targetDate)
+                .reason(reason)
                 .build();
         log.debug("Sending mute log to the mute post target.");
-        MessageToSend message = templateService.renderEmbedTemplate(MUTE_LOG_TEMPLATE, model, muteLogModel.getMutedUser().getIdLong());
-        List<CompletableFuture<Message>> futures = postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, muteLogModel.getMutedUser().getGuild().getIdLong());
+        Long serverId = userBeingMuted.getServerId();
+        MessageToSend message = templateService.renderEmbedTemplate(MUTE_LOG_TEMPLATE, model, serverId);
+        List<CompletableFuture<Message>> futures = postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, serverId);
         return FutureUtils.toSingleFutureGeneric(futures).thenApply(unused -> futures.get(0).join());
     }
 
@@ -268,45 +240,36 @@ public class MuteServiceBean implements MuteService {
 
     @Override
     @Transactional
-    public CompletableFuture<Void> unMuteUser(AUserInAServer userToUnmute, Member unMutingMember) {
-        boolean muteActive = muteManagementService.hasActiveMute(userToUnmute);
+    public CompletableFuture<Void> unMuteUser(ServerUser userToUnmute, ServerUser unMutingUser, Guild guild) {
+        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(userToUnmute);
+        boolean muteActive = muteManagementService.hasActiveMute(aUserInAServer);
         if(!muteActive) {
-            CompletableFuture<Member> unMutedMemberFuture = memberService.retrieveMemberInServer(ServerUser.fromAUserInAServer(userToUnmute));
-            return unMutedMemberFuture
-                    .thenCompose(member -> memberService.removeTimeout(member))
-                    .thenCompose(unused -> self.sendUnmuteLog(null, unMutingMember.getGuild(), unMutedMemberFuture.join(), unMutingMember));
+            return memberService.removeTimeout(guild, userToUnmute, null)
+                    .thenCompose(unused -> self.sendUnmuteLog(null, guild, userToUnmute, unMutingUser));
         } else {
-            Mute mute = muteManagementService.getAMuteOf(userToUnmute);
-            return endMute(mute);
+            Mute mute = muteManagementService.getAMuteOf(aUserInAServer);
+            return endMute(mute, guild);
         }
     }
 
     @Override
-    public CompletableFuture<Void> endMute(Mute mute) {
+    public CompletableFuture<Void> endMute(Mute mute, Guild guild) {
         if(mute.getMuteEnded()) {
             log.info("Mute {} in server {} has already ended. Not unmuting.", mute.getMuteId().getId(), mute.getMuteId().getServerId());
             return CompletableFuture.completedFuture(null);
         }
         Long muteId = mute.getMuteId().getId();
-        Guild guild = guildService.getGuildById(mute.getMuteId().getServerId());
         AServer mutingServer = mute.getServer();
+        ServerUser mutedUser = ServerUser.fromAUserInAServer(mute.getMutedUser());
+        ServerUser mutingUser = ServerUser.fromAUserInAServer(mute.getMutedUser());
         log.info("UnMuting {} in server {}", mute.getMutedUser().getUserReference().getId(), mutingServer.getId());
-        CompletableFuture<Member> mutedMemberFuture = memberService.getMemberInServerAsync(mute.getMutedUser());
-        CompletableFuture<Member> mutingMemberFuture = memberService.getMemberInServerAsync(mute.getMutingUser());
-        return CompletableFuture.allOf(mutedMemberFuture, mutingMemberFuture)
-                .thenAccept(member -> memberService.removeTimeout(mutedMemberFuture.join()))
-                .thenCompose(unused -> self.sendUnmuteLog(muteId, guild, mutingMemberFuture, mutedMemberFuture));
+        return memberService.removeTimeout(guild, mutedUser, null)
+                .thenCompose(unused -> self.sendUnmuteLog(muteId, guild, mutedUser, mutingUser));
     }
 
-    @Transactional
-    public CompletableFuture<Void> sendUnmuteLog(Long muteId, Guild guild, CompletableFuture<Member> mutingMemberFuture, CompletableFuture<Member> mutedMemberFuture) {
-        Member mutingMember = !mutingMemberFuture.isCompletedExceptionally() ? mutingMemberFuture.join() : null;
-        Member mutedMember = !mutedMemberFuture.isCompletedExceptionally() ? mutedMemberFuture.join() : null;
-        return sendUnmuteLog(muteId, guild, mutedMember, mutingMember);
-    }
 
     @Transactional
-    public CompletableFuture<Void> sendUnmuteLog(Long muteId, Guild guild, Member mutedMember, Member mutingMember) {
+    public CompletableFuture<Void> sendUnmuteLog(Long muteId, Guild guild, ServerUser unMutedMember, ServerUser mutingMember) {
         Mute mute = null;
         if(muteId != null) {
             mute = muteManagementService.findMute(muteId, guild.getIdLong());
@@ -315,9 +278,8 @@ public class MuteServiceBean implements MuteService {
         UnMuteLog unMuteLog = UnMuteLog
                 .builder()
                 .mute(mute)
-                .mutingUser(mutingMember)
-                .unMutedUser(mutedMember)
-                .guild(guild)
+                .mutingUser(MemberDisplay.fromServerUser(mutingMember))
+                .unMutedUser(MemberDisplay.fromServerUser(unMutedMember))
                 .build();
         CompletableFuture<Void> notificationFuture = sendUnMuteLogMessage(unMuteLog, mutingServer);
         return CompletableFuture.allOf(notificationFuture).thenAccept(aVoid -> {
@@ -341,7 +303,8 @@ public class MuteServiceBean implements MuteService {
         log.info("UnMuting the mute {} in server {}", muteId, serverId);
         Optional<Mute> muteOptional = muteManagementService.findMuteOptional(muteId, serverId);
         if(muteOptional.isPresent()) {
-            return endMute(muteOptional.get());
+            Guild guild = guildService.getGuildById(serverId);
+            return endMute(muteOptional.get(), guild);
         } else {
             throw new NoMuteFoundException();
         }
@@ -359,8 +322,8 @@ public class MuteServiceBean implements MuteService {
     }
 
     @Override
-    public void completelyUnMuteMember(Member member) {
-        completelyUnMuteUser(userInServerManagementService.loadOrCreateUser(member));
+    public void completelyUnMuteMember(ServerUser serverUser) {
+        completelyUnMuteUser(userInServerManagementService.loadOrCreateUser(serverUser));
     }
 
 }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/ReactionReportServiceBean.java

@@ -12,6 +12,7 @@ import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefiniti
 import dev.sheldan.abstracto.moderation.config.feature.mode.ReportReactionMode;
 import dev.sheldan.abstracto.moderation.config.posttarget.ReactionReportPostTarget;
 import dev.sheldan.abstracto.moderation.listener.manager.ReportMessageCreatedListenerManager;
+import dev.sheldan.abstracto.moderation.model.ModerationActionButton;
 import dev.sheldan.abstracto.moderation.model.database.ModerationUser;
 import dev.sheldan.abstracto.moderation.model.database.ReactionReport;
 import dev.sheldan.abstracto.moderation.model.template.listener.ReportReactionNotificationModel;
@@ -27,6 +28,7 @@ import org.springframework.transaction.annotation.Transactional;
 import java.time.Duration;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
@@ -68,6 +70,9 @@ public class ReactionReportServiceBean implements ReactionReportService {
     @Autowired
     private ReportMessageCreatedListenerManager reportMessageCreatedListenerManager;
 
+    @Autowired
+    private ModerationActionService moderationActionService;
+
     private static final String REACTION_REPORT_TEMPLATE_KEY = "reactionReport_notification";
     public static final String REACTION_REPORT_MODAL_ORIGIN = "reportMessageModal";
     public static final String REACTION_REPORT_RESPONSE_TEMPLATE = "reactionReport_response";
@@ -93,11 +98,19 @@ public class ReactionReportServiceBean implements ReactionReportService {
             return channelService.editFieldValueInMessage(reportTextChannel, report.getReportMessageId(), 0, report.getReportCount().toString())
                     .thenAccept(message -> self.updateModerationUserReportCooldown(reporter));
         } else {
+            boolean reportActionsEnabled = featureModeService.featureModeActive(ModerationFeatureDefinition.REPORT_REACTIONS, serverId, ReportReactionMode.REPORT_ACTIONS);
+            List<ModerationActionButton> moderationActionComponents = new ArrayList<>();
+            if(reportActionsEnabled) {
+                ServerUser reportedServerUser = ServerUser.fromAUserInAServer(reportedUser);
+                List<ModerationActionButton> moderationActions = moderationActionService.getModerationActionButtons(reportedServerUser);
+                moderationActionComponents.addAll(moderationActions);
+            }
             ReportReactionNotificationModel model = ReportReactionNotificationModel
                     .builder()
                     .reportCount(1)
                     .context(context)
                     .singularMessage(singularMessage)
+                    .moderationActionComponents(moderationActionComponents)
                     .reportedMessage(reportedMessage)
                     .build();
             MessageToSend messageToSend = templateService.renderEmbedTemplate(REACTION_REPORT_TEMPLATE_KEY, model, serverId);