Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-01-25 20:04:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Sheldan
2024-04-02 23:48:27 +02:00
parent cd3378df32
commit 732535850b
98 changed files with 1184 additions and 773 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

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

3
abstracto-application/abstracto-modules/remind/remind-impl/src/main/java/dev/sheldan/abstracto/remind/repository/ReminderRepository.java
View File

@@ -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);
}

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

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

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

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

30
abstracto-application/abstracto-modules/remind/remind-impl/src/main/resources/migrations/1.5.39/tables/reminder.xml
View File

@@ -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>

48
abstracto-application/abstracto-modules/remind/remind-impl/src/test/java/dev/sheldan/abstracto/remind/command/UnRemindTest.java
View File

@@ -1,48 +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.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
import dev.sheldan.abstracto.remind.service.ReminderService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class UnRemindTest {
@InjectMocks
private UnRemind testUnit;
@Mock
private ReminderService reminderService;
@Mock
private UserInServerManagementService userInServerManagementService;
@Test
public void testExecuteCommand() {
Long reminderId = 6L;
CommandContext withParameters = CommandTestUtilities.getWithParameters(Arrays.asList(reminderId));
AUserInAServer user = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadOrCreateUser(withParameters.getAuthor())).thenReturn(user);
CommandResult result = testUnit.execute(withParameters);
verify(reminderService, times(1)).unRemind(reminderId, user);
CommandTestUtilities.checkSuccessfulCompletion(result);
}
@Test
public void validateCommand() {
CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
}
}

267
abstracto-application/abstracto-modules/remind/remind-impl/src/test/java/dev/sheldan/abstracto/remind/service/RemindServiceBeanTest.java
View File

