[AB-xxx] adding default permissions for commands

adding owner limitation for certain internal commands

.env

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

.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

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

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

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

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

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>abstracto-modules</artifactId>
-        <version>1.5.55</version>
+        <version>1.6.3-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.55</version>
+        <version>1.6.3-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,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;
@@ -42,8 +45,11 @@ public class DeleteCustomCommand extends AbstractConditionableCommand {
     @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());
     }
@@ -66,6 +72,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.getCustomCommandsStartingWith(input, event.getGuild())
+                        .stream()
+                        .map(CustomCommand::getName)
+                        .toList();
+            } else {
+                return customCommandService.getUserCustomCommandsStartingWith(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,12 @@ 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);
 }

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,21 +61,48 @@ 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())
                 .orElseThrow(CustomCommandNotFoundException::new);
     }
 
+    @Override
+    public CustomCommand getUserCustomCommand(String name, User user) {
+        return customCommandManagementService.getUserCustomCommandByName(name, user.getIdLong())
+                .orElseThrow(CustomCommandNotFoundException::new);
+    }
+
     @Override
     public List<CustomCommand> getCustomCommandsStartingWith(String prefix, Guild guild) {
         AServer server = serverManagementService.loadServer(guild);
         return customCommandManagementService.getCustomCommandsStartingWith(prefix, server);
     }
+
+    @Override
+    public List<CustomCommand> getUserCustomCommandsStartingWith(String prefix, User user) {
+        AUser aUser = userManagementService.loadOrCreateUser(user.getIdLong());
+        return customCommandManagementService.getUserCustomCommandsStartingWith(prefix, 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> getUserCustomCommands(AUser aUser) {
+        return repository.findByCreatorUserAndUserSpecific(aUser, true);
+    }
+
     @Override
     public List<CustomCommand> getCustomCommandsStartingWith(String prefix, AServer server) {
         return repository.findByNameStartsWithIgnoreCaseAndServer(prefix, server);
     }
 
+    @Override
+    public List<CustomCommand> getUserCustomCommandsStartingWith(String prefix, AUser aUser) {
+        return repository.findByNameStartsWithIgnoreCaseAndCreatorUserAndUserSpecific(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.55</version>
+        <version>1.6.3-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> getUserCustomCommands(AUser aUser);
     List<CustomCommand> getCustomCommandsStartingWith(String prefix, AServer server);
+    List<CustomCommand> getUserCustomCommandsStartingWith(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);
+    CustomCommand getUserCustomCommand(String name, User user);
     List<CustomCommand> getCustomCommandsStartingWith(String prefix, Guild guild);
+    List<CustomCommand> getUserCustomCommandsStartingWith(String prefix, 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.55</version>
+        <version>1.6.3-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.55</version>
+        <version>1.6.3-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.55</version>
+        <version>1.6.3-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.55</version>
+        <version>1.6.3-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.55</version>
+        <version>1.6.3-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;
@@ -96,6 +97,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,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;
@@ -12,6 +13,7 @@ import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
@@ -60,7 +62,7 @@ public class EightBall extends AbstractConditionableCommand {
     @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());
     }
@@ -93,6 +95,8 @@ public class EightBall extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
                 .commandName(BALL_COMMAND)
                 .build();

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,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;
@@ -71,6 +72,8 @@ public class Roulette extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
                 .commandName(ROULETTE_COMMAND)
                 .build();

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/games/Mines.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.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
@@ -15,6 +16,7 @@ import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.FeatureFlagService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
@@ -81,33 +83,39 @@ 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();
                 });
     }
@@ -129,7 +137,7 @@ public class Mines extends AbstractConditionableCommand {
             mines = (Integer) parameters.get(2);
         }
         Integer credit = null;
-        long serverId = commandContext.getGuild().getIdLong();
+        Long serverId = commandContext.getGuild().getIdLong();
         boolean economyEnabled = featureFlagService.getFeatureFlagValue(EntertainmentFeatureDefinition.ECONOMY, serverId);
         if(economyEnabled){
             credit = 50;
@@ -154,7 +162,7 @@ public class Mines extends AbstractConditionableCommand {
         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()))
+                .thenAccept(unused ->  gameService.persistMineBoardMessage(board, futures.get(0).join(), serverId))
                 .thenApply(unused -> CommandResult.fromSuccess());
 
     }
