[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

abstracto-application/abstracto-modules/link-embed/link-embed-impl/src/main/java/dev/sheldan/abstracto/linkembed/listener/MessageEmbedListener.java

@@ -2,13 +2,13 @@ package dev.sheldan.abstracto.linkembed.listener;
 
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.config.ListenerPriority;
-import dev.sheldan.abstracto.core.execution.result.ExecutionResult;
-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.cache.CachedMessage;
+import dev.sheldan.abstracto.core.models.listener.MessageReceivedModel;
 import dev.sheldan.abstracto.core.service.MessageCache;
 import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
@@ -59,7 +59,8 @@ public class MessageEmbedListener implements MessageReceivedListener {
             .build();
 
     @Override
-    public MessageReceivedListenerResult execute(Message message) {
+    public ConsumableListenerResult execute(MessageReceivedModel model) {
+        Message message = model.getMessage();
         String messageRaw = message.getContentRaw();
         List<MessageEmbedLink> links = messageEmbedService.getLinksInMessage(messageRaw);
         if(!links.isEmpty()) {
@@ -82,12 +83,12 @@ public class MessageEmbedListener implements MessageReceivedListener {
         }
         if(StringUtils.isBlank(messageRaw) && !links.isEmpty()) {
             messageService.deleteMessage(message);
-            return MessageReceivedListenerResult.DELETED;
+            return ConsumableListenerResult.DELETED;
         }
         if(!links.isEmpty()) {
-            return MessageReceivedListenerResult.PROCESSED;
+            return ConsumableListenerResult.PROCESSED;
         }
-        return MessageReceivedListenerResult.IGNORED;
+        return ConsumableListenerResult.IGNORED;
     }
 
     @Transactional
@@ -104,8 +105,8 @@ public class MessageEmbedListener implements MessageReceivedListener {
     }
 
     @Override
-    public boolean shouldConsume(Event event, ExecutionResult result) {
-        return result.equals(MessageReceivedListenerResult.DELETED);
+    public boolean shouldConsume(Event event, ConsumableListenerResult result) {
+        return result.equals(ConsumableListenerResult.DELETED);
     }
 
     @Override

abstracto-application/abstracto-modules/link-embed/link-embed-impl/src/main/java/dev/sheldan/abstracto/linkembed/listener/MessageEmbedRemovalReactionListener.java

@@ -1,14 +1,13 @@
 package dev.sheldan.abstracto.linkembed.listener;
 
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncReactionAddedListener;
 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.cache.CachedMessage;
-import dev.sheldan.abstracto.core.models.cache.CachedReactions;
 import dev.sheldan.abstracto.core.models.database.AEmote;
+import dev.sheldan.abstracto.core.models.listener.ReactionAddedModel;
 import dev.sheldan.abstracto.core.service.BotService;
 import dev.sheldan.abstracto.core.service.EmoteService;
 import dev.sheldan.abstracto.core.service.MessageService;
@@ -59,21 +58,22 @@ public class MessageEmbedRemovalReactionListener implements AsyncReactionAddedLi
             .tagList(Arrays.asList(MetricTag.getTag(MESSAGE_EMBED_ACTION, "removed.source")))
             .build();
 
-
     @Override
-    public void executeReactionAdded(CachedMessage message, CachedReactions cachedReaction, ServerUser serverUser) {
-        Long guildId = message.getServerId();
-        AEmote aEmote = emoteService.getEmoteOrDefaultEmote(REMOVAL_EMOTE, guildId);
-        if(emoteService.compareCachedEmoteWithAEmote(cachedReaction.getEmote(), aEmote)) {
-            Optional<EmbeddedMessage> embeddedMessageOptional = messageEmbedPostManagementService.findEmbeddedPostByMessageId(message.getMessageId());
+    public DefaultListenerResult execute(ReactionAddedModel model) {
+        Long serverId = model.getServerId();
+        AEmote aEmote = emoteService.getEmoteOrDefaultEmote(REMOVAL_EMOTE, serverId);
+        if(emoteService.isReactionEmoteAEmote(model.getReaction().getReactionEmote(), aEmote)) {
+            Long messageId = model.getMessage().getMessageId();
+            Optional<EmbeddedMessage> embeddedMessageOptional = messageEmbedPostManagementService.findEmbeddedPostByMessageId(messageId);
             if(embeddedMessageOptional.isPresent()) {
+                Long channelId = model.getMessage().getChannelId();
                 EmbeddedMessage embeddedMessage = embeddedMessageOptional.get();
-                boolean embeddedUserRemoves = embeddedMessage.getEmbeddedUser().getUserReference().getId().equals(serverUser.getUserId());
-                boolean embeddingUserRemoves = embeddedMessage.getEmbeddingUser().getUserReference().getId().equals(serverUser.getUserId());
+                boolean embeddedUserRemoves = embeddedMessage.getEmbeddedUser().getUserReference().getId().equals(model.getUserReacting().getUserId());
+                boolean embeddingUserRemoves = embeddedMessage.getEmbeddingUser().getUserReference().getId().equals(model.getUserReacting().getUserId());
                 if(embeddedUserRemoves || embeddingUserRemoves) {
-                    log.info("Removing embed in message {} in channel {} in server {} because of a user reaction.", message.getMessageId(), message.getChannelId(), message.getServerId());
-                    messageService.deleteMessageInChannelInServer(message.getServerId(), message.getChannelId(), message.getMessageId()).thenAccept(aVoid -> {
-                        Optional<EmbeddedMessage> innerOptional = messageEmbedPostManagementService.findEmbeddedPostByMessageId(message.getMessageId());
+                    log.info("Removing embed in message {} in channel {} in server {} because of a user reaction.", messageId, channelId, serverId);
+                    messageService.deleteMessageInChannelInServer(serverId, channelId, messageId).thenAccept(aVoid -> {
+                        Optional<EmbeddedMessage> innerOptional = messageEmbedPostManagementService.findEmbeddedPostByMessageId(messageId);
                         innerOptional.ifPresent(value -> messageEmbedPostManagementService.deleteEmbeddedMessage(value));
                         if(embeddedUserRemoves) {
                             metricService.incrementCounter(MESSAGE_EMBED_REMOVED_SOURCE);
@@ -83,13 +83,19 @@ public class MessageEmbedRemovalReactionListener implements AsyncReactionAddedLi
                     });
                 } else {
                     log.trace("Somebody besides the original author and the user embedding added the removal reaction to the message {} in channel {} in server {}.",
-                            message.getMessageId(), message.getChannelId(), message.getServerId());
+                            messageId, channelId, serverId);
+                    return DefaultListenerResult.IGNORED;
                 }
 
             } else {
                 log.trace("Removal emote was placed on a message which was not recognized as an embedded message.");
+                return DefaultListenerResult.IGNORED;
             }
+            return DefaultListenerResult.PROCESSED;
+        } else {
+            return DefaultListenerResult.IGNORED;
         }
+
     }
 
     @Override

abstracto-application/abstracto-modules/link-embed/link-embed-impl/src/test/java/dev/sheldan/abstracto/linkembed/listener/MessageEmbedListenerTest.java

@@ -3,6 +3,7 @@ package dev.sheldan.abstracto.linkembed.listener;
 import dev.sheldan.abstracto.core.metric.service.MetricService;
 import dev.sheldan.abstracto.core.models.cache.CachedMessage;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.listener.MessageReceivedModel;
 import dev.sheldan.abstracto.core.service.MessageCache;
 import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
@@ -57,6 +58,9 @@ public class MessageEmbedListenerTest {
     @Mock
     private TextChannel textChannel;
 
+    @Mock
+    private MessageReceivedModel model;
+
     @Mock
     private Guild guild;
 
@@ -80,7 +84,8 @@ public class MessageEmbedListenerTest {
         when(message.getContentRaw()).thenReturn(text);
         List<MessageEmbedLink> foundMessageLinks = new ArrayList<>();
         when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
-        testUnit.execute(message);
+        when(model.getMessage()).thenReturn(message);
+        testUnit.execute(model);
         verify(messageService, times(0)).deleteMessage(message);
     }
 
@@ -116,7 +121,8 @@ public class MessageEmbedListenerTest {
         when(message.getMember()).thenReturn(author);
         when(userInServerManagementService.loadOrCreateUser(author)).thenReturn(userInAServer);
         when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
-        testUnit.execute(message);
+        when(model.getMessage()).thenReturn(message);
+        testUnit.execute(model);
         verify(messageService, times(0)).deleteMessage(message);
         verify(self, times(0)).embedSingleLink(eq(message), anyLong(), any(CachedMessage.class));
         verify(messageCache, times(0)).getMessageFromCache(anyLong(), anyLong(), anyLong());
@@ -148,7 +154,8 @@ public class MessageEmbedListenerTest {
         CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
         when(messageCache.getMessageFromCache(FIRST_SERVER_ID, FIRST_CHANNEL_ID, FIRST_MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
         when(messageEmbedService.getLinksInMessage(completeMessage)).thenReturn(foundMessageLinks);
-        testUnit.execute(message);
+        when(model.getMessage()).thenReturn(message);
+        testUnit.execute(model);
         verify(messageService, times(0)).deleteMessage(message);
         verify(self, times(1)).embedSingleLink(message, USER_IN_SERVER_ID, cachedMessage);
     }
@@ -179,7 +186,8 @@ public class MessageEmbedListenerTest {
         when(messageCache.getMessageFromCache(FIRST_SERVER_ID, FIRST_CHANNEL_ID, FIRST_MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
         when(messageCache.getMessageFromCache(FIRST_SERVER_ID, FIRST_CHANNEL_ID, SECOND_MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(secondCachedMessage));
         when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
-        testUnit.execute(message);
+        when(model.getMessage()).thenReturn(message);
+        testUnit.execute(model);
         verify(messageService, times(1)).deleteMessage(message);
         verify(self, times(1)).embedSingleLink(message, USER_IN_SERVER_ID, cachedMessage);
         verify(self, times(1)).embedSingleLink(message, USER_IN_SERVER_ID, secondCachedMessage);
@@ -210,7 +218,8 @@ public class MessageEmbedListenerTest {
         CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
         when(messageCache.getMessageFromCache(FIRST_SERVER_ID, FIRST_CHANNEL_ID, FIRST_MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(cachedMessage));
         when(messageEmbedService.getLinksInMessage(text)).thenReturn(foundMessageLinks);
-        testUnit.execute(message);
+        when(model.getMessage()).thenReturn(message);
+        testUnit.execute(model);
     }
 
 }

abstracto-application/abstracto-modules/link-embed/link-embed-impl/src/test/java/dev/sheldan/abstracto/linkembed/listener/MessageEmbedRemovalReactionListenerTest.java

@@ -2,16 +2,16 @@ package dev.sheldan.abstracto.linkembed.listener;
 
 import dev.sheldan.abstracto.core.metric.service.MetricService;
 import dev.sheldan.abstracto.core.models.ServerUser;
-import dev.sheldan.abstracto.core.models.cache.CachedEmote;
 import dev.sheldan.abstracto.core.models.cache.CachedMessage;
-import dev.sheldan.abstracto.core.models.cache.CachedReactions;
 import dev.sheldan.abstracto.core.models.database.AEmote;
 import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.listener.ReactionAddedModel;
 import dev.sheldan.abstracto.core.service.EmoteService;
 import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.linkembed.model.database.EmbeddedMessage;
 import dev.sheldan.abstracto.linkembed.service.management.MessageEmbedPostManagementService;
+import net.dv8tion.jda.api.entities.MessageReaction;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
@@ -43,10 +43,10 @@ public class MessageEmbedRemovalReactionListenerTest {
     private MetricService metricService;
 
     @Mock
-    private CachedReactions messageReaction;
+    private MessageReaction messageReaction;
 
     @Mock
-    private CachedEmote reactionEmote;
+    private MessageReaction.ReactionEmote reactionEmote;
 
     @Mock
     private AUserInAServer embeddingUser;
@@ -63,6 +63,9 @@ public class MessageEmbedRemovalReactionListenerTest {
     @Mock
     private ServerUser reactingUser;
 
+    @Mock
+    private ReactionAddedModel model;
+
     private static final Long SERVER_ID = 4L;
     private static final Long CHANNEL_ID = 5L;
     private static final Long MESSAGE_ID = 6L;
@@ -87,7 +90,7 @@ public class MessageEmbedRemovalReactionListenerTest {
         when(embeddingAUser.getId()).thenReturn(USER_ID);
         when(embeddedAUser.getId()).thenReturn(USER_ID + 1);
         when(reactingUser.getUserId()).thenReturn(USER_ID + 2);
-        executeDeletionTest(embeddingUser, embeddedUser, reactingUser, 0);
+        executeDeletionTest(embeddingUser, embeddedUser, 0);
     }
 
     @Test
@@ -97,7 +100,7 @@ public class MessageEmbedRemovalReactionListenerTest {
         when(embeddingUser.getUserReference()).thenReturn(embeddingAUser);
         when(embeddingAUser.getId()).thenReturn(USER_ID + 3);
         when(reactingUser.getUserId()).thenReturn(USER_ID + 1);
-        executeDeletionTest(embeddingUser, embeddedUser, reactingUser, 1);
+        executeDeletionTest(embeddingUser, embeddedUser, 1);
     }
 
     @Test
@@ -107,25 +110,28 @@ public class MessageEmbedRemovalReactionListenerTest {
         when(embeddingAUser.getId()).thenReturn(USER_ID);
         when(embeddedAUser.getId()).thenReturn(USER_ID + 1);
         when(reactingUser.getUserId()).thenReturn(USER_ID);
-        executeDeletionTest(embeddingUser, embeddedUser, reactingUser, 1);
+        executeDeletionTest(embeddingUser, embeddedUser, 1);
     }
 
-    private void executeDeletionTest(AUserInAServer embeddingUser, AUserInAServer embeddedUser, ServerUser userAddingReaction, int wantedDeletions) {
+    private void executeDeletionTest(AUserInAServer embeddingUser, AUserInAServer embeddedUser, int wantedDeletions) {
         CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
-        when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
         when(cachedMessage.getChannelId()).thenReturn(CHANNEL_ID);
         when(cachedMessage.getMessageId()).thenReturn(MESSAGE_ID);
         AEmote reactedEmote = Mockito.mock(AEmote.class);
         when(emoteService.getEmoteOrDefaultEmote(MessageEmbedRemovalReactionListener.REMOVAL_EMOTE, SERVER_ID)).thenReturn(reactedEmote);
-        when(messageReaction.getEmote()).thenReturn(reactionEmote);
-        when(emoteService.compareCachedEmoteWithAEmote(reactionEmote, reactedEmote)).thenReturn(true);
+        when(messageReaction.getReactionEmote()).thenReturn(reactionEmote);
+        when(emoteService.isReactionEmoteAEmote(reactionEmote, reactedEmote)).thenReturn(true);
         EmbeddedMessage message = Mockito.mock(EmbeddedMessage.class);
         when(message.getEmbeddingUser()).thenReturn(embeddingUser);
         when(message.getEmbeddedUser()).thenReturn(embeddedUser);
         when(messageEmbedPostManagementService.findEmbeddedPostByMessageId(MESSAGE_ID)).thenReturn(Optional.of(message));
         when(messageService.deleteMessageInChannelInServer(SERVER_ID, CHANNEL_ID, MESSAGE_ID)).thenReturn(CompletableFuture.completedFuture(null));
         when(messageEmbedPostManagementService.findEmbeddedPostByMessageId(MESSAGE_ID)).thenReturn(Optional.of(message));
-        testUnit.executeReactionAdded(cachedMessage, messageReaction, userAddingReaction);
+        when(model.getMessage()).thenReturn(cachedMessage);
+        when(model.getReaction()).thenReturn(messageReaction);
+        when(model.getServerId()).thenReturn(SERVER_ID);
+        when(model.getUserReacting()).thenReturn(reactingUser);
+        testUnit.execute(model);
         verify(messageService, times(wantedDeletions)).deleteMessageInChannelInServer(SERVER_ID, CHANNEL_ID, MESSAGE_ID);
         if(wantedDeletions > 0) {
             verify(messageEmbedPostManagementService, times(1)).deleteEmbeddedMessage(message);
@@ -134,14 +140,15 @@ public class MessageEmbedRemovalReactionListenerTest {
 
     private void executeRemovalEmoteAddedTest(boolean wasCorrectEmote) {
         CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
-        when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
         when(cachedMessage.getMessageId()).thenReturn(MESSAGE_ID);
-        ServerUser serverUser = Mockito.mock(ServerUser.class);
         AEmote reactedEmote = Mockito.mock(AEmote.class);
         when(emoteService.getEmoteOrDefaultEmote(MessageEmbedRemovalReactionListener.REMOVAL_EMOTE, SERVER_ID)).thenReturn(reactedEmote);
-        when(messageReaction.getEmote()).thenReturn(reactionEmote);
-        when(emoteService.compareCachedEmoteWithAEmote(reactionEmote, reactedEmote)).thenReturn(wasCorrectEmote);
-        testUnit.executeReactionAdded(cachedMessage, messageReaction, serverUser);
+        when(messageReaction.getReactionEmote()).thenReturn(reactionEmote);
+        when(emoteService.isReactionEmoteAEmote(reactionEmote, reactedEmote)).thenReturn(wasCorrectEmote);
+        when(model.getMessage()).thenReturn(cachedMessage);
+        when(model.getReaction()).thenReturn(messageReaction);
+        when(model.getServerId()).thenReturn(SERVER_ID);
+        testUnit.execute(model);
         verify(messageService, times(0)).deleteMessageInChannelInServer(anyLong(), anyLong(), anyLong());
     }