[AB-xxx] adding ability to add additional channels to a post target

adding auto complete to post target command
2026-01-07 09:47:55 +00:00 · 2025-12-17 23:54:54 +01:00
parent 0f6adacd90
commit 274dd77eeb
31 changed files with 287 additions and 83 deletions
--- a/abstracto-application/abstracto-modules/anti-raid/anti-raid-impl/src/main/java/dev/sheldan/abstracto/antiraid/service/MassPingServiceBean.java
+++ b/abstracto-application/abstracto-modules/anti-raid/anti-raid-impl/src/main/java/dev/sheldan/abstracto/antiraid/service/MassPingServiceBean.java
@@ -108,6 +108,6 @@ public class MassPingServiceBean implements MassPingService {
                .memberDisplay(MemberDisplay.fromMember(member))
                .build();
        MessageToSend messageToSend = templateService.renderEmbedTemplate(MASS_PING_MUTE_NOTIFICATION_TEMPLATE_KEY, model, member.getGuild().getIdLong());
-        return FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, AntiRaidPostTarget.MASS_PING_LOG, member.getGuild().getIdLong()));
+        return FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(messageToSend, AntiRaidPostTarget.MASS_PING_LOG, member.getGuild().getIdLong()));
    }
 }
--- a/abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/service/GiveawayServiceBean.java
+++ b/abstracto-application/abstracto-modules/giveaway/giveaway-impl/src/main/java/dev/sheldan/abstracto/giveaway/service/GiveawayServiceBean.java
@@ -134,7 +134,7 @@ public class GiveawayServiceBean implements GiveawayService {
        if(giveawayCreationRequest.getTargetChannel() == null) {
            log.info("Sending giveaway to post target in server {}", serverId);
            postTargetService.validatePostTarget(GiveawayPostTarget.GIVEAWAYS, serverId);
-            messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, GiveawayPostTarget.GIVEAWAYS, serverId);
+            messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, GiveawayPostTarget.GIVEAWAYS, serverId).get(0);
        } else {
            log.info("Sending giveaway to channel {} in server {}.", giveawayCreationRequest.getTargetChannel().getId(), serverId);
            messageFutures = channelService.sendMessageToSendToChannel(messageToSend, giveawayCreationRequest.getTargetChannel());
--- a/abstracto-application/abstracto-modules/invite-filter/invite-filter-impl/src/main/java/dev/sheldan/abstracto/invitefilter/service/InviteLinkFilterServiceBean.java
+++ b/abstracto-application/abstracto-modules/invite-filter/invite-filter-impl/src/main/java/dev/sheldan/abstracto/invitefilter/service/InviteLinkFilterServiceBean.java
@@ -254,8 +254,8 @@ public class InviteLinkFilterServiceBean implements InviteLinkFilterService {
        log.info("Sending notification about {} deleted invite links in guild {} from user {} in channel {} in message {}.",
                codes.size(), serverId, message.getAuthor().getIdLong(), message.getChannel().getIdLong(), message.getIdLong());
        MessageToSend messageToSend = templateService.renderEmbedTemplate(INVITE_LINK_DELETED_NOTIFICATION_EMBED_TEMPLATE_KEY, model, message.getGuild().getIdLong());
-        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, InviteFilterPostTarget.INVITE_DELETE_LOG, serverId);
-        return FutureUtils.toSingleFutureGeneric(messageFutures).thenAccept(unused ->
+        List<List<CompletableFuture<Message>>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, InviteFilterPostTarget.INVITE_DELETE_LOG, serverId);
+        return FutureUtils.toSingleFutureGenericList(messageFutures).thenAccept(unused ->
                log.debug("Successfully send notification about deleted invite link in message {}.", message.getIdLong())
        );
    }