@@ -207,6 +215,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();

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

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.55</version>
+        <version>1.6.3-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.55</version>
+        <version>1.6.3-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

@@ -7,6 +7,7 @@ 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;
@@ -97,6 +98,7 @@ public class DisableExpForRole extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(DISABLE_EXP_FOR_ROLE_COMMAND)
                 .build();
 

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

@@ -7,6 +7,7 @@ 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;
@@ -87,6 +88,7 @@ public class DisableExpGain extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(DISABLE_EXP_GAIN_COMMAND)
                 .build();
 

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

@@ -8,6 +8,7 @@ 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;
@@ -100,6 +101,7 @@ public class EnableExpForRole extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(ENABLE_EXP_FOR_ROLE_COMMAND)
                 .build();
 

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

@@ -7,6 +7,7 @@ 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;
@@ -88,6 +89,7 @@ public class EnableExpGain extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(ENABLE_EXP_GAIN_COMMAND)
                 .build();
 

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

@@ -7,6 +7,7 @@ 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;
@@ -80,6 +81,7 @@ public class ExpScale extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(EXP_SCALE_COMMAND)
                 .build();
 

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

@@ -9,6 +9,7 @@ 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;
@@ -112,6 +113,7 @@ public class ListDisabledExperienceRoles extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE_CONFIG)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName(LIST_DISABLED_EXPERIENCE_ROLES_COMMAND)
                 .build();
 

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.55</version>
+        <version>1.6.3-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.55</version>
+        <version>1.6.3-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.55</version>
+        <version>1.6.3-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;
@@ -106,6 +107,7 @@ public class AddGiveawayKey extends AbstractConditionableCommand {
         .builder()
         .enabled(true)
         .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+        .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
         .groupName("keys")
         .commandName("add")
         .build();

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();

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;
@@ -101,6 +102,7 @@ public class GreateGiveaway extends AbstractConditionableCommand {
                 .duration(duration)
                 .targetChannel(target)
                 .winnerCount(winners)
+                .serverId(creator.getGuild().getIdLong())
                 .title(title)
                 .build();
 
@@ -168,6 +170,7 @@ public class GreateGiveaway extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .groupName("management")
                 .commandName("create")
                 .build();

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();

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

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

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

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

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

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

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

@@ -58,7 +58,9 @@ public class GiveawayKeyManagementServiceBean implements GiveawayKeyManagementSe
   @Override
   public void deleteById(Long id, Long serverId) {
     GiveawayKey key = giveawayKeyRepository.findById(new GiveawayKeyId(id, serverId)).orElseThrow(GiveawayKeyNotFoundException::new);
-    key.getGiveaway().setGiveawayKey(null);
+    if(key.getGiveaway() != null) {
+      key.getGiveaway().setGiveawayKey(null);
+    }
     giveawayKeyRepository.delete(key);
   }
 

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

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

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

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

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

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

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

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.config.UserCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
@@ -109,6 +110,8 @@ public class AmongusText extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(ImageGenerationSlashCommandNames.IMAGE_GENERATION)
                 .groupName("memes")
                 .commandName("amongustext")

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

@@ -2,10 +2,7 @@ package dev.sheldan.abstracto.imagegeneration.command;
 
 import dev.sheldan.abstracto.core.command.UtilityModuleDefinition;
 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;
@@ -24,6 +21,7 @@ import dev.sheldan.abstracto.imagegeneration.config.ImageGenerationSlashCommandN
 import dev.sheldan.abstracto.imagegeneration.service.ImageGenerationService;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
@@ -92,13 +90,25 @@ public class Bonk extends AbstractConditionableCommand {
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         event.deferReply().queue();
+        String avatarUrl;
         Member targetMember;
         if(slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER_KEY, event)) {
             targetMember = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER_KEY, event, Member.class);
         } else {
             targetMember = event.getMember();
         }
-        File bonkGifFile = imageGenerationService.getBonkGif(targetMember.getEffectiveAvatar().getUrl(imageSize));
+        if(targetMember == null) {
+            User targetUser;
+            if(slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER_KEY, event)) {
+                targetUser = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER_KEY, event, User.class);
+            } else {
+                targetUser = event.getUser();
+            }
+            avatarUrl = targetUser.getEffectiveAvatar().getUrl(imageSize);
+        } else {
+            avatarUrl = targetMember.getEffectiveAvatar().getUrl(imageSize);
+        }
+        File bonkGifFile = imageGenerationService.getBonkGif(avatarUrl);
         MessageToSend messageToSend = templateService.renderEmbedTemplate(BONK_EMBED_TEMPLATE_KEY, new Object(), event.getGuild().getIdLong());
         // template support does not support binary files
         AttachedFile file = AttachedFile
