[AB-xxx] adding initial support for components v2

fixing issue with buttons which only provide an emoji
adding logging in case updating a starboard post goes wrong

.env

@@ -1,2 +1,2 @@
 REGISTRY_PREFIX=harbor.sheldan.dev/abstracto/
-VERSION=1.5.56
+VERSION=1.6.8

.github/workflows/release_manual.yml

@@ -30,7 +30,7 @@ jobs:
         with:
           title: Release of version ${{ env.version }}
       - name: Release maven packages
-        uses: qcastel/github-actions-maven-release@v1.12.41
+        uses: qcastel/github-actions-maven-release@v1.12.43
         env:
           JAVA_HOME: /usr/lib/jvm/java-17-openjdk/
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Sheldan
+Copyright (c) 2025 Sheldan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -11,7 +11,7 @@ This repository does not provide the full functionality in order to start a disc
 
 
 ## Technologies
-* [JDA](https://github.com/DV8FromTheWorld/JDA/) The Discord API Wrapper in the version 5.0.0-beta.21
+* [JDA](https://github.com/DV8FromTheWorld/JDA/) The Discord API Wrapper in the version 5.4.0
 * [Spring boot](https://github.com/spring-projects/spring-boot) is used as a framework to create standalone application in Java with Java EE methods. (including dependency injection and more)
 * [Hibernate](https://github.com/hibernate/hibernate-orm) is used as a reference implementation of JPA.
 * [Freemarker](https://github.com/apache/freemarker) is used as a templating engine. This is used to provide internationalization for user facing text and enable dynamic embed configuration.
@@ -30,4 +30,4 @@ If you want to view the documentation to an earlier released version you need to
 If you find any issue, feel free to create a GitHub issue.
 
 ## License
-This project is licensed under the MIT license.
+This project is licensed under the MIT license.

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

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

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

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

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

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

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

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

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

@@ -1,16 +1,26 @@
 package dev.sheldan.abstracto.assignableroles.command;
 
 import dev.sheldan.abstracto.assignableroles.config.AssignableRoleFeatureDefinition;
+import dev.sheldan.abstracto.assignableroles.config.AssignableRolePlaceSlashCommandName;
 import dev.sheldan.abstracto.assignableroles.service.AssignableRolePlaceService;
+import dev.sheldan.abstracto.assignableroles.service.management.AssignableRolePlaceManagementService;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import java.util.ArrayList;
+import java.util.stream.Collectors;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -24,37 +34,78 @@ import java.util.concurrent.CompletableFuture;
 @Component
 public class ActivateAssignableRolePlace extends AbstractConditionableCommand {
 
+    private static final String ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER = "name";
+    private static final String ACTIVATE_ASSIGNABLE_ROLE_PLACE_RESPONSE = "activateAssignableRolePlace_response";
     @Autowired
     private AssignableRolePlaceService service;
 
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private AssignableRolePlaceManagementService assignableRolePlaceManagementService;
+
     @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        return service.activateAssignableRolePlace(server, name)
-                .thenApply(unused -> CommandResult.fromSuccess());
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        return service.activateAssignableRolePlace(server, assignableRolePlaceName)
+            .thenAccept(unused -> interactionService.replyEmbed(ACTIVATE_ASSIGNABLE_ROLE_PLACE_RESPONSE, new Object(), 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 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) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        Role role = (Role) parameters.get(1);
-        AssignableRoleConditionType configKey = (AssignableRoleConditionType) parameters.get(2);
-        String parameterValue = (String) parameters.get(3);
-        assignableRoleConditionService.createAssignableRoleCondition(name, role, configKey, parameterValue);
-        return CommandResult.fromSuccess();
+    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 configKeyString = slashCommandParameterService.getCommandOption(CONDITION_KEY_PARAMETER, event, String.class);
+        AssignableRoleConditionType configKey = CommandParameterKey.getEnumFromKey(AssignableRoleConditionType.class, configKeyString);
+        String parameterValue = slashCommandParameterService.getCommandOption(CONDITION_PARAMETER_PARAMETER, event, String.class);
+        assignableRoleConditionService.createAssignableRoleCondition(assignableRolePlaceName, role, configKey, parameterValue);
+        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) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        AssignableRolePlaceParameterKey configKey = (AssignableRolePlaceParameterKey) parameters.get(1);
-        String parameterValue = (String) parameters.get(2);
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        return service.changeConfiguration(server, name, configKey, parameterValue)
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        String assignableRolePlaceParameterKeyString = slashCommandParameterService.getCommandOption(CONFIGURATION_KEY_PARAMETER, event, String.class);
+        AssignableRolePlaceParameterKey enumFromKey =
+            CommandParameterKey.getEnumFromKey(AssignableRolePlaceParameterKey.class, assignableRolePlaceParameterKeyString);
+        String parameterValue = slashCommandParameterService.getCommandOption(CONFIGURATION_VALUE_PARAMETER, event, String.class);
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        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) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        TextChannel channel = (TextChannel) parameters.get(1);
-        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())) {
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        GuildChannel channel = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_CHANNEL_PARAMETER, event, TextChannel.class, GuildChannel.class);
+        if(!channel.getGuild().equals(event.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);
-        return CommandResult.fromSuccess();
+        service.createAssignableRolePlace(assignableRolePlaceName, chosenChannel, text, type);
+        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) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        return service.deactivateAssignableRolePlace(server, name)
-                .thenApply(unused -> CommandResult.fromSuccess());
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        return service.deactivateAssignableRolePlace(server, assignableRolePlaceName)
+            .thenAccept(unused -> interactionService.replyEmbed(DEACTIVATE_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();
         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) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        return service.deleteAssignableRolePlace(server, name)
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        return service.deleteAssignableRolePlace(server, assignableRolePlaceName)
+            .thenAccept(unused -> slashCommandService.completeConfirmableCommand(event, DELETE_ASSIGNABLE_ROLE_PLACE_RESPONSE_TEMPLATE))
+            .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) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        Role role = (Role) parameters.get(1);
-        AssignableRoleConditionType configKey = (AssignableRoleConditionType) parameters.get(2);
-        assignableRoleConditionService.deleteAssignableRoleCondition(name, role, configKey);
-        return CommandResult.fromSuccess();
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        Role assignableRole = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PARAMETER, event, Role.class);
+        String conditionKeyString = slashCommandParameterService.getCommandOption(CONDITION_KEY_PARAMETER, event, String.class);
+
+        AssignableRoleConditionType assignableRoleConditionType = CommandParameterKey.getEnumFromKey(AssignableRoleConditionType.class, conditionKeyString);
+        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) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        ARole role = (ARole) parameters.get(1);
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        return service.removeRoleFromAssignableRolePlace(server, name, role)
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        ARole actualRole;
+        if(slashCommandParameterService.hasCommandOptionWithFullType(ASSIGNABLE_ROLE_PARAMETER, event, OptionType.ROLE)) {
+            Role role = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PARAMETER, event, ARole.class, Role.class);
+            actualRole = roleManagementService.findRole(role.getIdLong());
+        } 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) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        return service.setupAssignableRolePlace(server, name)
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        AServer server = serverManagementService.loadServer(event.getGuild());
+        return service.setupAssignableRolePlace(server, assignableRolePlaceName)
+            .thenAccept(unused -> interactionService.replyEmbed(SETUP_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();
         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.service.management.ServerManagementService;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
+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 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) {
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        String name = (String) parameters.get(0);
-        AssignableRolePlaceConfig config = service.getAssignableRolePlaceConfig(commandContext.getGuild(), name);
-        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInMessageChannel(ASSIGNABLE_ROLES_CONFIG_POST_TEMPLATE_KEY, config, commandContext.getChannel()))
-                .thenApply(unused -> CommandResult.fromSuccess());
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String assignableRolePlaceName = slashCommandParameterService.getCommandOption(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER, event, String.class);
+        AssignableRolePlaceConfig config = service.getAssignableRolePlaceConfig(event.getGuild(), assignableRolePlaceName);
+        return interactionService.replyEmbed(ASSIGNABLE_ROLES_CONFIG_POST_TEMPLATE_KEY, config, event)
+            .thenApply(interactionHook -> CommandResult.fromSuccess());
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter rolePostName = Parameter
                 .builder()
-                .name("name")
+                .name(ASSIGNABLE_ROLE_PLACE_NAME_PARAMETER)
                 .type(String.class)
                 .templated(true)
                 .build();
@@ -59,13 +61,24 @@ public class ShowAssignableRolePlaceConfig extends AbstractConditionableCommand
                 .builder()
                 .templated(true)
                 .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
+            .rootCommandName(AssignableRolePlaceSlashCommandName.ASSIGNABLE_ROLE_PLACE)
+            .groupName("place")
+            .commandName("showconfig")
+            .build();
+
         return CommandConfiguration.builder()
                 .name("showAssignableRolePlaceConfig")
                 .module(AssignableRoleModuleDefinition.ASSIGNABLE_ROLES)
                 .templated(true)
                 .async(true)
                 .causesReaction(false)
-                .messageCommandOnly(true)
+                .slashCommandOnly(true)
+                .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .parameters(parameters)
                 .help(helpInfo)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,30 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                     xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.26.xsd" >
+    <property name="editAssignableRolePlaceTextCommandId" value="(SELECT id FROM command WHERE name = 'editAssignableRolePlaceText')"/>
+    <changeSet author="Sheldan" id="delete-editAssignableRolePlaceText_command">
+        <sql >
+            delete from ${database.defaultSchemaName}.command_in_server_allowed_role
+            where command_in_server_id
+                      in
+                  (select
+                          command_in_server_id
+                  from ${database.defaultSchemaName}.command_in_server
+                  where command_id = (SELECT id FROM ${database.defaultSchemaName}.command WHERE name = 'editAssignableRolePlaceText'));
+            delete from ${database.defaultSchemaName}.command_in_server_alias
+            where command_in_server_id
+                      in
+                  (select command_in_server_id
+                  from ${database.defaultSchemaName}.command_in_server
+                  where command_id =
+                        (SELECT id FROM ${database.defaultSchemaName}.command WHERE name = 'editAssignableRolePlaceText'))
+        </sql>
+        <delete tableName="command_in_server">
+            <where>command_id=${editAssignableRolePlaceTextCommandId}</where>
+        </delete>
+        <delete tableName="command">
+            <where>id=${editAssignableRolePlaceTextCommandId}</where>
+        </delete>
+    </changeSet>
+</databaseChangeLog>

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

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

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/resources/migrations/assignableRoles-changeLog.xml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -5,11 +5,14 @@ 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.UserCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandFeatureDefinition;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandSlashCommandNames;
 import dev.sheldan.abstracto.customcommand.service.management.CustomCommandService;
@@ -44,8 +47,11 @@ public class CreateCustomCommand extends AbstractConditionableCommand {
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         String name = slashCommandParameterService.getCommandOption(CUSTOM_COMMAND_NAME_PARAMETER, event, String.class);
         String content = slashCommandParameterService.getCommandOption(CUSTOM_COMMAND_CONTENT_PARAMETER, event, String.class);
-
-        customCommandService.createCustomCommand(name, content, event.getMember());
+        if(ContextUtils.isUserCommand(event)) {
+            customCommandService.createUserCustomCommand(name, content, event.getUser());
+        } else {
+            customCommandService.createCustomCommand(name, content, event.getMember());
+        }
         return interactionService.replyEmbed(CREATE_CUSTOM_COMMAND_RESPONSE_TEMPLATE_KEY, event)
                 .thenApply(interactionHook -> CommandResult.fromSuccess());
     }
@@ -80,6 +86,9 @@ public class CreateCustomCommand extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .rootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND)
                 .commandName("create")
                 .build();

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

