[AB-365] introducing slash commands for a selection of commands

adding method for pinning a message moving suggestion to correct deployment
2026-01-27 06:04:54 +00:00 · 2022-05-17 00:39:06 +02:00
parent 1913bc930d
commit 1d6de3f1e8
286 changed files with 8021 additions and 3065 deletions
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Choose.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Choose.java
@@ -4,16 +4,21 @@ 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.SlashCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.command.execution.ContextConverter;
+import dev.sheldan.abstracto.core.command.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
 import dev.sheldan.abstracto.entertainment.model.command.ChooseResponseModel;
 import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

@@ -25,30 +30,81 @@ import java.util.concurrent.CompletableFuture;
 public class Choose extends AbstractConditionableCommand {

    public static final String CHOOSE_RESPONSE_TEMPLATE_KEY = "choose_response";
+    private static final String CHOOSE_COMMAND = "choose";
+    private static final String TEXT_PARAMETER = "text";
+    private static final int CHOICES_SIZE = 5;
+
    @Autowired
    private EntertainmentService entertainmentService;

    @Autowired
    private ChannelService channelService;

+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private InteractionService interactionService;
+
    @Override
    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
        List<String> choices = (List) commandContext.getParameters().getParameters().get(0);
        String choice = entertainmentService.takeChoice(choices, commandContext.getAuthor());
-        ChooseResponseModel responseModel = (ChooseResponseModel) ContextConverter.slimFromCommandContext(commandContext, ChooseResponseModel.class);
-        responseModel.setChosenValue(choice);
+        ChooseResponseModel responseModel = ChooseResponseModel
+                .builder()
+                .chosenValue(choice)
+                .build();
        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(CHOOSE_RESPONSE_TEMPLATE_KEY, responseModel, commandContext.getChannel()))
            .thenApply(unused -> CommandResult.fromIgnored());
    }