@@ -116,13 +126,18 @@ public class Bonk extends AbstractConditionableCommand {
     public CommandConfiguration getConfiguration() {
         List<Parameter> parameters = new ArrayList<>();
         Map<String, Object> parameterAlternatives = new HashMap<>();
-        parameterAlternatives.put(ADDITIONAL_TYPES_KEY, Arrays.asList(CombinedParameterEntry.messageParameter(Message.class), CombinedParameterEntry.parameter(Member.class)));
+        parameterAlternatives.put(ADDITIONAL_TYPES_KEY, List.of(
+                CombinedParameterEntry.messageParameter(Message.class),
+                CombinedParameterEntry.parameter(Member.class),
+                CombinedParameterEntry.parameter(User.class)
+        ));
         Parameter memberParameter = Parameter
                 .builder()
                 .name(MEMBER_PARAMETER_KEY)
                 .type(CombinedParameter.class)
                 .additionalInfo(parameterAlternatives)
                 .templated(true)
+                .useStrictParameters(true)
                 .optional(true)
                 .build();
         parameters.add(memberParameter);
@@ -134,6 +149,8 @@ public class Bonk extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(ImageGenerationSlashCommandNames.IMAGE_GENERATION)
                 .groupName("memes")
                 .commandName("bonk")

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

@@ -2,10 +2,7 @@ package dev.sheldan.abstracto.imagegeneration.command;
 
 import dev.sheldan.abstracto.core.command.UtilityModuleDefinition;
 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;
@@ -24,6 +21,7 @@ import dev.sheldan.abstracto.imagegeneration.config.ImageGenerationSlashCommandN
 import dev.sheldan.abstracto.imagegeneration.service.ImageGenerationService;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
@@ -92,13 +90,25 @@ public class Pat extends AbstractConditionableCommand {
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         event.deferReply().queue();
+        String avatarUrl;
         Member targetMember;
         if(slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER_KEY, event)) {
             targetMember = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER_KEY, event, Member.class);
         } else {
             targetMember = event.getMember();
         }
-        File patGifFile = imageGenerationService.getPatGif(targetMember.getEffectiveAvatar().getUrl(imageSize));
+        if(targetMember == null) {
+            User targetUser;
+            if(slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER_KEY, event)) {
+                targetUser = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER_KEY, event, User.class);
+            } else {
+                targetUser = event.getUser();
+            }
+            avatarUrl = targetUser.getEffectiveAvatar().getUrl(imageSize);
+        } else {
+            avatarUrl = targetMember.getEffectiveAvatar().getUrl(imageSize);
+        }
+        File patGifFile = imageGenerationService.getPatGif(avatarUrl);
         MessageToSend messageToSend = templateService.renderEmbedTemplate(PAT_EMBED_TEMPLATE_KEY, new Object(), event.getGuild().getIdLong());
         // template support does not support binary files
         AttachedFile file = AttachedFile
