added jda utilities dependency

added modmail with some simple features (chat between user and moderator), and initial server selection (currently allows all servers, and does not consider the modmail feature)
added the initial commands, not all of them hold logic currently
added some checks to not crash when a command has null configuration
changed systemconfig to also have a long value, because double is not fit for all cases
added locking mechanism, to effectively lock the whole table without using the ... proper locking mechanism (needs to be reviewed)
changed interface in channel service to be a message channel instead of a textChannel
changed starboard post to be a user in a server instead of only user

abstracto-application/abstracto-modules/modmail/modmail-impl/pom.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>dev.sheldan.abstracto.modules</groupId>
+        <artifactId>utility</artifactId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>modmail-impl</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>dev.sheldan.abstracto.modules</groupId>
+            <artifactId>modmail-int</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+    </dependencies>
+
+</project>

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

@@ -0,0 +1,43 @@
+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.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 org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class AnonReply extends AbstractConditionableCommand {
+
+    @Autowired
+    private RequiresModMailCondition requiresModMailCondition;
+
+    @Override
+    public CommandResult execute(CommandContext commandContext) {
+        return null;
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        return null;
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModMailFeatures.MODMAIL;
+    }
+
+    @Override
+    public List<CommandCondition> getConditions() {
+        List<CommandCondition> conditions = super.getConditions();
+        conditions.add(requiresModMailCondition);
+        return conditions;
+    }
+}

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

@@ -0,0 +1,43 @@
+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.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 org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class Close extends AbstractConditionableCommand {
+
+    @Autowired
+    private RequiresModMailCondition requiresModMailCondition;
+
+    @Override
+    public CommandResult execute(CommandContext commandContext) {
+        return null;
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        return null;
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModMailFeatures.MODMAIL;
+    }
+
+    @Override
+    public List<CommandCondition> getConditions() {
+        List<CommandCondition> conditions = super.getConditions();
+        conditions.add(requiresModMailCondition);
+        return conditions;
+    }
+}

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

@@ -0,0 +1,43 @@
+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.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 org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class CloseSilently extends AbstractConditionableCommand {
+
+    @Autowired
+    private RequiresModMailCondition requiresModMailCondition;
+
+    @Override
+    public CommandResult execute(CommandContext commandContext) {
+        return null;
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        return null;
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModMailFeatures.MODMAIL;
+    }
+
+    @Override
+    public List<CommandCondition> getConditions() {
+        List<CommandCondition> conditions = super.getConditions();
+        conditions.add(requiresModMailCondition);
+        return conditions;
+    }
+}

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

@@ -0,0 +1,28 @@
+package dev.sheldan.abstracto.modmail.commands;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+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.config.ModMailFeatures;
+import org.springframework.stereotype.Component;
+
+@Component
+public class Contact extends AbstractConditionableCommand {
+    @Override
+    public CommandResult execute(CommandContext commandContext) {
+        return null;
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        return null;
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModMailFeatures.MODMAIL;
+    }
+
+}

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

@@ -0,0 +1,22 @@
+package dev.sheldan.abstracto.modmail.commands;
+
+import dev.sheldan.abstracto.core.command.config.ModuleInfo;
+import dev.sheldan.abstracto.core.command.config.ModuleInterface;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ModMailModuleInterface implements ModuleInterface {
+
+    public static final String MODMAIL = "modMail";
+
+    @Override
+    public ModuleInfo getInfo() {
+        return ModuleInfo.builder().name(MODMAIL).description("Commands to be used for modmail.").build();
+    }
+
+
+    @Override
+    public String getParentModule() {
+        return "default";
+    }
+}

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

@@ -0,0 +1,67 @@
+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.config.Parameter;
+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 java.util.Arrays;
+import java.util.List;
+
+@Component
+public class Reply extends AbstractConditionableCommand {
+
+    @Autowired
+    private RequiresModMailCondition requiresModMailCondition;
+
+    @Autowired
+    private ModMailThreadService modMailThreadService;
+
+    @Autowired
+    private ModMailThreadManagementService modMailThreadManagementService;
+
+    @Override
+    public CommandResult execute(CommandContext commandContext) {
+        ModMailThread thread = modMailThreadManagementService.getByChannel(commandContext.getUserInitiatedContext().getChannel());
+        modMailThreadService.relayMessageToDm(thread, commandContext.getMessage());
+        return CommandResult.fromSuccess();
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter responseText = Parameter.builder().name("text").type(String.class).description("The text to reply with").build();
+        List<Parameter> parameters = Arrays.asList(responseText);
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("reply")
+                .module(ModMailModuleInterface.MODMAIL)
+                .parameters(parameters)
+                .help(helpInfo)
+                .templated(true)
+                .causesReaction(true)
+                .build();
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModMailFeatures.MODMAIL;
+    }
+
+    @Override
+    public List<CommandCondition> getConditions() {
+        List<CommandCondition> conditions = super.getConditions();
+        conditions.add(requiresModMailCondition);
+        return conditions;
+    }
+}

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