+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        List<String> choices = new ArrayList<>();
+        for (int i = 0; i < CHOICES_SIZE; i++) {
+            if(slashCommandParameterService.hasCommandOption(TEXT_PARAMETER + "_" + i, event)) {
+                String choice = slashCommandParameterService.getCommandOption(TEXT_PARAMETER + "_" + i, event, String.class);
+                choices.add(choice);
+            }
+        }
+        String choice = entertainmentService.takeChoice(choices, event.getMember());
+        ChooseResponseModel responseModel = ChooseResponseModel
+                .builder()
+                .chosenValue(choice)
+                .build();
+        return interactionService.replyEmbed(CHOOSE_RESPONSE_TEMPLATE_KEY, responseModel, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
    @Override
    public CommandConfiguration getConfiguration() {
        List<Parameter> parameters = new ArrayList<>();
-        parameters.add(Parameter.builder().name("text").type(String.class).templated(true).remainder(true).isListParam(true).build());
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        Parameter textParameter = Parameter
+                .builder()
+                .name(TEXT_PARAMETER)
+                .type(String.class)
+                .templated(true)
+                .remainder(true)
+                .listSize(CHOICES_SIZE)
+                .isListParam(true)
+                .build();
+        parameters.add(textParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
+                .commandName(CHOOSE_COMMAND)
+                .build();
+
        return CommandConfiguration.builder()
-                .name("choose")
+                .name(CHOOSE_COMMAND)
                .async(true)
+                .slashCommandConfig(slashCommandConfig)
                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                .templated(true)
                .supportsEmbedException(true)
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/EightBall.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/EightBall.java
@@ -4,17 +4,23 @@ 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.SlashCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.command.execution.ContextConverter;
+import dev.sheldan.abstracto.core.command.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
 import dev.sheldan.abstracto.entertainment.model.command.EightBallResponseModel;
 import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

@@ -26,6 +32,8 @@ import java.util.concurrent.CompletableFuture;
 public class EightBall extends AbstractConditionableCommand {

    public static final String EIGHT_BALL_RESPONSE_TEMPLATE_KEY = "eight_ball_response";
+    public static final String BALL_COMMAND = "8Ball";
+    public static final String TEXT_PARAMETER = "text";
    @Autowired
    private EntertainmentService entertainmentService;

@@ -35,24 +43,65 @@ public class EightBall extends AbstractConditionableCommand {
    @Autowired
    private ChannelService channelService;

+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private InteractionService interactionService;
+
    @Override
    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
        String text = (String) commandContext.getParameters().getParameters().get(0);
-        String chosenKey = entertainmentService.getEightBallValue(text);
-        EightBallResponseModel responseModel = (EightBallResponseModel) ContextConverter.slimFromCommandContext(commandContext, EightBallResponseModel.class);
-        responseModel.setChosenKey(chosenKey);
-        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(EIGHT_BALL_RESPONSE_TEMPLATE_KEY, responseModel, commandContext.getChannel()))
+        MessageToSend messageToSend = getMessageToSend(text, commandContext.getGuild().getIdLong());
+        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
                .thenApply(unused -> CommandResult.fromIgnored());
    }

+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String text = slashCommandParameterService.getCommandOption(TEXT_PARAMETER, event, String.class);
+        MessageToSend messageToSend = getMessageToSend(text, event.getGuild().getIdLong());
+        return interactionService.replyMessageToSend(messageToSend, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    private MessageToSend getMessageToSend(String text, Long serverId) {
+        String chosenKey = entertainmentService.getEightBallValue(text);
+        EightBallResponseModel responseModel = EightBallResponseModel
+                .builder()
+                .chosenKey(chosenKey)
+                .build();
+        return templateService.renderEmbedTemplate(EIGHT_BALL_RESPONSE_TEMPLATE_KEY, responseModel, serverId);
+    }
+
    @Override
    public CommandConfiguration getConfiguration() {
        List<Parameter> parameters = new ArrayList<>();
-        parameters.add(Parameter.builder().name("text").type(String.class).templated(true).remainder(true).build());
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        Parameter textParameter = Parameter
+                .builder()
+                .name(TEXT_PARAMETER)
+                .type(String.class)
+                .templated(true)
+                .remainder(true)
+                .build();
+        parameters.add(textParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
+                .commandName(BALL_COMMAND)
+                .build();
+
        return CommandConfiguration.builder()
-                .name("8Ball")
+                .name(BALL_COMMAND)
                .async(true)
+                .slashCommandConfig(slashCommandConfig)
                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                .templated(true)
                .supportsEmbedException(true)
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/LoveCalc.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/LoveCalc.java
@@ -4,16 +4,23 @@ 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.SlashCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.command.execution.ContextConverter;
+import dev.sheldan.abstracto.core.command.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
 import dev.sheldan.abstracto.entertainment.model.command.LoveCalcResponseModel;
 import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

@@ -25,6 +32,9 @@ import java.util.concurrent.CompletableFuture;
 public class LoveCalc extends AbstractConditionableCommand {

    public static final String LOVE_CALC_RESPONSE_TEMPLATE_KEY = "loveCalc_response";
+    public static final String FIRST_SUBJECT_PARAMETER = "firstSubject";
+    public static final String SECOND_SUBJECT_PARAMETER = "secondSubject";
+    public static final String LOVE_CALC_COMMAND = "loveCalc";

    @Autowired
    private ChannelService channelService;
@@ -32,28 +42,77 @@ public class LoveCalc extends AbstractConditionableCommand {
    @Autowired
    private EntertainmentService entertainmentService;

+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private TemplateService templateService;
+
    @Override
    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
        List<Object> parameters = commandContext.getParameters().getParameters();
        String firstPart = (String) parameters.get(0);
        String secondPart = (String) parameters.get(1);
-        Integer rolled = entertainmentService.getLoveCalcValue(firstPart, secondPart);
-        LoveCalcResponseModel model = (LoveCalcResponseModel) ContextConverter.slimFromCommandContext(commandContext, LoveCalcResponseModel.class);
-        model.setRolled(rolled);
-        model.setFirstPart(firstPart);
-        model.setSecondPart(secondPart);
-        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(LOVE_CALC_RESPONSE_TEMPLATE_KEY, model, commandContext.getChannel()))
+        MessageToSend messageToSend = getMessageToSend(commandContext.getGuild().getIdLong(), firstPart, secondPart);
+        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
                .thenApply(unused -> CommandResult.fromSuccess());
    }

+    @Override
+    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);
+        return interactionService.replyMessageToSend(messageToSend, event.getInteraction())
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    private MessageToSend getMessageToSend(Long serverId, String firstPart, String secondPart) {
+        Integer rolled = entertainmentService.getLoveCalcValue(firstPart, secondPart);
+        LoveCalcResponseModel model = LoveCalcResponseModel
+                .builder()
+                .rolled(rolled)
+                .firstPart(firstPart)
+                .secondPart(secondPart)
+                .build();
+        return templateService.renderEmbedTemplate(LOVE_CALC_RESPONSE_TEMPLATE_KEY, model, serverId);
+    }
+
    @Override
    public CommandConfiguration getConfiguration() {
        List<Parameter> parameters = new ArrayList<>();
-        parameters.add(Parameter.builder().name("firstSubject").type(String.class).templated(true).build());
-        parameters.add(Parameter.builder().name("secondSubject").type(String.class).templated(true).build());
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        Parameter firstSubjectParameter = Parameter
+                .builder()
+                .name(FIRST_SUBJECT_PARAMETER)
+                .type(String.class)
+                .templated(true)
+                .build();
+        parameters.add(firstSubjectParameter);
+        Parameter secondSubjectParameter = Parameter
+                .builder()
+                .name(SECOND_SUBJECT_PARAMETER)
+                .type(String.class)
+                .templated(true)
+                .build();
+        parameters.add(secondSubjectParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
+                .commandName(LOVE_CALC_COMMAND)
+                .build();
+
        return CommandConfiguration.builder()
-                .name("loveCalc")
+                .name(LOVE_CALC_COMMAND)
+                .slashCommandConfig(slashCommandConfig)
                .async(true)
                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                .templated(true)
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Roll.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Roll.java
@@ -4,19 +4,23 @@ 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.SlashCommandConfig;
 import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValidator;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.command.execution.ContextConverter;
+import dev.sheldan.abstracto.core.command.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.ConfigService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureConfig;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
 import dev.sheldan.abstracto.entertainment.model.command.RollResponseModel;
 import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

@@ -29,6 +33,9 @@ import java.util.concurrent.CompletableFuture;
 public class Roll extends AbstractConditionableCommand {

    public static final String ROLL_RESPONSE_TEMPLATE_KEY = "roll_response";
+    private static final String ROLL_COMMAND = "roll";
+    private static final String LOW_PARAMETER = "low";
+    private static final String HIGH_PARAMETER = "high";

    @Autowired
    private ChannelService channelService;
@@ -39,6 +46,12 @@ public class Roll extends AbstractConditionableCommand {
    @Autowired
    private ConfigService configService;

+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private InteractionService interactionService;
+
    @Override
    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
        List<Object> parameters = commandContext.getParameters().getParameters();
@@ -52,20 +65,73 @@ public class Roll extends AbstractConditionableCommand {
        }

        Integer rolled = entertainmentService.calculateRollResult(low, high);
-        RollResponseModel model = (RollResponseModel) ContextConverter.slimFromCommandContext(commandContext, RollResponseModel.class);
-        model.setRolled(rolled);
+        RollResponseModel model = RollResponseModel
+                .builder()
+                .rolled(rolled)
+                .build();
        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(ROLL_RESPONSE_TEMPLATE_KEY, model, commandContext.getChannel()))
                .thenApply(unused -> CommandResult.fromIgnored());
    }

+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        Integer low;
+        if(slashCommandParameterService.hasCommandOption(LOW_PARAMETER, event)) {
+            low = slashCommandParameterService.getCommandOption(LOW_PARAMETER, event, Integer.class);
+        } else {
+            low = 1;
+        }
+        Integer high;
+        if(slashCommandParameterService.hasCommandOption(HIGH_PARAMETER, event)) {
+            high = slashCommandParameterService.getCommandOption(HIGH_PARAMETER, event, Integer.class);
+        } else {
+            high = configService.getLongValueOrConfigDefault(EntertainmentFeatureConfig.ROLL_DEFAULT_HIGH_KEY, event.getGuild().getIdLong()).intValue();
+        }
+        Integer rolled = entertainmentService.calculateRollResult(low, high);
+        RollResponseModel model = RollResponseModel
+                .builder()
+                .rolled(rolled)
+                .build();
+        return interactionService.replyEmbed(ROLL_RESPONSE_TEMPLATE_KEY, model, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
    @Override
    public CommandConfiguration getConfiguration() {
        List<Parameter> parameters = new ArrayList<>();
-        parameters.add(Parameter.builder().name("high").type(Integer.class).templated(true).validators(Arrays.asList(MinIntegerValueValidator.min(2L))).optional(true).build());
-        parameters.add(Parameter.builder().name("low").type(Integer.class).templated(true).validators(Arrays.asList(MinIntegerValueValidator.min(0L))).optional(true).build());
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        Parameter highParameter = Parameter
+                .builder()
+                .name(HIGH_PARAMETER)
+                .type(Integer.class)
+                .templated(true)
+                .validators(Arrays.asList(MinIntegerValueValidator.min(2L)))
+                .optional(true)
+                .build();
+        parameters.add(highParameter);
+        Parameter lowParameter = Parameter
+                .builder()
+                .name(LOW_PARAMETER)
+                .type(Integer.class)
+                .templated(true)
+                .validators(Arrays.asList(MinIntegerValueValidator.min(0L)))
+                .optional(true)
+                .build();
+        parameters.add(lowParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
+                .commandName(ROLL_COMMAND)
+                .build();
+
        return CommandConfiguration.builder()
-                .name("roll")
+                .name(ROLL_COMMAND)
+                .slashCommandConfig(slashCommandConfig)
                .async(true)
                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                .templated(true)
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Roulette.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Roulette.java
@@ -4,16 +4,19 @@ 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.SlashCommandConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.command.execution.ContextConverter;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
 import dev.sheldan.abstracto.entertainment.model.command.RouletteResponseModel;
 import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

@@ -25,28 +28,57 @@ import java.util.concurrent.CompletableFuture;
 public class Roulette extends AbstractConditionableCommand {

    public static final String ROULETTE_RESPONSE_TEMPLATE_KEY = "roulette_response";
+    public static final String ROULETTE_COMMAND = "roulette";
    @Autowired
    private ChannelService channelService;

    @Autowired
    private EntertainmentService entertainmentService;

+    @Autowired
+    private InteractionService interactionService;
+
    @Override
    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
        boolean rouletteResult = entertainmentService.executeRoulette(commandContext.getAuthor());
-        RouletteResponseModel responseModel = (RouletteResponseModel) ContextConverter.slimFromCommandContext(commandContext, RouletteResponseModel.class);
-        responseModel.setResult(rouletteResult);
+        RouletteResponseModel responseModel = RouletteResponseModel
+                .builder()
+                .result(rouletteResult)
+                .build();
        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(ROULETTE_RESPONSE_TEMPLATE_KEY, responseModel, commandContext.getChannel()))
                .thenApply(unused -> CommandResult.fromIgnored());
    }

+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        boolean rouletteResult = entertainmentService.executeRoulette(event.getMember());
+        RouletteResponseModel responseModel = RouletteResponseModel
+                .builder()
+                .result(rouletteResult)
+                .build();
+        return interactionService.replyEmbed(ROULETTE_RESPONSE_TEMPLATE_KEY, responseModel, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
    @Override
    public CommandConfiguration getConfiguration() {
        List<Parameter> parameters = new ArrayList<>();
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(EntertainmentSlashCommandNames.UTILITY)
+                .commandName(ROULETTE_COMMAND)
+                .build();
+
        return CommandConfiguration.builder()
-                .name("roulette")
+                .name(ROULETTE_COMMAND)
                .async(true)
+                .slashCommandConfig(slashCommandConfig)
                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                .templated(true)
                .supportsEmbedException(true)
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/ChooseTest.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/ChooseTest.java
@@ -1,56 +0,0 @@
-package dev.sheldan.abstracto.entertainment.command;
-
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
-import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
-import dev.sheldan.abstracto.entertainment.model.command.ChooseResponseModel;
-import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class ChooseTest {
-
-    @InjectMocks
-    private Choose testUnit;
-
-    @Mock
-    private EntertainmentService entertainmentService;
-
-    @Mock
-    private ChannelService channelService;
-
-    @Captor
-    private ArgumentCaptor<ChooseResponseModel> responseModelArgumentCaptor;
-
-    @Test
-    public void executeChooseCommand() {
-        List<String> choices = Arrays.asList("choice1", "choice2");
-        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(choices));
-        when(entertainmentService.takeChoice(choices, parameters.getAuthor())).thenReturn(choices.get(0));
-        when(channelService.sendEmbedTemplateInTextChannelList(eq(Choose.CHOOSE_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(parameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
-        CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
-        CommandTestUtilities.checkSuccessfulCompletionAsync(result);
-        Assert.assertEquals(choices.get(0), responseModelArgumentCaptor.getValue().getChosenValue());
-    }
-
-    @Test
-    public void validateCommand() {
-        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
-    }
-}
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/EightBallTest.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/EightBallTest.java
@@ -1,57 +0,0 @@
-package dev.sheldan.abstracto.entertainment.command;
-
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
-import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
-import dev.sheldan.abstracto.entertainment.model.command.EightBallResponseModel;
-import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.concurrent.CompletableFuture;
-
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class EightBallTest {
-
-    @InjectMocks
-    private EightBall testUnit;
-
-    @Mock
-    private EntertainmentService entertainmentService;
-
-    @Mock
-    private ChannelService channelService;
-
-    @Captor
-    private ArgumentCaptor<EightBallResponseModel> responseModelArgumentCaptor;
-
-    @Test
-    public void execute8BallCommand() {
-        String inputText = "text";
-        String chosenKey = "key";
-        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(inputText));
-        when(entertainmentService.getEightBallValue(inputText)).thenReturn(chosenKey);
-        when(channelService.sendEmbedTemplateInTextChannelList(eq(EightBall.EIGHT_BALL_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(parameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
-        CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
-        CommandTestUtilities.checkSuccessfulCompletionAsync(result);
-        Assert.assertEquals(chosenKey, responseModelArgumentCaptor.getValue().getChosenKey());
-    }
-
-    @Test
-    public void validateCommand() {
-        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
-    }
-
-}
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/LoveCalcTest.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/LoveCalcTest.java
@@ -1,61 +0,0 @@
-package dev.sheldan.abstracto.entertainment.command;
-
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
-import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
-import dev.sheldan.abstracto.entertainment.model.command.LoveCalcResponseModel;
-import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.concurrent.CompletableFuture;
-
-import static dev.sheldan.abstracto.entertainment.command.LoveCalc.LOVE_CALC_RESPONSE_TEMPLATE_KEY;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class LoveCalcTest {
-
-    @InjectMocks
-    private LoveCalc testUnit;
-
-    @Mock
-    private EntertainmentService entertainmentService;
-
-    @Mock
-    private ChannelService channelService;
-
-    @Captor
-    private ArgumentCaptor<LoveCalcResponseModel> responseModelArgumentCaptor;
-
-    @Test
-    public void execute8BallCommand() {
-        String inputText = "text";
-        String inputText2 = "text2";
-        Integer loveResult = 2;
-        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(inputText, inputText2));
-        when(entertainmentService.getLoveCalcValue(inputText, inputText2)).thenReturn(loveResult);
-        when(channelService.sendEmbedTemplateInTextChannelList(eq(LOVE_CALC_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(parameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
-        CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
-        CommandTestUtilities.checkSuccessfulCompletionAsync(result);
-        Assert.assertEquals(loveResult, responseModelArgumentCaptor.getValue().getRolled());
-        Assert.assertEquals(inputText, responseModelArgumentCaptor.getValue().getFirstPart());
-        Assert.assertEquals(inputText2, responseModelArgumentCaptor.getValue().getSecondPart());
-    }
-
-    @Test
-    public void validateCommand() {
-        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
-    }
-
-}
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/RollTest.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/RollTest.java
@@ -1,87 +0,0 @@
-package dev.sheldan.abstracto.entertainment.command;
-
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.service.ConfigService;
-import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
-import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
-import dev.sheldan.abstracto.entertainment.model.command.RollResponseModel;
-import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.concurrent.CompletableFuture;
-
-import static dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureConfig.ROLL_DEFAULT_HIGH_KEY;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class RollTest {
-
-    @InjectMocks
-    private Roll testUnit;
-
-    @Mock
-    private EntertainmentService entertainmentService;
-
-    @Mock
-    private ChannelService channelService;
-
-    @Mock
-    private ConfigService configService;
-
-    @Captor
-    private ArgumentCaptor<RollResponseModel> responseModelArgumentCaptor;
-
-    @Test
-    public void executeWithNoParameter() {
-        CommandContext noParameters = CommandTestUtilities.getNoParameters();
-        Integer result = 4;
-        Long serverId = 3L;
-        Integer max = 10;
-        when(noParameters.getGuild().getIdLong()).thenReturn(serverId);
-        when(configService.getLongValueOrConfigDefault(ROLL_DEFAULT_HIGH_KEY, serverId)).thenReturn(max.longValue());
-        when(entertainmentService.calculateRollResult(1, max)).thenReturn(result);
-        when(channelService.sendEmbedTemplateInTextChannelList(eq(Roll.ROLL_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
-        CompletableFuture<CommandResult> futureResult = testUnit.executeAsync(noParameters);
-        CommandTestUtilities.checkSuccessfulCompletionAsync(futureResult);
-        Assert.assertEquals(4, responseModelArgumentCaptor.getValue().getRolled().intValue());
-    }
-
-    @Test
-    public void executeWithHighParameter() {
-        CommandContext noParameters = CommandTestUtilities.getWithParameters(Arrays.asList(20));
-        Integer result = 4;
-        when(entertainmentService.calculateRollResult(1, 20)).thenReturn(result);
-        when(channelService.sendEmbedTemplateInTextChannelList(eq(Roll.ROLL_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
-        CompletableFuture<CommandResult> futureResult = testUnit.executeAsync(noParameters);
-        CommandTestUtilities.checkSuccessfulCompletionAsync(futureResult);
-        Assert.assertEquals(4, responseModelArgumentCaptor.getValue().getRolled().intValue());
-    }
-
-    @Test
-    public void executeWithBothParameters() {
-        CommandContext noParameters = CommandTestUtilities.getWithParameters(Arrays.asList(20, 10));
-        Integer result = 4;
-        when(entertainmentService.calculateRollResult(10, 20)).thenReturn(result);
-        when(channelService.sendEmbedTemplateInTextChannelList(eq(Roll.ROLL_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
-        CompletableFuture<CommandResult> futureResult = testUnit.executeAsync(noParameters);
-        CommandTestUtilities.checkSuccessfulCompletionAsync(futureResult);
-        Assert.assertEquals(4, responseModelArgumentCaptor.getValue().getRolled().intValue());
-    }
-
-    @Test
-    public void validateCommand() {
-        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
-    }
-
-}
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/RouletteTest.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/RouletteTest.java
@@ -1,55 +0,0 @@
-package dev.sheldan.abstracto.entertainment.command;
-
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
-import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
-import dev.sheldan.abstracto.entertainment.model.command.RouletteResponseModel;
-import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.concurrent.CompletableFuture;
-
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class RouletteTest {
-
-    @InjectMocks
-    private Roulette testUnit;
-
-    @Mock
-    private EntertainmentService entertainmentService;
-
-    @Mock
-    private ChannelService channelService;
-
-    @Captor
-    private ArgumentCaptor<RouletteResponseModel> responseModelArgumentCaptor;
-
-    @Test
-    public void executeWithNoParameter() {
-        CommandContext noParameters = CommandTestUtilities.getNoParameters();
-        Boolean result = false;
-        when(entertainmentService.executeRoulette(noParameters.getAuthor())).thenReturn(result);
-        when(channelService.sendEmbedTemplateInTextChannelList(eq(Roulette.ROULETTE_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
-        CompletableFuture<CommandResult> futureResult = testUnit.executeAsync(noParameters);
-        CommandTestUtilities.checkSuccessfulCompletionAsync(futureResult);
-        Assert.assertEquals(result, responseModelArgumentCaptor.getValue().getResult());
-    }
-
-    @Test
-    public void validateCommand() {
-        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
-    }
-
-}
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/config/EntertainmentSlashCommandNames.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/config/EntertainmentSlashCommandNames.java
@@ -0,0 +1,6 @@
+package dev.sheldan.abstracto.entertainment.config;
+
+public class EntertainmentSlashCommandNames {
+    public static final String ENTERTAINMENT = "entertainment";
+    public static final String UTILITY = "utility";
+}
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/ChooseResponseModel.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/ChooseResponseModel.java
@@ -1,13 +1,12 @@
 package dev.sheldan.abstracto.entertainment.model.command;

-import dev.sheldan.abstracto.core.models.context.SlimUserInitiatedServerContext;
+import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
-import lombok.experimental.SuperBuilder;

@Getter
@Setter
-@SuperBuilder
-public class ChooseResponseModel extends SlimUserInitiatedServerContext {
+@Builder
+public class ChooseResponseModel {
    private String chosenValue;
 }
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/EightBallResponseModel.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/EightBallResponseModel.java
@@ -1,13 +1,12 @@
 package dev.sheldan.abstracto.entertainment.model.command;

-import dev.sheldan.abstracto.core.models.context.SlimUserInitiatedServerContext;
+import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
-import lombok.experimental.SuperBuilder;

@Getter
@Setter
-@SuperBuilder
-public class EightBallResponseModel extends SlimUserInitiatedServerContext {
+@Builder
+public class EightBallResponseModel {
    private String chosenKey;
 }
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/LoveCalcResponseModel.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/LoveCalcResponseModel.java
@@ -1,14 +1,13 @@
 package dev.sheldan.abstracto.entertainment.model.command;

-import dev.sheldan.abstracto.core.models.context.SlimUserInitiatedServerContext;
+import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
-import lombok.experimental.SuperBuilder;

@Getter
@Setter
-@SuperBuilder
-public class LoveCalcResponseModel extends SlimUserInitiatedServerContext {
+@Builder
+public class LoveCalcResponseModel {
    private String firstPart;
    private String secondPart;
    private Integer rolled;
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/RollResponseModel.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/RollResponseModel.java
@@ -1,13 +1,12 @@
 package dev.sheldan.abstracto.entertainment.model.command;

-import dev.sheldan.abstracto.core.models.context.SlimUserInitiatedServerContext;
+import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
-import lombok.experimental.SuperBuilder;

@Getter
@Setter
-@SuperBuilder
-public class RollResponseModel extends SlimUserInitiatedServerContext {
+@Builder
+public class RollResponseModel {
    private Integer rolled;
 }
--- a/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/RouletteResponseModel.java
+++ b/abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/RouletteResponseModel.java
@@ -1,13 +1,12 @@
 package dev.sheldan.abstracto.entertainment.model.command;

-import dev.sheldan.abstracto.core.models.context.SlimUserInitiatedServerContext;
+import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
-import lombok.experimental.SuperBuilder;

@Getter
@Setter
-@SuperBuilder
-public class RouletteResponseModel extends SlimUserInitiatedServerContext {
+@Builder
+public class RouletteResponseModel {
    private Boolean result;
 }