[AB-281] adding ban and unban command

removing banId command in favor of the normal ban command
removing various feature modes for moderation for clearer configuration

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

@@ -8,15 +8,13 @@ import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.command.execution.ContextConverter;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
-import dev.sheldan.abstracto.moderation.model.template.command.BanLog;
 import dev.sheldan.abstracto.moderation.service.BanService;
 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.Component;
 
@@ -41,22 +39,18 @@ public class Ban extends AbstractConditionableCommand {
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
-        Member member = (Member) parameters.get(0);
+        User user = (User) parameters.get(0);
         String defaultReason = templateService.renderSimpleTemplate(BAN_DEFAULT_REASON_TEMPLATE, commandContext.getGuild().getIdLong());
         String reason = parameters.size() == 2 ? (String) parameters.get(1) : defaultReason;
 
-        BanLog banLogModel = (BanLog) ContextConverter.fromCommandContext(commandContext, BanLog.class);
-        banLogModel.setBannedUser(member);
-        banLogModel.setBanningUser(commandContext.getAuthor());
-        banLogModel.setReason(reason);
-        return banService.banMember(member, reason, banLogModel)
+        return banService.banUser(user, reason, commandContext.getAuthor(), commandContext.getMessage())
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         List<Parameter> parameters = new ArrayList<>();
-        parameters.add(Parameter.builder().name("user").templated(true).type(Member.class).build());
+        parameters.add(Parameter.builder().name("user").templated(true).type(User.class).build());
         parameters.add(Parameter.builder().name("reason").templated(true).type(String.class).optional(true).remainder(true).build());
         HelpInfo helpInfo = HelpInfo.builder().templated(true).hasExample(true).build();
         List<EffectConfig> effectConfig = Arrays.asList(EffectConfig.builder().position(0).effectKey(BAN_EFFECT_KEY).build());

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/command/UnBan.java

@@ -1,18 +1,19 @@
 package dev.sheldan.abstracto.moderation.command;
 
 import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.condition.CommandCondition;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
 import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.command.execution.ContextConverter;
 import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.moderation.config.ModerationModuleDefinition;
 import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
-import dev.sheldan.abstracto.moderation.model.template.command.BanIdLog;
 import dev.sheldan.abstracto.moderation.service.BanService;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.User;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -21,36 +22,29 @@ import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
 @Component
-public class BanId extends AbstractConditionableCommand {
+@Slf4j
+public class UnBan extends AbstractConditionableCommand {
+    @Autowired
+    private BanService banService;
 
     @Autowired
     private TemplateService templateService;
 
-    @Autowired
-    private BanService banService;
-
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
-        Long userId = (Long) parameters.get(0);
-        String defaultReason = templateService.renderSimpleTemplate(Ban.BAN_DEFAULT_REASON_TEMPLATE, commandContext.getGuild().getIdLong());
-        String reason = parameters.size() == 2 ? (String) parameters.get(1) : defaultReason;
-        BanIdLog banLogModel = (BanIdLog) ContextConverter.fromCommandContext(commandContext, BanIdLog.class);
-        banLogModel.setBannedUserId(userId);
-        banLogModel.setBanningUser(commandContext.getAuthor());
-        banLogModel.setReason(reason);
-        return banService.banUserViaId(commandContext.getGuild().getIdLong(), userId, reason, banLogModel)
+        User user = (User) parameters.get(0);
+        return banService.unBanUser(user, commandContext.getAuthor())
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 
     @Override
     public CommandConfiguration getConfiguration() {
         List<Parameter> parameters = new ArrayList<>();
-        parameters.add(Parameter.builder().name("user").type(Long.class).templated(true).build());
-        parameters.add(Parameter.builder().name("reason").type(String.class).optional(true).remainder(true).templated(true).build());
+        parameters.add(Parameter.builder().name("user").templated(true).type(User.class).build());
         HelpInfo helpInfo = HelpInfo.builder().templated(true).hasExample(true).build();
         return CommandConfiguration.builder()
-                .name("banId")
+                .name("unBan")
                 .module(ModerationModuleDefinition.MODERATION)
                 .templated(true)
                 .async(true)
@@ -65,4 +59,11 @@ public class BanId extends AbstractConditionableCommand {
     public FeatureDefinition getFeature() {
         return ModerationFeatureDefinition.MODERATION;
     }
+
+    @Override
+    public List<CommandCondition> getConditions() {
+        List<CommandCondition> conditions = super.getConditions();
+        conditions.add(immuneUserCondition);
+        return conditions;
+    }
 }

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

@@ -0,0 +1,88 @@
+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.AsyncUserBannedListener;
+import dev.sheldan.abstracto.core.models.listener.UserBannedModel;
+import dev.sheldan.abstracto.core.service.FeatureModeService;
+import dev.sheldan.abstracto.core.service.PostTargetService;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.config.posttarget.ModerationPostTarget;
+import dev.sheldan.abstracto.moderation.model.template.listener.UserBannedListenerModel;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.audit.ActionType;
+import net.dv8tion.jda.api.audit.AuditLogEntry;
+import net.dv8tion.jda.api.entities.User;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+@Slf4j
+public class UserBannedListener implements AsyncUserBannedListener {
+
+    @Autowired
+    private FeatureModeService featureModeService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Autowired
+    private PostTargetService postTargetService;
+
+    @Autowired
+    private UserBannedListener self;
+
+    private static final String USER_BANNED_NOTIFICATION_TEMPLATE = "userBanned_listener_notification";
+
+    @Override
+    public DefaultListenerResult execute(UserBannedModel model) {
+        model.getGuild()
+                .retrieveAuditLogs()
+                .type(ActionType.BAN)
+                .limit(5)
+                .queue(auditLogEntries -> {
+                    if(auditLogEntries.isEmpty()) {
+                        log.info("Did not find recent bans in guild {}.", model.getServerId());
+                        return;
+                    }
+                    Optional<AuditLogEntry> banEntryOptional = auditLogEntries
+                            .stream()
+                            .filter(auditLogEntry -> auditLogEntry.getTargetIdLong() == model.getBannedUser().getUserId())
+                            .findFirst();
+                    if(banEntryOptional.isPresent()) {
+                        AuditLogEntry auditLogEntry = banEntryOptional.get();
+                        if(!model.getGuild().getJDA().getSelfUser().equals(auditLogEntry.getUser())) {
+                            self.sendBannedNotification(model.getUser(), auditLogEntry.getUser(), auditLogEntry.getReason(), model.getServerId());
+                        }
+                    } else {
+                        log.info("Did not find the banned user in the most recent bans for guild {}. Not adding audit log information.", model.getServerId());
+                        self.sendBannedNotification(model.getUser(), null, null, model.getServerId());
+                    }
+                });
+        return DefaultListenerResult.PROCESSED;
+    }
+
+    @Transactional
+    public CompletableFuture<Void> sendBannedNotification(User bannedUser, User banningUser, String reason, Long serverId) {
+        UserBannedListenerModel model = UserBannedListenerModel
+                .builder()
+                .bannedUser(bannedUser)
+                .banningUser(banningUser)
+                .reason(reason)
+                .build();
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(USER_BANNED_NOTIFICATION_TEMPLATE, model, serverId);
+        return FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, ModerationPostTarget.BAN_LOG, serverId));
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ModerationFeatureDefinition.MODERATION;
+    }
+}

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

@@ -0,0 +1,86 @@
+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.AsyncUserUnBannedListener;
+import dev.sheldan.abstracto.core.models.listener.UserUnBannedModel;
+import dev.sheldan.abstracto.core.service.FeatureModeService;
+import dev.sheldan.abstracto.core.service.PostTargetService;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
+import dev.sheldan.abstracto.moderation.config.posttarget.ModerationPostTarget;
+import dev.sheldan.abstracto.moderation.model.template.listener.UserUnBannedListenerModel;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.audit.ActionType;
+import net.dv8tion.jda.api.audit.AuditLogEntry;
+import net.dv8tion.jda.api.entities.User;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+@Slf4j
+public class UserUnBannedListener implements AsyncUserUnBannedListener {
+    @Autowired
+    private FeatureModeService featureModeService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Autowired
+    private PostTargetService postTargetService;
+
+    @Autowired
+    private UserUnBannedListener self;
+
+    private static final String USER_UN_BANNED_NOTIFICATION_TEMPLATE = "userUnBanned_listener_notification";
+
+    @Override
+    public DefaultListenerResult execute(UserUnBannedModel model) {
+        model.getGuild()
+                .retrieveAuditLogs()
+                .type(ActionType.UNBAN)
+                .limit(5)
+                .queue(auditLogEntries -> {
+                    if(auditLogEntries.isEmpty()) {
+                        log.info("Did not find recent bans in guild {}.", model.getServerId());
+                        return;
+                    }
+                    Optional<AuditLogEntry> banEntryOptional = auditLogEntries
+                            .stream()
+                            .filter(auditLogEntry -> auditLogEntry.getTargetIdLong() == model.getUnbannedUser().getUserId())
+                            .findFirst();
+                    if(banEntryOptional.isPresent()) {
+                        AuditLogEntry auditLogEntry = banEntryOptional.get();
+                        if(!model.getGuild().getJDA().getSelfUser().equals(auditLogEntry.getUser())) {
+                            self.sendUnBannedNotification(model.getUser(), auditLogEntry.getUser(), model.getServerId());
+                        }
+                    } else {
+                        log.info("Did not find the un-banned user in the most recent un-bans for guild {}. Not adding audit log information.", model.getServerId());
+                        self.sendUnBannedNotification(model.getUser(), null, model.getServerId());
+                    }
+                });
+        return DefaultListenerResult.PROCESSED;
+    }
+
+    @Transactional
+    public CompletableFuture<Void> sendUnBannedNotification(User unbannedUser, User unbanningUser, Long serverId) {
+        UserUnBannedListenerModel model = UserUnBannedListenerModel
+                .builder()
+                .unBannedUser(unbannedUser)
+                .unBanningUser(unbanningUser)
+                .build();
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(USER_UN_BANNED_NOTIFICATION_TEMPLATE, model, serverId);
+        return FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(messageToSend, ModerationPostTarget.BAN_LOG, serverId));
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ModerationFeatureDefinition.MODERATION;
+    }
+}

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

@@ -1,26 +1,23 @@
 package dev.sheldan.abstracto.moderation.service;
 
-import dev.sheldan.abstracto.core.exception.GuildNotFoundException;
-import dev.sheldan.abstracto.core.models.context.ServerContext;
 import dev.sheldan.abstracto.core.service.FeatureModeService;
 import dev.sheldan.abstracto.core.service.GuildService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
-import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
-import dev.sheldan.abstracto.moderation.config.feature.mode.ModerationMode;
 import dev.sheldan.abstracto.moderation.config.posttarget.ModerationPostTarget;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.moderation.model.template.command.BanLog;
+import dev.sheldan.abstracto.moderation.model.template.command.UnBanLog;
 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.Message;
-import org.jetbrains.annotations.NotNull;
+import net.dv8tion.jda.api.entities.User;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
-import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
 @Component
@@ -28,7 +25,7 @@ import java.util.concurrent.CompletableFuture;
 public class BanServiceBean implements BanService {
 
     public static final String BAN_LOG_TEMPLATE = "ban_log";
-    public static final String BAN_ID_LOG_TEMPLATE = "banId_log";
+    public static final String UN_BAN_LOG_TEMPLATE = "unBan_log";
 
     @Autowired
     private GuildService guildService;
@@ -42,47 +39,75 @@ public class BanServiceBean implements BanService {
     @Autowired
     private FeatureModeService featureModeService;
 
+    @Autowired
+    private BanServiceBean self;
+
     @Override
-    public CompletableFuture<Void> banMember(Member member, String reason, ServerContext banLog) {
-        CompletableFuture<Void> banFuture = banUser(member.getGuild(), member.getIdLong(), reason);
+    public CompletableFuture<Void> banMember(Member member, String reason, Member banningMember, Message message) {
+        BanLog banLog = BanLog
+                .builder()
+                .bannedUser(member.getUser())
+                .banningMember(banningMember)
+                .commandMessage(message)
+                .reason(reason)
+                .build();
+        CompletableFuture<Void> banFuture = banUser(member.getGuild(), member.getUser(), reason);
         CompletableFuture<Void> messageFuture = sendBanLogMessage(banLog, member.getGuild().getIdLong(), BAN_LOG_TEMPLATE);
         return CompletableFuture.allOf(banFuture, messageFuture);
     }
 
-    @NotNull
-    public CompletableFuture<Void> sendBanLogMessage(ServerContext banLog, Long guildId, String template) {
-        CompletableFuture<Void> completableFuture;
-        if(featureModeService.featureModeActive(ModerationFeatureDefinition.MODERATION, guildId, ModerationMode.BAN_LOG)) {
-            MessageToSend banLogMessage = templateService.renderEmbedTemplate(template, banLog, guildId);
-            log.debug("Sending ban log message in guild {}.", guildId);
-            List<CompletableFuture<Message>> notificationFutures = postTargetService.sendEmbedInPostTarget(banLogMessage, ModerationPostTarget.BAN_LOG, guildId);
-            completableFuture = FutureUtils.toSingleFutureGeneric(notificationFutures);
-        } else {
-            log.debug("Feature {} has mode {} for logging disabled for server {}. Not sending notification.", ModerationFeatureDefinition.MODERATION, ModerationMode.BAN_LOG, guildId);
-            completableFuture = CompletableFuture.completedFuture(null);
-        }
-        return completableFuture;
-    }
-
     @Override
-    public CompletableFuture<Void> banUserViaId(Long guildId, Long userId, String reason, ServerContext banIdLog) {
-        CompletableFuture<Void> banFuture = banUser(guildId, userId, reason);
-        CompletableFuture<Void> messageFuture = sendBanLogMessage(banIdLog, guildId, BAN_ID_LOG_TEMPLATE);
+    public CompletableFuture<Void> banUser(User user, String reason, Member banningMember, Message message) {
+        BanLog banLog = BanLog
+                .builder()
+                .bannedUser(user)
+                .banningMember(banningMember)
+                .commandMessage(message)
+                .reason(reason)
+                .build();
+        Guild guild = banningMember.getGuild();
+        CompletableFuture<Void> banFuture = banUser(guild, user, reason);
+        CompletableFuture<Void> messageFuture = sendBanLogMessage(banLog, guild.getIdLong(), BAN_LOG_TEMPLATE);
         return CompletableFuture.allOf(banFuture, messageFuture);
     }
 
-    private CompletableFuture<Void> banUser(Long guildId, Long userId, String reason) {
-        Optional<Guild> guildByIdOptional = guildService.getGuildByIdOptional(guildId);
-        if(guildByIdOptional.isPresent()) {
-            return banUser(guildByIdOptional.get(), userId, reason);
-        } else {
-            log.warn("Guild {} not found. Not able to ban user {}", guildId, userId);
-            throw new GuildNotFoundException(guildId);
-        }
+    @Override
+    public CompletableFuture<Void> unBanUser(User user, Member unBanningMember) {
+        Guild guild = unBanningMember.getGuild();
+        UnBanLog banLog = UnBanLog
+                .builder()
+                .bannedUser(user)
+                .unBanningMember(unBanningMember)
+                .build();
+        return unBanUser(guild, user)
+                .thenCompose(unused -> self.sendUnBanLogMessage(banLog, guild.getIdLong(), UN_BAN_LOG_TEMPLATE));
     }
 
-    private CompletableFuture<Void> banUser(Guild guild, Long userId, String reason) {
-        log.info("Banning user {} in guild {}.", userId, guild.getId());
-        return guild.ban(userId.toString(), 0, reason).submit();
+    public CompletableFuture<Void> sendBanLogMessage(BanLog banLog, Long guildId, String template) {
+        CompletableFuture<Void> completableFuture;
+        MessageToSend banLogMessage = templateService.renderEmbedTemplate(template, banLog, guildId);
+        log.debug("Sending ban log message in guild {}.", guildId);
+        List<CompletableFuture<Message>> notificationFutures = postTargetService.sendEmbedInPostTarget(banLogMessage, ModerationPostTarget.BAN_LOG, guildId);
+        completableFuture = FutureUtils.toSingleFutureGeneric(notificationFutures);
+        return completableFuture;
+    }
+
+    public CompletableFuture<Void> sendUnBanLogMessage(UnBanLog banLog, Long guildId, String template) {
+        CompletableFuture<Void> completableFuture;
+        MessageToSend banLogMessage = templateService.renderEmbedTemplate(template, banLog, guildId);
+        log.debug("Sending unban log message in guild {}.", guildId);
+        List<CompletableFuture<Message>> notificationFutures = postTargetService.sendEmbedInPostTarget(banLogMessage, ModerationPostTarget.UN_BAN_LOG, guildId);
+        completableFuture = FutureUtils.toSingleFutureGeneric(notificationFutures);
+        return completableFuture;
+    }
+
+    private CompletableFuture<Void> banUser(Guild guild, User user, String reason) {
+        log.info("Banning user {} in guild {}.", user.getIdLong(), guild.getId());
+        return guild.ban(user, 0, reason).submit();
+    }
+
+    private CompletableFuture<Void> unBanUser(Guild guild, User user) {
+        log.info("Unbanning user {} in guild {}.", user.getIdLong(), guild.getId());
+        return guild.unban(user).submit();
     }
 }

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

@@ -3,8 +3,6 @@ package dev.sheldan.abstracto.moderation.service;
 import dev.sheldan.abstracto.core.service.FeatureModeService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
-import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
-import dev.sheldan.abstracto.moderation.config.feature.mode.ModerationMode;
 import dev.sheldan.abstracto.moderation.config.posttarget.ModerationPostTarget;
 import dev.sheldan.abstracto.moderation.model.template.command.KickLogModel;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
@@ -43,14 +41,9 @@ public class KickServiceBean implements KickService {
 
     private CompletableFuture<Void> sendKickLog(KickLogModel kickLogModel)  {
         CompletableFuture<Void> completableFuture;
-        if(featureModeService.featureModeActive(ModerationFeatureDefinition.MODERATION, kickLogModel.getGuild().getIdLong(), ModerationMode.KICK_LOG)) {
-            MessageToSend warnLogMessage = templateService.renderEmbedTemplate(KICK_LOG_TEMPLATE, kickLogModel, kickLogModel.getGuild().getIdLong());
-            log.debug("Sending kick log message in guild {}.", kickLogModel.getGuild().getIdLong());
-            completableFuture = FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(warnLogMessage, ModerationPostTarget.KICK_LOG, kickLogModel.getGuild().getIdLong()));
-        } else {
-            log.debug("Feature {} has mode {} for logging disabled for server {}. Not sending kick notification.", ModerationFeatureDefinition.MODERATION, ModerationMode.BAN_LOG, kickLogModel.getGuild().getIdLong());
-            completableFuture = CompletableFuture.completedFuture(null);
-        }
+        MessageToSend warnLogMessage = templateService.renderEmbedTemplate(KICK_LOG_TEMPLATE, kickLogModel, kickLogModel.getGuild().getIdLong());
+        log.debug("Sending kick log message in guild {}.", kickLogModel.getGuild().getIdLong());
+        completableFuture = FutureUtils.toSingleFutureGeneric(postTargetService.sendEmbedInPostTarget(warnLogMessage, ModerationPostTarget.KICK_LOG, kickLogModel.getGuild().getIdLong()));
         return completableFuture;
     }
 }

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

@@ -242,29 +242,19 @@ public class MuteServiceBean implements MuteService {
 
     private CompletableFuture<Void> sendMuteLog(MuteContext muteLogModel, AServer server)  {
         CompletableFuture<Void> completableFuture;
-        if(featureModeService.featureModeActive(ModerationFeatureDefinition.MUTING, server, MutingMode.MUTE_LOGGING)) {
-            log.debug("Sending mute log to the mute post target.");
-            MessageToSend message = templateService.renderEmbedTemplate(MUTE_LOG_TEMPLATE, muteLogModel, server.getId());
-            List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, muteLogModel.getContext().getServerId());
-            completableFuture = FutureUtils.toSingleFutureGeneric(completableFutures);
-        } else {
-            completableFuture = CompletableFuture.completedFuture(null);
-            log.debug("Not sending mute log, because feature mode {} in feature {} has been disabled for server {}.", MutingMode.MUTE_LOGGING, ModerationFeatureDefinition.WARNING, server.getId());
-        }
+        log.debug("Sending mute log to the mute post target.");
+        MessageToSend message = templateService.renderEmbedTemplate(MUTE_LOG_TEMPLATE, muteLogModel, server.getId());
+        List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, muteLogModel.getContext().getServerId());
+        completableFuture = FutureUtils.toSingleFutureGeneric(completableFutures);
         return completableFuture;
     }
 
     private CompletableFuture<Void> sendUnMuteLogMessage(UnMuteLog muteLogModel, AServer server)  {
         CompletableFuture<Void> completableFuture;
-        if(featureModeService.featureModeActive(ModerationFeatureDefinition.MUTING, server, MutingMode.MUTE_LOGGING)) {
-            log.debug("Sending unMute log for mute {} to the mute posttarget in server {}", muteLogModel.getMute().getMuteId().getId(), server.getId());
-            MessageToSend message = templateService.renderEmbedTemplate(UN_MUTE_LOG_TEMPLATE, muteLogModel, server.getId());
-            List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, server.getId());
-            completableFuture = FutureUtils.toSingleFutureGeneric(completableFutures);
-        } else {
-            completableFuture = CompletableFuture.completedFuture(null);
-            log.debug("Not sending unMute log, because feature mode {} in feature {} has been disabled for server {}.", MutingMode.UN_MUTE_LOGGING, ModerationFeatureDefinition.WARNING, server.getId());
-        }
+        log.debug("Sending unMute log for mute {} to the mute posttarget in server {}", muteLogModel.getMute().getMuteId().getId(), server.getId());
+        MessageToSend message = templateService.renderEmbedTemplate(UN_MUTE_LOG_TEMPLATE, muteLogModel, server.getId());
+        List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, server.getId());
+        completableFuture = FutureUtils.toSingleFutureGeneric(completableFutures);
         return completableFuture;
     }
 
@@ -289,11 +279,10 @@ public class MuteServiceBean implements MuteService {
         CompletableFuture<Void> completableFuture;
         if(featureModeService.featureModeActive(ModerationFeatureDefinition.MUTING, guild.getIdLong(), MutingMode.MANUAL_UN_MUTE_LOGGING)) {
             completableFuture = self.sendUnmuteLog(muteId, guild, mutingMemberFuture, mutedMemberFuture);
-            log.debug("Sending un mute notification for manual un mute for mute {} in server {}.", muteId, guild.getIdLong());
+            log.info("Sending un mute notification for manual un mute for mute {} in server {}.", muteId, guild.getIdLong());
         } else {
             completableFuture = CompletableFuture.completedFuture(null);
-            log.debug("Not sending unMute log, because feature mode {} in feature {} has been disabled for server {}.", MutingMode.MANUAL_UN_MUTE_LOGGING, ModerationFeatureDefinition.WARNING, guild.getIdLong());
-
+            log.info("Not sending unMute log, because feature mode {} in feature {} has been disabled for server {}.", MutingMode.MANUAL_UN_MUTE_LOGGING, ModerationFeatureDefinition.WARNING, guild.getIdLong());
         }
         return completableFuture;
     }

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

@@ -99,13 +99,9 @@ public class WarnServiceBean implements WarnService {
         String warnNotificationMessage = templateService.renderTemplate(WARN_NOTIFICATION_TEMPLATE, warnNotification, server.getId());
         List<CompletableFuture<Message>> futures = new ArrayList<>();
         futures.add(messageService.sendMessageToUser(warnedMember.getUser(), warnNotificationMessage));
-        if(featureModeService.featureModeActive(ModerationFeatureDefinition.WARNING, server.getId(), WarningMode.WARN_LOG)) {
-            log.debug("Logging warning for server {}.", server.getId());
-            MessageToSend message = templateService.renderEmbedTemplate(WARN_LOG_TEMPLATE, context, server.getId());
-            futures.addAll(postTargetService.sendEmbedInPostTarget(message, WarningPostTarget.WARN_LOG, context.getGuild().getIdLong()));
-        } else {
-            log.debug("Not logging warning because of feature {} with feature mode {} in server {}.", ModerationFeatureDefinition.WARNING, WarningMode.WARN_LOG, server.getId());
-        }
+        log.debug("Logging warning for server {}.", server.getId());
+        MessageToSend message = templateService.renderEmbedTemplate(WARN_LOG_TEMPLATE, context, server.getId());
+        futures.addAll(postTargetService.sendEmbedInPostTarget(message, WarningPostTarget.WARN_LOG, context.getGuild().getIdLong()));
 
         return FutureUtils.toSingleFutureGeneric(futures);
     }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/resources/migrations/1.0-moderation/moderation-seedData/command.xml

@@ -20,11 +20,6 @@
             <column name="module_id" valueComputed="${moderationModule}"/>
             <column name="feature_id" valueComputed="${moderationFeature}"/>
         </insert>
-        <insert tableName="command">
-            <column name="name" value="banId"/>
-            <column name="module_id" valueComputed="${moderationModule}"/>
-            <column name="feature_id" valueComputed="${moderationFeature}"/>
-        </insert>
         <insert tableName="command">
             <column name="name" value="kick"/>
             <column name="module_id" valueComputed="${moderationModule}"/>

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/resources/migrations/1.2.15/seedData/command.xml

@@ -0,0 +1,20 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <property name="moderationModule" value="(SELECT id FROM module WHERE name = 'moderation')"/>
+    <property name="moderationFeature" value="(SELECT id FROM feature WHERE key = 'moderation')"/>
+
+    <changeSet  author="Sheldan"  id="moderation_moderation-commands">
+        <insert tableName="command">
+            <column name="name" value="unBan"/>
+            <column name="module_id" valueComputed="${moderationModule}"/>
+            <column name="feature_id" valueComputed="${moderationFeature}"/>
+        </insert>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/resources/migrations/1.2.15/seedData/data.xml

@@ -8,4 +8,5 @@
     http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
     <include file="feature.xml" relativeToChangelogFile="true"/>
     <include file="default_emote.xml" relativeToChangelogFile="true"/>
+    <include file="command.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/resources/moderation-config.properties

@@ -26,20 +26,17 @@ abstracto.postTargets.warnLog.name=warnLog
 abstracto.postTargets.reactionReports.name=reactionReports
 abstracto.postTargets.kickLog.name=kickLog
 abstracto.postTargets.banLog.name=banLog
+abstracto.postTargets.unBanLog.name=unBanLog
 abstracto.postTargets.muteLog.name=muteLog
 abstracto.postTargets.decayLog.name=decayLog
 
-abstracto.featureModes.banLogging.featureName=moderation
-abstracto.featureModes.banLogging.mode=banLogging
-abstracto.featureModes.banLogging.enabled=true
+abstracto.featureModes.banCommandLogging.featureName=moderation
+abstracto.featureModes.banCommandLogging.mode=banCommandLogging
+abstracto.featureModes.banCommandLogging.enabled=true
 
-abstracto.featureModes.kickLogging.featureName=moderation
-abstracto.featureModes.kickLogging.mode=kickLogging
-abstracto.featureModes.kickLogging.enabled=true
-
-abstracto.featureModes.warnLogging.featureName=warnings
-abstracto.featureModes.warnLogging.mode=warnLogging
-abstracto.featureModes.warnLogging.enabled=true
+abstracto.featureModes.unBanCommandLogging.featureName=moderation
+abstracto.featureModes.unBanCommandLogging.mode=unBanCommandLogging
+abstracto.featureModes.unBanCommandLogging.enabled=true
 
 abstracto.featureModes.warnDecayLogging.featureName=warnings
 abstracto.featureModes.warnDecayLogging.mode=warnDecayLogging
@@ -49,14 +46,6 @@ abstracto.featureModes.automaticWarnDecayLogging.featureName=warnDecay
 abstracto.featureModes.automaticWarnDecayLogging.mode=automaticWarnDecayLogging
 abstracto.featureModes.automaticWarnDecayLogging.enabled=true
 
-abstracto.featureModes.muteLogging.featureName=muting
-abstracto.featureModes.muteLogging.mode=muteLogging
-abstracto.featureModes.muteLogging.enabled=true
-
-abstracto.featureModes.unMuteLogging.featureName=muting
-abstracto.featureModes.unMuteLogging.mode=unMuteLogging
-abstracto.featureModes.unMuteLogging.enabled=true
-
 abstracto.featureModes.manualUnMuteLogging.featureName=muting
 abstracto.featureModes.manualUnMuteLogging.mode=manualUnMuteLogging
 abstracto.featureModes.manualUnMuteLogging.enabled=true

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/command/BanIdTest.java

@@ -1,77 +0,0 @@
-package dev.sheldan.abstracto.moderation.command;
-
-import dev.sheldan.abstracto.core.command.execution.CommandContext;
-import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
-import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
-import dev.sheldan.abstracto.moderation.model.template.command.BanIdLog;
-import dev.sheldan.abstracto.moderation.service.BanService;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.concurrent.CompletableFuture;
-
-import static org.mockito.Mockito.eq;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class BanIdTest {
-
-    @InjectMocks
-    private BanId testUnit;
-
-    @Mock
-    private BanService banService;
-
-    @Mock
-    private TemplateService templateService;
-
-    @Captor
-    private ArgumentCaptor<BanIdLog> banLogModelCaptor;
-
-    private static final String REASON = "reason";
-    private static final Long BANNED_USER_ID = 4L;
-    private static final Long SERVER_ID = 3L;
-
-    @Test
-    public void testBanIdWithDefaultReason() {
-        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(BANNED_USER_ID));
-        when(parameters.getGuild().getIdLong()).thenReturn(SERVER_ID);
-        when(templateService.renderSimpleTemplate(Ban.BAN_DEFAULT_REASON_TEMPLATE, SERVER_ID)).thenReturn(REASON);
-        when(banService.banUserViaId(eq(SERVER_ID), eq(BANNED_USER_ID), eq(REASON), banLogModelCaptor.capture())).thenReturn(CompletableFuture.completedFuture(null));
-        CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
-        BanIdLog usedModel = banLogModelCaptor.getValue();
-        Assert.assertEquals(REASON, usedModel.getReason());
-        Assert.assertEquals(BANNED_USER_ID, usedModel.getBannedUserId());
-        Assert.assertEquals(parameters.getAuthor(), usedModel.getBanningUser());
-        CommandTestUtilities.checkSuccessfulCompletionAsync(result);
-    }
-
-    @Test
-    public void testBanWithReason() {
-        String customReason = "reason2";
-        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(BANNED_USER_ID, customReason));
-        when(parameters.getGuild().getIdLong()).thenReturn(SERVER_ID);
-        when(templateService.renderSimpleTemplate(Ban.BAN_DEFAULT_REASON_TEMPLATE, SERVER_ID)).thenReturn(REASON);
-        when(banService.banUserViaId(eq(SERVER_ID), eq(BANNED_USER_ID), eq(customReason), banLogModelCaptor.capture())).thenReturn(CompletableFuture.completedFuture(null));
-        CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
-        BanIdLog usedModel = banLogModelCaptor.getValue();
-        Assert.assertEquals(customReason, usedModel.getReason());
-        Assert.assertEquals(BANNED_USER_ID, usedModel.getBannedUserId());
-        Assert.assertEquals(parameters.getAuthor(), usedModel.getBanningUser());
-        CommandTestUtilities.checkSuccessfulCompletionAsync(result);
-    }
-
-    @Test
-    public void validateCommand() {
-        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
-    }
-}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/command/BanTest.java

