[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/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/MessageDeleteLogListener.java

@@ -1,26 +1,30 @@
 package dev.sheldan.abstracto.moderation.listener;
 
 import dev.sheldan.abstracto.core.config.FeatureEnum;
-import dev.sheldan.abstracto.core.config.ListenerPriority;
-import dev.sheldan.abstracto.core.listener.MessageDeletedListener;
-import dev.sheldan.abstracto.core.models.AServerAChannelAUser;
-import dev.sheldan.abstracto.core.models.GuildChannelMember;
+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.PostTargetService;
+import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.config.posttargets.LoggingPostTarget;
-import dev.sheldan.abstracto.templating.model.MessageToSend;
-import dev.sheldan.abstracto.core.service.PostTargetService;
-import dev.sheldan.abstracto.core.utils.ContextUtils;
 import dev.sheldan.abstracto.moderation.models.template.listener.MessageDeletedAttachmentLog;
 import dev.sheldan.abstracto.moderation.models.template.listener.MessageDeletedLog;
+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.Member;
+import net.dv8tion.jda.api.entities.TextChannel;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
 @Component
 @Slf4j
-public class MessageDeleteLogListener implements MessageDeletedListener {
+public class MessageDeleteLogListener implements AsyncMessageDeletedListener {
 
     public static final String MESSAGE_DELETED_TEMPLATE = "message_deleted";
     public static final String MESSAGE_DELETED_ATTACHMENT_TEMPLATE = "message_deleted_attachment";
@@ -34,36 +38,52 @@ public class MessageDeleteLogListener implements MessageDeletedListener {
     @Autowired
     private PostTargetService postTargetService;
 
+    @Autowired
+    private BotService botService;
+
+    @Autowired
+    private ChannelManagementService channelManagementService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
+    @Autowired
+    private MessageDeleteLogListener self;
+
     @Override
-    public void execute(CachedMessage messageFromCache, AServerAChannelAUser authorUser, GuildChannelMember authorMember) {
+    public void execute(CachedMessage messageFromCache) {
+        botService.getMemberInServerAsync(messageFromCache.getServerId(), messageFromCache.getAuthor().getAuthorId()).thenAccept(member ->
+            self.executeListener(messageFromCache, member)
+        );
+    }
+
+    @Transactional
+    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());
         MessageDeletedLog logModel = MessageDeletedLog
                 .builder()
                 .cachedMessage(messageFromCache)
-                .server(authorUser.getGuild())
-                .channel(authorUser.getChannel())
-                .user(authorUser.getUser())
-                .aUserInAServer(authorUser.getAUserInAServer())
                 .guild(authorMember.getGuild())
-                .messageChannel(authorMember.getTextChannel())
-                .member(authorMember.getMember())
+                .channel(textChannel)
+                .member(authorMember)
                 .build();
         MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_DELETED_TEMPLATE, logModel);
         postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.DELETE_LOG, messageFromCache.getServerId());
-        if(messageFromCache.getAttachmentUrls() != null){
-            log.trace("Notifying about deletions of {} attachments.", messageFromCache.getAttachmentUrls().size());
-            for (int i = 0; i < messageFromCache.getAttachmentUrls().size(); i++) {
+        if(messageFromCache.getAttachments() != null){
+            log.trace("Notifying about deletions of {} attachments.", messageFromCache.getAttachments().size());
+            for (int i = 0; i < messageFromCache.getAttachments().size(); i++) {
                 MessageDeletedAttachmentLog log = MessageDeletedAttachmentLog
                         .builder()
-                        .imageUrl(messageFromCache.getAttachmentUrls().get(i))
+                        .imageUrl(messageFromCache.getAttachments().get(i).getProxyUrl())
                         .counter(i + 1)
-                        .server(authorUser.getGuild())
-                        .channel(authorUser.getChannel())
-                        .user(authorUser.getUser())
-                        .aUserInAServer(authorUser.getAUserInAServer())
                         .guild(authorMember.getGuild())
-                        .messageChannel(authorMember.getTextChannel())
-                        .member(authorMember.getMember())
+                        .channel(textChannel)
+                        .member(authorMember)
                         .build();
                 MessageToSend attachmentEmbed = templateService.renderEmbedTemplate(MESSAGE_DELETED_ATTACHMENT_TEMPLATE, log);
                 postTargetService.sendEmbedInPostTarget(attachmentEmbed, LoggingPostTarget.DELETE_LOG, messageFromCache.getServerId());
@@ -76,8 +96,4 @@ public class MessageDeleteLogListener implements MessageDeletedListener {
         return ModerationFeatures.LOGGING;
     }
 
-    @Override
-    public Integer getPriority() {
-        return ListenerPriority.MEDIUM;
-    }
 }

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

@@ -1,24 +1,23 @@
 package dev.sheldan.abstracto.moderation.listener;
 
 import dev.sheldan.abstracto.core.config.FeatureEnum;
-import dev.sheldan.abstracto.core.config.ListenerPriority;
-import dev.sheldan.abstracto.core.listener.MessageTextUpdatedListener;
+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.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.config.posttargets.LoggingPostTarget;
-import dev.sheldan.abstracto.templating.model.MessageToSend;
-import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.moderation.models.template.listener.MessageEditedLog;
+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.Message;
+import net.dv8tion.jda.api.entities.TextChannel;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
 
 @Service
 @Slf4j
-public class MessageEditedListener implements MessageTextUpdatedListener {
+public class MessageEditedListener implements AsyncMessageTextUpdatedListener {
 
     public static final String MESSAGE_EDITED_TEMPLATE = "message_edited";
 
@@ -28,24 +27,33 @@ public class MessageEditedListener implements MessageTextUpdatedListener {
     @Autowired
     private PostTargetService postTargetService;
 
+    @Autowired
+    private BotService botService;
+
     @Override
-    @Transactional
-    public void execute(CachedMessage messageBefore, Message messageAfter) {
-        if(messageBefore.getContent().equals(messageAfter.getContentRaw())){
+    public void execute(CachedMessage messageBefore, CachedMessage messageAfter) {
+        if(messageBefore.getContent().equals(messageAfter.getContent())) {
             log.trace("Message content was the same. Possible reason was: message was not in cache.");
             return;
         }
-        log.trace("Message {} in channel {} in guild {} was edited.", messageBefore.getMessageId(), messageBefore.getChannelId(), messageBefore.getServerId());
-        MessageEditedLog log = MessageEditedLog
-                .builder()
-                .messageAfter(messageAfter)
-                .messageBefore(messageBefore)
-                .messageChannel(messageAfter.getTextChannel())
-                .guild(messageAfter.getGuild())
-                .member(messageAfter.getMember())
-                .build();
-        MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_EDITED_TEMPLATE, log);
-        postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.EDIT_LOG, messageBefore.getServerId());
+        botService.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());
+            MessageEditedLog log = MessageEditedLog
+                    .builder()
+                    .messageAfter(messageAfter)
+                    .messageBefore(messageBefore)
+                    .messageChannel(textChannel)
+                    .guild(textChannel.getGuild())
+                    .member(author)
+                    .build();
+            MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_EDITED_TEMPLATE, log);
+            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;
+        });
     }
 
     @Override
@@ -53,8 +61,4 @@ public class MessageEditedListener implements MessageTextUpdatedListener {
         return ModerationFeatures.LOGGING;
     }
 
-    @Override
-    public Integer getPriority() {
-        return ListenerPriority.MEDIUM;
-    }
 }

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

@@ -1,13 +1,12 @@
 package dev.sheldan.abstracto.moderation.listener;
 
-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;
 import dev.sheldan.abstracto.moderation.config.features.WarningDecayFeature;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 
 @Component

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

@@ -1,25 +1,25 @@
-package dev.sheldan.abstracto.moderation.listener;
+package dev.sheldan.abstracto.moderation.listener.async;
 
 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.models.database.AUserInAServer;
+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.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.config.posttargets.LoggingPostTarget;
 import dev.sheldan.abstracto.templating.service.TemplateService;
 import lombok.extern.slf4j.Slf4j;
-import net.dv8tion.jda.api.entities.Guild;
 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;
 
 @Service
 @Slf4j
-public class JoinLogger implements JoinListener {
+public class JoinLogger implements AsyncJoinListener {
 
     public static final String USER_JOIN_TEMPLATE = "user_join";
 
@@ -29,6 +29,11 @@ public class JoinLogger implements JoinListener {
     @Autowired
     private PostTargetService postTargetService;
 
+    @Autowired
+    private BotService botService;
+
+    @Autowired
+    private JoinLogger self;
 
     private HashMap<String, Object> getUserParameter(User user) {
         HashMap<String, Object> parameters = new HashMap<>();
@@ -37,11 +42,18 @@ public class JoinLogger implements JoinListener {
     }
 
     @Override
-    public void execute(Member member, Guild guild, AUserInAServer aUserInAServer) {
-        log.info("User {} joined server {}.", aUserInAServer.getUserReference().getId(), aUserInAServer.getServerReference().getId());
+    public void execute(ServerUser serverUser) {
+        log.info("User {} joined server {}.", serverUser.getUserId(), serverUser.getServerId());
+        botService.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());
         String text = templateService.renderTemplateWithMap(USER_JOIN_TEMPLATE, parameters);
-        postTargetService.sendTextInPostTarget(text, LoggingPostTarget.JOIN_LOG, guild.getIdLong());
+        postTargetService.sendTextInPostTarget(text, LoggingPostTarget.JOIN_LOG, serverUser.getServerId());
     }
 
     @Override
@@ -49,8 +61,4 @@ public class JoinLogger implements JoinListener {
         return ModerationFeatures.LOGGING;
     }
 
-    @Override
-    public Integer getPriority() {
-        return ListenerPriority.MEDIUM;
-    }
 }

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

@@ -1,21 +1,20 @@
-package dev.sheldan.abstracto.moderation.listener;
+package dev.sheldan.abstracto.moderation.listener.async;
 
 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.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.service.MuteService;
 import dev.sheldan.abstracto.moderation.service.management.MuteManagementService;
 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;
 
 @Component
 @Slf4j
-public class JoinMuteListener implements JoinListener {
+public class JoinMuteListener implements AsyncJoinListener {
 
     @Autowired
     private MuteManagementService muteManagementService;
@@ -23,10 +22,14 @@ public class JoinMuteListener implements JoinListener {
     @Autowired
     private MuteService muteService;
 
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
     @Override
-    public void execute(Member member, Guild guild, AUserInAServer aUserInAServer) {
+    public void execute(ServerUser serverUser) {
+        AUserInAServer aUserInAServer = userInServerManagementService.loadUser(serverUser.getServerId(), serverUser.getUserId());
         if(muteManagementService.hasActiveMute(aUserInAServer)) {
-            log.info("Re-muting user {} which joined the server {}, because the mute has not ended yet.", member.getIdLong(), guild.getIdLong());
+            log.info("Re-muting user {} which joined the server {}, because the mute has not ended yet.", serverUser.getUserId(), serverUser.getServerId());
             muteService.applyMuteRole(aUserInAServer);
         }
     }
@@ -36,8 +39,4 @@ public class JoinMuteListener implements JoinListener {
         return ModerationFeatures.MUTING;
     }
 
-    @Override
-    public Integer getPriority() {
-        return ListenerPriority.HIGH;
-    }
 }

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

@@ -1,26 +1,27 @@
-package dev.sheldan.abstracto.moderation.listener;
+package dev.sheldan.abstracto.moderation.listener.async;
 
 import dev.sheldan.abstracto.core.config.FeatureEnum;
-import dev.sheldan.abstracto.core.config.ListenerPriority;
-import dev.sheldan.abstracto.core.listener.LeaveListener;
+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.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.config.posttargets.LoggingPostTarget;
 import dev.sheldan.abstracto.templating.service.TemplateService;
 import lombok.extern.slf4j.Slf4j;
-import net.dv8tion.jda.api.entities.Guild;
 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;
 
 @Service
 @Slf4j
-public class LeaveLogger implements LeaveListener {
+public class LeaveLogger implements AsyncLeaveListener {
 
     public static final String USER_LEAVE_TEMPLATE = "user_leave";
 
@@ -30,6 +31,11 @@ public class LeaveLogger implements LeaveListener {
     @Autowired
     private PostTargetService postTargetService;
 
+    @Autowired
+    private BotService botService;
+
+    @Autowired
+    private LeaveLogger self;
 
     @NotNull
     private HashMap<String, Object> getUserParameter(@Nonnull User user) {
@@ -40,10 +46,17 @@ public class LeaveLogger implements LeaveListener {
     }
 
     @Override
-    public void execute(Member member, Guild guild) {
-        log.info("User {} left server {}.", member.getUser().getId(), guild.getIdLong());
+    public void execute(ServerUser serverUser) {
+        log.info("User {} left server {}.", serverUser.getUserId(), serverUser.getServerId());
+        botService.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()));
-        postTargetService.sendTextInPostTarget(text, LoggingPostTarget.LEAVE_LOG, guild.getIdLong());
+        postTargetService.sendTextInPostTarget(text, LoggingPostTarget.LEAVE_LOG, serverUser.getServerId());
     }
 
     @Override
@@ -51,8 +64,4 @@ public class LeaveLogger implements LeaveListener {
         return ModerationFeatures.LOGGING;
     }
 
-    @Override
-    public Integer getPriority() {
-        return ListenerPriority.MEDIUM;
-    }
 }

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

@@ -268,15 +268,11 @@ public class MuteServiceBean implements MuteService {
             throw new NoMuteFoundException();
         }
         Mute mute = muteManagementService.getAMuteOf(aUserInAServer);
-        if(Boolean.TRUE.equals(mute.getMuteEnded())) {
-            log.info("Mute {} has ended already, user {} does not need to be unMuted anymore.", mute.getMuteId().getId(), mute.getMutedUser().getUserReference().getId());
-            return CompletableFuture.completedFuture(null);
-        }
         Long muteId = mute.getMuteId().getId();
         CompletableFuture<Member> mutingMemberFuture = botService.getMemberInServerAsync(mute.getMutingUser());
         CompletableFuture<Member> mutedMemberFuture = botService.getMemberInServerAsync(mute.getMutedUser());
-        Guild guild = botService.getGuildById(mute.getServer().getId());
-        return endMute(mute).thenCompose(unused ->
+        Guild guild = botService.getGuildById(mute.getMuteId().getServerId());
+        return endMute(mute, false).thenCompose(unused ->
             CompletableFuture.allOf(mutingMemberFuture, mutedMemberFuture)
         ).thenCompose(unused -> self.sendUnMuteLogForManualUnMute(muteId, mutingMemberFuture, mutedMemberFuture, guild));
     }
@@ -296,7 +292,11 @@ public class MuteServiceBean implements MuteService {
     }
 
     @Override
-    public CompletableFuture<Void> endMute(Mute mute) {
+    public CompletableFuture<Void> endMute(Mute mute, Boolean sendNotification) {
+        if(mute.getMuteEnded()) {
+            log.info("Mute {} in server {} has already ended. Not unmuting.", mute.getMuteId().getId(), mute.getMuteId().getServerId());
+            return CompletableFuture.completedFuture(null);
+        }
         Long muteId = mute.getMuteId().getId();
         AServer mutingServer = mute.getServer();
         log.info("UnMuting {} in server {}", mute.getMutedUser().getUserReference().getId(), mutingServer.getId());
@@ -315,9 +315,13 @@ public class MuteServiceBean implements MuteService {
         CompletableFuture<Member> mutedMemberFuture = botService.getMemberInServerAsync(mute.getMutedUser());
         CompletableFuture<Void> finalFuture = new CompletableFuture<>();
         CompletableFuture.allOf(mutingMemberFuture, mutedMemberFuture, roleRemovalFuture, mutingMemberFuture, mutedMemberFuture).handle((aVoid, throwable) -> {
-            self.sendUnmuteLog(muteId, guild, mutingMemberFuture, mutedMemberFuture).thenAccept(aVoid1 ->
-                finalFuture.complete(null)
-            );
+            if(sendNotification) {
+                self.sendUnmuteLog(muteId, guild, mutingMemberFuture, mutedMemberFuture).thenAccept(aVoid1 ->
+                        finalFuture.complete(null)
+                );
+            } else {
+                finalFuture.complete(null);
+            }
             return null;
         });
 
@@ -357,7 +361,7 @@ public class MuteServiceBean implements MuteService {
         log.info("UnMuting the mute {} in server {}", muteId, serverId);
         Optional<Mute> muteOptional = muteManagementService.findMuteOptional(muteId, serverId);
         if(muteOptional.isPresent()) {
-            return endMute(muteOptional.get());
+            return endMute(muteOptional.get(), true);
         } else {
             throw new NoMuteFoundException();
         }