@@ -0,0 +1,52 @@
+package dev.sheldan.abstracto.modmail.commands;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+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.config.ModMailFeatures;
+import dev.sheldan.abstracto.modmail.service.ModMailThreadService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Component
+public class SetModMailCategory extends AbstractConditionableCommand {
+
+    @Autowired
+    private ModMailThreadService modMailThreadService;
+
+    @Override
+    public CommandResult execute(CommandContext commandContext) {
+        Long categoryId = (Long) commandContext.getParameters().getParameters().get(0);
+        modMailThreadService.setModMailCategoryTo(commandContext.getUserInitiatedContext().getServer(), categoryId);
+        return CommandResult.fromSuccess();
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter categoryId = Parameter.builder().name("categoryId").type(Long.class).description("The category id to be used for modmail.").build();
+        List<Parameter> parameters = Arrays.asList(categoryId);
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        List<String> aliases = Arrays.asList("modMailCat");
+        return CommandConfiguration.builder()
+                .name("setModMailCategory")
+                .module(ModMailModuleInterface.MODMAIL)
+                .aliases(aliases)
+                .parameters(parameters)
+                .help(helpInfo)
+                .templated(true)
+                .causesReaction(true)
+                .build();
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModMailFeatures.MODMAIL;
+    }
+}

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

@@ -0,0 +1,26 @@
+package dev.sheldan.abstracto.modmail.commands.condition;
+
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.condition.CommandCondition;
+import dev.sheldan.abstracto.core.command.condition.ConditionResult;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThread;
+import dev.sheldan.abstracto.modmail.service.management.ModMailThreadManagementService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class RequiresModMailCondition implements CommandCondition {
+
+    @Autowired
+    private ModMailThreadManagementService modMailThreadManagementService;
+
+    @Override
+    public ConditionResult shouldExecute(CommandContext commandContext, Command command) {
+        ModMailThread thread = modMailThreadManagementService.getByChannel(commandContext.getUserInitiatedContext().getChannel());
+        if(thread != null) {
+            return ConditionResult.builder().result(true).build();
+        }
+        return ConditionResult.builder().result(false).reason("Not in a mod mail thread.").build();
+    }
+}

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

@@ -0,0 +1,13 @@
+package dev.sheldan.abstracto.modmail.config;
+
+import dev.sheldan.abstracto.core.config.FeatureConfig;
+import dev.sheldan.abstracto.core.config.FeatureEnum;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ModMailFeature implements FeatureConfig {
+    @Override
+    public FeatureEnum getFeature() {
+        return ModMailFeatures.MODMAIL;
+    }
+}

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

@@ -0,0 +1,18 @@
+package dev.sheldan.abstracto.modmail.config;
+
+import dev.sheldan.abstracto.core.config.FeatureEnum;
+
+public enum ModMailFeatures implements FeatureEnum {
+    MODMAIL("modmail");
+
+    private String key;
+
+    ModMailFeatures(String key) {
+        this.key = key;
+    }
+
+    @Override
+    public String getKey() {
+        return this.key;
+    }
+}

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