@@ -5,15 +5,26 @@ 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.UserCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUser;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserManagementService;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandFeatureDefinition;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandSlashCommandNames;
+import dev.sheldan.abstracto.customcommand.service.management.CustomCommandManagementService;
 import dev.sheldan.abstracto.customcommand.service.management.CustomCommandService;
+import java.util.ArrayList;
 import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -36,24 +47,59 @@ public class DeleteCustomCommand extends AbstractConditionableCommand {
     @Autowired
     private CustomCommandService customCommandService;
 
+    @Autowired
+    private CustomCommandManagementService customCommandManagementService;
+
     @Autowired
     private InteractionService interactionService;
 
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Autowired
+    private UserManagementService userManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         String name = slashCommandParameterService.getCommandOption(CUSTOM_COMMAND_NAME_PARAMETER, event, String.class);
-
-        customCommandService.deleteCustomCommand(name, event.getGuild());
+        if(ContextUtils.isUserCommand(event)) {
+            customCommandService.deleteUserCustomCommand(name, event.getUser());
+        } else {
+            customCommandService.deleteCustomCommand(name, event.getGuild());
+        }
         return interactionService.replyEmbed(DELETE_CUSTOM_COMMAND_RESPONSE_TEMPLATE_KEY, event)
                 .thenApply(interactionHook -> CommandResult.fromSuccess());
     }
 
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), CUSTOM_COMMAND_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            if(ContextUtils.isUserCommand(event)) {
+                AUser user = userManagementService.loadUser(event.getUser().getIdLong());
+                return customCommandManagementService.getUserCustomCommandsContaining(input, user)
+                    .stream().map(customCommand -> customCommand.getName().toLowerCase())
+                    .toList();
+            } else {
+                AServer server = serverManagementService.loadServer(event.getGuild());
+                return customCommandManagementService.getCustomCommandsContaining(input, server)
+                    .stream().map(customCommand -> customCommand.getName().toLowerCase())
+                    .toList();
+            }
+        }
+        return new ArrayList<>();
+    }
+
     @Override
     public CommandConfiguration getConfiguration() {
         Parameter commandNameParameter = Parameter
                 .builder()
                 .name(CUSTOM_COMMAND_NAME_PARAMETER)
                 .templated(true)
+                .supportsAutoComplete(true)
                 .type(String.class)
                 .build();
 
@@ -66,6 +112,9 @@ public class DeleteCustomCommand extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .rootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND)
                 .commandName("delete")
                 .build();

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