@@ -4,22 +4,21 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
-import dev.sheldan.abstracto.moderation.model.template.command.BanLog;
 import dev.sheldan.abstracto.moderation.service.BanService;
 import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.User;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
+import org.mockito.*;
 import org.mockito.junit.MockitoJUnitRunner;
 
 import java.util.Arrays;
 import java.util.concurrent.CompletableFuture;
 
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.eq;
 import static org.mockito.Mockito.when;
 
@@ -36,25 +35,23 @@ public class BanTest {
     private TemplateService templateService;
 
     @Captor
-    private ArgumentCaptor<BanLog> banLogModelCaptor;
+    private ArgumentCaptor<Member> banLogModelCaptor;
 
     private static final String REASON = "reason";
     private static final Long SERVER_ID = 1L;
 
     @Mock
-    private Member bannedMember;
+    private User bannedMember;
 
     @Test
     public void testBanWithDefaultReason() {
         CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(bannedMember));
         when(parameters.getGuild().getIdLong()).thenReturn(SERVER_ID);
         when(templateService.renderSimpleTemplate(Ban.BAN_DEFAULT_REASON_TEMPLATE, SERVER_ID)).thenReturn(REASON);
-        when(banService.banMember(eq(bannedMember), eq(REASON), banLogModelCaptor.capture())).thenReturn(CompletableFuture.completedFuture(null));
+        when(banService.banUser(eq(bannedMember), eq(REASON), banLogModelCaptor.capture(), any(Message.class))).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
-        BanLog usedModel = banLogModelCaptor.getValue();
-        Assert.assertEquals(REASON, usedModel.getReason());
-        Assert.assertEquals(bannedMember, usedModel.getBannedUser());
-        Assert.assertEquals(parameters.getAuthor(), usedModel.getBanningUser());
+        Member banningMember = banLogModelCaptor.getValue();
+        Assert.assertEquals(parameters.getAuthor(), banningMember);
         CommandTestUtilities.checkSuccessfulCompletionAsync(result);
     }
 