@@ -0,0 +1,52 @@
+package dev.sheldan.abstracto.modmail.listener;
+
+import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.listener.PrivateMessageReceivedListener;
+import dev.sheldan.abstracto.core.models.database.AUser;
+import dev.sheldan.abstracto.core.service.management.UserManagementService;
+import dev.sheldan.abstracto.modmail.config.ModMailFeature;
+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 dev.sheldan.abstracto.templating.service.TemplateService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Message;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+@Slf4j
+public class ModMailMessageListener implements PrivateMessageReceivedListener {
+
+    @Autowired
+    private ModMailThreadService modMailThreadService;
+
+    @Autowired
+    private ModMailThreadManagementService modMailThreadManagementService;
+
+    @Autowired
+    private UserManagementService userManagementService;
+
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Override
+    @Transactional
+    public void execute(Message message) {
+        AUser user = userManagementService.loadUser(message.getAuthor().getIdLong());
+        ModMailThread existingThread = modMailThreadManagementService.getOpenModmailThreadForUser(user);
+        if(existingThread != null) {
+            modMailThreadService.relayMessageToModMailThread(existingThread, message);
+        } else {
+            modMailThreadService.createModMailPrompt(user, message.getChannel());
+        }
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModMailFeatures.MODMAIL;
+    }
+}

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

@@ -0,0 +1,9 @@
+package dev.sheldan.abstracto.modmail.repository;
+
+import dev.sheldan.abstracto.modmail.models.database.ModMailMessage;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface ModMailMessageRepository extends JpaRepository<ModMailMessage, Long> {
+}

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

@@ -0,0 +1,22 @@
+package dev.sheldan.abstracto.modmail.repository;
+
+import dev.sheldan.abstracto.core.models.database.AChannel;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUser;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThread;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThreadState;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ModMailThreadRepository extends JpaRepository<ModMailThread, Long> {
+    ModMailThread findByChannel(AChannel channel);
+    List<ModMailThread> findByUser(AUserInAServer aUserInAServer);
+    ModMailThread findByUser_UserReferenceAndStateNot(AUser user, ModMailThreadState state);
+    List<ModMailThread> findByServerAndState(AServer server, ModMailThreadState state);
+    ModMailThread findByUserAndStateNot(AUserInAServer userInAServer, ModMailThreadState state);
+    List<ModMailThread> findByUserAndState(AUserInAServer userInAServer, ModMailThreadState state);
+}

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

