[AB-xxx] migrating assignable role commands to slash commands

removing separate command for editing assignable role place text, and adding it to the change command
fixing 2 bugs related with deleting assignable roles with users, and deleting assignable role places
refactoring how enums are handled with slash command parameters
adding cleanup for slash command confirmation payloads once they are clicked

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,7 +27,10 @@ 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.entities.emoji.CustomEmoji;
+import net.dv8tion.jda.api.entities.emoji.Emoji;
 import net.dv8tion.jda.api.interactions.components.buttons.ButtonStyle;
 import org.apache.commons.lang3.BooleanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -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/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/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/statistic/statistic-impl/src/main/java/dev/sheldan/abstracto/statistic/emote/command/DeletedEmoteStats.java

@@ -116,19 +116,13 @@ public class DeletedEmoteStats extends AbstractConditionableCommand {
                 .build();
         parameters.add(periodParameter);
 
-        List<String> emoteTypes = Arrays
-            .stream(UsedEmoteTypeParameter.values())
-            .map(Enum::name)
-            .collect(Collectors.toList());
-
         Parameter typeParameter = Parameter
             .builder()
             .name(DELETED_EMOTE_STATS_USED_EMOTE_TYPE)
             .templated(true)
             .slashCommandOnly(true)
             .optional(true)
-            .choices(emoteTypes)
+            .type(UsedEmoteTypeParameter.class)
-            .type(String.class)
             .build();
 
         parameters.add(typeParameter);

abstracto-application/abstracto-modules/statistic/statistic-impl/src/main/java/dev/sheldan/abstracto/statistic/emote/command/EmoteStat.java

@@ -124,19 +124,13 @@ public class EmoteStat extends AbstractConditionableCommand {
                 .build();
         parameters.add(periodParameter);
 
-        List<String> emoteTypes = Arrays
-            .stream(UsedEmoteTypeParameter.values())
-            .map(Enum::name)
-            .collect(Collectors.toList());
-
         Parameter typeParameter = Parameter
             .builder()
             .name(EMOTE_STAT_USED_EMOTE_TYPE)
             .templated(true)
             .slashCommandOnly(true)
             .optional(true)
-            .choices(emoteTypes)
+            .type(UsedEmoteTypeParameter.class)
-            .type(String.class)
             .build();
 
         parameters.add(typeParameter);

abstracto-application/abstracto-modules/statistic/statistic-impl/src/main/java/dev/sheldan/abstracto/statistic/emote/command/EmoteStats.java

@@ -118,19 +118,13 @@ public class EmoteStats extends AbstractConditionableCommand {
 
         parameters.add(periodParameter);
 
-        List<String> emoteTypes = Arrays
-            .stream(UsedEmoteTypeParameter.values())
-            .map(Enum::name)
-            .collect(Collectors.toList());
-
         Parameter typeParameter = Parameter
             .builder()
             .name(EMOTE_STATS_USED_EMOTE_TYPE)
             .templated(true)
             .slashCommandOnly(true)
             .optional(true)
-            .choices(emoteTypes)
+            .type(UsedEmoteTypeParameter.class)
-            .type(String.class)
             .build();
 
         SlashCommandConfig slashCommandConfig = SlashCommandConfig

abstracto-application/abstracto-modules/statistic/statistic-impl/src/main/java/dev/sheldan/abstracto/statistic/emote/command/ExternalEmoteStats.java

@@ -128,19 +128,13 @@ public class ExternalEmoteStats extends AbstractConditionableCommand {
                 .templated(true)
                 .build();
 
-        List<String> emoteTypes = Arrays
-            .stream(UsedEmoteTypeParameter.values())
-            .map(Enum::name)
-            .collect(Collectors.toList());
-
         Parameter typeParameter = Parameter
             .builder()
             .name(EXTERNAL_EMOTE_STATS_USED_EMOTE_TYPE)
             .templated(true)
             .slashCommandOnly(true)
             .optional(true)
-            .choices(emoteTypes)
+            .type(UsedEmoteTypeParameter.class)
-            .type(String.class)
             .build();
 
         parameters.add(typeParameter);

abstracto-application/abstracto-modules/statistic/statistic-impl/src/main/java/dev/sheldan/abstracto/statistic/emote/command/parameter/UsedEmoteTypeParameter.java

@@ -1,8 +1,9 @@
 package dev.sheldan.abstracto.statistic.emote.command.parameter;
 
+import dev.sheldan.abstracto.core.command.execution.CommandParameterKey;
 import dev.sheldan.abstracto.statistic.emote.model.database.UsedEmoteType;
 
-public enum UsedEmoteTypeParameter {
+public enum UsedEmoteTypeParameter implements CommandParameterKey {
     REACTION,
     MESSAGE;
 

abstracto-application/abstracto-modules/twitch/twitch-impl/src/main/java/dev/sheldan/abstracto/twitch/command/ChangeTwitchStreamer.java

@@ -5,6 +5,7 @@ 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.CommandParameterKey;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
@@ -111,17 +112,11 @@ public class ChangeTwitchStreamer extends AbstractConditionableCommand {
                 .type(String.class)
                 .build();
 
-        List<String> streamerProperties = Arrays
-                .stream(StreamerProperty.values())
-                .map(Enum::name)
-                .collect(Collectors.toList());
-
         Parameter streamerPropertyParameter = Parameter
                 .builder()
                 .templated(true)
                 .name(STREAMER_PROPERTY_PARAMETER)
-                .type(String.class)
+                .type(StreamerProperty.class)
-                .choices(streamerProperties)
                 .build();
 
         Parameter newValueParameter = Parameter
@@ -165,7 +160,7 @@ public class ChangeTwitchStreamer extends AbstractConditionableCommand {
         return TwitchFeatureDefinition.TWITCH;
     }
 
-    public enum StreamerProperty {
+    public enum StreamerProperty implements CommandParameterKey {
         TARGET_CHANNEL, STREAMER_MEMBER, DISABLE_NOTIFICATIONS, TEMPLATE_KEY
     }
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/utility/Echo.java

@@ -106,7 +106,10 @@ public class Echo extends AbstractConditionableCommand {
                 .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .rootCommandName(ECHO_COMMAND)
                 .build();
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        HelpInfo helpInfo = HelpInfo
+            .builder()
+            .templated(true)
+            .build();
         return CommandConfiguration.builder()
                 .name(ECHO_COMMAND)
                 .slashCommandOnly(true)

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/interaction/InteractionServiceBean.java

@@ -253,6 +253,11 @@ public class InteractionServiceBean implements InteractionService {
         return replaceOriginal(messageToSend, interactionHook);
     }
 
+    @Override
+    public CompletableFuture<Void> deleteMessage(InteractionHook interactionHook) {
+        return interactionHook.deleteOriginal().submit();
+    }
+
     public CompletableFuture<InteractionHook> replyMessageToSend(MessageToSend messageToSend, IReplyCallback callback) {
         ReplyCallbackAction action = null;
         if(messageToSend.getMessages() != null && !messageToSend.getMessages().isEmpty()) {

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/interaction/button/listener/ConfirmationButtonClickedListener.java

@@ -85,7 +85,12 @@ public class ConfirmationButtonClickedListener implements ButtonClickedListener
         } catch (Exception e) {
             commandReceivedHandler.reportException(context.getContext(), context.getCommand(), e, "Confirmation execution of command failed.");
         } finally {
-            cleanup(model, payload);
+            cleanup(model, payload).thenAccept(unused -> {
+                log.info("Cleanup successful.");
+            }).exceptionally(throwable -> {
+                log.error("Failed to cleanup confirmation button.", throwable);
+                return null;
+            });
         }
     }
 

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/interaction/slash/SlashCommandListenerBean.java

@@ -33,7 +33,6 @@ import java.util.concurrent.ConcurrentHashMap;
 import dev.sheldan.abstracto.core.utils.ContextUtils;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
-import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
@@ -200,7 +199,7 @@ public class SlashCommandListenerBean extends ListenerAdapter {
     }
 
     @Transactional
-    public void continueSlashCommand(Long interactionId, ButtonInteractionEvent buttonInteractionEvent) {
+    public void continueSlashCommand(Long interactionId, ButtonInteractionEvent buttonInteractionEvent, SlashCommandConfirmationPayload  slashCommandConfirmationPayload) {
         if(COMMANDS_WAITING_FOR_CONFIRMATION.containsKey(interactionId)) {
             DriedSlashCommand driedSlashCommand = COMMANDS_WAITING_FOR_CONFIRMATION.get(interactionId);
             Command commandInstance = driedSlashCommand.getCommand();
@@ -212,11 +211,13 @@ public class SlashCommandListenerBean extends ListenerAdapter {
             }).thenAccept(commandResult -> {
                 self.executePostCommandListener(commandInstance, driedSlashCommand.getEvent(), commandResult);
                 COMMANDS_WAITING_FOR_CONFIRMATION.remove(interactionId);
+                self.cleanupSlashCommandConfirmation(slashCommandConfirmationPayload, buttonInteractionEvent);
             }).exceptionally(throwable -> {
                 log.error("Error while handling post execution of command with confirmation {}", commandName, throwable);
                 CommandResult commandResult = CommandResult.fromError(throwable.getMessage(), throwable);
                 self.executePostCommandListener(commandInstance, driedSlashCommand.getEvent(), commandResult);
                 COMMANDS_WAITING_FOR_CONFIRMATION.remove(interactionId);
+                self.cleanupSlashCommandConfirmation(slashCommandConfirmationPayload, buttonInteractionEvent);
                 return null;
             });
         } else {
@@ -224,6 +225,12 @@ public class SlashCommandListenerBean extends ListenerAdapter {
         }
     }
 
+    @Transactional
+    public void cleanupSlashCommandConfirmation(SlashCommandConfirmationPayload  slashCommandConfirmationPayload, ButtonInteractionEvent buttonInteractionEvent) {
+        log.debug("Cleaning up component {} and {}.", slashCommandConfirmationPayload.getConfirmationPayloadId(), slashCommandConfirmationPayload.getAbortPayloadId());
+        componentPayloadManagementService.deletePayloads(Arrays.asList(slashCommandConfirmationPayload.getAbortPayloadId(), slashCommandConfirmationPayload.getConfirmationPayloadId()));
+    }
+
     @Transactional
     public void removeSlashCommandConfirmationInteraction(Long interactionId, String confirmationPayload, String abortPayload) {
         if(COMMANDS_WAITING_FOR_CONFIRMATION.containsKey(interactionId)) {
@@ -253,6 +260,8 @@ public class SlashCommandListenerBean extends ListenerAdapter {
                 .builder()
                 .action(SlashCommandConfirmationPayload.CommandConfirmationAction.CONFIRM)
                 .interactionId(event.getIdLong())
+                .abortPayloadId(abortId)
+                .confirmationPayloadId(confirmationId)
                 .build();
             Long serverId = event.getGuild().getIdLong();
             AServer server = serverManagementService.loadServer(event.getGuild());
@@ -261,6 +270,8 @@ public class SlashCommandListenerBean extends ListenerAdapter {
                 .builder()
                 .action(SlashCommandConfirmationPayload.CommandConfirmationAction.ABORT)
                 .interactionId(event.getIdLong())
+                .abortPayloadId(abortId)
+                .confirmationPayloadId(confirmationId)
                 .build();
             componentPayloadService.createButtonPayload(abortId, denialPayload, SLASH_COMMAND_CONFIRMATION_ORIGIN, server);
             CommandConfirmationModel model = CommandConfirmationModel

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/interaction/slash/SlashCommandServiceBean.java

@@ -2,6 +2,7 @@ package dev.sheldan.abstracto.core.interaction.slash;
 
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.execution.CommandParameterKey;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.command.config.UserCommandConfig;
 import dev.sheldan.abstracto.core.command.model.database.ACommand;
@@ -235,6 +236,9 @@ public class SlashCommandServiceBean implements SlashCommandService {
     }
 
     private void addChoices(OptionData optionData, Parameter parameter, String commandName, boolean isTemplated, Long serverId) {
+        if(CommandParameterKey.class.isAssignableFrom(parameter.getType())) {
+            parameter.setChoices(CommandParameterKey.getKeys(parameter.getType()));
+        }
         parameter.getChoices().forEach(choiceKey -> {
             String value = isTemplated ? templateService.renderSimpleTemplate(commandName + "_parameter_" + parameter.getName() + "_choice_" + choiceKey, serverId) : choiceKey;
             optionData.addChoice(value, choiceKey);

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/interaction/slash/listener/SlashCommandConfirmationGivenButtonListener.java

@@ -26,7 +26,7 @@ public class SlashCommandConfirmationGivenButtonListener implements ButtonClicke
     public ButtonClickedListenerResult execute(ButtonClickedListenerModel model) {
         SlashCommandConfirmationPayload payload = (SlashCommandConfirmationPayload) model.getDeserializedPayload();
         if(payload.getAction().equals(SlashCommandConfirmationPayload.CommandConfirmationAction.CONFIRM)) {
-            slashCommandListenerBean.continueSlashCommand(payload.getInteractionId(), model.getEvent());
+            slashCommandListenerBean.continueSlashCommand(payload.getInteractionId(), model.getEvent(), payload);
             return ButtonClickedListenerResult.ACKNOWLEDGED;
         } else {
             return ButtonClickedListenerResult.IGNORED;

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/interaction/slash/parameter/SlashCommandParameterServiceBean.java

@@ -171,7 +171,8 @@ public class SlashCommandParameterServiceBean implements SlashCommandParameterSe
     public List<OptionType> getTypesFromParameter(Parameter parameter) {
         return parameterProviders
                 .stream()
-                .filter(slashCommandParameterProvider -> slashCommandParameterProvider.getOptionMapping().getType().equals(parameter.getType()))
+                .filter(slashCommandParameterProvider -> slashCommandParameterProvider.getOptionMapping().getType().equals(parameter.getType())
+                    || slashCommandParameterProvider.getOptionMapping().getType().isAssignableFrom(parameter.getType()))
                 .findAny()
                 .map(slashCommandParameterProvider -> {
                     List<OptionType> optionTypes;
@@ -194,7 +195,8 @@ public class SlashCommandParameterServiceBean implements SlashCommandParameterSe
     public List<OptionType> getTypesFromParameter(Class clazz, boolean strict) {
         return parameterProviders
                 .stream()
-                .filter(slashCommandParameterProvider -> slashCommandParameterProvider.getOptionMapping().getType().equals(clazz))
+            .filter(slashCommandParameterProvider -> slashCommandParameterProvider.getOptionMapping().getType().equals(clazz)
+                || slashCommandParameterProvider.getOptionMapping().getType().isAssignableFrom(clazz))
                 .findAny()
                 .map(slashCommandParameterProvider -> {
                     List<OptionType> optionTypes;

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/interaction/slash/parameter/provider/provided/CommandParameterKeySlashCommandParameterProvider.java

@@ -0,0 +1,20 @@
+package dev.sheldan.abstracto.core.interaction.slash.parameter.provider.provided;
+
+import dev.sheldan.abstracto.core.command.execution.CommandParameterKey;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandOptionTypeMapping;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.provider.SlashCommandParameterProvider;
+import java.util.Arrays;
+import net.dv8tion.jda.api.interactions.commands.OptionType;
+import org.springframework.stereotype.Component;
+
+@Component
+public class CommandParameterKeySlashCommandParameterProvider implements SlashCommandParameterProvider {
+    @Override
+    public SlashCommandOptionTypeMapping getOptionMapping() {
+        return SlashCommandOptionTypeMapping
+                .builder()
+                .type(CommandParameterKey.class)
+                .optionTypes(Arrays.asList(OptionType.STRING))
+                .build();
+    }
+}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/interaction/slash/payload/SlashCommandConfirmationPayload.java

@@ -10,6 +10,8 @@ public class SlashCommandConfirmationPayload implements ButtonPayload {
 
     private CommandConfirmationAction action;
     private Long interactionId;
+    private String confirmationPayloadId;
+    private String abortPayloadId;
 
     public enum CommandConfirmationAction {
         CONFIRM, ABORT

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/execution/CommandParameterKey.java

@@ -19,4 +19,10 @@ public interface CommandParameterKey {
         }
         throw new IllegalArgumentException("Clazz and key must not be null");
     }
+
+    static <T extends Enum<T>> List<String> getKeys(Class<T> clazz) {
+        return Arrays.stream(clazz.getEnumConstants())
+            .map(Enum::name)
+            .toList();
+    }
 }

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/interaction/InteractionService.java

@@ -17,6 +17,7 @@ public interface InteractionService {
     List<CompletableFuture<Message>> sendEmbed(String templateKey, InteractionHook interactionHook);
     CompletableFuture<Message> replaceOriginal(MessageToSend messageToSend, InteractionHook interactionHook);
     CompletableFuture<Message> replaceOriginal(String template, Object model, InteractionHook interactionHook);
+    CompletableFuture<Void> deleteMessage(InteractionHook interactionHook);
     CompletableFuture<InteractionHook> replyMessageToSend(MessageToSend messageToSend, IReplyCallback callback);
     CompletableFuture<InteractionHook> replyMessage(String templateKey, Object model, IReplyCallback callback);
     CompletableFuture<Message> replyString(String content, InteractionHook interactionHook);