refactored the naming in channel service

added initial version of closing and logging the thread

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/LeaderBoardCommand.java

@@ -58,7 +58,7 @@ public class LeaderBoardCommand extends AbstractConditionableCommand {
         LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(commandContext.getUserInitiatedContext().getAUserInAServer());
         leaderBoardModel.setUserExecuting(converter.fromLeaderBoardEntry(userRank));
         MessageToSend messageToSend = templateService.renderEmbedTemplate(LEADERBOARD_POST_EMBED_TEMPLATE, leaderBoardModel);
-        channelService.sendMessageToEndInTextChannel(messageToSend, commandContext.getChannel());
+        channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
 
         return CommandResult.fromSuccess();
     }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/Rank.java

@@ -52,7 +52,7 @@ public class Rank extends AbstractConditionableCommand {
         AUserExperience experienceObj = userRank.getExperience();
         rankModel.setExperienceToNextLevel(experienceLevelService.calculateExperienceToNextLevel(experienceObj.getCurrentLevel().getLevel(), experienceObj.getExperience()));
         MessageToSend messageToSend = templateService.renderEmbedTemplate(RANK_POST_EMBED_TEMPLATE, rankModel);
-        channelService.sendMessageToEndInTextChannel(messageToSend, commandContext.getChannel());
+        channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
 
         return CommandResult.fromSuccess();
     }

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/commands/AnonReply.java

