Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-04-10 02:22:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AB-218] adding ability to split the normal message as well according to custom configuration

Browse Source 
adding ability to define the max amount of messages resulting from a template on a server and template base
fixing not always considering the server when rendering templates in various places
This commit is contained in:
Sheldan
2021-03-30 20:29:13 +02:00
parent 33959d696a
commit 6375dbf463
28 changed files with 213 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/service/AssignableRolePlaceServiceBean.java
View File

@@ -784,7 +784,7 @@ public class AssignableRolePlaceServiceBean implements AssignableRolePlaceServic
*/
private MessageToSend renderAssignablePlacePosts(AssignableRolePlace place) {
AssignablePostMessage model = prepareAssignablePostMessageModel(place);
return templateService.renderEmbedTemplate(ASSIGNABLE_ROLES_POST_TEMPLATE_KEY, model);
return templateService.renderEmbedTemplate(ASSIGNABLE_ROLES_POST_TEMPLATE_KEY, model, place.getServer().getId());
}
/**

2
abstracto-application/abstracto-modules/link-embed/link-embed-impl/src/main/java/dev/sheldan/abstracto/linkembed/service/MessageEmbedServiceBean.java
View File

@@ -115,7 +115,7 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
@Transactional
public CompletableFuture<Void> sendEmbeddingMessage(CachedMessage cachedMessage, TextChannel target, Long userEmbeddingUserInServerId, MessageEmbeddedModel messageEmbeddedModel) {
MessageToSend embed = templateService.renderEmbedTemplate(MESSAGE_EMBED_TEMPLATE, messageEmbeddedModel);
MessageToSend embed = templateService.renderEmbedTemplate(MESSAGE_EMBED_TEMPLATE, messageEmbeddedModel, target.getGuild().getIdLong());
AUserInAServer cause = userInServerManagementService.loadOrCreateUser(userEmbeddingUserInServerId);
List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToSendToChannel(embed, target);
log.trace("Embedding message {} from channel {} from server {}, because of user {}", cachedMessage.getMessageId(),

4
abstracto-application/abstracto-modules/link-embed/link-embed-impl/src/test/java/dev/sheldan/abstracto/linkembed/service/MessageEmbedServiceBeanTest.java
View File

@@ -234,7 +234,9 @@ public class MessageEmbedServiceBeanTest {
public void testSendEmbeddingMessage() {
MessageEmbeddedModel embeddedModel = Mockito.mock(MessageEmbeddedModel.class);
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(MessageEmbedServiceBean.MESSAGE_EMBED_TEMPLATE, embeddedModel)).thenReturn(messageToSend);
when(textChannel.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(templateService.renderEmbedTemplate(MessageEmbedServiceBean.MESSAGE_EMBED_TEMPLATE, embeddedModel, SERVER_ID)).thenReturn(messageToSend);
AUser user = Mockito.mock(AUser.class);
when(embeddingUser.getUserReference()).thenReturn(user);
when(userInServerManagementService.loadOrCreateUser(EMBEDDING_USER_IN_SERVER_ID)).thenReturn(embeddingUser);

2
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/WarnServiceBean.java
View File

@@ -242,7 +242,7 @@ public class WarnServiceBean implements WarnService {
.guild(guildService.getGuildById(server.getId()))
.warnings(warnDecayWarnings)
.build();
MessageToSend messageToSend = templateService.renderEmbedTemplate(WARN_DECAY_LOG_TEMPLATE_KEY, warnDecayLogModel);
MessageToSend messageToSend = templateService.renderEmbedTemplate(WARN_DECAY_LOG_TEMPLATE_KEY, warnDecayLogModel, serverId);
List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, WarnDecayPostTarget.DECAY_LOG, server.getId());
return FutureUtils.toSingleFutureGeneric(messageFutures);
}

3
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/MessageEditedListenerTest.java
View File

@@ -56,7 +56,6 @@ public class MessageEditedListenerTest {
private static final Long SERVER_ID = 4L;
private static final Long CHANNEL_ID = 5L;
private static final Long AUTHOR_ID = 6L;
@Test
public void testExecuteListenerWithSameContent() {
@@ -66,7 +65,7 @@ public class MessageEditedListenerTest {
when(model.getAfter()).thenReturn(messageAfter);
when(model.getBefore()).thenReturn(messageBefore);
testUnit.execute(model);
verify(templateService, times(0)).renderEmbedTemplate(eq(MessageEditedListener.MESSAGE_EDITED_TEMPLATE), any());
verify(templateService, times(0)).renderEmbedTemplate(eq(MessageEditedListener.MESSAGE_EDITED_TEMPLATE), any(), eq(SERVER_ID));
}
@Test

2
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/BanServiceBeanTest.java
View File

@@ -62,7 +62,7 @@ public class BanServiceBeanTest {
testUnit.banMember(memberToBan, REASON, context);
verify(mockedGuild, times(1)).ban(USER_ID.toString(), 0, REASON);
verify(postTargetService, times(0)).sendEmbedInPostTarget(mockedMessage, ModerationPostTarget.BAN_LOG, SERVER_ID);
verify(templateService, times(0)).renderEmbedTemplate(BanServiceBean.BAN_LOG_TEMPLATE, context);
verify(templateService, times(0)).renderEmbedTemplate(BanServiceBean.BAN_LOG_TEMPLATE, context, SERVER_ID);
}
@Test

2
abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/listener/ModMailMessageEditedListener.java
View File

@@ -115,7 +115,7 @@ public class ModMailMessageEditedListener implements AsyncMessageTextUpdatedList
modMailModeratorReplyModelBuilder.moderator(editingUser);
}
ModMailModeratorReplyModel modMailUserReplyModel = modMailModeratorReplyModelBuilder.build();
MessageToSend messageToSend = templateService.renderEmbedTemplate(ModMailThreadServiceBean.MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY, modMailUserReplyModel);
MessageToSend messageToSend = templateService.renderEmbedTemplate(ModMailThreadServiceBean.MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY, modMailUserReplyModel, editingUser.getGuild().getIdLong());
Long threadId = modMailMessage.getThreadReference().getId();
long serverId = editingUser.getGuild().getIdLong();
if(modMailMessage.getCreatedMessageInChannel() != null) {

12
abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/service/ModMailThreadServiceBean.java
View File

@@ -254,7 +254,7 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
.roles(rolesToPing)
.channel(channel)
.build();
MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_notification_message", modMailNotificationModel);
MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_notification_message", modMailNotificationModel, channel.getGuild().getIdLong());
List<CompletableFuture<Message>> modmailping = postTargetService.sendEmbedInPostTarget(messageToSend, ModMailPostTargets.MOD_MAIL_PING, serverId);
return CompletableFuture.allOf(modmailping.toArray(new CompletableFuture[0]));
}
@@ -434,7 +434,7 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
.member(member)
.subscribers(subscribers)
.build();
MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_user_message", modMailUserReplyModel);
MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_user_message", modMailUserReplyModel, textChannel.getGuild().getIdLong());
List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToSendToChannel(messageToSend, textChannel);
return CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0]))
.thenCompose(aVoid -> {
@@ -477,7 +477,7 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
public CompletableFuture<Void> relayMessageToDm(Long modmailThreadId, String text, Message replyCommandMessage, boolean anonymous, MessageChannel feedBack, List<UndoActionInstance> undoActions, Member targetMember) {
log.info("Relaying message {} to user {} in modmail thread {} on server {}.", replyCommandMessage.getId(), targetMember.getId(), modmailThreadId, targetMember.getGuild().getId());
AUserInAServer moderator = userInServerManagementService.loadOrCreateUser(replyCommandMessage.getMember());
metricService. incrementCounter(MDOMAIL_THREAD_MESSAGE_SENT);
metricService.incrementCounter(MDOMAIL_THREAD_MESSAGE_SENT);
ModMailThread modMailThread = modMailThreadManagementService.getById(modmailThreadId);
FullUserInServer fullThreadUser = FullUserInServer
.builder()
@@ -500,7 +500,7 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
modMailModeratorReplyModelBuilder.moderator(moderatorMember);
}
ModMailModeratorReplyModel modMailUserReplyModel = modMailModeratorReplyModelBuilder.build();
MessageToSend messageToSend = templateService.renderEmbedTemplate(MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY, modMailUserReplyModel);
MessageToSend messageToSend = templateService.renderEmbedTemplate(MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY, modMailUserReplyModel, modMailThread.getServer().getId());
CompletableFuture<Message> future = messageService.sendMessageToSendToUser(targetMember.getUser(), messageToSend);
CompletableFuture<Message> sameThreadMessageFuture;
if(featureModeService.featureModeActive(ModMailFeatureDefinition.MOD_MAIL, modMailThread.getServer(), ModMailMode.SEPARATE_MESSAGE)) {
@@ -720,7 +720,7 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
.note(note)
.build();
log.trace("Sending close header and individual mod mail messages to mod mail log target for thread {}.", modMailThreadId);
MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_close_header", headerModel);
MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_close_header", headerModel, modMailThread.getServer().getId());
List<CompletableFuture<Message>> closeHeaderFutures = postTargetService.sendEmbedInPostTarget(messageToSend, ModMailPostTargets.MOD_MAIL_LOG, modMailThread.getServer().getId());
// TODO in case the rendering fails, the already sent messages are not deleted
completableFutures.addAll(closeHeaderFutures);
@@ -761,7 +761,7 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
// TODO order messages
loadedMessages.forEach(message -> {
log.trace("Sending message {} of modmail thread {} to modmail log post target.", modMailThread.getId(), message.getMessage().getId());
MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_close_logged_message", message);
MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_close_logged_message", message, modMailThread.getServer().getId());
List<CompletableFuture<Message>> logFuture = postTargetService.sendEmbedInPostTarget(messageToSend, ModMailPostTargets.MOD_MAIL_LOG, modMailThread.getServer().getId());
messageFutures.addAll(logFuture);
});

8
abstracto-application/abstracto-modules/modmail/modmail-impl/src/test/java/dev/sheldan/abstracto/modmail/listener/ModMailMessageEditedListenerTest.java
View File

@@ -207,7 +207,7 @@ public class ModMailMessageEditedListenerTest {
when(authorMember.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(parsedParameters.getParameters()).thenReturn(Arrays.asList(NEW_PARAM));
when(templateService.renderEmbedTemplate(eq(ModMailThreadServiceBean.MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY), replyModelArgumentCaptor.capture())).thenReturn(messageToSend);
when(templateService.renderEmbedTemplate(eq(ModMailThreadServiceBean.MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY), replyModelArgumentCaptor.capture(), eq(SERVER_ID))).thenReturn(messageToSend);
testUnit.updateMessageInThread(loadedMessage, parsedParameters, targetMember, authorMember);
verify(channelService, times(0)).editMessageInAChannel(eq(messageToSend), any(AChannel.class), anyLong());
verify(messageService, times(1)).editMessageInDMChannel(targetUser, messageToSend, CREATED_MESSAGE_ID);
@@ -231,7 +231,7 @@ public class ModMailMessageEditedListenerTest {
when(channel.getId()).thenReturn(CHANNEL_ID);
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(parsedParameters.getParameters()).thenReturn(Arrays.asList(NEW_PARAM));
when(templateService.renderEmbedTemplate(eq(ModMailThreadServiceBean.MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY), replyModelArgumentCaptor.capture())).thenReturn(messageToSend);
when(templateService.renderEmbedTemplate(eq(ModMailThreadServiceBean.MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY), replyModelArgumentCaptor.capture(), eq(SERVER_ID))).thenReturn(messageToSend);
testUnit.updateMessageInThread(loadedMessage, parsedParameters, targetMember, authorMember);
verify(channelService, times(1)).editMessageInAChannel(eq(messageToSend), eq(channel), eq(CREATED_MESSAGE_ID));
verify(messageService, times(1)).editMessageInDMChannel(targetUser, messageToSend, CREATED_MESSAGE_ID);
@@ -251,7 +251,7 @@ public class ModMailMessageEditedListenerTest {
when(authorMember.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(parsedParameters.getParameters()).thenReturn(Arrays.asList(NEW_PARAM));
when(templateService.renderEmbedTemplate(eq(ModMailThreadServiceBean.MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY), replyModelArgumentCaptor.capture())).thenReturn(messageToSend);
when(templateService.renderEmbedTemplate(eq(ModMailThreadServiceBean.MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY), replyModelArgumentCaptor.capture(), eq(SERVER_ID))).thenReturn(messageToSend);
testUnit.updateMessageInThread(loadedMessage, parsedParameters, targetMember, authorMember);
verify(channelService, times(0)).editMessageInAChannel(eq(messageToSend), any(AChannel.class), anyLong());
verify(messageService, times(1)).editMessageInDMChannel(targetUser, messageToSend, CREATED_MESSAGE_ID);
@@ -274,7 +274,7 @@ public class ModMailMessageEditedListenerTest {
when(thread.getChannel()).thenReturn(channel);
when(channel.getId()).thenReturn(CHANNEL_ID);
when(parsedParameters.getParameters()).thenReturn(Arrays.asList(NEW_PARAM));
when(templateService.renderEmbedTemplate(eq(ModMailThreadServiceBean.MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY), replyModelArgumentCaptor.capture())).thenReturn(messageToSend);
when(templateService.renderEmbedTemplate(eq(ModMailThreadServiceBean.MODMAIL_STAFF_MESSAGE_TEMPLATE_KEY), replyModelArgumentCaptor.capture(), eq(SERVER_ID))).thenReturn(messageToSend);
testUnit.updateMessageInThread(loadedMessage, parsedParameters, targetMember, authorMember);
verify(channelService, times(1)).editMessageInAChannel(eq(messageToSend), eq(channel), eq(CREATED_MESSAGE_ID));
verify(messageService, times(1)).editMessageInDMChannel(targetUser, messageToSend, CREATED_MESSAGE_ID);

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

@@ -145,7 +145,7 @@ public class RemindServiceBean implements ReminderService {
.member(member)
.duration(Duration.between(reminder.getReminderDate(), reminder.getTargetDate()))
.build();
MessageToSend messageToSend = templateService.renderEmbedTemplate(REMINDER_TEMPLATE_TEXT, build);
MessageToSend messageToSend = templateService.renderEmbedTemplate(REMINDER_TEMPLATE_TEXT, build, channelToAnswerIn.getGuild().getIdLong());
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, channelToAnswerIn));
}

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

@@ -246,7 +246,8 @@ public class RemindServiceBeanTest {
when(remindedReminder.getReminderDate()).thenReturn(Instant.now());
when(reminderManagementService.loadReminder(REMINDER_ID)).thenReturn(remindedReminder);
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(RemindServiceBean.REMINDER_TEMPLATE_TEXT), any())).thenReturn(messageToSend);
when(channel.getGuild()).thenReturn(guild);
when(templateService.renderEmbedTemplate(eq(RemindServiceBean.REMINDER_TEMPLATE_TEXT), any(), eq(SERVER_ID))).thenReturn(messageToSend);
when(channelService.sendMessageToSendToChannel(messageToSend, channel)).thenReturn(Arrays.asList(CompletableFuture.completedFuture(null)));
CompletableFuture<Void> future = testUnit.sendReminderText(REMINDER_ID, channel, remindedMember);
future.join();

4
abstracto-application/abstracto-modules/starboard/starboard-impl/src/main/java/dev/sheldan/abstracto/starboard/service/StarboardServiceBean.java
View File

@@ -113,7 +113,7 @@ public class StarboardServiceBean implements StarboardService {
@Transactional
public CompletionStage<Void> sendStarboardPostAndStore(CachedMessage message, Long starredUserId, List<Long> userExceptAuthorIds, StarboardPostModel starboardPostModel, Long userReactingId) {
MessageToSend messageToSend = templateService.renderEmbedTemplate(STARBOARD_POST_TEMPLATE, starboardPostModel);
MessageToSend messageToSend = templateService.renderEmbedTemplate(STARBOARD_POST_TEMPLATE, starboardPostModel, message.getServerId());
PostTarget starboard = postTargetManagement.getPostTarget(StarboardPostTarget.STARBOARD.getKey(), message.getServerId());
List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, StarboardPostTarget.STARBOARD, message.getServerId());
Long starboardChannelId = starboard.getChannelReference().getId();
@@ -169,7 +169,7 @@ public class StarboardServiceBean implements StarboardService {
int starCount = userExceptAuthor.size();
log.info("Updating starboard post {} in server {} with reactors {}.", post.getId(), post.getSourceChannel().getServer().getId(), starCount);
return buildStarboardPostModel(message, starCount).thenCompose(starboardPostModel -> {
MessageToSend messageToSend = templateService.renderEmbedTemplate(STARBOARD_POST_TEMPLATE, starboardPostModel);
MessageToSend messageToSend = templateService.renderEmbedTemplate(STARBOARD_POST_TEMPLATE, starboardPostModel, message.getServerId());
List<CompletableFuture<Message>> futures = postTargetService.editOrCreatedInPostTarget(post.getStarboardMessageId(), messageToSend, StarboardPostTarget.STARBOARD, message.getServerId());
Long starboardPostId = post.getId();
return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).thenAccept(aVoid -> {

4
abstracto-application/abstracto-modules/starboard/starboard-impl/src/test/java/dev/sheldan/abstracto/starboard/service/StarboardServiceBeanTest.java
View File

@@ -179,7 +179,7 @@ public class StarboardServiceBeanTest {
CachedMessage message = Mockito.mock(CachedMessage.class);
when(message.getServerId()).thenReturn(SERVER_ID);
StarboardPostModel model = Mockito.mock(StarboardPostModel.class);
when(templateService.renderEmbedTemplate(StarboardServiceBean.STARBOARD_POST_TEMPLATE, model)).thenReturn(messageToSend);
when(templateService.renderEmbedTemplate(StarboardServiceBean.STARBOARD_POST_TEMPLATE, model, SERVER_ID)).thenReturn(messageToSend);
PostTarget postTarget = Mockito.mock(PostTarget.class);
when(postTarget.getChannelReference()).thenReturn(starboardChannel);
when(starboardChannel.getId()).thenReturn(STARBOARD_CHANNEL_ID);
@@ -235,7 +235,7 @@ public class StarboardServiceBeanTest {
when(post.getSourceChannel()).thenReturn(sourceChannel);
when(post.getId()).thenReturn(starboardPostId);
MessageToSend postMessage = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(StarboardServiceBean.STARBOARD_POST_TEMPLATE), starboardPostModelArgumentCaptor.capture())).thenReturn(postMessage);
when(templateService.renderEmbedTemplate(eq(StarboardServiceBean.STARBOARD_POST_TEMPLATE), starboardPostModelArgumentCaptor.capture(), eq(SERVER_ID))).thenReturn(postMessage);
when(postTargetService.editOrCreatedInPostTarget(oldPostId, postMessage, StarboardPostTarget.STARBOARD, SERVER_ID)).thenReturn(Arrays.asList(CompletableFuture.completedFuture(sendPost)));
when(sendPost.getIdLong()).thenReturn(newPostId);
SystemConfigProperty config = Mockito.mock(SystemConfigProperty.class);

2
abstracto-application/abstracto-modules/statistic/statistic-impl/src/main/java/dev/sheldan/abstracto/statistic/emote/command/ExportEmoteStats.java
View File

@@ -101,7 +101,7 @@ public class ExportEmoteStats extends AbstractConditionableCommand {
if(tempFile.length() > maxFileSize) {
throw new UploadFileTooLargeException(tempFile.length(), maxFileSize);
}
MessageToSend messageToSend = templateService.renderEmbedTemplate(DOWNLOAD_EMOTE_STATS_RESPONSE_TEMPLATE_KEY, model);
MessageToSend messageToSend = templateService.renderEmbedTemplate(DOWNLOAD_EMOTE_STATS_RESPONSE_TEMPLATE_KEY, model, actualServer.getId());
messageToSend.setFileToSend(tempFile);
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
.thenApply(unused -> CommandResult.fromIgnored());

6
abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emote/command/ExportEmoteStatsTest.java
View File

@@ -77,7 +77,7 @@ public class ExportEmoteStatsTest {
when(fileService.createTempFile(FILE_NAME)).thenReturn(file);
when(file.length()).thenReturn(3L);
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(DOWNLOAD_EMOTE_STATS_RESPONSE_TEMPLATE_KEY), any())).thenReturn(messageToSend);
when(templateService.renderEmbedTemplate(eq(DOWNLOAD_EMOTE_STATS_RESPONSE_TEMPLATE_KEY), any(), eq(SERVER_ID))).thenReturn(messageToSend);
when(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel())).thenReturn(CommandTestUtilities.messageFutureList());
CompletableFuture<CommandResult> asyncResult = testUnit.executeAsync(commandContext);
CommandTestUtilities.checkSuccessfulCompletionAsync(asyncResult);
@@ -92,6 +92,7 @@ public class ExportEmoteStatsTest {
CommandContext commandContext = CommandTestUtilities.getWithParameters(Arrays.asList(Duration.ofHours(3)));
when(commandContext.getGuild().getIdLong()).thenReturn(SERVER_ID);
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandContext.getGuild().getMaxFileSize()).thenReturn(4L);
List<UsedEmote> usedEmotes = Arrays.asList(usedEmote);
@@ -102,7 +103,7 @@ public class ExportEmoteStatsTest {
when(fileService.createTempFile(FILE_NAME)).thenReturn(file);
when(file.length()).thenReturn(3L);
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(DOWNLOAD_EMOTE_STATS_RESPONSE_TEMPLATE_KEY), any())).thenReturn(messageToSend);
when(templateService.renderEmbedTemplate(eq(DOWNLOAD_EMOTE_STATS_RESPONSE_TEMPLATE_KEY), any(), eq(SERVER_ID))).thenReturn(messageToSend);
when(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel())).thenReturn(CommandTestUtilities.messageFutureList());
CompletableFuture<CommandResult> asyncResult = testUnit.executeAsync(commandContext);
CommandTestUtilities.checkSuccessfulCompletionAsync(asyncResult);
@@ -166,6 +167,7 @@ public class ExportEmoteStatsTest {
private void mockServerAndFileRendering(CommandContext commandContext) {
when(commandContext.getGuild().getIdLong()).thenReturn(SERVER_ID);
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
List<UsedEmote> usedEmotes = Arrays.asList(usedEmote);
when(usedEmoteManagementService.loadEmoteUsagesForServerSince(server, Instant.EPOCH)).thenReturn(usedEmotes);

4
abstracto-application/abstracto-modules/suggestion/suggestion-impl/src/main/java/dev/sheldan/abstracto/suggestion/service/SuggestionServiceBean.java
View File

@@ -77,7 +77,7 @@ public class SuggestionServiceBean implements SuggestionService {
suggestionLog.setState(SuggestionState.NEW);
suggestionLog.setSuggesterUser(suggester);
suggestionLog.setText(text);
MessageToSend messageToSend = templateService.renderEmbedTemplate(SUGGESTION_LOG_TEMPLATE, suggestionLog);
MessageToSend messageToSend = templateService.renderEmbedTemplate(SUGGESTION_LOG_TEMPLATE, suggestionLog, member.getGuild().getIdLong());
long guildId = member.getGuild().getIdLong();
log.info("Creating suggestion with id {} in server {} from member {}.", newSuggestionId, member.getGuild().getId(), member.getId());
List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, guildId);
@@ -144,7 +144,7 @@ public class SuggestionServiceBean implements SuggestionService {
MessageEmbed suggestionEmbed = embedOptional.get();
suggestionLog.setReason(text);
suggestionLog.setText(suggestionEmbed.getDescription());
MessageToSend messageToSend = templateService.renderEmbedTemplate(SUGGESTION_LOG_TEMPLATE, suggestionLog);
MessageToSend messageToSend = templateService.renderEmbedTemplate(SUGGESTION_LOG_TEMPLATE, suggestionLog, suggestionLog.getGuild().getIdLong());
List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, suggestionLog.getGuild().getIdLong());
return CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0]));
} else {

5
abstracto-application/abstracto-modules/suggestion/suggestion-impl/src/test/java/dev/sheldan/abstracto/suggestion/service/SuggestionServiceBeanTest.java
View File

@@ -106,10 +106,9 @@ public class SuggestionServiceBeanTest {
SuggestionLog log = Mockito.mock(SuggestionLog.class);
when(suggestionCreator.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(serverManagementService.loadServer(suggestionCreator.getGuild())).thenReturn(server);
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(SuggestionServiceBean.SUGGESTION_LOG_TEMPLATE), any(SuggestionLog.class))).thenReturn(messageToSend);
when(templateService.renderEmbedTemplate(eq(SuggestionServiceBean.SUGGESTION_LOG_TEMPLATE), any(SuggestionLog.class), eq(SERVER_ID))).thenReturn(messageToSend);
Message suggestionMessage = Mockito.mock(Message.class);
when(counterService.getNextCounterValue(server, SuggestionServiceBean.SUGGESTION_COUNTER_KEY)).thenReturn(SUGGESTION_ID);
AUserInAServer aUserInAServer = Mockito.mock(AUserInAServer.class);
@@ -193,7 +192,7 @@ public class SuggestionServiceBeanTest {
when(guild.getIdLong()).thenReturn(SERVER_ID);
when(suggestionMessage.getEmbeds()).thenReturn(Arrays.asList(embed));
MessageToSend updatedMessage = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(eq(SuggestionServiceBean.SUGGESTION_LOG_TEMPLATE), any(SuggestionLog.class))).thenReturn(updatedMessage);
when(templateService.renderEmbedTemplate(eq(SuggestionServiceBean.SUGGESTION_LOG_TEMPLATE), any(SuggestionLog.class), eq(SERVER_ID))).thenReturn(updatedMessage);
testUnit.updateSuggestionMessageText(CLOSING_TEXT, log, suggestionMessage);
verify(postTargetService, times(1)).sendEmbedInPostTarget(updatedMessage, SuggestionPostTarget.SUGGESTION, SERVER_ID);
}

2
abstracto-application/abstracto-modules/webservices/webservices-impl/src/main/java/dev/sheldan/abstracto/webservices/urban/command/UrbanDefine.java
View File

@@ -48,7 +48,7 @@ public class UrbanDefine extends AbstractConditionableCommand {
UrbanDefinition definition = urbanService.getUrbanDefinition(parameter);
UrbanResponseModel model = (UrbanResponseModel) ContextConverter.slimFromCommandContext(commandContext, UrbanResponseModel.class);
model.setDefinition(definition);
MessageToSend message = templateService.renderEmbedTemplate(URBAN_DEFINE_RESPONSE_MODEL_TEMPLATE_KEY, model);
MessageToSend message = templateService.renderEmbedTemplate(URBAN_DEFINE_RESPONSE_MODEL_TEMPLATE_KEY, model, commandContext.getGuild().getIdLong());
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(message, commandContext.getChannel()))
.thenApply(unused -> CommandResult.fromSuccess());
} catch (IOException e) {

6
abstracto-application/abstracto-modules/webservices/webservices-impl/src/main/java/dev/sheldan/abstracto/webservices/youtube/command/YoutubeVideoSearch.java
View File

@@ -30,6 +30,8 @@ import java.util.concurrent.CompletableFuture;
@Component
public class YoutubeVideoSearch extends AbstractConditionableCommand {
public static final String YOUTUBE_SEARCH_COMMAND_RESPONSE_TEMPLATE_KEY = "youtube_search_command_response";
public static final String YOUTUBE_SEARCH_COMMAND_RESPONSE_LINK_TEMPLATE_KEY = "youtube_search_command_response_link";
@Autowired
private YoutubeSearchService youtubeSearchService;
@@ -50,12 +52,12 @@ public class YoutubeVideoSearch extends AbstractConditionableCommand {
model.setVideo(foundVideo);
CompletableFuture<Void> infoEmbedFuture;
if(featureModeService.featureModeActive(WebserviceFeatureDefinition.YOUTUBE, commandContext.getGuild().getIdLong(), YoutubeWebServiceFeatureMode.VIDEO_DETAILS)) {
MessageToSend message = templateService.renderEmbedTemplate("youtube_search_command_response", model);
MessageToSend message = templateService.renderEmbedTemplate(YOUTUBE_SEARCH_COMMAND_RESPONSE_TEMPLATE_KEY, model, commandContext.getGuild().getIdLong());
infoEmbedFuture = FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(message, commandContext.getChannel()));
} else {
infoEmbedFuture = CompletableFuture.completedFuture(null);
}
MessageToSend linkEmbed = templateService.renderEmbedTemplate("youtube_search_command_response_link", model);
MessageToSend linkEmbed = templateService.renderEmbedTemplate(YOUTUBE_SEARCH_COMMAND_RESPONSE_LINK_TEMPLATE_KEY, model, commandContext.getGuild().getIdLong());
CompletableFuture<Void> linkEmbedFuture = FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(linkEmbed, commandContext.getChannel()));
return CompletableFuture.allOf(infoEmbedFuture, linkEmbedFuture)
.thenApply(unused -> CommandResult.fromSuccess());

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/help/Help.java
View File

@@ -163,7 +163,7 @@ public class Help implements Command {
List<ModuleDefinition> subModules = moduleService.getSubModules(moduleDefinition);
HelpModuleOverviewModel model = (HelpModuleOverviewModel) ContextConverter.fromCommandContext(commandContext, HelpModuleOverviewModel.class);
model.setModules(subModules);
MessageToSend messageToSend = templateService.renderEmbedTemplate("help_module_overview_response", model);
MessageToSend messageToSend = templateService.renderEmbedTemplate("help_module_overview_response", model, commandContext.getGuild().getIdLong());
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
.thenApply(aVoid -> CommandResult.fromIgnored());
}

45
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/ChannelServiceBean.java
View File

@@ -200,33 +200,38 @@ public class ChannelServiceBean implements ChannelService {
@Override
public List<CompletableFuture<Message>> sendMessageToSendToChannel(MessageToSend messageToSend, MessageChannel textChannel) {
String messageText = messageToSend.getMessage();
List<CompletableFuture<Message>> futures = new ArrayList<>();
MessageAction firstMessageAction = null;
List<MessageAction> allMessageActions = new ArrayList<>();
if(!StringUtils.isBlank(messageText)) {
int iterations = Math.min(messageToSend.getMessages().size(), messageToSend.getEmbeds().size());
for (int i = 0; i < iterations; i++) {
metricService.incrementCounter(MESSAGE_SEND_METRIC);
firstMessageAction = textChannel.sendMessage(messageText);
String text = messageToSend.getMessages().get(i);
MessageEmbed embed = messageToSend.getEmbeds().get(i);
MessageAction messageAction = textChannel.sendMessage(text).embed(embed);
allMessageActions.add(messageAction);
}
if(!messageToSend.getEmbeds().isEmpty()) {
if(firstMessageAction != null) {
metricService.incrementCounter(MESSAGE_SEND_METRIC);
firstMessageAction.embed(messageToSend.getEmbeds().get(0));
} else {
firstMessageAction = textChannel.sendMessage(messageToSend.getEmbeds().get(0));
}
messageToSend.getEmbeds().stream().skip(1).forEach(embed -> allMessageActions.add(sendEmbedToChannelInComplete(embed, textChannel)));
// one of these loops will get additional iterations, if the number is different, not both
for (int i = iterations; i < messageToSend.getMessages().size(); i++) {
metricService.incrementCounter(MESSAGE_SEND_METRIC);
String text = messageToSend.getMessages().get(i);
MessageAction messageAction = textChannel.sendMessage(text);
allMessageActions.add(messageAction);
}
for (int i = iterations; i < messageToSend.getEmbeds().size(); i++) {
metricService.incrementCounter(MESSAGE_SEND_METRIC);
MessageEmbed embed = messageToSend.getEmbeds().get(i);
MessageAction messageAction = textChannel.sendMessage(embed);
allMessageActions.add(messageAction);
}
if(messageToSend.hasFileToSend()) {
if(firstMessageAction != null) {
if(!allMessageActions.isEmpty()) {
// in case there has not been a message, we need to increment it
metricService.incrementCounter(MESSAGE_SEND_METRIC);
firstMessageAction.addFile(messageToSend.getFileToSend());
allMessageActions.set(0, allMessageActions.get(0).addFile(messageToSend.getFileToSend()));
} else {
firstMessageAction = textChannel.sendFile(messageToSend.getFileToSend());
metricService.incrementCounter(MESSAGE_SEND_METRIC);
allMessageActions.add(textChannel.sendFile(messageToSend.getFileToSend()));
}
}
allMessageActions.add(0, firstMessageAction);
List<Message.MentionType> allowedMentions = getAllowedMentionsFor(textChannel);
allMessageActions.forEach(messageAction ->
futures.add(messageAction.allowedMentions(allowedMentions).submit())
@@ -253,9 +258,9 @@ public class ChannelServiceBean implements ChannelService {
@Override
public CompletableFuture<Message> editMessageInAChannelFuture(MessageToSend messageToSend, MessageChannel channel, Long messageId) {
MessageAction messageAction;
if(!StringUtils.isBlank(messageToSend.getMessage())) {
if(!StringUtils.isBlank(messageToSend.getMessages().get(0))) {
log.trace("Editing message {} with new text content.", messageId);
messageAction = channel.editMessageById(messageId, messageToSend.getMessage());
messageAction = channel.editMessageById(messageId, messageToSend.getMessages().get(0));
if(messageToSend.getEmbeds() != null && !messageToSend.getEmbeds().isEmpty()) {
log.trace("Also editing the embed for message {}.", messageId);
messageAction = messageAction.embed(messageToSend.getEmbeds().get(0));
@@ -459,7 +464,7 @@ public class ChannelServiceBean implements ChannelService {
if(tempFile.length() > maxFileSize) {
throw new UploadFileTooLargeException(tempFile.length(), maxFileSize);
}
MessageToSend messageToSend = templateService.renderEmbedTemplate(messageTemplate, model);
MessageToSend messageToSend = templateService.renderEmbedTemplate(messageTemplate, model, channel.getGuild().getIdLong());
messageToSend.setFileToSend(tempFile);
return sendMessageToSendToChannel(messageToSend, channel);
} catch (IOException e) {

7
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/PostTargetServiceBean.java
View File

@@ -130,7 +130,8 @@ public class PostTargetServiceBean implements PostTargetService {
@Override
public List<CompletableFuture<Message>> editEmbedInPostTarget(Long messageId, MessageToSend message, PostTarget target) {
TextChannel textChannelForPostTarget = getTextChannelForPostTarget(target);
String messageText = message.getMessage();
// always takes the first one, only applicable for this scenario
String messageText = message.getMessages().get(0);
if(StringUtils.isBlank(messageText)) {
log.trace("Editing embeds of message {} in post target {}.", messageId, target.getName());
return Arrays.asList(channelService.editEmbedMessageInAChannel(message.getEmbeds().get(0), textChannelForPostTarget, messageId));
@@ -146,7 +147,7 @@ public class PostTargetServiceBean implements PostTargetService {
TextChannel textChannelForPostTarget = getTextChannelForPostTarget(target);
CompletableFuture<Message> messageEditFuture = new CompletableFuture<>();
futures.add(messageEditFuture);
if(StringUtils.isBlank(messageToSend.getMessage().trim())) {
if(StringUtils.isBlank(messageToSend.getMessages().get(0).trim())) {
channelService.retrieveMessageInChannel(textChannelForPostTarget, messageId).thenAccept(message -> {
log.trace("Editing existing message {} when upserting message embeds in channel {} in server {}.",
messageId, textChannelForPostTarget.getIdLong(), textChannelForPostTarget.getGuild().getId());
@@ -167,7 +168,7 @@ public class PostTargetServiceBean implements PostTargetService {
channelService.retrieveMessageInChannel(textChannelForPostTarget, messageId).thenAccept(message -> {
log.trace("Editing existing message {} when upserting message in channel {} in server {}.",
messageId, textChannelForPostTarget.getIdLong(), textChannelForPostTarget.getGuild().getId());
messageService.editMessage(message, messageToSend.getMessage(), messageToSend.getEmbeds().get(0))
messageService.editMessage(message, messageToSend.getMessages().get(0), messageToSend.getEmbeds().get(0))
.queue(messageEditFuture::complete, messageEditFuture::completeExceptionally);
}).exceptionally(throwable -> {
log.trace("Creating new message when trying to upsert a message {} in channel {} in server {}.",

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/templating/model/EmbedConfiguration.java
View File

@@ -55,6 +55,8 @@ public class EmbedConfiguration {
* The message which is posted along the {@link net.dv8tion.jda.api.entities.MessageEmbed} as a normal message.
*/
private String additionalMessage;
private Long additionalMessageLengthLimit;
private Long messageLimit;
private boolean preventEmptyEmbed = false;
}

