[AB-184] adding various metrics to the system, organizing imports, changing some transactional behaviour

adding okhttp metrics, split bot service into multiple services (guild, message), unified some places that services are used in order to interact with the api, and not directly the objects (this is to make it easier for metric to be accurate)

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/Ban.java

@@ -2,10 +2,12 @@ package dev.sheldan.abstracto.moderation.commands;
 
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.condition.CommandCondition;
-import dev.sheldan.abstracto.core.command.config.HelpInfo;
 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.*;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ContextConverter;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/BanId.java

@@ -1,10 +1,12 @@
 package dev.sheldan.abstracto.moderation.commands;
 
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
-import dev.sheldan.abstracto.core.command.config.HelpInfo;
 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.*;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ContextConverter;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/Kick.java

@@ -2,10 +2,12 @@ package dev.sheldan.abstracto.moderation.commands;
 
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.condition.CommandCondition;
-import dev.sheldan.abstracto.core.command.config.HelpInfo;
 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.*;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ContextConverter;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/MyWarnings.java

@@ -38,7 +38,7 @@ public class MyWarnings extends AbstractConditionableCommand {
     @Override
     public CommandResult execute(CommandContext commandContext) {
         MyWarningsModel model = (MyWarningsModel) ContextConverter.fromCommandContext(commandContext, MyWarningsModel.class);
-        AUserInAServer userInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
+        AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
         Long currentWarnCount = warnManagementService.getActiveWarnsForUser(userInAServer);
         model.setCurrentWarnCount(currentWarnCount);
         Long totalWarnCount = warnManagementService.getTotalWarnsForUser(userInAServer);

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/SlowMode.java

@@ -3,8 +3,8 @@ package dev.sheldan.abstracto.moderation.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.execution.CommandContext;
 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.core.utils.ParseUtils;

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/UserNoteCommand.java

@@ -33,7 +33,7 @@ public class UserNoteCommand extends AbstractConditionableCommand {
         List<Object> parameters = commandContext.getParameters().getParameters();
         Member member = (Member) parameters.get(0);
         String text = (String) parameters.get(1);
-        AUserInAServer userInAServer = userInServerManagementService.loadUser(member);
+        AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(member);
         userNoteManagementService.createUserNote(userInAServer, text);
         return CommandResult.fromSuccess();
     }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/UserNotes.java

@@ -60,7 +60,7 @@ public class UserNotes extends AbstractConditionableCommand {
         ListNotesModel model = (ListNotesModel) ContextConverter.fromCommandContext(commandContext, ListNotesModel.class);
         if(parameters.size() == 1) {
             Member member = (Member) parameters.get(0);
-            AUserInAServer userInAServer = userInServerManagementService.loadUser(member);
+            AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(member);
             userNotes = userNoteManagementService.loadNotesForUser(userInAServer);
             FullUserInServer specifiedUser = FullUserInServer
                     .builder()

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/Warn.java

@@ -2,10 +2,12 @@ package dev.sheldan.abstracto.moderation.commands;
 
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
 import dev.sheldan.abstracto.core.command.condition.CommandCondition;
-import dev.sheldan.abstracto.core.command.config.HelpInfo;
 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.*;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ContextConverter;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/Warnings.java

@@ -60,7 +60,7 @@ public class Warnings extends AbstractConditionableCommand {
         List<Warning> warnsToDisplay;
         if(!commandContext.getParameters().getParameters().isEmpty()) {
             Member member = (Member) commandContext.getParameters().getParameters().get(0);
-            warnsToDisplay = warnManagementService.getAllWarnsForUser(userInServerManagementService.loadUser(member));
+            warnsToDisplay = warnManagementService.getAllWarnsForUser(userInServerManagementService.loadOrCreateUser(member));
         } else {
             AServer server = serverManagementService.loadServer(commandContext.getGuild());
             warnsToDisplay = warnManagementService.getAllWarningsOfServer(server);

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/mute/UnMute.java

@@ -41,7 +41,7 @@ public class UnMute extends AbstractConditionableCommand {
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         Member member = (Member) parameters.get(0);
-        AUserInAServer userToUnMute = userInServerManagementService.loadUser(member);
+        AUserInAServer userToUnMute = userInServerManagementService.loadOrCreateUser(member);
         return muteService.unMuteUser(userToUnMute).thenApply(aVoid ->
             CommandResult.fromSuccess()
         );

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/converter/UserNotesConverter.java

@@ -2,7 +2,7 @@ package dev.sheldan.abstracto.moderation.converter;
 
 import dev.sheldan.abstracto.core.models.FullUserInServer;
 import dev.sheldan.abstracto.core.models.ServerSpecificId;
-import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.models.database.UserNote;
@@ -15,8 +15,8 @@ import org.springframework.transaction.annotation.Transactional;
 
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.Map;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 
 @Component
@@ -25,7 +25,7 @@ public class UserNotesConverter {
     private UserInServerManagementService userInServerManagementService;
 
     @Autowired
-    private BotService botService;
+    private MemberService memberService;
 
     @Autowired
     private UserNotesConverter self;
@@ -38,7 +38,7 @@ public class UserNotesConverter {
         List<CompletableFuture<Member>> memberFutures = new ArrayList<>();
         HashMap<ServerSpecificId, CompletableFuture<Member>> noteMemberMap = new HashMap<>();
         userNotes.forEach(userNote -> {
-            CompletableFuture<Member> memberFuture = botService.getMemberInServerAsync(userNote.getUser());
+            CompletableFuture<Member> memberFuture = memberService.getMemberInServerAsync(userNote.getUser());
             memberFutures.add(memberFuture);
             noteMemberMap.put(userNote.getUserNoteId(), memberFuture);
         });

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/converter/WarnEntryConverter.java

@@ -3,7 +3,7 @@ package dev.sheldan.abstracto.moderation.converter;
 import dev.sheldan.abstracto.core.models.FullUserInServer;
 import dev.sheldan.abstracto.core.models.FutureMemberPair;
 import dev.sheldan.abstracto.core.models.ServerSpecificId;
-import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.models.database.Warning;
@@ -16,15 +16,15 @@ import org.springframework.transaction.annotation.Transactional;
 
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.Map;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 
 @Component
 public class WarnEntryConverter {
 
     @Autowired
-    private BotService botService;
+    private MemberService memberService;
 
     @Autowired
     private UserInServerManagementService userInServerManagementService;
@@ -40,8 +40,8 @@ public class WarnEntryConverter {
         List<CompletableFuture<Member>> allFutures = new ArrayList<>();
         // TODO maybe optimize to not need to look into the cache twice
         warnings.forEach(warning -> {
-            CompletableFuture<Member> warningMemberFuture = botService.getMemberInServerAsync(warning.getWarningUser());
-            CompletableFuture<Member> warnedMemberFuture = botService.getMemberInServerAsync(warning.getWarnedUser());
+            CompletableFuture<Member> warningMemberFuture = memberService.getMemberInServerAsync(warning.getWarningUser());
+            CompletableFuture<Member> warnedMemberFuture = memberService.getMemberInServerAsync(warning.getWarnedUser());
             FutureMemberPair futurePair = FutureMemberPair.builder().firstMember(warningMemberFuture).secondMember(warnedMemberFuture).build();
             loadedWarnings.put(warning.getWarnId(), futurePair);
             allFutures.add(warningMemberFuture);
@@ -62,14 +62,14 @@ public class WarnEntryConverter {
             FullUserInServer warnedUser = FullUserInServer
                     .builder()
                     .member(warnedMember)
-                    .aUserInAServer(userInServerManagementService.loadUser(warnedMember))
+                    .aUserInAServer(userInServerManagementService.loadOrCreateUser(warnedMember))
                     .build();
 
             Member warningMember = memberPair.getFirstMember().join();
             FullUserInServer warningUser = FullUserInServer
                     .builder()
                     .member(warningMember)
-                    .aUserInAServer(userInServerManagementService.loadUser(warningMember))
+                    .aUserInAServer(userInServerManagementService.loadOrCreateUser(warningMember))
                     .build();
             WarnEntry entry = WarnEntry
                     .builder()

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/job/WarnDecayJob.java

@@ -13,6 +13,7 @@ import org.quartz.PersistJobDataAfterExecution;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.scheduling.quartz.QuartzJobBean;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Isolation;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
@@ -36,7 +37,7 @@ public class WarnDecayJob extends QuartzJobBean {
     private WarnService warnService;
 
     @Override
-    @Transactional
+    @Transactional(isolation = Isolation.SERIALIZABLE)
     public void executeInternal(JobExecutionContext context) throws JobExecutionException {
         List<AServer> allServers = serverManagementService.getAllServers();
         log.info("Executing warn decay job.");

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/async/InviteLinkFilterListener.java

@@ -4,8 +4,12 @@ import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.config.ListenerPriority;
 import dev.sheldan.abstracto.core.execution.result.MessageReceivedListenerResult;
 import dev.sheldan.abstracto.core.listener.sync.jda.MessageReceivedListener;
+import dev.sheldan.abstracto.core.metrics.service.CounterMetric;
+import dev.sheldan.abstracto.core.metrics.service.MetricService;
+import dev.sheldan.abstracto.core.metrics.service.MetricTag;
 import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.service.FeatureModeService;
+import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
@@ -20,7 +24,9 @@ import net.dv8tion.jda.api.entities.Message;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import javax.annotation.PostConstruct;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.regex.Matcher;
@@ -41,6 +47,22 @@ public class InviteLinkFilterListener implements MessageReceivedListener {
     @Autowired
     private TemplateService templateService;
 
+    @Autowired
+    private MetricService metricService;
+
+    @Autowired
+    private MessageService messageService;
+
+    public static final String MODERATION_PURGE_METRIC = "invite.filter";
+    public static final String CONSEQUENCE = "consequence";
+
+    private static final CounterMetric MESSAGE_INVITE_FILTERED =
+            CounterMetric
+                    .builder()
+                    .tagList(Arrays.asList(MetricTag.getTag(CONSEQUENCE, "filtered")))
+                    .name(MODERATION_PURGE_METRIC)
+                    .build();
+
     public static final String INVITE_LINK_DELETED_NOTIFICATION_EMBED_TEMPLATE_KEY = "invite_link_deleted_notification";
 
     @Override
@@ -60,7 +82,8 @@ public class InviteLinkFilterListener implements MessageReceivedListener {
         }
 
         if(toDelete) {
-            message.delete().queue();
+            metricService.incrementCounter(MESSAGE_INVITE_FILTERED);
+            messageService.deleteMessage(message);
             boolean trackUsages = featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, serverId, InviteFilterMode.TRACK_USES);
             if(trackUsages) {
                 codesToTrack.forEach(s -> inviteLinkFilterService.storeFilteredInviteLinkUsage(s, author));
@@ -111,4 +134,9 @@ public class InviteLinkFilterListener implements MessageReceivedListener {
     public Integer getPriority() {
         return ListenerPriority.HIGH;
     }
+
+    @PostConstruct
+    public void postConstruct() {
+        metricService.registerCounter(MESSAGE_INVITE_FILTERED, "Amount of messages containing an invite filtered");
+    }
 }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/async/JoinLogger.java

@@ -3,7 +3,7 @@ package dev.sheldan.abstracto.moderation.listener.async;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncJoinListener;
 import dev.sheldan.abstracto.core.models.ServerUser;
-import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.config.posttargets.LoggingPostTarget;
@@ -30,7 +30,7 @@ public class JoinLogger implements AsyncJoinListener {
     private PostTargetService postTargetService;
 
     @Autowired
-    private BotService botService;
+    private MemberService memberService;
 
     @Autowired
     private JoinLogger self;
@@ -44,7 +44,7 @@ public class JoinLogger implements AsyncJoinListener {
     @Override
     public void execute(ServerUser serverUser) {
         log.info("User {} joined server {}.", serverUser.getUserId(), serverUser.getServerId());
-        botService.getMemberInServerAsync(serverUser.getServerId(), serverUser.getUserId()).thenAccept(member ->
+        memberService.getMemberInServerAsync(serverUser.getServerId(), serverUser.getUserId()).thenAccept(member ->
             self.sendJoinLog(serverUser, member)
         );
     }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/async/JoinMuteListener.java

@@ -27,7 +27,7 @@ public class JoinMuteListener implements AsyncJoinListener {
 
     @Override
     public void execute(ServerUser serverUser) {
-        AUserInAServer aUserInAServer = userInServerManagementService.loadUser(serverUser.getServerId(), serverUser.getUserId());
+        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(serverUser.getServerId(), serverUser.getUserId());
         if(muteManagementService.hasActiveMute(aUserInAServer)) {
             log.info("Re-muting user {} which joined the server {}, because the mute has not ended yet.", serverUser.getUserId(), serverUser.getServerId());
             muteService.applyMuteRole(aUserInAServer);

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/async/LeaveLogger.java

@@ -3,7 +3,7 @@ package dev.sheldan.abstracto.moderation.listener.async;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncLeaveListener;
 import dev.sheldan.abstracto.core.models.ServerUser;
-import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.config.posttargets.LoggingPostTarget;
@@ -32,7 +32,7 @@ public class LeaveLogger implements AsyncLeaveListener {
     private PostTargetService postTargetService;
 
     @Autowired
-    private BotService botService;
+    private MemberService memberService;
 
     @Autowired
     private LeaveLogger self;
@@ -48,7 +48,7 @@ public class LeaveLogger implements AsyncLeaveListener {
     @Override
     public void execute(ServerUser serverUser) {
         log.info("User {} left server {}.", serverUser.getUserId(), serverUser.getServerId());
-        botService.getMemberInServerAsync(serverUser.getServerId(), serverUser.getUserId()).thenAccept(member ->
+        memberService.getMemberInServerAsync(serverUser.getServerId(), serverUser.getUserId()).thenAccept(member ->
             self.executeJoinLogging(serverUser, member)
         );
     }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/async/MessageDeleteLogListener.java

@@ -3,7 +3,8 @@ package dev.sheldan.abstracto.moderation.listener.async;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncMessageDeletedListener;
 import dev.sheldan.abstracto.core.models.cache.CachedMessage;
-import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
@@ -39,7 +40,10 @@ public class MessageDeleteLogListener implements AsyncMessageDeletedListener {
     private PostTargetService postTargetService;
 
     @Autowired
-    private BotService botService;
+    private MemberService memberService;
+
+    @Autowired
+    private ChannelService channelService;
 
     @Autowired
     private ChannelManagementService channelManagementService;
@@ -55,7 +59,7 @@ public class MessageDeleteLogListener implements AsyncMessageDeletedListener {
 
     @Override
     public void execute(CachedMessage messageFromCache) {
-        botService.getMemberInServerAsync(messageFromCache.getServerId(), messageFromCache.getAuthor().getAuthorId()).thenAccept(member ->
+        memberService.getMemberInServerAsync(messageFromCache.getServerId(), messageFromCache.getAuthor().getAuthorId()).thenAccept(member ->
             self.executeListener(messageFromCache, member)
         );
     }
@@ -64,7 +68,7 @@ public class MessageDeleteLogListener implements AsyncMessageDeletedListener {
     public void executeListener(CachedMessage messageFromCache, Member authorMember) {
         log.trace("Message {} in channel {} in guild {} was deleted.", messageFromCache.getMessageId(), messageFromCache.getChannelId(), messageFromCache.getServerId());
 
-        TextChannel textChannel = botService.getTextChannelFromServer(messageFromCache.getServerId(), messageFromCache.getChannelId());
+        TextChannel textChannel = channelService.getTextChannelFromServer(messageFromCache.getServerId(), messageFromCache.getChannelId());
         MessageDeletedLog logModel = MessageDeletedLog
                 .builder()
                 .cachedMessage(messageFromCache)

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/async/MessageEditedListener.java

@@ -3,7 +3,8 @@ package dev.sheldan.abstracto.moderation.listener.async;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncMessageTextUpdatedListener;
 import dev.sheldan.abstracto.core.models.cache.CachedMessage;
-import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.config.posttargets.LoggingPostTarget;
@@ -28,7 +29,10 @@ public class MessageEditedListener implements AsyncMessageTextUpdatedListener {
     private PostTargetService postTargetService;
 
     @Autowired
-    private BotService botService;
+    private MemberService memberService;
+
+    @Autowired
+    private ChannelService channelService;
 
     @Override
     public void execute(CachedMessage messageBefore, CachedMessage messageAfter) {
@@ -36,9 +40,9 @@ public class MessageEditedListener implements AsyncMessageTextUpdatedListener {
             log.trace("Message content was the same. Possible reason was: message was not in cache.");
             return;
         }
-        botService.getMemberInServerAsync(messageAfter.getServerId(), messageAfter.getAuthor().getAuthorId()).thenAccept(author -> {
+        memberService.getMemberInServerAsync(messageAfter.getServerId(), messageAfter.getAuthor().getAuthorId()).thenAccept(author -> {
             log.trace("Message {} in channel {} in guild {} was edited.", messageBefore.getMessageId(), messageBefore.getChannelId(), messageBefore.getServerId());
-            TextChannel textChannel = botService.getTextChannelFromServer(messageAfter.getServerId(), messageAfter.getChannelId());
+            TextChannel textChannel = channelService.getTextChannelFromServer(messageAfter.getServerId(), messageAfter.getChannelId());
             MessageEditedLog log = MessageEditedLog
                     .builder()
                     .messageAfter(messageAfter)

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

@@ -2,8 +2,8 @@ package dev.sheldan.abstracto.moderation.service;
 
 import dev.sheldan.abstracto.core.exception.GuildNotFoundException;
 import dev.sheldan.abstracto.core.models.context.ServerContext;
-import dev.sheldan.abstracto.core.service.BotService;
 import dev.sheldan.abstracto.core.service.FeatureModeService;
+import dev.sheldan.abstracto.core.service.GuildService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
@@ -31,7 +31,7 @@ public class BanServiceBean implements BanService {
     public static final String BAN_ID_LOG_TEMPLATE = "banId_log";
 
     @Autowired
-    private BotService botService;
+    private GuildService guildService;
 
     @Autowired
     private TemplateService templateService;
@@ -72,7 +72,7 @@ public class BanServiceBean implements BanService {
     }
 
     private CompletableFuture<Void> banUser(Long guildId, Long userId, String reason) {
-        Optional<Guild> guildByIdOptional = botService.getGuildByIdOptional(guildId);
+        Optional<Guild> guildByIdOptional = guildService.getGuildByIdOptional(guildId);
         if(guildByIdOptional.isPresent()) {
             return banUser(guildByIdOptional.get(), userId, reason);
         } else {

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

@@ -27,7 +27,10 @@ import dev.sheldan.abstracto.scheduling.service.SchedulerService;
 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 net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.TextChannel;
 import org.quartz.JobDataMap;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
@@ -67,7 +70,10 @@ public class MuteServiceBean implements MuteService {
     private TemplateService templateService;
 
     @Autowired
-    private BotService botService;
+    private GuildService guildService;
+
+    @Autowired
+    private MemberService memberService;
 
     @Autowired
     private MessageService messageService;
@@ -94,6 +100,9 @@ public class MuteServiceBean implements MuteService {
     @Autowired
     private FeatureModeService featureModeService;
 
+    @Autowired
+    private ChannelService channelService;
+
     public static final String MUTE_LOG_TEMPLATE = "mute_log";
     public static final String UN_MUTE_LOG_TEMPLATE = "unmute_log";
     public static final String MUTE_NOTIFICATION_TEMPLATE = "mute_notification";
@@ -103,13 +112,13 @@ public class MuteServiceBean implements MuteService {
     public CompletableFuture<Void> muteMember(Member memberToMute, Member mutingMember, String reason, Instant unMuteDate, ServerChannelMessage message) {
         FullUserInServer mutedUser = FullUserInServer
                 .builder()
-                    .aUserInAServer(userInServerManagementService.loadUser(memberToMute))
+                    .aUserInAServer(userInServerManagementService.loadOrCreateUser(memberToMute))
                 .member(memberToMute)
                 .build();
 
         FullUserInServer mutingUser = FullUserInServer
                 .builder()
-                .aUserInAServer(userInServerManagementService.loadUser(mutingMember))
+                .aUserInAServer(userInServerManagementService.loadOrCreateUser(mutingMember))
                 .member(mutingMember)
                 .build();
         return muteUserInServer(mutedUser, mutingUser, reason, unMuteDate, message);
@@ -153,8 +162,8 @@ public class MuteServiceBean implements MuteService {
         String muteNotificationMessage = templateService.renderTemplate(MUTE_NOTIFICATION_TEMPLATE, muteNotification);
         CompletableFuture<Message> messageCompletableFuture = messageService.sendMessageToUser(memberBeingMuted.getUser(), muteNotificationMessage);
         messageCompletableFuture.exceptionally(throwable -> {
-            TextChannel feedBackChannel = botService.getTextChannelFromServer(message.getServerId(), message.getChannelId());
-            feedBackChannel.sendMessage(throwable.getMessage()).submit().whenComplete((exceptionMessage, innerThrowable) -> {
+            TextChannel feedBackChannel = channelService.getTextChannelFromServer(message.getServerId(), message.getChannelId());
+            channelService.sendTextToChannel(throwable.getMessage(), feedBackChannel).whenComplete((exceptionMessage, innerThrowable) -> {
                 notificationFuture.complete(null);
                 log.info("Successfully notified user {} in server {} about mute.", memberBeingMuted.getId(), memberBeingMuted.getGuild().getId());
             });
@@ -174,8 +183,8 @@ public class MuteServiceBean implements MuteService {
                 .server(channel.getServer())
                 .messageId(muteContext.getContext().getMessageId())
                 .build();
-        AUserInAServer userInServerBeingMuted = userInServerManagementService.loadUser(muteContext.getMutedUser());
-        AUserInAServer userInServerMuting = userInServerManagementService.loadUser(muteContext.getMutedUser());
+        AUserInAServer userInServerBeingMuted = userInServerManagementService.loadOrCreateUser(muteContext.getMutedUser());
+        AUserInAServer userInServerMuting = userInServerManagementService.loadOrCreateUser(muteContext.getMutedUser());
         muteManagementService.createMute(userInServerBeingMuted, userInServerMuting, muteContext.getReason(), muteContext.getMuteTargetDate(), origin, triggerKey, muteContext.getMuteId());
     }
 
@@ -269,9 +278,9 @@ public class MuteServiceBean implements MuteService {
         }
         Mute mute = muteManagementService.getAMuteOf(aUserInAServer);
         Long muteId = mute.getMuteId().getId();
-        CompletableFuture<Member> mutingMemberFuture = botService.getMemberInServerAsync(mute.getMutingUser());
-        CompletableFuture<Member> mutedMemberFuture = botService.getMemberInServerAsync(mute.getMutedUser());
-        Guild guild = botService.getGuildById(mute.getMuteId().getServerId());
+        CompletableFuture<Member> mutingMemberFuture = memberService.getMemberInServerAsync(mute.getMutingUser());
+        CompletableFuture<Member> mutedMemberFuture = memberService.getMemberInServerAsync(mute.getMutedUser());
+        Guild guild = guildService.getGuildById(mute.getMuteId().getServerId());
         return endMute(mute, false).thenCompose(unused ->
             CompletableFuture.allOf(mutingMemberFuture, mutedMemberFuture)
         ).thenCompose(unused -> self.sendUnMuteLogForManualUnMute(muteId, mutingMemberFuture, mutedMemberFuture, guild));
@@ -302,17 +311,17 @@ public class MuteServiceBean implements MuteService {
         log.info("UnMuting {} in server {}", mute.getMutedUser().getUserReference().getId(), mutingServer.getId());
         MuteRole muteRole = muteRoleManagementService.retrieveMuteRoleForServer(mutingServer);
         log.trace("Using the mute role {} mapping to role {}", muteRole.getId(), muteRole.getRole().getId());
-        Guild guild = botService.getGuildById(mutingServer.getId());
+        Guild guild = guildService.getGuildById(mutingServer.getId());
         CompletableFuture<Void> roleRemovalFuture;
         // TODO replace with future, because caching
-        if(botService.isUserInGuild(guild, mute.getMutedUser())) {
+        if(memberService.isUserInGuild(guild, mute.getMutedUser())) {
             roleRemovalFuture = roleService.removeRoleFromUserFuture(mute.getMutedUser(), muteRole.getRole());
         } else {
             roleRemovalFuture = CompletableFuture.completedFuture(null);
             log.info("User to unMute left the guild.");
         }
-        CompletableFuture<Member> mutingMemberFuture = botService.getMemberInServerAsync(mute.getMutingUser());
-        CompletableFuture<Member> mutedMemberFuture = botService.getMemberInServerAsync(mute.getMutedUser());
+        CompletableFuture<Member> mutingMemberFuture = memberService.getMemberInServerAsync(mute.getMutingUser());
+        CompletableFuture<Member> mutedMemberFuture = memberService.getMemberInServerAsync(mute.getMutedUser());
         CompletableFuture<Void> finalFuture = new CompletableFuture<>();
         CompletableFuture.allOf(mutingMemberFuture, mutedMemberFuture, roleRemovalFuture, mutingMemberFuture, mutedMemberFuture).handle((aVoid, throwable) -> {
             if(sendNotification) {
@@ -379,6 +388,7 @@ public class MuteServiceBean implements MuteService {
 
     @Override
     public void completelyUnMuteMember(Member member) {
-        completelyUnMuteUser(userInServerManagementService.loadUser(member));
+        completelyUnMuteUser(userInServerManagementService.loadOrCreateUser(member));
     }
+
 }

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

@@ -1,5 +1,8 @@
 package dev.sheldan.abstracto.moderation.service;
 
+import dev.sheldan.abstracto.core.metrics.service.CounterMetric;
+import dev.sheldan.abstracto.core.metrics.service.MetricService;
+import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.moderation.exception.NoMessageFoundException;
 import dev.sheldan.abstracto.moderation.models.template.commands.PurgeStatusUpdateModel;
@@ -15,6 +18,7 @@ import net.dv8tion.jda.api.utils.TimeUtil;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import javax.annotation.PostConstruct;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
@@ -32,6 +36,20 @@ public class PurgeServiceBean implements PurgeService {
     @Autowired
     private TemplateService templateService;
 
+    @Autowired
+    private MetricService metricService;
+
+    @Autowired
+    private ChannelService channelService;
+
+    public static final String MODERATION_PURGE_METRIC = "moderation.purge";
+
+    private static final CounterMetric PURGE_MESSAGE_COUNTER_METRIC =
+            CounterMetric
+                    .builder()
+                    .name(MODERATION_PURGE_METRIC)
+                    .build();
+
     @Override
     public CompletableFuture<Void> purgeMessagesInChannel(Integer amountToDelete, TextChannel channel, Long startId, Member purgedMember) {
         return purgeMessages(amountToDelete, channel, startId, purgedMember, amountToDelete, 0, 0L);
@@ -45,9 +63,10 @@ public class PurgeServiceBean implements PurgeService {
         } else {
             toDeleteInThisIteration = amountToDelete % PURGE_MAX_MESSAGES;
         }
+        metricService.incrementCounter(PURGE_MESSAGE_COUNTER_METRIC, (long) toDeleteInThisIteration);
         log.info("Purging {} this iteration ({}/{}) messages in channel {} in server {}.", toDeleteInThisIteration, currentCount, totalCount, channel.getId(), channel.getGuild().getId());
 
-        CompletableFuture<MessageHistory> historyFuture = channel.getHistoryBefore(startId, toDeleteInThisIteration).submit();
+        CompletableFuture<MessageHistory> historyFuture = channelService.getHistoryOfChannel(channel, startId, toDeleteInThisIteration);
         CompletableFuture<Long> statusMessageFuture = getOrCreatedStatusMessage(channel, totalCount, statusMessageId);
 
         CompletableFuture<Void> deletionFuture = new CompletableFuture<>();
@@ -60,6 +79,7 @@ public class PurgeServiceBean implements PurgeService {
                 if(messagesToDeleteNow.size() == 0) {
                     log.warn("No messages found to delete, all were filtered.");
                     deletionFuture.completeExceptionally(new NoMessageFoundException());
+                    // TODO move to message service
                     channel.deleteMessageById(currentStatusMessageId).queueAfter(5, TimeUnit.SECONDS);
                     return;
                 }
@@ -71,7 +91,7 @@ public class PurgeServiceBean implements PurgeService {
                 if (messagesToDeleteNow.size() > 1) {
                     bulkDeleteMessages(channel, deletionFuture, messagesToDeleteNow, consumer);
                 } else if (messagesToDeleteNow.size() == 1) {
-                    latestMessage.delete().queue(consumer, deletionFuture::completeExceptionally);
+                    messageService.deleteMessage(latestMessage).queue(consumer, deletionFuture::completeExceptionally);
                 }
 
             } catch (Exception e) {
@@ -88,9 +108,9 @@ public class PurgeServiceBean implements PurgeService {
 
     private void bulkDeleteMessages(TextChannel channel, CompletableFuture<Void> deletionFuture, List<Message> messagesToDeleteNow, Consumer<Void> consumer) {
         try {
-            channel.deleteMessages(messagesToDeleteNow).queue(consumer, deletionFuture::completeExceptionally);
+            channelService.deleteMessagesInChannel(channel, messagesToDeleteNow).queue(consumer, deletionFuture::completeExceptionally);
         } catch (IllegalArgumentException e) {
-            channel.sendMessage(e.getMessage()).queue();
+            channelService.sendTextToChannel(e.getMessage(), channel);
             log.warn("Failed to bulk delete, message was most likely too old to delete by bulk.", e);
             deletionFuture.complete(null);
         }
@@ -145,6 +165,7 @@ public class PurgeServiceBean implements PurgeService {
                 );
             } else {
                 log.trace("Completed purging of {} messages.", totalCount);
+                // Todo Move to message service
                 channel.deleteMessageById(currentStatusMessageId).queueAfter(5, TimeUnit.SECONDS);
                 deletionFuture.complete(null);
             }
@@ -159,4 +180,9 @@ public class PurgeServiceBean implements PurgeService {
     public CompletableFuture<Void> purgeMessagesInChannel(Integer count, TextChannel channel, Message origin, Member purgingRestriction) {
         return purgeMessagesInChannel(count, channel, origin.getIdLong(), purgingRestriction);
     }
+
+    @PostConstruct
+    public void postConstruct() {
+        metricService.registerCounter(PURGE_MESSAGE_COUNTER_METRIC, "Amount of messages deleted by purge.");
+    }
 }

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

@@ -2,7 +2,7 @@ package dev.sheldan.abstracto.moderation.service;
 
 import dev.sheldan.abstracto.core.exception.ChannelNotInGuildException;
 import dev.sheldan.abstracto.core.models.database.AChannel;
-import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.core.service.ChannelService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.TextChannel;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -17,16 +17,16 @@ import java.util.concurrent.CompletableFuture;
 public class SlowModeServiceBean implements SlowModeService {
 
     @Autowired
-    private BotService botService;
+    private ChannelService channelService;
 
     @Override
     public CompletableFuture<Void> setSlowMode(TextChannel channel, Duration duration) {
         log.info("Setting slow mode to {} in channel {} in server {}", duration.toString(), channel.getIdLong(), channel.getGuild().getId());
-        long seconds = duration.getSeconds();
+        int seconds = (int) duration.getSeconds();
         if(seconds > TextChannel.MAX_SLOWMODE) {
             throw new IllegalArgumentException("Slow mode duration must be < " + TextChannel.MAX_SLOWMODE + " seconds.");
         }
-        return channel.getManager().setSlowmode((int) seconds).submit();
+        return channelService.setSlowModeInChannel(channel, seconds);
     }
 
     @Override
@@ -36,7 +36,7 @@ public class SlowModeServiceBean implements SlowModeService {
 
     @Override
     public CompletableFuture<Void> setSlowMode(AChannel channel, Duration duration)  {
-        Optional<TextChannel> textChannelOptional = botService.getTextChannelFromServerOptional(channel.getServer().getId(), channel.getId());
+        Optional<TextChannel> textChannelOptional = channelService.getTextChannelFromServerOptional(channel.getServer().getId(), channel.getId());
         if(textChannelOptional.isPresent()) {
             TextChannel textChannel = textChannelOptional.get();
             return this.setSlowMode(textChannel, duration);

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

@@ -3,38 +3,36 @@ package dev.sheldan.abstracto.moderation.service;
 import dev.sheldan.abstracto.core.models.FutureMemberPair;
 import dev.sheldan.abstracto.core.models.ServerSpecificId;
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.*;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
-import dev.sheldan.abstracto.moderation.config.features.mode.WarnDecayMode;
 import dev.sheldan.abstracto.moderation.config.features.WarningDecayFeature;
+import dev.sheldan.abstracto.moderation.config.features.mode.WarnDecayMode;
 import dev.sheldan.abstracto.moderation.config.features.mode.WarningMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.WarnDecayPostTarget;
 import dev.sheldan.abstracto.moderation.config.posttargets.WarningPostTarget;
-import dev.sheldan.abstracto.moderation.models.template.job.WarnDecayLogModel;
-import dev.sheldan.abstracto.moderation.models.template.job.WarnDecayWarning;
-import dev.sheldan.abstracto.templating.model.MessageToSend;
+import dev.sheldan.abstracto.moderation.models.database.Warning;
 import dev.sheldan.abstracto.moderation.models.template.commands.WarnContext;
 import dev.sheldan.abstracto.moderation.models.template.commands.WarnNotification;
-import dev.sheldan.abstracto.moderation.models.database.Warning;
+import dev.sheldan.abstracto.moderation.models.template.job.WarnDecayLogModel;
+import dev.sheldan.abstracto.moderation.models.template.job.WarnDecayWarning;
 import dev.sheldan.abstracto.moderation.service.management.WarnManagementService;
-import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+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 net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Member;
+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;
 
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 
@@ -55,7 +53,10 @@ public class WarnServiceBean implements WarnService {
     private TemplateService templateService;
 
     @Autowired
-    private BotService botService;
+    private MemberService memberService;
+
+    @Autowired
+    private GuildService guildService;
 
     @Autowired
     private MessageService messageService;
@@ -115,8 +116,8 @@ public class WarnServiceBean implements WarnService {
     public void persistWarning(WarnContext context) {
         log.info("Persisting warning {} in server {} for user {} by user {}.",
                 context.getWarnId(), context.getGuild().getId(), context.getWarnedMember().getId(), context.getMember().getId());
-        AUserInAServer warnedUser = userInServerManagementService.loadUser(context.getWarnedMember());
-        AUserInAServer warningUser = userInServerManagementService.loadUser(context.getMember());
+        AUserInAServer warnedUser = userInServerManagementService.loadOrCreateUser(context.getWarnedMember());
+        AUserInAServer warningUser = userInServerManagementService.loadOrCreateUser(context.getMember());
         warnManagementService.createWarning(warnedUser, warningUser, context.getReason(), context.getWarnId());
 
     }
@@ -179,8 +180,8 @@ public class WarnServiceBean implements WarnService {
         List<CompletableFuture<Member>> allFutures = new ArrayList<>();
         Long serverId = server.getId();
         warningsToDecay.forEach(warning -> {
-            CompletableFuture<Member> warningMember = botService.getMemberInServerAsync(warning.getWarningUser());
-            CompletableFuture<Member> warnedMember = botService.getMemberInServerAsync(warning.getWarnedUser());
+            CompletableFuture<Member> warningMember = memberService.getMemberInServerAsync(warning.getWarningUser());
+            CompletableFuture<Member> warnedMember = memberService.getMemberInServerAsync(warning.getWarnedUser());
             FutureMemberPair futurePair = FutureMemberPair.builder().firstMember(warningMember).secondMember(warnedMember).build();
             warningMembers.put(warning.getWarnId(), futurePair);
         });
@@ -214,7 +215,7 @@ public class WarnServiceBean implements WarnService {
         });
         WarnDecayLogModel warnDecayLogModel = WarnDecayLogModel
                 .builder()
-                .guild(botService.getGuildById(server.getId()))
+                .guild(guildService.getGuildById(server.getId()))
                 .warnings(warnDecayWarnings)
                 .build();
         MessageToSend messageToSend = templateService.renderEmbedTemplate(WARN_DECAY_LOG_TEMPLATE_KEY, warnDecayLogModel);

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

@@ -71,7 +71,7 @@ public class MuteManagementServiceBean implements MuteManagementService {
 
     @Override
     public boolean hasActiveMute(Member member) {
-        return muteRepository.existsByMutedUserAndMuteEndedFalse(userInServerManagementService.loadUser(member));
+        return muteRepository.existsByMutedUserAndMuteEndedFalse(userInServerManagementService.loadOrCreateUser(member));
     }
 
     @Override
@@ -81,7 +81,7 @@ public class MuteManagementServiceBean implements MuteManagementService {
 
     @Override
     public Mute getAMuteOf(Member member) {
-        return getAMuteOf(userInServerManagementService.loadUser(member));
+        return getAMuteOf(userInServerManagementService.loadOrCreateUser(member));
     }
 
     @Override

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

@@ -3,9 +3,9 @@ package dev.sheldan.abstracto.moderation.service.management;
 import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
 import dev.sheldan.abstracto.core.models.ServerSpecificId;
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.moderation.models.database.Warning;
 import dev.sheldan.abstracto.moderation.repository.WarnRepository;
-import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;