@@ -64,12 +61,10 @@ public class BanTest {
         CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(bannedMember, customReason));
         when(parameters.getGuild().getIdLong()).thenReturn(SERVER_ID);
         when(templateService.renderSimpleTemplate(Ban.BAN_DEFAULT_REASON_TEMPLATE, SERVER_ID)).thenReturn(REASON);
-        when(banService.banMember(eq(bannedMember), eq(customReason), banLogModelCaptor.capture())).thenReturn(CompletableFuture.completedFuture(null));
+        when(banService.banUser(eq(bannedMember), eq(customReason), banLogModelCaptor.capture(), any(Message.class))).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<CommandResult> result = testUnit.executeAsync(parameters);
-        BanLog usedModel = banLogModelCaptor.getValue();
-        Assert.assertEquals(customReason, usedModel.getReason());
-        Assert.assertEquals(bannedMember, usedModel.getBannedUser());
-        Assert.assertEquals(parameters.getAuthor(), usedModel.getBanningUser());
+        Member banningMember = banLogModelCaptor.getValue();
+        Assert.assertEquals(parameters.getAuthor(), banningMember);
         CommandTestUtilities.checkSuccessfulCompletionAsync(result);
     }
 

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/BanServiceBeanTest.java

@@ -1,17 +1,13 @@
 package dev.sheldan.abstracto.moderation.service;
 