--- a/abstracto-application/abstracto-modules/logging/logging-impl/src/main/java/dev/sheldan/abstracto/logging/listener/JoinLogger.java
+++ b/abstracto-application/abstracto-modules/logging/logging-impl/src/main/java/dev/sheldan/abstracto/logging/listener/JoinLogger.java
@@ -37,7 +37,7 @@ public class JoinLogger implements AsyncJoinListener {
                .build();
        log.debug("Logging join event for user {} in server {}.", listenerModel.getMember().getIdLong(), listenerModel.getServerId());
        MessageToSend messageToSend = templateService.renderEmbedTemplate(USER_JOIN_TEMPLATE, model, listenerModel.getServerId());
-        FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, LoggingPostTarget.JOIN_LOG, listenerModel.getServerId()))
+        FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(messageToSend, LoggingPostTarget.JOIN_LOG, listenerModel.getServerId()))
        .exceptionally(throwable -> {
            log.error("Failed to send member joining log.", throwable);
            return null;
--- a/abstracto-application/abstracto-modules/logging/logging-impl/src/main/java/dev/sheldan/abstracto/logging/listener/LeaveLogger.java
+++ b/abstracto-application/abstracto-modules/logging/logging-impl/src/main/java/dev/sheldan/abstracto/logging/listener/LeaveLogger.java
@@ -57,7 +57,7 @@ public class LeaveLogger implements AsyncLeaveListener {
                .build();
        log.debug("Logging leave event for user {} in server {}.", listenerModel.getUser().getIdLong(), listenerModel.getServerId());
        MessageToSend messageToSend = templateService.renderEmbedTemplate(USER_LEAVE_TEMPLATE, model, listenerModel.getServerId());
-        FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, LoggingPostTarget.LEAVE_LOG, listenerModel.getServerId()))
+        FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(messageToSend, LoggingPostTarget.LEAVE_LOG, listenerModel.getServerId()))
        .exceptionally(throwable -> {
            log.error("Failed to send member leaving log.", throwable);
            return null;
--- a/abstracto-application/abstracto-modules/logging/logging-impl/src/main/java/dev/sheldan/abstracto/logging/listener/MessageDeleteLogListener.java
+++ b/abstracto-application/abstracto-modules/logging/logging-impl/src/main/java/dev/sheldan/abstracto/logging/listener/MessageDeleteLogListener.java
@@ -69,7 +69,7 @@ public class MessageDeleteLogListener implements AsyncMessageDeletedListener {
                .member(authorMember)
                .build();
        MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_DELETED_TEMPLATE, logModel, messageFromCache.getServerId());
-        FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.DELETE_LOG, messageFromCache.getServerId()))
+        FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.DELETE_LOG, messageFromCache.getServerId()))
        .exceptionally(throwable -> {
            log.error("Failed to send message deleted log.", throwable);
            return null;
@@ -86,7 +86,7 @@ public class MessageDeleteLogListener implements AsyncMessageDeletedListener {
                        .member(authorMember)
                        .build();
                MessageToSend attachmentEmbed = templateService.renderEmbedTemplate(MESSAGE_DELETED_ATTACHMENT_TEMPLATE, attachmentLogModel, messageFromCache.getServerId());
-                FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(attachmentEmbed, LoggingPostTarget.DELETE_LOG, messageFromCache.getServerId()))
+                FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(attachmentEmbed, LoggingPostTarget.DELETE_LOG, messageFromCache.getServerId()))
                .exceptionally(throwable -> {
                    log.error("Failed to send message deleted log.", throwable);
                    return null;
--- a/abstracto-application/abstracto-modules/logging/logging-impl/src/main/java/dev/sheldan/abstracto/logging/listener/MessageEditedListener.java
+++ b/abstracto-application/abstracto-modules/logging/logging-impl/src/main/java/dev/sheldan/abstracto/logging/listener/MessageEditedListener.java
@@ -66,7 +66,7 @@ public class MessageEditedListener implements AsyncMessageUpdatedListener {
                .member(messageAfter.getMember())
                .build();
        MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_EDITED_TEMPLATE, lodModel, model.getServerId());
-        FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.EDIT_LOG, model.getServerId()))
+        FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.EDIT_LOG, model.getServerId()))
        .exceptionally(throwable -> {
            log.error("Failed to send message edited log.", throwable);
            return null;
@@ -90,7 +90,7 @@ public class MessageEditedListener implements AsyncMessageUpdatedListener {
                        .build();
                MessageToSend attachmentEmbed = templateService.renderEmbedTemplate(MESSAGE_EDITED_ATTACHMENT_REMOVED_TEMPLATE,
                        attachmentModel, messageBefore.getServerId());
-                FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(attachmentEmbed, LoggingPostTarget.DELETE_LOG, messageBefore.getServerId()))
+                FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(attachmentEmbed, LoggingPostTarget.DELETE_LOG, messageBefore.getServerId()))
                .exceptionally(throwable -> {
                    log.error("Failed to send message edited attachment log.", throwable);
                    return null;
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/BanServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/BanServiceBean.java
@@ -168,14 +168,14 @@ public class BanServiceBean implements BanService {
    @Transactional
    public CompletableFuture<Void> sendUnBanLogMessage(UserUnBannedLogModel model, Long serverId) {
        MessageToSend messageToSend = templateService.renderEmbedTemplate(USER_UN_BANNED_NOTIFICATION_TEMPLATE, model, serverId);
-        return FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, ModerationPostTarget.BAN_LOG, serverId));
+        return FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(messageToSend, ModerationPostTarget.BAN_LOG, serverId));
    }

    @Override
    @Transactional
    public CompletableFuture<Void> sendBanLogMessage(UserBannedLogModel model, Long serverId) {
        MessageToSend messageToSend = templateService.renderEmbedTemplate(USER_BANNED_NOTIFICATION_TEMPLATE, model, serverId);
-        return FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, ModerationPostTarget.BAN_LOG, serverId));
+        return FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(messageToSend, ModerationPostTarget.BAN_LOG, serverId));
    }

 }
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/InfractionServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/InfractionServiceBean.java
@@ -129,7 +129,7 @@ public class InfractionServiceBean implements InfractionService {
                    .build();
            infractionLevelChangedListenerManager.sendInfractionLevelChangedEvent(newLevel, oldLevel, currentPoints, oldPoints, ServerUser.fromAUserInAServer(aUserInAServer));
            MessageToSend messageToSend = templateService.renderEmbedTemplate(INFRACTION_NOTIFICATION_TEMPLATE_KEY, model, serverId);
-            return FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, InfractionPostTarget.INFRACTION_NOTIFICATION, serverId));
+            return FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(messageToSend, InfractionPostTarget.INFRACTION_NOTIFICATION, serverId));
        } else {
            return CompletableFuture.completedFuture(null);
        }
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/KickServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/KickServiceBean.java
@@ -125,7 +125,7 @@ public class KickServiceBean implements KickService {
    public CompletableFuture<Message> sendKicklog(KickLogModel kickLogModel, Long serverId) {
        MessageToSend warnLogMessage = templateService.renderEmbedTemplate(KICK_LOG_TEMPLATE, kickLogModel, serverId);
        log.debug("Sending kick log message in guild {}.", serverId);
-        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(warnLogMessage, ModerationPostTarget.KICK_LOG, serverId);
+        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(warnLogMessage, ModerationPostTarget.KICK_LOG, serverId).get(0);
        return FutureUtils.toSingleFutureGeneric(messageFutures).thenApply(unused -> messageFutures.get(0).join());
    }

--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/MuteServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/MuteServiceBean.java
@@ -320,7 +320,7 @@ public class MuteServiceBean implements MuteService {
    @Override
    public CompletableFuture<Void> sendMuteLogMessage(MuteLogModel model, Long serverId) {
        MessageToSend message = templateService.renderEmbedTemplate(MuteServiceBean.MUTE_LOG_TEMPLATE, model, serverId);
-        return FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, serverId));
+        return FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, serverId));
    }

    @Override
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/ReactionReportServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/ReactionReportServiceBean.java
@@ -114,7 +114,7 @@ public class ReactionReportServiceBean implements ReactionReportService {
                    .reportedMessage(reportedMessage)
                    .build();
            MessageToSend messageToSend = templateService.renderEmbedTemplate(REACTION_REPORT_TEMPLATE_KEY, model, serverId);
-            List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, ReactionReportPostTarget.REACTION_REPORTS, serverId);
+            List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, ReactionReportPostTarget.REACTION_REPORTS, serverId).get(0);
            return FutureUtils.toSingleFutureGeneric(messageFutures)
                    .thenAccept(unused -> reportMessageCreatedListenerManager.sendReportMessageCreatedEvent(reportedMessage, messageFutures.get(0).join(), anonymous ? null : reporter))
                    .thenAccept(unused -> {
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/WarnServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/WarnServiceBean.java
@@ -120,7 +120,7 @@ public class WarnServiceBean implements WarnService {
                .reason(reason)
                .build();
        MessageToSend message = renderMessageModel(warnContext, guild.getIdLong());
-        List<CompletableFuture<Message>> futures = postTargetService.sendEmbedInPostTarget(message, WarningPostTarget.WARN_LOG, guild.getIdLong());
+        List<CompletableFuture<Message>> futures = postTargetService.sendEmbedInPostTarget(message, WarningPostTarget.WARN_LOG, guild.getIdLong()).get(0);
        return FutureUtils.toSingleFutureGeneric(futures).thenCompose(unused -> futures.get(0));
    }

@@ -363,7 +363,7 @@ public class WarnServiceBean implements WarnService {
                .warnings(warnDecayWarnings)
                .build();
        MessageToSend messageToSend = templateService.renderEmbedTemplate(WARN_DECAY_LOG_TEMPLATE_KEY, warnDecayLogModel, serverId);
-        return FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, WarnDecayPostTarget.DECAY_LOG, server.getId()));
+        return FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(messageToSend, WarnDecayPostTarget.DECAY_LOG, server.getId()));
    }

    @Override
