[AB-xxx] changing the method used to edit the giveaway message

fixing reminder message not containing a link to the message anymore

.env

@@ -1,2 +1,2 @@
 REGISTRY_PREFIX=harbor.sheldan.dev/abstracto/
-VERSION=1.6.2
+VERSION=1.6.11

README.md

@@ -11,7 +11,7 @@ This repository does not provide the full functionality in order to start a disc
 
 
 ## Technologies
-* [JDA](https://github.com/DV8FromTheWorld/JDA/) The Discord API Wrapper in the version 5.0.0-beta.21
+* [JDA](https://github.com/DV8FromTheWorld/JDA/) The Discord API Wrapper in the version 5.4.0
 * [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.
@@ -30,4 +30,4 @@ If you want to view the documentation to an earlier released version you need to
 If you find any issue, feel free to create a GitHub issue.
 
 ## License
-This project is licensed under the MIT license.
+This project is licensed under the MIT license.

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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/ActivateAssignableRolePlace.java

@@ -1,16 +1,26 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.stream.Collectors;
+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;
 
@@ -24,37 +34,78 @@ import java.util.concurrent.CompletableFuture;
 @Component
 public class ActivateAssignableRolePlace extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String ACTIVATE_ASSIGNABLE_ROLE_PLACE_RESPONSE = "activateAssignableRolePlace_response";
     @Autowired
     private AssignableRolePlaceService service;
 
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
+
     @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
-        String name = (String) parameters.get(0);
+        AServer server = serverManagementService.loadServer(event.getGuild());
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return service.activateAssignableRolePlace(server, assignableRolePlaceName)
-        return service.activateAssignableRolePlace(server, name)
+            .thenAccept(unused -> interactionService.replyEmbed(ACTIVATE_ASSIGNABLE_ROLE_PLACE_RESPONSE, new Object(), event))
-                .thenApply(unused -> CommandResult.fromSuccess());
+            .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            return assignableRolePlaceManagementService.getAssignableRolePlacesWithNamesContaining(input, server)
+                .stream().map(assignableRolePlace -> assignableRolePlace.getKey().toLowerCase())
+                .collect(Collectors.toList());
+        }
+        return new ArrayList<>();
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter placeName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
+                .supportsAutoComplete(true)
                 .templated(true)
                 .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("place")
+            .commandName("activate")
+            .build();
+
         List<Parameter> parameters = Arrays.asList(placeName);
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        HelpInfo helpInfo = HelpInfo
+            .builder()
+            .templated(true)
+            .build();
         return CommandConfiguration.builder()
                 .name("activateAssignableRolePlace")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
-                .messageCommandOnly(true)
                 .async(true)
+                .slashCommandConfig(slashCommandConfig)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .causesReaction(true)
                 .parameters(parameters)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/AddAssignableRoleCondition.java

@@ -1,16 +1,30 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.model.condition.AssignableRoleConditionType;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRoleConditionService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandParameterKey;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
 import net.dv8tion.jda.api.entities.Role;
+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;
 
@@ -20,43 +34,79 @@ import java.util.List;
 @Component
 public class AddAssignableRoleCondition extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String ASSIGNABLE_ROLE_PARAMETER = "role";
+    private static final String CONDITION_KEY_PARAMETER = "conditionKey";
+    private static final String CONDITION_PARAMETER_PARAMETER = "conditionParameter";
+    private static final String ADD_ASSIGNABLE_ROLE_CONDITION_RESPONSE = "addAssignableRoleCondition_response";
+
     @Autowired
     private AssignableRoleConditionService assignableRoleConditionService;
 
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
-    public CommandResult execute(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
-        String name = (String) parameters.get(0);
+        Role role = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PARAMETER, event, Role.class);
-        Role role = (Role) parameters.get(1);
+        String configKeyString = slashCommandParameterService.getCommandOption(CONDITION_KEY_PARAMETER, event, String.class);
-        AssignableRoleConditionType configKey = (AssignableRoleConditionType) parameters.get(2);
+        AssignableRoleConditionType configKey = CommandParameterKey.getEnumFromKey(AssignableRoleConditionType.class, configKeyString);
-        String parameterValue = (String) parameters.get(3);
+        String parameterValue = slashCommandParameterService.getCommandOption(CONDITION_PARAMETER_PARAMETER, event, String.class);
-        assignableRoleConditionService.createAssignableRoleCondition(name, role, configKey, parameterValue);
+        assignableRoleConditionService.createAssignableRoleCondition(assignableRolePlaceName, role, configKey, parameterValue);
-        return CommandResult.fromSuccess();
+        return interactionService.replyEmbed(ADD_ASSIGNABLE_ROLE_CONDITION_RESPONSE, event)
+            .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            return assignableRolePlaceManagementService.getAssignableRolePlacesWithNamesContaining(input, server)
+                .stream().map(assignableRolePlace -> assignableRolePlace.getKey().toLowerCase())
+                .collect(Collectors.toList());
+        }
+        return new ArrayList<>();
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter placeName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
+                .supportsAutoComplete(true)
                 .templated(true)
                 .build();
         Parameter role = Parameter
                 .builder()
-                .name("role")
+                .name(ASSIGNABLE_ROLE_PARAMETER)
                 .type(Role.class)
                 .templated(true)
                 .build();
         Parameter conditionKey = Parameter
                 .builder()
-                .name("conditionKey")
+                .name(CONDITION_KEY_PARAMETER)
                 .type(AssignableRoleConditionType.class)
                 .templated(true)
                 .build();
+
         Parameter conditionValue = Parameter
                 .builder()
-                .name("conditionParameter")
+                .name(CONDITION_PARAMETER_PARAMETER)
                 .type(String.class)
                 .templated(true)
                 .build();
@@ -65,11 +115,22 @@ public class AddAssignableRoleCondition extends AbstractConditionableCommand {
                 .builder()
                 .templated(true)
                 .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("role")
+            .commandName("addcondition")
+            .build();
+
         return CommandConfiguration.builder()
                 .name("addAssignableRoleCondition")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
-                .messageCommandOnly(true)
+                .slashCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .causesReaction(true)
                 .parameters(parameters)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/AddRoleToAssignableRolePlace.java

@@ -0,0 +1,170 @@
+package dev.sheldan.abstracto.assignableroles.command;
+
+import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
+import dev.sheldan.abstracto.assignableroles.exception.AssignableRoleNotUsableException;
+import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
+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.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.models.database.AEmote;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.RoleService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.stream.Collectors;
+import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.entities.emoji.Emoji;
+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.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Command used to add an {@link dev.sheldan.abstracto.assignableroles.model.database.AssignableRole assignableRole}
+ * to an {@link dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlace place}
+ */
+@Component
+public class AddRoleToAssignableRolePlace extends AbstractConditionableCommand {
+
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String ASSIGNABLE_ROLE_PARAMETER = "role";
+    private static final String DISPLAY_TEXT_PARAMETER = "displayText";
+    private static final String EMOTE_PARAMETER = "emote";
+
+    private static final String ADD_ROLE_TO_ASSIGNABLE_ROLE_POST_RESPONSE = "addRoleToAssignableRolePlace_response";
+    @Autowired
+    private AssignableRolePlaceService service;
+
+    @Autowired
+    private RoleService roleService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        Role role = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PARAMETER, event, Role.class);
+        String displayText;
+        if(slashCommandParameterService.hasCommandOption(DISPLAY_TEXT_PARAMETER, event)) {
+            displayText = slashCommandParameterService.getCommandOption(DISPLAY_TEXT_PARAMETER, event, String.class);
+        } else {
+            displayText = null;
+        }
+
+        Emoji emoji;
+        if(slashCommandParameterService.hasCommandOption(EMOTE_PARAMETER, event)) {
+            String emoteText = slashCommandParameterService.getCommandOption(EMOTE_PARAMETER, event, String.class);
+            emoji = slashCommandParameterService.loadEmoteFromString(emoteText, event.getGuild());
+        } else {
+            emoji = null;
+        }
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        // already used check via role and assignable role place name
+        if(!roleService.canBotInteractWithRole(role)) {
+            throw new AssignableRoleNotUsableException(role);
+        }
+        return service.addRoleToAssignableRolePlace(server, assignableRolePlaceName, role, emoji, displayText)
+            .thenAccept(unused -> interactionService.replyEmbed(ADD_ROLE_TO_ASSIGNABLE_ROLE_POST_RESPONSE, event))
+            .thenApply(aVoid -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            return assignableRolePlaceManagementService.getAssignableRolePlacesWithNamesContaining(input, server)
+                .stream().map(assignableRolePlace -> assignableRolePlace.getKey().toLowerCase())
+                .collect(Collectors.toList());
+        }
+        return new ArrayList<>();
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter placeName = Parameter
+                .builder()
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
+                .type(String.class)
+                .supportsAutoComplete(true)
+                .templated(true)
+                .build();
+        Parameter role = Parameter
+                .builder()
+                .name(ASSIGNABLE_ROLE_PARAMETER)
+                .type(Role.class)
+                .templated(true)
+                .build();
+        Parameter rolePostName = Parameter
+                .builder()
+                .name(DISPLAY_TEXT_PARAMETER)
+                .type(String.class)
+                .templated(true)
+                .build();
+        Parameter emote = Parameter
+                .builder()
+                .name(EMOTE_PARAMETER)
+                .type(AEmote.class)
+                .optional(true)
+                .templated(true)
+                .build();
+        List<Parameter> parameters = Arrays.asList(placeName, role, rolePostName, emote);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("role")
+            .commandName("add")
+            .build();
+
+        return CommandConfiguration.builder()
+                .name("addRoleToAssignableRolePlace")
+                .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
+                .templated(true)
+                .causesReaction(true)
+                .slashCommandConfig(slashCommandConfig)
+                .async(true)
+                .supportsEmbedException(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return AssignableRoleFeatureDefinition.ASSIGNABLE_ROLES;
+    }
+}

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/AddRoleToAssignableRolePost.java

@@ -1,112 +0,0 @@
-package dev.sheldan.abstracto.assignableroles.command;
-
-import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
-import dev.sheldan.abstracto.assignableroles.exception.AssignableRoleNotUsableException;
-import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
-import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
-import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
-import dev.sheldan.abstracto.core.command.config.HelpInfo;
-import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.config.FeatureDefinition;
-import dev.sheldan.abstracto.core.models.FullEmote;
-import dev.sheldan.abstracto.core.models.database.AServer;
-import dev.sheldan.abstracto.core.service.RoleService;
-import dev.sheldan.abstracto.core.service.management.ServerManagementService;
-import net.dv8tion.jda.api.entities.Role;
-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;
-
-/**
- * Command used to add an {@link dev.sheldan.abstracto.assignableroles.model.database.AssignableRole assignableRole}
- * to an {@link dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlace place}
- */
-@Component
-public class AddRoleToAssignableRolePost extends AbstractConditionableCommand {
-
-    @Autowired
-    private AssignableRolePlaceService service;
-
-    @Autowired
-    private RoleService roleService;
-
-    @Autowired
-    private ServerManagementService serverManagementService;
-
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        Role role = (Role) parameters.get(1);
-        String description = null;
-        if (parameters.size() > 2) {
-            description = (String) parameters.get(2);
-        }
-        FullEmote emote = null;
-        if(parameters.size() > 3) {
-            emote = (FullEmote) parameters.get(3);
-        }
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        // already used check via role and assignable role place name
-        if(!roleService.canBotInteractWithRole(role)) {
-            throw new AssignableRoleNotUsableException(role);
-        }
-        return service.addRoleToAssignableRolePlace(server, name, role, emote, description)
-                .thenApply(aVoid -> CommandResult.fromSuccess());
-    }
-
-    @Override
-    public CommandConfiguration getConfiguration() {
-        Parameter placeName = Parameter
-                .builder()
-                .name("name")
-                .type(String.class)
-                .templated(true)
-                .build();
-        Parameter role = Parameter
-                .builder()
-                .name("role")
-                .type(Role.class)
-                .templated(true)
-                .build();
-        Parameter rolePostName = Parameter
-                .builder()
-                .name("displayText")
-                .type(String.class)
-                .templated(true)
-                .build();
-        Parameter emote = Parameter
-                .builder()
-                .name("emote")
-                .type(FullEmote.class)
-                .optional(true)
-                .templated(true)
-                .build();
-        List<Parameter> parameters = Arrays.asList(placeName, role, rolePostName, emote);
-        HelpInfo helpInfo = HelpInfo
-                .builder()
-                .templated(true)
-                .build();
-        return CommandConfiguration.builder()
-                .name("addRoleToAssignableRolePlace")
-                .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
-                .templated(true)
-                .causesReaction(true)
-                .messageCommandOnly(true)
-                .async(true)
-                .supportsEmbedException(true)
-                .parameters(parameters)
-                .help(helpInfo)
-                .build();
-    }
-
-    @Override
-    public FeatureDefinition getFeature() {
-        return AssignableRoleFeatureDefinition.ASSIGNABLE_ROLES;
-    }
-}

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/ChangeAssignableRolePlaceConfig.java

@@ -2,17 +2,28 @@ package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceParameterKey;
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandParameterKey;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
+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;
 
@@ -27,52 +38,96 @@ import java.util.concurrent.CompletableFuture;
 @Slf4j
 public class ChangeAssignableRolePlaceConfig extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String CONFIGURATION_KEY_PARAMETER = "key";
+    private static final String CONFIGURATION_VALUE_PARAMETER = "value";
+    private static final String CHANGE_ASSIGNABLE_ROLE_PLACE_CONFIG_RESPONSE = "changeAssignableRolePlaceConfig_response";
     @Autowired
     private AssignableRolePlaceService service;
 
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
 
     @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