@@ -5,12 +5,14 @@ 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.UserCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandFeatureDefinition;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandSlashCommandNames;
 import dev.sheldan.abstracto.customcommand.model.command.CustomCommandResponseModel;
@@ -48,7 +50,12 @@ public class GetCustomCommand extends AbstractConditionableCommand {
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         String name = slashCommandParameterService.getCommandOption(CUSTOM_COMMAND_NAME_PARAMETER, event, String.class);
-        CustomCommand customCommand = customCommandService.getCustomCommand(name, event.getGuild());
+        CustomCommand customCommand;
+        if(ContextUtils.isUserCommand(event)) {
+            customCommand = customCommandService.getUserCustomCommand(name, event.getUser());
+        } else {
+            customCommand = customCommandService.getCustomCommand(name, event.getGuild());
+        }
         CustomCommandResponseModel model = CustomCommandResponseModel
                 .builder()
                 .additionalText(customCommand.getAdditionalMessage())
@@ -61,11 +68,17 @@ public class GetCustomCommand extends AbstractConditionableCommand {
     public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
         if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), CUSTOM_COMMAND_NAME_PARAMETER)) {
             String input = event.getFocusedOption().getValue();
-            return customCommandService.getCustomCommandsStartingWith(input, event.getGuild())
-                    .stream()
-                    .map(CustomCommand::getName)
-                    .limit(25)
-                    .toList();
+            if(ContextUtils.isNotUserCommand(event)) {
+                return customCommandService.getCustomCommandsContaining(input, event.getGuild())
+                        .stream()
+                        .map(CustomCommand::getName)
+                        .toList();
+            } else {
+                return customCommandService.getUserCustomCommandsContaining(input, event.getUser())
+                        .stream()
+                        .map(CustomCommand::getName)
+                        .toList();
+            }
         } else {
             return new ArrayList<>();
         }
@@ -95,7 +108,10 @@ public class GetCustomCommand extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND_PUBLIC)
+                .userRootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND)
                 .commandName("get")
                 .build();
 

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

@@ -4,11 +4,13 @@ import dev.sheldan.abstracto.core.command.UtilityModuleDefinition;
 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.UserCommandConfig;
 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.service.PaginatorService;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandFeatureDefinition;
 import dev.sheldan.abstracto.customcommand.config.CustomCommandSlashCommandNames;
 import dev.sheldan.abstracto.customcommand.model.command.ListCustomCommandsResponseModel;
@@ -42,7 +44,12 @@ public class ListCustomCommands extends AbstractConditionableCommand {
 
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        List<CustomCommand> customCommands = customCommandService.getCustomCommands(event.getGuild());
+        List<CustomCommand> customCommands;
+        if(ContextUtils.isUserCommand(event)) {
+            customCommands = customCommandService.getUserCustomCommands(event.getUser());
+        } else {
+            customCommands = customCommandService.getCustomCommands(event.getGuild());
+        }
         if(customCommands.isEmpty()) {
             return interactionService.replyEmbed(NO_CUSTOM_COMMANDS_TEMPLATE_KEY, event)
                     .thenApply(interactionHook -> CommandResult.fromSuccess());
@@ -67,7 +74,10 @@ public class ListCustomCommands extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND_PUBLIC)
+                .userRootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND)
                 .commandName("list")
                 .build();
 

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

