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

adding auto complete to post target command
2026-01-03 08:19:54 +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/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>