@@ -116,13 +126,17 @@ public class Pat extends AbstractConditionableCommand {
     public CommandConfiguration getConfiguration() {
         List<Parameter> parameters = new ArrayList<>();
         Map<String, Object> parameterAlternatives = new HashMap<>();
-        parameterAlternatives.put(ADDITIONAL_TYPES_KEY, Arrays.asList(CombinedParameterEntry.messageParameter(Message.class), CombinedParameterEntry.parameter(Member.class)));
+        parameterAlternatives.put(ADDITIONAL_TYPES_KEY, List.of(
+                CombinedParameterEntry.messageParameter(Message.class),
+                CombinedParameterEntry.parameter(Member.class),
+                CombinedParameterEntry.parameter(User.class)));
         Parameter memberParameter = Parameter
                 .builder()
                 .name(MEMBER_PARAMETER_KEY)
                 .type(CombinedParameter.class)
                 .additionalInfo(parameterAlternatives)
                 .templated(true)
+                .useStrictParameters(true)
                 .optional(true)
                 .build();
         parameters.add(memberParameter);
@@ -134,6 +148,8 @@ public class Pat extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(ImageGenerationSlashCommandNames.IMAGE_GENERATION)
                 .groupName("memes")
                 .commandName("pat")

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

@@ -2,11 +2,10 @@ package dev.sheldan.abstracto.imagegeneration.command;
 
 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.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;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
@@ -21,6 +20,8 @@ import dev.sheldan.abstracto.imagegeneration.config.ImageGenerationFeatureDefini
 import dev.sheldan.abstracto.imagegeneration.config.ImageGenerationSlashCommandNames;
 import dev.sheldan.abstracto.imagegeneration.service.ImageGenerationService;
 import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
@@ -28,9 +29,13 @@ import org.springframework.stereotype.Component;
 
 import java.io.File;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 
+import static dev.sheldan.abstracto.core.command.config.Parameter.ADDITIONAL_TYPES_KEY;
+
 @Component
 public class Triggered extends AbstractConditionableCommand {
 
@@ -84,13 +89,25 @@ public class Triggered extends AbstractConditionableCommand {
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         event.deferReply().queue();
+        String avatarUrl;
         Member targetMember;
         if(slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER_KEY, event)) {
             targetMember = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER_KEY, event, Member.class);
         } else {
             targetMember = event.getMember();
         }
-        File triggeredGifFile = imageGenerationService.getTriggeredGif(targetMember.getEffectiveAvatar().getUrl(imageSize));
+        if(targetMember == null) {
+            User targetUser;
+            if(slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER_KEY, event)) {
+                targetUser = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER_KEY, event, User.class);
+            } else {
+                targetUser = event.getUser();
+            }
+            avatarUrl = targetUser.getEffectiveAvatar().getUrl(imageSize);
+        } else {
+            avatarUrl = targetMember.getEffectiveAvatar().getUrl(imageSize);
+        }
+        File triggeredGifFile = imageGenerationService.getTriggeredGif(avatarUrl);
         MessageToSend messageToSend = templateService.renderEmbedTemplate(TRIGGERED_EMBED_TEMPLATE_KEY, new Object(), event.getGuild().getIdLong());
         // template support does not support binary files
         AttachedFile file = AttachedFile