@@ -0,0 +1,243 @@
+package dev.sheldan.abstracto.modmail.service;
+
+import com.jagrosh.jdautilities.commons.waiter.EventWaiter;
+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.cache.CachedReaction;
+import dev.sheldan.abstracto.core.models.database.*;
+import dev.sheldan.abstracto.core.service.BotService;
+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.ModMailThread;
+import dev.sheldan.abstracto.modmail.models.dto.ServerChoice;
+import dev.sheldan.abstracto.modmail.models.template.ModMailModeratorReplyModel;
+import dev.sheldan.abstracto.modmail.models.template.ModMailServerChooserModel;
+import dev.sheldan.abstracto.modmail.service.management.ModMailMessageManagementService;
+import dev.sheldan.abstracto.modmail.service.management.ModMailThreadManagementService;
+import dev.sheldan.abstracto.templating.model.MessageToSend;
+import dev.sheldan.abstracto.templating.service.TemplateService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+@Component
+@Slf4j
+public class ModMailThreadServiceBean implements ModMailThreadService {
+
+    public static final String MODMAIL_CATEGORY = "modmailCategory";
+    @Autowired
+    private ModMailThreadManagementService modMailThreadManagementService;
+
+    @Autowired
+    private ConfigService configService;
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Autowired
+    private ChannelManagementService channelManagementService;
+
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
+    @Autowired
+    private BotService botService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Autowired
+    private ModMailMessageManagementService modMailMessageManagementService;
+
+    @Autowired
+    private ModMailThreadServiceBean self;
+
+    private List<String> NUMBER_EMOJI = Arrays.asList("\u0031\u20e3", "\u0032\u20e3", "\u0033\u20e3",
+            "\u0034\u20e3", "\u0035\u20e3", "\u0036\u20e3",
+            "\u0037\u20e3", "\u0038\u20e3", "\u0039\u20e3",
+            "\u0040\u20e3");
+
+
+    @Override
+    public void createModMailThreadForUser(FullUser aUserInAServer) {
+        Long categoryId = configService.getLongValue(MODMAIL_CATEGORY, aUserInAServer.getAUserInAServer().getServerReference().getId());
+        User user = aUserInAServer.getMember().getUser();
+        CompletableFuture<TextChannel> textChannel = channelService.createTextChannel(user.getName() + user.getDiscriminator(), aUserInAServer.getAUserInAServer().getServerReference(), categoryId);
+
+        textChannel.thenAccept(channel -> {
+            self.createThreadObject(channel, aUserInAServer);
+            self.sendWelcomeMessage(channel, aUserInAServer);
+        });
+    }
+
+    @Transactional
+    public void createThreadObject(TextChannel channel, FullUser user) {
+        AChannel channel2 = channelManagementService.createChannel(channel.getIdLong(), AChannelType.TEXT, user.getAUserInAServer().getServerReference());
+        log.info("Creating mod mail thread in channel {} with db channel {}", channel.getIdLong(), channel2.getId());
+        modMailThreadManagementService.createModMailThread(user.getAUserInAServer(), channel2);
+    }
+
+    @Override
+    public boolean hasOpenThread(AUserInAServer aUserInAServer) {
+        return modMailThreadManagementService.getOpenModmailThreadForUser(aUserInAServer) != null;
+    }
+
+    @Override
+    public boolean hasOpenThread(AUser user) {
+        return modMailThreadManagementService.getOpenModmailThreadForUser(user) != null;
+    }
+
+    @Override
+    public void setModMailCategoryTo(AServer server, Long categoryId) {
+        configService.setLongValue(MODMAIL_CATEGORY, server.getId(), categoryId);
+    }
+
+    @Override
+    public void createModMailPrompt(AUser user, MessageChannel channel) {
+        List<AUserInAServer> knownServers = userInServerManagementService.getUserInAllServers(user.getId());
+        if(knownServers.size() > 0) {
+            List<ServerChoice> availableGuilds = new ArrayList<>();
+            HashMap<String, AUserInAServer> choices = new HashMap<>();
+            for (int i = 0; i < knownServers.size(); i++) {
+                AUserInAServer aUserInAServer = knownServers.get(i);
+                AServer serverReference = aUserInAServer.getServerReference();
+                FullGuild guild = FullGuild
+                        .builder()
+                        .guild(botService.getGuildByIdNullable(serverReference.getId()))
+                        .server(serverReference)
+                        .build();
+                String reactionEmote = NUMBER_EMOJI.get(i);
+                ServerChoice serverChoice = ServerChoice.builder().guild(guild).reactionEmote(reactionEmote).build();
+                choices.put(reactionEmote, aUserInAServer);
+                availableGuilds.add(serverChoice);
+            }
+            ModMailServerChooserModel modMailServerChooserModel = ModMailServerChooserModel
+                    .builder()
+                    .commonGuilds(availableGuilds)
+                    .build();
+
+            String text = templateService.renderTemplate("modmail_modal_server_choice", modMailServerChooserModel);
+            // todo dont instantiate directly
+            EventWaiter waiter = new EventWaiter();
+            botService.getInstance().addEventListener(waiter);
+            ButtonMenu menu = new ButtonMenu.Builder()
+                    .setChoices(choices.keySet().toArray(new String[0]))
+                    .setEventWaiter(waiter)
+                    .setDescription(text)
+                    .setAction(reactionEmote -> {
+                        AUserInAServer chosenServer = choices.get(reactionEmote.getEmoji());
+                        Member memberInServer = botService.getMemberInServer(chosenServer);
+                        FullUser fullUser = FullUser.builder().member(memberInServer).aUserInAServer(chosenServer).build();
+                        self.createModMailThreadForUser(fullUser);
+                        botService.getInstance().removeEventListener(waiter);
+                    })
+                    .build();
+            menu.display(channel);
+        }
+    }
+
+    @Override
+    public void sendWelcomeMessage(TextChannel channel, FullUser aUserInAServer) {
+        String text = templateService.renderTemplate("modmail_welcome_message", new Object());
+        channel.sendMessage(text).queue();
+    }
+
+    @Override
+    public void relayMessageToModMailThread(ModMailThread modMailThread, Message message) {
+        Optional<TextChannel> textChannelFromServer = botService.getTextChannelFromServer(modMailThread.getServer().getId(), modMailThread.getChannel().getId());
+        if(textChannelFromServer.isPresent()) {
+            TextChannel textChannel = textChannelFromServer.get();
+            self.sendUserReply(textChannel, modMailThread, message);
+        }
+    }
+
+    @Transactional
+    public void sendUserReply(TextChannel textChannel, ModMailThread modMailThread, Message message) {
+        FullUser fullUser = FullUser
+                .builder()
+                .aUserInAServer(modMailThread.getUser())
+                .member(botService.getMemberInServer(modMailThread.getUser()))
+                .build();
+        ModMailModeratorReplyModel modMailUserReplyModel = ModMailModeratorReplyModel
+                .builder()
+                .modMailThread(modMailThread)
+                .postedMessage(message)
+                .threadUser(fullUser)
+                .build();
+        MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_moderator_message", modMailUserReplyModel);
+        List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToEndInTextChannel(messageToSend, textChannel);
+        List<Message> messages = new ArrayList<>();
+        completableFutures.forEach(messageCompletableFuture -> {
+            try {
+                Message messageToAdd = messageCompletableFuture.get();
+                messages.add(messageToAdd);
+            } catch (InterruptedException | ExecutionException e) {
+                log.error("Error while executing future to retrieve reaction.", e);
+            }
+            self.saveMessageIds(messages, modMailThread, modMailThread.getUser(), false);
+        });
+    }
+
+    @Override
+    public void relayMessageToDm(ModMailThread modMailThread, Message message) {
+        User userById = botService.getInstance().getUserById(modMailThread.getUser().getUserReference().getId());
+        if(userById != null) {
+            userById.openPrivateChannel().queue(privateChannel -> {
+                self.sendReply(modMailThread, message, privateChannel);
+            });
+        }
+    }
+
+    @Transactional
+    public void sendReply(ModMailThread modMailThread, Message message, PrivateChannel privateChannel) {
+        AUserInAServer moderator = userInServerManagementService.loadUser(message.getMember());
+        Member userInGuild = botService.getMemberInServer(modMailThread.getUser());
+        FullUser moderatorUser = FullUser
+                .builder()
+                .aUserInAServer(moderator)
+                .member(message.getMember())
+                .build();
+        FullUser fullThreadUser = FullUser
+                .builder()
+                .aUserInAServer(modMailThread.getUser())
+                .member(userInGuild)
+                .build();
+        ModMailModeratorReplyModel modMailUserReplyModel = ModMailModeratorReplyModel
+                .builder()
+                .modMailThread(modMailThread)
+                .postedMessage(message)
+                .threadUser(fullThreadUser)
+                .moderator(moderatorUser)
+                .build();
+        MessageToSend messageToSend = templateService.renderEmbedTemplate("modmail_staff_message", modMailUserReplyModel);
+        List<CompletableFuture<Message>> completableFutures = channelService.sendMessageToEndInTextChannel(messageToSend, privateChannel);
+        CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).thenAccept(aVoid -> {
+            List<Message> messages = new ArrayList<>();
+            completableFutures.forEach(messageCompletableFuture -> {
+                try {
+                    Message messageToAdd = messageCompletableFuture.get();
+                    messages.add(messageToAdd);
+                } catch (InterruptedException | ExecutionException e) {
+                    log.error("Error while executing send message to reply to user.", e);
+                }
+            });
+           self.saveMessageIds(messages, modMailThread, moderator, false);
+        });
+    }
+
+    @Transactional
+    public void saveMessageIds(List<Message> messages, ModMailThread modMailThread, AUserInAServer author, Boolean anonymous) {
+        messages.forEach(message -> {
+            modMailMessageManagementService.addMessageToThread(modMailThread, message, author, false);
+        });
+    }
+}

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