@@ -1,6 +1,7 @@
 package dev.sheldan.abstracto.customcommand.repository;
 
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
@@ -11,7 +12,14 @@ import java.util.Optional;
 @Repository
 public interface CustomCommandRepository extends JpaRepository<CustomCommand, Long> {
     Optional<CustomCommand> getByNameIgnoreCaseAndServer(String name, AServer server);
+    Optional<CustomCommand> getByNameIgnoreCaseAndCreatorUser(String name, AUser creator);
+    Optional<CustomCommand> getByNameIgnoreCaseAndCreatorUser_IdAndUserSpecific(String name, Long userId, Boolean userSpecific);
     void deleteByNameAndServer(String name, AServer server);
+    void deleteByNameAndCreatorUserAndUserSpecific(String name, AUser aUser, Boolean userSpecific);
     List<CustomCommand> findByServer(AServer server);
+    List<CustomCommand> findByCreatorUserAndUserSpecific(AUser user, Boolean userSpecific);
     List<CustomCommand> findByNameStartsWithIgnoreCaseAndServer(String prefix, AServer server);
+    List<CustomCommand> findByNameStartsWithIgnoreCaseAndCreatorUserAndUserSpecific(String prefix, AUser aUser, Boolean userSpecific);
+    List<CustomCommand> findByNameContainingIgnoreCaseAndServer(String name, AServer server);
+    List<CustomCommand> findByNameContainingIgnoreCaseAndCreatorUserAndUserSpecific(String name, AUser user, Boolean userSpecific);
 }

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

@@ -1,9 +1,11 @@
 package dev.sheldan.abstracto.customcommand.service;
 
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserManagementService;
 import dev.sheldan.abstracto.customcommand.exception.CustomCommandExistsException;
 import dev.sheldan.abstracto.customcommand.exception.CustomCommandNotFoundException;
 import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