--- a/abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/service/ModMailThreadServiceBean.java
+++ b/abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/service/ModMailThreadServiceBean.java
@@ -332,7 +332,7 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
    public CompletableFuture<Void> sendModMailNotification(User user, GuildMessageChannel channel, boolean appeal) {
        Long serverId = channel.getGuild().getIdLong();
        MessageToSend messageToSend = getModmailNotificationMessageToSend(user, channel, serverId, true, appeal);
-        return FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, ModMailPostTargets.MOD_MAIL_PING, serverId));
+        return FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(messageToSend, ModMailPostTargets.MOD_MAIL_PING, serverId));
    }

    private MessageToSend getModmailNotificationMessageToSend(User user, GuildMessageChannel channel, Long serverId, boolean pingRole, boolean appeal) {
@@ -1023,7 +1023,7 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
            ModMailThread modMailThread = modMailThreadManagementService.getById(modmailThreadId);
            return channelService.sendMessageEmbedToSendToAChannel(messageToSend, modMailThread.getChannel());
        } else {
-            return postTargetService.sendEmbedInPostTarget(messageToSend, ModMailPostTargets.MOD_MAIL_LOG, model.getServerId());
+            return postTargetService.sendEmbedInPostTarget(messageToSend, ModMailPostTargets.MOD_MAIL_LOG, model.getServerId()).get(0);
        }
    }

@@ -1064,7 +1064,7 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
            ModMailLoggedMessageModel message = loadedMessages.get(i);
            log.debug("Sending message {} of modmail thread {} to modmail log post target.", modMailThreadId, message.getMessage().getId());
            MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_close_logged_message", message, updateMessage.getGuild().getIdLong());
-            List<CompletableFuture<Message>> logFuture = postTargetService.sendEmbedInPostTarget(messageToSend, ModMailPostTargets.MOD_MAIL_LOG, updateMessage.getGuild().getIdLong());
+            List<CompletableFuture<Message>> logFuture = postTargetService.sendEmbedInPostTarget(messageToSend, ModMailPostTargets.MOD_MAIL_LOG, updateMessage.getGuild().getIdLong()).get(0);
            if(i != 0 && (i % 10) == 0) {
                progressModel.setLoggedMessages(i);
                messageService.editMessageWithNewTemplate(updateMessage, MODMAIL_CLOSE_PROGRESS_TEMPLATE_KEY, progressModel);
--- a/abstracto-application/abstracto-modules/profanity-filter/profanity-filter-impl/src/main/java/dev/sheldan/abstracto/profanityfilter/service/ProfanityFilterServiceBean.java
+++ b/abstracto-application/abstracto-modules/profanity-filter/profanity-filter-impl/src/main/java/dev/sheldan/abstracto/profanityfilter/service/ProfanityFilterServiceBean.java
@@ -126,7 +126,7 @@ public class ProfanityFilterServiceBean implements ProfanityFilterService {
                .build();
        MessageToSend messageToSend = templateService.renderEmbedTemplate(PROFANITY_REPORT_TEMPLATE_KEY, reportModel, serverId);
        List<CompletableFuture<Message>> messageFutures = postTargetService
-                .sendEmbedInPostTarget(messageToSend, ProfanityFilterPostTarget.PROFANITY_FILTER_QUEUE, serverId);
+                .sendEmbedInPostTarget(messageToSend, ProfanityFilterPostTarget.PROFANITY_FILTER_QUEUE, serverId).get(0);
        Long profanityRegexId = foundProfanityRegex.getId();
        return FutureUtils.toSingleFutureGeneric(messageFutures).thenCompose(aVoid -> {
            Message createdMessage = messageFutures.get(0).join();
--- a/abstracto-application/abstracto-modules/starboard/starboard-impl/src/main/java/dev/sheldan/abstracto/starboard/service/StarboardServiceBean.java
+++ b/abstracto-application/abstracto-modules/starboard/starboard-impl/src/main/java/dev/sheldan/abstracto/starboard/service/StarboardServiceBean.java
@@ -118,7 +118,7 @@ public class StarboardServiceBean implements StarboardService {
    public CompletionStage<Void> sendStarboardPostAndStore(CachedMessage message, Long starredUserId, List<Long> userExceptAuthorIds, StarboardPostModel starboardPostModel, Long userReactingId) {
        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());
+        List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, StarboardPostTarget.STARBOARD, message.getServerId()).get(0);
        Long starboardChannelId = starboard.getChannelReference().getId();
        return CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenAccept(aVoid ->
            self.persistPost(message, userExceptAuthorIds, completableFutures, starboardChannelId, starredUserId, userReactingId)
--- a/abstracto-application/abstracto-modules/starboard/starboard-impl/src/test/java/dev/sheldan/abstracto/starboard/service/StarboardServiceBeanTest.java
+++ b/abstracto-application/abstracto-modules/starboard/starboard-impl/src/test/java/dev/sheldan/abstracto/starboard/service/StarboardServiceBeanTest.java
@@ -185,7 +185,7 @@ public class StarboardServiceBeanTest {
        when(postTarget.getChannelReference()).thenReturn(starboardChannel);
        when(starboardChannel.getId()).thenReturn(STARBOARD_CHANNEL_ID);
        when(postTargetManagement.getPostTarget(StarboardPostTarget.STARBOARD.getKey(), SERVER_ID)).thenReturn(postTarget);
-        when(postTargetService.sendEmbedInPostTarget(messageToSend, StarboardPostTarget.STARBOARD, SERVER_ID)).thenReturn(Arrays.asList(CompletableFuture.completedFuture(null)));
+        when(postTargetService.sendEmbedInPostTarget(messageToSend, StarboardPostTarget.STARBOARD, SERVER_ID)).thenReturn(List.of(List.of(CompletableFuture.completedFuture(null))));
        ArrayList<Long> userExceptAuthorIds = new ArrayList<>();
        testUnit.sendStarboardPostAndStore(message, STARRED_USER_ID, userExceptAuthorIds, model, STARRING_USER_ID);
        verify(self, times(1)).persistPost(eq(message), eq(userExceptAuthorIds), any(), eq(STARBOARD_CHANNEL_ID), eq(STARRED_USER_ID), eq(STARRING_USER_ID));
--- a/abstracto-application/abstracto-modules/suggestion/suggestion-impl/src/main/java/dev/sheldan/abstracto/suggestion/service/PollServiceBean.java
+++ b/abstracto-application/abstracto-modules/suggestion/suggestion-impl/src/main/java/dev/sheldan/abstracto/suggestion/service/PollServiceBean.java
@@ -212,7 +212,7 @@ public class PollServiceBean implements PollService {
                .build();
        componentPayloadManagementService.createButtonPayload(buttonConfigModel, serverId);
        MessageToSend messageToSend = templateService.renderEmbedTemplate(SERVER_POLL_TEMPLATE_KEY, model, serverId);
-        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, PollPostTarget.POLLS, serverId);
+        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, PollPostTarget.POLLS, serverId).get(0);
        return FutureUtils.toSingleFutureGeneric(messageFutures)
                .thenAccept(unused -> self.persistPoll(messageFutures.get(0).join(), pollCreationRequest));
    }
@@ -373,7 +373,7 @@ public class PollServiceBean implements PollService {
                .build();
        MessageToSend messageToSend = templateService.renderEmbedTemplate(SERVER_POLL_EVALUATION_UPDATE_TEMPLATE_KEY, model, serverId);
        log.info("Sending update message for poll evaluation of server poll {} in server {}.", pollId, serverId);
-        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, PollPostTarget.POLLS, serverId);
+        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, PollPostTarget.POLLS, serverId).get(0);
        GuildMessageChannel channel = channelService.getMessageChannelFromServer(serverId, poll.getChannel().getId());
        log.info("Cleaning existing components in message {} for server poll {} in server {}.", poll.getMessageId(), pollId, serverId);
        CompletableFuture<Message> cleanMessageFuture = channelService.removeComponents(channel, poll.getMessageId());
@@ -408,7 +408,7 @@ public class PollServiceBean implements PollService {
                .build();
        MessageToSend messageToSend = templateService.renderEmbedTemplate(SERVER_POLL_REMINDER_TEMPLATE_KEY, model, serverId);
        log.info("Sending poll reminder about server poll {} in server {}.", pollId, serverId);
-        return FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, PollPostTarget.POLL_REMINDER, serverId));
+        return FutureUtils.toSingleFutureGenericList(postTargetService.sendEmbedInPostTarget(messageToSend, PollPostTarget.POLL_REMINDER, serverId));
    }

    @Override
@@ -464,10 +464,10 @@ public class PollServiceBean implements PollService {
            schedulerService.stopTrigger(poll.getEvaluationJobTriggerKey());
        }
        MessageToSend messageToSend = templateService.renderEmbedTemplate(SERVER_POLL_CLOSE_MESSAGE, model, serverId);
-        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, PollPostTarget.POLLS, serverId);
+        List<List<CompletableFuture<Message>>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, PollPostTarget.POLLS, serverId);
        MessageChannel channel = channelService.getMessageChannelFromServer(serverId, poll.getChannel().getId());
        CompletableFuture<Message> removeComponentsFuture = channelService.removeComponents(channel, poll.getMessageId());