@@ -0,0 +1,30 @@
+package dev.sheldan.abstracto.modmail.service.management;
+
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.modmail.models.database.ModMailMessage;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThread;
+import dev.sheldan.abstracto.modmail.repository.ModMailMessageRepository;
+import net.dv8tion.jda.api.entities.Message;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ModMailMessageManagementServiceBean implements ModMailMessageManagementService {
+
+    @Autowired
+    private ModMailMessageRepository modMailMessageRepository;
+
+    @Override
+    public ModMailMessage addMessageToThread(ModMailThread modMailThread, Message message, AUserInAServer author, Boolean anonymous) {
+        ModMailMessage modMailMessage = ModMailMessage
+                .builder()
+                .author(author)
+                .messageId(message.getIdLong())
+                .threadReference(modMailThread)
+                .anonymous(anonymous)
+                .build();
+
+        modMailMessageRepository.save(modMailMessage);
+        return modMailMessage;
+    }
+}

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

@@ -0,0 +1,70 @@
+package dev.sheldan.abstracto.modmail.service.management;
+
+import dev.sheldan.abstracto.core.models.database.AChannel;
+import dev.sheldan.abstracto.core.models.database.AUser;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThread;
+import dev.sheldan.abstracto.modmail.models.database.ModMailThreadState;
+import dev.sheldan.abstracto.modmail.repository.ModMailThreadRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.time.Instant;
+import java.util.List;
+
+@Component
+public class ModMailThreadManagementServiceBean implements ModMailThreadManagementService {
+
+    @Autowired
+    private ModMailThreadRepository modMailThreadRepository;
+
+    @Autowired
+    private ChannelManagementService channelManagementService;
+
+    @Override
+    public ModMailThread getByChannelId(Long channelId) {
+        AChannel channel = channelManagementService.loadChannel(channelId);
+        return getByChannel(channel);
+    }
+
+    @Override
+    public ModMailThread getByChannel(AChannel channel) {
+        return modMailThreadRepository.findByChannel(channel);
+    }
+
+    @Override
+    public List<ModMailThread> getThreadByUserAndState(AUserInAServer userInAServer, ModMailThreadState state) {
+        return modMailThreadRepository.findByUserAndState(userInAServer, state);
+    }
+
+    @Override
+    public ModMailThread getOpenModmailThreadForUser(AUserInAServer userInAServer) {
+        return modMailThreadRepository.findByUserAndStateNot(userInAServer, ModMailThreadState.CLOSED);
+    }
+
+    @Override
+    public ModMailThread getOpenModmailThreadForUser(AUser user) {
+        return modMailThreadRepository.findByUser_UserReferenceAndStateNot(user, ModMailThreadState.CLOSED);
+    }
+
+    @Override
+    public List<ModMailThread> getModMailThreadForUser(AUserInAServer aUserInAServer) {
+        return modMailThreadRepository.findByUser(aUserInAServer);
+    }
+
+    @Override
+    public void createModMailThread(AUserInAServer userInAServer, AChannel channel) {
+        ModMailThread thread = ModMailThread
+                .builder()
+                .channel(channel)
+                .created(Instant.now())
+                .user(userInAServer)
+                .server(userInAServer.getServerReference())
+                .state(ModMailThreadState.INITIAL)
+                .updated(Instant.now())
+                .build();
+
+        modMailThreadRepository.save(thread);
+    }
+}

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/resources/templates/serverChooser/modmail_modal_server_choice_en_US.ftl

