[AB-xxx] adding support for user installable apps to varying commands

2026-04-14 03:45:57 +00:00 · 2024-04-02 23:48:27 +02:00
parent cd3378df32
commit 732535850b
98 changed files with 1184 additions and 773 deletions
--- a/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/command/Remind.java
+++ b/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/command/Remind.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.interaction.ComponentPayloadService;
 import dev.sheldan.abstracto.core.interaction.ComponentService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
@@ -14,12 +15,17 @@ import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParame
 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.AServer;
+import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
-import dev.sheldan.abstracto.core.models.template.display.MemberNameDisplay;
+import dev.sheldan.abstracto.core.models.template.display.UserDisplay;
 import dev.sheldan.abstracto.core.service.ChannelService;
+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.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.core.utils.ParseUtils;
 import dev.sheldan.abstracto.core.utils.SnowflakeUtils;
@@ -73,6 +79,12 @@ public class Remind extends AbstractConditionableCommand {
    @Autowired
    private ComponentPayloadService componentPayloadService;

+    @Autowired
+    private UserManagementService userManagementService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
    @Override
    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
        List<Object> parameters = commandContext.getParameters().getParameters();
@@ -88,7 +100,7 @@ public class Remind extends AbstractConditionableCommand {
        ReminderModel remindModel = ReminderModel
                .builder()
                .remindText(text)
-                .memberDisplay(MemberNameDisplay.fromMember(commandContext.getAuthor()))
+                .userDisplay(UserDisplay.fromUser(commandContext.getAuthor().getUser()))
                .joinButtonId(joinButtonId)
                .reminder(ReminderDisplay.fromReminder(createdReminder))
                .message(ServerChannelMessage.fromMessage(commandContext.getMessage()))
@@ -118,29 +130,41 @@ public class Remind extends AbstractConditionableCommand {
        if(slashCommandParameterService.hasCommandOption(REMIND_TEXT_PARAMETER, event)) {
            reminderText = slashCommandParameterService.getCommandOption(REMIND_TEXT_PARAMETER, event, String.class, String.class);
        }
-        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(event.getMember());
-        Long snowFlake = SnowflakeUtils.createSnowFlake();
-        String joinButtonId = componentService.generateComponentId();
-        Reminder createdReminder = remindService.createReminderInForUser(aUserInAServer, reminderText, duration, event.getChannel().getIdLong(), snowFlake);
+        String joinButtonId;
+        Reminder createdReminder;
+        if(ContextUtils.isUserCommand(event)) {
+            joinButtonId = null;
+            AUser aUser = userManagementService.loadOrCreateUser(event.getUser().getIdLong());
+            createdReminder = remindService.createReminderInForUser(aUser, reminderText, duration);
+        } else {
+            joinButtonId = componentService.generateComponentId();
+            Long snowFlake = SnowflakeUtils.createSnowFlake();
+            AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(event.getMember());
+            createdReminder = remindService.createReminderInForUser(aUserInAServer, reminderText, duration, event.getChannel().getIdLong(), snowFlake);
+        }
        ReminderModel remindModel = ReminderModel
                .builder()
                .remindText(reminderText)
                .joinButtonId(joinButtonId)
-                .memberDisplay(MemberNameDisplay.fromMember(event.getMember()))
+                .userDisplay(UserDisplay.fromUser(event.getUser()))
                .reminder(ReminderDisplay.fromReminder(createdReminder))
                .build();

-        JoinReminderPayload payload = JoinReminderPayload
-                .builder()
-                .remindedUserId(event.getMember().getIdLong())
-                .reminderId(createdReminder.getId())
-                .serverId(serverId)
-                .build();
+        if(ContextUtils.isNotUserCommand(event)) {
+            AServer server = serverManagementService.loadServer(serverId);
+            JoinReminderPayload payload = JoinReminderPayload
+                    .builder()
+                    .remindedUserId(event.getUser().getIdLong())
+                    .reminderId(createdReminder.getId())
+                    .serverId(serverId)
+                    .build();
+            componentPayloadService.createButtonPayload(joinButtonId, payload, REMINDER_JOIN_BUTTON_ORIGIN, server);
+        }

-        componentPayloadService.createButtonPayload(joinButtonId, payload, REMINDER_JOIN_BUTTON_ORIGIN, aUserInAServer.getServerReference());

-        log.info("Notifying user {} about reminder being scheduled.", event.getMember().getId());
-        MessageToSend messageToSend = templateService.renderEmbedTemplate(REMINDER_EMBED_KEY, remindModel, serverId);
+
+        log.info("Notifying user {} about reminder being scheduled.", event.getUser().getId());
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(REMINDER_EMBED_KEY, remindModel, ContextUtils.serverIdOrNull(event));
        return interactionService.replyMessageToSend(messageToSend, event)
                .thenApply(interactionHook -> CommandResult.fromSuccess());
    }
@@ -171,6 +195,8 @@ public class Remind extends AbstractConditionableCommand {
        SlashCommandConfig slashCommandConfig = SlashCommandConfig
                .builder()
                .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                .rootCommandName(RemindSlashCommandNames.REMIND)
                .commandName("create")
                .build();
--- a/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/command/Reminders.java
+++ b/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/command/Reminders.java
@@ -4,17 +4,21 @@ 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.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.ServerChannelMessage;
+import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.template.display.UserDisplay;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserManagementService;
 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.remind.config.RemindFeatureDefinition;
 import dev.sheldan.abstracto.remind.config.RemindSlashCommandNames;
@@ -26,6 +30,7 @@ import dev.sheldan.abstracto.remind.service.management.ReminderManagementService
 import dev.sheldan.abstracto.remind.service.management.ReminderParticipantManagementService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.Member;
+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.stereotype.Component;
@@ -57,16 +62,19 @@ public class Reminders extends AbstractConditionableCommand {
    @Autowired
    private ReminderParticipantManagementService reminderParticipantManagementService;

+    @Autowired
+    private UserManagementService userManagementService;
+
    @Override
    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
        Long serverId = commandContext.getGuild().getIdLong();
        Member member = commandContext.getAuthor();
-        MessageToSend messageToSend = getMessageToSend(serverId, member);
+        MessageToSend messageToSend = getServerReminders(serverId, member);
        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
                .thenApply(aVoid -> CommandResult.fromIgnored());
    }

-    private MessageToSend getMessageToSend(Long serverId, Member member) {
+    private MessageToSend getServerReminders(Long serverId, Member member) {
        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(member);
        List<Reminder> activeReminders = reminderManagementService.getActiveRemindersForUser(aUserInAServer);
        List<Reminder> joinedReminders = reminderParticipantManagementService.getActiveReminders(aUserInAServer)
@@ -85,17 +93,37 @@ public class Reminders extends AbstractConditionableCommand {
        RemindersModel model = RemindersModel
                .builder()
                .reminders(reminders)
-                .member(member)
+                .userDisplay(UserDisplay.fromUser(member.getUser()))
                .build();
        log.info("Showing {} reminders for user {} in server {}.", activeReminders.size(), aUserInAServer.getUserReference().getId(), serverId);
        return templateService.renderEmbedTemplate(REMINDERS_RESPONSE_TEMPLATE, model, serverId);
    }

+    private MessageToSend getUserReminders(User user) {
+        AUser aUser = userManagementService.loadOrCreateUser(user.getIdLong());
+        List<Reminder> activeReminders = reminderManagementService.getActiveUserRemindersForUser(aUser);
+        List<ReminderDisplay> reminders = activeReminders
+                .stream()
+                .map(ReminderDisplay::fromReminder)
+                .collect(Collectors.toList());
+        RemindersModel model = RemindersModel
+                .builder()
+                .reminders(reminders)
+                .userDisplay(UserDisplay.fromUser(user))
+                .build();
+        return templateService.renderEmbedTemplate(REMINDERS_RESPONSE_TEMPLATE, model);
+    }
+
    @Override
    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
-        Long serverId = event.getGuild().getIdLong();
-        Member member = event.getMember();
-        MessageToSend messageToSend = getMessageToSend(serverId, member);
+        MessageToSend messageToSend;
+        if(ContextUtils.isUserCommand(event)) {
+            messageToSend = getUserReminders(event.getUser());
+        } else {
+            Member member = event.getMember();
+            Long serverId = event.getGuild().getIdLong();
+            messageToSend = getServerReminders(serverId, member);
+        }
        return interactionService.replyMessageToSend(messageToSend, event)
                .thenApply(interactionHook -> CommandResult.fromSuccess());
    }
@@ -110,6 +138,8 @@ public class Reminders extends AbstractConditionableCommand {
        SlashCommandConfig slashCommandConfig = SlashCommandConfig
                .builder()
                .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                .rootCommandName(RemindSlashCommandNames.REMIND)
                .commandName("list")
                .build();
--- a/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/command/UnRemind.java
+++ b/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/command/UnRemind.java
@@ -10,6 +10,8 @@ import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParame
 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.core.service.management.UserManagementService;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.remind.config.RemindFeatureDefinition;
 import dev.sheldan.abstracto.remind.config.RemindSlashCommandNames;
 import dev.sheldan.abstracto.remind.service.ReminderService;
@@ -36,6 +38,9 @@ public class UnRemind extends AbstractConditionableCommand {
    @Autowired
    private UserInServerManagementService userInServerManagementService;

+    @Autowired
+    private UserManagementService userManagementService;
+
    @Autowired
    private SlashCommandParameterService slashCommandParameterService;

@@ -52,7 +57,11 @@ public class UnRemind extends AbstractConditionableCommand {
    @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()));
+        if(ContextUtils.isUserCommand(event)) {
+            reminderService.unRemind(reminderId, userManagementService.loadOrCreateUser(event.getUser().getIdLong()));
+        } else {
+            reminderService.unRemind(reminderId, userInServerManagementService.loadOrCreateUser(event.getMember()));
+        }
        return interactionService.replyEmbed(UN_REMIND_RESPONSE, event)
                .thenApply(interactionHook -> CommandResult.fromSuccess());
    }
@@ -74,6 +83,8 @@ public class UnRemind extends AbstractConditionableCommand {
        SlashCommandConfig slashCommandConfig = SlashCommandConfig
                .builder()
                .enabled(true)
+                .userInstallable(true)
+                .userCommandConfig(UserCommandConfig.all())
                .rootCommandName(RemindSlashCommandNames.REMIND)
                .commandName("cancel")
                .build();
--- a/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/repository/ReminderRepository.java
+++ b/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/repository/ReminderRepository.java
@@ -1,5 +1,6 @@
 package dev.sheldan.abstracto.remind.repository;

+import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.remind.model.database.Reminder;
 import org.springframework.data.jpa.repository.JpaRepository;
@@ -11,8 +12,10 @@ import java.util.List;
 public interface ReminderRepository extends JpaRepository<Reminder, Long> {

    List<Reminder> getByRemindedUserAndRemindedFalse(AUserInAServer aUserInAServer);
+    List<Reminder> getByRemindedAUserAndRemindedFalseAndUserCommandTrueAndServerIsNull(AUser aUser);

    Reminder getByIdAndRemindedUserAndRemindedFalse(Long reminderId, AUserInAServer aUserInAServer);
+    Reminder getByIdAndRemindedAUserAndUserCommandTrue(Long reminderId, AUser aUser);
    Reminder getByIdAndRemindedUser(Long reminderId, AUserInAServer aUserInAServer);

 }
--- a/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/service/RemindServiceBean.java
+++ b/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/service/RemindServiceBean.java
@@ -3,12 +3,11 @@ package dev.sheldan.abstracto.remind.service;
 import dev.sheldan.abstracto.core.models.AServerAChannelAUser;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 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.models.template.display.MemberDisplay;
-import dev.sheldan.abstracto.core.models.template.display.MemberNameDisplay;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.service.GuildService;
-import dev.sheldan.abstracto.core.service.MemberService;
+import dev.sheldan.abstracto.core.models.template.display.UserDisplay;
+import dev.sheldan.abstracto.core.service.*;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
@@ -18,6 +17,7 @@ import dev.sheldan.abstracto.remind.exception.ReminderNotFoundException;
 import dev.sheldan.abstracto.remind.model.database.Reminder;
 import dev.sheldan.abstracto.remind.model.database.ReminderParticipant;
 import dev.sheldan.abstracto.remind.model.template.commands.ExecutedReminderModel;
+import dev.sheldan.abstracto.remind.model.template.commands.ReminderDisplay;
 import dev.sheldan.abstracto.remind.service.management.ReminderManagementService;
 import dev.sheldan.abstracto.remind.service.management.ReminderParticipantManagementService;
 import dev.sheldan.abstracto.scheduling.model.JobParameters;
@@ -55,6 +55,9 @@ public class RemindServiceBean implements ReminderService {
    @Autowired
    private TemplateService templateService;

+    @Autowired
+    private MessageService messageService;
+
    @Autowired
    private SchedulerService schedulerService;

@@ -64,6 +67,9 @@ public class RemindServiceBean implements ReminderService {
    @Autowired
    private GuildService guildService;

+    @Autowired
+    private UserService userService;
+
    @Autowired
    private RemindServiceBean self;

@@ -86,15 +92,15 @@ public class RemindServiceBean implements ReminderService {
    @Override
    public Reminder createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, Long channelId, Long messageId) {
        AChannel channel = channelManagementService.loadChannel(channelId);
-        AServerAChannelAUser aServerAChannelAUser = AServerAChannelAUser
-                .builder()
-                .user(user.getUserReference())
-                .aUserInAServer(user)
-                .guild(user.getServerReference())
-                .channel(channel)
-                .build();
        Instant remindAt = Instant.now().plusMillis(remindIn.toMillis());
-        Reminder reminder = reminderManagementService.createReminder(aServerAChannelAUser, remindText, remindAt, messageId);
+        AServerAChannelAUser aServerAChannelAUser = AServerAChannelAUser
+            .builder()
+            .channel(channel)
+            .user(user.getUserReference())
+            .guild(user.getServerReference())
+            .aUserInAServer(user)
+            .build();
+        Reminder reminder = reminderManagementService.createReminder(aServerAChannelAUser, remindText, remindAt, messageId, false, false);
        log.info("Creating reminder for user {} in guild {} due at {}.",
                user.getUserReference().getId(), user.getServerReference().getId(), remindAt);

@@ -102,6 +108,19 @@ public class RemindServiceBean implements ReminderService {
        return reminder;
    }

+    @Override
+    public Reminder createReminderInForUser(AUser aUser, String remindText, Duration remindIn) {
+        Instant remindAt = Instant.now().plusMillis(remindIn.toMillis());
+        AServerAChannelAUser aServerAChannelAUser = AServerAChannelAUser
+            .builder()
+            .user(aUser)
+            .build();
+        Reminder reminder = reminderManagementService.createReminder(aServerAChannelAUser, remindText, remindAt, null, true, true);
+        log.info("Creating reminder for user {} due at {}.", aUser.getId(), remindAt);
+        scheduleReminder(remindIn, reminder);
+        return reminder;
+    }
+
    @Override
    public Reminder createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, Long channelId) {
        return createReminderInForUser(user, remindText, remindIn, channelId, null);
@@ -136,30 +155,56 @@ public class RemindServiceBean implements ReminderService {
    @Transactional
    public void executeReminder(Long reminderId)  {
        Reminder reminderToRemindFor = reminderManagementService.loadReminder(reminderId);
-        if(reminderToRemindFor.isReminded()) {
+        if(reminderToRemindFor.getReminded()) {
            return;
        }
-        AServer server = reminderToRemindFor.getServer();
-        AChannel channel = reminderToRemindFor.getChannel();
-        Long userId = reminderToRemindFor.getRemindedUser().getUserReference().getId();
-        log.info("Executing reminder {} in channel {} in server {} for user {}.",
-                reminderId, channel.getId(), server.getId(), userId);
-        Optional<Guild> guildToAnswerIn = guildService.getGuildByIdOptional(server.getId());
-        if(guildToAnswerIn.isPresent()) {
-            Optional<GuildMessageChannel> channelToAnswerIn = channelService.getMessageChannelFromServerOptional(server.getId(), channel.getId());
-            // only send the message if the channel still exists, if not, only set the reminder to reminded.
-            if(channelToAnswerIn.isPresent()) {
-                memberService.getMemberInServerAsync(server.getId(), userId).thenAccept(member ->
-                    self.sendReminderText(reminderId, channelToAnswerIn.get(), member)
-                ).exceptionally(throwable -> {
-                    log.warn("Member {} not anymore in server {} - not reminding.", userId, server.getId(), throwable);
-                    return null;
-                });
-            } else {
-                log.warn("Channel {} in server {} to remind user did not exist anymore. Ignoring reminder {}", channel.getId(), server.getId(), reminderId);
-            }
+        Long userId = reminderToRemindFor.getRemindedAUser().getId();
+        if(reminderToRemindFor.getSendInDm()) {
+            log.info("Executing reminder {} in DMs of user {}.", reminderId, userId);
+            Long serverId = reminderToRemindFor.getServer() != null ? reminderToRemindFor.getServer().getId() : null;
+            Long channelId = reminderToRemindFor.getChannel() != null ? reminderToRemindFor.getChannel().getId() : null;
+            Long messageId = reminderToRemindFor.getMessageId();
+            Instant reminderDate = reminderToRemindFor.getReminderDate();
+            Instant targetDate = reminderToRemindFor.getTargetDate();
+            ReminderDisplay reminderDisplay = ReminderDisplay.fromReminder(reminderToRemindFor);
+            userService.retrieveUserForId(userId).thenCompose(user -> {
+                ExecutedReminderModel build = ExecutedReminderModel
+                        .builder()
+                        .reminderId(reminderId)
+                        .serverId(serverId)
+                        .channelId(channelId)
+                        .messageId(messageId)
+                        .reminderDisplay(reminderDisplay)
+                        .userDisplay(UserDisplay.fromUser(user))
+                        .duration(Duration.between(reminderDate, targetDate))
+                        .build();
+                return messageService.sendEmbedToUser(user, REMINDER_TEMPLATE_TEXT, build);
+            }).exceptionally(throwable -> {
+                log.error("Failed to remind user {} about reminder {}.", userId, reminderId, throwable);
+                return null;
+            });
        } else {
-            log.warn("Guild {} to remind user in did not exist anymore. Ignoring reminder {}.", server.getId(), reminderId);
+            AServer server = reminderToRemindFor.getServer();
+            AChannel channel = reminderToRemindFor.getChannel();
+            log.info("Executing reminder {} in channel {} in server {} for user {}.",
+                    reminderId, channel.getId(), server.getId(), userId);
+            Optional<Guild> guildToAnswerIn = guildService.getGuildByIdOptional(server.getId());
+            if(guildToAnswerIn.isPresent()) {
+                Optional<GuildMessageChannel> channelToAnswerIn = channelService.getMessageChannelFromServerOptional(server.getId(), channel.getId());
+                // only send the message if the channel still exists, if not, only set the reminder to reminded.
+                if(channelToAnswerIn.isPresent()) {
+                    memberService.getMemberInServerAsync(server.getId(), userId).thenCompose(member ->
+                        self.sendReminderText(reminderId, channelToAnswerIn.get(), member)
+                    ).exceptionally(throwable -> {
+                        log.warn("Member {} not anymore in server {} - not reminding.", userId, server.getId(), throwable);
+                        return null;
+                    });
+                } else {
+                    log.warn("Channel {} in server {} to remind user did not exist anymore. Ignoring reminder {}", channel.getId(), server.getId(), reminderId);
+                }
+            } else {
+                log.warn("Guild {} to remind user in did not exist anymore. Ignoring reminder {}.", server.getId(), reminderId);
+            }
        }
        reminderManagementService.setReminded(reminderToRemindFor);
    }
@@ -173,11 +218,12 @@ public class RemindServiceBean implements ReminderService {
                .stream()
                .map(reminderParticipant -> MemberDisplay.fromAUserInAServer(reminderParticipant.getParticipant()))
                .collect(Collectors.toList());
+        ReminderDisplay reminderDisplay = ReminderDisplay.fromReminder(reminder);
        ExecutedReminderModel build = ExecutedReminderModel
                .builder()
-                .reminder(reminder)
                .reminderParticipants(participantsDisplays)
-                .memberNameDisplay(MemberNameDisplay.fromMember(member))
+                .reminderDisplay(reminderDisplay)
+                .userDisplay(UserDisplay.fromUser(member.getUser()))
                .duration(Duration.between(reminder.getReminderDate(), reminder.getTargetDate()))
                .build();
        MessageToSend messageToSend = templateService.renderEmbedTemplate(REMINDER_TEMPLATE_TEXT, build, channelToAnswerIn.getGuild().getIdLong());
@@ -195,10 +241,21 @@ public class RemindServiceBean implements ReminderService {
        }
    }

+    @Override
+    public void unRemind(Long reminderId, AUser aUser) {
+        log.info("Trying to end reminder {} for user {}.", reminderId, aUser.getId());
+        Reminder reminder = reminderManagementService.getReminderByAndByUserNotRemindedForUserCommand(aUser, reminderId).orElseThrow(() -> new ReminderNotFoundException(reminderId));
+        reminder.setReminded(true);
+        if(reminder.getJobTriggerKey() != null) {
+            log.debug("Stopping scheduled trigger {} for reminder {}.", reminder.getJobTriggerKey(), reminderId);
+            schedulerService.stopTrigger(reminder.getJobTriggerKey());
+        }
+    }
+
    @Override
    public void snoozeReminder(Long reminderId, AUserInAServer user, Duration newDuration) {
        Reminder reminder = reminderManagementService.getReminderByAndByUser(user, reminderId).orElseThrow(() -> new ReminderNotFoundException(reminderId));
-        if(reminder.getTargetDate().isAfter(Instant.now()) && !reminder.isReminded()) {
+        if(reminder.getTargetDate().isAfter(Instant.now()) && !reminder.getReminded()) {
            throw new NotPossibleToSnoozeException();
        }
        log.info("Snoozing reminder {} to be executed in {}.", reminderId, newDuration);
--- a/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/service/management/ReminderManagementServiceBean.java
+++ b/abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/service/management/ReminderManagementServiceBean.java
@@ -1,6 +1,7 @@
 package dev.sheldan.abstracto.remind.service.management;

 import dev.sheldan.abstracto.core.models.AServerAChannelAUser;
+import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.remind.exception.ReminderNotFoundException;
 import dev.sheldan.abstracto.remind.model.database.Reminder;
@@ -21,20 +22,20 @@ public class ReminderManagementServiceBean implements ReminderManagementService
    private ReminderRepository reminderRepository;

    @Override
-    public Reminder createReminder(AServerAChannelAUser userToBeReminded, String text, Instant timeToBeRemindedAt, Long messageId) {
+    public Reminder createReminder(AServerAChannelAUser userToBeReminded, String text, Instant timeToBeRemindedAt, Long messageId, Boolean sendInDms, Boolean userCommand) {
        Reminder reminder = Reminder.builder()
                .channel(userToBeReminded.getChannel())
                .server(userToBeReminded.getGuild())
                .remindedUser(userToBeReminded.getAUserInAServer())
+                .remindedAUser(userToBeReminded.getUser())
+                .sendInDm(sendInDms)
                .reminded(false)
                .text(text)
                .reminderDate(Instant.now())
+                .userCommand(userCommand)
                .targetDate(timeToBeRemindedAt)
                .messageId(messageId)
        .build();
-        log.info("Creating reminder for user {} in server {} in message {} to be reminded at {}.",
-                userToBeReminded.getAUserInAServer().getUserReference().getId(), userToBeReminded.getGuild().getId(), messageId, timeToBeRemindedAt);
-
        return reminderRepository.save(reminder);
    }

@@ -65,6 +66,16 @@ public class ReminderManagementServiceBean implements ReminderManagementService
        return reminderRepository.getByRemindedUserAndRemindedFalse(aUserInAServer);
    }

+    @Override
+    public List<Reminder> getActiveUserRemindersForUser(AUser aUser) {
+        return reminderRepository.getByRemindedAUserAndRemindedFalseAndUserCommandTrueAndServerIsNull(aUser);
+    }
+
+    @Override
+    public Optional<Reminder> getReminderByAndByUserNotRemindedForUserCommand(AUser aUser, Long reminderId) {
+        return Optional.ofNullable(reminderRepository.getByIdAndRemindedAUserAndUserCommandTrue(reminderId, aUser));
+    }
+
    @Override
    public Optional<Reminder> getReminderByAndByUserNotReminded(AUserInAServer aUserInAServer, Long reminderId) {
        return Optional.ofNullable(reminderRepository.getByIdAndRemindedUserAndRemindedFalse(reminderId, aUserInAServer));
--- a/abstracto-application/abstracto-modules/remind/remind-impl/src/main/resources/migrations/1.5.39/tables/reminder.xml
+++ b/abstracto-application/abstracto-modules/remind/remind-impl/src/main/resources/migrations/1.5.39/tables/reminder.xml
@@ -2,9 +2,35 @@
 <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="reminder-add_user_installable_support">
+        <addColumn tableName="reminder">
+            <column name="user_id" type="BIGINT">
+                <constraints nullable="true"/>
+            </column>
+            <column name="send_dm" type="BOOLEAN" value="false">
+                <constraints nullable="false"/>
+            </column>
+            <column name="user_command" type="BOOLEAN" value="false">
+                <constraints nullable="false"/>
+            </column>
+        </addColumn>
+        <sql>
+            update reminder set user_id = (select ua.user_id from user_in_server ua where ua.user_in_server_id = user_in_server_id order by ua.server_id limit 1)
+        </sql>
+        <addNotNullConstraint columnName="user_id"
+                              tableName="reminder"
+                              validate="true"/>
+        <sql>
+            ALTER TABLE reminder ALTER COLUMN server_id DROP NOT NULL;
+            ALTER TABLE reminder ALTER COLUMN channel_id DROP NOT NULL;
+            ALTER TABLE reminder ALTER COLUMN user_in_server_id DROP NOT NULL;
+        </sql>
+    </changeSet>
+
    <changeSet author="Sheldan" id="reminder-resize_text">
        <modifyDataType columnName="text"
-                         newDataType="VARCHAR(4000)"
-                         tableName="reminder"/>
+                        newDataType="VARCHAR(4000)"
+                        tableName="reminder"/>
    </changeSet>
+
 </databaseChangeLog>