-        String name = (String) parameters.get(0);
+        String assignableRolePlaceParameterKeyString = slashCommandParameterService.getCommandOption(CONFIGURATION_KEY_PARAMETER, event, String.class);
-        AssignableRolePlaceParameterKey configKey = (AssignableRolePlaceParameterKey) parameters.get(1);
+        AssignableRolePlaceParameterKey enumFromKey =
-        String parameterValue = (String) parameters.get(2);
+            CommandParameterKey.getEnumFromKey(AssignableRolePlaceParameterKey.class, assignableRolePlaceParameterKeyString);
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        String parameterValue = slashCommandParameterService.getCommandOption(CONFIGURATION_VALUE_PARAMETER, event, String.class);
-        return service.changeConfiguration(server, name, configKey, parameterValue)
+        AServer server = serverManagementService.loadServer(event.getGuild());
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+        return service.changeConfiguration(server, assignableRolePlaceName, enumFromKey, parameterValue)
+            .thenAccept(unused -> interactionService.replyEmbed(CHANGE_ASSIGNABLE_ROLE_PLACE_CONFIG_RESPONSE, event))
+            .thenApply(aVoid -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            return assignableRolePlaceManagementService.getAssignableRolePlacesWithNamesContaining(input, server)
+                .stream().map(assignableRolePlace -> assignableRolePlace.getKey().toLowerCase())
+                .collect(Collectors.toList());
+        }
+        return new ArrayList<>();
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter assignableRolePlaceName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
+                .supportsAutoComplete(true)
                 .templated(true)
                 .build();
         Parameter parameterKey = Parameter
                 .builder()
-                .name("key")
+                .name(CONFIGURATION_KEY_PARAMETER)
                 .type(AssignableRolePlaceParameterKey.class)
                 .templated(true)
                 .build();
         Parameter parameterValue = Parameter
                 .builder()
-                .name("value")
+                .name(CONFIGURATION_VALUE_PARAMETER)
                 .type(String.class)
                 .templated(true)
                 .build();
 
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("place")
+            .commandName("changeconfig")
+            .build();
+
         List<Parameter> parameters = Arrays.asList(assignableRolePlaceName, parameterKey, parameterValue);
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        HelpInfo helpInfo = HelpInfo
+            .builder()
+            .templated(true)
+            .build();
         return CommandConfiguration.builder()
                 .name("changeAssignableRolePlaceConfig")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
-                .messageCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
+                .slashCommandOnly(true)
                 .async(true)
                 .supportsEmbedException(true)
                 .causesReaction(true)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/CreateAssignableRolePlace.java

@@ -1,6 +1,7 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlace;
 import dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlaceType;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
@@ -10,14 +11,20 @@ import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.config.ParameterValidator;
 import dev.sheldan.abstracto.core.command.config.validator.MaxStringLengthValidator;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandParameterKey;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 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.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
-import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.concurrent.CompletableFuture;
 import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
+import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -25,30 +32,44 @@ import java.util.Arrays;
 import java.util.List;
 
 @Component
-public class CreateAssignableRolePost extends AbstractConditionableCommand {
+public class CreateAssignableRolePlace extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String ASSIGNABLE_ROLE_PLACE_CHANNEL_PARAMETER = "channel";
+    private static final String ASSIGNABLE_ROLE_PLACE_TYPE_PARAMETER = "type";
+    private static final String ASSIGNABLE_ROLE_PLACE_TEXT_PARAMETER = "text";
+    private static final String CREATE_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE = "createAssignableRolePlace_response";
     @Autowired
     private AssignableRolePlaceService service;
 
     @Autowired
     private ChannelManagementService channelManagementService;
 
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private InteractionService interactionService;
+
     @Override
-    public CommandResult execute(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
-        String name = (String) parameters.get(0);
+        GuildChannel channel = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_CHANNEL_PARAMETER, event, TextChannel.class, GuildChannel.class);
-        TextChannel channel = (TextChannel) parameters.get(1);
+        if(!channel.getGuild().equals(event.getGuild())) {
-        String text =  (String) parameters.get(2);
-        AssignableRolePlaceType type = AssignableRolePlaceType.DEFAULT;
-        if(parameters.size() > 3) {
-            type = (AssignableRolePlaceType) parameters.get(3);
-        }
-        if(!channel.getGuild().equals(commandContext.getGuild())) {
             throw new EntityGuildMismatchException();
         }
+        String text = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_TEXT_PARAMETER, event, String.class);
+        AssignableRolePlaceType type;
+        if(slashCommandParameterService.hasCommandOption(ASSIGNABLE_ROLE_PLACE_TYPE_PARAMETER, event)) {
+            String typeString = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_TYPE_PARAMETER, event, String.class);
+            type = CommandParameterKey.getEnumFromKey(AssignableRolePlaceType.class, typeString);
+        } else {
+            type = AssignableRolePlaceType.DEFAULT;
+        }
         AChannel chosenChannel = channelManagementService.loadChannel(channel.getIdLong());
-        service.createAssignableRolePlace(name, chosenChannel, text, type);
+        service.createAssignableRolePlace(assignableRolePlaceName, chosenChannel, text, type);
-        return CommandResult.fromSuccess();
+        return interactionService.replyEmbed(CREATE_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE, event)
+            .thenApply(interactionHook -> CommandResult.fromSuccess());
     }
 
     @Override
@@ -56,20 +77,20 @@ public class CreateAssignableRolePost extends AbstractConditionableCommand {
         List<ParameterValidator> rolePlaceNameValidator = Arrays.asList(MaxStringLengthValidator.max(AssignableRolePlace.ASSIGNABLE_PLACE_NAME_LIMIT));
         Parameter rolePostName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .validators(rolePlaceNameValidator)
                 .type(String.class)
                 .templated(true)
                 .build();
         Parameter channel = Parameter
                 .builder()
-                .name("channel")
+                .name(ASSIGNABLE_ROLE_PLACE_CHANNEL_PARAMETER)
                 .type(TextChannel.class)
                 .templated(true)
                 .build();
         Parameter type = Parameter
                 .builder()
-                .name("type")
+                .name(ASSIGNABLE_ROLE_PLACE_TYPE_PARAMETER)
                 .type(AssignableRolePlaceType.class)
                 .templated(true)
                 .optional(true)
@@ -77,11 +98,21 @@ public class CreateAssignableRolePost extends AbstractConditionableCommand {
         List<ParameterValidator> rolePlaceDescriptionValidator = Arrays.asList(MaxStringLengthValidator.max(AssignableRolePlace.ASSIGNABLE_PLACE_NAME_LIMIT));
         Parameter text = Parameter
                 .builder()
-                .name("text")
+                .name(ASSIGNABLE_ROLE_PLACE_TEXT_PARAMETER)
                 .validators(rolePlaceDescriptionValidator)
                 .type(String.class)
                 .templated(true)
                 .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("place")
+            .commandName("create")
+            .build();
+
         List<String> aliases = Arrays.asList("crRPl", "crAssRoPl");
         List<Parameter> parameters = Arrays.asList(rolePostName, channel, text, type);
         HelpInfo helpInfo = HelpInfo
@@ -94,7 +125,8 @@ public class CreateAssignableRolePost extends AbstractConditionableCommand {
                 .templated(true)
                 .supportsEmbedException(true)
                 .causesReaction(true)
-                .messageCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
+                .slashCommandOnly(true)
                 .parameters(parameters)
                 .aliases(aliases)
                 .help(helpInfo)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/DeactivateAssignableRolePlace.java

@@ -1,16 +1,26 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.stream.Collectors;
+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;
 
@@ -24,37 +34,78 @@ import java.util.concurrent.CompletableFuture;
 @Component
 public class DeactivateAssignableRolePlace extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String DEACTIVATE_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE = "deactivateAssignableRolePlace_response";
     @Autowired
     private AssignableRolePlaceService service;
 
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
+
     @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
-        String name = (String) parameters.get(0);
+        AServer server = serverManagementService.loadServer(event.getGuild());
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return service.deactivateAssignableRolePlace(server, assignableRolePlaceName)
-        return service.deactivateAssignableRolePlace(server, name)
+            .thenAccept(unused -> interactionService.replyEmbed(DEACTIVATE_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE, event))
-                .thenApply(unused -> CommandResult.fromSuccess());
+            .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            return assignableRolePlaceManagementService.getAssignableRolePlacesWithNamesContaining(input, server)
+                .stream().map(assignableRolePlace -> assignableRolePlace.getKey().toLowerCase())
+                .collect(Collectors.toList());
+        }
+        return new ArrayList<>();
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter rolePostName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
+                .supportsAutoComplete(true)
                 .templated(true)
                 .build();
         List<Parameter> parameters = Arrays.asList(rolePostName);
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        HelpInfo helpInfo = HelpInfo
+            .builder()
+            .templated(true)
+            .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("place")
+            .commandName("deactivate")
+            .build();
+
         return CommandConfiguration.builder()
                 .name("deactivateAssignableRolePlace")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
                 .async(true)
-                .messageCommandOnly(true)
+                .slashCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .causesReaction(true)
                 .parameters(parameters)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/DeleteAssignableRolePlace.java

@@ -1,16 +1,26 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandService;
+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.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.stream.Collectors;
+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;
 
@@ -24,38 +34,80 @@ import java.util.concurrent.CompletableFuture;
 @Component
 public class DeleteAssignableRolePlace extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String DELETE_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE = "deleteAssignableRolePlace_response";
+
     @Autowired
     private AssignableRolePlaceService service;
 
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private SlashCommandService slashCommandService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
+
     @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
-        String name = (String) parameters.get(0);
+        AServer server = serverManagementService.loadServer(event.getGuild());
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return service.deleteAssignableRolePlace(server, assignableRolePlaceName)
-        return service.deleteAssignableRolePlace(server, name)
+            .thenAccept(unused -> slashCommandService.completeConfirmableCommand(event, DELETE_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE))
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+            .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            return assignableRolePlaceManagementService.getAssignableRolePlacesWithNamesContaining(input, server)
+                .stream().map(assignableRolePlace -> assignableRolePlace.getKey().toLowerCase())
+                .collect(Collectors.toList());
+        }
+        return new ArrayList<>();
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter rolePostName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
+                .supportsAutoComplete(true)
                 .templated(true)
                 .build();
         List<Parameter> parameters = Arrays.asList(rolePostName);
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("place")
+            .commandName("delete")
+            .build();
+
+        HelpInfo helpInfo = HelpInfo
+            .builder()
+            .templated(true)
+            .build();
         return CommandConfiguration.builder()
                 .name("deleteAssignableRolePlace")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
                 .causesReaction(true)
                 .async(true)
-                .messageCommandOnly(true)
+                .slashCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
                 .requiresConfirmation(true)
                 .supportsEmbedException(true)
                 .parameters(parameters)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/EditAssignableRolePlaceText.java

@@ -1,83 +0,0 @@
-package dev.sheldan.abstracto.assignableroles.command;
-
-import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
-import dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlace;
-import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
-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.config.ParameterValidator;
-import dev.sheldan.abstracto.core.command.config.validator.MaxStringLengthValidator;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.config.FeatureDefinition;
-import dev.sheldan.abstracto.core.models.database.AServer;
-import dev.sheldan.abstracto.core.service.management.ServerManagementService;
-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;
-
-/**
- * Command used to change the text of an {@link AssignableRolePlace place}
- */
-@Component
-public class EditAssignableRolePlaceText extends AbstractConditionableCommand {
-
-    @Autowired
-    private AssignableRolePlaceService service;
-
-    @Autowired
-    private ServerManagementService serverManagementService;
-
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        String newText = (String) parameters.get(1);
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        return service.changeTextAsync(server, name, newText)
-                .thenApply(aVoid ->  CommandResult.fromSuccess());
-    }
-
-    @Override
-    public CommandConfiguration getConfiguration() {
-        List<ParameterValidator> rolePlaceNameValidator = Arrays.asList(MaxStringLengthValidator.max(AssignableRolePlace.ASSIGNABLE_PLACE_NAME_LIMIT));
-        Parameter rolePostName = Parameter
-                .builder().name("name")
-                .validators(rolePlaceNameValidator)
-                .type(String.class)
-                .templated(true)
-                .build();
-        Parameter newText = Parameter
-                .builder()
-                .name("newText")
-                .type(String.class)
-                .templated(true)
-                .build();
-        List<Parameter> parameters = Arrays.asList(rolePostName, newText);
-        HelpInfo helpInfo = HelpInfo
-                .builder()
-                .templated(true)
-                .build();
-        return CommandConfiguration.builder()
-                .name("editAssignableRolePlaceText")
-                .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
-                .templated(true)
-                .async(true)
-                .messageCommandOnly(true)
-                .supportsEmbedException(true)
-                .causesReaction(true)
-                .parameters(parameters)
-                .help(helpInfo)
-                .build();
-    }
-
-    @Override
-    public FeatureDefinition getFeature() {
-        return AssignableRoleFeatureDefinition.ASSIGNABLE_ROLES;
-    }
-}

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/MoveAssignableRolePlace.java

@@ -1,7 +1,9 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
@@ -10,9 +12,20 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.exception.EntityGuildMismatchException;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.stream.Collectors;
 import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
+import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
+import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
+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;
 
@@ -27,12 +40,27 @@ import java.util.concurrent.CompletableFuture;
 @Component
 public class MoveAssignableRolePlace extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String NEW_CHANNEL_PARAMETER = "channel";
+    private static final String MOVE_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE = "moveAssignableRolePlace_response";
     @Autowired
     private AssignableRolePlaceService placeManagementService;
 
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
@@ -46,29 +74,69 @@ public class MoveAssignableRolePlace extends AbstractConditionableCommand {
         .thenApply(unused -> CommandResult.fromSuccess());
     }
 
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        GuildChannel channel = slashCommandParameterService.getCommandOption(NEW_CHANNEL_PARAMETER, event, TextChannel.class, GuildChannel.class);
+        if(!channel.getGuild().equals(event.getGuild()) && !(channel instanceof GuildMessageChannel)) {
+            throw new EntityGuildMismatchException();
+        }
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        return placeManagementService.moveAssignableRolePlace(server, assignableRolePlaceName, (GuildMessageChannel) channel)
+            .thenAccept(unused -> interactionService.replyEmbed(MOVE_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE, event))
+            .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            return assignableRolePlaceManagementService.getAssignableRolePlacesWithNamesContaining(input, server)
+                .stream().map(assignableRolePlace -> assignableRolePlace.getKey().toLowerCase())
+                .collect(Collectors.toList());
+        }
+        return new ArrayList<>();
+    }
+
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter rolePostName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
+                .supportsAutoComplete(true)
                 .templated(true)
                 .build();
         Parameter channel = Parameter
                 .builder()