@@ -1,267 +0,0 @@
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.service.ChannelService;
import dev.sheldan.abstracto.core.service.GuildService;
import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.remind.exception.ReminderNotFoundException;
import dev.sheldan.abstracto.remind.model.database.Reminder;
import dev.sheldan.abstracto.remind.service.management.ReminderManagementService;
import dev.sheldan.abstracto.remind.service.management.ReminderParticipantManagementService;
import dev.sheldan.abstracto.scheduling.model.JobParameters;
import dev.sheldan.abstracto.scheduling.service.SchedulerService;
import dev.sheldan.abstracto.core.templating.model.MessageToSend;
import dev.sheldan.abstracto.core.templating.service.TemplateService;
import net.dv8tion.jda.api.entities.*;
import net.dv8tion.jda.api.entities.channel.unions.GuildMessageChannelUnion;
import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion;
import net.dv8tion.jda.api.utils.ImageProxy;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.time.Duration;
import java.time.Instant;
import java.util.Arrays;
import java.util.Date;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ScheduledExecutorService;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class RemindServiceBeanTest {
@InjectMocks
private RemindServiceBean testUnit;
@Mock
private ReminderManagementService reminderManagementService;
@Mock
private ChannelManagementService channelManagementService;
@Mock
private TemplateService templateService;
@Mock
private SchedulerService schedulerService;
@Mock
private GuildService guildService;
@Mock
private MemberService memberService;
@Mock
private RemindServiceBean self;
@Mock
private ChannelService channelService;
@Mock
private Message message;
@Mock
private GuildMessageChannelUnion guildMessageChannelUnion;
@Mock
private MessageChannelUnion messageChannelUnion;
@Mock
private ScheduledExecutorService instantReminderScheduler;
@Mock
private ReminderParticipantManagementService reminderParticipantManagementService;
@Mock
private AServer server;
@Mock
private AUserInAServer aUserInAServer;
@Mock
private AUser user;
@Mock
private User jdaUser;
@Mock
private AChannel aChannel;
private static final Long REMINDER_ID = 5L;
private static final Long CHANNEL_ID = 6L;
private static final Long SERVER_ID = 8L;
private static final Long USER_ID = 9L;
@Before
public void setup() {
when(message.getIdLong()).thenReturn(5L);
when(message.getChannel()).thenReturn(messageChannelUnion);
}
@Test
public void createReminderWithScheduler() {
String remindText = "text";
String triggerKey = "trigger";
Duration duration = Duration.ofSeconds(62);
when(message.getChannel()).thenReturn(messageChannelUnion);
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(user);
Instant targetDate = Instant.now().plus(duration);
Reminder createdReminder = Mockito.mock(Reminder.class);
when(createdReminder.getTargetDate()).thenReturn(targetDate);
Long messageId = 5L;
when(reminderManagementService.createReminder(any(AServerAChannelAUser.class), eq(remindText), any(Instant.class), eq(messageId))).thenReturn(createdReminder);
when(schedulerService.executeJobWithParametersOnce(eq("reminderJob"), eq("utility"), any(JobParameters.class), eq(Date.from(targetDate)))).thenReturn(triggerKey);
Reminder returnedReminder = testUnit.createReminderInForUser(aUserInAServer, remindText, duration, message);
verify(reminderManagementService, times(1)).saveReminder(createdReminder);
Assert.assertEquals(createdReminder, returnedReminder);
}
@Test
public void createReminderWithoutScheduler() {
String remindText = "text";
Duration duration = Duration.ofSeconds(50);
when(message.getChannel()).thenReturn(messageChannelUnion);
when(messageChannelUnion.getIdLong()).thenReturn(CHANNEL_ID);
when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(aChannel);
Reminder createdReminder = Mockito.mock(Reminder.class);
when(createdReminder.getText()).thenReturn(remindText);
Long messageId = 5L;
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(reminderManagementService.createReminder(any(AServerAChannelAUser.class), eq(remindText), any(Instant.class), eq(messageId))).thenReturn(createdReminder);
Reminder returnedReminder = testUnit.createReminderInForUser(aUserInAServer, remindText, duration, message);
verify(reminderManagementService, times(0)).saveReminder(createdReminder);
Assert.assertEquals(remindText, returnedReminder.getText());
Assert.assertEquals(createdReminder.getId(), returnedReminder.getId());
}
@Test
public void testExecuteReminder() {
Reminder remindedReminder = Mockito.mock(Reminder.class);
when(remindedReminder.getRemindedUser()).thenReturn(aUserInAServer);
when(remindedReminder.getChannel()).thenReturn(aChannel);
when(remindedReminder.getServer()).thenReturn(server);
when(aChannel.getId()).thenReturn(CHANNEL_ID);
when(server.getId()).thenReturn(SERVER_ID);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(user.getId()).thenReturn(USER_ID);
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
Guild guildMock = Mockito.mock(Guild.class);
when(guildService.getGuildByIdOptional(SERVER_ID)).thenReturn(Optional.of(guildMock));
when(channelService.getMessageChannelFromServerOptional(SERVER_ID, CHANNEL_ID)).thenReturn(Optional.of(guildMessageChannelUnion));
Member mockedMember = Mockito.mock(Member.class);
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(mockedMember));
testUnit.executeReminder(REMINDER_ID);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
}
@Test
public void testExecuteReminderFromNotFoundChannel() {
Reminder remindedReminder = Mockito.mock(Reminder.class);
when(remindedReminder.getChannel()).thenReturn(aChannel);
when(remindedReminder.getServer()).thenReturn(server);
when(server.getId()).thenReturn(SERVER_ID);
when(aChannel.getId()).thenReturn(CHANNEL_ID);
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
Guild guildMock = Mockito.mock(Guild.class);
when(guildService.getGuildByIdOptional(SERVER_ID)).thenReturn(Optional.of(guildMock));
when(aUserInAServer.getUserReference()).thenReturn(user);
when(remindedReminder.getRemindedUser()).thenReturn(aUserInAServer);
when(channelService.getMessageChannelFromServerOptional(SERVER_ID, CHANNEL_ID)).thenReturn(Optional.empty());
testUnit.executeReminder(REMINDER_ID);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
verify(self, times(0)).sendReminderText(anyLong(), any(), any(Member.class));
}
@Test
public void testExecuteReminderFromNotFoundGuild() {
Long reminderId = 5L;
Reminder remindedReminder = Mockito.mock(Reminder.class);
when(remindedReminder.getChannel()).thenReturn(aChannel);
when(remindedReminder.getServer()).thenReturn(server);
when(server.getId()).thenReturn(SERVER_ID);
when(remindedReminder.getRemindedUser()).thenReturn(aUserInAServer);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(reminderManagementService.loadReminder(reminderId)).thenReturn(remindedReminder);
when(guildService.getGuildByIdOptional(SERVER_ID)).thenReturn(Optional.empty());
testUnit.executeReminder(reminderId);
verify(reminderManagementService, times(1)).setReminded(remindedReminder);
}
@Test
public void testExecuteRemindedReminder() {
Reminder remindedReminder = Mockito.mock(Reminder.class);
when(remindedReminder.isReminded()).thenReturn(true);
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
testUnit.executeReminder(REMINDER_ID);
verify(guildService, times(0)).getGuildByIdOptional(anyLong());
}
@Test
public void testUnRemindScheduledReminder() {
String triggerKey = "trigger";
Reminder reminderToUnRemind = Mockito.mock(Reminder.class);
when(reminderToUnRemind.getJobTriggerKey()).thenReturn(triggerKey);
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(reminderManagementService.getReminderByAndByUserNotReminded(aUserInAServer, REMINDER_ID)).thenReturn(Optional.of(reminderToUnRemind));
testUnit.unRemind(REMINDER_ID, aUserInAServer);
verify(schedulerService, times(1)).stopTrigger(triggerKey);
}
@Test
public void testUnRemindNonScheduledReminder() {
Reminder reminderToUnRemind = Mockito.mock(Reminder.class);
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(reminderManagementService.getReminderByAndByUserNotReminded(aUserInAServer, REMINDER_ID)).thenReturn(Optional.of(reminderToUnRemind));
testUnit.unRemind(REMINDER_ID, aUserInAServer);
verify(schedulerService, times(0)).stopTrigger(anyString());
}
@Test(expected = ReminderNotFoundException.class)
public void testUnRemindNonExistingReminder() {
when(aUserInAServer.getServerReference()).thenReturn(server);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(reminderManagementService.getReminderByAndByUserNotReminded(aUserInAServer, REMINDER_ID)).thenReturn(Optional.empty());
testUnit.unRemind(REMINDER_ID, aUserInAServer);
}
@Test
public void testSendReminderText() {
Member remindedMember = Mockito.mock(Member.class);
Guild guild = Mockito.mock(Guild.class);
when(remindedMember.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(8L);
when(remindedMember.getIdLong()).thenReturn(9L);
when(remindedMember.getUser()).thenReturn(jdaUser);
when(remindedMember.getEffectiveAvatar()).thenReturn(Mockito.mock(ImageProxy.class));
when(jdaUser.getDefaultAvatar()).thenReturn(Mockito.mock(ImageProxy.class));
Reminder remindedReminder = Mockito.mock(Reminder.class);
when(remindedReminder.getTargetDate()).thenReturn(Instant.now());
when(remindedReminder.getReminderDate()).thenReturn(Instant.now());
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(guildMessageChannelUnion.getGuild()).thenReturn(guild);
when(templateService.renderEmbedTemplate(eq(RemindServiceBean.REMINDER_TEMPLATE_TEXT), any(), eq(SERVER_ID))).thenReturn(messageToSend);
when(channelService.sendMessageToSendToChannel(messageToSend, guildMessageChannelUnion)).thenReturn(Arrays.asList(CompletableFuture.completedFuture(null)));
CompletableFuture<Void> future = testUnit.sendReminderText(REMINDER_ID, guildMessageChannelUnion, remindedMember);
future.join();
Assert.assertFalse(future.isCompletedExceptionally());
}
}

