[AB-154] split up private and guild message received handler, split handlers into async and sync handlers

adapting the tests and improving tests to reduce usage of MockUtils
adding some util methods to message bean
extending cache for cached messages
enabling to build cached messages from messages in DM channels (they are not part of the message cache)
splitting multiple listeners to different beans, for better overview (emote updated)
adding convenience service for reactions specifically
split cached reaction and cached reactions, singular only contains one user, while the later contains all users
fixing liquibase configuration for assigned role user
fixing assignable role not having a transaction
moved caching update a bit earlier in various methods
fixing bug that a manual unmute caused duplicate unmute notification
fixing short scheduled unmute not checking the new mute state
limiting parameters for roll

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/config/ExperienceConfigListener.java

@@ -1,6 +1,6 @@
 package dev.sheldan.abstracto.experience.config;
 
-import dev.sheldan.abstracto.core.listener.ServerConfigListener;
+import dev.sheldan.abstracto.core.listener.sync.entity.ServerConfigListener;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
 import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/ExperienceTrackerListener.java

@@ -1,24 +1,24 @@
 package dev.sheldan.abstracto.experience.listener;
 
 import dev.sheldan.abstracto.core.config.FeatureEnum;
-import dev.sheldan.abstracto.core.config.ListenerPriority;
-import dev.sheldan.abstracto.core.listener.MessageReceivedListener;
+import dev.sheldan.abstracto.core.listener.async.jda.AsyncMessageReceivedListener;
+import dev.sheldan.abstracto.core.listener.sync.jda.MessageReceivedListener;
+import dev.sheldan.abstracto.core.models.cache.CachedMessage;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
-import net.dv8tion.jda.api.entities.Message;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
-import org.springframework.transaction.annotation.Propagation;
-import org.springframework.transaction.annotation.Transactional;
 
 /**
  * This {@link MessageReceivedListener} is responsible to execute the {@link AUserExperienceService} in order to track
  * that a certain user has send a message, and experience should be awarded.
  */
 @Component
