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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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