52
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/templating/service/TemplateServiceBean.java
View File

@@ -1,7 +1,9 @@
package dev.sheldan.abstracto.core.templating.service;
import com.google.gson.Gson;
import dev.sheldan.abstracto.core.command.config.features.CoreFeatureConfig;
import dev.sheldan.abstracto.core.config.ServerContext;
import dev.sheldan.abstracto.core.service.ConfigService;
import dev.sheldan.abstracto.core.templating.Templatable;
import dev.sheldan.abstracto.core.templating.exception.TemplatingException;
import dev.sheldan.abstracto.core.templating.model.*;
@@ -13,6 +15,7 @@ import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.MessageEmbed;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -41,6 +44,9 @@ public class TemplateServiceBean implements TemplateService {
@Autowired
private ServerContext serverContext;
@Autowired
private ConfigService configService;
/**
* Formats the passed passed count with the embed used for formatting pages.
*
@@ -114,9 +120,51 @@ public class TemplateServiceBean implements TemplateService {
embeds = embedBuilders.stream().map(EmbedBuilder::build).collect(Collectors.toList());
}
List<String> messages = new ArrayList<>();
String additionalMessage = embedConfiguration.getAdditionalMessage();
if(additionalMessage != null) {
Long segmentLimit = embedConfiguration.getAdditionalMessageLengthLimit() != null ? embedConfiguration.getAdditionalMessageLengthLimit() : Long.valueOf(Message.MAX_CONTENT_LENGTH);
if(additionalMessage.length() > segmentLimit) {
int segmentStart = 0;
int segmentEnd = segmentLimit.intValue();
while(segmentStart < additionalMessage.length()) {
int segmentLength = additionalMessage.length() - segmentStart;
if(segmentLength > segmentLimit) {
int lastSpace = additionalMessage.substring(segmentStart, segmentEnd).lastIndexOf(" ");
if(lastSpace != -1) {
segmentEnd = segmentStart + lastSpace;
}
} else {
segmentEnd = additionalMessage.length();
}
String messageText = additionalMessage.substring(segmentStart, segmentEnd);
messages.add(messageText);
segmentStart = segmentEnd;
segmentEnd += segmentLimit;
}
} else {
messages.add(additionalMessage);
}
}
Long messageLimit = 100L;
if(serverContext.getServerId() != null) {
messageLimit = Math.min(messageLimit, configService.getLongValue(CoreFeatureConfig.MAX_MESSAGES_KEY, serverContext.getServerId()));
}
if(embedConfiguration.getMessageLimit() != null) {
messageLimit = Math.min(messageLimit, embedConfiguration.getMessageLimit());
}
if(embeds.size() > messageLimit) {
log.info("Limiting size of embeds. Max allowed: {}, currently: {}.", messageLimit, embeds.size());
embeds.subList(messageLimit.intValue(), embeds.size()).clear();
}
if(messages.size() > messageLimit) {
log.info("Limiting size of messages. Max allowed: {}, currently: {}.", messageLimit, messages.size());
messages.subList(messageLimit.intValue(), messages.size()).clear();
}
return MessageToSend.builder()
.embeds(embeds)
.message(embedConfiguration.getAdditionalMessage())
.messages(messages)
.build();
}
@@ -171,7 +219,7 @@ public class TemplateServiceBean implements TemplateService {
@Override
public MessageToSend renderTemplateToMessageToSend(String key, Object model) {
return MessageToSend.builder().message(renderTemplate(key, model)).build();
return MessageToSend.builder().messages(Arrays.asList(renderTemplate(key, model))).build();
}
@Override

3
abstracto-application/core/core-impl/src/main/resources/abstracto.properties
View File

@@ -13,5 +13,8 @@ abstracto.systemConfigs.prefix.stringValue=!
abstracto.systemConfigs.noCommandFoundReporting.name=noCommandFoundReporting
abstracto.systemConfigs.noCommandFoundReporting.stringValue=true
abstracto.systemConfigs.maxMessages.name=maxMessages
abstracto.systemConfigs.maxMessages.longValue=3
abstracto.featureFlags.core.featureName=core
abstracto.featureFlags.core.enabled=true

105
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/templating/service/TemplateServiceBeanTest.java
View File

@@ -1,7 +1,9 @@
package dev.sheldan.abstracto.core.templating.service;
import com.google.gson.Gson;
import dev.sheldan.abstracto.core.command.config.features.CoreFeatureConfig;
import dev.sheldan.abstracto.core.config.ServerContext;
import dev.sheldan.abstracto.core.service.ConfigService;
import dev.sheldan.abstracto.core.templating.Templatable;
import dev.sheldan.abstracto.core.templating.exception.TemplatingException;
import dev.sheldan.abstracto.core.templating.model.*;
@@ -54,6 +56,9 @@ public class TemplateServiceBeanTest {
@Mock
private Configuration configuration;
@Mock
private ConfigService configService;
@Mock
private Gson gson;
@@ -66,15 +71,20 @@ public class TemplateServiceBeanTest {
@Test
public void testSimpleTemplate() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
when(configuration.getTemplate(TEMPLATE_KEY, null, SERVER_ID, null, true, false)).thenReturn(getSimpleTemplate());
String rendered = templateServiceBean.renderSimpleTemplate(TEMPLATE_KEY);
Assert.assertEquals(SIMPLE_TEMPLATE_SOURCE, rendered);
}
private void setupServerAware() {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
when(configService.getLongValue(CoreFeatureConfig.MAX_MESSAGES_KEY, SERVER_ID)).thenReturn(5L);
}
@Test
public void renderTemplatable() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
when(configuration.getTemplate(TEMPLATE_KEY, null, SERVER_ID, null, true, false)).thenReturn(getSimpleTemplate());
Templatable templatable = getTemplatableWithSimpleTemplate();
String rendered = templateServiceBean.renderTemplatable(templatable);
@@ -82,8 +92,62 @@ public class TemplateServiceBeanTest {
}
@Test
public void testTemplateWithMapParameter() throws IOException, TemplateException {
public void testRenderTooLongAdditionalMessage() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
String additionalMessage = RandomStringUtils.randomAlphabetic(3500);
when(configService.getLongValue(CoreFeatureConfig.MAX_MESSAGES_KEY, SERVER_ID)).thenReturn(5L);
String templateContent = String.format("{ \"additionalMessage\": \"%s\"}", additionalMessage);
EmbedConfiguration config = Mockito.mock(EmbedConfiguration.class);
when(config.getAdditionalMessageLengthLimit()).thenReturn(2000L);
when(config.getAdditionalMessage()).thenReturn(additionalMessage);
when(configuration.getTemplate(getEmbedTemplateKey(), null, SERVER_ID, null, true, false)).thenReturn(new Template(getEmbedTemplateKey(), templateContent, getNonMockedConfiguration()));
when(gson.fromJson(templateContent, EmbedConfiguration.class)).thenReturn(config);
MessageToSend messageToSend = templateServiceBean.renderEmbedTemplate(TEMPLATE_KEY, new Object());
Assert.assertEquals(2, messageToSend.getMessages().size());
Assert.assertEquals(additionalMessage.substring(0, 2000), messageToSend.getMessages().get(0));
Assert.assertEquals(additionalMessage.substring(2000, 3500), messageToSend.getMessages().get(1));
}
@Test
public void testRenderEmbedWithMessageLimit() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
String additionalMessage = RandomStringUtils.randomAlphabetic(3500);
when(configService.getLongValue(CoreFeatureConfig.MAX_MESSAGES_KEY, SERVER_ID)).thenReturn(5L);
String templateContent = String.format("{ \"additionalMessage\": \"%s\", \"messageLimit\": 1}", additionalMessage);
EmbedConfiguration config = Mockito.mock(EmbedConfiguration.class);
when(config.getAdditionalMessageLengthLimit()).thenReturn(2000L);
when(config.getAdditionalMessage()).thenReturn(additionalMessage);
when(config.getMessageLimit()).thenReturn(1L);
when(configuration.getTemplate(getEmbedTemplateKey(), null, SERVER_ID, null, true, false)).thenReturn(new Template(getEmbedTemplateKey(), templateContent, getNonMockedConfiguration()));
when(gson.fromJson(templateContent, EmbedConfiguration.class)).thenReturn(config);
MessageToSend messageToSend = templateServiceBean.renderEmbedTemplate(TEMPLATE_KEY, new Object());
Assert.assertEquals(1, messageToSend.getMessages().size());
Assert.assertEquals(additionalMessage.substring(0, 2000), messageToSend.getMessages().get(0));
}
@Test
public void testRenderTooLongMultipleAdditionalMessages() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
String additionalMessage = RandomStringUtils.randomAlphabetic(3500);
when(configService.getLongValue(CoreFeatureConfig.MAX_MESSAGES_KEY, SERVER_ID)).thenReturn(5L);
String templateContent = String.format("{ \"additionalMessage\": \"%s\"}", additionalMessage);
EmbedConfiguration config = Mockito.mock(EmbedConfiguration.class);
when(config.getAdditionalMessageLengthLimit()).thenReturn(500L);
when(config.getAdditionalMessage()).thenReturn(additionalMessage);
when(configuration.getTemplate(getEmbedTemplateKey(), null, SERVER_ID, null, true, false)).thenReturn(new Template(getEmbedTemplateKey(), templateContent, getNonMockedConfiguration()));
when(gson.fromJson(templateContent, EmbedConfiguration.class)).thenReturn(config);
MessageToSend messageToSend = templateServiceBean.renderEmbedTemplate(TEMPLATE_KEY, new Object());
Assert.assertEquals(5, messageToSend.getMessages().size());
Assert.assertEquals(additionalMessage.substring(0, 500), messageToSend.getMessages().get(0));
Assert.assertEquals(additionalMessage.substring(500, 1000), messageToSend.getMessages().get(1));
Assert.assertEquals(additionalMessage.substring(1000, 1500), messageToSend.getMessages().get(2));
Assert.assertEquals(additionalMessage.substring(1500, 2000), messageToSend.getMessages().get(3));
Assert.assertEquals(additionalMessage.substring(2000, 2500), messageToSend.getMessages().get(4));
}
@Test
public void testTemplateWithMapParameter() throws IOException, TemplateException {
setupServerAware();
when(configuration.getTemplate(TEMPLATE_KEY, null, SERVER_ID, null, true, false)).thenReturn(getSimpleTemplate());
String rendered = templateServiceBean.renderTemplateWithMap(TEMPLATE_KEY, new HashMap<>());
Assert.assertEquals(SIMPLE_TEMPLATE_SOURCE, rendered);
@@ -91,7 +155,7 @@ public class TemplateServiceBeanTest {
@Test
public void testEmbedWithDescription() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
String descriptionText = "test";
String fullEmbedTemplateKey = getEmbedTemplateKey();
when(configuration.getTemplate(fullEmbedTemplateKey, null, SERVER_ID, null, true, false)).thenReturn(getEmbedTemplateWithDescription(descriptionText));
@@ -102,11 +166,11 @@ public class TemplateServiceBeanTest {
@Test
public void testEmbedWithAllUsableAttributes() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
when(configuration.getTemplate(getEmbedTemplateKey(), null, SERVER_ID, null, true, false)).thenReturn(getEmbedTemplateWithFallFieldsUsedOnce());
when(gson.fromJson(getFullEmbedConfigString(), EmbedConfiguration.class)).thenReturn(getFullEmbedConfiguration());
MessageToSend messageToSend = templateServiceBean.renderEmbedTemplate(TEMPLATE_KEY, new HashMap<>());
Assert.assertEquals("additionalMessage", messageToSend.getMessage());
Assert.assertEquals("additionalMessage", messageToSend.getMessages().get(0));
MessageEmbed onlyEmbed = messageToSend.getEmbeds().get(0);
Assert.assertEquals(EXAMPLE_URL, onlyEmbed.getAuthor().getIconUrl());
Assert.assertEquals("name", onlyEmbed.getAuthor().getName());
@@ -129,7 +193,7 @@ public class TemplateServiceBeanTest {
@Test
public void testEmbedWithTooLongDescriptionNoSpace() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
int tooMuchCharacterCount = 1024;
String descriptionText = RandomStringUtils.randomAlphabetic(MessageEmbed.TEXT_MAX_LENGTH + tooMuchCharacterCount);
when(configuration.getTemplate(getEmbedTemplateKey(), null, SERVER_ID, null, true, false)).thenReturn(getEmbedTemplateWithDescription(descriptionText));
@@ -146,7 +210,7 @@ public class TemplateServiceBeanTest {
@Test
public void testEmbedWithTooManyFields() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
int totalFieldCount = 30;
when(configuration.getTemplate(getEmbedTemplateKey(), null, SERVER_ID, null, true, false)).thenReturn(getEmbedTemplateWithFieldCount(totalFieldCount));
when(configuration.getTemplate(EMBED_PAGE_COUNT_TEMPLATE, null, SERVER_ID, null, true, false)).thenReturn(getPageCountTemplate(1));
@@ -162,6 +226,7 @@ public class TemplateServiceBeanTest {
public void testEmbedWithTooLongFieldNoSpace() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
String fieldValue = RandomStringUtils.randomAlphabetic(1500);
when(configService.getLongValue(CoreFeatureConfig.MAX_MESSAGES_KEY, SERVER_ID)).thenReturn(5L);
when(configuration.getTemplate(getEmbedTemplateKey(), null, SERVER_ID, null, true, false)).thenReturn(getEmbedTemplateWithTooLongField(fieldValue));
when(gson.fromJson(getSingleFieldWithValue(fieldValue), EmbedConfiguration.class)).thenReturn(getEmbedWithSingleFieldOfValue(fieldValue));
MessageToSend messageToSend = templateServiceBean.renderEmbedTemplate(TEMPLATE_KEY, new HashMap<>());
@@ -173,7 +238,7 @@ public class TemplateServiceBeanTest {
@Test
public void testEmbedWithTooLongFieldWithSpace() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
int partsLength = 750;
String firstPart = RandomStringUtils.randomAlphabetic(partsLength);
String secondPart = RandomStringUtils.randomAlphabetic(partsLength);
@@ -189,7 +254,7 @@ public class TemplateServiceBeanTest {
@Test
public void testDescriptionWithOneSpace() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
int partLengths = 1024;
String firstPart = RandomStringUtils.randomAlphabetic(partLengths);
String secondPart = RandomStringUtils.randomAlphabetic(partLengths);
@@ -209,7 +274,7 @@ public class TemplateServiceBeanTest {
@Test
public void testDescriptionWithTwoSpacesAndLongChunks() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
int partLengths = 1024;
String firstPart = RandomStringUtils.randomAlphabetic(partLengths);
String secondPart = RandomStringUtils.randomAlphabetic(partLengths);
@@ -233,7 +298,7 @@ public class TemplateServiceBeanTest {
@Test
public void testDescriptionWithMultipleSpacesSplitIntoTwo() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
int partLengths = 750;
String firstPart = RandomStringUtils.randomAlphabetic(partLengths);
String secondPart = RandomStringUtils.randomAlphabetic(partLengths);
@@ -254,7 +319,7 @@ public class TemplateServiceBeanTest {
@Test
public void testFieldLengthTooLongForEmbed() throws IOException, TemplateException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
int partLengths = 1000;
String fieldValue = RandomStringUtils.randomAlphabetic(partLengths);
String firstField = fieldValue + "a";
@@ -286,25 +351,21 @@ public class TemplateServiceBeanTest {
@Test(expected = TemplatingException.class)
public void tryToRenderMissingTemplate() throws IOException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
when(configuration.getTemplate(TEMPLATE_KEY, null, SERVER_ID, null, true, false)).thenThrow(new TemplateNotFoundException(TEMPLATE_KEY, new Object(), ""));
templateServiceBean.renderSimpleTemplate(TEMPLATE_KEY);
}
@Test(expected = TemplatingException.class)
public void tryToRenderMissingEmbedTemplate() throws IOException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
when(configuration.getTemplate(getEmbedTemplateKey(), null, SERVER_ID, null, true, false)).thenThrow(new TemplateNotFoundException(TEMPLATE_KEY, new Object(), ""));
templateServiceBean.renderEmbedTemplate(TEMPLATE_KEY, new Object());
}
private String getEmbedTemplateKey() {
return TEMPLATE_KEY + "_embed";
}
@Test(expected = TemplatingException.class)
public void tryToRenderMissingTemplateWithMap() throws IOException {
when(serverContext.getServerId()).thenReturn(SERVER_ID);
setupServerAware();
when(configuration.getTemplate(TEMPLATE_KEY, null, SERVER_ID, null, true, false)).thenThrow(new TemplateNotFoundException(TEMPLATE_KEY, new Object(), ""));
templateServiceBean.renderTemplateWithMap(TEMPLATE_KEY, new HashMap<>());
}
@@ -319,6 +380,10 @@ public class TemplateServiceBeanTest {
return EmbedConfiguration.builder().fields(fields).build();
}
private String getEmbedTemplateKey() {
return TEMPLATE_KEY + "_embed";
}
private EmbedConfiguration getEmbedWithFields(List<String> fieldValues) {
List<EmbedField> fields = new ArrayList<>();
fieldValues.forEach(s -> {

3
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/config/features/CoreFeatureConfig.java
View File

@@ -13,6 +13,7 @@ public class CoreFeatureConfig implements FeatureConfig {
public static final String NO_COMMAND_REPORTING_CONFIG_KEY = "noCommandFoundReporting";
public static final String SUCCESS_REACTION_KEY = "successReaction";
public static final String WARN_REACTION_KEY = "warnReaction";
public static final String MAX_MESSAGES_KEY = "maxMessages";
@Override
public FeatureDefinition getFeature() {
@@ -26,6 +27,6 @@ public class CoreFeatureConfig implements FeatureConfig {
@Override
public List<String> getRequiredSystemConfigKeys() {
return Arrays.asList(NO_COMMAND_REPORTING_CONFIG_KEY);
return Arrays.asList(NO_COMMAND_REPORTING_CONFIG_KEY, MAX_MESSAGES_KEY);
}
}

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/templating/model/MessageToSend.java
View File

@@ -24,7 +24,7 @@ public class MessageToSend {
/**
* The string content to be used in the first message.
*/
private String message;
private List<String> messages;
/**
* The file handle to send attached to the message.
*/