[AB-xxx] preparing for minor release

adding handling for emotes which are only provided as ID to command inputs
removing message commands from emote statistic related commands

.env

@@ -1,2 +1,2 @@
 REGISTRY_PREFIX=harbor.sheldan.dev/abstracto/
-VERSION=1.5.53
+VERSION=1.6.0

.github/workflows/release_manual.yml

@@ -39,6 +39,7 @@ jobs:
           git-release-bot-name: "release-bot"
           git-release-bot-email: "release-bot@sheldan.dev"
           release-branch-name: master
+          version-minor: true
           maven-args: "-Dmaven.javadoc.skip=true -s settings.xml -DskipTests"
           access-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Install node dependencies and build

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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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,13 @@ 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.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 +46,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 +85,8 @@ public class CreateCustomCommand extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .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,13 @@ 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.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 +44,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 +71,8 @@ public class DeleteCustomCommand extends AbstractConditionableCommand {
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()
                 .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                 .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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-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.54-SNAPSHOT</version>
+        <version>1.5.61-SNAPSHOT</version>
     </parent>
 
     <artifactId>giveaway-impl</artifactId>
@@ -38,6 +38,12 @@
             <version>${project.version}</version>
         </dependency>
 
+        <dependency>
+            <groupId>dev.sheldan.abstracto.modules</groupId>
+            <artifactId>modmail-int</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
         <dependency>
             <groupId>dev.sheldan.abstracto.core</groupId>
             <artifactId>metrics-int</artifactId>

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

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

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

@@ -80,6 +80,7 @@ public class CancelGiveaway extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+                .groupName("management")
                 .commandName("cancel")
                 .build();
 

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

@@ -18,6 +18,7 @@ import dev.sheldan.abstracto.giveaway.service.GiveawayService;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.InteractionHook;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -25,6 +26,7 @@ import java.time.Duration;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import org.springframework.transaction.annotation.Transactional;
 
 @Component
 public class GreateGiveaway extends AbstractConditionableCommand {
@@ -48,55 +50,63 @@ public class GreateGiveaway extends AbstractConditionableCommand {
     @Autowired
     private GiveawayService giveawayService;
 
+    @Autowired
+    private GreateGiveaway self;
+
     @Override
     public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
         return event.deferReply()
                 .submit()
-                .thenCompose(interactionHook -> {
-                    String title = slashCommandParameterService.getCommandOption(TITLE_PARAMETER, event, String.class);
-                    String description;
-                    if(slashCommandParameterService.hasCommandOption(DESCRIPTION_PARAMETER, event)) {
-                        description = slashCommandParameterService.getCommandOption(DESCRIPTION_PARAMETER, event, String.class);
-                    } else {
-                        description = null;
-                    }
+                .thenCompose(interactionHook -> self.createGiveaway(event, interactionHook))
+                .thenApply(unused -> CommandResult.fromSuccess());
 
-                    String durationString = slashCommandParameterService.getCommandOption(DURATION_PARAMETER, event, Duration.class, String.class);
-                    Duration duration = ParseUtils.parseDuration(durationString);
+    }
 
-                    GuildMessageChannel target = null;
-                    if(slashCommandParameterService.hasCommandOption(CHANNEL_PARAMETER, event)) {
-                        target = slashCommandParameterService.getCommandOption(CHANNEL_PARAMETER, event, GuildMessageChannel.class);
-                    }
+    @Transactional
+    public CompletableFuture<Void> createGiveaway(SlashCommandInteractionEvent event, InteractionHook interactionHook) {
+        String title = slashCommandParameterService.getCommandOption(TITLE_PARAMETER, event, String.class);
+        String description;
+        if(slashCommandParameterService.hasCommandOption(DESCRIPTION_PARAMETER, event)) {
+            description = slashCommandParameterService.getCommandOption(DESCRIPTION_PARAMETER, event, String.class);
+        } else {
+            description = null;
+        }
 
-                    Integer winners = 1;
-                    if(slashCommandParameterService.hasCommandOption(WINNERS_PARAMETER, event)) {
-                        winners = slashCommandParameterService.getCommandOption(WINNERS_PARAMETER, event, Integer.class);
-                    }
+        String durationString = slashCommandParameterService.getCommandOption(DURATION_PARAMETER, event, Duration.class, String.class);
+        Duration duration = ParseUtils.parseDuration(durationString);
 
-                    Member benefactor;
-                    if(slashCommandParameterService.hasCommandOption(BENEFACTOR_PARAMETER, event)) {
-                        benefactor = slashCommandParameterService.getCommandOption(BENEFACTOR_PARAMETER, event, Member.class);
-                    } else {
-                        benefactor = null;
-                    }
+        GuildMessageChannel target = null;
+        if(slashCommandParameterService.hasCommandOption(CHANNEL_PARAMETER, event)) {
+            target = slashCommandParameterService.getCommandOption(CHANNEL_PARAMETER, event, GuildMessageChannel.class);
+        }
 
-                    Member creator = event.getMember();
-                    GiveawayCreationRequest request = GiveawayCreationRequest
-                            .builder()
-                            .benefactor(benefactor)
-                            .creator(creator)
-                            .description(description)
-                            .duration(duration)
-                            .targetChannel(target)
-                            .winnerCount(winners)
-                            .title(title)
-                            .build();
+        Integer winners = 1;
+        if(slashCommandParameterService.hasCommandOption(WINNERS_PARAMETER, event)) {
+            winners = slashCommandParameterService.getCommandOption(WINNERS_PARAMETER, event, Integer.class);
+        }
 
-                    return giveawayService.createGiveaway(request)
-                            .thenAccept(unused -> interactionService.sendEmbed(CREATE_GIVEAWAY_RESPONSE_TEMPLATE_KEY, interactionHook));
-        }).thenApply(unused -> CommandResult.fromSuccess());
+        Member benefactor;
+        if(slashCommandParameterService.hasCommandOption(BENEFACTOR_PARAMETER, event)) {
+            benefactor = slashCommandParameterService.getCommandOption(BENEFACTOR_PARAMETER, event, Member.class);
+        } else {
+            benefactor = null;
+        }
 
+        Member creator = event.getMember();
+        GiveawayCreationRequest request = GiveawayCreationRequest
+                .builder()
+                .benefactorId(benefactor != null ? benefactor.getIdLong() : null)
+                .creatorId(creator.getIdLong())
+                .description(description)
+                .duration(duration)
+                .targetChannel(target)
+                .winnerCount(winners)
+                .serverId(creator.getGuild().getIdLong())
+                .title(title)
+                .build();
+
+        return giveawayService.createGiveaway(request)
+            .thenAccept(unused -> interactionService.sendEmbed(CREATE_GIVEAWAY_RESPONSE_TEMPLATE_KEY, interactionHook));
     }
 
     @Override
@@ -159,6 +169,7 @@ public class GreateGiveaway extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+                .groupName("management")
                 .commandName("create")
                 .build();
 

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

@@ -0,0 +1,160 @@
+package dev.sheldan.abstracto.giveaway.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.execution.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.service.ConfigService;
+import dev.sheldan.abstracto.core.utils.ParseUtils;
+import dev.sheldan.abstracto.giveaway.config.GiveawayFeatureConfig;
+import dev.sheldan.abstracto.giveaway.config.GiveawayFeatureDefinition;
+import dev.sheldan.abstracto.giveaway.config.GiveawayMode;
+import dev.sheldan.abstracto.giveaway.config.GiveawaySlashCommandNames;
+import dev.sheldan.abstracto.giveaway.exception.GiveawayNotPossibleException;
+import dev.sheldan.abstracto.giveaway.exception.GiveawayKeyNotFoundException;
+import dev.sheldan.abstracto.giveaway.model.GiveawayCreationRequest;
+import dev.sheldan.abstracto.giveaway.model.database.GiveawayKey;
+import dev.sheldan.abstracto.giveaway.service.GiveawayService;
+import dev.sheldan.abstracto.giveaway.service.management.GiveawayKeyManagementService;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.InteractionHook;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+public class GreateKeyGiveaway extends AbstractConditionableCommand {
+
+    private static final String COMMAND_NAME = "createKeyGiveaway";
+    private static final String KEY_ID_PARAMETER = "keyId";
+    private static final String DURATION_PARAMETER = "duration";
+
+    private static final String CREATE_KEY_GIVEAWAY_RESPONSE_TEMPLATE_KEY = "createKeyGiveaway_response";
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private GiveawayService giveawayService;
+
+    @Autowired
+    private GiveawayKeyManagementService giveawayKeyManagementService;
+
+    @Autowired
+    private ConfigService configService;
+
+    @Autowired
+    private GreateKeyGiveaway self;
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        Long id = slashCommandParameterService.getCommandOption(KEY_ID_PARAMETER, event, Integer.class).longValue();
+        String durationString;
+        if(slashCommandParameterService.hasCommandOption(DURATION_PARAMETER, event)) {
+            durationString = slashCommandParameterService.getCommandOption(DURATION_PARAMETER, event, Duration.class, String.class);
+        } else {
+            durationString = configService.getStringValueOrConfigDefault(GiveawayFeatureConfig.KEY_GIVEAWAYS_DURATION, event.getGuild().getIdLong()).trim();
+        }
+        Duration duration = ParseUtils.parseDuration(durationString);
+        return event.deferReply()
+          .submit()
+          .thenCompose(interactionHook -> self.createKeyGiveaway(id, interactionHook, duration))
+          .thenApply(unused -> CommandResult.fromSuccess());
+
+    }
+
+    @Transactional
+    public CompletableFuture<Void> createKeyGiveaway(Long giveawayKeyId, InteractionHook interactionHook, Duration duration) {
+        Long serverId = interactionHook.getInteraction().getGuild().getIdLong();
+        GiveawayKey giveawayKey = giveawayKeyManagementService.getById(giveawayKeyId, serverId)
+          .orElseThrow(GiveawayKeyNotFoundException::new);
+        if((giveawayKey.getGiveaway() != null && giveawayKey.getGiveaway().getTargetDate().isAfter(Instant.now())) || giveawayKey.getUsed()) {
+            throw new GiveawayNotPossibleException();
+        }
+      GiveawayCreationRequest request = GiveawayCreationRequest
+          .builder()
+          .benefactorId(giveawayKey.getBenefactor() != null ? giveawayKey.getBenefactor().getUserReference().getId() : null)
+          .creatorId(giveawayKey.getCreator().getUserReference().getId())
+          .description(giveawayKey.getDescription())
+          .duration(duration)
+          .serverId(serverId)
+          .giveawayKeyId(giveawayKeyId)
+          .winnerCount(1)
+          .title(giveawayKey.getName())
+          .build();
+
+      return giveawayService.createGiveaway(request)
+          .thenAccept(giveawayId -> {
+              interactionService.sendEmbed(CREATE_KEY_GIVEAWAY_RESPONSE_TEMPLATE_KEY, interactionHook);
+          });
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter keyParameter = Parameter
+            .builder()
+            .templated(true)
+            .name(KEY_ID_PARAMETER)
+            .type(Long.class)
+            .build();
+
+        Parameter durationParameter = Parameter
+            .builder()
+            .templated(true)
+            .name(DURATION_PARAMETER)
+            .optional(true)
+            .type(Duration.class)
+            .build();
+
+        List<Parameter> parameters = Arrays.asList(keyParameter, durationParameter);
+        HelpInfo helpInfo = HelpInfo
+            .builder()
+            .templated(true)
+            .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+            .builder()
+            .enabled(true)
+            .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+            .groupName("key")
+            .commandName("creategiveaway")
+            .build();
+
+        return CommandConfiguration.builder()
+            .name(COMMAND_NAME)
+            .module(UtilityModuleDefinition.UTILITY)
+            .templated(true)
+            .slashCommandConfig(slashCommandConfig)
+            .async(true)
+            .supportsEmbedException(true)
+            .causesReaction(false)
+            .parameters(parameters)
+            .help(helpInfo)
+            .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return GiveawayFeatureDefinition.GIVEAWAY;
+    }
+
+    @Override
+    public List<FeatureMode> getFeatureModeLimitations() {
+        return Arrays.asList(GiveawayMode.KEY_GIVEAWAYS);
+    }
+}

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

@@ -80,6 +80,7 @@ public class ReRollGiveaway extends AbstractConditionableCommand {
                 .builder()
                 .enabled(true)
                 .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+                .groupName("management")
                 .commandName("reroll")
                 .build();
 

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

@@ -0,0 +1,96 @@
+package dev.sheldan.abstracto.giveaway.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.execution.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.giveaway.config.GiveawayFeatureDefinition;
+import dev.sheldan.abstracto.giveaway.config.GiveawayMode;
+import dev.sheldan.abstracto.giveaway.config.GiveawaySlashCommandNames;
+import dev.sheldan.abstracto.giveaway.service.management.GiveawayKeyManagementService;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class RemoveGiveawayKey extends AbstractConditionableCommand {
+
+
+  private static final String ID_PARAMETER = "id";
+  private static final String REMOVE_GIVEAWAY_KEY_COMMAND_NAME = "removeGiveawayKey";
+  private static final String REMOVE_GIVEAWAY_KEY_RESPONSE = "removeGiveawayKey_response";
+
+  @Autowired
+  private GiveawayKeyManagementService giveawayKeyManagementService;
+
+  @Autowired
+  private SlashCommandParameterService slashCommandParameterService;
+
+  @Autowired
+  private InteractionService interactionService;
+
+  @Override
+  public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+    Long id = slashCommandParameterService.getCommandOption(ID_PARAMETER, event, Integer.class).longValue();
+    giveawayKeyManagementService.deleteById(id, event.getGuild().getIdLong());
+    return interactionService.replyEmbed(REMOVE_GIVEAWAY_KEY_RESPONSE, event)
+        .thenApply(interactionHook -> CommandResult.fromSuccess());
+  }
+
+  @Override
+  public CommandConfiguration getConfiguration() {
+    Parameter giveawayKeyId = Parameter
+        .builder()
+        .templated(true)
+        .name(ID_PARAMETER)
+        .type(Long.class)
+        .build();
+
+    List<Parameter> parameters = Arrays.asList(giveawayKeyId);
+    HelpInfo helpInfo = HelpInfo
+        .builder()
+        .templated(true)
+        .build();
+
+    SlashCommandConfig slashCommandConfig = SlashCommandConfig
+        .builder()
+        .enabled(true)
+        .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+        .groupName("keys")
+        .commandName("remove")
+        .build();
+
+    return CommandConfiguration.builder()
+        .name(REMOVE_GIVEAWAY_KEY_COMMAND_NAME)
+        .module(UtilityModuleDefinition.UTILITY)
+        .templated(true)
+        .slashCommandOnly(true)
+        .slashCommandConfig(slashCommandConfig)
+        .async(true)
+        .supportsEmbedException(true)
+        .causesReaction(false)
+        .parameters(parameters)
+        .help(helpInfo)
+        .build();
+  }
+
+  @Override
+  public FeatureDefinition getFeature() {
+    return GiveawayFeatureDefinition.GIVEAWAY;
+  }
+
+  @Override
+  public List<FeatureMode> getFeatureModeLimitations() {
+    return Arrays.asList(GiveawayMode.KEY_GIVEAWAYS);
+  }
+}

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

@@ -0,0 +1,140 @@
+package dev.sheldan.abstracto.giveaway.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.execution.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import dev.sheldan.abstracto.core.service.PaginatorService;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.giveaway.config.GiveawayFeatureDefinition;
+import dev.sheldan.abstracto.giveaway.config.GiveawayMode;
+import dev.sheldan.abstracto.giveaway.config.GiveawaySlashCommandNames;
+import dev.sheldan.abstracto.giveaway.model.database.GiveawayKey;
+import dev.sheldan.abstracto.giveaway.model.template.GiveawayKeyDisplayModel;
+import dev.sheldan.abstracto.giveaway.model.template.GiveawayKeysDisplayModel;
+import dev.sheldan.abstracto.giveaway.service.management.GiveawayKeyManagementService;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ShowGiveawayKeys extends AbstractConditionableCommand {
+
+  public static final String SHOW_ALL_PARAMETER_NAME = "all";
+
+
+  private static final String SHOW_GIVEAWAY_KEYS_RESPONSE_TEMPLATE = "showGiveawayKeys_response";
+  private static final String SHOW_GIVEAWAY_NO_KEYS_FOUND_TEMPLATE = "showGiveawayKeys_no_keys_found";
+
+  @Autowired
+  private PaginatorService paginatorService;
+
+  @Autowired
+  private SlashCommandParameterService slashCommandParameterService;
+
+  @Autowired
+  private GiveawayKeyManagementService giveawayKeyManagementService;
+
+  @Autowired
+  private TemplateService templateService;
+
+  @Autowired
+  private InteractionService interactionService;
+
+  @Override
+  public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+    boolean showAll;
+    if(slashCommandParameterService.hasCommandOption(SHOW_ALL_PARAMETER_NAME, event)) {
+      showAll = slashCommandParameterService.getCommandOption(SHOW_ALL_PARAMETER_NAME, event, Boolean.class);
+    } else {
+      showAll = false;
+    }
+    List<GiveawayKey> giveawayKeys = giveawayKeyManagementService.getGiveawayKeys(event.getGuild().getIdLong(), showAll);
+    if(giveawayKeys.isEmpty()) {
+      MessageToSend messageToSend = templateService.renderEmbedTemplate(SHOW_GIVEAWAY_NO_KEYS_FOUND_TEMPLATE, new Object(), event.getGuild().getIdLong());
+      return interactionService.replyMessageToSend(messageToSend, event)
+          .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+    List<GiveawayKeyDisplayModel> models = giveawayKeys
+        .stream()
+        .map(giveawayKey -> GiveawayKeyDisplayModel
+            .builder()
+            .key(giveawayKey.getKey())
+            .id(giveawayKey.getId().getKeyId())
+            .used(giveawayKey.getUsed())
+            .description(giveawayKey.getDescription())
+            .name(giveawayKey.getName())
+            .winner(giveawayKey.getWinner() != null ? MemberDisplay.fromAUserInAServer(giveawayKey.getWinner()) : null)
+            .creator(MemberDisplay.fromAUserInAServer(giveawayKey.getCreator()))
+            .benefactor(giveawayKey.getBenefactor() != null ? MemberDisplay.fromAUserInAServer(giveawayKey.getBenefactor()) : null)
+            .build())
+        .toList();
+    GiveawayKeysDisplayModel model = GiveawayKeysDisplayModel
+        .builder()
+        .keys(models)
+        .build();
+    return paginatorService.createPaginatorFromTemplate(SHOW_GIVEAWAY_KEYS_RESPONSE_TEMPLATE, model, event)
+        .thenApply(unused -> CommandResult.fromSuccess());
+  }
+
+  @Override
+  public CommandConfiguration getConfiguration() {
+
+    Parameter showAllParameter = Parameter
+        .builder()
+        .templated(true)
+        .name(SHOW_ALL_PARAMETER_NAME)
+        .type(Boolean.class)
+        .optional(true)
+        .build();
+
+    List<Parameter> parameters = Arrays.asList(showAllParameter);
+    HelpInfo helpInfo = HelpInfo
+        .builder()
+        .templated(true)
+        .build();
+
+    SlashCommandConfig slashCommandConfig = SlashCommandConfig
+        .builder()
+        .enabled(true)
+        .rootCommandName(GiveawaySlashCommandNames.GIVEAWAY)
+        .groupName("keys")
+        .commandName("show")
+        .build();
+
+    return CommandConfiguration.builder()
+        .name("showGiveawayKeys")
+        .module(UtilityModuleDefinition.UTILITY)
+        .templated(true)
+        .slashCommandConfig(slashCommandConfig)
+        .async(true)
+        .slashCommandOnly(true)
+        .supportsEmbedException(true)
+        .causesReaction(false)
+        .parameters(parameters)
+        .help(helpInfo)
+        .build();
+  }
+
+  @Override
+  public FeatureDefinition getFeature() {
+    return GiveawayFeatureDefinition.GIVEAWAY;
+  }
+
+  @Override
+  public List<FeatureMode> getFeatureModeLimitations() {
+    return Arrays.asList(GiveawayMode.KEY_GIVEAWAYS);
+  }
+}

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/repository/GiveawayKeyRepository.java

@@ -0,0 +1,13 @@
+package dev.sheldan.abstracto.giveaway.repository;
+
+import dev.sheldan.abstracto.giveaway.model.database.GiveawayKey;
+import dev.sheldan.abstracto.giveaway.model.database.embed.GiveawayKeyId;
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface GiveawayKeyRepository extends JpaRepository<GiveawayKey, GiveawayKeyId> {
+    List<GiveawayKey> findGiveawayKeysByUsedAndServer_IdOrderById(Boolean used, Long serverId);
+    List<GiveawayKey> findGiveawayKeysByServer_IdOrderById(Long serverId);
+}

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

@@ -7,28 +7,38 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.CounterService;
+import dev.sheldan.abstracto.core.service.FeatureModeService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
+import dev.sheldan.abstracto.core.service.UserService;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
+import dev.sheldan.abstracto.giveaway.config.GiveawayFeatureDefinition;
+import dev.sheldan.abstracto.giveaway.config.GiveawayMode;
 import dev.sheldan.abstracto.giveaway.config.GiveawayPostTarget;
+import dev.sheldan.abstracto.giveaway.exception.GiveawayKeyNotFoundException;
 import dev.sheldan.abstracto.giveaway.exception.GiveawayNotFoundException;
 import dev.sheldan.abstracto.giveaway.model.GiveawayCreationRequest;
 import dev.sheldan.abstracto.giveaway.model.JoinGiveawayPayload;
 import dev.sheldan.abstracto.giveaway.model.database.Giveaway;
+import dev.sheldan.abstracto.giveaway.model.database.GiveawayKey;
 import dev.sheldan.abstracto.giveaway.model.database.GiveawayParticipant;
 import dev.sheldan.abstracto.giveaway.model.template.GiveawayMessageModel;
 import dev.sheldan.abstracto.giveaway.model.template.GiveawayResultMessageModel;
+import dev.sheldan.abstracto.giveaway.model.template.GiveawayWinnerNotificationMessageModel;
+import dev.sheldan.abstracto.giveaway.service.management.GiveawayKeyManagementService;
 import dev.sheldan.abstracto.giveaway.service.management.GiveawayManagementService;
 import dev.sheldan.abstracto.giveaway.service.management.GiveawayParticipantManagementService;
+import dev.sheldan.abstracto.modmail.service.ModMailThreadService;
 import dev.sheldan.abstracto.scheduling.model.JobParameters;
 import dev.sheldan.abstracto.scheduling.service.SchedulerService;
 import jakarta.transaction.Transactional;
 import lombok.extern.slf4j.Slf4j;
 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.entities.channel.middleman.GuildMessageChannel;
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -44,6 +54,7 @@ import java.util.concurrent.CompletableFuture;
 public class GiveawayServiceBean implements GiveawayService {
 
     private static final String GIVEAWAY_MESSAGE_TEMPLATE_KEY = "giveaway_post";
+    private static final String GIVEAWAY_WINNER_MODMAIL_NOTIFICATION = "giveaway_winner_modmail_notification";
     private static final String GIVEAWAY_RESULT_MESSAGE_TEMPLATE_KEY = "giveaway_result";
     public static final String GIVEAWAY_JOIN_ORIGIN = "JOIN_GIVEAWAY";
 
@@ -85,42 +96,55 @@ public class GiveawayServiceBean implements GiveawayService {
     @Autowired
     private CounterService counterService;
 
+    @Autowired
+    private GiveawayKeyManagementService giveawayKeyManagementService;
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private FeatureModeService featureModeService;
+
+    @Autowired(required = false)
+    private ModMailThreadService modMailThreadService;
+
     @Autowired
     private GiveawayServiceBean self;
 
     @Override
-    public CompletableFuture<Void> createGiveaway(GiveawayCreationRequest giveawayCreationRequest) {
+    public CompletableFuture<Long> createGiveaway(GiveawayCreationRequest giveawayCreationRequest) {
         String componentId = componentService.generateComponentId();
         Instant targetDate = Instant.now().plus(giveawayCreationRequest.getDuration());
-        Long serverId = giveawayCreationRequest.getCreator().getGuild().getIdLong();
+        Long serverId = giveawayCreationRequest.getServerId();
         Long giveawayId = counterService.getNextCounterValue(serverId, GIVEAWAY_COUNTER);
         GiveawayMessageModel model = GiveawayMessageModel
                 .builder()
                 .title(giveawayCreationRequest.getTitle())
                 .description(giveawayCreationRequest.getDescription())
                 .giveawayId(giveawayId)
-                .benefactor(giveawayCreationRequest.getBenefactor() != null ? MemberDisplay.fromMember(giveawayCreationRequest.getBenefactor()) : null)
-                .creator(MemberDisplay.fromMember(giveawayCreationRequest.getCreator()))
+                .benefactor(giveawayCreationRequest.getBenefactorId() != null ? MemberDisplay.fromIds(giveawayCreationRequest.getServerId(), giveawayCreationRequest.getBenefactorId()) : null)
+                .creator(MemberDisplay.fromIds(giveawayCreationRequest.getServerId(), giveawayCreationRequest.getCreatorId()))
                 .winnerCount(giveawayCreationRequest.getWinnerCount())
                 .targetDate(targetDate)
                 .joinComponentId(componentId)
                 .build();
         List<CompletableFuture<Message>> messageFutures;
-        log.info("Rendering giveaway message in server {} by user {}", serverId, giveawayCreationRequest.getCreator().getIdLong());
+        log.info("Rendering giveaway message in server {} by user {}", serverId, giveawayCreationRequest.getCreatorId());
         MessageToSend messageToSend = templateService.renderEmbedTemplate(GIVEAWAY_MESSAGE_TEMPLATE_KEY, model, serverId);
         if(giveawayCreationRequest.getTargetChannel() == null) {
             log.info("Sending giveaway to post target in server {}", serverId);
-            postTargetService.validatePostTarget(GiveawayPostTarget.GIVEAWAYS, giveawayCreationRequest.getCreator().getGuild().getIdLong());
+            postTargetService.validatePostTarget(GiveawayPostTarget.GIVEAWAYS, serverId);
             messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, GiveawayPostTarget.GIVEAWAYS, serverId);
         } else {
             log.info("Sending giveaway to channel {} in server {}.", giveawayCreationRequest.getTargetChannel().getId(), serverId);
             messageFutures = channelService.sendMessageToSendToChannel(messageToSend, giveawayCreationRequest.getTargetChannel());
         }
         CompletableFutureList<Message> messageFutureList = new CompletableFutureList<>(messageFutures);
-        return messageFutureList.getMainFuture().thenAccept(o -> {
+        return messageFutureList.getMainFuture().thenApply(o -> {
             Message createdMessage = messageFutureList.getFutures().get(0).join();
             giveawayCreationRequest.setTargetChannel(createdMessage.getGuildChannel());
             self.persistGiveaway(giveawayCreationRequest, giveawayId, createdMessage.getIdLong(), componentId);
+            return giveawayId;
         });
     }
 
@@ -140,13 +164,9 @@ public class GiveawayServiceBean implements GiveawayService {
     @Override
     @Transactional
     public CompletableFuture<Void> evaluateGiveaway(Long giveawayId, Long serverId) {
-        Optional<Giveaway> giveAwayOptional = giveawayManagementService.loadGiveawayById(giveawayId, serverId);
-        if(giveAwayOptional.isEmpty()) {
-            throw new GiveawayNotFoundException();
-        }
+        Giveaway giveaway = giveawayManagementService.loadGiveawayById(giveawayId, serverId).orElseThrow(GiveawayNotFoundException::new);
         log.info("Evaluating giveaway {} in server {}.", giveawayId, serverId);
-        Giveaway giveaway = giveAwayOptional.get();
-        Set<Long> winners = new HashSet<>();
+        Set<Long> winnerUserInServerIds = new HashSet<>();
         Integer winnerCount = giveaway.getWinnerCount();
         giveaway.getParticipants().forEach(giveawayParticipant -> giveawayParticipant.setWon(false));
         List<Long> potentialWinners = new ArrayList<>(giveaway
@@ -156,20 +176,20 @@ public class GiveawayServiceBean implements GiveawayService {
                 .toList());
 
         if(potentialWinners.size() <= winnerCount) {
-            winners.addAll(potentialWinners);
+            winnerUserInServerIds.addAll(potentialWinners);
             log.debug("Less participants than total winners - selecting all for giveaway {} in server {}.", giveawayId, serverId);
         } else {
             for (int i = 0; i < winnerCount; i++) {
                 int winnerIndex = secureRandom.nextInt(potentialWinners.size());
                 Long winner = potentialWinners.get(winnerIndex);
                 potentialWinners.remove(winnerIndex);
-                winners.add(winner);
+                winnerUserInServerIds.add(winner);
             }
         }
         List<GiveawayParticipant> winningParticipants = giveaway
                 .getParticipants()
                 .stream()
-                .filter(giveawayParticipant -> winners.contains(giveawayParticipant.getParticipant().getUserInServerId()))
+                .filter(giveawayParticipant -> winnerUserInServerIds.contains(giveawayParticipant.getParticipant().getUserInServerId()))
                 .toList();
         winningParticipants.forEach(giveawayParticipant -> giveawayParticipant.setWon(true));
         List<MemberDisplay> winnerDisplays = winningParticipants
@@ -185,16 +205,55 @@ public class GiveawayServiceBean implements GiveawayService {
         log.info("Sending result message for giveaway {} in server {}.", giveawayId, serverId);
         MessageToSend messageToSend = templateService.renderEmbedTemplate(GIVEAWAY_RESULT_MESSAGE_TEMPLATE_KEY, resultModel, serverId);
         List<CompletableFuture<Message>> resultFutures = channelService.sendMessageEmbedToSendToAChannel(messageToSend, giveaway.getGiveawayChannel());
-
+        long actualWinnerCount = winnerUserInServerIds.size();
+        Long winnerUserId;
+        if(giveaway.getGiveawayKey() != null && !winningParticipants.isEmpty()) {
+            GiveawayParticipant winnerParticipant = winningParticipants.get(0);
+            GiveawayKey giveawayKey = giveaway.getGiveawayKey();
+            giveawayKey.setWinner(winnerParticipant.getParticipant());
+            giveawayKey.setUsed(true);
+            winnerUserId = winnerParticipant.getParticipant().getUserReference().getId();
+        } else {
+            winnerUserId = null;
+        }
         GiveawayMessageModel giveawayMessageModel = GiveawayMessageModel.fromGiveaway(giveaway);
         giveawayMessageModel.setWinners(winnerDisplays);
         giveawayMessageModel.setEnded(true);
+        boolean createGiveawayKeyNotification = giveaway.getGiveawayKey() != null
+            && featureModeService.featureModeActive(GiveawayFeatureDefinition.GIVEAWAY, serverId, GiveawayMode.AUTO_NOTIFY_GIVEAWAY_KEY_WINNERS)
+            && featureModeService.featureModeActive(GiveawayFeatureDefinition.GIVEAWAY, serverId, GiveawayMode.KEY_GIVEAWAYS)
+            && actualWinnerCount > 0
+            && modMailThreadService != null;
         MessageToSend giveawayMessageToSend = templateService.renderEmbedTemplate(GIVEAWAY_MESSAGE_TEMPLATE_KEY, giveawayMessageModel, serverId);
         log.info("Updating original giveaway message for giveaway {} in server {}.", giveawayId, serverId);
         GuildMessageChannel messageChannel = channelService.getMessageChannelFromServer(giveaway.getServer().getId(), giveaway.getGiveawayChannel().getId());
         CompletableFuture<Message> giveawayUpdateFuture = channelService.editMessageInAChannelFuture(giveawayMessageToSend, messageChannel, giveaway.getMessageId());
         resultFutures.add(giveawayUpdateFuture);
-        return new CompletableFutureList<>(resultFutures).getMainFuture();
+        return new CompletableFutureList<>(resultFutures).getMainFuture().thenCompose(unused -> {
+            if(createGiveawayKeyNotification) {
+                return userService.retrieveUserForId(winnerUserId)
+                    .thenCompose(user -> self.handleKeyGiveawayNotifications(giveawayId, serverId, winnerUserInServerIds.iterator().next(), user))
+                    .exceptionally(throwable -> {
+                        log.error("Failed to notify winner of giveaway {} in server {}.", giveawayId, serverId, throwable);
+                        return null;
+                    });
+            } else {
+                return CompletableFuture.completedFuture(null);
+            }
+        });
+    }
+
+    @Transactional
+    public CompletableFuture<Void> handleKeyGiveawayNotifications(Long giveawayId, Long serverId, Long winnerInServerId, User user) {
+        if(modMailThreadService == null) {
+            log.info("Modmail service not available - skipping notifications about giveaway {} in server {}.", giveawayId, serverId);
+            return CompletableFuture.completedFuture(null);
+        }
+        Giveaway giveaway = giveawayManagementService.loadGiveawayById(giveawayId, serverId).orElseThrow(GiveawayNotFoundException::new);
+        GiveawayWinnerNotificationMessageModel messageModel = GiveawayWinnerNotificationMessageModel.fromGiveaway(giveaway, giveaway.getGiveawayKey().getKey());
+        AUserInAServer winner = userInServerManagementService.loadOrCreateUser(winnerInServerId);
+        MessageToSend giveawayWinnerNotification = templateService.renderEmbedTemplate(GIVEAWAY_WINNER_MODMAIL_NOTIFICATION, messageModel, serverId);
+        return modMailThreadService.sendMessageToUser(winner, giveawayWinnerNotification, user);
     }
 
     @Override
@@ -241,14 +300,13 @@ public class GiveawayServiceBean implements GiveawayService {
 
     @Transactional
     public void persistGiveaway(GiveawayCreationRequest giveawayCreationRequest, Long giveawayId, Long messageId, String componentId) {
-        Member creatorMember = giveawayCreationRequest.getCreator();
-        log.info("Persisting giveaway in server {} with message id {}.", creatorMember.getGuild().getIdLong(), messageId);
+        log.info("Persisting giveaway in server {} with message id {}.", giveawayCreationRequest.getServerId(), messageId);
         Instant targetDate = Instant.now().plus(giveawayCreationRequest.getDuration());
         AChannel targetChannel = channelManagementService.loadChannel(giveawayCreationRequest.getTargetChannel().getIdLong());
-        AUserInAServer creator = userInServerManagementService.loadOrCreateUser(creatorMember);
+        AUserInAServer creator = userInServerManagementService.loadOrCreateUser(giveawayCreationRequest.getServerId(), giveawayCreationRequest.getCreatorId());
         AUserInAServer benefactor;
-        if(giveawayCreationRequest.getBenefactor() != null) {
-            benefactor = userInServerManagementService.loadOrCreateUser(giveawayCreationRequest.getBenefactor());
+        if(giveawayCreationRequest.getBenefactorId() != null) {
+            benefactor = userInServerManagementService.loadOrCreateUser(giveawayCreationRequest.getServerId(), giveawayCreationRequest.getBenefactorId());
         } else {
             benefactor = null;
         }
@@ -257,6 +315,12 @@ public class GiveawayServiceBean implements GiveawayService {
                 giveawayCreationRequest.getTitle(), giveawayCreationRequest.getDescription(), giveawayCreationRequest.getWinnerCount(),
                 messageId, componentId, giveawayId);
 
+        if(giveawayCreationRequest.getGiveawayKeyId() != null) {
+            GiveawayKey giveawayKey = giveawayKeyManagementService.getById(giveawayCreationRequest.getGiveawayKeyId(), giveawayCreationRequest.getServerId())
+                .orElseThrow(GiveawayKeyNotFoundException::new);
+            giveawayKey.setGiveaway(giveaway);
+            giveawayKeyManagementService.saveGiveawayKey(giveawayKey);
+        }
         HashMap<Object, Object> parameters = new HashMap<>();
         parameters.put("giveawayId", giveaway.getGiveawayId().getId().toString());
         parameters.put("serverId", giveaway.getGiveawayId().getServerId().toString());
@@ -264,7 +328,7 @@ public class GiveawayServiceBean implements GiveawayService {
                 .builder()
                 .parameters(parameters)
                 .build();
-        log.info("Scheduling giveaway reminder for giveaway {} originating from message {} in server {}.", giveaway.getGiveawayId().getId(), messageId, creatorMember.getGuild().getIdLong());
+        log.info("Scheduling giveaway reminder for giveaway {} originating from message {} in server {}.", giveaway.getGiveawayId().getId(), messageId, giveawayCreationRequest.getServerId());
         String triggerKey = schedulerService.executeJobWithParametersOnce("giveawayEvaluationJob", "giveaway", jobParameters, Date.from(giveaway.getTargetDate()));
         giveaway.setReminderTriggerKey(triggerKey);
         JoinGiveawayPayload joinPayload = JoinGiveawayPayload

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

@@ -0,0 +1,85 @@
+package dev.sheldan.abstracto.giveaway.service.management;
+
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.service.CounterService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.giveaway.exception.GiveawayKeyNotFoundException;
+import dev.sheldan.abstracto.giveaway.model.database.GiveawayKey;
+import dev.sheldan.abstracto.giveaway.model.database.embed.GiveawayKeyId;
+import dev.sheldan.abstracto.giveaway.repository.GiveawayKeyRepository;
+import java.util.List;
+import java.util.Optional;
+import net.dv8tion.jda.api.entities.Member;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class GiveawayKeyManagementServiceBean implements GiveawayKeyManagementService {
+
+  @Autowired
+  private GiveawayKeyRepository giveawayKeyRepository;
+
+  @Autowired
+  private CounterService counterService;
+
+  @Autowired
+  private UserInServerManagementService userInServerManagementService;
+
+  public static final String GIVEAWAY_KEYS_COUNTER = "giveaway_keys";
+
+  @Override
+  public GiveawayKey createGiveawayKey(Member creator, Member benefactor, String key, String description, String name) {
+    Long counterValue = counterService.getNextCounterValue(creator.getGuild().getIdLong(), GIVEAWAY_KEYS_COUNTER);
+    GiveawayKeyId id = new GiveawayKeyId(counterValue, creator.getGuild().getIdLong());
+
+    AUserInAServer creatorUser = userInServerManagementService.loadOrCreateUser(creator);
+    AUserInAServer benefactorUser;
+    if(benefactor != null) {
+      benefactorUser = userInServerManagementService.loadOrCreateUser(benefactor);
+    } else {
+      benefactorUser = null;
+    }
+
+    GiveawayKey giveawayKey = GiveawayKey
+        .builder()
+        .id(id)
+        .creator(creatorUser)
+        .used(false)
+        .server(creatorUser.getServerReference())
+        .key(key)
+        .description(description)
+        .benefactor(benefactorUser)
+        .name(name)
+        .build();
+    return giveawayKeyRepository.save(giveawayKey);
+  }
+
+  @Override
+  public void deleteById(Long id, Long serverId) {
+    GiveawayKey key = giveawayKeyRepository.findById(new GiveawayKeyId(id, serverId)).orElseThrow(GiveawayKeyNotFoundException::new);
+    if(key.getGiveaway() != null) {
+      key.getGiveaway().setGiveawayKey(null);
+    }
+    giveawayKeyRepository.delete(key);
+  }
+
+  @Override
+  public Optional<GiveawayKey> getById(Long id, Long serverId) {
+    return giveawayKeyRepository.findById(new GiveawayKeyId(id, serverId));
+  }
+
+  @Override
+  public GiveawayKey saveGiveawayKey(GiveawayKey giveawayKey) {
+    return giveawayKeyRepository.save(giveawayKey);
+  }
+
+  @Override
+  public List<GiveawayKey> getGiveawayKeys(Long serverId, Boolean showAll) {
+    if(showAll) {
+      return giveawayKeyRepository.findGiveawayKeysByServer_IdOrderById(serverId);
+    } else {
+      return giveawayKeyRepository.findGiveawayKeysByUsedAndServer_IdOrderById(false, serverId);
+    }
+  }
+}

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

@@ -1,4 +1,15 @@
 abstracto.featureFlags.giveaway.featureName=giveaway
 abstracto.featureFlags.giveaway.enabled=false
 
-abstracto.postTargets.giveaways.name=giveaways
+abstracto.postTargets.giveaways.name=giveaways
+
+abstracto.featureModes.keyGiveaways.featureName=giveaway
+abstracto.featureModes.keyGiveaways.mode=keyGiveaways
+abstracto.featureModes.keyGiveaways.enabled=false
+
+abstracto.featureModes.autoNotifyGiveawayKeyWinners.featureName=giveaway
+abstracto.featureModes.autoNotifyGiveawayKeyWinners.mode=autoNotifyGiveawayKeyWinners
+abstracto.featureModes.autoNotifyGiveawayKeyWinners.enabled=false
+
+abstracto.systemConfigs.keyGiveawaysDuration.name=keyGiveawaysDuration
+abstracto.systemConfigs.keyGiveawaysDuration.stringValue=24h

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/resources/migrations/1.5.55/collection.xml

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

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/resources/migrations/1.5.55/seedData/command.xml

@@ -0,0 +1,30 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                     xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.26.xsd" >
+    <property name="utilityModule" value="(SELECT id FROM module WHERE name = 'utility')"/>
+    <property name="giveawayFeature" value="(SELECT id FROM feature WHERE key = 'giveaway')"/>
+    <changeSet  author="Sheldan" id="giveawayKey-commands">
+        <insert tableName="command">
+            <column name="name" value="addGiveawayKey"/>
+            <column name="module_id" valueComputed="${utilityModule}"/>
+            <column name="feature_id" valueComputed="${giveawayFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="removeGiveawayKey"/>
+            <column name="module_id" valueComputed="${utilityModule}"/>
+            <column name="feature_id" valueComputed="${giveawayFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="showGiveawayKeys"/>
+            <column name="module_id" valueComputed="${utilityModule}"/>
+            <column name="feature_id" valueComputed="${giveawayFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="createKeyGiveaway"/>
+            <column name="module_id" valueComputed="${utilityModule}"/>
+            <column name="feature_id" valueComputed="${giveawayFeature}"/>
+        </insert>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/resources/migrations/1.5.55/seedData/data.xml

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

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/resources/migrations/1.5.55/tables/giveaway_key.xml

@@ -0,0 +1,69 @@
+<?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="giveaway_key-table">
+        <createTable tableName="giveaway_key">
+            <column name="id" type="BIGINT">
+                <constraints nullable="false" />
+            </column>
+            <column name="creator_user_id" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="benefactor_user_id" type="INTEGER">
+                <constraints nullable="true"/>
+            </column>
+            <column name="winner_user_id" type="INTEGER">
+                <constraints nullable="true"/>
+            </column>
+            <column name="key" type="VARCHAR(255)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="name" type="VARCHAR(100)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="description" type="VARCHAR(255)">
+                <constraints nullable="true"/>
+            </column>
+            <column name="used" type="BOOLEAN">
+                <constraints nullable="false"/>
+            </column>
+            <column name="server_id" type="BIGINT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="giveaway_id" type="BIGINT">
+                <constraints nullable="true" />
+            </column>
+            <column name="giveaway_server_id" type="BIGINT">
+                <constraints nullable="true" />
+            </column>
+            <column name="created" type="TIMESTAMP WITHOUT TIME ZONE">
+                <constraints nullable="false"/>
+            </column>
+            <column name="updated" type="TIMESTAMP WITHOUT TIME ZONE"/>
+        </createTable>
+        <addPrimaryKey tableName="giveaway_key" columnNames="id, server_id"/>
+        <addForeignKeyConstraint baseColumnNames="creator_user_id" baseTableName="giveaway_key" constraintName="fk_giveaway_key_creator" deferrable="false"
+                                 initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="user_in_server_id"
+                                 referencedTableName="user_in_server" validate="true"/>
+        <addForeignKeyConstraint baseColumnNames="benefactor_user_id" baseTableName="giveaway_key" constraintName="fk_giveaway_key_benefactor" deferrable="false"
+                                 initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="user_in_server_id"
+                                 referencedTableName="user_in_server" validate="true"/>
+        <addForeignKeyConstraint baseColumnNames="winner_user_id" baseTableName="giveaway_key" constraintName="fk_giveaway_key_winner" deferrable="false"
+                                 initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="user_in_server_id"
+                                 referencedTableName="user_in_server" validate="true"/>
+        <addForeignKeyConstraint baseColumnNames="giveaway_id,giveaway_server_id" baseTableName="giveaway_key" constraintName="fk_giveaway_key_giveaway" deferrable="false"
+                                 initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="id,server_id"
+                                 referencedTableName="giveaway" validate="true"/>
+        <addForeignKeyConstraint baseColumnNames="server_id" baseTableName="giveaway_key" constraintName="fk_giveaway_key_server" deferrable="false" initiallyDeferred="false"
+                                 onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="id" referencedTableName="server" validate="true"/>
+        <sql>
+            DROP TRIGGER IF EXISTS giveaway_key_update_trigger ON giveaway_key;
+            CREATE TRIGGER giveaway_update_trigger BEFORE UPDATE ON giveaway_key FOR EACH ROW EXECUTE PROCEDURE update_trigger_procedure();
+        </sql>
+        <sql>
+            DROP TRIGGER IF EXISTS giveaway_key_insert_trigger ON giveaway_key;
+            CREATE TRIGGER giveaway_insert_trigger BEFORE INSERT ON giveaway_key FOR EACH ROW EXECUTE PROCEDURE insert_trigger_procedure();
+        </sql>
+    </changeSet>
+</databaseChangeLog>

abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/resources/migrations/1.5.55/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="giveaway_key.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

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

@@ -3,4 +3,5 @@
                      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="1.5.13/collection.xml" relativeToChangelogFile="true"/>
+    <include file="1.5.55/collection.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>

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.54-SNAPSHOT</version>
+        <version>1.5.61-SNAPSHOT</version>
     </parent>
 
     <artifactId>giveaway-int</artifactId>

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/config/GiveawayFeatureConfig.java

@@ -2,6 +2,7 @@ package dev.sheldan.abstracto.giveaway.config;
 
 import dev.sheldan.abstracto.core.config.FeatureConfig;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.FeatureMode;
 import dev.sheldan.abstracto.core.config.PostTargetEnum;
 import org.springframework.stereotype.Component;
 
@@ -11,6 +12,8 @@ import java.util.List;
 @Component
 public class GiveawayFeatureConfig implements FeatureConfig {
 
+    public static final String KEY_GIVEAWAYS_DURATION = "keyGiveawaysDuration";
+
     @Override
     public FeatureDefinition getFeature() {
         return GiveawayFeatureDefinition.GIVEAWAY;
@@ -20,4 +23,14 @@ public class GiveawayFeatureConfig implements FeatureConfig {
     public List<PostTargetEnum> getRequiredPostTargets() {
         return Arrays.asList(GiveawayPostTarget.GIVEAWAYS);
     }
+
+    @Override
+    public List<FeatureMode> getAvailableModes() {
+        return Arrays.asList(GiveawayMode.KEY_GIVEAWAYS, GiveawayMode.AUTO_NOTIFY_GIVEAWAY_KEY_WINNERS);
+    }
+
+    @Override
+    public List<String> getRequiredSystemConfigKeys() {
+        return Arrays.asList(KEY_GIVEAWAYS_DURATION);
+    }
 }

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/config/GiveawayMode.java

@@ -0,0 +1,17 @@
+package dev.sheldan.abstracto.giveaway.config;
+
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import lombok.Getter;
+
+@Getter
+public enum GiveawayMode implements FeatureMode {
+    KEY_GIVEAWAYS("keyGiveaways"),
+    AUTO_NOTIFY_GIVEAWAY_KEY_WINNERS("autoNotifyGiveawayKeyWinners");
+
+    private final String key;
+
+    GiveawayMode(String key) {
+        this.key = key;
+    }
+
+}

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/exception/GiveawayKeyNotFoundException.java

@@ -0,0 +1,19 @@
+package dev.sheldan.abstracto.giveaway.exception;
+
+import dev.sheldan.abstracto.core.exception.AbstractoTemplatableException;
+
+public class GiveawayKeyNotFoundException extends AbstractoTemplatableException {
+  public GiveawayKeyNotFoundException() {
+    super("Giveaway key not found.");
+  }
+
+  @Override
+  public String getTemplateName() {
+    return "giveaway_key_not_found_exception";
+  }
+
+  @Override
+  public Object getTemplateModel() {
+    return new Object();
+  }
+}

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/exception/GiveawayNotPossibleException.java

@@ -0,0 +1,19 @@
+package dev.sheldan.abstracto.giveaway.exception;
+
+import dev.sheldan.abstracto.core.exception.AbstractoTemplatableException;
+
+public class GiveawayNotPossibleException extends AbstractoTemplatableException {
+  public GiveawayNotPossibleException() {
+    super("Giveaway not possible.");
+  }
+
+  @Override
+  public String getTemplateName() {
+    return "giveaway_not_possible_exception";
+  }
+
+  @Override
+  public Object getTemplateModel() {
+    return new Object();
+  }
+}

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/model/GiveawayCreationRequest.java

@@ -3,7 +3,6 @@ package dev.sheldan.abstracto.giveaway.model;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
-import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
 
 import java.time.Duration;
@@ -12,8 +11,10 @@ import java.time.Duration;
 @Getter
 public class GiveawayCreationRequest {
 
-    private Member creator;
-    private Member benefactor;
+    private Long creatorId;
+    private Long serverId;
+    private Long benefactorId;
+    private Long giveawayKeyId;
     private String title;
     private String description;
     private Duration duration;

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/model/database/Giveaway.java

@@ -65,6 +65,9 @@ public class Giveaway {
     @Column(name = "message_id", nullable = false)
     private Long messageId;
 
+    @OneToOne(mappedBy = "giveaway")
+    private GiveawayKey giveawayKey;
+
     @Column(name = "created", nullable = false, insertable = false, updatable = false)
     private Instant created;
 

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/model/database/GiveawayKey.java

@@ -0,0 +1,75 @@
+package dev.sheldan.abstracto.giveaway.model.database;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.giveaway.model.database.embed.GiveawayKeyId;
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.EmbeddedId;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.JoinColumns;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.MapsId;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Builder
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "giveaway_key")
+@Getter
+@Setter
+@EqualsAndHashCode
+public class GiveawayKey {
+  @Id
+  @EmbeddedId
+  private GiveawayKeyId id;
+
+  @OneToOne(fetch = FetchType.LAZY)
+  @JoinColumns(
+      {
+          @JoinColumn(name = "giveaway_id", referencedColumnName = "id"),
+          @JoinColumn(name = "giveaway_server_id", referencedColumnName = "server_id")
+      })
+  private Giveaway giveaway;
+
+  @ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
+  @MapsId("serverId")
+  @JoinColumn(name = "server_id", referencedColumnName = "id", nullable = false)
+  private AServer server;
+
+  @ManyToOne(fetch = FetchType.LAZY)
+  @JoinColumn(name = "creator_user_id", nullable = false)
+  private AUserInAServer creator;
+
+  @ManyToOne(fetch = FetchType.LAZY)
+  @JoinColumn(name = "winner_user_id")
+  private AUserInAServer winner;
+
+  @ManyToOne(fetch = FetchType.LAZY)
+  @JoinColumn(name = "benefactor_user_id")
+  private AUserInAServer benefactor;
+
+  @Column(name = "key", nullable = false)
+  private String key;
+
+  @Column(name = "name")
+  private String name;
+
+  @Column(name = "used")
+  private Boolean used;
+
+  @Column(name = "description")
+  private String description;
+
+}

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/model/database/embed/GiveawayKeyId.java

@@ -0,0 +1,27 @@
+package dev.sheldan.abstracto.giveaway.model.database.embed;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Embeddable;
+import java.io.Serializable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Embeddable
+@Getter
+@Setter
+@Builder
+@EqualsAndHashCode
+@NoArgsConstructor
+@AllArgsConstructor
+public class GiveawayKeyId implements Serializable {
+    @Column(name = "id")
+    private Long keyId;
+
+    @Column(name = "server_id")
+    private Long serverId;
+
+}

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/model/template/GiveawayKeyDisplayModel.java

@@ -0,0 +1,18 @@
+package dev.sheldan.abstracto.giveaway.model.template;
+
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@Getter
+public class GiveawayKeyDisplayModel {
+    private String key;
+    private String name;
+    private Long id;
+    private String description;
+    private Boolean used;
+    private MemberDisplay creator;
+    private MemberDisplay benefactor;
+    private MemberDisplay winner;
+}

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/model/template/GiveawayKeysDisplayModel.java

@@ -0,0 +1,11 @@
+package dev.sheldan.abstracto.giveaway.model.template;
+
+import java.util.List;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@Getter
+public class GiveawayKeysDisplayModel {
+    private List<GiveawayKeyDisplayModel> keys;
+}

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/model/template/GiveawayWinnerNotificationMessageModel.java

@@ -0,0 +1,31 @@
+package dev.sheldan.abstracto.giveaway.model.template;
+
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import dev.sheldan.abstracto.giveaway.model.database.Giveaway;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Builder
+@Getter
+@Setter
+public class GiveawayWinnerNotificationMessageModel {
+    private String title;
+    private String description;
+    private String key;
+    private Long giveawayId;
+    private MemberDisplay creator;
+    private MemberDisplay benefactor;
+
+    public static GiveawayWinnerNotificationMessageModel fromGiveaway(Giveaway giveaway, String key) {
+        return GiveawayWinnerNotificationMessageModel
+                .builder()
+                .title(giveaway.getTitle())
+                .description(giveaway.getDescription())
+                .key(key)
+                .benefactor(giveaway.getBenefactor() != null ? MemberDisplay.fromAUserInAServer(giveaway.getBenefactor()) : null)
+                .creator(MemberDisplay.fromAUserInAServer(giveaway.getCreator()))
+                .giveawayId(giveaway.getGiveawayId().getId())
+                .build();
+    }
+}

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/service/GiveawayService.java

@@ -8,7 +8,7 @@ import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
 import java.util.concurrent.CompletableFuture;
 
 public interface GiveawayService {
-    CompletableFuture<Void> createGiveaway(GiveawayCreationRequest giveawayCreationRequest);
+    CompletableFuture<Long> createGiveaway(GiveawayCreationRequest giveawayCreationRequest);
     CompletableFuture<Void> addGiveawayParticipant(Giveaway giveaway, Member member, MessageChannel messageChannel);
     CompletableFuture<Void> evaluateGiveaway(Long giveawayId, Long serverId);
     CompletableFuture<Void> cancelGiveaway(Long giveawayId, Long serverId);

abstracto-application/abstracto-modules/giveaway/giveaway-int/src/main/java/dev/sheldan/abstracto/giveaway/service/management/GiveawayKeyManagementService.java

@@ -0,0 +1,14 @@
+package dev.sheldan.abstracto.giveaway.service.management;
+
+import dev.sheldan.abstracto.giveaway.model.database.GiveawayKey;
+import java.util.List;
+import java.util.Optional;
+import net.dv8tion.jda.api.entities.Member;
+
+public interface GiveawayKeyManagementService {
+  GiveawayKey createGiveawayKey(Member creator, Member benefactor, String key, String description, String name);
+  void deleteById(Long id, Long serverId);
+  Optional<GiveawayKey> getById(Long id, Long serverId);
+  GiveawayKey saveGiveawayKey(GiveawayKey giveawayKey);
+  List<GiveawayKey> getGiveawayKeys(Long serverId, Boolean ignoreUsedFlag);
+}

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

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/listener/MuteModerationActionListener.java

@@ -15,10 +15,10 @@ import dev.sheldan.abstracto.moderation.model.interaction.ModerationActionMutePa
 import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionMuteModalModel;
 import dev.sheldan.abstracto.moderation.model.template.listener.ModerationActionPayloadModel;
 import dev.sheldan.abstracto.moderation.service.ModerationActionServiceBean;
-import jakarta.transaction.Transactional;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
 @Component
 @Slf4j

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

@@ -217,7 +217,7 @@ public class PurgeServiceBean implements PurgeService {
             }
             log.debug("Setting status for {} out of {}", currentCount, totalCount);
             MessageToSend finalUpdateMessage = getStatusMessageToSend(totalCount, channel.getGuild().getIdLong(), currentCount);
-            interactionService.editOriginal(finalUpdateMessage, interactionHook);
+            interactionService.replaceOriginal(finalUpdateMessage, interactionHook);
         };
     }
 
@@ -244,7 +244,7 @@ public class PurgeServiceBean implements PurgeService {
 
         CompletableFuture<MessageHistory> historyFuture = channelService.getHistoryOfChannel(channel, startId, toDeleteInThisIteration);
         MessageToSend statusMessageToSend = getStatusMessageToSend(totalCount, channel.getGuild().getIdLong(), 0);
-        CompletableFuture<Message> statusMessageFuture = interactionService.editOriginal(statusMessageToSend, interactionHook);
+        CompletableFuture<Message> statusMessageFuture = interactionService.replaceOriginal(statusMessageToSend, interactionHook);
 
         CompletableFuture<Void> deletionFuture = new CompletableFuture<>();
         CompletableFuture<Void> retrievalFuture = CompletableFuture.allOf(historyFuture, statusMessageFuture);

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

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