@@ -34,7 +34,7 @@ public class AnonReply extends AbstractConditionableCommand {
     @Override
     public CommandResult execute(CommandContext commandContext) {
         ModMailThread thread = modMailThreadManagementService.getByChannel(commandContext.getUserInitiatedContext().getChannel());
-        modMailThreadService.relayMessageToDm(thread, commandContext.getMessage(), true);
+        modMailThreadService.relayMessageToDm(thread, commandContext.getMessage(), true, commandContext.getChannel());
         return CommandResult.fromSuccess();
     }
 

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/commands/Close.java

@@ -3,14 +3,20 @@ package dev.sheldan.abstracto.modmail.commands;
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.condition.CommandCondition;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.modmail.commands.condition.RequiresModMailCondition;
 import dev.sheldan.abstracto.modmail.config.ModMailFeatures;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThread;
+import dev.sheldan.abstracto.modmail.service.ModMailThreadService;
+import dev.sheldan.abstracto.modmail.service.management.ModMailThreadManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
+import java.util.ArrayList;
 import java.util.List;
 
 @Component
@@ -19,14 +25,32 @@ public class Close extends AbstractConditionableCommand {
     @Autowired
     private RequiresModMailCondition requiresModMailCondition;
 
+    @Autowired
+    private ModMailThreadManagementService modMailThreadManagementService;
+
+    @Autowired
+    private ModMailThreadService modMailThreadService;
+
+
     @Override
+    @Transactional
     public CommandResult execute(CommandContext commandContext) {
-        return null;
+        ModMailThread thread = modMailThreadManagementService.getByChannel(commandContext.getUserInitiatedContext().getChannel());
+        modMailThreadService.closeModMailThread(thread, commandContext.getChannel());
+        return CommandResult.fromSuccess();
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
-        return null;
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("close")
+                .module(ModMailModuleInterface.MODMAIL)
+                .parameters(new ArrayList<>())
+                .help(helpInfo)
+                .templated(true)
+                .causesReaction(true)
+                .build();
     }
 
     @Override

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/commands/Contact.java

@@ -53,7 +53,7 @@ public class Contact extends AbstractConditionableCommand {
             ModMailThreadExistsModel model = (ModMailThreadExistsModel) ContextConverter.fromCommandContext(commandContext, ModMailThreadExistsModel.class);
             model.setExistingModMailThread(existingThread);
             MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_thread_already_exists", model);
-            channelService.sendMessageToEndInTextChannel(messageToSend, commandContext.getChannel());
+            channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
         } else {
             FullUser fullUser = FullUser
                     .builder()

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/commands/Reply.java

@@ -34,7 +34,7 @@ public class Reply extends AbstractConditionableCommand {
     @Override
     public CommandResult execute(CommandContext commandContext) {
         ModMailThread thread = modMailThreadManagementService.getByChannel(commandContext.getUserInitiatedContext().getChannel());
-        modMailThreadService.relayMessageToDm(thread, commandContext.getMessage(), false);
+        modMailThreadService.relayMessageToDm(thread, commandContext.getMessage(), false, commandContext.getChannel());
         return CommandResult.fromSuccess();
     }
 

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/config/ModMailProperties.java

@@ -0,0 +1,9 @@
+package dev.sheldan.abstracto.modmail.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+
+@Configuration
+@PropertySource("classpath:config/modmail.properties")
+public class ModMailProperties {
+}

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/java/dev/sheldan/abstracto/modmail/repository/ModMailMessageRepository.java

@@ -1,9 +1,13 @@
 package dev.sheldan.abstracto.modmail.repository;
 
 import dev.sheldan.abstracto.modmail.models.database.ModMailMessage;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThread;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
+
 @Repository
 public interface ModMailMessageRepository extends JpaRepository<ModMailMessage, Long> {
+    List<ModMailMessage> findByThreadReference(ModMailThread modMailThread);
 }

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

@@ -0,0 +1,74 @@
+package dev.sheldan.abstracto.modmail.service;
+
+import dev.sheldan.abstracto.core.models.ServerChannelMessage;
+import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.modmail.models.database.ModMailMessage;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThread;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.TextChannel;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+@Slf4j
+public class ModMailMessageServiceBean implements ModMailMessageService {
+
+    @Autowired
+    private BotService botService;
+
+    @Override
+    public List<CompletableFuture<Message>> loadModMailMessages(List<ModMailMessage> modMailMessages) {
+        if(modMailMessages.size() == 0) {
+            return new ArrayList<>();
+        }
+        ModMailThread thread = modMailMessages.get(0).getThreadReference();
+        List<ServerChannelMessage> messageIds = new ArrayList<>();
+        modMailMessages.forEach(modMailMessage -> {
+            ServerChannelMessage.ServerChannelMessageBuilder serverChannelMessageBuilder = ServerChannelMessage
+                    .builder()
+                    .messageId(modMailMessage.getMessageId());
+            if(!modMailMessage.getDmChannel()) {
+                serverChannelMessageBuilder
+                        .channelId(modMailMessage.getThreadReference().getChannel().getId())
+                        .serverId(modMailMessage.getThreadReference().getServer().getId());
+            }
+            messageIds.add(serverChannelMessageBuilder.build());
+        });
+        List<CompletableFuture<Message>> messageFutures = new ArrayList<>();
+        modMailMessages.forEach(modMailMessage -> {
+            messageFutures.add(new CompletableFuture<>());
+        });
+        Optional<TextChannel> textChannelFromServer = botService.getTextChannelFromServer(thread.getServer().getId(), thread.getChannel().getId());
+        if(textChannelFromServer.isPresent()) {
+            TextChannel modMailThread = textChannelFromServer.get();
+            botService.getInstance().openPrivateChannelById(thread.getUser().getUserReference().getId()).queue(privateChannel -> {
+                Iterator<CompletableFuture<Message>> iterator = messageFutures.iterator();
+                messageIds.forEach(serverChannelMessage -> {
+                    if(serverChannelMessage.getChannelId() == null){
+                        privateChannel.retrieveMessageById(serverChannelMessage.getMessageId()).queue(message -> {
+                            iterator.next().complete(message);
+                        }, throwable -> {
+                            log.info("Failed to load message in private channel with user {}", thread.getUser().getUserReference().getId());
+                            iterator.next().complete(null);
+                        });
+                    } else {
+                        modMailThread.retrieveMessageById(serverChannelMessage.getMessageId()).queue(message -> {
+                            iterator.next().complete(message);
+                        }, throwable -> {
+                            log.info("Failed to load message {} in thread {}", serverChannelMessage.getMessageId(), modMailThread.getIdLong());
+                            iterator.next().complete(null);
+                        });
+                    }
+                });
+            });
+        }
+        return messageFutures;
+    }
+}

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

@@ -5,13 +5,14 @@ import com.jagrosh.jdautilities.menu.ButtonMenu;
 import dev.sheldan.abstracto.core.models.FullGuild;
 import dev.sheldan.abstracto.core.models.FullUser;
 import dev.sheldan.abstracto.core.models.database.*;
-import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.core.service.*;
-import dev.sheldan.abstracto.core.service.ChannelService;
-import dev.sheldan.abstracto.core.service.ConfigService;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.modmail.models.database.ModMailMessage;
 import dev.sheldan.abstracto.modmail.models.database.ModMailThread;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThreadState;
 import dev.sheldan.abstracto.modmail.models.dto.ServerChoice;
+import dev.sheldan.abstracto.modmail.models.template.ModMailExceptionModel;
 import dev.sheldan.abstracto.modmail.models.template.ModMailModeratorReplyModel;
 import dev.sheldan.abstracto.modmail.models.template.ModMailServerChooserModel;
 import dev.sheldan.abstracto.modmail.service.management.ModMailMessageManagementService;
@@ -33,6 +34,7 @@ import java.util.concurrent.ExecutionException;
 public class ModMailThreadServiceBean implements ModMailThreadService {
 
     public static final String MODMAIL_CATEGORY = "modmailCategory";
+    public static final String MODMAIL_LOG_POSTTARGET = "modmaillog";
     @Autowired
     private ModMailThreadManagementService modMailThreadManagementService;
 
@@ -57,6 +59,12 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
     @Autowired
     private ModMailMessageManagementService modMailMessageManagementService;
 
+    @Autowired
+    private ModMailMessageService modMailMessageService;
+
+    @Autowired
+    private PostTargetService postTargetService;
+
     @Autowired
     private ModMailThreadServiceBean self;
 
@@ -147,7 +155,9 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
     @Override
     public void sendWelcomeMessage(TextChannel channel, FullUser aUserInAServer) {
         String text = templateService.renderTemplate("modmail_welcome_message", new Object());
-        channel.sendMessage(text).queue();
+        channel.sendMessage(text).queue(message -> {}, throwable -> {
+            log.warn("Failed to send welcome message to user {}", aUserInAServer.getAUserInAServer().getUserReference().getId());
+        });
     }
 
     @Override
@@ -172,8 +182,8 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
                 .postedMessage(message)
                 .threadUser(fullUser)
                 .build();
-        MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_user_message_embed", modMailUserReplyModel);
+        MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_user_message", modMailUserReplyModel);
-        List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToEndInTextChannel(messageToSend, textChannel);
+        List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToSendToChannel(messageToSend, textChannel);
         List<Message> messages = new ArrayList<>();
         completableFutures.forEach(messageCompletableFuture -> {
             try {
@@ -182,22 +192,104 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
             } catch (InterruptedException | ExecutionException e) {
                 log.error("Error while executing future to retrieve reaction.", e);
             }
-            self.saveMessageIds(messages, modMailThread, modMailThread.getUser(), false);
+            self.saveMessageIds(messages, modMailThread, modMailThread.getUser(), false, false);
         });
     }
 
     @Override
-    public void relayMessageToDm(ModMailThread modMailThread, Message message, Boolean anonymous) {
+    public void relayMessageToDm(ModMailThread modMailThread, Message message, Boolean anonymous, MessageChannel feedBack) {
         User userById = botService.getInstance().getUserById(modMailThread.getUser().getUserReference().getId());
         if(userById != null) {
             userById.openPrivateChannel().queue(privateChannel -> {
-                self.sendReply(modMailThread, message, privateChannel, anonymous);
+                self.sendReply(modMailThread, message, privateChannel, anonymous, feedBack);
+            }, throwable -> {
+                log.warn("Failed to open private channel with user {}", userById.getIdLong());
             });
         }
     }
 
+    private void sendModMailFailure(String template, ModMailThread modMailThread, MessageChannel channel, Throwable throwable) {
+        try {
+            FullUser fullUser = FullUser
+                    .builder()
+                    .aUserInAServer(modMailThread.getUser())
+                    .member(botService.getMemberInServer(modMailThread.getUser()))
+                    .build();
+            ModMailExceptionModel modMailExceptionModel = ModMailExceptionModel
+                    .builder()
+                    .modMailThread(modMailThread)
+                    .user(fullUser)
+                    .throwable(throwable)
+                    .build();
+            channelService.sendTemplateInChannel(template, modMailExceptionModel, channel);
+        } catch (Exception e) {
+            log.error("Failed to notify about mod mail exception.", e);
+        }
+    }
+
+    @Override
+    public void closeModMailThread(ModMailThread modMailThread, MessageChannel feedBack) {
+        List<ModMailMessage> modMailMessages = modMailMessageManagementService.getMessagesOfThread(modMailThread);
+
+        List<CompletableFuture<Message>> messages = modMailMessageService.loadModMailMessages(modMailMessages);
+        for (int i = 0; i < messages.size(); i++) {
+            CompletableFuture<Message> messageCompletableFuture = messages.get(i);
+            Long messageId = modMailMessages.get(i).getMessageId();
+            messageCompletableFuture.exceptionally(throwable -> {
+                log.warn("Failed to load message {} in mod mail thread {}", messageId, modMailThread.getId());
+                return null;
+            });
+        }
+        CompletableFuture.allOf(messages.toArray(new CompletableFuture[0])).thenAccept(aVoid -> {
+            handledRetrievedMessages(modMailThread, messages);
+        }).exceptionally(throwable -> {
+            log.warn("Failed to load some mod mail messages for mod mail thread {}. Still trying to post the ones we got.", modMailThread.getId(), throwable);
+            handledRetrievedMessages(modMailThread, messages);
+            return null;
+        });
+
+
+    }
+
+    private void handledRetrievedMessages(ModMailThread modMailThread, List<CompletableFuture<Message>> messages) {
+        List<Message> loadedMessages = new ArrayList<>();
+        messages.forEach(future -> {
+            try {
+                if(!future.isCompletedExceptionally()) {
+                    Message loadedMessage = future.get();
+                    if(loadedMessage != null) {
+                        loadedMessages.add(loadedMessage);
+                    }
+                }
+            } catch (InterruptedException | ExecutionException e) {
+                log.error("Error while executing future to retrieve reaction.", e);
+            }
+        });
+        List<CompletableFuture<Message>> completableFutures = self.sendMessagesToPostTarget(modMailThread, loadedMessages);
+        CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenAccept(aVoid -> {
+            channelService.deleteTextChannel(modMailThread.getChannel()).thenAccept(o -> {
+                self.closeModMailThreadInDb(modMailThread);
+            });
+        });
+    }
+
     @Transactional
-    public void sendReply(ModMailThread modMailThread, Message message, PrivateChannel privateChannel, Boolean anonymous) {
+    public void closeModMailThreadInDb(ModMailThread modMailThread) {
+        modMailThreadManagementService.setModMailThreadState(modMailThread, ModMailThreadState.CLOSED);
+    }
+
+    @Transactional
+    public List<CompletableFuture<Message>> sendMessagesToPostTarget(ModMailThread modMailThread, List<Message> loadedMessages) {
+        List<CompletableFuture<Message>> messageFutures = new ArrayList<>();
+        loadedMessages.forEach(message -> {
+            CompletableFuture<Message> logFuture = postTargetService.sendMessageInPostTarget(message, MODMAIL_LOG_POSTTARGET, modMailThread.getServer().getId());
+            messageFutures.add(logFuture);
+        });
+        return messageFutures;
+    }
+
+    @Transactional
+    public void sendReply(ModMailThread modMailThread, Message message, PrivateChannel privateChannel, Boolean anonymous, MessageChannel feedBack) {
         AUserInAServer moderator = userInServerManagementService.loadUser(message.getMember());
         Member userInGuild = botService.getMemberInServer(modMailThread.getUser());
         FullUser moderatorUser = FullUser
@@ -218,7 +310,7 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
                 .moderator(moderatorUser)
                 .build();
         MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_staff_message", modMailUserReplyModel);
-        List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToEndInTextChannel(messageToSend, privateChannel);
+        List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToSendToChannel(messageToSend, privateChannel);
         CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenAccept(aVoid -> {
             List<Message> messages = new ArrayList<>();
             completableFutures.forEach(messageCompletableFuture -> {
@@ -226,17 +318,21 @@ public class ModMailThreadServiceBean implements ModMailThreadService {
                     Message messageToAdd = messageCompletableFuture.get();
                     messages.add(messageToAdd);
                 } catch (InterruptedException | ExecutionException e) {
-                    log.error("Error while executing send message to reply to user.", e);
+                    log.error("A future when sending the message to the user was interrupted.", e);
                 }
             });
-           self.saveMessageIds(messages, modMailThread, moderator, anonymous);
+           self.saveMessageIds(messages, modMailThread, moderator, anonymous, true);
+        }).exceptionally(throwable -> {
+            log.error("Failed to send message to user {}", modMailThread.getUser().getUserReference().getId());
+            sendModMailFailure("modmail_exception_cannot_message_user", modMailThread, feedBack, throwable);
+            return null;
         });
     }
 
     @Transactional
-    public void saveMessageIds(List<Message> messages, ModMailThread modMailThread, AUserInAServer author, Boolean anonymous) {
+    public void saveMessageIds(List<Message> messages, ModMailThread modMailThread, AUserInAServer author, Boolean anonymous, Boolean inDmChannel) {
         messages.forEach(message -> {
-            modMailMessageManagementService.addMessageToThread(modMailThread, message, author, false);
+            modMailMessageManagementService.addMessageToThread(modMailThread, message, author, anonymous, inDmChannel);
         });
     }
 }

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

@@ -8,6 +8,8 @@ import net.dv8tion.jda.api.entities.Message;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.util.List;
+
 @Component
 public class ModMailMessageManagementServiceBean implements ModMailMessageManagementService {
 
@@ -15,11 +17,12 @@ public class ModMailMessageManagementServiceBean implements ModMailMessageManage
     private ModMailMessageRepository modMailMessageRepository;
 
     @Override
-    public ModMailMessage addMessageToThread(ModMailThread modMailThread, Message message, AUserInAServer author, Boolean anonymous) {
+    public ModMailMessage addMessageToThread(ModMailThread modMailThread, Message message, AUserInAServer author, Boolean anonymous, Boolean dmChannel) {
         ModMailMessage modMailMessage = ModMailMessage
                 .builder()
                 .author(author)
                 .messageId(message.getIdLong())
+                .dmChannel(dmChannel)
                 .threadReference(modMailThread)
                 .anonymous(anonymous)
                 .build();
@@ -27,4 +30,9 @@ public class ModMailMessageManagementServiceBean implements ModMailMessageManage
         modMailMessageRepository.save(modMailMessage);
         return modMailMessage;
     }
+
+    @Override
+    public List<ModMailMessage> getMessagesOfThread(ModMailThread modMailThread) {
+        return modMailMessageRepository.findByThreadReference(modMailThread);
+    }
 }

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

@@ -67,4 +67,9 @@ public class ModMailThreadManagementServiceBean implements ModMailThreadManageme
 
         modMailThreadRepository.save(thread);
     }
+
+    @Override
+    public void setModMailThreadState(ModMailThread modMailThread, ModMailThreadState newState) {
+        modMailThread.setState(newState);
+    }
 }

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/resources/config/modmail.properties

@@ -0,0 +1 @@
+abstracto.postTargets.modmail=modmaillog

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/resources/templates/exception/modmail_exception_cannot_message_user_embed_en_US.ftl

@@ -0,0 +1,12 @@
+{
+  "author": {
+    "name": "${user.member.effectiveName}",
+    "avatar":  "${user.member.user.effectiveAvatarUrl}"
+  },
+  "color" : {
+    "r": 200,
+    "g": 0,
+    "b": 255
+  },
+  "description": "<#include "reply_exception_cannot_send_message_to_use_en_US.ftl">"
+}

abstracto-application/abstracto-modules/modmail/modmail-int/src/main/java/dev/sheldan/abstracto/modmail/models/database/ModMailMessage.java

@@ -28,5 +28,7 @@ public class ModMailMessage {
     @JoinColumn(name = "threadReference", nullable = false)
     private ModMailThread threadReference;
 
+    private Boolean dmChannel;
+
     private Boolean anonymous;
 }

abstracto-application/abstracto-modules/modmail/modmail-int/src/main/java/dev/sheldan/abstracto/modmail/models/template/ModMailExceptionModel.java

@@ -0,0 +1,16 @@
+package dev.sheldan.abstracto.modmail.models.template;
+
+import dev.sheldan.abstracto.core.models.FullUser;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThread;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Builder
+public class ModMailExceptionModel {
+    private ModMailThread modMailThread;
+    private FullUser user;
+    private Throwable throwable;
+}

abstracto-application/abstracto-modules/modmail/modmail-int/src/main/java/dev/sheldan/abstracto/modmail/service/ModMailMessageService.java

@@ -0,0 +1,11 @@
+package dev.sheldan.abstracto.modmail.service;
+
+import dev.sheldan.abstracto.modmail.models.database.ModMailMessage;
+import net.dv8tion.jda.api.entities.Message;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public interface ModMailMessageService {
+    List<CompletableFuture<Message>> loadModMailMessages(List<ModMailMessage> modMailMessages);
+}

abstracto-application/abstracto-modules/modmail/modmail-int/src/main/java/dev/sheldan/abstracto/modmail/service/ModMailThreadService.java

@@ -18,5 +18,6 @@ public interface ModMailThreadService {
     void createModMailPrompt(AUser user, MessageChannel messageChannel);
     void sendWelcomeMessage(TextChannel channel, FullUser aUserInAServer);
     void relayMessageToModMailThread(ModMailThread modMailThread, Message message);
-    void relayMessageToDm(ModMailThread modMailThread, Message message, Boolean anonymous);
+    void relayMessageToDm(ModMailThread modMailThread, Message message, Boolean anonymous, MessageChannel feedBack);
+    void closeModMailThread(ModMailThread modMailThread, MessageChannel feedBack);
 }

abstracto-application/abstracto-modules/modmail/modmail-int/src/main/java/dev/sheldan/abstracto/modmail/service/management/ModMailMessageManagementService.java

@@ -5,6 +5,9 @@ import dev.sheldan.abstracto.modmail.models.database.ModMailMessage;
 import dev.sheldan.abstracto.modmail.models.database.ModMailThread;
 import net.dv8tion.jda.api.entities.Message;
 
+import java.util.List;
+
 public interface ModMailMessageManagementService {
-    ModMailMessage addMessageToThread(ModMailThread modMailThread, Message message, AUserInAServer author, Boolean anonymous);
+    ModMailMessage addMessageToThread(ModMailThread modMailThread, Message message, AUserInAServer author, Boolean anonymous, Boolean dmChannel);
+    List<ModMailMessage> getMessagesOfThread(ModMailThread modMailThread);
 }

abstracto-application/abstracto-modules/modmail/modmail-int/src/main/java/dev/sheldan/abstracto/modmail/service/management/ModMailThreadManagementService.java

@@ -17,5 +17,6 @@ public interface ModMailThreadManagementService {
     ModMailThread getOpenModmailThreadForUser(AUser user);
     List<ModMailThread> getModMailThreadForUser(AUserInAServer aUserInAServer);
     void createModMailThread(AUserInAServer userInAServer, AChannel channel);
+    void setModMailThreadState(ModMailThread modMailThread, ModMailThreadState newState);
 
 }

abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/StarStats.java

@@ -38,7 +38,7 @@ public class StarStats extends AbstractConditionableCommand {
     public CommandResult execute(CommandContext commandContext) {
         StarStatsModel result = starboardService.retrieveStarStats(commandContext.getGuild().getIdLong());
         MessageToSend messageToSend = templateService.renderEmbedTemplate(STARSTATS_RESPONSE_TEMPLATE, result);
-        channelService.sendMessageToEndInTextChannel(messageToSend, commandContext.getChannel());
+        channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
         return CommandResult.fromSuccess();
     }
 

abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/commands/remind/Reminders.java

@@ -38,7 +38,7 @@ public class Reminders extends AbstractConditionableCommand {
         RemindersModel model = (RemindersModel) ContextConverter.fromCommandContext(commandContext, RemindersModel.class);
         model.setReminders(activeReminders);
         MessageToSend messageToSend = templateService.renderEmbedTemplate("reminders_response", model);
-        channelService.sendMessageToEndInTextChannel(messageToSend, commandContext.getChannel());
+        channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
         return CommandResult.fromSuccess();
     }
 

abstracto-application/abstracto-modules/utility/utility-impl/src/main/java/dev/sheldan/abstracto/utility/service/MessageEmbedServiceBean.java

@@ -113,7 +113,7 @@ public class MessageEmbedServiceBean implements MessageEmbedService {
     public void embedLink(CachedMessage cachedMessage, TextChannel target, AUserInAServer cause, Message embeddingMessage) {
         MessageEmbeddedModel messageEmbeddedModel = buildTemplateParameter(embeddingMessage, cachedMessage);
         MessageToSend embed = templateService.renderEmbedTemplate(MESSAGE_EMBED_TEMPLATE, messageEmbeddedModel);
-        List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToEndInTextChannel(embed, target);
+        List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToSendToChannel(embed, target);
         log.trace("Embedding message {} from channel {} from server {}, because of user {}", cachedMessage.getMessageId(),
                 cachedMessage.getChannelId(), cachedMessage.getServerId(), cause.getUserReference().getId());
         CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenAccept(aVoid -> {

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

@@ -71,7 +71,7 @@ public class RemindServiceBean implements ReminderService {
         Reminder reminder = reminderManagementService.createReminder(aServerAChannelAUser, remindText, remindAt, reminderModel.getMessage().getIdLong());
         reminderModel.setReminder(reminder);
         MessageToSend message = templateService.renderEmbedTemplate(REMINDER_EMBED_KEY, reminderModel);
-        channelService.sendMessageToEndInAChannel(message, reminderModel.getChannel());
+        channelService.sendMessageToSendToAChannel(message, reminderModel.getChannel());
         log.info("Creating reminder for user {} in guild {} due at {}.",
                 user.getUserReference().getId(), user.getServerReference().getId(), remindAt);
 
@@ -120,7 +120,7 @@ public class RemindServiceBean implements ReminderService {
                         .duration(Duration.between(reminderToRemindFor.getReminderDate(), reminderToRemindFor.getTargetDate()))
                         .build();
                 MessageToSend messageToSend = templateService.renderEmbedTemplate("remind_reminder", build);
-                channelService.sendMessageToEndInTextChannel(messageToSend, channelToAnswerIn.get());
+                channelService.sendMessageToSendToChannel(messageToSend, channelToAnswerIn.get());
             } else {
                 log.warn("Channel {} in server {} to remind user did not exist anymore. Ignoring reminder {}", channel.getId(), server.getId(), reminderId);
             }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/ListChannelGroups.java

@@ -43,7 +43,7 @@ public class ListChannelGroups extends AbstractConditionableCommand {
         ListChannelGroupsModel template = (ListChannelGroupsModel) ContextConverter.fromCommandContext(commandContext, ListChannelGroupsModel.class);
         template.setGroups(convertAChannelGroupToChannelGroupChannel(channelGroups));
         MessageToSend response = templateService.renderEmbedTemplate("listChannelGroups_response", template);
-        channelService.sendMessageToEndInTextChannel(response, commandContext.getChannel());
+        channelService.sendMessageToSendToChannel(response, commandContext.getChannel());
         return CommandResult.fromSuccess();
     }
 

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/features/Disable.java

@@ -41,7 +41,7 @@ public class Disable extends AbstractConditionableCommand {
             EnableModel model = (EnableModel) ContextConverter.fromCommandContext(commandContext, EnableModel.class);
             model.setFeatures(featureFlagService.getAllFeatures());
             String response = templateService.renderTemplate("disable_features_response", model);
-            channelService.sendTextInAChannel(response, commandContext.getChannel());
+            channelService.sendTextToChannelNoFuture(response, commandContext.getChannel());
         } else {
             String flagKey = (String) commandContext.getParameters().getParameters().get(0);
             FeatureConfig feature = featureFlagService.getFeatureDisplayForFeature(flagKey);

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/features/Enable.java

@@ -40,7 +40,7 @@ public class Enable extends AbstractConditionableCommand {
             EnableModel model = (EnableModel) ContextConverter.fromCommandContext(commandContext, EnableModel.class);
             model.setFeatures(featureFlagService.getAllFeatures());
             String response = templateService.renderTemplate("enable_features_response", model);
-            channelService.sendTextInAChannel(response, commandContext.getChannel());
+            channelService.sendTextToChannelNoFuture(response, commandContext.getChannel());
         } else {
             String flagKey = (String) commandContext.getParameters().getParameters().get(0);
             FeatureConfig feature = featureFlagService.getFeatureDisplayForFeature(flagKey);

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/features/Features.java

@@ -42,7 +42,7 @@ public class Features extends AbstractConditionableCommand {
         FeaturesModel featuresModel = (FeaturesModel) ContextConverter.fromCommandContext(commandContext, FeaturesModel.class);
         featuresModel.setFeatures(featureFlagConverter.fromFeatureFlags(features));
         MessageToSend messageToSend = templateService.renderEmbedTemplate("features_response", featuresModel);
-        channelService.sendMessageToEndInTextChannel(messageToSend, commandContext.getChannel());
+        channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
         return CommandResult.fromSuccess();
     }
 

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

@@ -59,7 +59,7 @@ public class Help implements Command {
             HelpModuleOverviewModel model = (HelpModuleOverviewModel) ContextConverter.fromCommandContext(commandContext, HelpModuleOverviewModel.class);
             model.setModules(subModules);
             MessageToSend messageToSend = templateService.renderEmbedTemplate("help_module_overview_response", model);
-            channelService.sendMessageToEndInTextChannel(messageToSend, commandContext.getChannel());
+            channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
         } else {
             String parameter = (String) parameters.get(0);
             if(moduleService.moduleExists(parameter)){
@@ -70,7 +70,7 @@ public class Help implements Command {
                 model.setModule(module);
                 model.setSubModules(subModules);
                 MessageToSend messageToSend = templateService.renderEmbedTemplate("help_module_details_response", model);
-                channelService.sendMessageToEndInTextChannel(messageToSend, commandContext.getChannel());
+                channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
             } else if(commandRegistry.commandExists(parameter)) {
                 Command command = commandRegistry.getCommandByName(parameter);
                 ACommand aCommand = commandManagementService.findCommandByName(parameter);
@@ -83,7 +83,7 @@ public class Help implements Command {
                 }
                 model.setCommand(command.getConfiguration());
                 MessageToSend messageToSend = templateService.renderEmbedTemplate("help_command_details_response", model);
-                channelService.sendMessageToEndInTextChannel(messageToSend, commandContext.getChannel());
+                channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
             }
         }
         return CommandResult.fromSuccess();

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

@@ -6,13 +6,16 @@ import dev.sheldan.abstracto.core.exception.GuildException;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.models.database.AChannel;
+import dev.sheldan.abstracto.templating.service.TemplateService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.*;
 import net.dv8tion.jda.api.requests.restaction.MessageAction;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
+import java.nio.channels.Channel;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -25,23 +28,26 @@ public class ChannelServiceBean implements ChannelService {
     @Autowired
     private BotService botService;
 
+    @Autowired
+    private TemplateService templateService;
+
     @Override
-    public void sendTextInAChannel(String text, AChannel channel) {
+    public void sendTextToAChannelNoFuture(String text, AChannel channel) {
-        sendTextInAChannelFuture(text, channel);
+        sendTextToAChannel(text, channel);
     }
 
     @Override
-    public void sendTextInAChannel(String text, MessageChannel channel) {
+    public void sendTextToChannelNoFuture(String text, MessageChannel channel) {
-        sendTextInAChannelFuture(text, channel);
+        sendTextToChannel(text, channel);
     }
 
     @Override
-    public CompletableFuture<Message> sendTextInAChannelFuture(String text, AChannel channel) {
+    public CompletableFuture<Message> sendTextToAChannel(String text, AChannel channel) {
         Guild guild = botService.getInstance().getGuildById(channel.getServer().getId());
         if (guild != null) {
             TextChannel textChannel = guild.getTextChannelById(channel.getId());
             if(textChannel != null) {
-                return sendTextInAChannelFuture(text, textChannel);
+                return sendTextToChannel(text, textChannel);
             } else {
                 log.error("Channel {} to post towards was not found in server {}", channel.getId(), channel.getServer().getId());
                 throw new ChannelException(String.format("Channel %s to post to not found.", channel.getId()));
@@ -53,17 +59,32 @@ public class ChannelServiceBean implements ChannelService {
     }
 
     @Override
-    public CompletableFuture<Message> sendTextInAChannelFuture(String text, MessageChannel channel) {
+    public CompletableFuture<Message> sendMessageToAChannel(Message message, AChannel channel) {
+        Optional<TextChannel> textChannelOpt = botService.getTextChannelFromServer(channel.getServer().getId(), channel.getId());
+        if(textChannelOpt.isPresent()) {
+            TextChannel textChannel = textChannelOpt.get();
+            return sendMessageToChannel(message, textChannel);
+        }
+        throw new ChannelException(String.format("Channel %s in guild %s not found.", channel.getId(), channel.getServer().getId()));
+    }
+
+    @Override
+    public CompletableFuture<Message> sendMessageToChannel(Message message, MessageChannel channel) {
+        return channel.sendMessage(message).submit();
+    }
+
+    @Override
+    public CompletableFuture<Message> sendTextToChannel(String text, MessageChannel channel) {
         return channel.sendMessage(text).submit();
     }
 
     @Override
-    public CompletableFuture<Message> sendEmbedInAChannelFuture(MessageEmbed embed, AChannel channel) {
+    public CompletableFuture<Message> sendEmbedToAChannel(MessageEmbed embed, AChannel channel) {
         Guild guild = botService.getInstance().getGuildById(channel.getServer().getId());
         if (guild != null) {
             TextChannel textChannel = guild.getTextChannelById(channel.getId());
             if(textChannel != null) {
-                return sendEmbedInAChannelFuture(embed, textChannel);
+                return sendEmbedToChannel(embed, textChannel);
             } else {
                 log.error("Channel {} to post towards was not found in server {}", channel.getId(), channel.getServer().getId());
                 throw new ChannelException(String.format("Channel %s to post to not found.", channel.getId()));
@@ -75,26 +96,26 @@ public class ChannelServiceBean implements ChannelService {
     }
 
     @Override
-    public CompletableFuture<Message> sendEmbedInAChannelFuture(MessageEmbed embed, MessageChannel channel) {
+    public CompletableFuture<Message> sendEmbedToChannel(MessageEmbed embed, MessageChannel channel) {
         return channel.sendMessage(embed).submit();
     }
 
     @Override
-    public List<CompletableFuture<Message>> sendMessageToEndInAChannel(MessageToSend messageToSend, AChannel channel) {
+    public List<CompletableFuture<Message>> sendMessageToSendToAChannel(MessageToSend messageToSend, AChannel channel) {
         Optional<TextChannel> textChannelFromServer = botService.getTextChannelFromServer(channel.getServer().getId(), channel.getId());
         if(textChannelFromServer.isPresent()) {
-            return sendMessageToEndInTextChannel(messageToSend, textChannelFromServer.get());
+            return sendMessageToSendToChannel(messageToSend, textChannelFromServer.get());
         }
         throw new ChannelException(String.format("Channel %s was not found.", channel.getId()));
     }
 
     @Override
-    public List<CompletableFuture<Message>> sendMessageToEndInTextChannel(MessageToSend messageToSend, MessageChannel textChannel) {
+    public List<CompletableFuture<Message>> sendMessageToSendToChannel(MessageToSend messageToSend, MessageChannel textChannel) {
         String messageText = messageToSend.getMessage();
         List<CompletableFuture<Message>> futures = new ArrayList<>();
         if(StringUtils.isBlank(messageText)) {
             messageToSend.getEmbeds().forEach(embed ->
-                futures.add(sendEmbedInAChannelFuture(embed, textChannel))
+                futures.add(sendEmbedToChannel(embed, textChannel))
             );
         } else  {
             MessageAction messageAction = textChannel.sendMessage(messageText);
@@ -102,7 +123,7 @@ public class ChannelServiceBean implements ChannelService {
                 CompletableFuture<Message> messageFuture = messageAction.embed(messageToSend.getEmbeds().get(0)).submit();
                 futures.add(messageFuture);
                 messageToSend.getEmbeds().stream().skip(1).forEach(embed ->
-                    futures.add(sendEmbedInAChannelFuture(embed, textChannel))
+                    futures.add(sendEmbedToChannel(embed, textChannel))
                 );
             } else {
                 futures.add(messageAction.submit());
@@ -145,6 +166,22 @@ public class ChannelServiceBean implements ChannelService {
         messageAction.queue();
     }
 
+    @Override
+    public CompletableFuture<Void> deleteTextChannel(AChannel channel) {
+        TextChannel textChannelById = botService.getInstance().getTextChannelById(channel.getId());
+        if(textChannelById != null) {
+            return textChannelById.delete().submit();
+        }
+        throw new ChannelException(String.format("Failed to delete channel %s in server %s", channel.getId(), channel.getServer().getId()));
+    }
+
+    @Override
+    @Transactional
+    public List<CompletableFuture<Message>> sendTemplateInChannel(String templateKey, Object model, MessageChannel channel) {
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(templateKey, model);
+        return sendMessageToSendToChannel(messageToSend, channel);
+    }
+
     @Override
     public CompletableFuture<TextChannel> createTextChannel(String name, AServer server, Long categoryId) {
         Optional<Guild> guildById = botService.getGuildById(server.getId());

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/MessageServiceBean.java

@@ -2,6 +2,7 @@ package dev.sheldan.abstracto.core.service;
 
 import dev.sheldan.abstracto.core.exception.EmoteException;
 import dev.sheldan.abstracto.core.exception.GuildException;
+import dev.sheldan.abstracto.core.models.ServerChannelMessage;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.EmoteManagementService;
@@ -13,6 +14,8 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
@@ -70,7 +73,7 @@ public class MessageServiceBean implements MessageService {
 
     @Override
     public CompletableFuture<Message> createStatusMessage(MessageToSend messageToSend, AChannel channel) {
-        return channelService.sendMessageToEndInAChannel(messageToSend, channel).get(0);
+        return channelService.sendMessageToSendToAChannel(messageToSend, channel).get(0);
     }
 
     @Override
@@ -103,6 +106,6 @@ public class MessageServiceBean implements MessageService {
 
     @Transactional
     public void sendFeedbackAboutException(Throwable e, TextChannel feedbackChannel) {
-        channelService.sendTextInAChannel(String.format("Failed to send message: %s", e.getMessage()), feedbackChannel);
+        channelService.sendTextToChannelNoFuture(String.format("Failed to send message: %s", e.getMessage()), feedbackChannel);
     }
 }

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

@@ -38,7 +38,7 @@ public class PostTargetServiceBean implements PostTargetService {
 
     @Override
     public CompletableFuture<Message> sendTextInPostTarget(String text, PostTarget target)  {
-        return channelService.sendTextInAChannelFuture(text, target.getChannelReference());
+        return channelService.sendTextToAChannel(text, target.getChannelReference());
     }
 
     @Override
@@ -86,6 +86,17 @@ public class PostTargetServiceBean implements PostTargetService {
         return this.sendEmbedInPostTarget(embed, postTarget);
     }
 
+    @Override
+    public CompletableFuture<Message> sendMessageInPostTarget(Message message, String postTargetName, Long serverId) {
+        PostTarget postTarget = this.getPostTarget(postTargetName, serverId);
+        return sendMessageInPostTarget(message, postTarget);
+    }
+
+    @Override
+    public CompletableFuture<Message> sendMessageInPostTarget(Message message, PostTarget target) {
+        return channelService.sendMessageToAChannel(message, target.getChannelReference());
+    }
+
     @Override
     public List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, String postTargetName, Long serverId)  {
         PostTarget postTarget = this.getPostTarget(postTargetName, serverId);
@@ -95,7 +106,7 @@ public class PostTargetServiceBean implements PostTargetService {
     @Override
     public List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, PostTarget target)  {
         TextChannel textChannelForPostTarget = getTextChannelForPostTarget(target);
-        return channelService.sendMessageToEndInTextChannel(message, textChannelForPostTarget);
+        return channelService.sendMessageToSendToChannel(message, textChannelForPostTarget);
     }
 
     @Override

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/ChannelService.java

@@ -13,17 +13,21 @@ import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
 public interface ChannelService {
-    void sendTextInAChannel(String text, AChannel channel);
+    void sendTextToAChannelNoFuture(String text, AChannel channel);
-    void sendTextInAChannel(String text, MessageChannel channel);
+    void sendTextToChannelNoFuture(String text, MessageChannel channel);
-    CompletableFuture<Message> sendTextInAChannelFuture(String text, AChannel channel);
+    CompletableFuture<Message> sendTextToAChannel(String text, AChannel channel);
-    CompletableFuture<Message> sendTextInAChannelFuture(String text, MessageChannel channel);
+    CompletableFuture<Message> sendMessageToAChannel(Message message, AChannel channel);
-    CompletableFuture<Message> sendEmbedInAChannelFuture(MessageEmbed embed, AChannel channel);
+    CompletableFuture<Message> sendMessageToChannel(Message message, MessageChannel channel);
-    CompletableFuture<Message> sendEmbedInAChannelFuture(MessageEmbed embed, MessageChannel channel);
+    CompletableFuture<Message> sendTextToChannel(String text, MessageChannel channel);
-    List<CompletableFuture<Message>> sendMessageToEndInAChannel(MessageToSend messageToSend, AChannel channel);
+    CompletableFuture<Message> sendEmbedToAChannel(MessageEmbed embed, AChannel channel);
-    List<CompletableFuture<Message>> sendMessageToEndInTextChannel(MessageToSend messageToSend, MessageChannel textChannel);
+    CompletableFuture<Message> sendEmbedToChannel(MessageEmbed embed, MessageChannel channel);
+    List<CompletableFuture<Message>> sendMessageToSendToAChannel(MessageToSend messageToSend, AChannel channel);
+    List<CompletableFuture<Message>> sendMessageToSendToChannel(MessageToSend messageToSend, MessageChannel textChannel);
     Optional<TextChannel> getTextChannelInGuild(Long serverId, Long channelId);
     void editMessageInAChannel(MessageToSend messageToSend, AChannel channel, Long messageId);
     void editMessageInAChannel(MessageToSend messageToSend, MessageChannel channel, Long messageId);
+    CompletableFuture<Void> deleteTextChannel(AChannel channel);
+    List<CompletableFuture<Message>> sendTemplateInChannel(String templateKey, Object model, MessageChannel channel);
 
     CompletableFuture<TextChannel> createTextChannel(String name, AServer server, Long categoryId);
 }

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/MessageCache.java

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.models.cache.CachedReaction;
 import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.MessageReaction;
 
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
 public interface MessageCache {

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/MessageService.java

@@ -1,5 +1,6 @@
 package dev.sheldan.abstracto.core.service;
 
+import dev.sheldan.abstracto.core.models.ServerChannelMessage;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.templating.model.MessageToSend;
@@ -7,6 +8,7 @@ import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.TextChannel;
 import net.dv8tion.jda.api.entities.User;
 
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
 public interface MessageService {

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/service/PostTargetService.java

@@ -13,6 +13,8 @@ public interface PostTargetService {
     CompletableFuture<Message> sendEmbedInPostTarget(MessageEmbed embed, PostTarget target);
     CompletableFuture<Message> sendTextInPostTarget(String text, String postTargetName, Long serverId);
     CompletableFuture<Message> sendEmbedInPostTarget(MessageEmbed embed, String postTargetName, Long serverId);
+    CompletableFuture<Message> sendMessageInPostTarget(Message message, String postTargetName,  Long serverId);
+    CompletableFuture<Message> sendMessageInPostTarget(Message message, PostTarget target);
     List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, String postTargetName, Long serverId);
     List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, PostTarget target);
     List<CompletableFuture<Message>> editEmbedInPostTarget(Long messageId, MessageToSend message, PostTarget target);

abstracto-application/template-config/src/main/resources/templates/en_US/commands/modmail/reply/help/reply_exception_cannot_send_message_to_use_en_US.ftl

@@ -0,0 +1 @@
+Failed to send message to user.