132
abstracto-application/abstracto-modules/remind/remind-impl/src/test/java/dev/sheldan/abstracto/remind/service/management/ReminderManagementServiceBeanTest.java
View File

@@ -1,132 +0,0 @@
package dev.sheldan.abstracto.remind.service.management;
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.remind.model.database.Reminder;
import dev.sheldan.abstracto.remind.repository.ReminderRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.time.Instant;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class ReminderManagementServiceBeanTest {
@InjectMocks
private ReminderManagementServiceBean testUnit;
@Mock
private ReminderRepository reminderRepository;
@Mock
private AUserInAServer aUserInAServer;
@Mock
private AChannel channel;
@Mock
private AServer server;
@Mock
private Reminder reminder;
private static final Long REMINDER_ID = 8L;
@Test
public void testCreateReminder() {
AServerAChannelAUser serverAChannelAUser = Mockito.mock(AServerAChannelAUser.class);
AUser user = Mockito.mock(AUser.class);
when(aUserInAServer.getUserReference()).thenReturn(user);
when(serverAChannelAUser.getAUserInAServer()).thenReturn(aUserInAServer);
when(serverAChannelAUser.getGuild()).thenReturn(server);
when(serverAChannelAUser.getChannel()).thenReturn(channel);
String reminderText = "text";
Instant reminderTargetDate = Instant.ofEpochSecond(1590615937);
Long messageId = 5L;
ArgumentCaptor<Reminder> reminderArgumentCaptor = ArgumentCaptor.forClass(Reminder.class);
Reminder savedReminder = Mockito.mock(Reminder.class);
when(reminderRepository.save(reminderArgumentCaptor.capture())).thenReturn(savedReminder);
Reminder createdReminder = testUnit.createReminder(serverAChannelAUser, reminderText, reminderTargetDate, messageId);
Assert.assertEquals(savedReminder, createdReminder);
Reminder capturedReminder = reminderArgumentCaptor.getValue();
Assert.assertEquals(messageId, capturedReminder.getMessageId());
Assert.assertEquals(aUserInAServer, capturedReminder.getRemindedUser());
Assert.assertEquals(server, capturedReminder.getServer());
Assert.assertEquals(reminderText, capturedReminder.getText());
Assert.assertEquals(reminderTargetDate, capturedReminder.getTargetDate());
Assert.assertEquals(channel, capturedReminder.getChannel());
Assert.assertFalse(capturedReminder.isReminded());
}
@Test
public void testSetReminded() {
testUnit.setReminded(reminder);
verify(reminder, times(1)).setReminded(true);
verify(reminderRepository, times(1)).save(reminder);
}
@Test
public void testSaveReminder() {
testUnit.saveReminder(reminder);
verify(reminderRepository, times(1)).save(reminder);
}
@Test
public void testRetrieveActiveReminders() {
Reminder reminder2 = Mockito.mock(Reminder.class);
List<Reminder> reminders = Arrays.asList(reminder, reminder2);
when(reminderRepository.getByRemindedUserAndRemindedFalse(aUserInAServer)).thenReturn(reminders);
List<Reminder> activeRemindersForUser = testUnit.getActiveRemindersForUser(aUserInAServer);
for (int i = 0; i < reminders.size(); i++) {
Reminder reference = reminders.get(i);
Reminder returned = activeRemindersForUser.get(i);
Assert.assertEquals(reference, returned);
}
Assert.assertEquals(reminders.size(), activeRemindersForUser.size());
}
@Test
public void testGetReminderByIdAndNotReminded() {
when(reminderRepository.getByIdAndRemindedUserAndRemindedFalse(REMINDER_ID, aUserInAServer)).thenReturn(reminder);
Optional<Reminder> returned = testUnit.getReminderByAndByUserNotReminded(aUserInAServer, REMINDER_ID);
Assert.assertTrue(returned.isPresent());
returned.ifPresent(returnedReminder -> Assert.assertEquals(reminder, returnedReminder));
}
@Test
public void testGetReminderByIdAndNotRemindedNothingFound() {
when(reminderRepository.getByIdAndRemindedUserAndRemindedFalse(REMINDER_ID, aUserInAServer)).thenReturn(null);
Optional<Reminder> returned = testUnit.getReminderByAndByUserNotReminded(aUserInAServer, REMINDER_ID);
Assert.assertFalse(returned.isPresent());
}
@Test
public void testLoadingReminder() {
when(reminderRepository.findById(REMINDER_ID)).thenReturn(Optional.of(reminder));
Optional<Reminder> returned = testUnit.loadReminderOptional(REMINDER_ID);
Assert.assertTrue(returned.isPresent());
returned.ifPresent(returnedReminder -> Assert.assertEquals(reminder, returnedReminder));
}
@Test
public void testLoadingReminderNotFound() {
when(reminderRepository.findById(REMINDER_ID)).thenReturn(Optional.empty());
Optional<Reminder> returned = testUnit.loadReminderOptional(REMINDER_ID);
Assert.assertFalse(returned.isPresent());
}
}