-        return CompletableFuture.allOf(FutureUtils.toSingleFutureGeneric(messageFutures), removeComponentsFuture);
+        return CompletableFuture.allOf(FutureUtils.toSingleFutureGenericList(messageFutures), removeComponentsFuture);
    }

    @Override
--- a/abstracto-application/abstracto-modules/suggestion/suggestion-impl/src/main/java/dev/sheldan/abstracto/suggestion/service/SuggestionServiceBean.java
+++ b/abstracto-application/abstracto-modules/suggestion/suggestion-impl/src/main/java/dev/sheldan/abstracto/suggestion/service/SuggestionServiceBean.java
@@ -154,7 +154,7 @@ public class SuggestionServiceBean implements SuggestionService {
        }
        MessageToSend messageToSend = templateService.renderEmbedTemplate(SUGGESTION_CREATION_TEMPLATE, model, serverId);
        log.info("Creating suggestion with id {} in server {} from member {}.", newSuggestionId, serverId, suggester.getIdLong());
-        List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, serverId);
+        List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, serverId).get(0);
        List<ButtonConfigModel> buttonConfigModels = Arrays.asList(model.getAgreeButtonModel(), model.getDisAgreeButtonModel(), model.getRemoveVoteButtonModel());
        return FutureUtils.toSingleFutureGeneric(completableFutures)
                .thenCompose(aVoid -> self.addVotingPossibility(suggestionChannelId, suggestionMessageId, text, suggester, serverId, newSuggestionId, completableFutures, buttonConfigModels, useButtons))
@@ -393,7 +393,7 @@ public class SuggestionServiceBean implements SuggestionService {
        suggestionLog.setReason(text);
        Long serverId = suggestionLog.getServerId();
        MessageToSend messageToSend = templateService.renderEmbedTemplate(SUGGESTION_UPDATE_TEMPLATE, suggestionLog, serverId);
-        List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, serverId);
+        List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION, serverId).get(0);
        return CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0]));
    }

@@ -463,8 +463,8 @@ public class SuggestionServiceBean implements SuggestionService {
                .build();
        MessageToSend messageToSend = templateService.renderEmbedTemplate(SUGGESTION_REMINDER_TEMPLATE_KEY, model, serverId);
        log.info("Reminding about suggestion {} in server {}.", suggestionId.getId(), serverId);
-        List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION_REMINDER, serverId);
-        return FutureUtils.toSingleFutureGeneric(completableFutures);
+        List<List<CompletableFuture<Message>>> completableFutures = postTargetService.sendEmbedInPostTarget(messageToSend, SuggestionPostTarget.SUGGESTION_REMINDER, serverId);
+        return FutureUtils.toSingleFutureGenericList(completableFutures);
    }

    @Override
--- a/abstracto-application/abstracto-modules/twitch/twitch-impl/src/main/java/dev/sheldan/abstracto/twitch/service/StreamerServiceBean.java
+++ b/abstracto-application/abstracto-modules/twitch/twitch-impl/src/main/java/dev/sheldan/abstracto/twitch/service/StreamerServiceBean.java
@@ -158,7 +158,7 @@ public class StreamerServiceBean implements StreamerService {
            return new CompletableFutureList<>(futures);
        } else {
            log.info("Announcing streamer {} in server {}.", streamer.getId(), streamer.getServer().getId());
-            List<CompletableFuture<Message>> futures = postTargetService.sendEmbedInPostTarget(messagetoSend, TwitchPostTarget.TWITCH_LIVE_NOTIFICATION, streamer.getServer().getId());
+            List<CompletableFuture<Message>> futures = postTargetService.sendEmbedInPostTarget(messagetoSend, TwitchPostTarget.TWITCH_LIVE_NOTIFICATION, streamer.getServer().getId()).get(0);
            return new CompletableFutureList<>(futures);
        }
    }
--- a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/PostTargetCommand.java
+++ b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/PostTargetCommand.java
@@ -14,13 +14,19 @@ import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.CoreSlashCommandNames;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandPrivilegeLevels;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.models.database.AChannel;
+import dev.sheldan.abstracto.core.models.database.AChannelGroup;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.PostTarget;
 import dev.sheldan.abstracto.core.models.template.commands.PostTargetDisplayModel;
 import dev.sheldan.abstracto.core.models.template.commands.PostTargetModelEntry;
+import dev.sheldan.abstracto.core.models.template.display.ChannelDisplay;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
+import dev.sheldan.abstracto.core.service.PostTargetServiceBean;
+import dev.sheldan.abstracto.core.service.management.ChannelGroupManagementService;
 import dev.sheldan.abstracto.core.service.management.PostTargetManagement;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
