[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