-public class ExperienceTrackerListener implements MessageReceivedListener {
+@Slf4j
+public class ExperienceTrackerListener implements AsyncMessageReceivedListener {
 
     @Autowired
     private AUserExperienceService userExperienceService;
@@ -27,9 +27,8 @@ public class ExperienceTrackerListener implements MessageReceivedListener {
     private UserInServerManagementService userInServerManagementService;
 
     @Override
-    @Transactional(propagation = Propagation.REQUIRES_NEW)
-    public void execute(Message message) {
-        AUserInAServer cause = userInServerManagementService.loadUser(message.getMember());
+    public void execute(CachedMessage message) {
+        AUserInAServer cause = userInServerManagementService.loadUser(message.getServerId(), message.getAuthor().getAuthorId());
         userExperienceService.addExperience(cause);
     }
 
@@ -38,8 +37,4 @@ public class ExperienceTrackerListener implements MessageReceivedListener {
         return ExperienceFeature.EXPERIENCE;
     }
 
-    @Override
-    public Integer getPriority() {
-        return ListenerPriority.MEDIUM;
-    }
 }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/JoiningUserRoleListener.java

@@ -1,15 +1,16 @@
 package dev.sheldan.abstracto.experience.listener;
 
 import dev.sheldan.abstracto.core.config.FeatureEnum;
-import dev.sheldan.abstracto.core.config.ListenerPriority;
-import dev.sheldan.abstracto.core.listener.JoinListener;
+import dev.sheldan.abstracto.core.listener.async.jda.AsyncJoinListener;
+import dev.sheldan.abstracto.core.listener.sync.jda.JoinListener;
+import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
 import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
 import lombok.extern.slf4j.Slf4j;
-import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -20,7 +21,7 @@ import org.springframework.stereotype.Component;
  */
 @Component
 @Slf4j
-public class JoiningUserRoleListener implements JoinListener {
+public class JoiningUserRoleListener implements AsyncJoinListener {
 
     @Autowired
     private UserExperienceManagementService userExperienceManagementService;
@@ -28,17 +29,21 @@ public class JoiningUserRoleListener implements JoinListener {
     @Autowired
     private AUserExperienceService userExperienceService;
 
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
     @Override
-    public void execute(Member member, Guild guild, AUserInAServer aUserInAServer) {
-        AUserExperience userExperience = userExperienceManagementService.findUserInServer(aUserInAServer);
-        Long userInServerId = aUserInAServer.getUserInServerId();
+    public void execute(ServerUser serverUser) {
+        AUserInAServer userInAServer = userInServerManagementService.loadUser(serverUser.getServerId(), serverUser.getUserId());
+        AUserExperience userExperience = userExperienceManagementService.findUserInServer(userInAServer);
+        Long userInServerId = userInAServer.getUserInServerId();
         if(userExperience != null) {
-            log.info("User {} joined {} with previous experience. Setting up experience role again (if necessary).", member.getUser().getIdLong(), guild.getIdLong());
+            log.info("User {} joined {} with previous experience. Setting up experience role again (if necessary).", serverUser.getUserId(), serverUser.getServerId());
             userExperienceService.syncForSingleUser(userExperience).thenAccept(result ->
-                log.info("Finished re-assigning experience for re-joning user {} in server {}.", userInServerId, guild.getIdLong())
+                log.info("Finished re-assigning experience for re-joining user {} in server {}.", userInServerId, serverUser.getServerId())
             );
         } else {
-            log.info("Joined user {} in server {} does not have any previous experience. Not setting up anything.", member.getId(), guild.getId());
+            log.info("Joined user {} in server {} does not have any previous experience. Not setting up anything.", serverUser.getUserId(), serverUser.getServerId());
         }
     }
 
@@ -47,8 +52,4 @@ public class JoiningUserRoleListener implements JoinListener {
         return ExperienceFeature.EXPERIENCE;
     }
 
-    @Override
-    public Integer getPriority() {
-        return ListenerPriority.MEDIUM;
-    }
 }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/condition/HasLevelCondition.java

@@ -34,7 +34,7 @@ public class HasLevelCondition implements SystemCondition {
         Long userId = (Long) parameters.get(USER_ID_VARIABLE);
         Integer level = (Integer) parameters.get(LEVEL_VARIABLE);
         log.info("Evaluating has level condition.");
-        Optional<AUserInAServer> userInServerOptional = userInServerManagementService.loadUserConditional(userId);
+        Optional<AUserInAServer> userInServerOptional = userInServerManagementService.loadUserOptional(userId);
         if(userInServerOptional.isPresent()) {
             AUserInAServer userInServer = userInServerOptional.get();
             log.info("Evaluating has level condition for user {} in server {} with level {}.",

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/listener/ExperienceTrackerListenerTest.java

@@ -1,13 +1,13 @@
 package dev.sheldan.abstracto.experience.listener;
 
+import dev.sheldan.abstracto.core.models.cache.CachedAuthor;
+import dev.sheldan.abstracto.core.models.cache.CachedMessage;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
-import net.dv8tion.jda.api.entities.Member;
-import net.dv8tion.jda.api.entities.Message;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
@@ -31,13 +31,13 @@ public class ExperienceTrackerListenerTest extends ExperienceRelatedTest {
 
     @Test
     public void testExperienceTracking() {
-        AServer server = AServer.builder().id(3L).build();
-        AUser user = AUser.builder().id(4L).build();
-        AUserInAServer userInAServer = AUserInAServer.builder().userReference(user).serverReference(server).build();
-        Member member = Mockito.mock(Member.class);
-        Message mockedMessage = Mockito.mock(Message.class);
-        when(mockedMessage.getMember()).thenReturn(member);
-        when(userInServerManagementService.loadUser(member)).thenReturn(userInAServer);
+        AServer server = Mockito.mock(AServer.class);
+        AUser user = Mockito.mock(AUser.class);
+        AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
+        CachedMessage mockedMessage = Mockito.mock(CachedMessage.class);
+        CachedAuthor cachedAuthor = Mockito.mock(CachedAuthor.class);
+        when(mockedMessage.getAuthor()).thenReturn(cachedAuthor);
+        when(userInServerManagementService.loadUser(server.getId(), user.getId())).thenReturn(userInAServer);
         testUnit.execute(mockedMessage);
         verify(userExperienceService, times(1)).addExperience(userInAServer);
     }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/listener/JoiningUserRoleListenerTest.java

@@ -1,14 +1,13 @@
 package dev.sheldan.abstracto.experience.listener;
 
-import dev.sheldan.abstracto.core.models.database.AUser;
+import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
 import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
-import net.dv8tion.jda.api.entities.Guild;
-import net.dv8tion.jda.api.entities.Member;
-import net.dv8tion.jda.api.entities.User;
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
@@ -32,31 +31,38 @@ public class JoiningUserRoleListenerTest extends ExperienceRelatedTest {
     @Mock
     private AUserExperienceService userExperienceService;
 
+    @Mock
+    private UserInServerManagementService userInServerManagementService;
+
+    @Mock
+    private ServerUser serverUser;
+
+    @Mock
+    private AUserInAServer aUserInAServer;
+
+    private static final Long SERVER_ID = 1L;
+    private static final Long USER_ID = 2L;
+
+    @Before
+    public void setup() {
+        when(serverUser.getServerId()).thenReturn(SERVER_ID);
+        when(serverUser.getUserId()).thenReturn(USER_ID);
+        when(userInServerManagementService.loadUser(SERVER_ID, USER_ID)).thenReturn(aUserInAServer);
+    }
+
     @Test
     public void testUserWithExperienceRejoining() {
-        AUser user = AUser.builder().id(1L).build();
-        AUserInAServer aUserInAServer = AUserInAServer.builder().userInServerId(2L).userReference(user).build();
-        Member member = Mockito.mock(Member.class);
-        User jdaUser = Mockito.mock(User.class);
-        when(member.getUser()).thenReturn(jdaUser);
-        when(jdaUser.getIdLong()).thenReturn(user.getId());
-        Guild guild = Mockito.mock(Guild.class);
-        AUserExperience experience = AUserExperience.builder().experience(3L).user(aUserInAServer).build();
+        AUserExperience experience = Mockito.mock(AUserExperience.class);
         when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
         when(userExperienceService.syncForSingleUser(experience)).thenReturn(CompletableFuture.completedFuture(null));
-        testUnit.execute(member, guild, aUserInAServer);
+        testUnit.execute(serverUser);
     }
 
     @Test
     public void testUserWithOutExperienceRejoining() {
-        AUser user = AUser.builder().id(1L).build();
-        AUserInAServer aUserInAServer = AUserInAServer.builder().userInServerId(2L).userReference(user).build();
-        Member member = Mockito.mock(Member.class);
-        Guild guild = Mockito.mock(Guild.class);
-        AUserExperience experience = AUserExperience.builder().experience(3L).user(aUserInAServer).build();
         when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(null);
-        testUnit.execute(member, guild, aUserInAServer);
-        verify(userExperienceService, times(0)).syncForSingleUser(experience);
+        testUnit.execute(serverUser);
+        verify(userExperienceService, times(0)).syncForSingleUser(any());
     }
 
 }