@@ -11,6 +13,7 @@ import dev.sheldan.abstracto.customcommand.service.management.CustomCommandManag
 import dev.sheldan.abstracto.customcommand.service.management.CustomCommandService;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.User;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -28,6 +31,9 @@ public class CustomCommandServiceBean implements CustomCommandService {
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private UserManagementService userManagementService;
+
     @Override
     public CustomCommand createCustomCommand(String name, String content, Member creator) {
         if(customCommandManagementService.getCustomCommandByName(name, creator.getGuild().getIdLong()).isPresent()) {
@@ -37,6 +43,15 @@ public class CustomCommandServiceBean implements CustomCommandService {
         return customCommandManagementService.createCustomCommand(name, content, creatorUser);
     }
 
+    @Override
+    public CustomCommand createUserCustomCommand(String name, String content, User user) {
+        AUser aUser = userManagementService.loadOrCreateUser(user.getIdLong());
+        if(customCommandManagementService.getUserCustomCommandByName(name, aUser).isPresent()) {
+           throw new CustomCommandExistsException();
+        }
+        return customCommandManagementService.createUserCustomCommand(name, content, aUser);
+    }
+
     @Override
     public void deleteCustomCommand(String name, Guild guild) {
         if(customCommandManagementService.getCustomCommandByName(name, guild.getIdLong()).isEmpty()) {
@@ -46,12 +61,27 @@ public class CustomCommandServiceBean implements CustomCommandService {
         customCommandManagementService.deleteCustomCommand(name, server);
     }
 
+    @Override
+    public void deleteUserCustomCommand(String name, User user) {
+        if(customCommandManagementService.getUserCustomCommandByName(name, user.getIdLong()).isEmpty()) {
+            throw new CustomCommandNotFoundException();
+        }
+        AUser aUser = userManagementService.loadOrCreateUser(user.getIdLong());
+        customCommandManagementService.deleteCustomCommand(name, aUser);
+    }
+
     @Override
     public List<CustomCommand> getCustomCommands(Guild guild) {
         AServer server = serverManagementService.loadServer(guild);
         return customCommandManagementService.getCustomCommands(server);
     }
 
+    @Override
+    public List<CustomCommand> getUserCustomCommands(User user) {
+        AUser aUser = userManagementService.loadOrCreateUser(user.getIdLong());
+        return customCommandManagementService.getUserCustomCommands(aUser);
+    }
+
     @Override
     public CustomCommand getCustomCommand(String name, Guild guild) {
         return customCommandManagementService.getCustomCommandByName(name, guild.getIdLong())
@@ -59,8 +89,20 @@ public class CustomCommandServiceBean implements CustomCommandService {
     }
 
     @Override
-    public List<CustomCommand> getCustomCommandsStartingWith(String prefix, Guild guild) {
+    public CustomCommand getUserCustomCommand(String name, User user) {
+        return customCommandManagementService.getUserCustomCommandByName(name, user.getIdLong())
+                .orElseThrow(CustomCommandNotFoundException::new);
+    }
+
+    @Override
+    public List<CustomCommand> getCustomCommandsContaining(String name, Guild guild) {
         AServer server = serverManagementService.loadServer(guild);
-        return customCommandManagementService.getCustomCommandsStartingWith(prefix, server);
+        return customCommandManagementService.getCustomCommandsContaining(name, server);
+    }
+
+    @Override
+    public List<CustomCommand> getUserCustomCommandsContaining(String name, User user) {
+        AUser aUser = userManagementService.loadOrCreateUser(user.getIdLong());
+        return customCommandManagementService.getUserCustomCommandsContaining(name, aUser);
     }
 }

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

@@ -1,6 +1,7 @@
 package dev.sheldan.abstracto.customcommand.service.management;
 
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
@@ -26,6 +27,16 @@ public class CustomCommandManagementServiceBean implements CustomCommandManageme
         return repository.getByNameIgnoreCaseAndServer(name, server);
     }
 
+    @Override
+    public Optional<CustomCommand> getUserCustomCommandByName(String name, AUser user) {
+        return repository.getByNameIgnoreCaseAndCreatorUser(name, user);
+    }
+
+    @Override
+    public Optional<CustomCommand> getUserCustomCommandByName(String name, Long userId) {
+        return repository.getByNameIgnoreCaseAndCreatorUser_IdAndUserSpecific(name, userId, true);
+    }
+
     @Override
     public CustomCommand createCustomCommand(String name, String content, AUserInAServer creator) {
         CustomCommand customCommand = CustomCommand
@@ -34,6 +45,20 @@ public class CustomCommandManagementServiceBean implements CustomCommandManageme
                 .additionalMessage(content)
                 .server(creator.getServerReference())
                 .creator(creator)
+                .userSpecific(false)
+                .creatorUser(creator.getUserReference())
+                .build();
+        return repository.save(customCommand);
+    }
+
+    @Override
+    public CustomCommand createUserCustomCommand(String name, String content, AUser user) {
+        CustomCommand customCommand = CustomCommand
+                .builder()
+                .name(name)
+                .additionalMessage(content)
+                .creatorUser(user)
+                .userSpecific(true)
                 .build();
         return repository.save(customCommand);
     }
@@ -43,14 +68,29 @@ public class CustomCommandManagementServiceBean implements CustomCommandManageme
         repository.deleteByNameAndServer(name, server);
     }
 
+    @Override
+    public void deleteCustomCommand(String name, AUser user) {
+        repository.deleteByNameAndCreatorUserAndUserSpecific(name, user, true);
+    }
+
     @Override
     public List<CustomCommand> getCustomCommands(AServer server) {
         return repository.findByServer(server);
     }
 
     @Override
-    public List<CustomCommand> getCustomCommandsStartingWith(String prefix, AServer server) {
-        return repository.findByNameStartsWithIgnoreCaseAndServer(prefix, server);
+    public List<CustomCommand> getUserCustomCommands(AUser aUser) {
+        return repository.findByCreatorUserAndUserSpecific(aUser, true);
+    }
+
+    @Override
+    public List<CustomCommand> getCustomCommandsContaining(String name, AServer server) {
+        return repository.findByNameContainingIgnoreCaseAndServer(name, server);
+    }
+
+    @Override
+    public List<CustomCommand> getUserCustomCommandsContaining(String prefix, AUser aUser) {
+        return repository.findByNameContainingIgnoreCaseAndCreatorUserAndUserSpecific(prefix, aUser, true);
     }
 
 }

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/resources/migrations/1.5.37/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="tables/tables.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/resources/migrations/1.5.37/tables/custom_command.xml

@@ -0,0 +1,26 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                     xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.26.xsd" >
+    <changeSet author="Sheldan" id="custom_command-add_user_installable_support">
+        <addColumn tableName="custom_command">
+            <column name="creator_id" type="BIGINT">
+                <constraints nullable="true"/>
+            </column>
+            <column name="user_specific" type="BOOLEAN" value="false">
+                <constraints nullable="false"/>
+            </column>
+        </addColumn>
+        <sql>
+            update custom_command set creator_id = (select ua.user_id from user_in_server ua where ua.user_in_server_id = creator_user_in_server_id order by ua.server_id limit 1)
+        </sql>
+        <addNotNullConstraint columnName="creator_id"
+                              tableName="custom_command"
+                              validate="true"/>
+        <sql>
+            ALTER TABLE custom_command ALTER COLUMN server_id DROP NOT NULL;
+            ALTER TABLE custom_command ALTER COLUMN creator_user_in_server_id DROP NOT NULL;
+        </sql>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/resources/migrations/1.5.37/tables/tables.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="custom_command.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/resources/migrations/custom-command-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.4.0/collection.xml" relativeToChangelogFile="true"/>
     <include file="1.5.8/collection.xml" relativeToChangelogFile="true"/>
+    <include file="1.5.37/collection.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>

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

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

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/model/command/ListCustomCommandModel.java

@@ -13,11 +13,18 @@ public class ListCustomCommandModel {
     private MemberDisplay creator;
 
     public static ListCustomCommandModel fromCustomCommand(CustomCommand customCommand) {
+        MemberDisplay creatorObj;
+        if(customCommand.getUserSpecific()) {
+            creatorObj = MemberDisplay.fromAUser(customCommand.getCreatorUser());
+        } else {
+            creatorObj = MemberDisplay.fromAUserInAServer(customCommand.getCreator());
+        }
+
         return ListCustomCommandModel
                 .builder()
                 .name(customCommand.getName())
                 .content(customCommand.getAdditionalMessage())
-                .creator(MemberDisplay.fromAUserInAServer(customCommand.getCreator()))
+                .creator(creatorObj)
                 .build();
     }
 }

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/model/database/CustomCommand.java

@@ -29,13 +29,20 @@ public class CustomCommand implements Serializable {
     private String name;
 
     @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "server_id", nullable = false)
+    @JoinColumn(name = "server_id")
     private AServer server;
 
     @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "creator_user_in_server_id", nullable = false)
+    @JoinColumn(name = "creator_user_in_server_id")
     private AUserInAServer creator;
 
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "creator_id", nullable = false)
+    private AUser creatorUser;
+
+    @Column(name = "user_specific")
+    private Boolean userSpecific;
+
     @Column(name = "created", nullable = false, insertable = false, updatable = false)
     private Instant created;
 

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

@@ -1,6 +1,7 @@
 package dev.sheldan.abstracto.customcommand.service.management;
 
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
 
@@ -9,8 +10,14 @@ import java.util.Optional;
 
 public interface CustomCommandManagementService {
     Optional<CustomCommand> getCustomCommandByName(String name, Long serverId);
+    Optional<CustomCommand> getUserCustomCommandByName(String name, AUser user);
+    Optional<CustomCommand> getUserCustomCommandByName(String name, Long userId);
     CustomCommand createCustomCommand(String name, String content, AUserInAServer creator);
+    CustomCommand createUserCustomCommand(String name, String content, AUser user);
     void deleteCustomCommand(String name, AServer server);
+    void deleteCustomCommand(String name, AUser user);
     List<CustomCommand> getCustomCommands(AServer server);
-    List<CustomCommand> getCustomCommandsStartingWith(String prefix, AServer server);
+    List<CustomCommand> getUserCustomCommands(AUser aUser);
+    List<CustomCommand> getCustomCommandsContaining(String prefix, AServer server);
+    List<CustomCommand> getUserCustomCommandsContaining(String prefix, AUser aUser);
 }

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

@@ -3,13 +3,19 @@ package dev.sheldan.abstracto.customcommand.service.management;
 import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.User;
 
 import java.util.List;
 
 public interface CustomCommandService {
     CustomCommand createCustomCommand(String name, String content, Member creator);
+    CustomCommand createUserCustomCommand(String name, String content, User user);
     void deleteCustomCommand(String name, Guild guild);
+    void deleteUserCustomCommand(String name, User user);
     List<CustomCommand> getCustomCommands(Guild guild);
+    List<CustomCommand> getUserCustomCommands(User user);
     CustomCommand getCustomCommand(String name, Guild guild);
-    List<CustomCommand> getCustomCommandsStartingWith(String prefix, Guild guild);
+    CustomCommand getUserCustomCommand(String name, User user);
+    List<CustomCommand> getCustomCommandsContaining(String name, Guild guild);
+    List<CustomCommand> getUserCustomCommandsContaining(String name, User user);
 }

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

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

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

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

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

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

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

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

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

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

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

@@ -4,6 +4,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.config.UserCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
@@ -51,6 +52,7 @@ public class Choose extends AbstractConditionableCommand {
         String choice = entertainmentService.takeChoice(choices, commandContext.getAuthor());
         ChooseResponseModel responseModel = ChooseResponseModel
                 .builder()
+                .choices(choices)
                 .chosenValue(choice)
                 .build();
         return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInMessageChannel(CHOOSE_RESPONSE_TEMPLATE_KEY, responseModel, commandContext.getChannel()))
@@ -69,6 +71,7 @@ public class Choose extends AbstractConditionableCommand {
         String choice = entertainmentService.takeChoice(choices, event.getMember());
         ChooseResponseModel responseModel = ChooseResponseModel
                 .builder()
+                .choices(choices)
                 .chosenValue(choice)
                 .build();
         return interactionService.replyEmbed(CHOOSE_RESPONSE_TEMPLATE_KEY, responseModel, event)
@@ -96,6 +99,8 @@ public class Choose extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
                 .commandName(CHOOSE_COMMAND)
                 .build();

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

@@ -4,15 +4,14 @@ 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.UserCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
-import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
@@ -39,28 +38,16 @@ public class EightBall extends AbstractConditionableCommand {
     @Autowired
     private TemplateService templateService;
 
-    @Autowired
-    private ChannelService channelService;
-
     @Autowired
     private SlashCommandParameterService slashCommandParameterService;
 
     @Autowired
     private InteractionService interactionService;
 
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        String text = (String) commandContext.getParameters().getParameters().get(0);
-        MessageToSend messageToSend = getMessageToSend(text, commandContext.getGuild().getIdLong());
-        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
-                .thenApply(unused -> CommandResult.fromIgnored());
-    }
-
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         String text = slashCommandParameterService.getCommandOption(TEXT_PARAMETER, event, String.class);
-        MessageToSend messageToSend = getMessageToSend(text, event.getGuild().getIdLong());
+        MessageToSend messageToSend = getMessageToSend(text, ContextUtils.serverIdOrNull(event));
         return interactionService.replyMessageToSend(messageToSend, event)
                 .thenApply(interactionHook -> CommandResult.fromSuccess());
     }
@@ -69,6 +56,7 @@ public class EightBall extends AbstractConditionableCommand {
         String chosenKey = entertainmentService.getEightBallValue(text);
         EightBallResponseModel responseModel = EightBallResponseModel
                 .builder()
+                .input(text)
                 .chosenKey(chosenKey)
                 .build();
         return templateService.renderEmbedTemplate(EIGHT_BALL_RESPONSE_TEMPLATE_KEY, responseModel, serverId);
@@ -93,6 +81,8 @@ public class EightBall extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
                 .commandName(BALL_COMMAND)
                 .build();
@@ -104,6 +94,7 @@ public class EightBall extends AbstractConditionableCommand {
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
                 .supportsEmbedException(true)
+                .slashCommandOnly(true)
                 .causesReaction(true)
                 .parameters(parameters)
                 .help(helpInfo)

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

@@ -4,6 +4,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.config.UserCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
@@ -13,6 +14,7 @@ import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
@@ -64,7 +66,7 @@ public class LoveCalc extends AbstractConditionableCommand {
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         String firstPart = slashCommandParameterService.getCommandOption(FIRST_SUBJECT_PARAMETER, event, String.class);
         String secondPart = slashCommandParameterService.getCommandOption(SECOND_SUBJECT_PARAMETER, event, String.class);
-        MessageToSend messageToSend = getMessageToSend(event.getGuild().getIdLong(), firstPart, secondPart);
+        MessageToSend messageToSend = getMessageToSend(ContextUtils.serverIdOrNull(event), firstPart, secondPart);
         return interactionService.replyMessageToSend(messageToSend, event.getInteraction())
                 .thenApply(interactionHook -> CommandResult.fromSuccess());
     }
@@ -105,6 +107,8 @@ public class LoveCalc extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
                 .commandName(LOVE_CALC_COMMAND)
                 .build();

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

@@ -1,10 +1,7 @@
 package dev.sheldan.abstracto.entertainment.command;
 
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
-import dev.sheldan.abstracto.core.command.config.CombinedParameterEntry;
-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.*;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.command.handler.parameter.CombinedParameter;
@@ -108,6 +105,8 @@ public class Mock extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(EntertainmentSlashCommandNames.ENTERTAINMENT)
                 .commandName(MOCK_COMMAND)
                 .build();

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

@@ -4,6 +4,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.config.UserCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValidator;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
@@ -125,6 +126,8 @@ public class Roll extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
                 .commandName(ROLL_COMMAND)
                 .build();

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

@@ -4,13 +4,11 @@ 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.UserCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
@@ -29,8 +27,6 @@ public class Roulette extends AbstractConditionableCommand {
 
     public static final String ROULETTE_RESPONSE_TEMPLATE_KEY = "roulette_response";
     public static final String ROULETTE_COMMAND = "roulette";
-    @Autowired
-    private ChannelService channelService;
 
     @Autowired
     private EntertainmentService entertainmentService;
@@ -38,17 +34,6 @@ public class Roulette extends AbstractConditionableCommand {
     @Autowired
     private InteractionService interactionService;
 
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        boolean rouletteResult = entertainmentService.executeRoulette(commandContext.getAuthor());
-        RouletteResponseModel responseModel = RouletteResponseModel
-                .builder()
-                .result(rouletteResult)
-                .build();
-        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInMessageChannel(ROULETTE_RESPONSE_TEMPLATE_KEY, responseModel, commandContext.getChannel()))
-                .thenApply(unused -> CommandResult.fromIgnored());
-    }
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         boolean rouletteResult = entertainmentService.executeRoulette(event.getMember());
@@ -71,6 +56,8 @@ public class Roulette extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
                 .commandName(ROULETTE_COMMAND)
                 .build();
@@ -81,6 +68,7 @@ public class Roulette extends AbstractConditionableCommand {
                 .slashCommandConfig(slashCommandConfig)
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .causesReaction(true)
                 .parameters(parameters)

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

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

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

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

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

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

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

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

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

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

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

@@ -4,18 +4,17 @@ 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.config.UserCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.ServerUser;
-import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.FeatureFlagService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
-import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
@@ -24,7 +23,6 @@ import dev.sheldan.abstracto.entertainment.model.command.games.MineBoard;
 import dev.sheldan.abstracto.entertainment.model.database.EconomyUser;
 import dev.sheldan.abstracto.entertainment.service.GameService;
 import dev.sheldan.abstracto.entertainment.service.management.EconomyUserManagementService;
-import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -63,9 +61,6 @@ public class Mines extends AbstractConditionableCommand {
     @Autowired
     private EconomyUserManagementService economyUserManagementService;
 
-    @Autowired
-    private ChannelService channelService;
-
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         Integer width = 5;
@@ -81,84 +76,43 @@ public class Mines extends AbstractConditionableCommand {
             mines = slashCommandParameterService.getCommandOption(MINES_PARAMETER, event, Integer.class);
         }
         Integer credit = null;
-        long serverId = event.getGuild().getIdLong();
-        boolean economyEnabled = featureFlagService.getFeatureFlagValue(EntertainmentFeatureDefinition.ECONOMY, serverId);
-        if(economyEnabled){
-            credit = 50;
-            if(slashCommandParameterService.hasCommandOption(CREDITS_PARAMETER, event)) {
-                credit = slashCommandParameterService.getCommandOption(CREDITS_PARAMETER, event, Integer.class);
-            }
+        Long serverId;
+        boolean economyEnabled = false;
+        if(ContextUtils.isNotUserCommand(event)) {
+            serverId = event.getGuild().getIdLong();
+            economyEnabled = featureFlagService.getFeatureFlagValue(EntertainmentFeatureDefinition.ECONOMY, serverId);
+            if(economyEnabled){
+                credit = 50;
+                if(slashCommandParameterService.hasCommandOption(CREDITS_PARAMETER, event)) {
+                    credit = slashCommandParameterService.getCommandOption(CREDITS_PARAMETER, event, Integer.class);
+                }
 
-            Optional<EconomyUser> userOptional = economyUserManagementService.getUser(ServerUser.fromMember(event.getMember()));
-            if(!userOptional.isPresent()) {
-                throw new NotEnoughCreditsException();
-            }
-            EconomyUser user = userOptional.get();
-            if(user.getCredits() < credit) {
-                throw new NotEnoughCreditsException();
+                Optional<EconomyUser> userOptional = economyUserManagementService.getUser(ServerUser.fromMember(event.getMember()));
+                if(!userOptional.isPresent()) {
+                    throw new NotEnoughCreditsException();
+                }
+                EconomyUser user = userOptional.get();
+                if(user.getCredits() < credit) {
+                    throw new NotEnoughCreditsException();
+                }
             }
+        } else {
+            serverId = null;
         }
         MineBoard board = gameService.createBoard(width, height, mines, serverId);
         board.setCreditsEnabled(economyEnabled);
-        board.setUserId(event.getMember().getIdLong());
+        board.setUserId(event.getUser().getIdLong());
         board.setServerId(serverId);
         board.setCredits(credit);
         MessageToSend messageToSend = templateService.renderEmbedTemplate(MINE_BOARD_TEMPLATE_KEY, board, serverId);
         return interactionService.replyMessageToSend(messageToSend, event)
                 .thenCompose(interactionHook -> interactionHook.retrieveOriginal().submit())
                 .thenApply(message -> {
-                    gameService.persistMineBoardMessage(board, message);
+                    gameService.persistMineBoardMessage(board, message, serverId);
                     return CommandResult.fromSuccess();
                 });
     }
 
-
-    @Override
-    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        Integer width = 5;
-        List<Object> parameters = commandContext.getParameters().getParameters();
-        if(!parameters.isEmpty()) {
-            width = (Integer) parameters.get(0);
-        }
-        Integer height = 5;
-        if(parameters.size() >= 2) {
-            height = (Integer) parameters.get(1);
-        }
-        Integer mines = 5;
-        if(parameters.size() >= 3) {
-            mines = (Integer) parameters.get(2);
-        }
-        Integer credit = null;
-        long serverId = commandContext.getGuild().getIdLong();
-        boolean economyEnabled = featureFlagService.getFeatureFlagValue(EntertainmentFeatureDefinition.ECONOMY, serverId);
-        if(economyEnabled){
-            credit = 50;
-            if(parameters.size() == 4) {
-                credit = (Integer) parameters.get(3);
-            }
-
-            Optional<EconomyUser> userOptional = economyUserManagementService.getUser(ServerUser.fromMember(commandContext.getAuthor()));
-            if(!userOptional.isPresent()) {
-                throw new NotEnoughCreditsException();
-            }
-            EconomyUser user = userOptional.get();
-            if(user.getCredits() < credit) {
-                throw new NotEnoughCreditsException();
-            }
-        }
-        MineBoard board = gameService.createBoard(width, height, mines, serverId);
-        board.setCreditsEnabled(economyEnabled);
-        board.setUserId(commandContext.getAuthor().getIdLong());
-        board.setServerId(serverId);
-        board.setCredits(credit);
-        MessageToSend messageToSend = templateService.renderEmbedTemplate(MINE_BOARD_TEMPLATE_KEY, board, serverId);
-        List<CompletableFuture<Message>> futures = channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
-        return FutureUtils.toSingleFutureGeneric(futures)
-                .thenAccept(unused ->  gameService.persistMineBoardMessage(board, futures.get(0).join()))
-                .thenApply(unused -> CommandResult.fromSuccess());
-
-    }
-
     @Override
     public CommandConfiguration getConfiguration() {
         List<Parameter> parameters = new ArrayList<>();
@@ -207,6 +161,8 @@ public class Mines extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(EntertainmentSlashCommandNames.GAME)
                 .commandName(MINES_COMMAND_NAME)
                 .build();
@@ -217,6 +173,7 @@ public class Mines extends AbstractConditionableCommand {
                 .async(true)
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
+                .slashCommandOnly(true)
                 .supportsEmbedException(true)
                 .parameters(parameters)
                 .help(helpInfo)

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/listener/interaction/MinesButtonClickedListener.java

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListe
 import dev.sheldan.abstracto.core.service.FeatureFlagService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.entertainment.command.games.Mines;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.model.command.games.MineBoard;
@@ -49,13 +50,15 @@ public class MinesButtonClickedListener implements ButtonClickedListener {
         GameService.MineResult mineResult = gameService.uncoverField(mineBoard, payload.getX(), payload.getY());
         mineBoard.setState(mineResult);
         if(mineBoard.getState() != GameService.MineResult.CONTINUE) {
-            if(featureFlagService.getFeatureFlagValue(EntertainmentFeatureDefinition.ECONOMY, model.getServerId())){
-                gameService.evaluateCreditChanges(mineBoard);
+            if(ContextUtils.isNotUserCommand(model.getEvent())) {
+                if(featureFlagService.getFeatureFlagValue(EntertainmentFeatureDefinition.ECONOMY, model.getServerId())){
+                    gameService.evaluateCreditChanges(mineBoard);
+                }
             }
             gameService.uncoverBoard(mineBoard);
         }
         MessageToSend messageToSend = templateService.renderEmbedTemplate(Mines.MINE_BOARD_TEMPLATE_KEY, mineBoard, model.getServerId());
-        interactionService.editOriginal(messageToSend, model.getEvent().getHook()).thenAccept(message -> {
+        interactionService.replaceOriginal(messageToSend, model.getEvent().getHook()).thenAccept(message -> {
             gameService.updateMineBoard(mineBoard);
             log.info("Updated original mineboard for board {}.", mineBoard.getBoardId());
         });

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/service/GameServiceBean.java

@@ -70,10 +70,16 @@ public class GameServiceBean implements GameService {
 
     @Override
     @Transactional
-    public void persistMineBoardMessage(MineBoard mineBoard, Message message) {
+    public void persistMineBoardMessage(MineBoard mineBoard, Message message, Long serverId) {
         mineBoard.setMessageId(message.getIdLong());
         mineBoard.setChannelId(message.getChannel().getIdLong());
-        AServer server = serverManagementService.loadServer(message.getGuild());
+
+        AServer server;
+        if(serverId != null) {
+            server = serverManagementService.loadServer(serverId);
+        } else {
+            server = null;
+        }
         mineBoard.getFields().forEach(mineBoardField -> {
             MineBoardPayload payload = MineBoardPayload
                     .builder()

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

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

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

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

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

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

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/service/GameService.java

@@ -5,7 +5,7 @@ import net.dv8tion.jda.api.entities.Message;
 
 public interface GameService {
     MineBoard createBoard(Integer width, Integer height, Integer mines, Long serverId);
-    void persistMineBoardMessage(MineBoard mineBoard, Message message);
+    void persistMineBoardMessage(MineBoard mineBoard, Message message, Long serverId);
     void updateMineBoard(MineBoard mineBoard);
     void uncoverBoard(MineBoard mineBoard);
     void evaluateCreditChanges(MineBoard mineBoard);

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

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

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

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

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

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.config.FeatureMode;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AServer;
@@ -168,6 +169,7 @@ public class AddLevelAction extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .groupName("levelAction")
                 .commandName("add")
                 .build();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.config.FeatureMode;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AServer;
@@ -142,6 +143,7 @@ public class RemoveLevelAction extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .groupName("levelAction")
                 .commandName("remove")
                 .build();

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

@@ -8,6 +8,7 @@ import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.config.FeatureMode;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
 import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
 import dev.sheldan.abstracto.experience.config.ExperienceFeatureMode;
 import dev.sheldan.abstracto.experience.config.ExperienceSlashCommandNames;
@@ -51,6 +52,7 @@ public class ShowLevelActions extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .groupName("levelAction")
                 .commandName("show")
                 .build();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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