@@ -107,11 +124,19 @@ public class Triggered extends AbstractConditionableCommand {
     @Override
     public CommandConfiguration getConfiguration() {
         List<Parameter> parameters = new ArrayList<>();
+        Map<String, Object> parameterAlternatives = new HashMap<>();
+        parameterAlternatives.put(ADDITIONAL_TYPES_KEY, List.of(
+                CombinedParameterEntry.messageParameter(Message.class),
+                CombinedParameterEntry.parameter(Member.class),
+                CombinedParameterEntry.parameter(User.class)
+        ));
         Parameter memberParameter = Parameter
                 .builder()
                 .name(MEMBER_PARAMETER_KEY)
-                .type(Member.class)
+                .type(CombinedParameter.class)
+                .additionalInfo(parameterAlternatives)
                 .templated(true)
+                .useStrictParameters(true)
                 .optional(true)
                 .build();
         parameters.add(memberParameter);
@@ -123,6 +148,8 @@ public class Triggered extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .rootCommandName(ImageGenerationSlashCommandNames.IMAGE_GENERATION)
                 .groupName("memes")
                 .commandName("triggered")

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

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

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

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

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

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

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

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>invite-filter</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.5.55</version>
+        <version>1.6.3-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -18,7 +18,7 @@
         <dependency>
             <groupId>dev.sheldan.abstracto.modules</groupId>
             <artifactId>moderation-int</artifactId>
-            <version>1.5.55</version>
+            <version>1.6.3-SNAPSHOT</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.command.condition.CommandCondition;
 import dev.sheldan.abstracto.core.command.config.*;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 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.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
@@ -138,6 +139,7 @@ public class Ban extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.MODERATION)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName(BAN_COMMAND)
                 .build();
 

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/DecayAllWarnings.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.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;
@@ -12,10 +11,8 @@ import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
-import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
 import dev.sheldan.abstracto.moderation.service.WarnService;
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -45,14 +42,6 @@ public class DecayAllWarnings extends AbstractConditionableCommand {
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 
-    @Override
-    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        AServer server = serverManagementService.loadServer(event.getGuild());
-        return warnService.decayAllWarningsForServer(server)
-                .thenCompose(unused -> interactionService.replyEmbed(DECAY_ALL_WARNINGS_RESPONSE, event))
-                .thenApply(aVoid -> CommandResult.fromSuccess());
-    }
-
     @Override
     public CommandConfiguration getConfiguration() {
         List<Parameter> parameters = new ArrayList<>();
@@ -61,19 +50,11 @@ public class DecayAllWarnings extends AbstractConditionableCommand {
                 .templated(true)
                 .build();
 
-        SlashCommandConfig slashCommandConfig = SlashCommandConfig
-                .builder()
-                .enabled(true)
-                .rootCommandName(ModerationSlashCommandNames.WARN_DECAY)
-                .commandName(DECAY_ALL_WARNINGS_COMMAND)
-                .build();
-
         return CommandConfiguration.builder()
                 .name(DECAY_ALL_WARNINGS_COMMAND)
                 .module(ModerationModuleDefinition.MODERATION)
                 .templated(true)
                 .async(true)
-                .slashCommandConfig(slashCommandConfig)
                 .requiresConfirmation(true)
                 .supportsEmbedException(true)
                 .causesReaction(true)

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

@@ -4,18 +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.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.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
-import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
 import dev.sheldan.abstracto.moderation.service.WarnService;
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -27,7 +23,6 @@ import java.util.concurrent.CompletableFuture;
 public class DecayWarnings extends AbstractConditionableCommand {
 
     private static final String DECAY_WARNINGS_COMMAND = "decayWarnings";
-    private static final String DECAY_WARNINGS_RESPONSE = "decayWarnings_response";
 
     @Autowired
     private WarnService warnService;
@@ -35,9 +30,6 @@ public class DecayWarnings extends AbstractConditionableCommand {
     @Autowired
     private ServerManagementService serverManagementService;
 
-    @Autowired
-    private InteractionService interactionService;
-
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         AServer server = serverManagementService.loadServer(commandContext.getGuild());
@@ -45,14 +37,6 @@ public class DecayWarnings extends AbstractConditionableCommand {
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 
-    @Override
-    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        AServer server = serverManagementService.loadServer(event.getGuild());
-        return warnService.decayWarningsForServer(server)
-                .thenCompose(unused -> interactionService.replyEmbed(DECAY_WARNINGS_RESPONSE, event))
-                .thenApply(aVoid -> CommandResult.fromSuccess());
-    }
-
     @Override
     public CommandConfiguration getConfiguration() {
         List<Parameter> parameters = new ArrayList<>();
@@ -61,18 +45,10 @@ public class DecayWarnings extends AbstractConditionableCommand {
                 .templated(true)
                 .build();
 
-        SlashCommandConfig slashCommandConfig = SlashCommandConfig
-                .builder()
-                .enabled(true)
-                .rootCommandName(ModerationSlashCommandNames.WARN_DECAY)
-                .commandName(DECAY_WARNINGS_COMMAND)
-                .build();
-
         return CommandConfiguration.builder()
                 .name(DECAY_WARNINGS_COMMAND)
                 .module(ModerationModuleDefinition.MODERATION)
                 .templated(true)
-                .slashCommandConfig(slashCommandConfig)
                 .requiresConfirmation(true)
                 .async(true)
                 .supportsEmbedException(true)

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

@@ -6,6 +6,7 @@ import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValida
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 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.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
@@ -77,6 +78,7 @@ public class DeleteNote extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.USER_NOTES)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName("delete")
                 .build();
 

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

@@ -6,6 +6,7 @@ import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValida
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 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.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.interaction.InteractionService;
@@ -76,6 +77,7 @@ public class DeleteWarning extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.WARNINGS)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName("delete")
                 .build();
 

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

@@ -8,6 +8,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.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationSlashCommandNames;
@@ -71,6 +72,7 @@ public class EditInfraction extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.INFRACTIONS)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName("edit")
                 .build();
 

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

@@ -10,6 +10,7 @@ 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.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
@@ -182,6 +183,7 @@ public class Infractions extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.INFRACTIONS)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName("list")
                 .build();
 

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

@@ -11,6 +11,7 @@ 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.templating.service.TemplateService;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
@@ -100,6 +101,7 @@ public class Kick extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.MODERATION)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName(KICK_COMMAND)
                 .build();
 

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

@@ -6,6 +6,7 @@ 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.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.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.exception.EntityGuildMismatchException;
@@ -168,6 +169,7 @@ public class Mute extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.MUTE)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName("create")
                 .build();
 

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

@@ -7,6 +7,7 @@ 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;
@@ -155,6 +156,7 @@ public class Mutes extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.MUTE)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName("list")
                 .build();
 

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

