[AB-203] restructuring listeners to use more common code and common interfaces for listeners and models

restructuring entity listener to be async and added models fixing usage of repository save method adding interface dependencies to bundle dependency management
2026-03-27 22:31:45 +00:00 · 2021-03-21 10:58:31 +01:00
parent cfe7786d4d
commit b4e36efafb
241 changed files with 3521 additions and 2049 deletions
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/InviteLinkFilterListener.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/InviteLinkFilterListener.java
@@ -2,12 +2,13 @@ package dev.sheldan.abstracto.moderation.listener;

 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.config.ListenerPriority;
-import dev.sheldan.abstracto.core.execution.result.MessageReceivedListenerResult;
+import dev.sheldan.abstracto.core.listener.ConsumableListenerResult;
 import dev.sheldan.abstracto.core.listener.sync.jda.MessageReceivedListener;
 import dev.sheldan.abstracto.core.metric.service.CounterMetric;
 import dev.sheldan.abstracto.core.metric.service.MetricService;
 import dev.sheldan.abstracto.core.metric.service.MetricTag;
 import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.listener.MessageReceivedModel;
 import dev.sheldan.abstracto.core.service.FeatureModeService;
 import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
@@ -69,7 +70,8 @@ public class InviteLinkFilterListener implements MessageReceivedListener {
    public static final String INVITE_LINK_DELETED_NOTIFICATION_EMBED_TEMPLATE_KEY = "invite_link_deleted_notification";

    @Override
-    public MessageReceivedListenerResult execute(Message message) {
+    public ConsumableListenerResult execute(MessageReceivedModel model) {
+        Message message = model.getMessage();
        Long serverId = message.getGuild().getIdLong();
        Matcher matcher = Message.INVITE_PATTERN.matcher(message.getContentRaw());
        ServerUser author = ServerUser.builder().userId(message.getAuthor().getIdLong()).serverId(message.getGuild().getIdLong()).build();
@@ -95,9 +97,9 @@ public class InviteLinkFilterListener implements MessageReceivedListener {
            if(sendNotification) {
                sendDeletionNotification(codesToTrack, message);
            }
-            return MessageReceivedListenerResult.DELETED;
+            return ConsumableListenerResult.DELETED;
        } else {
-            return MessageReceivedListenerResult.PROCESSED;
+            return ConsumableListenerResult.PROCESSED;
        }
    }

--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/JoinLogger.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/JoinLogger.java
@@ -1,19 +1,18 @@
 package dev.sheldan.abstracto.moderation.listener;

 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncJoinListener;
-import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.listener.MemberJoinModel;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
 import dev.sheldan.abstracto.moderation.config.posttarget.LoggingPostTarget;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import lombok.extern.slf4j.Slf4j;
-import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.User;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;

 import java.util.HashMap;

@@ -42,20 +41,14 @@ public class JoinLogger implements AsyncJoinListener {
    }

    @Override
-    public void execute(ServerUser serverUser) {
-        log.info("User {} joined server {}.", serverUser.getUserId(), serverUser.getServerId());
-        memberService.getMemberInServerAsync(serverUser.getServerId(), serverUser.getUserId()).thenAccept(member ->
-            self.sendJoinLog(serverUser, member)
-        );
-    }
-
-    @Transactional
-    public void sendJoinLog(ServerUser serverUser, Member member) {
-        HashMap<String, Object> parameters = getUserParameter(member.getUser());
+    public DefaultListenerResult execute(MemberJoinModel serverUser) {
+        HashMap<String, Object> parameters = getUserParameter(serverUser.getMember().getUser());
        String text = templateService.renderTemplateWithMap(USER_JOIN_TEMPLATE, parameters, serverUser.getServerId());
        postTargetService.sendTextInPostTarget(text, LoggingPostTarget.JOIN_LOG, serverUser.getServerId());
+        return DefaultListenerResult.PROCESSED;
    }

+
    @Override
    public FeatureDefinition getFeature() {
        return ModerationFeatureDefinition.LOGGING;
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/JoinMuteListener.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/JoinMuteListener.java
@@ -1,9 +1,10 @@
 package dev.sheldan.abstracto.moderation.listener;

 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncJoinListener;
-import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.listener.MemberJoinModel;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
 import dev.sheldan.abstracto.moderation.service.MuteService;
@@ -26,12 +27,13 @@ public class JoinMuteListener implements AsyncJoinListener {
    private UserInServerManagementService userInServerManagementService;

    @Override
-    public void execute(ServerUser serverUser) {
-        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(serverUser.getServerId(), serverUser.getUserId());
+    public DefaultListenerResult execute(MemberJoinModel model) {
+        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(model.getServerId(), model.getJoiningUser().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());
+            log.info("Re-muting user {} which joined the server {}, because the mute has not ended yet.", model.getJoiningUser().getUserId(), model.getServerId());
            muteService.applyMuteRole(aUserInAServer);
        }
+        return DefaultListenerResult.PROCESSED;
    }

    @Override
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/LeaveLogger.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/LeaveLogger.java
@@ -1,20 +1,19 @@
 package dev.sheldan.abstracto.moderation.listener;

 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncLeaveListener;
-import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.listener.MemberLeaveModel;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
 import dev.sheldan.abstracto.moderation.config.posttarget.LoggingPostTarget;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import lombok.extern.slf4j.Slf4j;
-import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.User;
 import org.jetbrains.annotations.NotNull;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;

 import javax.annotation.Nonnull;
 import java.util.HashMap;
@@ -45,23 +44,15 @@ public class LeaveLogger implements AsyncLeaveListener {
        return parameters;
    }

-    @Override
-    public void execute(ServerUser serverUser) {
-        log.info("User {} left server {}.", serverUser.getUserId(), serverUser.getServerId());
-        memberService.getMemberInServerAsync(serverUser.getServerId(), serverUser.getUserId()).thenAccept(member ->
-            self.executeJoinLogging(serverUser, member)
-        );
-    }
-
-    @Transactional
-    public void executeJoinLogging(ServerUser serverUser, Member member) {
-        String text = templateService.renderTemplateWithMap(USER_LEAVE_TEMPLATE, getUserParameter(member.getUser()), serverUser.getServerId());
-        postTargetService.sendTextInPostTarget(text, LoggingPostTarget.LEAVE_LOG, serverUser.getServerId());
-    }
-
    @Override
    public FeatureDefinition getFeature() {
        return ModerationFeatureDefinition.LOGGING;
    }

+    @Override
+    public DefaultListenerResult execute(MemberLeaveModel model) {
+        String text = templateService.renderTemplateWithMap(USER_LEAVE_TEMPLATE, getUserParameter(model.getMember().getUser()), model.getLeavingUser().getServerId());
+        postTargetService.sendTextInPostTarget(text, LoggingPostTarget.LEAVE_LOG, model.getServerId());
+        return DefaultListenerResult.PROCESSED;
+    }
 }
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/MessageDeleteLogListener.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/MessageDeleteLogListener.java
@@ -1,8 +1,10 @@
 package dev.sheldan.abstracto.moderation.listener;

 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncMessageDeletedListener;
 import dev.sheldan.abstracto.core.models.cache.CachedMessage;
+import dev.sheldan.abstracto.core.models.listener.MessageDeletedModel;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
@@ -58,10 +60,12 @@ public class MessageDeleteLogListener implements AsyncMessageDeletedListener {
    private MessageDeleteLogListener self;

    @Override
-    public void execute(CachedMessage messageFromCache) {
-        memberService.getMemberInServerAsync(messageFromCache.getServerId(), messageFromCache.getAuthor().getAuthorId()).thenAccept(member ->
-            self.executeListener(messageFromCache, member)
+    public DefaultListenerResult execute(MessageDeletedModel model) {
+        CachedMessage message = model.getCachedMessage();
+        memberService.getMemberInServerAsync(model.getServerId(), message.getAuthor().getAuthorId()).thenAccept(member ->
+            self.executeListener(message, member)
        );
+        return DefaultListenerResult.PROCESSED;
    }

    @Transactional
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/MessageEditedListener.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/MessageEditedListener.java
@@ -1,8 +1,10 @@
 package dev.sheldan.abstracto.moderation.listener;

 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncMessageTextUpdatedListener;
 import dev.sheldan.abstracto.core.models.cache.CachedMessage;
+import dev.sheldan.abstracto.core.models.listener.MessageTextUpdatedModel;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
@@ -12,6 +14,7 @@ import dev.sheldan.abstracto.moderation.model.template.listener.MessageEditedLog
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
 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.Service;
@@ -35,29 +38,26 @@ public class MessageEditedListener implements AsyncMessageTextUpdatedListener {
    private ChannelService channelService;

    @Override
-    public void execute(CachedMessage messageBefore, CachedMessage messageAfter) {
-        if(messageBefore.getContent().equals(messageAfter.getContent())) {
+    public DefaultListenerResult execute(MessageTextUpdatedModel model) {
+        Message messageAfter = model.getAfter();
+        CachedMessage messageBefore = model.getBefore();
+        if(messageBefore.getContent().equals(messageAfter.getContentRaw())) {
            log.trace("Message content was the same. Possible reason was: message was not in cache.");
-            return;
+            return DefaultListenerResult.IGNORED;
        }
-        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 = channelService.getTextChannelFromServer(messageAfter.getServerId(), messageAfter.getChannelId());
-            MessageEditedLog log = MessageEditedLog
-                    .builder()
-                    .messageAfter(messageAfter)
-                    .messageBefore(messageBefore)
-                    .messageChannel(textChannel)
-                    .guild(textChannel.getGuild())
-                    .member(author)
-                    .build();
-            MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_EDITED_TEMPLATE, log, messageBefore.getServerId());
-            postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.EDIT_LOG, messageBefore.getServerId());
-        }).exceptionally(throwable -> {
-            log.error("Failed to load member {} for message edited listener in server {} for message {} in channel {}.",
-                    messageAfter.getAuthor().getAuthorId(), messageAfter.getServerId(), messageAfter.getMessageId(), messageAfter.getChannelId(), throwable);
-            return null;
-        });
+        log.trace("Message {} in channel {} in guild {} was edited.", messageBefore.getMessageId(), messageBefore.getChannelId(), messageBefore.getServerId());
+        TextChannel textChannel = channelService.getTextChannelFromServer(model.getServerId(), messageBefore.getChannelId());
+        MessageEditedLog log = MessageEditedLog
+                .builder()
+                .messageAfter(messageAfter)
+                .messageBefore(messageBefore)
+                .messageChannel(textChannel)
+                .guild(textChannel.getGuild())
+                .member(messageAfter.getMember())
+                .build();
+        MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_EDITED_TEMPLATE, log, messageBefore.getServerId());
+        postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.EDIT_LOG, messageBefore.getServerId());
+        return DefaultListenerResult.PROCESSED;
    }

    @Override
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/MuteManagementServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/MuteManagementServiceBean.java
@@ -44,8 +44,7 @@ public class MuteManagementServiceBean implements MuteManagementService {
                .muteId(id)
                .muteEnded(false)
                .build();
-        muteRepository.save(mute);
-        return mute;
+        return muteRepository.save(mute);
    }

    @Override
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/MuteRoleManagementServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/MuteRoleManagementServiceBean.java
@@ -30,8 +30,7 @@ public class MuteRoleManagementServiceBean implements MuteRoleManagementService
                .role(role)
                .roleServer(server)
                .build();
-        muteRoleRepository.save(muteRole);
-        return  muteRole;
+        return muteRoleRepository.save(muteRole);
    }

    @Override
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/UserNoteManagementServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/UserNoteManagementServiceBean.java
@@ -36,8 +36,7 @@ public class UserNoteManagementServiceBean implements UserNoteManagementService
                .server(aUserInAServer.getServerReference())
                .user(aUserInAServer)
                .build();
-        userNoteRepository.save(newNote);
-        return newNote;
+        return userNoteRepository.save(newNote);
    }

    @Override
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/WarnManagementServiceBean.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/WarnManagementServiceBean.java
@@ -35,8 +35,7 @@ public class WarnManagementServiceBean implements WarnManagementService {
                .warnId(warningId)
                .decayed(false)
                .build();
-        warnRepository.save(warning);
-        return warning;
+        return warnRepository.save(warning);
    }

    @Override
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/InviteLinkFilterListenerTest.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/InviteLinkFilterListenerTest.java
@@ -1,8 +1,9 @@
 package dev.sheldan.abstracto.moderation.listener;

-import dev.sheldan.abstracto.core.execution.result.MessageReceivedListenerResult;
+import dev.sheldan.abstracto.core.listener.ConsumableListenerResult;
 import dev.sheldan.abstracto.core.metric.service.MetricService;
 import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.listener.MessageReceivedModel;
 import dev.sheldan.abstracto.core.service.FeatureModeService;
 import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
@@ -68,6 +69,9 @@ public class InviteLinkFilterListenerTest {
    @Mock
    private MetricService metricService;

+    @Mock
+    private MessageReceivedModel model;
+
    private static final Long SERVER_ID = 1L;
    private static final Long CHANNEL_ID = 2L;
    private static final Long USER_ID = 3L;
@@ -79,8 +83,9 @@ public class InviteLinkFilterListenerTest {
    public void testExecutionWithNoInvite() {
        when(message.getContentRaw()).thenReturn("text");
        setupBasicMessage();
-        MessageReceivedListenerResult result = testUnit.execute(message);
-        Assert.assertEquals(MessageReceivedListenerResult.PROCESSED, result);
+        when(model.getMessage()).thenReturn(message);
+        ConsumableListenerResult result = testUnit.execute(model);
+        Assert.assertEquals(ConsumableListenerResult.PROCESSED, result);
    }

    @Test
@@ -88,8 +93,9 @@ public class InviteLinkFilterListenerTest {
        when(message.getContentRaw()).thenReturn(INVITE_LINK);
        when(inviteLinkFilterService.isCodeFiltered(eq(INVITE_CODE), any(ServerUser.class))).thenReturn(false);
        setupBasicMessage();
-        MessageReceivedListenerResult result = testUnit.execute(message);
-        Assert.assertEquals(MessageReceivedListenerResult.PROCESSED, result);
+        when(model.getMessage()).thenReturn(message);
+        ConsumableListenerResult result = testUnit.execute(model);
+        Assert.assertEquals(ConsumableListenerResult.PROCESSED, result);
    }

    @Test
@@ -100,8 +106,9 @@ public class InviteLinkFilterListenerTest {
        when(featureModeService.featureModeActive(ModerationFeatureDefinition.INVITE_FILTER, SERVER_ID, InviteFilterMode.TRACK_USES)).thenReturn(false);
        when(featureModeService.featureModeActive(ModerationFeatureDefinition.INVITE_FILTER, SERVER_ID, InviteFilterMode.FILTER_NOTIFICATIONS)).thenReturn(false);
        setupBasicMessage();
-        MessageReceivedListenerResult result = testUnit.execute(message);
-        Assert.assertEquals(MessageReceivedListenerResult.DELETED, result);
+        when(model.getMessage()).thenReturn(message);
+        ConsumableListenerResult result = testUnit.execute(model);
+        Assert.assertEquals(ConsumableListenerResult.DELETED, result);
        verify(metricService, times(1)).incrementCounter(any());
    }

@@ -113,8 +120,9 @@ public class InviteLinkFilterListenerTest {
        when(featureModeService.featureModeActive(ModerationFeatureDefinition.INVITE_FILTER, SERVER_ID, InviteFilterMode.TRACK_USES)).thenReturn(true);
        when(featureModeService.featureModeActive(ModerationFeatureDefinition.INVITE_FILTER, SERVER_ID, InviteFilterMode.FILTER_NOTIFICATIONS)).thenReturn(false);
        setupBasicMessage();
-        MessageReceivedListenerResult result = testUnit.execute(message);
-        Assert.assertEquals(MessageReceivedListenerResult.DELETED, result);
+        when(model.getMessage()).thenReturn(message);
+        ConsumableListenerResult result = testUnit.execute(model);
+        Assert.assertEquals(ConsumableListenerResult.DELETED, result);
        verifyTracking();
        verify(metricService, times(1)).incrementCounter(any());
    }
@@ -128,8 +136,9 @@ public class InviteLinkFilterListenerTest {
        when(featureModeService.featureModeActive(ModerationFeatureDefinition.INVITE_FILTER, SERVER_ID, InviteFilterMode.FILTER_NOTIFICATIONS)).thenReturn(true);
        setupForNotification();
        setupBasicMessage();
-        MessageReceivedListenerResult result = testUnit.execute(message);
-        Assert.assertEquals(MessageReceivedListenerResult.DELETED, result);
+        when(model.getMessage()).thenReturn(message);
+        ConsumableListenerResult result = testUnit.execute(model);
+        Assert.assertEquals(ConsumableListenerResult.DELETED, result);
        verifyTracking();
        verify(metricService, times(1)).incrementCounter(any());
    }
@@ -143,9 +152,10 @@ public class InviteLinkFilterListenerTest {
        when(featureModeService.featureModeActive(ModerationFeatureDefinition.INVITE_FILTER, SERVER_ID, InviteFilterMode.FILTER_NOTIFICATIONS)).thenReturn(true);
        setupForNotification();
        setupBasicMessage();
-        MessageReceivedListenerResult result = testUnit.execute(message);
+        when(model.getMessage()).thenReturn(message);
+        ConsumableListenerResult result = testUnit.execute(model);
        verify(metricService, times(1)).incrementCounter(any());
-        Assert.assertEquals(MessageReceivedListenerResult.DELETED, result);
+        Assert.assertEquals(ConsumableListenerResult.DELETED, result);
        verify(inviteLinkFilterService, times(0)).storeFilteredInviteLinkUsage(eq(INVITE_CODE), any(ServerUser.class));
    }

@@ -158,9 +168,10 @@ public class InviteLinkFilterListenerTest {
        when(featureModeService.featureModeActive(ModerationFeatureDefinition.INVITE_FILTER, SERVER_ID, InviteFilterMode.FILTER_NOTIFICATIONS)).thenReturn(true);
        when(postTargetService.postTargetDefinedInServer(InviteFilterPostTarget.INVITE_DELETE_LOG, SERVER_ID)).thenReturn(false);
        setupBasicMessage();
-        MessageReceivedListenerResult result = testUnit.execute(message);
+        when(model.getMessage()).thenReturn(message);
+        ConsumableListenerResult result = testUnit.execute(model);
        verify(metricService, times(1)).incrementCounter(any());
-        Assert.assertEquals(MessageReceivedListenerResult.DELETED, result);
+        Assert.assertEquals(ConsumableListenerResult.DELETED, result);
        verify(inviteLinkFilterService, times(0)).storeFilteredInviteLinkUsage(eq(INVITE_CODE), any(ServerUser.class));
        verify(templateService, times(0)).renderEmbedTemplate(eq(InviteLinkFilterListener.INVITE_LINK_DELETED_NOTIFICATION_EMBED_TEMPLATE_KEY), any(DeletedInvitesNotificationModel.class), eq(SERVER_ID));
    }
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/JoinLoggerTest.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/JoinLoggerTest.java
@@ -1,6 +1,7 @@
 package dev.sheldan.abstracto.moderation.listener;

 import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.listener.MemberJoinModel;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.posttarget.LoggingPostTarget;
@@ -40,6 +41,8 @@ public class JoinLoggerTest {
    @Mock
    private Member member;

+    @Mock
+    private MemberJoinModel model;

    private static final Long SERVER_ID = 1L;
    private static final Long USER_ID = 2L;
@@ -48,17 +51,13 @@ public class JoinLoggerTest {
    public void testExecute() {
        when(serverUser.getUserId()).thenReturn(USER_ID);
        when(serverUser.getServerId()).thenReturn(SERVER_ID);
+        when(model.getMember()).thenReturn(member);
        when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
-        testUnit.execute(serverUser);
-        verify(self, times(1)).sendJoinLog(serverUser, member);
-    }
-
-    @Test
-    public void testJoinLog() {
-        String message = "text";
+        testUnit.execute(model);
        when(serverUser.getServerId()).thenReturn(SERVER_ID);
+        String message = "text";
        when(templateService.renderTemplateWithMap(eq(JoinLogger.USER_JOIN_TEMPLATE), any(), eq(SERVER_ID))).thenReturn(message);
-        testUnit.sendJoinLog(serverUser, member);
        verify(postTargetService, times(1)).sendTextInPostTarget(message, LoggingPostTarget.JOIN_LOG, SERVER_ID);
    }
+
 }
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/JoinMuteListenerTest.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/JoinMuteListenerTest.java
@@ -2,6 +2,7 @@ package dev.sheldan.abstracto.moderation.listener;

 import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.listener.MemberJoinModel;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.moderation.service.MuteService;
 import dev.sheldan.abstracto.moderation.service.management.MuteManagementService;
@@ -42,6 +43,9 @@ public class JoinMuteListenerTest {
    @Mock
    private ServerUser serverUser;

+    @Mock
+    private MemberJoinModel model;
+
    private static final Long SERVER_ID = 3L;
    private static final Long USER_ID = 4L;

@@ -51,7 +55,8 @@ public class JoinMuteListenerTest {
        when(serverUser.getUserId()).thenReturn(USER_ID);
        when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(joiningUser);
        when(muteManagementService.hasActiveMute(joiningUser)).thenReturn(false);
-        testUnit.execute(serverUser);
+        when(model.getMember()).thenReturn(member);
+        testUnit.execute(model);
        verify(muteService, times(0)).applyMuteRole(joiningUser);
    }

@@ -61,7 +66,8 @@ public class JoinMuteListenerTest {
        when(serverUser.getUserId()).thenReturn(USER_ID);
        when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(joiningUser);
        when(muteManagementService.hasActiveMute(joiningUser)).thenReturn(true);
-        testUnit.execute(serverUser);
+        when(model.getMember()).thenReturn(member);
+        testUnit.execute(model);
        verify(muteService, times(1)).applyMuteRole(joiningUser);
    }
 }
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/LeaveLoggerTest.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/LeaveLoggerTest.java
@@ -1,6 +1,7 @@
 package dev.sheldan.abstracto.moderation.listener;

 import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.listener.MemberLeaveModel;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.posttarget.LoggingPostTarget;
@@ -42,6 +43,9 @@ public class LeaveLoggerTest {
    @Mock
    private Member member;

+    @Mock
+    private MemberLeaveModel model;
+
    private static final Long SERVER_ID = 1L;
    private static final Long USER_ID = 2L;

@@ -50,19 +54,14 @@ public class LeaveLoggerTest {
         when(leavingUser.getUserId()).thenReturn(USER_ID);
         when(leavingUser.getServerId()).thenReturn(SERVER_ID);
         when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
-         testUnit.execute(leavingUser);
-         verify(self, times(1)).executeJoinLogging(leavingUser, member);
+         when(model.getMember()).thenReturn(member);
+         User user = Mockito.mock(User.class);
+         when(member.getUser()).thenReturn(user);
+         String message = "text";
+         when(leavingUser.getServerId()).thenReturn(SERVER_ID);
+         when(templateService.renderTemplateWithMap(eq(LeaveLogger.USER_LEAVE_TEMPLATE), any(), eq(SERVER_ID))).thenReturn(message);
+         testUnit.execute(model);
+         verify(postTargetService, times(1)).sendTextInPostTarget(message, LoggingPostTarget.LEAVE_LOG, SERVER_ID);
     }

-    @Test
-    public void executeListener() {
-        User user = Mockito.mock(User.class);
-        when(member.getUser()).thenReturn(user);
-        String message = "text";
-        when(leavingUser.getServerId()).thenReturn(SERVER_ID);
-        when(templateService.renderTemplateWithMap(eq(LeaveLogger.USER_LEAVE_TEMPLATE), any(), eq(SERVER_ID))).thenReturn(message);
-        testUnit.executeJoinLogging(leavingUser, member);
-        verify(postTargetService, times(1)).sendTextInPostTarget(message, LoggingPostTarget.LEAVE_LOG, SERVER_ID);
-
-    }
 }
--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/MessageDeleteLogListenerTest.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/MessageDeleteLogListenerTest.java
@@ -3,6 +3,7 @@ package dev.sheldan.abstracto.moderation.listener;
 import dev.sheldan.abstracto.core.models.cache.CachedAttachment;
 import dev.sheldan.abstracto.core.models.cache.CachedAuthor;
 import dev.sheldan.abstracto.core.models.cache.CachedMessage;
+import dev.sheldan.abstracto.core.models.listener.MessageDeletedModel;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
@@ -86,13 +87,18 @@ public class MessageDeleteLogListenerTest {
    @Mock
    private Guild guild;

+    @Mock
+    private MessageDeletedModel model;
+
    @Test
    public void testExecuteListener() {
        when(deletedMessage.getAuthor()).thenReturn(cachedAuthor);
        when(cachedAuthor.getAuthorId()).thenReturn(AUTHOR_ID);
        when(deletedMessage.getServerId()).thenReturn(SERVER_ID);
        when(memberService.getMemberInServerAsync(SERVER_ID, AUTHOR_ID)).thenReturn(CompletableFuture.completedFuture(member));
-        testUnit.execute(deletedMessage);
+        when(model.getCachedMessage()).thenReturn(deletedMessage);
+        when(model.getServerId()).thenReturn(SERVER_ID);
+        testUnit.execute(model);
        verify(self, times(1)).executeListener(deletedMessage, member);
    }

--- a/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/MessageEditedListenerTest.java
+++ b/abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/MessageEditedListenerTest.java
@@ -2,6 +2,7 @@ package dev.sheldan.abstracto.moderation.listener;

 import dev.sheldan.abstracto.core.models.cache.CachedAuthor;
 import dev.sheldan.abstracto.core.models.cache.CachedMessage;
+import dev.sheldan.abstracto.core.models.listener.MessageTextUpdatedModel;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
@@ -11,6 +12,7 @@ import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
 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.junit.Assert;
 import org.junit.Test;
@@ -44,11 +46,13 @@ public class MessageEditedListenerTest {
    private MemberService memberService;

    @Mock
-    private CachedMessage messageAfter;
+    private Message messageAfter;

    @Mock
    private CachedMessage messageBefore;

+    private MessageTextUpdatedModel model;
+
    private static final Long SERVER_ID = 4L;
    private static final Long CHANNEL_ID = 5L;
    private static final Long AUTHOR_ID = 6L;
@@ -56,9 +60,11 @@ public class MessageEditedListenerTest {
    @Test
    public void testExecuteListenerWithSameContent() {
        String content = "text";
-        when(messageAfter.getContent()).thenReturn(content);
+        when(messageAfter.getContentRaw()).thenReturn(content);
        when(messageBefore.getContent()).thenReturn(content);
-        testUnit.execute(messageBefore, messageAfter);
+        when(model.getAfter()).thenReturn(messageAfter);
+        when(model.getBefore()).thenReturn(messageBefore);
+        testUnit.execute(model);
        verify(templateService, times(0)).renderEmbedTemplate(eq(MessageEditedListener.MESSAGE_EDITED_TEMPLATE), any());
    }

@@ -67,15 +73,12 @@ public class MessageEditedListenerTest {
        String content = "text";
        String contentAfterwards = "text2";
        TextChannel channel = Mockito.mock(TextChannel.class);
-        when(messageAfter.getContent()).thenReturn(contentAfterwards);
-        when(messageAfter.getChannelId()).thenReturn(CHANNEL_ID);
+        when(messageAfter.getContentRaw()).thenReturn(contentAfterwards);
        Guild guild = Mockito.mock(Guild.class);
        when(channel.getGuild()).thenReturn(guild);
-        when(messageAfter.getServerId()).thenReturn(SERVER_ID);
        Member author = Mockito.mock(Member.class);
        CachedAuthor cachedAuthor = Mockito.mock(CachedAuthor.class);
        when(cachedAuthor.getAuthorId()).thenReturn(AUTHOR_ID);
-        when(messageAfter.getAuthor()).thenReturn(cachedAuthor);
        when(messageBefore.getContent()).thenReturn(content);
        when(messageBefore.getServerId()).thenReturn(SERVER_ID);
        MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
@@ -83,7 +86,9 @@ public class MessageEditedListenerTest {
        when(templateService.renderEmbedTemplate(eq(MessageEditedListener.MESSAGE_EDITED_TEMPLATE), captor.capture(), eq(SERVER_ID))).thenReturn(messageToSend);
        when(memberService.getMemberInServerAsync(SERVER_ID, AUTHOR_ID)).thenReturn(CompletableFuture.completedFuture(author));
        when(channelService.getTextChannelFromServer(SERVER_ID, CHANNEL_ID)).thenReturn(channel);
-        testUnit.execute(messageBefore, messageAfter);
+        when(model.getAfter()).thenReturn(messageAfter);
+        when(model.getBefore()).thenReturn(messageBefore);
+        testUnit.execute(model);
        verify(postTargetService, times(1)).sendEmbedInPostTarget(messageToSend, LoggingPostTarget.EDIT_LOG, SERVER_ID);
        MessageEditedLog capturedValue = captor.getValue();
        Assert.assertEquals(messageBefore, capturedValue.getMessageBefore());