@@ -0,0 +1,5 @@
+<#include "server_chooser_server_list_description">
+
+<#list commonGuilds as guild>
+    ${guild.reactionEmote} ${guild.guild.guild.name}
+</#list>

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/resources/templates/threadContent/modmail_staff_message_embed_en_US.ftl

@@ -0,0 +1,20 @@
+{
+  "author": {
+    "name": "${threadUser.member.effectiveName}",
+    "avatar":  "${threadUser.member.user.effectiveAvatarUrl}"
+  },
+  "title": {
+    "title": "<#include "modmail_thread_staff_message_title">"
+  },
+  "color" : {
+    "r": 200,
+    "g": 0,
+    "b": 255
+  },
+  <#if postedMessage.contentRaw?has_content>
+    "description": "${postedMessage.contentRaw}"
+  </#if>
+   <#if postedMessage.attachments?size gt 0>
+   ,"imageUrl": "${postedMessage.attachments[0].proxyUrl}"
+   </#if>
+}

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/resources/templates/threadContent/modmail_user_message_embed_en_US.ftl

@@ -0,0 +1,20 @@
+{
+  "author": {
+    "name": "${threadUser.member.effectiveName}",
+    "avatar":  "${threadUser.member.user.effectiveAvatarUrl}"
+  },
+  "title": {
+    "title": "<#include "modmail_thread_user_message_title">"
+  },
+  "color" : {
+    "r": 200,
+    "g": 0,
+    "b": 255
+  },
+  <#if postedMessage.contentRaw?has_content>
+    "description": "${postedMessage.contentRaw}"
+  </#if>
+   <#if postedMessage.attachments?size gt 0>
+   ,"imageUrl": "${postedMessage.attachments[0].proxyUrl}"
+   </#if>
+}

abstracto-application/abstracto-modules/modmail/modmail-impl/src/main/resources/templates/welcomeMessage/modmail_welcome_message_en_US.ftl

@@ -0,0 +1 @@
+You opened a mod mail thread on the server reply in this channel to send messages to a staff only channel.