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

adding method for pinning a message
moving suggestion to correct deployment

abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/command/Remind.java

@@ -5,24 +5,32 @@ 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.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.core.utils.ParseUtils;
+import dev.sheldan.abstracto.core.utils.SnowflakeUtils;
 import dev.sheldan.abstracto.remind.config.RemindFeatureDefinition;
+import dev.sheldan.abstracto.remind.config.RemindSlashCommandNames;
 import dev.sheldan.abstracto.remind.model.database.Reminder;
 import dev.sheldan.abstracto.remind.model.template.commands.ReminderModel;
 import dev.sheldan.abstracto.remind.service.ReminderService;
 import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.time.Duration;
-import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
@@ -31,44 +39,107 @@ import java.util.concurrent.CompletableFuture;
 public class Remind extends AbstractConditionableCommand {
 
     public static final String REMINDER_EMBED_KEY = "remind_response";
+    public static final String DURATION_PARAMETER = "duration";
+    public static final String REMIND_TEXT_PARAMETER = "remindText";
 
     @Autowired
     private ReminderService remindService;
 
+    @Autowired
+    private TemplateService templateService;
+
     @Autowired
     private ChannelService channelService;
 
     @Autowired
     private UserInServerManagementService userInServerManagementService;
 
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private InteractionService interactionService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         Duration remindTime = (Duration) parameters.get(0);
         String text = (String) parameters.get(1);
+        Long serverId = commandContext.getGuild().getIdLong();
         AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
-        ReminderModel remindModel = (ReminderModel) ContextConverter.fromCommandContext(commandContext, ReminderModel.class);
-        remindModel.setRemindText(text);
         Reminder createdReminder = remindService.createReminderInForUser(aUserInAServer, text, remindTime, commandContext.getMessage());
+        ReminderModel remindModel = ReminderModel
+                .builder()
+                .remindText(text)
+                .member(commandContext.getAuthor())
+                .reminder(createdReminder)
+                .build();
         remindModel.setReminder(createdReminder);
 
         log.info("Notifying user {} about reminder being scheduled.", commandContext.getAuthor().getId());
-
-        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(REMINDER_EMBED_KEY, remindModel, commandContext.getChannel()))
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(REMINDER_EMBED_KEY, remindModel, serverId);
+        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String durationString = slashCommandParameterService.getCommandOption(DURATION_PARAMETER, event, Duration.class, String.class);
+        Duration duration = ParseUtils.parseDuration(durationString);
+        String reminderText = slashCommandParameterService.getCommandOption(REMIND_TEXT_PARAMETER, event, String.class, String.class);
+        Long serverId = event.getGuild().getIdLong();
+        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(event.getMember());
+        Long snowFlake = SnowflakeUtils.createSnowFlake();
+        Reminder createdReminder = remindService.createReminderInForUser(aUserInAServer, reminderText, duration, event.getChannel().getIdLong(), snowFlake);
+        ReminderModel remindModel = ReminderModel
+                .builder()
+                .remindText(reminderText)
+                .member(event.getMember())
+                .reminder(createdReminder)
+                .build();
+        remindModel.setReminder(createdReminder);
+
+        log.info("Notifying user {} about reminder being scheduled.", event.getMember().getId());
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(REMINDER_EMBED_KEY, remindModel, serverId);
+        return interactionService.replyMessageToSend(messageToSend, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
     @Override
     public CommandConfiguration getConfiguration() {
-        List<Parameter> parameters = new ArrayList<>();
-        parameters.add(Parameter.builder().name("duration").type(Duration.class).templated(true).build());
-        parameters.add(Parameter.builder().name("remindText").type(String.class).templated(true).remainder(true).build());
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).hasExample(true).build();
+        Parameter durationParameter = Parameter
+                .builder()
+                .name(DURATION_PARAMETER)
+                .type(Duration.class)
+                .templated(true)
+                .build();
+        Parameter remindTextParameter = Parameter
+                .builder()
+                .name(REMIND_TEXT_PARAMETER)
+                .type(String.class)
+                .templated(true)
+                .remainder(true)
+                .build();
+        List<Parameter> parameters = Arrays.asList(durationParameter, remindTextParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .hasExample(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(RemindSlashCommandNames.REMIND)
+                .commandName("create")
+                .build();
+
         return CommandConfiguration.builder()
                 .name("remind")
                 .async(true)
                 .module(UtilityModuleDefinition.UTILITY)
                 .templated(true)
+                .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .causesReaction(false)
                 .parameters(parameters)

abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/command/Reminders.java

@@ -4,26 +4,33 @@ 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.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.models.ServerChannelMessage;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.remind.config.RemindFeatureDefinition;
+import dev.sheldan.abstracto.remind.config.RemindSlashCommandNames;
 import dev.sheldan.abstracto.remind.model.database.Reminder;
 import dev.sheldan.abstracto.remind.model.template.commands.ReminderDisplay;
 import dev.sheldan.abstracto.remind.model.template.commands.RemindersModel;
 import dev.sheldan.abstracto.remind.service.management.ReminderManagementService;
 import lombok.extern.slf4j.Slf4j;
+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;
 
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
 
 @Component
 @Slf4j
@@ -39,38 +46,75 @@ public class Reminders extends AbstractConditionableCommand {
     @Autowired
     private UserInServerManagementService userInServerManagementService;
 
+    @Autowired
+    private TemplateService templateService;
+
+    @Autowired
+    private InteractionService interactionService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
+        Long serverId = commandContext.getGuild().getIdLong();
+        Member member = commandContext.getAuthor();
+        MessageToSend messageToSend = getMessageToSend(serverId, member);
+        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
+                .thenApply(aVoid -> CommandResult.fromIgnored());
+    }
+
+    private MessageToSend getMessageToSend(Long serverId, Member member) {
+        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(member);
         List<Reminder> activeReminders = reminderManagementService.getActiveRemindersForUser(aUserInAServer);
-        RemindersModel model = (RemindersModel) ContextConverter.fromCommandContext(commandContext, RemindersModel.class);
-        activeReminders.forEach(reminder -> {
+        List<ReminderDisplay> reminders = activeReminders.stream().map(reminder -> {
             ServerChannelMessage originMessage = ServerChannelMessage
                     .builder()
                     .messageId(reminder.getMessageId())
                     .channelId(reminder.getChannel().getId())
-                    .serverId(commandContext.getGuild().getIdLong())
+                    .serverId(serverId)
                     .build();
-            ReminderDisplay display = ReminderDisplay
+            return ReminderDisplay
                     .builder()
                     .reminder(reminder)
                     .message(originMessage)
                     .build();
-            model.getReminders().add(display);
-        });
-        log.info("Showing {} reminders for user {} in server {}.", activeReminders.size(), commandContext.getAuthor().getId(), commandContext.getGuild().getId());
-        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(REMINDERS_RESPONSE_TEMPLATE, model, commandContext.getChannel()))
-                .thenApply(aVoid -> CommandResult.fromIgnored());
+        }).collect(Collectors.toList());
+        RemindersModel model = RemindersModel
+                .builder()
+                .reminders(reminders)
+                .member(member)
+                .build();
+        log.info("Showing {} reminders for user {} in server {}.", activeReminders.size(), aUserInAServer.getUserReference().getId(), serverId);
+        return templateService.renderEmbedTemplate(REMINDERS_RESPONSE_TEMPLATE, model, serverId);
+    }
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        Long serverId = event.getGuild().getIdLong();
+        Member member = event.getMember();
+        MessageToSend messageToSend = getMessageToSend(serverId, member);
+        return interactionService.replyMessageToSend(messageToSend, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(RemindSlashCommandNames.REMIND)
+                .commandName("list")
+                .build();
+
         return CommandConfiguration.builder()
                 .name("reminders")
                 .async(true)
                 .module(UtilityModuleDefinition.UTILITY)
                 .templated(true)
+                .slashCommandConfig(slashCommandConfig)
                 .supportsEmbedException(true)
                 .causesReaction(true)
                 .help(helpInfo)

abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/command/Snooze.java

@@ -5,29 +5,47 @@ 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.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.core.utils.ParseUtils;
 import dev.sheldan.abstracto.remind.config.RemindFeatureDefinition;
+import dev.sheldan.abstracto.remind.config.RemindSlashCommandNames;
 import dev.sheldan.abstracto.remind.service.ReminderService;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.time.Duration;
-import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 
 @Component
 public class Snooze extends AbstractConditionableCommand {
 
+    private static final String SNOOZE_COMMAND = "snooze";
+    private static final String DURATION_PARAMETER = "duration";
+    private static final String REMINDER_ID_PARAMETER = "reminderId";
+    private static final String SNOOZE_RESPONSE = "snooze_response";
+
     @Autowired
     private ReminderService reminderService;
 
     @Autowired
     private UserInServerManagementService userInServerManagementService;
 
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         List<Object> newParameters = commandContext.getParameters().getParameters();
@@ -38,18 +56,51 @@ public class Snooze extends AbstractConditionableCommand {
         return CommandResult.fromSuccess();
     }
 
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        Long reminderId = slashCommandParameterService.getCommandOption(REMINDER_ID_PARAMETER, event, Long.class, Integer.class).longValue();
+        String newDurationString = slashCommandParameterService.getCommandOption(DURATION_PARAMETER, event, String.class, String.class);
+        Duration newDuration = ParseUtils.parseDuration(newDurationString);
+        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(event.getMember());
+        reminderService.snoozeReminder(reminderId, aUserInAServer, newDuration);
+        return interactionService.replyEmbed(SNOOZE_RESPONSE, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
     @Override
     public CommandConfiguration getConfiguration() {
-        List<Parameter> parameters = new ArrayList<>();
-        parameters.add(Parameter.builder().name("reminderId").type(Long.class).templated(true).build());
-        parameters.add(Parameter.builder().name("duration").type(Duration.class).templated(true).build());
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        Parameter reminderParameter = Parameter
+                .builder()
+                .name(REMINDER_ID_PARAMETER)
+                .type(Long.class)
+                .templated(true)
+                .build();
+        Parameter durationParameter = Parameter
+                .builder()
+                .name(DURATION_PARAMETER)
+                .type(Duration.class)
+                .templated(true)
+                .build();
+        List<Parameter> parameters = Arrays.asList(reminderParameter, durationParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(RemindSlashCommandNames.REMIND)
+                .commandName(SNOOZE_COMMAND)
+                .build();
+
         return CommandConfiguration.builder()
-                .name("snooze")
+                .name(SNOOZE_COMMAND)
                 .module(UtilityModuleDefinition.UTILITY)
                 .templated(true)
                 .supportsEmbedException(true)
                 .causesReaction(true)
+                .slashCommandConfig(slashCommandConfig)
                 .parameters(parameters)
                 .help(helpInfo)
                 .build();

abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/command/UnRemind.java

@@ -2,35 +2,45 @@ package dev.sheldan.abstracto.remind.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.ParameterValidator;
-import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValidator;
+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.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.remind.config.RemindFeatureDefinition;
+import dev.sheldan.abstracto.remind.config.RemindSlashCommandNames;
 import dev.sheldan.abstracto.remind.service.ReminderService;
 import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 
 @Slf4j
 @Component
 public class UnRemind extends AbstractConditionableCommand {
 
+    private static final String UN_REMIND_COMMAND = "unRemind";
+    private static final String REMINDER_ID_PARAMETER = "reminderId";
+    private static final String UN_REMIND_RESPONSE = "unRemind_response";
+
     @Autowired
     private ReminderService reminderService;
 
     @Autowired
     private UserInServerManagementService userInServerManagementService;
 
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private InteractionService interactionService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         Long reminderId = (Long) commandContext.getParameters().getParameters().get(0);
@@ -38,17 +48,41 @@ public class UnRemind extends AbstractConditionableCommand {
         return CommandResult.fromSuccess();
     }
 
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        Long reminderId = slashCommandParameterService.getCommandOption(REMINDER_ID_PARAMETER, event, Long.class, Integer.class).longValue();
+        reminderService.unRemind(reminderId, userInServerManagementService.loadOrCreateUser(event.getMember()));
+        return interactionService.replyEmbed(UN_REMIND_RESPONSE, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
     @Override
     public CommandConfiguration getConfiguration() {
-        List<Parameter> parameters = new ArrayList<>();
-        List<ParameterValidator> reminderIdValidator = Arrays.asList(MinIntegerValueValidator.min(1L));
-        parameters.add(Parameter.builder().name("reminderId").validators(reminderIdValidator).templated(true).type(Long.class).build());
-        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        Parameter reminderParameter = Parameter
+                .builder()
+                .name(REMINDER_ID_PARAMETER)
+                .templated(true)
+                .type(Long.class)
+                .build();
+        List<Parameter> parameters = Arrays.asList(reminderParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(RemindSlashCommandNames.REMIND)
+                .commandName("cancel")
+                .build();
+
         return CommandConfiguration.builder()
-                .name("unRemind")
+                .name(UN_REMIND_COMMAND)
                 .module(UtilityModuleDefinition.UTILITY)
                 .templated(true)
                 .supportsEmbedException(true)
+                .slashCommandConfig(slashCommandConfig)
                 .causesReaction(true)
                 .parameters(parameters)
                 .help(helpInfo)

abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/service/RemindServiceBean.java

@@ -92,6 +92,11 @@ public class RemindServiceBean implements ReminderService {
         return reminder;
     }
 
+    @Override
+    public Reminder createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, Long channelId) {
+        return createReminderInForUser(user, remindText, remindIn, channelId, null);
+    }
+
     private void scheduleReminder(Duration remindIn, Reminder reminder) {
         if(remindIn.getSeconds() < 60) {
             reminder.setJobTriggerKey(null);

abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/service/management/ReminderManagementServiceBean.java

@@ -38,6 +38,11 @@ public class ReminderManagementServiceBean implements ReminderManagementService
         return reminderRepository.save(reminder);
     }
 
+    @Override
+    public Reminder createReminder(AServerAChannelAUser userToBeReminded, String text, Instant timeToBeRemindedAt) {
+        return null;
+    }
+
     @Override
     public Optional<Reminder> loadReminderOptional(Long reminderId) {
         return reminderRepository.findById(reminderId);

abstracto-application/abstracto-modules/remind/remind-impl/src/test/java/dev/sheldan/abstracto/remind/command/RemindTest.java

@@ -1,63 +0,0 @@
-package dev.sheldan.abstracto.remind.command;
-
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.models.database.AUserInAServer;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
-import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
-import dev.sheldan.abstracto.remind.model.template.commands.ReminderModel;
-import dev.sheldan.abstracto.remind.service.ReminderService;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.*;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.time.Duration;
-import java.util.Arrays;
-import java.util.concurrent.CompletableFuture;
-
-import static org.mockito.Mockito.*;
-
-@RunWith(MockitoJUnitRunner.class)
-public class RemindTest {
-
-    @InjectMocks
-    private Remind testUnit;
-
-    @Mock
-    private ReminderService remindService;
-
-    @Mock
-    private ChannelService channelService;
-
-    @Mock
-    private UserInServerManagementService userInServerManagementService;
-
-    @Captor
-    private ArgumentCaptor<ReminderModel> captor;
-
-    @Test
-    public void executeCommand() {
-        String reminderText = "text";
-        Duration duration = Duration.ofMinutes(10);
-        CommandContext withParameters = CommandTestUtilities.getWithParameters(Arrays.asList(duration, reminderText));
-        AUserInAServer user = Mockito.mock(AUserInAServer.class);
-        when(userInServerManagementService.loadOrCreateUser(withParameters.getAuthor())).thenReturn(user);
-        CompletableFuture<CommandResult> result = testUnit.executeAsync(withParameters);
-        verify(remindService, times(1)).createReminderInForUser(user, reminderText, duration, withParameters.getMessage());
-        verify(channelService, times(1)).sendEmbedTemplateInTextChannelList(eq(Remind.REMINDER_EMBED_KEY), captor.capture(), eq(withParameters.getChannel()));
-        ReminderModel reminderModel = captor.getValue();
-        Assert.assertEquals(reminderText, reminderModel.getRemindText());
-        Assert.assertEquals(withParameters.getMessage(), reminderModel.getMessage());
-        CommandTestUtilities.checkSuccessfulCompletionAsync(result);
-    }
-
-    @Test
-    public void validateCommand() {
-        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
-    }
-
-}

abstracto-application/abstracto-modules/remind/remind-impl/src/test/java/dev/sheldan/abstracto/remind/command/RemindersTest.java

@@ -1,72 +0,0 @@
-package dev.sheldan.abstracto.remind.command;
-
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.models.database.AChannel;
-import dev.sheldan.abstracto.core.models.database.AServer;
-import dev.sheldan.abstracto.core.models.database.AUserInAServer;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
-import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
-import dev.sheldan.abstracto.remind.model.database.Reminder;
-import dev.sheldan.abstracto.remind.model.template.commands.RemindersModel;
-import dev.sheldan.abstracto.remind.service.management.ReminderManagementService;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.*;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-
-import static org.mockito.Mockito.*;
-
-@RunWith(MockitoJUnitRunner.class)
-public class RemindersTest {
-
-    @InjectMocks
-    private Reminders testUnit;
-
-    @Mock
-    private ReminderManagementService reminderManagementService;
-
-    @Mock
-    private ChannelService channelService;
-
-    @Mock
-    private UserInServerManagementService userInServerManagementService;
-
-    @Mock
-    private AChannel channel;
-
-    @Captor
-    private ArgumentCaptor<RemindersModel> modelCaptor;
-
-    @Test
-    public void testExecuteCommand() {
-        CommandContext context = CommandTestUtilities.getNoParameters();
-        Reminder reminder = Mockito.mock(Reminder.class);
-        when(reminder.getChannel()).thenReturn(channel);
-        Reminder secondReminder = Mockito.mock(Reminder.class);
-        when(secondReminder.getChannel()).thenReturn(channel);
-        List<Reminder> reminders = Arrays.asList(reminder, secondReminder);
-        AUserInAServer user = Mockito.mock(AUserInAServer.class);
-        when(userInServerManagementService.loadOrCreateUser(context.getAuthor())).thenReturn(user);
-        when(reminderManagementService.getActiveRemindersForUser(user)).thenReturn(reminders);
-        CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
-        verify(channelService, times(1)).sendEmbedTemplateInTextChannelList(eq(Reminders.REMINDERS_RESPONSE_TEMPLATE), modelCaptor.capture(), eq(context.getChannel()));
-        RemindersModel usedModel = modelCaptor.getValue();
-        Assert.assertEquals(reminder, usedModel.getReminders().get(0).getReminder());
-        Assert.assertEquals(secondReminder, usedModel.getReminders().get(1).getReminder());
-        Assert.assertEquals(reminders.size(), usedModel.getReminders().size());
-        CommandTestUtilities.checkSuccessfulCompletionAsync(result);
-    }
-
-    @Test
-    public void validateCommand() {
-        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
-    }
-}