@@ -6,6 +6,7 @@ import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValida
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 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.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.exception.EntityGuildMismatchException;
@@ -104,6 +105,7 @@ public class Purge extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.MODERATION)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName(PURGE_COMMAND)
                 .build();
 

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

@@ -7,6 +7,7 @@ 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;
@@ -123,6 +124,7 @@ public class SlowMode extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.MODERATION)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName(SLOWMODE_COMMAND)
                 .build();
 

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

@@ -8,6 +8,7 @@ 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;
@@ -83,6 +84,7 @@ public class UnBan extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.MODERATION)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName(UN_BAN_COMMAND)
                 .build();
 

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

@@ -7,6 +7,7 @@ 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;
@@ -86,6 +87,7 @@ public class UnMute extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.MUTE)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.INVITER)
                 .commandName("remove")
                 .build();
 

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

@@ -7,6 +7,7 @@ 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;
@@ -97,6 +98,7 @@ public class UserNoteCommand extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.USER_NOTES)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName("create")
                 .build();
 

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

@@ -7,6 +7,7 @@ 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;
@@ -148,6 +149,7 @@ public class UserNotes extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.USER_NOTES)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName("list")
                 .build();
 

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

@@ -6,6 +6,7 @@ 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.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.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.exception.EntityGuildMismatchException;
@@ -123,6 +124,7 @@ public class Warn extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(ModerationSlashCommandNames.WARNINGS)
+                .defaultPrivilege(SlashCommandPrivilegeLevels.ADMIN)
                 .commandName("create")
                 .build();