21
abstracto-application/abstracto-modules/remind/remind-int/src/main/java/dev/sheldan/abstracto/remind/model/database/Reminder.java
View File

@@ -2,6 +2,7 @@ package dev.sheldan.abstracto.remind.model.database;
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 lombok.*;
@@ -25,18 +26,22 @@ public class Reminder implements Serializable {
private Long id;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_in_server_id", nullable = false)
@JoinColumn(name = "user_in_server_id")
private AUserInAServer remindedUser;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_id")
private AUser remindedAUser;
@Column(name = "message_id")
private Long messageId;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "channel_id", nullable = false)
@JoinColumn(name = "channel_id")
private AChannel channel;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "server_id", nullable = false)
@JoinColumn(name = "server_id")
private AServer server;
@Column(name = "created", nullable = false, insertable = false, updatable = false)
@@ -51,9 +56,17 @@ public class Reminder implements Serializable {
@Column(name = "text")
private String text;
@Builder.Default
@Column(name = "send_dm", nullable = false)
private Boolean sendInDm = false;
@Builder.Default
@Column(name = "user_command", nullable = false)
private Boolean userCommand = false;
@Builder.Default
@Column(name = "reminded", nullable = false)
private boolean reminded = false;
private Boolean reminded = false;
@Column(name = "job_trigger_key")
private String jobTriggerKey;

11
abstracto-application/abstracto-modules/remind/remind-int/src/main/java/dev/sheldan/abstracto/remind/model/template/commands/ExecutedReminderModel.java
View File

@@ -3,6 +3,7 @@ package dev.sheldan.abstracto.remind.model.template.commands;
import dev.sheldan.abstracto.core.models.context.ServerContext;
import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
import dev.sheldan.abstracto.core.models.template.display.MemberNameDisplay;
import dev.sheldan.abstracto.core.models.template.display.UserDisplay;
import dev.sheldan.abstracto.core.utils.MessageUtils;
import dev.sheldan.abstracto.remind.model.database.Reminder;
import lombok.Getter;
@@ -16,12 +17,16 @@ import java.util.List;
@Setter
@SuperBuilder
public class ExecutedReminderModel extends ServerContext {
private Reminder reminder;
private MemberNameDisplay memberNameDisplay;
private Long reminderId;
private Long serverId;
private Long channelId;
private Long messageId;
private UserDisplay userDisplay;
private ReminderDisplay reminderDisplay;
private List<MemberDisplay> reminderParticipants;
private Duration duration;
public String getMessageUrl() {
return MessageUtils.buildMessageUrl(this.reminder.getServer().getId() ,this.reminder.getChannel().getId(), this.reminder.getMessageId());
return MessageUtils.buildMessageUrl(serverId , channelId, messageId);
}
}

10
abstracto-application/abstracto-modules/remind/remind-int/src/main/java/dev/sheldan/abstracto/remind/model/template/commands/ReminderDisplay.java
View File

@@ -17,6 +17,8 @@ public class ReminderDisplay {
private String text;
private Instant targetDate;
private Instant creationDate;
private Boolean sentInDm;
private Boolean userCommand;
@Builder.Default
private Boolean joined = false;
private ServerChannelMessage message;
@@ -25,15 +27,17 @@ public class ReminderDisplay {
ServerChannelMessage message = ServerChannelMessage
.builder()
.messageId(reminder.getMessageId())
.channelId(reminder.getChannel().getId())
.serverId(reminder.getServer().getId())
.channelId(reminder.getChannel() != null ? reminder.getChannel().getId() : null)
.serverId(reminder.getServer() != null ? reminder.getServer().getId() : null)
.build();
return ReminderDisplay
.builder()
.creationDate(reminder.getReminderDate())
.targetDate(reminder.getTargetDate())
.id(reminder.getId())
.reminded(reminder.isReminded())
.sentInDm(reminder.getSendInDm())
.reminded(reminder.getReminded())
.userCommand(reminder.getUserCommand())
.message(message)
.text(reminder.getText())
.build();

4
abstracto-application/abstracto-modules/remind/remind-int/src/main/java/dev/sheldan/abstracto/remind/model/template/commands/ReminderModel.java
View File

@@ -1,7 +1,7 @@
package dev.sheldan.abstracto.remind.model.template.commands;
import dev.sheldan.abstracto.core.models.ServerChannelMessage;
import dev.sheldan.abstracto.core.models.template.display.MemberNameDisplay;
import dev.sheldan.abstracto.core.models.template.display.UserDisplay;
import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
@@ -11,7 +11,7 @@ import lombok.Setter;
@Builder
public class ReminderModel {
private String remindText;
private MemberNameDisplay memberDisplay;
private UserDisplay userDisplay;
private ReminderDisplay reminder;
private ServerChannelMessage message;
private String joinButtonId;

4
abstracto-application/abstracto-modules/remind/remind-int/src/main/java/dev/sheldan/abstracto/remind/model/template/commands/RemindersModel.java
View File

@@ -1,9 +1,9 @@
package dev.sheldan.abstracto.remind.model.template.commands;
import dev.sheldan.abstracto.core.models.template.display.UserDisplay;
import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
import net.dv8tion.jda.api.entities.Member;
import java.util.ArrayList;
import java.util.List;
@@ -14,5 +14,5 @@ import java.util.List;
public class RemindersModel {
@Builder.Default
private List<ReminderDisplay> reminders = new ArrayList<>();
private Member member;
private UserDisplay userDisplay;
}

3
abstracto-application/abstracto-modules/remind/remind-int/src/main/java/dev/sheldan/abstracto/remind/service/ReminderService.java
View File

@@ -1,5 +1,6 @@
package dev.sheldan.abstracto.remind.service;
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 net.dv8tion.jda.api.entities.Message;
@@ -9,8 +10,10 @@ import java.time.Duration;
public interface ReminderService {
Reminder createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, Message message);
Reminder createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, Long channelId, Long messageId);
Reminder createReminderInForUser(AUser aUser, String remindText, Duration remindIn);
Reminder createReminderInForUser(AUserInAServer user, String remindText, Duration remindIn, Long channelId);
void executeReminder(Long reminderId);
void unRemind(Long reminderId, AUserInAServer userInAServer);
void unRemind(Long reminderId, AUser aUser);
void snoozeReminder(Long reminderId, AUserInAServer user, Duration newDuration);
}

5
abstracto-application/abstracto-modules/remind/remind-int/src/main/java/dev/sheldan/abstracto/remind/service/management/ReminderManagementService.java
View File

@@ -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.model.database.Reminder;
@@ -9,12 +10,14 @@ import java.util.List;
import java.util.Optional;
public interface ReminderManagementService {
Reminder createReminder(AServerAChannelAUser userToBeReminded, String text, Instant timeToBeRemindedAt, Long messageId);
Reminder createReminder(AServerAChannelAUser userToBeReminded, String text, Instant timeToBeRemindedAt, Long messageId, Boolean sendInDms, Boolean userCommand);
Optional<Reminder> loadReminderOptional(Long reminderId);
Reminder loadReminder(Long reminderId);
void setReminded(Reminder reminder);
Reminder saveReminder(Reminder reminder);
List<Reminder> getActiveRemindersForUser(AUserInAServer aUserInAServer);
List<Reminder> getActiveUserRemindersForUser(AUser aUser);
Optional<Reminder> getReminderByAndByUserNotReminded(AUserInAServer aUserInAServer, Long reminderId);
Optional<Reminder> getReminderByAndByUserNotRemindedForUserCommand(AUser aUser, Long reminderId);
Optional<Reminder> getReminderByAndByUser(AUserInAServer aUserInAServer, Long reminderId);
}