@@ -35,6 +41,7 @@ import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
 import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
 import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -70,6 +77,12 @@ public class PostTargetCommand extends AbstractConditionableCommand {
    @Autowired
    private SlashCommandParameterService slashCommandParameterService;

+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Autowired
+    private ChannelGroupManagementService channelGroupManagementService;
+
    private void validateAndCreatePosttarget(Guild guild, String targetName, GuildChannel channel) {
        if (!postTargetService.validPostTarget(targetName)) {
            throw new PostTargetNotValidException(targetName, postTargetService.getAvailablePostTargets());
@@ -85,12 +98,33 @@ public class PostTargetCommand extends AbstractConditionableCommand {
        List<PostTarget> postTargets = postTargetService.getPostTargets(server);
        ArrayList<PostTargetModelEntry> postTargetEntries = new ArrayList<>();
        postTargets.forEach(target -> {
+            Optional<AChannelGroup> channelGroupOptional =
+                channelGroupManagementService.findByNameAndServerAndTypeOptional(target.getName(), server, PostTargetServiceBean.POSTTARGET_CHANNEL_GROUP_TYPE);
            Optional<GuildMessageChannel> channelFromAChannel = channelService.getGuildMessageChannelFromAChannelOptional(target.getChannelReference());
+            PostTargetModelEntry.PostTargetChannelGroup channelGroupDisplay;
+            if(channelGroupOptional.isPresent()) {
+                AChannelGroup aChannelGroup = channelGroupOptional.get();
+                List<ChannelDisplay> guildMessageChannels = new ArrayList<>();
+                for (AChannel aChannel : aChannelGroup.getChannels()) {
+                    Optional<GuildMessageChannel> channelOptional = channelService.getGuildMessageChannelFromAChannelOptional(aChannel);
+                    channelOptional.ifPresent(e -> guildMessageChannels.add(ChannelDisplay.fromChannel(e)));
+                }
+                channelGroupDisplay = PostTargetModelEntry.PostTargetChannelGroup
+                    .builder()
+                    .disabled(!aChannelGroup.getEnabled())
+                    .name(aChannelGroup.getGroupName())
+                    .additionalChannels(guildMessageChannels)
+                    .build();
+            } else {
+                channelGroupDisplay = null;
+            }
            PostTargetModelEntry targetEntry = PostTargetModelEntry
                    .builder()
-                    .channel(channelFromAChannel.orElse(null))
+                    .channel(channelFromAChannel.map(ChannelDisplay::fromChannel).orElse(null))
                    .disabled(target.getDisabled())
-                    .postTarget(target).build();
+                    .channelGroup(channelGroupDisplay)
+                    .name(target.getName())
+                    .build();
            postTargetEntries.add(targetEntry);
        });
        PostTargetDisplayModel posttargetDisplayModel = PostTargetDisplayModel
@@ -100,14 +134,14 @@ public class PostTargetCommand extends AbstractConditionableCommand {

        List<String> postTargetConfigs = postTargetService.getPostTargetsOfEnabledFeatures(server);
        postTargetConfigs.forEach(postTargetName -> {
-            if(postTargetEntries.stream().noneMatch(postTargetModelEntry -> postTargetModelEntry.getPostTarget().getName().equalsIgnoreCase(postTargetName))) {
+            if(postTargetEntries.stream().noneMatch(postTargetModelEntry -> postTargetModelEntry.getName().equalsIgnoreCase(postTargetName))) {
                PostTarget fakeEntry = PostTarget
                        .builder()
                        .name(postTargetName)
                        .build();
                PostTargetModelEntry postTargetEntry = PostTargetModelEntry
                        .builder()
-                        .postTarget(fakeEntry)
+                        .name(fakeEntry.getName())
                        .disabled(false)
                        .build();
                postTargetEntries.add(postTargetEntry);
@@ -137,12 +171,25 @@ public class PostTargetCommand extends AbstractConditionableCommand {
        }
    }

+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if (slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue().toLowerCase();
+            return postTargetService.getAvailablePostTargets()
+                .stream()
+                .filter(name -> name.toLowerCase().startsWith(input))
+                .toList();
+        }
+        return new ArrayList<>();
+    }
+
    @Override
    public CommandConfiguration getConfiguration() {
        Parameter postTargetName = Parameter
            .builder()
            .name(NAME_PARAMETER)
            .type(String.class)
+            .supportsAutoComplete(true)
            .optional(true)
            .templated(true)
            .build();
--- a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/PostTargetServiceBean.java
+++ b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/PostTargetServiceBean.java
@@ -4,12 +4,16 @@ import dev.sheldan.abstracto.core.config.FeatureConfig;
 import dev.sheldan.abstracto.core.config.PostTargetEnum;
 import dev.sheldan.abstracto.core.exception.PostTargetNotUsableException;
 import dev.sheldan.abstracto.core.exception.PostTargetNotValidException;
+import dev.sheldan.abstracto.core.models.database.AChannel;
+import dev.sheldan.abstracto.core.models.database.AChannelGroup;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.PostTarget;
+import dev.sheldan.abstracto.core.service.management.ChannelGroupManagementService;
 import dev.sheldan.abstracto.core.service.management.DefaultPostTargetManagementService;
 import dev.sheldan.abstracto.core.service.management.PostTargetManagement;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
+import java.util.function.BiConsumer;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.*;
 import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
@@ -29,6 +33,7 @@ import java.util.concurrent.CompletableFuture;
@Component
 public class PostTargetServiceBean implements PostTargetService {

+    public static final String POSTTARGET_CHANNEL_GROUP_TYPE = "posttarget";
    @Autowired
    private PostTargetManagement postTargetManagement;

@@ -50,27 +55,70 @@ public class PostTargetServiceBean implements PostTargetService {
    @Autowired
    private MessageService messageService;

+    @Autowired
+    private ChannelGroupManagementService channelGroupManagementService;
+
    @Override
-    public CompletableFuture<Message> sendTextInPostTarget(String text, PostTarget target) {
+    public List<CompletableFuture<Message>> sendTextInPostTarget(String text, PostTarget target) {
        if (target.getDisabled()) {
            log.info("Post target {} has been disabled in server {} - not sending message.", target.getName(), target.getServerReference().getId());
-            return CompletableFuture.completedFuture(null);
+            return List.of(CompletableFuture.completedFuture(null));
        } else {
            log.debug("Sending text to post target {}.", target.getName());
-            return channelService.sendTextToAChannel(text, target.getChannelReference());
+            List<CompletableFuture<Message>> futures = new ArrayList<>();
+            CompletableFuture<Message> mainTargetFuture = channelService.sendTextToAChannel(text, target.getChannelReference());
+            futures.add(mainTargetFuture);
+            BiConsumer<AChannel, List<CompletableFuture<Message>>> sendToChannel = (AChannel channel, List<CompletableFuture<Message>> list)
+                -> list.add(channelService.sendTextToAChannel(text, channel));
+            executeForSingleMessages(target, sendToChannel, futures);
+            return futures;
        }
    }

+    private void executeForSingleMessages(PostTarget target, BiConsumer<AChannel, List<CompletableFuture<Message>>> sendToChannel, List<CompletableFuture<Message>> futures) {
+        Optional<AChannelGroup> channelGroupOptional = channelGroupManagementService.findByNameAndServerAndTypeOptional(target.getName(), target.getServerReference(),
+            POSTTARGET_CHANNEL_GROUP_TYPE);
+        channelGroupOptional.ifPresent(channelGroup -> {
+            if(channelGroup.getEnabled()) {
+                channelGroup.getChannels().forEach(aChannel -> {
+                    log.debug("Sending message also to channel due to channel group {}.", aChannel.getId());
+                    sendToChannel.accept(aChannel, futures);
+                });
+            }
+        });
+    }
+
+    private void executeForMultipleMessages(PostTarget target, BiConsumer<AChannel, List<List<CompletableFuture<Message>>>> sendToChannel, List<List<CompletableFuture<Message>>> futures) {
+        Optional<AChannelGroup> channelGroupOptional = channelGroupManagementService.findByNameAndServerAndTypeOptional(target.getName(), target.getServerReference(),
+            POSTTARGET_CHANNEL_GROUP_TYPE);
+        channelGroupOptional.ifPresent(channelGroup -> {
+            if(channelGroup.getEnabled()) {
+                channelGroup.getChannels().forEach(aChannel -> {
+                    log.debug("Sending message also to channel due to channel group {}.", aChannel.getId());
+                    sendToChannel.accept(aChannel, futures);
+                });
+            }
+        });
+    }
+
    @Override
-    public CompletableFuture<Message> sendEmbedInPostTarget(MessageEmbed embed, PostTarget target) {
+    public List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageEmbed embed, PostTarget target) {
        if (target.getDisabled()) {
            log.info("Post target {} has been disabled in server {} - not sending message.", target.getName(), target.getServerReference().getId());
-            return CompletableFuture.completedFuture(null);
+            return List.of(CompletableFuture.completedFuture(null));
        } else {
            log.debug("Sending message embed to post target {}.", target.getName());
-            return getMessageChannelForPostTarget(target)
-                    .map(channel -> channelService.sendEmbedToChannel(embed, channel))
-                    .orElse(CompletableFuture.completedFuture(null));
+            List<CompletableFuture<Message>> futures = new ArrayList<>();
+            CompletableFuture<Message> mainTargetFutures = getMessageChannelForPostTarget(target)
+                .map(channel -> channelService.sendEmbedToChannel(embed, channel))
+                .orElse(CompletableFuture.completedFuture(null));
+            futures.add(mainTargetFutures);
+            BiConsumer<AChannel, List<CompletableFuture<Message>>> sendToChannel = (AChannel channel, List<CompletableFuture<Message>> list)
+                -> list.add(getMessageChannelForPostTarget(target)
+                .map(innerChannel -> channelService.sendEmbedToChannel(embed, innerChannel))
+                .orElse(CompletableFuture.completedFuture(null)));
+            executeForSingleMessages(target, sendToChannel, futures);
+            return futures;
        }
    }

@@ -91,62 +139,126 @@ public class PostTargetServiceBean implements PostTargetService {
    }

    @Override
-    public CompletableFuture<Message> sendTextInPostTarget(String text, PostTargetEnum postTargetEnum, Long serverId) {
+    public List<CompletableFuture<Message>> sendTextInPostTarget(String text, PostTargetEnum postTargetEnum, Long serverId) {
        Optional<PostTarget> postTargetOptional = getPostTarget(postTargetEnum, serverId);
-        if (!postTargetOptional.isPresent()) {
-            return CompletableFuture.completedFuture(null);
+        if (postTargetOptional.isEmpty()) {
+            return List.of(CompletableFuture.completedFuture(null));
        }
        return this.sendTextInPostTarget(text, postTargetOptional.get());
    }

    @Override
-    public CompletableFuture<Message> sendEmbedInPostTarget(MessageEmbed embed, PostTargetEnum postTargetName, Long serverId) {
+    public List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageEmbed embed, PostTargetEnum postTargetName, Long serverId) {
        Optional<PostTarget> postTargetOptional = getPostTarget(postTargetName, serverId);
-        if (!postTargetOptional.isPresent()) {
-            return CompletableFuture.completedFuture(null);
+        if (postTargetOptional.isEmpty()) {
+            return List.of(CompletableFuture.completedFuture(null));
        }
        return this.sendEmbedInPostTarget(embed, postTargetOptional.get());
    }

    @Override
-    public CompletableFuture<Message> sendMessageInPostTarget(Message message, PostTargetEnum postTargetName, Long serverId) {
+    public List<CompletableFuture<Message>> sendMessageInPostTarget(Message message, PostTargetEnum postTargetName, Long serverId) {
        Optional<PostTarget> postTargetOptional = getPostTarget(postTargetName, serverId);
-        if (!postTargetOptional.isPresent()) {
-            return CompletableFuture.completedFuture(null);
+        if (postTargetOptional.isEmpty()) {
+            return List.of(CompletableFuture.completedFuture(null));
        }
        return sendMessageInPostTarget(message, postTargetOptional.get());
    }

    @Override
-    public CompletableFuture<Message> sendMessageInPostTarget(Message message, PostTarget target) {
+    public List<CompletableFuture<Message>> sendMessageInPostTarget(Message message, PostTarget target) {
        if (target.getDisabled()) {
            log.info("Post target {} has been disabled in server {} - not sending message.", target.getName(), target.getServerReference().getId());
-            return CompletableFuture.completedFuture(null);
+            return List.of(CompletableFuture.completedFuture(null));
        } else {
            log.debug("Send message {} towards post target {}.", message.getId(), target.getName());
-            return channelService.sendMessageToAChannel(message, target.getChannelReference());
+            List<CompletableFuture<Message>> futures = new ArrayList<>();
+            CompletableFuture<Message> mainFuture = channelService.sendMessageToAChannel(message, target.getChannelReference());
+            futures.add(mainFuture);
+            BiConsumer<AChannel, List<CompletableFuture<Message>>> sendToChannel = (AChannel channel, List<CompletableFuture<Message>> list)
+                -> list.add(channelService.sendMessageToAChannel(message, target.getChannelReference()));
+            executeForSingleMessages(target, sendToChannel, futures);
+            return futures;
        }
    }

    @Override
-    public List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, PostTargetEnum postTargetName, Long serverId) {
+    public List<List<CompletableFuture<Message>>> sendEmbedInPostTarget(MessageToSend message, PostTargetEnum postTargetName, Long serverId) {
        Optional<PostTarget> postTargetOptional = getPostTarget(postTargetName, serverId);
-        if (!postTargetOptional.isPresent()) {
-            return Arrays.asList(CompletableFuture.completedFuture(null));
+        if (postTargetOptional.isEmpty()) {
+            return List.of(List.of(CompletableFuture.completedFuture(null)));
        }
        return this.sendEmbedInPostTarget(message, postTargetOptional.get());
    }

    @Override
-    public List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, PostTarget target) {
+    public List<List<CompletableFuture<Message>>> sendEmbedInPostTarget(List<MessageToSend> messages, PostTargetEnum postTargetName, Long serverId) {
+        Optional<PostTarget> postTargetOptional = getPostTarget(postTargetName, serverId);
+        if (postTargetOptional.isEmpty()) {
+            return List.of(List.of(CompletableFuture.completedFuture(null)));
+        }
+        PostTarget target = postTargetOptional.get();
        if (target.getDisabled()) {
            log.info("Post target {} has been disabled in server {} - not sending message.", target.getName(), target.getServerReference().getId());
-            return Arrays.asList(CompletableFuture.completedFuture(null));
+            return List.of(List.of(CompletableFuture.completedFuture(null)));
        } else {
            log.debug("Send messageToSend towards post target {}.", target.getName());
-            return getMessageChannelForPostTarget(target)
-                    .map(channel -> channelService.sendMessageToSendToChannel(message, channel))
+            List<CompletableFuture<Message>> mainTargetFutures;
+            if(!messages.isEmpty()) {
+                // the primary post target channel gets the first message to send
+                mainTargetFutures = getMessageChannelForPostTarget(target)
+                    .map(channel -> channelService.sendMessageToSendToChannel(messages.get(0), channel))
                    .orElse(Arrays.asList(CompletableFuture.completedFuture(null)));
+            } else {
+                mainTargetFutures = new ArrayList<>();
+                mainTargetFutures.add(CompletableFuture.completedFuture(null));
+            }
+            List<List<CompletableFuture<Message>>> futures = new ArrayList<>();
+            futures.add(mainTargetFutures);
+            Optional<AChannelGroup> channelGroupOptional = channelGroupManagementService.findByNameAndServerAndTypeOptional(target.getName(), target.getServerReference(),
+                POSTTARGET_CHANNEL_GROUP_TYPE);
+            // the rest of the additional post target channels get the further message to sends
+            // as appropriate, if we are at the end of the available ones and there are still channels left, we just keep the same
+            channelGroupOptional.ifPresent(channelGroup -> {
+                if(channelGroup.getEnabled()) {
+                    for (int i = 0; i <  channelGroup.getChannels().size(); i++) {
+                        AChannel aChannel = channelGroup.getChannels().get(i);
+                        log.debug("Sending message also to channel due to channel group {}.", aChannel.getId());
+                        Optional<GuildMessageChannel> messageOptional =
+                            channelService.getGuildMessageChannelFromAChannelOptional(aChannel);
+                        List<CompletableFuture<Message>> innerMessageFutures;
+                        if(messageOptional.isPresent()) {
+                            innerMessageFutures =
+                                channelService.sendMessageToSendToChannel(messages.get(Math.min(messages.size() - 1, i + 1)), messageOptional.get());
+                        } else {
+                            innerMessageFutures = Arrays.asList(CompletableFuture.completedFuture(null));
+                        }
+                        futures.add(innerMessageFutures);
+                    }
+                }
+            });
+            return futures;
+        }
+    }
+
+    @Override
+    public List<List<CompletableFuture<Message>>> sendEmbedInPostTarget(MessageToSend message, PostTarget target) {
+        if (target.getDisabled()) {
+            log.info("Post target {} has been disabled in server {} - not sending message.", target.getName(), target.getServerReference().getId());
+            return List.of(List.of(CompletableFuture.completedFuture(null)));
+        } else {
+            log.debug("Send messageToSend towards post target {}.", target.getName());
+            List<CompletableFuture<Message>> mainTargetFutures = getMessageChannelForPostTarget(target)
+                .map(channel -> channelService.sendMessageToSendToChannel(message, channel))
+                .orElse(Arrays.asList(CompletableFuture.completedFuture(null)));
+            List<List<CompletableFuture<Message>>> futures = new ArrayList<>();
+            futures.add(mainTargetFutures);
+            BiConsumer<AChannel, List<List<CompletableFuture<Message>>>> sendToChannel = (AChannel channel, List<List<CompletableFuture<Message>>> list)
+                -> list.add(channelService.getGuildMessageChannelFromAChannelOptional(channel)
+                .map(innerChannel -> channelService.sendMessageToSendToChannel(message, innerChannel))
+                .orElse(Arrays.asList(CompletableFuture.completedFuture(null))));
+            executeForMultipleMessages(target, sendToChannel, futures);
+            return futures;
        }
    }

@@ -213,7 +325,7 @@ public class PostTargetServiceBean implements PostTargetService {
                        }).exceptionally(throwable -> {
                            log.debug("Creating new message when upserting message embeds for message {} in channel {} in server {}.",
                                messageId, messageChannel.getIdLong(), messageChannel.getGuild().getId());
-                            sendEmbedInPostTarget(messageToSend, target).get(0)
+                            sendEmbedInPostTarget(messageToSend, target).get(0).get(0)
                                .thenAccept(messageEditFuture::complete).exceptionally(innerThrowable -> {
                                    log.error("Failed to send message to create a message.", innerThrowable);
                                    messageEditFuture.completeExceptionally(innerThrowable);
@@ -230,7 +342,7 @@ public class PostTargetServiceBean implements PostTargetService {
                        }).exceptionally(throwable -> {
                            log.debug("Creating new message when trying to upsert a message {} in channel {} in server {}.",
                                messageId, messageChannel.getIdLong(), messageChannel.getGuild().getId());
-                            sendEmbedInPostTarget(messageToSend, target).get(0)
+                            sendEmbedInPostTarget(messageToSend, target).get(0).get(0)
                                .thenAccept(messageEditFuture::complete).exceptionally(innerThrowable -> {
                                    log.error("Failed to send message to create a message.", innerThrowable);
                                    messageEditFuture.completeExceptionally(innerThrowable);
@@ -248,7 +360,7 @@ public class PostTargetServiceBean implements PostTargetService {
    @Override
    public List<CompletableFuture<Message>> editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTargetEnum postTargetName, Long serverId) {
        Optional<PostTarget> postTargetOptional = getPostTarget(postTargetName, serverId);
-        if (!postTargetOptional.isPresent()) {
+        if (postTargetOptional.isEmpty()) {
            return Arrays.asList(CompletableFuture.completedFuture(null));
        }
        return this.editOrCreatedInPostTarget(messageId, messageToSend, postTargetOptional.get());
@@ -257,7 +369,7 @@ public class PostTargetServiceBean implements PostTargetService {
    @Override
    public void throwIfPostTargetIsNotDefined(PostTargetEnum targetEnum, Long serverId) {
        Optional<PostTarget> postTargetOptional = getPostTarget(targetEnum, serverId);
-        if (!postTargetOptional.isPresent()) {
+        if (postTargetOptional.isEmpty()) {
            throw new PostTargetNotValidException(targetEnum.getKey(), defaultPostTargetManagementService.getDefaultPostTargetKeys());
        }
    }
@@ -270,7 +382,7 @@ public class PostTargetServiceBean implements PostTargetService {
    @Override
    public List<CompletableFuture<Message>> editEmbedInPostTarget(Long messageId, MessageToSend message, PostTargetEnum postTargetName, Long serverId) {
        Optional<PostTarget> postTargetOptional = getPostTarget(postTargetName, serverId);
-        if (!postTargetOptional.isPresent()) {
+        if (postTargetOptional.isEmpty()) {
            return Arrays.asList(CompletableFuture.completedFuture(null));
        }
        return editEmbedInPostTarget(messageId, message, postTargetOptional.get());
--- a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/management/ChannelGroupManagementServiceBean.java
+++ b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/management/ChannelGroupManagementServiceBean.java
@@ -139,7 +139,7 @@ public class ChannelGroupManagementServiceBean implements ChannelGroupManagement

    @Override
    public AChannelGroup findByNameAndServerAndType(String name, AServer server, String expectedType) {
-        Optional<AChannelGroup> channelOptional = channelGroupRepository.findByGroupNameIgnoreCaseAndServerAndChannelGroupType_GroupTypeKey(name, server, expectedType);
+        Optional<AChannelGroup> channelOptional = findByNameAndServerAndTypeOptional(name, server, expectedType);
        return channelOptional.orElseThrow(() -> {
            if(channelGroupRepository.existsByGroupNameIgnoreCaseAndServer(name, server)) {
                return new ChannelGroupIncorrectTypeException(name, expectedType);
@@ -150,6 +150,11 @@ public class ChannelGroupManagementServiceBean implements ChannelGroupManagement
        });
    }

+    @Override
+    public Optional<AChannelGroup> findByNameAndServerAndTypeOptional(String name, AServer server, String expectedType) {
+        return channelGroupRepository.findByGroupNameIgnoreCaseAndServerAndChannelGroupType_GroupTypeKey(name, server, expectedType);
+    }
+
    @Override
    public List<AChannelGroup> findAllInServer(AServer server) {
        return channelGroupRepository.findByServer(server);
--- a/abstracto-application/core/core-impl/src/main/resources/migrations/1.6.18/collection.xml
+++ b/abstracto-application/core/core-impl/src/main/resources/migrations/1.6.18/collection.xml
@@ -0,0 +1,6 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<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">
+    <include file="seedData/data.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>
--- a/abstracto-application/core/core-impl/src/main/resources/migrations/1.6.18/seedData/channel_group_types.xml
+++ b/abstracto-application/core/core-impl/src/main/resources/migrations/1.6.18/seedData/channel_group_types.xml
@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<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="posttarget_channel_group_type-insertion">
+        <insert tableName="channel_group_type">
+            <column name="group_type_key" value="posttarget"/>
+        </insert>
+    </changeSet>
+</databaseChangeLog>
--- a/abstracto-application/core/core-impl/src/main/resources/migrations/1.6.18/seedData/data.xml
+++ b/abstracto-application/core/core-impl/src/main/resources/migrations/1.6.18/seedData/data.xml
@@ -0,0 +1,6 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<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" >
+    <include file="channel_group_types.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>
--- a/abstracto-application/core/core-impl/src/main/resources/migrations/core-changeLog.xml
+++ b/abstracto-application/core/core-impl/src/main/resources/migrations/core-changeLog.xml
@@ -22,4 +22,5 @@
    <include file="1.4.0/collection.xml" relativeToChangelogFile="true"/>
    <include file="1.5.8/collection.xml" relativeToChangelogFile="true"/>
    <include file="1.5.10/collection.xml" relativeToChangelogFile="true"/>
+    <include file="1.6.18/collection.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>
--- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/models/template/commands/PostTargetModelEntry.java
+++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/models/template/commands/PostTargetModelEntry.java
@@ -1,16 +1,26 @@
 package dev.sheldan.abstracto.core.models.template.commands;

-import dev.sheldan.abstracto.core.models.database.PostTarget;
+import dev.sheldan.abstracto.core.models.template.display.ChannelDisplay;
+import java.util.List;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
-import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;

@Getter
@Setter
@Builder
 public class PostTargetModelEntry {
-    private PostTarget postTarget;
-    private MessageChannel channel;
+    private String name;
+    private ChannelDisplay channel;
+    private PostTargetChannelGroup channelGroup;
    private Boolean disabled;
+
+    @Getter
+    @Builder
+    public static class PostTargetChannelGroup {
+        private String name;
+        private Boolean disabled;
+        private List<ChannelDisplay> additionalChannels;
+    }
 }
+
--- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/PostTargetService.java
+++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/PostTargetService.java
@@ -13,14 +13,15 @@ import java.util.Optional;
 import java.util.concurrent.CompletableFuture;

 public interface PostTargetService {
-    CompletableFuture<Message> sendTextInPostTarget(String text, PostTarget target);
-    CompletableFuture<Message> sendEmbedInPostTarget(MessageEmbed embed, PostTarget target);
-    CompletableFuture<Message> sendTextInPostTarget(String text, PostTargetEnum postTargetName, Long serverId);
-    CompletableFuture<Message> sendEmbedInPostTarget(MessageEmbed embed, PostTargetEnum postTargetName, Long serverId);
-    CompletableFuture<Message> sendMessageInPostTarget(Message message, PostTargetEnum postTargetName,  Long serverId);
-    CompletableFuture<Message> sendMessageInPostTarget(Message message, PostTarget target);
-    List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, PostTargetEnum postTargetName, Long serverId);
-    List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, PostTarget target);
+    List<CompletableFuture<Message>> sendTextInPostTarget(String text, PostTarget target);
+    List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageEmbed embed, PostTarget target);
+    List<CompletableFuture<Message>> sendTextInPostTarget(String text, PostTargetEnum postTargetName, Long serverId);
+    List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageEmbed embed, PostTargetEnum postTargetName, Long serverId);
+    List<CompletableFuture<Message>> sendMessageInPostTarget(Message message, PostTargetEnum postTargetName,  Long serverId);
+    List<CompletableFuture<Message>> sendMessageInPostTarget(Message message, PostTarget target);
+    List<List<CompletableFuture<Message>>> sendEmbedInPostTarget(MessageToSend message, PostTargetEnum postTargetName, Long serverId);
+    List<List<CompletableFuture<Message>>> sendEmbedInPostTarget(List<MessageToSend> messages, PostTargetEnum postTargetName, Long serverId);
+    List<List<CompletableFuture<Message>>> sendEmbedInPostTarget(MessageToSend message, PostTarget target);
    List<CompletableFuture<Message>> editEmbedInPostTarget(Long messageId, MessageToSend message, PostTarget target);
    List<CompletableFuture<Message>> editEmbedInPostTarget(Long messageId, MessageToSend message, PostTargetEnum postTargetName, Long serverId);
    List<CompletableFuture<Message>> editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTarget target);
--- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/management/ChannelGroupManagementService.java
+++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/management/ChannelGroupManagementService.java
@@ -19,6 +19,7 @@ public interface ChannelGroupManagementService {
    AChannelGroup findByNameAndServer(String name, AServer server);
    Optional<AChannelGroup> findByNameAndServerOptional(String name, AServer server);
    AChannelGroup findByNameAndServerAndType(String name, AServer server, String expectedType);
+    Optional<AChannelGroup> findByNameAndServerAndTypeOptional(String name, AServer server, String expectedType);
    List<AChannelGroup> findAllInServer(AServer server);
    List<String> getAllAvailableAsString(AServer server);
    List<AChannelGroup> findAllInServer(Long serverId);
--- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/utils/FutureUtils.java
+++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/utils/FutureUtils.java
@@ -12,6 +12,11 @@ public class FutureUtils {
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
    }

+    public static <T> CompletableFuture<Void> toSingleFutureGenericList(List<List<CompletableFuture<T>>> futures) {
+        List<CompletableFuture<T>> allFutures = futures.stream().flatMap(List::stream).toList();
+        return toSingleFutureGeneric(allFutures);
+    }
+
    public static CompletableFuture<Void> toSingleFuture(List<CompletableFuture<?>> futures) {
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
    }