-                .name("channel")
+                .name(NEW_CHANNEL_PARAMETER)
                 .type(TextChannel.class)
                 .templated(true)
                 .build();
         List<Parameter> parameters = Arrays.asList(rolePostName, channel);
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        HelpInfo helpInfo = HelpInfo
+            .builder()
+            .templated(true)
+            .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("place")
+            .commandName("move")
+            .build();
+
         return CommandConfiguration.builder()
                 .name("moveAssignableRolePlace")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
                 .causesReaction(true)
-                .messageCommandOnly(true)
+                .slashCommandOnly(true)
                 .async(true)
+                .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .parameters(parameters)
                 .help(helpInfo)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/RemoveAssignableRoleCondition.java

@@ -1,16 +1,30 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.model.condition.AssignableRoleConditionType;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRoleConditionService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandParameterKey;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
 import net.dv8tion.jda.api.entities.Role;
+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;
 
@@ -20,46 +34,96 @@ import java.util.List;
 @Component
 public class RemoveAssignableRoleCondition extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String ASSIGNABLE_ROLE_PARAMETER = "role";
+    private static final String CONDITION_KEY_PARAMETER = "conditionKey";
+
+    private static final String REMOVE_ASSIGNABLE_ROLE_CONDITION_RESPONSE_TEMPLATE = "removeAssignableRoleCondition_response";
+
     @Autowired
     private AssignableRoleConditionService assignableRoleConditionService;
 
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
-    public CommandResult execute(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
-        String name = (String) parameters.get(0);
+        Role assignableRole = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PARAMETER, event, Role.class);
-        Role role = (Role) parameters.get(1);
+        String conditionKeyString = slashCommandParameterService.getCommandOption(CONDITION_KEY_PARAMETER, event, String.class);
-        AssignableRoleConditionType configKey = (AssignableRoleConditionType) parameters.get(2);
+
-        assignableRoleConditionService.deleteAssignableRoleCondition(name, role, configKey);
+        AssignableRoleConditionType assignableRoleConditionType = CommandParameterKey.getEnumFromKey(AssignableRoleConditionType.class, conditionKeyString);
-        return CommandResult.fromSuccess();
+        assignableRoleConditionService.deleteAssignableRoleCondition(assignableRolePlaceName, assignableRole, assignableRoleConditionType);
+        return interactionService.replyEmbed(REMOVE_ASSIGNABLE_ROLE_CONDITION_RESPONSE_TEMPLATE, event)
+            .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            return assignableRolePlaceManagementService.getAssignableRolePlacesWithNamesContaining(input, server)
+                .stream().map(assignableRolePlace -> assignableRolePlace.getKey().toLowerCase())
+                .collect(Collectors.toList());
+        }
+        return new ArrayList<>();
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter placeName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
+                .supportsAutoComplete(true)
                 .templated(true)
                 .build();
         Parameter role = Parameter
                 .builder()
-                .name("role")
+                .name(ASSIGNABLE_ROLE_PARAMETER)
                 .type(Role.class)
                 .templated(true)
                 .build();
         Parameter conditionKey = Parameter
                 .builder()
-                .name("conditionKey")
+                .name(CONDITION_KEY_PARAMETER)
                 .type(AssignableRoleConditionType.class)
                 .templated(true)
                 .build();
         List<Parameter> parameters = Arrays.asList(placeName, role, conditionKey);
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        HelpInfo helpInfo = HelpInfo
+            .builder()
+            .templated(true)
+            .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("role")
+            .commandName("removecondition")
+            .build();
+
         return CommandConfiguration.builder()
                 .name("removeAssignableRoleCondition")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
-                .messageCommandOnly(true)
+                .slashCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .causesReaction(true)
                 .parameters(parameters)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/RemoveRoleFromAssignableRolePlace.java

@@ -1,17 +1,31 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.exception.SlashCommandParameterMissingException;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.stream.Collectors;
+import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.commands.OptionType;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -26,33 +40,73 @@ import java.util.concurrent.CompletableFuture;
 @Component
 public class RemoveRoleFromAssignableRolePlace extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String ASSIGNABLE_ROLE_PARAMETER = "role";
+    private static final String REMOVE_ROLE_FROM_ASSIGNABLE_ROLE_PLACE_RESPONSE = "removeRoleFromAssignableRolePlace_response";
     @Autowired
     private AssignableRolePlaceService service;
 
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private RoleManagementService roleManagementService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
+
     @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
-        String name = (String) parameters.get(0);
+        ARole actualRole;
-        ARole role = (ARole) parameters.get(1);
+        if(slashCommandParameterService.hasCommandOptionWithFullType(ASSIGNABLE_ROLE_PARAMETER, event, OptionType.ROLE)) {
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+            Role role = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PARAMETER, event, ARole.class, Role.class);
-        return service.removeRoleFromAssignableRolePlace(server, name, role)
+            actualRole = roleManagementService.findRole(role.getIdLong());
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+        } else if(slashCommandParameterService.hasCommandOptionWithFullType(ASSIGNABLE_ROLE_PARAMETER, event, OptionType.STRING)) {
+            String roleId = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PARAMETER, event, ARole.class, String.class);
+            actualRole = roleManagementService.findRole(Long.parseLong(roleId));
+        } else {
+            throw new SlashCommandParameterMissingException(ASSIGNABLE_ROLE_PARAMETER);
+        }
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        return service.removeRoleFromAssignableRolePlace(server, assignableRolePlaceName, actualRole)
+            .thenAccept(unused -> interactionService.replyEmbed(REMOVE_ROLE_FROM_ASSIGNABLE_ROLE_PLACE_RESPONSE, event))
+            .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            return assignableRolePlaceManagementService.getAssignableRolePlacesWithNamesContaining(input, server)
+                .stream().map(assignableRolePlace -> assignableRolePlace.getKey().toLowerCase())
+                .collect(Collectors.toList());
+        }
+        return new ArrayList<>();
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter rolePostName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
+                .supportsAutoComplete(true)
                 .templated(true)
                 .build();
         Parameter role = Parameter
                 .builder()
-                .name("role")
+                .name(ASSIGNABLE_ROLE_PARAMETER)
                 .type(ARole.class)
                 .templated(true)
                 .build();
@@ -61,13 +115,24 @@ public class RemoveRoleFromAssignableRolePlace extends AbstractConditionableComm
                 .builder()
                 .templated(true)
                 .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("role")
+            .commandName("remove")
+            .build();
+
         return CommandConfiguration.builder()
                 .name("removeRoleFromAssignableRolePlace")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
                 .causesReaction(true)
                 .async(true)
-                .messageCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .parameters(parameters)
                 .help(helpInfo)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/SetupAssignableRolePlace.java

@@ -1,18 +1,27 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AServer;
-import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
+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;
 
@@ -28,30 +37,54 @@ import java.util.concurrent.CompletableFuture;
 @Slf4j
 public class SetupAssignableRolePlace extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String SETUP_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE = "setupAssignableRolePlace_response";
     @Autowired
     private AssignableRolePlaceService service;
 
-    @Autowired
-    private ChannelService channelService;
-
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
+
     @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
-        String name = (String) parameters.get(0);
+        AServer server = serverManagementService.loadServer(event.getGuild());
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return service.setupAssignableRolePlace(server, assignableRolePlaceName)
-        return service.setupAssignableRolePlace(server, name)
+            .thenAccept(unused -> interactionService.replyEmbed(SETUP_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE, event))
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+            .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            AServer server = serverManagementService.loadServer(event.getGuild());
+            return assignableRolePlaceManagementService.getAssignableRolePlacesWithNamesContaining(input, server)
+                .stream().map(assignableRolePlace -> assignableRolePlace.getKey().toLowerCase())
+                .collect(Collectors.toList());
+        }
+        return new ArrayList<>();
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter rolePostName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
+                .supportsAutoComplete(true)
                 .templated(true)
                 .build();
         List<Parameter> parameters = Arrays.asList(rolePostName);
@@ -59,12 +92,23 @@ public class SetupAssignableRolePlace extends AbstractConditionableCommand {
                 .builder()
                 .templated(true)
                 .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("place")
+            .commandName("setup")
+            .build();
+
         return CommandConfiguration.builder()
                 .name("setupAssignableRolePlace")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
                 .async(true)
-                .messageCommandOnly(true)
+                .slashCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .causesReaction(true)
                 .parameters(parameters)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/ShowAssignableRolePlaceConfig.java

@@ -1,18 +1,20 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.model.template.AssignableRolePlaceConfig;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
-import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
-import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -30,27 +32,27 @@ public class ShowAssignableRolePlaceConfig extends AbstractConditionableCommand
     private AssignableRolePlaceService service;
 
     @Autowired
-    private ServerManagementService serverManagementService;
+    private InteractionService interactionService;
 
     @Autowired
-    private ChannelService channelService;
+    private SlashCommandParameterService slashCommandParameterService;
 
-    public static final String ASSIGNABLE_ROLES_CONFIG_POST_TEMPLATE_KEY = "assignable_roles_config_post";
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String ASSIGNABLE_ROLES_CONFIG_POST_TEMPLATE_KEY = "assignable_roles_config_post";
 
     @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
-        String name = (String) parameters.get(0);
+        AssignableRolePlaceConfig config = service.getAssignableRolePlaceConfig(event.getGuild(), assignableRolePlaceName);
-        AssignableRolePlaceConfig config = service.getAssignableRolePlaceConfig(commandContext.getGuild(), name);
+        return interactionService.replyEmbed(ASSIGNABLE_ROLES_CONFIG_POST_TEMPLATE_KEY, config, event)
-        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInMessageChannel(ASSIGNABLE_ROLES_CONFIG_POST_TEMPLATE_KEY, config, commandContext.getChannel()))
+            .thenApply(interactionHook -> CommandResult.fromSuccess());
-                .thenApply(unused -> CommandResult.fromSuccess());
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter rolePostName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
                 .templated(true)
                 .build();
@@ -59,13 +61,24 @@ public class ShowAssignableRolePlaceConfig extends AbstractConditionableCommand
                 .builder()
                 .templated(true)
                 .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("place")
+            .commandName("showconfig")
+            .build();
+
         return CommandConfiguration.builder()
                 .name("showAssignableRolePlaceConfig")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
                 .async(true)
                 .causesReaction(false)
-                .messageCommandOnly(true)
+                .slashCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .parameters(parameters)
                 .help(helpInfo)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/ShowAssignableRolePlaces.java