-import dev.sheldan.abstracto.core.exception.GuildNotFoundException;
-import dev.sheldan.abstracto.core.models.context.ServerContext;
-import dev.sheldan.abstracto.core.service.FeatureModeService;
-import dev.sheldan.abstracto.core.service.GuildService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
-import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
-import dev.sheldan.abstracto.moderation.config.feature.mode.ModerationMode;
 import dev.sheldan.abstracto.moderation.config.posttarget.ModerationPostTarget;
 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.User;
 import net.dv8tion.jda.api.requests.restaction.AuditableRestAction;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -20,7 +16,6 @@ import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnitRunner;
 
-import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
 import static org.mockito.Mockito.*;
@@ -34,9 +29,6 @@ public class BanServiceBeanTest {
     @InjectMocks
     private BanServiceBean testUnit;
 
-    @Mock
-    private GuildService guildService;
-
     @Mock
     private TemplateService templateService;
 
@@ -44,68 +36,25 @@ public class BanServiceBeanTest {
     private PostTargetService postTargetService;
 
     @Mock
-    private FeatureModeService featureModeService;
-
-    @Test
-    public void testBanMemberByMemberWithoutLog() {
-        Member memberToBan = Mockito.mock(Member.class);
-        when(memberToBan.getIdLong()).thenReturn(USER_ID);
-        ServerContext context = Mockito.mock(ServerContext.class);
-        Guild mockedGuild = Mockito.mock(Guild.class);
-        when(memberToBan.getGuild()).thenReturn(mockedGuild);
-        when(mockedGuild.getIdLong()).thenReturn(SERVER_ID);
-        AuditableRestAction mockedAction = mock(AuditableRestAction.class);
-        when(mockedAction.submit()).thenReturn(CompletableFuture.completedFuture(null));
-        when(mockedGuild.ban(USER_ID.toString(), 0, REASON)).thenReturn(mockedAction);
-        MessageToSend mockedMessage = Mockito.mock(MessageToSend.class);
-        when(featureModeService.featureModeActive(ModerationFeatureDefinition.MODERATION, SERVER_ID, ModerationMode.BAN_LOG)).thenReturn(false);
-        testUnit.banMember(memberToBan, REASON, context);
-        verify(mockedGuild, times(1)).ban(USER_ID.toString(), 0, REASON);
-        verify(postTargetService, times(0)).sendEmbedInPostTarget(mockedMessage, ModerationPostTarget.BAN_LOG, SERVER_ID);
-        verify(templateService, times(0)).renderEmbedTemplate(BanServiceBean.BAN_LOG_TEMPLATE, context, SERVER_ID);
-    }
+    private Message message;
 
     @Test
     public void testBanMemberWithLog() {
         Member memberToBan = Mockito.mock(Member.class);
-        when(memberToBan.getIdLong()).thenReturn(USER_ID);
-        ServerContext context = Mockito.mock(ServerContext.class);
+        User user = Mockito.mock(User.class);
+        when(memberToBan.getUser()).thenReturn(user);
+        Member banningMember = Mockito.mock(Member.class);
         Guild mockedGuild = Mockito.mock(Guild.class);
         when(memberToBan.getGuild()).thenReturn(mockedGuild);
         when(mockedGuild.getIdLong()).thenReturn(SERVER_ID);
         AuditableRestAction mockedAction = mock(AuditableRestAction.class);
         when(mockedAction.submit()).thenReturn(CompletableFuture.completedFuture(null));
-        when(mockedGuild.ban(USER_ID.toString(), 0, REASON)).thenReturn(mockedAction);
+        when(mockedGuild.ban(user, 0, REASON)).thenReturn(mockedAction);
         MessageToSend mockedMessage = Mockito.mock(MessageToSend.class);
-        when(templateService.renderEmbedTemplate(BanServiceBean.BAN_LOG_TEMPLATE, context, SERVER_ID)).thenReturn(mockedMessage);
-        when(featureModeService.featureModeActive(ModerationFeatureDefinition.MODERATION, SERVER_ID, ModerationMode.BAN_LOG)).thenReturn(true);
-        testUnit.banMember(memberToBan, REASON, context);
-        verify(mockedGuild, times(1)).ban(USER_ID.toString(), 0, REASON);
+        when(templateService.renderEmbedTemplate(eq(BanServiceBean.BAN_LOG_TEMPLATE), any(), eq(SERVER_ID))).thenReturn(mockedMessage);
+        testUnit.banMember(memberToBan, REASON, banningMember, message);
+        verify(mockedGuild, times(1)).ban(user, 0, REASON);
         verify(postTargetService, times(1)).sendEmbedInPostTarget(mockedMessage, ModerationPostTarget.BAN_LOG, SERVER_ID);
     }
 
-
-    @Test
-    public void testBanMemberById() {
-        ServerContext context = Mockito.mock(ServerContext.class);
-        Guild mockedGuild = Mockito.mock(Guild.class);
-        AuditableRestAction mockedAction = mock(AuditableRestAction.class);
-        when(mockedAction.submit()).thenReturn(CompletableFuture.completedFuture(null));
-        when(mockedGuild.ban(USER_ID.toString(), 0, REASON)).thenReturn(mockedAction);
-        MessageToSend mockedMessage = Mockito.mock(MessageToSend.class);
-        when(templateService.renderEmbedTemplate(BanServiceBean.BAN_ID_LOG_TEMPLATE, context, SERVER_ID)).thenReturn(mockedMessage);
-        when(featureModeService.featureModeActive(ModerationFeatureDefinition.MODERATION, SERVER_ID, ModerationMode.BAN_LOG)).thenReturn(true);
-        when(guildService.getGuildByIdOptional(SERVER_ID)).thenReturn(Optional.of(mockedGuild));
-        testUnit.banUserViaId(SERVER_ID, USER_ID, REASON, context);
-        verify(mockedGuild, times(1)).ban(USER_ID.toString(), 0, REASON);
-        verify(postTargetService, times(1)).sendEmbedInPostTarget(mockedMessage, ModerationPostTarget.BAN_LOG, SERVER_ID);
-    }
-
-    @Test(expected = GuildNotFoundException.class)
-    public void tryToBanInNonExistentGuild() {
-        ServerContext context = Mockito.mock(ServerContext.class);
-        when(guildService.getGuildByIdOptional(SERVER_ID)).thenReturn(Optional.empty());
-        testUnit.banUserViaId(SERVER_ID, USER_ID, REASON, context);
-    }
-
 }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/KickServiceBeanTest.java

@@ -2,8 +2,6 @@ package dev.sheldan.abstracto.moderation.service;
 
 import dev.sheldan.abstracto.core.service.FeatureModeService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
-import dev.sheldan.abstracto.moderation.config.feature.ModerationFeatureDefinition;
-import dev.sheldan.abstracto.moderation.config.feature.mode.ModerationMode;
 import dev.sheldan.abstracto.moderation.config.posttarget.ModerationPostTarget;
 import dev.sheldan.abstracto.moderation.model.template.command.KickLogModel;
 import dev.sheldan.abstracto.core.templating.model.MessageToSend;
@@ -40,27 +38,6 @@ public class KickServiceBeanTest {
 
     private static final Long SERVER_ID = 1L;
 
-    @Test
-    public void testKickMemberWithoutLog() {
-        User user = Mockito.mock(User.class);
-        Member member = Mockito.mock(Member.class);
-        when(member.getUser()).thenReturn(user);
-        when(user.getIdLong()).thenReturn(6L);
-        Guild mockedGuild = Mockito.mock(Guild.class);
-        when(mockedGuild.getIdLong()).thenReturn(SERVER_ID);
-        when(member.getGuild()).thenReturn(mockedGuild);
-        String reason = "reason";
-        AuditableRestAction<Void> mockedAction = Mockito.mock(AuditableRestAction.class);
-        when(mockedGuild.kick(member, reason)).thenReturn(mockedAction);
-        when(mockedAction.submit()).thenReturn(CompletableFuture.completedFuture(null));
-        KickLogModel model = Mockito.mock(KickLogModel.class);
-        when(model.getGuild()).thenReturn(mockedGuild);
-        when(featureModeService.featureModeActive(ModerationFeatureDefinition.MODERATION, SERVER_ID, ModerationMode.KICK_LOG)).thenReturn(false);
-        testUnit.kickMember(member, reason, model);
-        verify(postTargetService, times(0)).sendEmbedInPostTarget(any(MessageToSend.class), eq(ModerationPostTarget.KICK_LOG), eq(SERVER_ID));
-        verify(templateService, times(0)).renderEmbedTemplate(KickServiceBean.KICK_LOG_TEMPLATE, model, SERVER_ID);
-    }
-
     @Test
     public void testKickMemberWithLog() {
         User user = Mockito.mock(User.class);
@@ -76,10 +53,8 @@ public class KickServiceBeanTest {
         when(mockedAction.submit()).thenReturn(CompletableFuture.completedFuture(null));
         KickLogModel model = Mockito.mock(KickLogModel.class);
         when(model.getGuild()).thenReturn(mockedGuild);
-        MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
-        when(templateService.renderEmbedTemplate(KickServiceBean.KICK_LOG_TEMPLATE, model, SERVER_ID)).thenReturn(messageToSend);
-        when(featureModeService.featureModeActive(ModerationFeatureDefinition.MODERATION, SERVER_ID, ModerationMode.KICK_LOG)).thenReturn(true);
         testUnit.kickMember(member, reason, model);
-        verify(postTargetService, times(1)).sendEmbedInPostTarget(messageToSend, ModerationPostTarget.KICK_LOG, SERVER_ID);
+        verify(postTargetService, times(0)).sendEmbedInPostTarget(any(MessageToSend.class), eq(ModerationPostTarget.KICK_LOG), eq(SERVER_ID));
+        verify(templateService, times(1)).renderEmbedTemplate(KickServiceBean.KICK_LOG_TEMPLATE, model, SERVER_ID);
     }
 }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/MuteServiceBeanTest.java

@@ -270,7 +270,6 @@ public class MuteServiceBeanTest {
         when(muteLog.getMuteTargetDate()).thenReturn(unMuteDate);
         when(server.getId()).thenReturn(SERVER_ID);
         when(serverManagementService.loadOrCreate(SERVER_ID)).thenReturn(server);
-        when(featureModeService.featureModeActive(ModerationFeatureDefinition.MUTING, server, MutingMode.MUTE_LOGGING)).thenReturn(true);
         String notificationText = "text";
         when(templateService.renderTemplate(eq(MUTE_NOTIFICATION_TEMPLATE), any(MuteNotification.class), eq(SERVER_ID))).thenReturn(notificationText);
         when(messageService.sendMessageToUser(memberBeingMuted.getUser(), notificationText)).thenReturn(CompletableFuture.completedFuture(null));
@@ -301,7 +300,6 @@ public class MuteServiceBeanTest {
         when(muteLog.getContext()).thenReturn(serverChannelMessage);
         when(muteLog.getMuteTargetDate()).thenReturn(unMuteDate);
         when(serverManagementService.loadOrCreate(SERVER_ID)).thenReturn(server);
-        when(featureModeService.featureModeActive(ModerationFeatureDefinition.MUTING, server, MutingMode.MUTE_LOGGING)).thenReturn(false);
         String notificationText = "text";
         when(templateService.renderTemplate(eq(MUTE_NOTIFICATION_TEMPLATE), any(MuteNotification.class), eq(SERVER_ID))).thenReturn(notificationText);
         when(messageService.sendMessageToUser(memberBeingMuted.getUser(), notificationText)).thenReturn(CompletableFuture.completedFuture(null));
@@ -344,6 +342,7 @@ public class MuteServiceBeanTest {
     public void testSendUnmuteLog() {
         when(guild.getIdLong()).thenReturn(SERVER_ID);
         when(muteManagementService.findMute(MUTE_ID, SERVER_ID)).thenReturn(mute);
+        when(mute.getMuteId()).thenReturn(new ServerSpecificId(SERVER_ID, MUTE_ID));
         when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
         testUnit.sendUnmuteLog(MUTE_ID, guild, CompletableFuture.completedFuture(memberMuting), CompletableFuture.completedFuture(memberBeingMuted));
         verify(self, times(1)).endMuteInDatabase(MUTE_ID, SERVER_ID);

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/WarnServiceBeanTest.java

@@ -203,7 +203,6 @@ public class WarnServiceBeanTest {
     @Test
     public void testWarnFullUser() {
         setupWarnContext();
-        when(featureModeService.featureModeActive(ModerationFeatureDefinition.WARNING, SERVER_ID, WarningMode.WARN_LOG)).thenReturn(true);
         setupMocksForWarning();
         CompletableFuture<Void> future = testUnit.notifyAndLogFullUserWarning(context);
         future.join();