@@ -1,6 +1,7 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.model.template.AssignablePlaceOverview;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
@@ -9,10 +10,13 @@ import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -28,13 +32,13 @@ public class ShowAssignableRolePlaces extends AbstractConditionableCommand {
     @Autowired
     private AssignableRolePlaceService service;
 
-    @Autowired
-    private ServerManagementService serverManagementService;
-
     @Autowired
     private ChannelService channelService;
 
-    public static final String ASSIGNABLE_ROLE_PLACES_OVERVIEW_TEMPLATE_KEY = "assignable_role_places_overview";
+    @Autowired
+    private InteractionService interactionService;
+
+    private static final String ASSIGNABLE_ROLE_PLACES_OVERVIEW_TEMPLATE_KEY = "assignable_role_places_overview";
 
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
@@ -43,17 +47,35 @@ public class ShowAssignableRolePlaces extends AbstractConditionableCommand {
                 .thenApply(unused -> CommandResult.fromSuccess());
     }
 
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        AssignablePlaceOverview model = service.getAssignableRolePlaceOverview(event.getGuild());
+        return interactionService.replyEmbed(ASSIGNABLE_ROLE_PLACES_OVERVIEW_TEMPLATE_KEY, model, event)
+            .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
     @Override
     public CommandConfiguration getConfiguration() {
         HelpInfo helpInfo = HelpInfo
                 .builder()
                 .templated(true)
                 .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("place")
+            .commandName("show")
+            .build();
+
         return CommandConfiguration.builder()
                 .name("showAssignableRolePlaces")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
-                .messageCommandOnly(true)
+                .slashCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
                 .async(true)
                 .supportsEmbedException(true)
                 .help(helpInfo)

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/repository/AssignableRolePlaceRepository.java

@@ -37,5 +37,6 @@ public interface AssignableRolePlaceRepository extends JpaRepository<AssignableR
      * @return A list of {@link AssignableRolePlace places} which were found in the given {@link AServer server}
      */
     List<AssignableRolePlace> findByServer(AServer server);
+    List<AssignableRolePlace> findByKeyContainingIgnoreCaseAndServer(String name, AServer server);
 
 }

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/service/AssignableRolePlaceServiceBean.java

@@ -14,7 +14,6 @@ import dev.sheldan.abstracto.core.exception.EmoteNotUsableException;
 import dev.sheldan.abstracto.core.interaction.ComponentPayloadManagementService;
 import dev.sheldan.abstracto.core.interaction.ComponentPayloadService;
 import dev.sheldan.abstracto.core.interaction.ComponentService;
-import dev.sheldan.abstracto.core.models.FullEmote;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
@@ -28,8 +27,11 @@ import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.*;
 import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
+import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
 import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
-import net.dv8tion.jda.api.interactions.components.buttons.ButtonStyle;
+import net.dv8tion.jda.api.entities.emoji.CustomEmoji;
+import net.dv8tion.jda.api.entities.emoji.Emoji;
+import net.dv8tion.jda.api.components.buttons.ButtonStyle;
 import org.apache.commons.lang3.BooleanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -104,7 +106,7 @@ public class AssignableRolePlaceServiceBean implements AssignableRolePlaceServic
 
     @Override
     @Transactional
-    public CompletableFuture<Void> addRoleToAssignableRolePlace(AServer server, String placeName, Role role, FullEmote fakeEmote, String description) {
+    public CompletableFuture<Void> addRoleToAssignableRolePlace(AServer server, String placeName, Role role, Emoji emoji, String description) {
         AssignableRolePlace assignableRolePlace = rolePlaceManagementService.findByServerAndKey(server, placeName);
         if (assignableRolePlace.getAssignableRoles().size() > MAX_ASSIGNABLE_ROLES_PER_POST) {
             log.info("Assignable role place {} has already {} roles. Not possible to add more.", assignableRolePlace.getId(), assignableRolePlace.getAssignableRoles().size());
@@ -115,26 +117,26 @@ public class AssignableRolePlaceServiceBean implements AssignableRolePlaceServic
         }
         Long placeId = assignableRolePlace.getId();
         Long serverId = server.getId();
-        if (fakeEmote != null && fakeEmote.getEmote() != null) {
+        if (emoji instanceof CustomEmoji customEmoji) {
             // it only may be unusable if its a custom emote
             log.debug("Using custom emote {} to create assignable role {} for  assignable role place {} in server {}.",
-                    fakeEmote.getEmote().getId(), role.getId(), placeId, serverId);
+                customEmoji.getId(), role.getId(), placeId, serverId);
-            if (!emoteService.isEmoteUsableByBot(fakeEmote.getEmote())) {
+            if (!emoteService.isEmoteUsableByBot(customEmoji)) {
-                throw new EmoteNotUsableException(fakeEmote.getEmote());
+                throw new EmoteNotUsableException(customEmoji);
             }
         }
         Optional<GuildMessageChannel> channelOptional = channelService.getMessageChannelFromServerOptional(server.getId(), assignableRolePlace.getChannel().getId());
         if (channelOptional.isPresent()) {
             GuildMessageChannel textChannel = channelOptional.get();
             String buttonId = componentService.generateComponentId();
-            String emoteMarkdown = fakeEmote != null ? fakeEmote.getEmoteRepr() : null;
+            String emoteMarkdown = emoji != null ? emoji.getFormatted() : null;
             if (assignableRolePlace.getMessageId() != null) {
                 log.debug("Assignable role place {} has already message post with ID {} - updating.", assignableRolePlace.getId(), assignableRolePlace.getMessageId());
                 return componentService.addButtonToMessage(assignableRolePlace.getMessageId(), textChannel, buttonId, description, emoteMarkdown, ButtonStyle.SECONDARY)
-                        .thenAccept(message -> self.persistAssignableRoleAddition(placeId, role, description, fakeEmote, buttonId));
+                        .thenAccept(message -> self.persistAssignableRoleAddition(placeId, role, description, emoji, buttonId));
             } else {
                 log.info("Assignable role place {} is not yet setup - only adding role to the database.", assignableRolePlace.getId());
-                self.persistAssignableRoleAddition(placeId, role, description, fakeEmote, buttonId);
+                self.persistAssignableRoleAddition(placeId, role, description, emoji, buttonId);
                 return CompletableFuture.completedFuture(null);
             }
         } else {
@@ -143,11 +145,11 @@ public class AssignableRolePlaceServiceBean implements AssignableRolePlaceServic
     }
 
     @Transactional
-    public void persistAssignableRoleAddition(Long placeId, Role role, String description, FullEmote fakeEmote, String componentId) {
+    public void persistAssignableRoleAddition(Long placeId, Role role, String description, Emoji emoji, String componentId) {
         AssignableRolePlace place = assignableRolePlaceManagementServiceBean.findByPlaceId(placeId);
         log.info("Adding role {} to assignable role place {} with component ID {}.", role.getId(), place.getId(), componentId);
         ComponentPayload payload = persistButtonCallback(place, componentId, role.getIdLong());
-        assignableRoleManagementServiceBean.addRoleToPlace(fakeEmote, role, description, place, payload);
+        assignableRoleManagementServiceBean.addRoleToPlace(emoji, role, description, place, payload);
     }
 
     @Override
@@ -353,7 +355,7 @@ public class AssignableRolePlaceServiceBean implements AssignableRolePlaceServic
     }
 
     @Override
-    public CompletableFuture<Void> moveAssignableRolePlace(AServer server, String name, TextChannel newChannel) {
+    public CompletableFuture<Void> moveAssignableRolePlace(AServer server, String name, GuildMessageChannel newChannel) {
         AssignableRolePlace place = rolePlaceManagementService.findByServerAndKey(server, name);
         log.info("Moving assignable role place {} from channel {} to channel {} in guild {}.",
                 place.getId(), place.getChannel().getId(), newChannel.getId(), newChannel.getGuild().getIdLong());
@@ -381,7 +383,7 @@ public class AssignableRolePlaceServiceBean implements AssignableRolePlaceServic
     }
 
     @Transactional
-    public void updateAssignableRolePlaceChannel(String name, TextChannel textChannel) {
+    public void updateAssignableRolePlaceChannel(String name, GuildChannel textChannel) {
         AChannel channel = channelManagementService.loadChannel(textChannel.getIdLong());
         log.info("Setting assignable role place to channel {}.", textChannel.getIdLong());
         rolePlaceManagementService.moveAssignableRolePlace(name, channel);
@@ -400,7 +402,10 @@ public class AssignableRolePlaceServiceBean implements AssignableRolePlaceServic
     public void deleteAssignableRolePlaceInDatabase(Long placeId) {
         AssignableRolePlace place = rolePlaceManagementService.findByPlaceId(placeId);
         place.getAssignableRoles()
-                .forEach(assignableRole -> componentPayloadManagementService.deletePayload(assignableRole.getComponentPayload()));
+                .forEach(assignableRole -> {
+                    assignedRoleUserManagementServiceBean.removeAssignedRoleFromUsers(assignableRole);
+                    componentPayloadManagementService.deletePayload(assignableRole.getComponentPayload());
+                });
         rolePlaceManagementService.deleteAssignablePlace(place);
     }
 
@@ -414,13 +419,15 @@ public class AssignableRolePlaceServiceBean implements AssignableRolePlaceServic
 
     @Override
     public CompletableFuture<Void> changeConfiguration(AServer server, String name, AssignableRolePlaceParameterKey keyToChange, String newValue) {
-        Boolean booleanValue = BooleanUtils.toBooleanObject(newValue);
-        if (booleanValue == null) {
-            throw new CommandParameterKeyValueWrongTypeException(Arrays.asList("yes", "no", "true", "false", "on", "off"));
-        }
         if (keyToChange == AssignableRolePlaceParameterKey.UNIQUE) {
+            Boolean booleanValue = BooleanUtils.toBooleanObject(newValue);
+            if (booleanValue == null) {
+                throw new CommandParameterKeyValueWrongTypeException(Arrays.asList("yes", "no", "true", "false", "on", "off"));
+            }
             setAssignablePlaceUniqueTo(server, name, booleanValue);
             return CompletableFuture.completedFuture(null);
+        } else if(keyToChange == AssignableRolePlaceParameterKey.TEXT) {
+            return changeTextAsync(server, name, newValue);
         }
         throw new AssignableRolePlaceIllegalConfigurationException();
     }
@@ -518,7 +525,7 @@ public class AssignableRolePlaceServiceBean implements AssignableRolePlaceServic
 
 
     @Transactional
-    public CompletableFuture<Void> setupAssignableRolePlaceInChannel(Long serverId, Long assignablePlaceId, TextChannel textChannel) {
+    public CompletableFuture<Void> setupAssignableRolePlaceInChannel(Long serverId, Long assignablePlaceId, GuildMessageChannel textChannel) {
         AssignableRolePlace assignableRolePlace = rolePlaceManagementService.findByPlaceId(assignablePlaceId);
         log.info("Sending assignable role place posts for place {} in channel {} in server {}.", assignableRolePlace.getId(), textChannel.getId(), serverId);
         return sendAssignablePostMessage(assignableRolePlace, textChannel);

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/service/management/AssignableRoleManagementServiceBean.java

@@ -6,7 +6,6 @@ import dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlaceT
 import dev.sheldan.abstracto.assignableroles.model.database.AssignedRoleUser;
 import dev.sheldan.abstracto.assignableroles.repository.AssignableRoleRepository;
 import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
-import dev.sheldan.abstracto.core.models.FullEmote;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.ComponentPayload;
 import dev.sheldan.abstracto.core.service.EmoteService;
@@ -14,6 +13,7 @@ import dev.sheldan.abstracto.core.service.management.EmoteManagementService;
 import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.entities.emoji.Emoji;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -39,12 +39,12 @@ public class AssignableRoleManagementServiceBean implements AssignableRoleManage
     private EmoteService emoteService;
 
     @Override
-    public AssignableRole addRoleToPlace(FullEmote emote, Role role, String description, AssignableRolePlace place, ComponentPayload componentPayload) {
+    public AssignableRole addRoleToPlace(Emoji emoji, Role role, String description, AssignableRolePlace place, ComponentPayload componentPayload) {
         ARole arole = roleManagementService.findRole(role.getIdLong());
         AssignableRole roleToAdd = AssignableRole
                 .builder()
                 .assignablePlace(place)
-                .emoteMarkdown(emote != null ? emote.getEmoteRepr() : null)
+                .emoteMarkdown(emoji != null ? emoji.getFormatted() : null)
                 .role(arole)
                 .componentPayload(componentPayload)
                 .server(place.getServer())

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/service/management/AssignableRolePlaceManagementServiceBean.java

@@ -86,4 +86,8 @@ public class AssignableRolePlaceManagementServiceBean implements AssignableRoleP
     }
 
 
+    @Override
+    public List<AssignableRolePlace> getAssignableRolePlacesWithNamesContaining(String name, AServer server) {
+        return repository.findByKeyContainingIgnoreCaseAndServer(name, server);
+    }
 }

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/service/management/AssignedRoleUserManagementServiceBean.java

@@ -47,7 +47,6 @@ public class AssignedRoleUserManagementServiceBean implements AssignedRoleUserMa
     @Override
     public void removeAssignedRoleFromUsers(AssignableRole assignableRole, List<AssignedRoleUser> users) {
         log.info("Clearing all assignable role {} for {} users.", assignableRole.getId(), users.size());
-        assignableRole.getAssignedUsers().removeAll(users);
         users.forEach(roleUser -> roleUser.getRoles().remove(assignableRole));
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/resources/migrations/1.6.4/collection.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="delete/delete.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/resources/migrations/1.6.4/delete/command.xml

@@ -0,0 +1,30 @@
+<?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="editAssignableRolePlaceTextCommandId" value="(SELECT id FROM command WHERE name = 'editAssignableRolePlaceText')"/>
+    <changeSet author="Sheldan" id="delete-editAssignableRolePlaceText_command">
+        <sql >
+            delete from ${database.defaultSchemaName}.command_in_server_allowed_role
+            where command_in_server_id
+                      in
+                  (select
+                          command_in_server_id
+                  from ${database.defaultSchemaName}.command_in_server
+                  where command_id = (SELECT id FROM ${database.defaultSchemaName}.command WHERE name = 'editAssignableRolePlaceText'));
+            delete from ${database.defaultSchemaName}.command_in_server_alias
+            where command_in_server_id
+                      in
+                  (select command_in_server_id
+                  from ${database.defaultSchemaName}.command_in_server
+                  where command_id =
+                        (SELECT id FROM ${database.defaultSchemaName}.command WHERE name = 'editAssignableRolePlaceText'))
+        </sql>
+        <delete tableName="command_in_server">
+            <where>command_id=${editAssignableRolePlaceTextCommandId}</where>
+        </delete>
+        <delete tableName="command">
+            <where>id=${editAssignableRolePlaceTextCommandId}</where>
+        </delete>
+    </changeSet>
+</databaseChangeLog>

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/resources/migrations/1.6.4/delete/delete.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/assignable-roles/assignable-roles-impl/src/main/resources/migrations/assignableRoles-changeLog.xml

@@ -4,4 +4,5 @@
                      xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.26.xsd" >
     <include file="1.0-assignableRoles/collection.xml" relativeToChangelogFile="true"/>
     <include file="1.3.4/collection.xml" relativeToChangelogFile="true"/>
+    <include file="1.6.4/collection.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>

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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <artifactId>assignable-roles-int</artifactId>

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/config/AssignableRolePlaceParameterKey.java

@@ -5,5 +5,5 @@ import lombok.Getter;
 
 @Getter
 public enum AssignableRolePlaceParameterKey implements CommandParameterKey {
-    UNIQUE
+    UNIQUE, TEXT
 }

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/config/AssignableRolePlaceSlashCommandName.java

@@ -0,0 +1,5 @@
+package dev.sheldan.abstracto.assignableroles.config;
+
+public class AssignableRolePlaceSlashCommandName {
+    public static final String ASSIGNABLE_ROLE_PLACE = "assignablerole";
+}

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/model/database/AssignableRole.java

@@ -74,7 +74,7 @@ public class AssignableRole implements Serializable {
     private String description;
 
     @OneToOne(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE})
-    @JoinColumn(name = "component_id", nullable = false)
+    @JoinColumn(name = "component_id")
     private ComponentPayload componentPayload;
 
     /**

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/service/AssignableRolePlaceService.java

@@ -5,20 +5,20 @@ import dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlace;
 import dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlaceType;
 import dev.sheldan.abstracto.assignableroles.model.template.AssignablePlaceOverview;
 import dev.sheldan.abstracto.assignableroles.model.template.AssignableRolePlaceConfig;
-import dev.sheldan.abstracto.core.models.FullEmote;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Role;
-import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
 
 import java.util.concurrent.CompletableFuture;
+import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
+import net.dv8tion.jda.api.entities.emoji.Emoji;
 
 public interface AssignableRolePlaceService {
     void createAssignableRolePlace(String name, AChannel channel, String text, AssignableRolePlaceType type);
 
-    CompletableFuture<Void> addRoleToAssignableRolePlace(AServer server, String placeName, Role role, FullEmote emote, String description);
+    CompletableFuture<Void> addRoleToAssignableRolePlace(AServer server, String placeName, Role role, Emoji emoji, String description);
 
     CompletableFuture<Void> removeRoleFromAssignableRolePlace(AServer server, String placeName, ARole role);
 
@@ -48,7 +48,7 @@ public interface AssignableRolePlaceService {
 
     AssignableRolePlaceConfig getAssignableRolePlaceConfig(Guild guild, String name);
 
-    CompletableFuture<Void> moveAssignableRolePlace(AServer server, String name, TextChannel newChannel);
+    CompletableFuture<Void> moveAssignableRolePlace(AServer server, String name, GuildMessageChannel newChannel);
 
     CompletableFuture<Void> deleteAssignableRolePlace(AServer server, String name);
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/service/management/AssignableRoleManagementService.java

@@ -4,14 +4,14 @@ import dev.sheldan.abstracto.assignableroles.model.database.AssignableRole;
 import dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlace;
 import dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlaceType;
 import dev.sheldan.abstracto.assignableroles.model.database.AssignedRoleUser;
-import dev.sheldan.abstracto.core.models.FullEmote;
 import dev.sheldan.abstracto.core.models.database.ComponentPayload;
 import net.dv8tion.jda.api.entities.Role;
 
 import java.util.List;
+import net.dv8tion.jda.api.entities.emoji.Emoji;
 
 public interface AssignableRoleManagementService {
-    AssignableRole addRoleToPlace(FullEmote emote, Role role, String description, AssignableRolePlace place, ComponentPayload componentPayload);
+    AssignableRole addRoleToPlace(Emoji emoji, Role role, String description, AssignableRolePlace place, ComponentPayload componentPayload);
 
     AssignableRole getByAssignableRoleId(Long assignableRoleId);
     void deleteAssignableRole(AssignableRole assignableRole);

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/service/management/AssignableRolePlaceManagementService.java

@@ -28,4 +28,6 @@ public interface AssignableRolePlaceManagementService {
 
     List<AssignableRolePlace> findAllByServer(AServer server);
 
+    List<AssignableRolePlace> getAssignableRolePlacesWithNamesContaining(String name, AServer server);
+
 }

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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/command/CreateCustomCommand.java

@@ -10,6 +10,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandFeatureDefinition;
@@ -87,6 +88,7 @@ public class CreateCustomCommand extends AbstractConditionableCommand {
                 .enabled(true)
                 .userInstallable(true)
                 .userCommandConfig(UserCommandConfig.all())
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .rootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND)
                 .commandName("create")
                 .build();

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/command/DeleteCustomCommand.java

@@ -10,12 +10,21 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.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.AUser;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserManagementService;
 import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandFeatureDefinition;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandSlashCommandNames;
+import dev.sheldan.abstracto.customcommand.service.management.CustomCommandManagementService;
 import dev.sheldan.abstracto.customcommand.service.management.CustomCommandService;
+import java.util.ArrayList;
 import lombok.extern.slf4j.Slf4j;
+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;
@@ -38,9 +47,21 @@ public class DeleteCustomCommand extends AbstractConditionableCommand {
     @Autowired
     private CustomCommandService customCommandService;
 
+    @Autowired
+    private CustomCommandManagementService customCommandManagementService;
+
     @Autowired
     private InteractionService interactionService;
 
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Autowired
+    private UserManagementService userManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         String name = slashCommandParameterService.getCommandOption(CUSTOM_COMMAND_NAME_PARAMETER, event, String.class);
@@ -53,12 +74,32 @@ public class DeleteCustomCommand extends AbstractConditionableCommand {
                 .thenApply(interactionHook -> CommandResult.fromSuccess());
     }
 
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), CUSTOM_COMMAND_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            if(ContextUtils.isUserCommand(event)) {
+                AUser user = userManagementService.loadUser(event.getUser().getIdLong());
+                return customCommandManagementService.getUserCustomCommandsContaining(input, user)
+                    .stream().map(customCommand -> customCommand.getName().toLowerCase())
+                    .toList();
+            } else {
+                AServer server = serverManagementService.loadServer(event.getGuild());
+                return customCommandManagementService.getCustomCommandsContaining(input, server)
+                    .stream().map(customCommand -> customCommand.getName().toLowerCase())
+                    .toList();
+            }
+        }
+        return new ArrayList<>();
+    }
+
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter commandNameParameter = Parameter
                 .builder()
                 .name(CUSTOM_COMMAND_NAME_PARAMETER)
                 .templated(true)
+                .supportsAutoComplete(true)
                 .type(String.class)
                 .build();
 
@@ -73,6 +114,7 @@ public class DeleteCustomCommand extends AbstractConditionableCommand {
                 .enabled(true)
                 .userInstallable(true)
                 .userCommandConfig(UserCommandConfig.all())
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .rootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND)
                 .commandName("delete")
                 .build();

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/command/GetCustomCommand.java

@@ -69,12 +69,12 @@ public class GetCustomCommand extends AbstractConditionableCommand {
         if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), CUSTOM_COMMAND_NAME_PARAMETER)) {
             String input = event.getFocusedOption().getValue();
             if(ContextUtils.isNotUserCommand(event)) {
-                return customCommandService.getCustomCommandsStartingWith(input, event.getGuild())
+                return customCommandService.getCustomCommandsContaining(input, event.getGuild())
                         .stream()
                         .map(CustomCommand::getName)
                         .toList();
             } else {
-                return customCommandService.getUserCustomCommandsStartingWith(input, event.getUser())
+                return customCommandService.getUserCustomCommandsContaining(input, event.getUser())
                         .stream()
                         .map(CustomCommand::getName)
                         .toList();

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/repository/CustomCommandRepository.java

@@ -20,4 +20,6 @@ public interface CustomCommandRepository extends JpaRepository<CustomCommand, Lo
     List<CustomCommand> findByCreatorUserAndUserSpecific(AUser user, Boolean userSpecific);
     List<CustomCommand> findByNameStartsWithIgnoreCaseAndServer(String prefix, AServer server);
     List<CustomCommand> findByNameStartsWithIgnoreCaseAndCreatorUserAndUserSpecific(String prefix, AUser aUser, Boolean userSpecific);
+    List<CustomCommand> findByNameContainingIgnoreCaseAndServer(String name, AServer server);
+    List<CustomCommand> findByNameContainingIgnoreCaseAndCreatorUserAndUserSpecific(String name, AUser user, Boolean userSpecific);
 }

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/service/CustomCommandServiceBean.java

@@ -95,14 +95,14 @@ public class CustomCommandServiceBean implements CustomCommandService {
     }
 
     @Override
-    public List<CustomCommand> getCustomCommandsStartingWith(String prefix, Guild guild) {
+    public List<CustomCommand> getCustomCommandsContaining(String name, Guild guild) {
         AServer server = serverManagementService.loadServer(guild);
-        return customCommandManagementService.getCustomCommandsStartingWith(prefix, server);
+        return customCommandManagementService.getCustomCommandsContaining(name, server);
     }
 
     @Override
-    public List<CustomCommand> getUserCustomCommandsStartingWith(String prefix, User user) {
+    public List<CustomCommand> getUserCustomCommandsContaining(String name, User user) {
         AUser aUser = userManagementService.loadOrCreateUser(user.getIdLong());
-        return customCommandManagementService.getUserCustomCommandsStartingWith(prefix, aUser);
+        return customCommandManagementService.getUserCustomCommandsContaining(name, aUser);
     }
 }

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/service/management/CustomCommandManagementServiceBean.java

@@ -84,13 +84,13 @@ public class CustomCommandManagementServiceBean implements CustomCommandManageme
     }
 
     @Override
-    public List<CustomCommand> getCustomCommandsStartingWith(String prefix, AServer server) {
+    public List<CustomCommand> getCustomCommandsContaining(String name, AServer server) {
-        return repository.findByNameStartsWithIgnoreCaseAndServer(prefix, server);
+        return repository.findByNameContainingIgnoreCaseAndServer(name, server);
     }
 
     @Override
-    public List<CustomCommand> getUserCustomCommandsStartingWith(String prefix, AUser aUser) {
+    public List<CustomCommand> getUserCustomCommandsContaining(String prefix, AUser aUser) {
-        return repository.findByNameStartsWithIgnoreCaseAndCreatorUserAndUserSpecific(prefix, aUser, true);
+        return repository.findByNameContainingIgnoreCaseAndCreatorUserAndUserSpecific(prefix, aUser, true);
     }
 
 }

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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/service/management/CustomCommandManagementService.java

@@ -18,6 +18,6 @@ public interface CustomCommandManagementService {
     void deleteCustomCommand(String name, AUser user);
     List<CustomCommand> getCustomCommands(AServer server);
     List<CustomCommand> getUserCustomCommands(AUser aUser);
-    List<CustomCommand> getCustomCommandsStartingWith(String prefix, AServer server);
+    List<CustomCommand> getCustomCommandsContaining(String prefix, AServer server);
-    List<CustomCommand> getUserCustomCommandsStartingWith(String prefix, AUser aUser);
+    List<CustomCommand> getUserCustomCommandsContaining(String prefix, AUser aUser);
 }

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/service/management/CustomCommandService.java

@@ -16,6 +16,6 @@ public interface CustomCommandService {
     List<CustomCommand> getUserCustomCommands(User user);
     CustomCommand getCustomCommand(String name, Guild guild);
     CustomCommand getUserCustomCommand(String name, User user);
-    List<CustomCommand> getCustomCommandsStartingWith(String prefix, Guild guild);
+    List<CustomCommand> getCustomCommandsContaining(String name, Guild guild);
-    List<CustomCommand> getUserCustomCommandsStartingWith(String prefix, User user);
+    List<CustomCommand> getUserCustomCommandsContaining(String name, User user);
 }

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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Choose.java

@@ -52,6 +52,7 @@ public class Choose extends AbstractConditionableCommand {
         String choice = entertainmentService.takeChoice(choices, commandContext.getAuthor());
         ChooseResponseModel responseModel = ChooseResponseModel
                 .builder()
+                .choices(choices)
                 .chosenValue(choice)
                 .build();
         return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInMessageChannel(CHOOSE_RESPONSE_TEMPLATE_KEY, responseModel, commandContext.getChannel()))
@@ -70,6 +71,7 @@ public class Choose extends AbstractConditionableCommand {
         String choice = entertainmentService.takeChoice(choices, event.getMember());
         ChooseResponseModel responseModel = ChooseResponseModel
                 .builder()
+                .choices(choices)
                 .chosenValue(choice)
                 .build();
         return interactionService.replyEmbed(CHOOSE_RESPONSE_TEMPLATE_KEY, responseModel, event)

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/EightBall.java

@@ -6,15 +6,12 @@ import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.config.UserCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 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.service.ChannelService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.utils.ContextUtils;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
@@ -41,24 +38,12 @@ public class EightBall extends AbstractConditionableCommand {
     @Autowired
     private TemplateService templateService;
 
-    @Autowired
-    private ChannelService channelService;
-
     @Autowired
     private SlashCommandParameterService slashCommandParameterService;
 
     @Autowired
     private InteractionService interactionService;
 
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        String text = (String) commandContext.getParameters().getParameters().get(0);
-        MessageToSend messageToSend = getMessageToSend(text, commandContext.getGuild().getIdLong());
-        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
-                .thenApply(unused -> CommandResult.fromIgnored());
-    }
-
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         String text = slashCommandParameterService.getCommandOption(TEXT_PARAMETER, event, String.class);
@@ -71,6 +56,7 @@ public class EightBall extends AbstractConditionableCommand {
         String chosenKey = entertainmentService.getEightBallValue(text);
         EightBallResponseModel responseModel = EightBallResponseModel
                 .builder()
+                .input(text)
                 .chosenKey(chosenKey)
                 .build();
         return templateService.renderEmbedTemplate(EIGHT_BALL_RESPONSE_TEMPLATE_KEY, responseModel, serverId);
@@ -108,6 +94,7 @@ public class EightBall extends AbstractConditionableCommand {
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
                 .supportsEmbedException(true)
+                .slashCommandOnly(true)
                 .causesReaction(true)
                 .parameters(parameters)
                 .help(helpInfo)

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Roulette.java

@@ -6,12 +6,9 @@ import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.config.UserCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
@@ -30,8 +27,6 @@ public class Roulette extends AbstractConditionableCommand {
 
     public static final String ROULETTE_RESPONSE_TEMPLATE_KEY = "roulette_response";
     public static final String ROULETTE_COMMAND = "roulette";
-    @Autowired
-    private ChannelService channelService;
 
     @Autowired
     private EntertainmentService entertainmentService;
@@ -39,17 +34,6 @@ public class Roulette extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        boolean rouletteResult = entertainmentService.executeRoulette(commandContext.getAuthor());
-        RouletteResponseModel responseModel = RouletteResponseModel
-                .builder()
-                .result(rouletteResult)
-                .build();
-        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInMessageChannel(ROULETTE_RESPONSE_TEMPLATE_KEY, responseModel, commandContext.getChannel()))
-                .thenApply(unused -> CommandResult.fromIgnored());
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         boolean rouletteResult = entertainmentService.executeRoulette(event.getMember());
@@ -84,6 +68,7 @@ public class Roulette extends AbstractConditionableCommand {
                 .slashCommandConfig(slashCommandConfig)
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .causesReaction(true)
                 .parameters(parameters)

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/economy/CreditGamble.java

@@ -4,17 +4,12 @@ import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
-import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.core.templating.model.MessageToSend;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
@@ -43,22 +38,6 @@ public class CreditGamble extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Autowired
-    private TemplateService templateService;
-
-    @Autowired
-    private ChannelService channelService;
-
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
-        CreditGambleResult result = economyService.triggerCreditGamble(aUserInAServer);
-        CreditGambleResultModel model = CreditGambleResultModel.fromCreditGambleResult(result);
-        MessageToSend messageToSend = templateService.renderEmbedTemplate(CREDIT_GAMBLE_RESPONSE, model, commandContext.getGuild().getIdLong());
-        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
-                .thenApply(interactionHook -> CommandResult.fromSuccess());
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(event.getMember());
@@ -89,6 +68,7 @@ public class CreditGamble extends AbstractConditionableCommand {
                 .async(true)
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .parameters(parameters)
                 .help(helpInfo)

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/economy/CreditLeaderboard.java

@@ -4,7 +4,6 @@ import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
@@ -12,12 +11,9 @@ import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 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.ChannelService;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.core.templating.model.MessageToSend;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
@@ -56,38 +52,9 @@ public class CreditLeaderboard extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Autowired
-    private ChannelService channelService;
-
-    @Autowired
-    private TemplateService templateService;
-
     @Autowired
     private MemberService memberService;
 
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        // parameter is optional, in case its not present, we default to the 0th page
-        Integer page = !parameters.isEmpty() ? (Integer) parameters.get(0) : 1;
-        List<CreditsLeaderboardEntry> creditLeaderboard = economyService.getCreditLeaderboard(server, page);
-        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
-        CreditsLeaderboardEntry ownRank = economyService.getRankOfUser(aUserInAServer);
-        CreditsLeaderboardResponseModel model = CreditsLeaderboardResponseModel
-                .builder()
-                .entries(creditLeaderboard)
-                .ownRank(ownRank)
-                .build();
-        return enrichModelWithMembers(model, commandContext.getGuild().getIdLong())
-                .thenCompose(model1 -> {
-                    MessageToSend message = templateService.renderEmbedTemplate(CREDIT_LEADERBOARD_RESPONSE, model1, commandContext.getGuild().getIdLong());
-                    return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(message, commandContext.getChannel()));
-                })
-                .thenApply(unused -> CommandResult.fromSuccess());
-    }
-
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         event.deferReply().queue();
@@ -165,6 +132,7 @@ public class CreditLeaderboard extends AbstractConditionableCommand {
                 .templated(true)
                 .async(true)
                 .slashCommandConfig(slashCommandConfig)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .causesReaction(false)
                 .parameters(parameters)

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/economy/Credits.java

@@ -4,17 +4,12 @@ import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
-import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.core.templating.model.MessageToSend;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
@@ -44,26 +39,6 @@ public class Credits extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Autowired
-    private TemplateService templateService;
-
-    @Autowired
-    private ChannelService channelService;
-
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        AUserInAServer targetUser = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
-        CreditsLeaderboardEntry rankEntry = economyService.getRankOfUser(targetUser);
-        rankEntry.setMember(commandContext.getAuthor());
-        CreditsModel model = CreditsModel
-                .builder()
-                .entry(rankEntry)
-                .build();
-        MessageToSend messageToSend = templateService.renderEmbedTemplate(CREDITS_RESPONSE, model, commandContext.getGuild().getIdLong());
-        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
-                .thenApply(interactionHook -> CommandResult.fromSuccess());
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         AUserInAServer targetUser = userInServerManagementService.loadOrCreateUser(event.getMember());
@@ -98,6 +73,7 @@ public class Credits extends AbstractConditionableCommand {
                 .async(true)
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .parameters(parameters)
                 .help(helpInfo)

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/economy/Slots.java

@@ -5,18 +5,13 @@ 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.config.validator.MinIntegerValueValidator;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
-import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.core.templating.model.MessageToSend;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
@@ -52,24 +47,6 @@ public class Slots extends AbstractConditionableCommand {
     @Autowired
     private UserInServerManagementService userInServerManagementService;
 
-    @Autowired
-    private TemplateService templateService;
-
-    @Autowired
-    private ChannelService channelService;
-
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        Integer bid = (Integer) commandContext.getParameters().getParameters().get(0);
-        Member member = commandContext.getAuthor();
-        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(member);
-        SlotsResult slotsResult = economyUserServiceBean.triggerSlots(aUserInAServer, bid.longValue());
-        SlotsResponseModel responseModel = SlotsResponseModel.fromSlotsResult(slotsResult);
-        MessageToSend messageToSend = templateService.renderEmbedTemplate(SLOTS_RESPONSE, responseModel, member.getGuild().getIdLong());
-        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
-                .thenApply(unused -> CommandResult.fromSuccess());
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Long bid = slashCommandParameterService.getCommandOption(BID_PARAMETER, event, Integer.class).longValue();
@@ -111,6 +88,7 @@ public class Slots extends AbstractConditionableCommand {
                 .async(true)
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .parameters(parameters)
                 .help(helpInfo)

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/economy/TransferCredits.java

@@ -4,7 +4,6 @@ import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
@@ -12,9 +11,7 @@ import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
-import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
@@ -48,27 +45,6 @@ public class TransferCredits extends AbstractConditionableCommand {
     @Autowired
     private EconomyService economyService;
 
-    @Autowired
-    private ChannelService channelService;
-
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        Member targetMember = (Member) parameters.get(0);
-        Integer amount = (Integer) parameters.get(1);
-        AUserInAServer targetUser = userInServerManagementService.loadOrCreateUser(targetMember);
-        AUserInAServer sourceUser = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
-        economyService.transferCredits(sourceUser, targetUser, amount.longValue());
-        TransferCreditsModel responseModel = TransferCreditsModel
-                .builder()
-                .sourceMember(MemberDisplay.fromMember(commandContext.getAuthor()))
-                .targetMember(MemberDisplay.fromMember(targetMember))
-                .credits(amount)
-                .build();
-        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInMessageChannel(TRANSFER_CREDITS_RESPONSE, responseModel, commandContext.getChannel()))
-                .thenApply(unused -> CommandResult.fromSuccess());
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Member targetMember = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER, event, Member.class);
@@ -123,6 +99,7 @@ public class TransferCredits extends AbstractConditionableCommand {
                 .slashCommandConfig(slashCommandConfig)
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .parameters(parameters)
                 .causesReaction(false)

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/games/Mines.java

@@ -5,19 +5,16 @@ 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.config.UserCommandConfig;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.ServerUser;
-import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.FeatureFlagService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.core.utils.ContextUtils;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
@@ -26,7 +23,6 @@ import dev.sheldan.abstracto.entertainment.model.command.games.MineBoard;
 import dev.sheldan.abstracto.entertainment.model.database.EconomyUser;
 import dev.sheldan.abstracto.entertainment.service.GameService;
 import dev.sheldan.abstracto.entertainment.service.management.EconomyUserManagementService;
-import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -65,9 +61,6 @@ public class Mines extends AbstractConditionableCommand {
     @Autowired
     private EconomyUserManagementService economyUserManagementService;
 
-    @Autowired
-    private ChannelService channelService;
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Integer width = 5;
@@ -120,53 +113,6 @@ public class Mines extends AbstractConditionableCommand {
                 });
     }
 
-
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        Integer width = 5;
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        if(!parameters.isEmpty()) {
-            width = (Integer) parameters.get(0);
-        }
-        Integer height = 5;
-        if(parameters.size() >= 2) {
-            height = (Integer) parameters.get(1);
-        }
-        Integer mines = 5;
-        if(parameters.size() >= 3) {
-            mines = (Integer) parameters.get(2);
-        }
-        Integer credit = null;
-        Long serverId = commandContext.getGuild().getIdLong();
-        boolean economyEnabled = featureFlagService.getFeatureFlagValue(EntertainmentFeatureDefinition.ECONOMY, serverId);
-        if(economyEnabled){
-            credit = 50;
-            if(parameters.size() == 4) {
-                credit = (Integer) parameters.get(3);
-            }
-
-            Optional<EconomyUser> userOptional = economyUserManagementService.getUser(ServerUser.fromMember(commandContext.getAuthor()));
-            if(!userOptional.isPresent()) {
-                throw new NotEnoughCreditsException();
-            }
-            EconomyUser user = userOptional.get();
-            if(user.getCredits() < credit) {
-                throw new NotEnoughCreditsException();
-            }
-        }
-        MineBoard board = gameService.createBoard(width, height, mines, serverId);
-        board.setCreditsEnabled(economyEnabled);
-        board.setUserId(commandContext.getAuthor().getIdLong());
-        board.setServerId(serverId);
-        board.setCredits(credit);
-        MessageToSend messageToSend = templateService.renderEmbedTemplate(MINE_BOARD_TEMPLATE_KEY, board, serverId);
-        List<CompletableFuture<Message>> futures = channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
-        return FutureUtils.toSingleFutureGeneric(futures)
-                .thenAccept(unused ->  gameService.persistMineBoardMessage(board, futures.get(0).join(), serverId))
-                .thenApply(unused -> CommandResult.fromSuccess());
-
-    }
-
     @Override
     public CommandConfiguration getConfiguration() {
         List<Parameter> parameters = new ArrayList<>();
@@ -227,6 +173,7 @@ public class Mines extends AbstractConditionableCommand {
                 .async(true)
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .parameters(parameters)
                 .help(helpInfo)

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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/ChooseResponseModel.java

@@ -1,5 +1,6 @@
 package dev.sheldan.abstracto.entertainment.model.command;
 
+import java.util.List;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
@@ -9,4 +10,5 @@ import lombok.Setter;
 @Builder
 public class ChooseResponseModel {
     private String chosenValue;
+    private List<String> choices;
 }

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/EightBallResponseModel.java

@@ -9,4 +9,5 @@ import lombok.Setter;
 @Builder
 public class EightBallResponseModel {
     private String chosenKey;
+    private String input;
 }

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

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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

@@ -9,6 +9,7 @@ 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.SlashCommandPrivilegeLevels;
 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;
@@ -168,6 +169,7 @@ public class AddLevelAction extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .groupName("levelAction")
                 .commandName("add")
                 .build();

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

@@ -5,8 +5,8 @@ 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.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.exception.EntityGuildMismatchException;
@@ -47,22 +47,6 @@ public class DisableExpForRole extends AbstractConditionableCommand {
     private InteractionService interactionService;
 
 
-    @Override
-    public CommandResult execute(CommandContext commandContext) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        Role role = (Role) parameters.get(0);
-        ARole actualRole = roleManagementService.findRole(role.getIdLong());
-        if(!actualRole.getServer().getId().equals(commandContext.getGuild().getIdLong())) {
-            throw new EntityGuildMismatchException();
-        }
-        // as we manage experience disabled roles via the existence of them in a table, we should not do anything
-        // in case it is used a second time as a disabled experience role
-        if(!disabledExpRoleManagementService.isExperienceDisabledForRole(actualRole)) {
-            disabledExpRoleManagementService.setRoleToBeDisabledForExp(actualRole);
-        }
-        return CommandResult.fromSuccess();
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Role role = slashCommandParameterService.getCommandOption(ROLE_PARAMETER, event, Role.class);
@@ -97,6 +81,7 @@ public class DisableExpForRole extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(DISABLE_EXP_FOR_ROLE_COMMAND)
                 .build();
 
@@ -104,6 +89,7 @@ public class DisableExpForRole extends AbstractConditionableCommand {
                 .name(DISABLE_EXP_FOR_ROLE_COMMAND)
                 .module(ExperienceModuleDefinition.EXPERIENCE)
                 .templated(true)
+                .slashCommandOnly(true)
                 .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .causesReaction(true)

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

@@ -5,8 +5,8 @@ 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.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.exception.EntityGuildMismatchException;
@@ -46,17 +46,6 @@ public class DisableExpGain extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Override
-    public CommandResult execute(CommandContext commandContext) {
-        Member para = (Member) commandContext.getParameters().getParameters().get(0);
-        if(!para.getGuild().equals(commandContext.getGuild())) {
-            throw new EntityGuildMismatchException();
-        }
-        AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(para);
-        aUserExperienceService.disableExperienceForUser(userInAServer);
-        return CommandResult.fromSuccess();
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Member para = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER, event, Member.class);
@@ -87,6 +76,7 @@ public class DisableExpGain extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(DISABLE_EXP_GAIN_COMMAND)
                 .build();
 
@@ -96,6 +86,7 @@ public class DisableExpGain extends AbstractConditionableCommand {
                 .slashCommandConfig(slashCommandConfig)
                 .causesReaction(true)
                 .supportsEmbedException(true)
+                .slashCommandOnly(true)
                 .templated(true)
                 .parameters(parameters)
                 .help(helpInfo)

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

@@ -6,11 +6,10 @@ import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.command.exception.SlashCommandParameterMissingException;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 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.models.database.ARole;
 import dev.sheldan.abstracto.core.service.management.RoleManagementService;
@@ -49,20 +48,6 @@ public class EnableExpForRole extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Override
-    public CommandResult execute(CommandContext commandContext) {
-        ARole role = (ARole) commandContext.getParameters().getParameters().get(0);
-        ARole actualRole = roleManagementService.findRole(role.getId());
-        if(!actualRole.getServer().getId().equals(commandContext.getGuild().getIdLong())) {
-            throw new EntityGuildMismatchException();
-        }
-        // If its not disabled for the role, we can remove it
-        if(disabledExpRoleManagementService.isExperienceDisabledForRole(actualRole)) {
-            disabledExpRoleManagementService.removeRoleToBeDisabledForExp(actualRole);
-        }
-        return CommandResult.fromSuccess();
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         ARole actualRole;
@@ -100,6 +85,7 @@ public class EnableExpForRole extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(ENABLE_EXP_FOR_ROLE_COMMAND)
                 .build();
 
@@ -110,6 +96,7 @@ public class EnableExpForRole extends AbstractConditionableCommand {
                 .slashCommandConfig(slashCommandConfig)
                 .causesReaction(true)
                 .supportsEmbedException(true)
+                .slashCommandOnly(true)
                 .parameters(parameters)
                 .help(helpInfo)
                 .build();

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

@@ -5,8 +5,8 @@ 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.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.exception.EntityGuildMismatchException;
@@ -47,17 +47,6 @@ public class EnableExpGain extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Override
-    public CommandResult execute(CommandContext commandContext) {
-        Member member = (Member) commandContext.getParameters().getParameters().get(0);
-        if(!member.getGuild().equals(commandContext.getGuild())) {
-            throw new EntityGuildMismatchException();
-        }
-        AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(member);
-        aUserExperienceService.enableExperienceForUser(userInAServer);
-        return CommandResult.fromSuccess();
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Member member = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER, event, Member.class);
@@ -88,6 +77,7 @@ public class EnableExpGain extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(ENABLE_EXP_GAIN_COMMAND)
                 .build();
 
@@ -98,6 +88,7 @@ public class EnableExpGain extends AbstractConditionableCommand {
                 .causesReaction(true)
                 .supportsEmbedException(true)
                 .templated(true)
+                .slashCommandOnly(true)
                 .parameters(parameters)
                 .help(helpInfo)
                 .build();

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

@@ -4,7 +4,6 @@ import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.config.FeatureMode;
@@ -45,13 +44,6 @@ public class ExpLevelUpNotification extends AbstractConditionableCommand {
     @Autowired
     private SlashCommandParameterService slashCommandParameterService;
 
-    @Override
-    public CommandResult execute(CommandContext commandContext) {
-        Boolean newValue = (Boolean) commandContext.getParameters().getParameters().get(0);
-        updateExpLevelNotification(commandContext.getAuthor(), newValue);
-        return CommandResult.fromSuccess();
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Boolean newValue = slashCommandParameterService.getCommandOption(FLAG_PARAMETER, event, Boolean.class);
@@ -97,6 +89,7 @@ public class ExpLevelUpNotification extends AbstractConditionableCommand {
                 .slashCommandConfig(slashCommandConfig)
                 .causesReaction(true)
                 .supportsEmbedException(true)
+                .slashCommandOnly(true)
                 .templated(true)
                 .parameters(parameters)
                 .help(helpInfo)

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

@@ -5,8 +5,8 @@ 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.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
@@ -44,15 +44,6 @@ public class ExpScale extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Override
-    public CommandResult execute(CommandContext commandContext) {
-        Double scale = (Double) commandContext.getParameters().getParameters().get(0);
-        Long guildId = commandContext.getGuild().getIdLong();
-        configService.setDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, guildId, scale);
-        log.info("Setting experience scale to {} for {}", scale, guildId);
-        return CommandResult.fromSuccess();
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Double newScale = slashCommandParameterService.getCommandOption(SCALE_PARAMETER, event, Double.class);
@@ -80,6 +71,7 @@ public class ExpScale extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(EXP_SCALE_COMMAND)
                 .build();
 
@@ -88,6 +80,7 @@ public class ExpScale extends AbstractConditionableCommand {
                 .name(EXP_SCALE_COMMAND)
                 .module(ExperienceModuleDefinition.EXPERIENCE)
                 .causesReaction(true)
+                .slashCommandOnly(true)
                 .slashCommandConfig(slashCommandConfig)
                 .templated(true)
                 .supportsEmbedException(true)

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

@@ -5,25 +5,22 @@ 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.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.models.FullRole;
 import dev.sheldan.abstracto.core.models.database.AServer;
-import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.RoleService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 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.experience.config.ExperienceFeatureDefinition;
 import dev.sheldan.abstracto.experience.config.ExperienceSlashCommandNames;
 import dev.sheldan.abstracto.experience.model.database.ADisabledExpRole;
 import dev.sheldan.abstracto.experience.model.template.DisabledExperienceRolesModel;
 import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
 import net.dv8tion.jda.api.entities.Member;
-import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.Role;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -49,9 +46,6 @@ public class ListDisabledExperienceRoles extends AbstractConditionableCommand {
     @Autowired
     private RoleService roleService;
 
-    @Autowired
-    private ChannelService channelService;
-
     @Autowired
     private ServerManagementService serverManagementService;
 
@@ -61,14 +55,6 @@ public class ListDisabledExperienceRoles extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        Long serverId = commandContext.getGuild().getIdLong();
-        MessageToSend messageToSend = getResponseModel(serverId, commandContext.getAuthor());
-        List<CompletableFuture<Message>> futures = channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
-        return FutureUtils.toSingleFutureGeneric(futures).thenApply(aVoid -> CommandResult.fromIgnored());
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Long serverId = event.getGuild().getIdLong();
@@ -112,6 +98,7 @@ public class ListDisabledExperienceRoles extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(LIST_DISABLED_EXPERIENCE_ROLES_COMMAND)
                 .build();
 
@@ -122,6 +109,7 @@ public class ListDisabledExperienceRoles extends AbstractConditionableCommand {
                 .templated(true)
                 .supportsEmbedException(true)
                 .causesReaction(true)
+                .slashCommandOnly(true)
                 .async(true)
                 .aliases(aliases)
                 .parameters(parameters)

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

@@ -9,6 +9,7 @@ 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.SlashCommandPrivilegeLevels;
 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;
@@ -142,6 +143,7 @@ public class RemoveLevelAction extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .groupName("levelAction")
                 .commandName("remove")
                 .build();

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

@@ -8,6 +8,7 @@ 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.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
 import dev.sheldan.abstracto.experience.config.ExperienceFeatureMode;
 import dev.sheldan.abstracto.experience.config.ExperienceSlashCommandNames;
@@ -51,6 +52,7 @@ public class ShowLevelActions extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .groupName("levelAction")
                 .commandName("show")
                 .build();

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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
 
     <artifactId>giveaway-impl</artifactId>

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/command/AddGiveawayKey.java

@@ -10,6 +10,7 @@ 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.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.giveaway.config.GiveawayFeatureDefinition;
 import dev.sheldan.abstracto.giveaway.config.GiveawayMode;
@@ -26,111 +27,112 @@ import org.springframework.stereotype.Component;
 @Component
 public class AddGiveawayKey extends AbstractConditionableCommand {
 
-  private static final String KEY_PARAMETER = "key";
+    private static final String KEY_PARAMETER = "key";
-  private static final String DESCRIPTION_PARAMETER = "description";
+    private static final String DESCRIPTION_PARAMETER = "description";
-  private static final String BENEFACTOR_PARAMETER = "benefactor";
+    private static final String BENEFACTOR_PARAMETER = "benefactor";
-  private static final String NAME_PARAMETER = "name";
+    private static final String NAME_PARAMETER = "name";
-  private static final String ADD_GIVEAWAY_KEY_COMMAND_NAME = "addGiveawayKey";
+    private static final String ADD_GIVEAWAY_KEY_COMMAND_NAME = "addGiveawayKey";
-  private static final String ADD_GIVEAWAY_KEY_RESPONSE = "addGiveawayKey_response";
+    private static final String ADD_GIVEAWAY_KEY_RESPONSE = "addGiveawayKey_response";
 
-  @Autowired
+    @Autowired
-  private InteractionService interactionService;
+    private InteractionService interactionService;
 
-  @Autowired
+    @Autowired
-  private GiveawayKeyManagementService giveawayKeyManagementService;
+    private GiveawayKeyManagementService giveawayKeyManagementService;
 
-  @Autowired
+    @Autowired
-  private SlashCommandParameterService slashCommandParameterService;
+    private SlashCommandParameterService slashCommandParameterService;
 
-  @Override
+    @Override
-  public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-    String key = slashCommandParameterService.getCommandOption(KEY_PARAMETER, event, String.class);
+        String key = slashCommandParameterService.getCommandOption(KEY_PARAMETER, event, String.class);
-    String name = slashCommandParameterService.getCommandOption(NAME_PARAMETER, event, String.class);
+        String name = slashCommandParameterService.getCommandOption(NAME_PARAMETER, event, String.class);
-    String description;
+        String description;
-    if(slashCommandParameterService.hasCommandOption(DESCRIPTION_PARAMETER, event)) {
+        if (slashCommandParameterService.hasCommandOption(DESCRIPTION_PARAMETER, event)) {
-      description = slashCommandParameterService.getCommandOption(DESCRIPTION_PARAMETER, event, String.class);
+            description = slashCommandParameterService.getCommandOption(DESCRIPTION_PARAMETER, event, String.class);
-    } else {
+        } else {
-      description = null;
+            description = null;
+        }
+        Member benefactor;
+        if (slashCommandParameterService.hasCommandOption(BENEFACTOR_PARAMETER, event)) {
+            benefactor = slashCommandParameterService.getCommandOption(BENEFACTOR_PARAMETER, event, Member.class);
+        } else {
+            benefactor = null;
+        }
+        giveawayKeyManagementService.createGiveawayKey(event.getMember(), benefactor, key, description, name);
+        return interactionService.replyEmbed(ADD_GIVEAWAY_KEY_RESPONSE, event)
+            .thenApply(interactionHook -> CommandResult.fromSuccess());
     }
-    Member benefactor;
+
-    if(slashCommandParameterService.hasCommandOption(BENEFACTOR_PARAMETER, event)) {
+    @Override
-      benefactor = slashCommandParameterService.getCommandOption(BENEFACTOR_PARAMETER, event, Member.class);
+    public CommandConfiguration getConfiguration() {
-    } else {
+        Parameter giveawayKey = Parameter
-      benefactor = null;
+            .builder()
+            .templated(true)
+            .name(KEY_PARAMETER)
+            .type(String.class)
+            .build();
+
+        Parameter giveawayKeyDescription = Parameter
+            .builder()
+            .templated(true)
+            .name(DESCRIPTION_PARAMETER)
+            .type(String.class)
+            .optional(true)
+            .build();
+
+
+        Parameter giveawayKeyBenefactor = Parameter
+            .builder()
+            .templated(true)
+            .name(BENEFACTOR_PARAMETER)
+            .type(Member.class)
+            .optional(true)
+            .build();
+
+        Parameter giveawayKeyName = Parameter
+            .builder()
+            .templated(true)
+            .name(NAME_PARAMETER)
+            .type(String.class)
+            .build();
+
+        List<Parameter> parameters = Arrays.asList(giveawayKeyName, giveawayKey, giveawayKeyBenefactor, giveawayKeyDescription);
+        HelpInfo helpInfo = HelpInfo
+            .builder()
+            .templated(true)
+            .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .groupName("keys")
+            .commandName("add")
+            .build();
+
+        return CommandConfiguration.builder()
+            .name(ADD_GIVEAWAY_KEY_COMMAND_NAME)
+            .module(UtilityModuleDefinition.UTILITY)
+            .templated(true)
+            .slashCommandOnly(true)
+            .slashCommandConfig(slashCommandConfig)
+            .async(true)
+            .supportsEmbedException(true)
+            .causesReaction(false)
+            .parameters(parameters)
+            .help(helpInfo)
+            .build();
     }
-    giveawayKeyManagementService.createGiveawayKey(event.getMember(), benefactor, key, description, name);
-    return interactionService.replyEmbed(ADD_GIVEAWAY_KEY_RESPONSE, event)
-        .thenApply(interactionHook -> CommandResult.fromSuccess());
-  }
 
-  @Override
+    @Override
-  public CommandConfiguration getConfiguration() {
+    public FeatureDefinition getFeature() {
-    Parameter giveawayKey = Parameter
+        return GiveawayFeatureDefinition.GIVEAWAY;
-        .builder()
+    }
-        .templated(true)
-        .name(KEY_PARAMETER)
-        .type(String.class)
-        .build();
 
-    Parameter giveawayKeyDescription = Parameter
+    @Override
-        .builder()
+    public List<FeatureMode> getFeatureModeLimitations() {
-        .templated(true)
+        return Arrays.asList(GiveawayMode.KEY_GIVEAWAYS);
-        .name(DESCRIPTION_PARAMETER)
+    }
-        .type(String.class)
-        .optional(true)
-        .build();
-
-
-    Parameter giveawayKeyBenefactor = Parameter
-        .builder()
-        .templated(true)
-        .name(BENEFACTOR_PARAMETER)
-        .type(Member.class)
-        .optional(true)
-        .build();
-
-    Parameter giveawayKeyName = Parameter
-        .builder()
-        .templated(true)
-        .name(NAME_PARAMETER)
-        .type(String.class)
-        .build();
-
-    List<Parameter> parameters = Arrays.asList(giveawayKeyName, giveawayKey, giveawayKeyBenefactor, giveawayKeyDescription);
-    HelpInfo helpInfo = HelpInfo
-        .builder()
-        .templated(true)
-        .build();
-
-    SlashCommandConfig slashCommandConfig = SlashCommandConfig
-        .builder()
-        .enabled(true)
-        .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
-        .groupName("keys")
-        .commandName("add")
-        .build();
-
-    return CommandConfiguration.builder()
-        .name(ADD_GIVEAWAY_KEY_COMMAND_NAME)
-        .module(UtilityModuleDefinition.UTILITY)
-        .templated(true)
-        .slashCommandOnly(true)
-        .slashCommandConfig(slashCommandConfig)
-        .async(true)
-        .supportsEmbedException(true)
-        .causesReaction(false)
-        .parameters(parameters)
-        .help(helpInfo)
-        .build();
-  }
-
-  @Override
-  public FeatureDefinition getFeature() {
-    return GiveawayFeatureDefinition.GIVEAWAY;
-  }
-
-  @Override
-  public List<FeatureMode> getFeatureModeLimitations() {
-    return Arrays.asList(GiveawayMode.KEY_GIVEAWAYS);
-  }
 }

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/command/CancelGiveaway.java

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
 import dev.sheldan.abstracto.giveaway.config.GiveawayFeatureDefinition;
@@ -80,6 +81,7 @@ public class CancelGiveaway extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .groupName("management")
                 .commandName("cancel")
                 .build();
@@ -88,6 +90,7 @@ public class CancelGiveaway extends AbstractConditionableCommand {
                 .name(COMMAND_NAME)
                 .module(UtilityModuleDefinition.UTILITY)
                 .templated(true)
+                .slashCommandOnly(true)
                 .slashCommandConfig(slashCommandConfig)
                 .async(true)
                 .supportsEmbedException(true)

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/command/GreateGiveaway.java

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.utils.ParseUtils;
 import dev.sheldan.abstracto.giveaway.config.GiveawayFeatureDefinition;
@@ -169,6 +170,7 @@ public class GreateGiveaway extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .groupName("management")
                 .commandName("create")
                 .build();
@@ -177,6 +179,7 @@ public class GreateGiveaway extends AbstractConditionableCommand {
                 .name(COMMAND_NAME)
                 .module(UtilityModuleDefinition.UTILITY)
                 .templated(true)
+                .slashCommandOnly(true)
                 .slashCommandConfig(slashCommandConfig)
                 .async(true)
                 .supportsEmbedException(true)

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/command/GreateKeyGiveaway.java

@@ -10,6 +10,7 @@ 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.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.service.ConfigService;
 import dev.sheldan.abstracto.core.utils.ParseUtils;
@@ -131,6 +132,7 @@ public class GreateKeyGiveaway extends AbstractConditionableCommand {
             .builder()
             .enabled(true)
             .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
             .groupName("key")
             .commandName("creategiveaway")
             .build();
@@ -141,6 +143,7 @@ public class GreateKeyGiveaway extends AbstractConditionableCommand {
             .templated(true)
             .slashCommandConfig(slashCommandConfig)
             .async(true)
+            .slashCommandOnly(true)
             .supportsEmbedException(true)
             .causesReaction(false)
             .parameters(parameters)

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/command/ReRollGiveaway.java

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
 import dev.sheldan.abstracto.giveaway.config.GiveawayFeatureDefinition;
@@ -80,6 +81,7 @@ public class ReRollGiveaway extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .groupName("management")
                 .commandName("reroll")
                 .build();

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/command/RemoveGiveawayKey.java

@@ -10,6 +10,7 @@ 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.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.giveaway.config.GiveawayFeatureDefinition;
 import dev.sheldan.abstracto.giveaway.config.GiveawayMode;
@@ -66,6 +67,7 @@ public class RemoveGiveawayKey extends AbstractConditionableCommand {
         .builder()
         .enabled(true)
         .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+        .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
         .groupName("keys")
         .commandName("remove")
         .build();

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/command/ShowGiveawayKeys.java

@@ -10,6 +10,7 @@ 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.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
 import dev.sheldan.abstracto.core.service.PaginatorService;
@@ -110,6 +111,7 @@ public class ShowGiveawayKeys extends AbstractConditionableCommand {
         .builder()
         .enabled(true)
         .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+        .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
         .groupName("keys")
         .commandName("show")
         .build();

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/service/GiveawayServiceBean.java

@@ -155,7 +155,7 @@ public class GiveawayServiceBean implements GiveawayService {
         Long giveawayId = giveaway.getGiveawayId().getId();
         log.info("Adding giveaway participating of user {} to giveaway {} in server {}.", member.getIdLong(), giveawayId, member.getGuild().getIdLong());
         MessageToSend messageToSend = templateService.renderEmbedTemplate(GIVEAWAY_MESSAGE_TEMPLATE_KEY, giveawayMessageModel, member.getGuild().getIdLong());
-        return channelService.editEmbedMessageInAChannel(messageToSend.getEmbeds().get(0), messageChannel, giveaway.getMessageId())
+        return channelService.editMessageInAChannelFuture(messageToSend, messageChannel, giveaway.getMessageId())
                 .thenAccept(message -> {
             self.persistAddedParticipant(member, giveawayId);
         });

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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
 
     <artifactId>image-generation-impl</artifactId>

abstracto-application/abstracto-modules/image-generation/image-generation-impl/src/main/java/dev/sheldan/abstracto/imagegeneration/command/Triggered.java

@@ -70,7 +70,11 @@ public class Triggered extends AbstractConditionableCommand {
         if(parameters.isEmpty()) {
             member = commandContext.getAuthor();
         } else {
-            member = (Member) parameters.get(0);
+            if(parameters.get(0) instanceof Message) {
+                member = ((Message) parameters.get(0)).getMember();
+            } else {
+                member = (Member) parameters.get(0);
+            }
         }
         File triggeredGifFile = imageGenerationService.getTriggeredGif(member.getEffectiveAvatar().getUrl(imageSize));
         MessageToSend messageToSend = templateService.renderEmbedTemplate(TRIGGERED_EMBED_TEMPLATE_KEY, new Object(), commandContext.getGuild().getIdLong());

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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -18,7 +18,7 @@
         <dependency>
             <groupId>dev.sheldan.abstracto.modules</groupId>
             <artifactId>moderation-int</artifactId>
-            <version>1.6.2</version>
+            <version>1.6.12-SNAPSHOT</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>

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.6.2</version>
+        <version>1.6.12-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.6.2</version>
+        <version>1.6.12-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/link-embed/link-embed-impl/src/main/java/dev/sheldan/abstracto/linkembed/listener/MessageEmbedDeleteButtonClickedListener.java

@@ -3,18 +3,14 @@ package dev.sheldan.abstracto.linkembed.listener;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerResult;
 import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListener;
-import dev.sheldan.abstracto.core.metric.service.MetricService;
 import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerModel;
-import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.core.interaction.ComponentPayloadManagementService;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.linkembed.config.LinkEmbedFeatureDefinition;
 import dev.sheldan.abstracto.linkembed.exception.LinkEmbedRemovalNotAllowedException;
 import dev.sheldan.abstracto.linkembed.model.template.MessageEmbedDeleteButtonPayload;
 import dev.sheldan.abstracto.linkembed.service.MessageEmbedMetricService;
 import dev.sheldan.abstracto.linkembed.service.MessageEmbedServiceBean;
-import dev.sheldan.abstracto.linkembed.service.management.MessageEmbedPostManagementService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -28,21 +24,9 @@ public class MessageEmbedDeleteButtonClickedListener implements ButtonClickedLis
     @Autowired
     private MessageService messageService;
 
-    @Autowired
-    private MetricService metricService;
-
-    @Autowired
-    private MessageEmbedPostManagementService messageEmbedPostManagementService;
-
     @Autowired
     private MessageEmbedMetricService messageEmbedMetricService;
 
-    @Autowired
-    private InteractionService interactionService;
-
-    @Autowired
-    private TemplateService templateService;
-
     @Autowired
     private ComponentPayloadManagementService componentPayloadManagementService;
 

abstracto-application/abstracto-modules/link-embed/link-embed-impl/src/main/java/dev/sheldan/abstracto/linkembed/service/MessageEmbedServiceBean.java

@@ -11,6 +11,7 @@ import dev.sheldan.abstracto.core.interaction.button.ButtonConfigModel;
 import dev.sheldan.abstracto.core.interaction.ComponentPayloadManagementService;
 import dev.sheldan.abstracto.linkembed.config.LinkEmbedFeatureDefinition;
 import dev.sheldan.abstracto.linkembed.config.LinkEmbedFeatureMode;
+import dev.sheldan.abstracto.linkembed.model.template.MessageEmbedCleanupReplacementModel;
 import dev.sheldan.abstracto.linkembed.model.template.MessageEmbedDeleteButtonPayload;
 import dev.sheldan.abstracto.linkembed.model.template.MessageEmbeddedModel;
 import dev.sheldan.abstracto.core.service.*;
@@ -18,7 +19,6 @@ import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
-import dev.sheldan.abstracto.core.utils.CompletableFutureList;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.linkembed.model.MessageEmbedLink;
 import dev.sheldan.abstracto.linkembed.model.database.EmbeddedMessage;
@@ -28,6 +28,7 @@ import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
 import net.dv8tion.jda.api.interactions.commands.CommandInteraction;
+import org.apache.commons.lang3.tuple.Pair;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
@@ -49,6 +50,7 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
     private final Pattern messageRegex = Pattern.compile("(?<whole>(?:https?://)?(?:\\w+\\.)?discord(?:app)?\\.com/channels/(?<server>\\d+)/(?<channel>\\d+)/(?<message>\\d+)(?:.*?))+", Pattern.CASE_INSENSITIVE);
 
     public static final String MESSAGE_EMBED_TEMPLATE = "message_embed";
+    private static final String MESSAGE_EMBED_CLEANUP_REPLACEMENT_TEMPLATE = "message_embed_cleanup_replacement";
     public static final String REMOVAL_EMOTE = "removeEmbed";
 
     @Autowired
@@ -78,9 +80,6 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
     @Autowired
     private ReactionService reactionService;
 
-    @Autowired
-    private MessageService messageService;
-
     @Autowired
     private ComponentService componentServiceBean;
 
@@ -160,15 +159,21 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
             return CompletableFuture.completedFuture(null);
         }
         log.info("Cleaning up {} embedded embeddedMessages", embeddedMessages.size());
-        List<ServerChannelMessage> reactionChannelMessages = embeddedMessages.stream()
+        List<Pair<ServerChannelMessage, ServerChannelMessage>> embeddingMessages = embeddedMessages.stream()
-                .filter(embeddedMessage -> embeddedMessage.getDeletionComponentId() == null)
+                .map(embeddedMessage -> Pair.of(ServerChannelMessage
-                .map(this::convertEmbedMessageToServerChannelMessage)
+                    .builder()
-        .collect(Collectors.toList());
+                    .serverId(embeddedMessage.getEmbeddingServer().getId())
+                    .channelId(embeddedMessage.getEmbeddingChannel().getId())
+                    .messageId(embeddedMessage.getEmbeddingMessageId())
+                    .build(),
+                    ServerChannelMessage
+                        .builder().
+                        serverId(embeddedMessage.getEmbeddedServer().getId())
+                        .channelId(embeddedMessage.getEmbeddedChannel().getId())
+                        .messageId(embeddedMessage.getEmbeddedMessageId())
+                        .build()))
+        .toList();
 
-        List<ServerChannelMessage> buttonChannelMessages = embeddedMessages.stream()
-                .filter(embeddedMessage -> embeddedMessage.getDeletionComponentId() != null)
-                .map(this::convertEmbedMessageToServerChannelMessage)
-                .collect(Collectors.toList());
         List<Long> embeddedMessagesHandled = embeddedMessages
                 .stream()
                 .map(EmbeddedMessage::getEmbeddingMessageId)
@@ -179,67 +184,26 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
                 .filter(Objects::nonNull)
                 .distinct()
                 .collect(Collectors.toList());
-        List<CompletableFuture<Message>> reactionMessageFutures = messageService.retrieveMessages(reactionChannelMessages);
+        List<CompletableFuture<Message>> editList = embeddingMessages.stream().map(messagePair -> {
-        List<CompletableFuture<Message>> buttonMessageFutures = messageService.retrieveMessages(buttonChannelMessages);
+            ServerChannelMessage embeddingMessage = messagePair.getLeft();
-        CompletableFutureList<Message> reactionFutureList = new CompletableFutureList<>(reactionMessageFutures);
+            ServerChannelMessage embeddedMessage = messagePair.getRight();
-        CompletableFutureList<Message> buttonFutureList = new CompletableFutureList<>(buttonMessageFutures);
+            MessageEmbedCleanupReplacementModel model = MessageEmbedCleanupReplacementModel
-        return reactionFutureList.getMainFuture()
-                .handle((unused, throwable) -> {
-                    if(throwable != null) {
-                        log.warn("Embedded messages reaction message loading failed.", throwable);
-                    }
-                    return self.removeReactions(reactionFutureList.getObjects());
-                })
-                .thenCompose(Function.identity())
-                .thenCompose(unused -> buttonFutureList.getMainFuture())
-                .handle((unused, throwable) -> {
-                    if(throwable != null) {
-                        log.warn("Embedded messages button message loading failed.", throwable);
-                    }
-                    return self.removeButtons(buttonFutureList.getObjects());
-                })
-                // deleting the messages from db regardless of exceptions, at most the reaction remains
-                .thenCompose(Function.identity())
-                .whenComplete((unused, throwable) -> {
-                    if(throwable != null) {
-                        log.warn("Embedded message button clearing failed.", throwable);
-                    }
-                    self.deleteEmbeddedMessages(embeddedMessagesHandled, componentPayloadsToDelete);
-                })
-                .exceptionally(throwable -> {
-                    log.error("Failed to clean up embedded messages.", throwable);
-                    return null;
-                });
-    }
-
-    public CompletableFuture<Void> removeButtons(List<Message> messages) {
-        List<CompletableFuture<Void>> removalFutures = new ArrayList<>();
-        messages.forEach(message -> removalFutures.add(componentServiceBean.clearButtons(message)));
-        return FutureUtils.toSingleFutureGeneric(removalFutures);
-    }
-
-    private ServerChannelMessage convertEmbedMessageToServerChannelMessage(EmbeddedMessage embeddedMessage) {
-        return ServerChannelMessage
                 .builder()
-                .serverId(embeddedMessage.getEmbeddingServer().getId())
+                .message(embeddedMessage)
-                .channelId(embeddedMessage.getEmbeddingChannel().getId())
-                .messageId(embeddedMessage.getEmbeddingMessageId())
                 .build();
+            MessageToSend messageToSend =
+                templateService.renderEmbedTemplate(MESSAGE_EMBED_CLEANUP_REPLACEMENT_TEMPLATE, model, embeddingMessage.getServerId());
+            return channelService.editMessageInAChannelFuture(messageToSend, embeddingMessage.getServerId(), embeddingMessage.getChannelId(),
+                embeddingMessage.getMessageId());
+        }).toList();
+        return FutureUtils.toSingleFutureGeneric(editList).whenComplete((unused, throwable) -> {
+            if(throwable != null) {
+                log.warn("Failed to cleanup embedded messages..", throwable);
+            }
+            self.deleteEmbeddedMessages(embeddedMessagesHandled, componentPayloadsToDelete);
+        });
     }
 
-    @Transactional
-    public CompletableFuture<Void> removeReactions(List<Message> allMessages) {
-        List<CompletableFuture<Void>> removalFutures = new ArrayList<>();
-        Map<Long, List<Message>> groupedPerServer = allMessages
-                .stream()
-                .collect(Collectors.groupingBy(message -> message.getGuild().getIdLong()));
-        groupedPerServer.forEach((serverId, serverMessages) -> {
-            // we assume the emote remained the same
-            CompletableFutureList<Void> removalFuture = reactionService.removeReactionFromMessagesWithFutureWithFutureList(serverMessages, REMOVAL_EMOTE);
-            removalFutures.add(removalFuture.getMainFuture());
-        });
-        return FutureUtils.toSingleFutureGeneric(removalFutures);
-    }
 
     @Transactional
     public void deleteEmbeddedMessages(List<Long> embeddedMessagesToDelete, List<String> componentPayloadsToDelete) {
@@ -357,7 +321,9 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
 
     private Boolean shouldMentionReferencedAuthor(Message message) {
         if(message.getReferencedMessage() != null) {
-            return message.getMentions().getMentions(Message.MentionType.USER).contains(message.getReferencedMessage().getAuthor());
+            return message.getMentions().getMentions(Message.MentionType.USER)
+                .stream()
+                .anyMatch(user -> message.getReferencedMessage().getAuthor().getIdLong() == user.getIdLong());
         }
         return false;
     }