[AB-68] adding invite filter with commands to allow/disallow invites, remove stored filtered invite links and show filtered invite links

removing database entities from command context

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/ActivateAssignableRolePlace.java

@@ -9,6 +9,8 @@ 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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -21,11 +23,15 @@ public class ActivateAssignableRolePlace extends AbstractConditionableCommand {
     @Autowired
     private AssignableRolePlaceService service;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
-        service.activateAssignableRolePlace(commandContext.getUserInitiatedContext().getServer(), name);
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        service.activateAssignableRolePlace(server, name);
         return CommandResult.fromSuccess();
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/AddRoleToAssignableRolePost.java

@@ -13,7 +13,9 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.models.FullEmote;
 import dev.sheldan.abstracto.core.models.FullRole;
+import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.RoleService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -30,6 +32,9 @@ public class AddRoleToAssignableRolePost extends AbstractConditionableCommand {
     @Autowired
     private RoleService roleService;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
@@ -37,13 +42,14 @@ public class AddRoleToAssignableRolePost extends AbstractConditionableCommand {
         FullEmote emote = (FullEmote) parameters.get(1);
         String description = (String) parameters.get(2);
         FullRole role = (FullRole) parameters.get(3);
-        if(service.hasAssignableRolePlaceEmote(commandContext.getUserInitiatedContext().getServer(), name, emote.getFakeEmote())) {
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        if(service.hasAssignableRolePlaceEmote(server, name, emote.getFakeEmote())) {
             throw new AssignableRoleAlreadyDefinedException(emote, name);
         }
         if(!roleService.canBotInteractWithRole(role.getRole())) {
             throw new AssignableRoleNotUsableException(role, commandContext.getGuild());
         }
-        return service.addRoleToAssignableRolePlace(commandContext.getUserInitiatedContext().getServer(), name, role.getRole(), emote, description)
+        return service.addRoleToAssignableRolePlace(server, name, role.getRole(), emote, description)
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/ChangeAssignableRolePlaceConfig.java

@@ -10,6 +10,8 @@ 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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -25,13 +27,18 @@ public class ChangeAssignableRolePlaceConfig extends AbstractConditionableComman
     @Autowired
     private AssignableRolePlaceService service;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
         AssignableRolePlaceParameterKey configKey = (AssignableRolePlaceParameterKey) parameters.get(1);
         Object parameterValue = parameters.get(2);
-        return service.changeConfiguration(commandContext.getUserInitiatedContext().getServer(), name, configKey, parameterValue)
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return service.changeConfiguration(server, name, configKey, parameterValue)
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/CreateAssignableRolePost.java

@@ -13,7 +13,9 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.models.database.AChannel;
+import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import net.dv8tion.jda.api.entities.MessageChannel;
 import net.dv8tion.jda.api.entities.TextChannel;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -31,6 +33,9 @@ public class CreateAssignableRolePost extends AbstractConditionableCommand {
     @Autowired
     private ChannelManagementService channelManagementService;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
@@ -38,7 +43,8 @@ public class CreateAssignableRolePost extends AbstractConditionableCommand {
         MessageChannel channel = (TextChannel) parameters.get(1);
         String text =  (String) parameters.get(2);
         AChannel chosenChannel = channelManagementService.loadChannel(channel.getIdLong());
-        service.createAssignableRolePlace(commandContext.getUserInitiatedContext().getServer(), name, chosenChannel, text);
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        service.createAssignableRolePlace(server, name, chosenChannel, text);
         return CommandResult.fromSuccess();
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/DeactivateAssignableRolePlace.java

@@ -9,6 +9,8 @@ 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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -21,11 +23,15 @@ public class DeactivateAssignableRolePlace extends AbstractConditionableCommand
     @Autowired
     private AssignableRolePlaceService service;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
-        service.deactivateAssignableRolePlace(commandContext.getUserInitiatedContext().getServer(), name);
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        service.deactivateAssignableRolePlace(server, name);
         return CommandResult.fromSuccess();
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/DeleteAssignableRolePlace.java

@@ -9,6 +9,8 @@ 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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -22,11 +24,15 @@ public class DeleteAssignableRolePlace extends AbstractConditionableCommand {
     @Autowired
     private AssignableRolePlaceService service;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
-        return service.deleteAssignableRolePlace(commandContext.getUserInitiatedContext().getServer(), name)
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return service.deleteAssignableRolePlace(server, name)
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/EditAssignableRolePlaceText.java

@@ -12,6 +12,8 @@ import dev.sheldan.abstracto.core.command.config.validator.MaxStringLengthValida
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -26,14 +28,16 @@ public class EditAssignableRolePlaceText extends AbstractConditionableCommand {
     @Autowired
     private AssignableRolePlaceService service;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
 
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
         String newText = (String) parameters.get(1);
-
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-        return service.changeText(commandContext.getUserInitiatedContext().getServer(), name, newText)
+        return service.changeText(server, name, newText)
                 .thenApply(aVoid ->  CommandResult.fromSuccess());
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/MoveAssignableRolePlace.java

@@ -9,6 +9,8 @@ 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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import net.dv8tion.jda.api.entities.TextChannel;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -22,12 +24,16 @@ public class MoveAssignableRolePlace extends AbstractConditionableCommand {
     @Autowired
     private AssignableRolePlaceService placeManagementService;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
         TextChannel newChannel = (TextChannel) parameters.get(1);
-        placeManagementService.moveAssignableRolePlace(commandContext.getUserInitiatedContext().getServer(), name, newChannel);
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        placeManagementService.moveAssignableRolePlace(server, name, newChannel);
         return CommandResult.fromSuccess();
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/RemoveRoleFromAssignableRolePlace.java

@@ -10,6 +10,8 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.models.FullEmote;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -23,12 +25,16 @@ public class RemoveRoleFromAssignableRolePlace extends AbstractConditionableComm
     @Autowired
     private AssignableRolePlaceService service;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
         FullEmote emote = (FullEmote) parameters.get(1);
-        return service.removeRoleFromAssignableRolePlace(commandContext.getUserInitiatedContext().getServer(), name, emote)
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return service.removeRoleFromAssignableRolePlace(server, name, emote)
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/SetAssignableRolePosition.java

@@ -10,6 +10,8 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.models.FullEmote;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -22,13 +24,17 @@ public class SetAssignableRolePosition extends AbstractConditionableCommand {
     @Autowired
     private AssignableRolePlaceService service;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
         FullEmote emote = (FullEmote) parameters.get(1);
         Integer newPosition = (Integer) parameters.get(2);
-        service.setEmoteToPosition(commandContext.getUserInitiatedContext().getServer(), name, emote, newPosition);
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        service.setEmoteToPosition(server, name, emote, newPosition);
         return CommandResult.fromSuccess();
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/SetupAssignableRolePlace.java

@@ -9,7 +9,9 @@ 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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -28,11 +30,15 @@ public class SetupAssignableRolePlace extends AbstractConditionableCommand {
     @Autowired
     private ChannelService channelService;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
-        return service.setupAssignableRolePlace(commandContext.getUserInitiatedContext().getServer(), name)
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return service.setupAssignableRolePlace(server, name)
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/ShowAssignableRolePlaceConfig.java

@@ -9,6 +9,8 @@ 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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -22,12 +24,16 @@ public class ShowAssignableRolePlaceConfig extends AbstractConditionableCommand
     @Autowired
     private AssignableRolePlaceService service;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
         // TODO refactor to return something to be posted in this command here instead of relying it to be posted somewhere else
-        service.showAssignablePlaceConfig(commandContext.getUserInitiatedContext().getServer(), name, commandContext.getChannel());
+        service.showAssignablePlaceConfig(server, name, commandContext.getChannel());
         return CommandResult.fromIgnored();
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/ShowAssignableRolePlaces.java

@@ -8,6 +8,8 @@ import dev.sheldan.abstracto.core.command.config.HelpInfo;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -20,9 +22,13 @@ public class ShowAssignableRolePlaces extends AbstractConditionableCommand {
     @Autowired
     private AssignableRolePlaceService service;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        return service.showAllAssignableRolePlaces(commandContext.getUserInitiatedContext().getServer(), commandContext.getChannel())
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return service.showAllAssignableRolePlaces(server, commandContext.getChannel())
                 .thenApply(aVoid -> CommandResult.fromIgnored());
     }
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/SwapAssignableRolePosition.java

@@ -13,6 +13,7 @@ import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.models.FullEmote;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.EmoteService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -28,13 +29,16 @@ public class SwapAssignableRolePosition extends AbstractConditionableCommand {
     @Autowired
     private EmoteService emoteService;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
         FullEmote firstEmote = (FullEmote) parameters.get(1);
         FullEmote secondEmote = (FullEmote) parameters.get(2);
-        AServer server = commandContext.getUserInitiatedContext().getServer();
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
         if(emoteService.compareAEmote(firstEmote.getFakeEmote(), secondEmote.getFakeEmote())) {
             return CommandResult.fromError("You cannot swap the same emote");
         }

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/command/TestAssignableRolePlace.java

@@ -9,6 +9,8 @@ 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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -22,11 +24,15 @@ public class TestAssignableRolePlace extends AbstractConditionableCommand {
     @Autowired
     private AssignableRolePlaceService service;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         String name = (String) parameters.get(0);
-        return service.testAssignableRolePlace(commandContext.getUserInitiatedContext().getServer(), name, commandContext.getChannel())
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return service.testAssignableRolePlace(server, name, commandContext.getChannel())
                 .thenApply(aVoid -> CommandResult.fromIgnored());
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/LeaderBoardCommand.java

@@ -10,7 +10,11 @@ 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.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.converter.LeaderBoardModelConverter;
@@ -51,20 +55,26 @@ public class LeaderBoardCommand extends AbstractConditionableCommand {
     @Autowired
     private LeaderBoardModelConverter converter;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
 
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         // parameter is optional, in case its not present, we default to the 0th page
         Integer page = !parameters.isEmpty() ? (Integer) parameters.get(0) : 1;
-        LeaderBoard leaderBoard = userExperienceService.findLeaderBoardData(commandContext.getUserInitiatedContext().getServer(), page);
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        LeaderBoard leaderBoard = userExperienceService.findLeaderBoardData(server, page);
         LeaderBoardModel leaderBoardModel = (LeaderBoardModel) ContextConverter.slimFromCommandContext(commandContext, LeaderBoardModel.class);
         List<CompletableFuture<LeaderBoardEntryModel>> futures = new ArrayList<>();
         List<CompletableFuture<LeaderBoardEntryModel>> completableFutures = converter.fromLeaderBoard(leaderBoard);
         futures.addAll(completableFutures);
         log.info("Rendering leaderboard for page {} in server {} for user {}.", page, commandContext.getAuthor().getId(), commandContext.getGuild().getId());
-
+        AUserInAServer aUserInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
-        LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(commandContext.getUserInitiatedContext().getAUserInAServer());
+        LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(aUserInAServer);
         CompletableFuture<LeaderBoardEntryModel> userRankFuture = converter.fromLeaderBoardEntry(userRank);
         futures.add(userRankFuture);
         return FutureUtils.toSingleFutureGeneric(futures).thenCompose(aVoid -> {

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/ListDisabledExperienceRoles.java

@@ -9,8 +9,10 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.command.execution.ContextConverter;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.models.FullRole;
+import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.RoleService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.models.database.ADisabledExpRole;
@@ -40,9 +42,13 @@ public class ListDisabledExperienceRoles extends AbstractConditionableCommand {
     @Autowired
     private ChannelService channelService;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        List<ADisabledExpRole> disabledRolesForServer = disabledExpRoleManagementService.getDisabledRolesForServer(commandContext.getUserInitiatedContext().getServer());
+        AServer server =  serverManagementService.loadServer(commandContext.getGuild());
+        List<ADisabledExpRole> disabledRolesForServer = disabledExpRoleManagementService.getDisabledRolesForServer(server);
         DisabledExperienceRolesModel disabledExperienceRolesModel = (DisabledExperienceRolesModel) ContextConverter.fromCommandContext(commandContext, DisabledExperienceRolesModel.class);
         disabledRolesForServer.forEach(aDisabledExpRole -> {
             FullRole role = FullRole

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/Rank.java

@@ -67,7 +67,8 @@ public class Rank extends AbstractConditionableCommand {
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         RankModel rankModel = (RankModel) ContextConverter.slimFromCommandContext(commandContext, RankModel.class);
-        LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(commandContext.getUserInitiatedContext().getAUserInAServer());
+        AUserInAServer aUserInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
+        LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(aUserInAServer);
         CompletableFuture<LeaderBoardEntryModel> future = converter.fromLeaderBoardEntry(userRank);
         return future.thenCompose(leaderBoardEntryModel ->
             self.renderAndSendRank(commandContext, rankModel, leaderBoardEntryModel)

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/SetExpRole.java

@@ -44,7 +44,7 @@ public class SetExpRole extends AbstractConditionableCommand {
         Integer level = (Integer) commandContext.getParameters().getParameters().get(0);
         Role role = (Role) commandContext.getParameters().getParameters().get(1);
         log.info("Setting role  {} to be used for level {} on server {}", role.getId(), level, role.getGuild().getId());
-        return experienceRoleService.setRoleToLevel(role, level, commandContext.getUserInitiatedContext().getChannel())
+        return experienceRoleService.setRoleToLevel(role, level, commandContext.getChannel().getIdLong())
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/SyncRoles.java

@@ -8,6 +8,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
 import lombok.extern.slf4j.Slf4j;
@@ -31,11 +32,14 @@ public class SyncRoles extends AbstractConditionableCommand {
     @Autowired
     private AUserExperienceService userExperienceService;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        AServer server = commandContext.getUserInitiatedContext().getServer();
+        AServer server =  serverManagementService.loadServer(commandContext.getGuild());
         log.info("Synchronizing roles on server {}", server.getId());
-        return userExperienceService.syncUserRolesWithFeedback(server, commandContext.getUserInitiatedContext().getChannel())
+        return userExperienceService.syncUserRolesWithFeedback(server, commandContext.getChannel().getIdLong())
                 .thenApply(aVoid -> CommandResult.fromIgnored());
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/UnSetExpRole.java

@@ -37,7 +37,7 @@ public class UnSetExpRole extends AbstractConditionableCommand {
         ARole actualRole = roleManagementService.findRole(role.getId());
         // do not check for the existence of the role, because if the role was deleted, users should be able
         // to get rid of it in the configuration
-        return experienceRoleService.unsetRole(actualRole, commandContext.getUserInitiatedContext().getChannel())
+        return experienceRoleService.unsetRole(actualRole, commandContext.getChannel().getIdLong())
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

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

@@ -4,10 +4,8 @@ import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
-import dev.sheldan.abstracto.core.service.BotService;
+import dev.sheldan.abstracto.core.service.*;
-import dev.sheldan.abstracto.core.service.ConfigService;
+import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
-import dev.sheldan.abstracto.core.service.MessageService;
-import dev.sheldan.abstracto.core.service.RoleService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
@@ -79,6 +77,9 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     @Autowired
     private ServerManagementService serverManagementService;
 
+    @Autowired
+    private ChannelManagementService channelManagementService;
+
     @Autowired
     private AUserExperienceServiceBean self;
 
@@ -403,10 +404,11 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     /**
      * Synchronizes the roles of all the users and provides feedback to the user executing
      * @param server The {@link AServer} to update users for
-     * @param channel The {@link AChannel} in which the {@link dev.sheldan.abstracto.experience.models.templates.UserSyncStatusModel}
+     * @param channelId The ID of the channel in which the {@link dev.sheldan.abstracto.experience.models.templates.UserSyncStatusModel} should be posted to
      */
     @Override
-    public CompletableFuture<Void> syncUserRolesWithFeedback(AServer server, AChannel channel) {
+    public CompletableFuture<Void> syncUserRolesWithFeedback(AServer server, Long channelId) {
+        AChannel channel = channelManagementService.loadChannel(channelId);
         List<AUserExperience> aUserExperiences = userExperienceManagementService.loadAllUsers(server);
         log.info("Found {} users to synchronize", aUserExperiences.size());
         List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);

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

@@ -3,6 +3,7 @@ package dev.sheldan.abstracto.experience.service;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
 import dev.sheldan.abstracto.experience.models.RoleCalculationResult;
@@ -42,6 +43,9 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
     @Autowired
     private RoleManagementService roleManagementService;
 
+    @Autowired
+    private ChannelManagementService channelManagementService;
+
     /**
      * UnSets the current configuration for the passed level, and sets the {@link ARole} to be used for this level
      * in the given {@link AServer}
@@ -49,10 +53,10 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
      * @param level The level the {@link ARole} should be awarded at
      */
     @Override
-    public CompletableFuture<Void> setRoleToLevel(Role role, Integer level, AChannel feedbackChannel) {
+    public CompletableFuture<Void> setRoleToLevel(Role role, Integer level, Long channelId) {
         Long roleId = role.getIdLong();
         ARole aRole = roleManagementService.findRole(roleId);
-        return unsetRole(aRole, feedbackChannel).thenAccept(aVoid ->
+        return unsetRole(aRole, channelId).thenAccept(aVoid ->
             self.unsetRoleInDb(level, roleId)
         );
     }
@@ -73,7 +77,8 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
      *             configuration
      */
     @Override
-    public CompletableFuture<Void> unsetRole(ARole role, AChannel feedbackChannel) {
+    public CompletableFuture<Void> unsetRole(ARole role, Long feedbackChannelId) {
+        AChannel channel = channelManagementService.loadChannel(feedbackChannelId);
         Optional<AExperienceRole> roleInServerOptional = experienceRoleManagementService.getRoleInServerOptional(role);
         if(roleInServerOptional.isPresent()) {
             AExperienceRole roleInServer = roleInServerOptional.get();
@@ -82,7 +87,7 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
                 List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(role.getServer());
                 roles.removeIf(role1 -> role1.getId().equals(roleInServer.getId()));
                 Long roleId = role.getId();
-                CompletableFutureList<RoleCalculationResult> calculationResults = userExperienceService.executeActionOnUserExperiencesWithFeedBack(roleInServer.getUsers(), feedbackChannel,
+                CompletableFutureList<RoleCalculationResult> calculationResults = userExperienceService.executeActionOnUserExperiencesWithFeedBack(roleInServer.getUsers(), channel,
                         (AUserExperience ex) -> userExperienceService.updateUserRole(ex, roles, ex.getLevelOrDefault()));
                 return calculationResults.getMainFuture().thenAccept(aVoid ->
                         self.persistData(calculationResults, roleId)

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/DisableExpGainTest.java

@@ -5,7 +5,6 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
-import dev.sheldan.abstracto.core.test.MockUtils;
 import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
 import net.dv8tion.jda.api.entities.Member;
@@ -35,7 +34,7 @@ public class DisableExpGainTest {
     @Test
     public void testDisableExpForMember() {
         CommandContext noParameters = CommandTestUtilities.getNoParameters();
-        AUserInAServer parameterUser = MockUtils.getUserObject(4L, noParameters.getUserInitiatedContext().getServer());
+        AUserInAServer parameterUser = Mockito.mock(AUserInAServer.class);
         Member member = Mockito.mock(Member.class);
         CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(member));
         when(userInServerManagementService.loadUser(member)).thenReturn(parameterUser);

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/EnableExpGainTest.java

@@ -5,7 +5,6 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
-import dev.sheldan.abstracto.core.test.MockUtils;
 import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
 import net.dv8tion.jda.api.entities.Member;
@@ -35,7 +34,7 @@ public class EnableExpGainTest {
     @Test
     public void testEnableExpForMember() {
         CommandContext noParameters = CommandTestUtilities.getNoParameters();
-        AUserInAServer parameterUser = MockUtils.getUserObject(4L, noParameters.getUserInitiatedContext().getServer());
+        AUserInAServer parameterUser = Mockito.mock(AUserInAServer.class);
         Member member = Mockito.mock(Member.class);
         CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(member));
         when(userInServerManagementService.loadUser(member)).thenReturn(parameterUser);

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/LeaderBoardCommandTest.java

@@ -2,7 +2,11 @@ package dev.sheldan.abstracto.experience.commands;
 
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.converter.LeaderBoardModelConverter;
 import dev.sheldan.abstracto.experience.models.LeaderBoard;
 import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
@@ -17,6 +21,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnitRunner;
 
 import java.util.ArrayList;
@@ -43,6 +48,12 @@ public class LeaderBoardCommandTest {
     @Mock
     private LeaderBoardModelConverter converter;
 
+    @Mock
+    private UserInServerManagementService userInServerManagementService;
+
+    @Mock
+    private ServerManagementService serverManagementService;
+
     @Test
     public void testLeaderBoardWithNoParameter() {
         testLeaderBoardCommand(CommandTestUtilities.getNoParameters(), 1);
@@ -54,11 +65,15 @@ public class LeaderBoardCommandTest {
     }
 
     private void testLeaderBoardCommand(CommandContext context, int expectedPage) {
-        LeaderBoard leaderBoard = LeaderBoard.builder().build();
+        LeaderBoard leaderBoard = Mockito.mock(LeaderBoard.class);
-        when(userExperienceService.findLeaderBoardData(context.getUserInitiatedContext().getServer(), expectedPage)).thenReturn(leaderBoard);
+        AServer server = Mockito.mock(AServer.class);
+        when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
+        AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
+        when(userInServerManagementService.loadUser(context.getAuthor())).thenReturn(userInAServer);
+        when(userExperienceService.findLeaderBoardData(server, expectedPage)).thenReturn(leaderBoard);
         when(converter.fromLeaderBoard(leaderBoard)).thenReturn(new ArrayList<>());
         LeaderBoardEntry executingUserRank = LeaderBoardEntry.builder().build();
-        when(userExperienceService.getRankOfUserInServer(context.getUserInitiatedContext().getAUserInAServer())).thenReturn(executingUserRank);
+        when(userExperienceService.getRankOfUserInServer(userInAServer)).thenReturn(executingUserRank);
         LeaderBoardEntryModel leaderBoardEntryModel = LeaderBoardEntryModel.builder().build();
         when(converter.fromLeaderBoardEntry(executingUserRank)).thenReturn(CompletableFuture.completedFuture(leaderBoardEntryModel));
         MessageToSend messageToSend = MessageToSend.builder().build();

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/ListDisabledExperienceRolesTest.java

@@ -6,6 +6,7 @@ import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.RoleService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.experience.models.database.ADisabledExpRole;
 import dev.sheldan.abstracto.experience.models.templates.DisabledExperienceRolesModel;
 import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
@@ -41,10 +42,14 @@ public class ListDisabledExperienceRolesTest {
     @Mock
     private ChannelService channelService;
 
+    @Mock
+    private ServerManagementService serverManagementService;
+
     @Test
     public void testCommandExecutionNoRolesFound() {
         CommandContext context = CommandTestUtilities.getNoParameters();
-        AServer server = context.getUserInitiatedContext().getServer();
+        AServer server = Mockito.mock(AServer.class);
+        when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
         when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
         when(channelService.sendEmbedTemplateInChannel(eq("list_disabled_experience_roles"),
                 any(DisabledExperienceRolesModel.class), eq(context.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
@@ -56,7 +61,7 @@ public class ListDisabledExperienceRolesTest {
     @Test
     public void testCommandExecutionRolesFound() {
         CommandContext context = CommandTestUtilities.getNoParameters();
-        AServer server = context.getUserInitiatedContext().getServer();
+        AServer server = Mockito.mock(AServer.class);
         ADisabledExpRole disabledExpRole1 = ADisabledExpRole.builder().role(MockUtils.getRole(4L, server)).build();
         ADisabledExpRole disabledExpRole2 = ADisabledExpRole.builder().role(MockUtils.getRole(6L, server)).build();
         when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(Arrays.asList(disabledExpRole1, disabledExpRole2));
@@ -64,6 +69,7 @@ public class ListDisabledExperienceRolesTest {
         Role role2 = Mockito.mock(Role.class);
         when(roleService.getRoleFromGuild(disabledExpRole1.getRole())).thenReturn(role1);
         when(roleService.getRoleFromGuild(disabledExpRole2.getRole())).thenReturn(role2);
+        when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
         when(channelService.sendEmbedTemplateInChannel(eq("list_disabled_experience_roles"),
                 any(DisabledExperienceRolesModel.class), eq(context.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
         CompletableFuture<CommandResult> result = testUnit.executeAsync(context);

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/RankTest.java

@@ -68,7 +68,8 @@ public class RankTest {
     public void testRankExecution() {
         CommandContext context = CommandTestUtilities.getNoParameters();
         LeaderBoardEntry leaderBoardEntry = Mockito.mock(LeaderBoardEntry.class);
-        when(userExperienceService.getRankOfUserInServer(context.getUserInitiatedContext().getAUserInAServer())).thenReturn(leaderBoardEntry);
+        when(userInServerManagementService.loadUser(context.getAuthor())).thenReturn(aUserInAServer);
+        when(userExperienceService.getRankOfUserInServer(aUserInAServer)).thenReturn(leaderBoardEntry);
         LeaderBoardEntryModel leaderBoardEntryModel = Mockito.mock(LeaderBoardEntryModel.class);
         when(converter.fromLeaderBoardEntry(leaderBoardEntry)).thenReturn(CompletableFuture.completedFuture(leaderBoardEntryModel));
         when(self.renderAndSendRank(eq(context), any(RankModel.class), eq(leaderBoardEntryModel))).thenReturn(CompletableFuture.completedFuture(null));

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/SetExpRoleTest.java

@@ -35,14 +35,17 @@ public class SetExpRoleTest {
     @Mock
     private RoleManagementService roleManagementService;
 
+    private static final Long CHANNEL_ID = 4L;
+
     @Test
     public void setExpRole() {
         CommandContext noParameters = CommandTestUtilities.getNoParameters();
         Role roleToChange = Mockito.mock(Role.class);
         when(roleToChange.getGuild()).thenReturn(noParameters.getGuild());
         Integer levelToSetTo = 4;
+        when(noParameters.getChannel().getIdLong()).thenReturn(CHANNEL_ID);
         CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(levelToSetTo, roleToChange));
-        when(experienceRoleService.setRoleToLevel(roleToChange, levelToSetTo, context.getUserInitiatedContext().getChannel())).thenReturn(CompletableFuture.completedFuture(null));
+        when(experienceRoleService.setRoleToLevel(roleToChange, levelToSetTo, CHANNEL_ID)).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
         CommandTestUtilities.checkSuccessfulCompletionAsync(result);
     }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/SyncRolesTest.java

@@ -2,8 +2,9 @@ package dev.sheldan.abstracto.experience.commands;
 
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
-import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
 import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
@@ -11,6 +12,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnitRunner;
 
 import java.util.concurrent.CompletableFuture;
@@ -26,12 +28,21 @@ public class SyncRolesTest {
     @Mock
     private AUserExperienceService userExperienceService;
 
+    @Mock
+    private ChannelManagementService channelManagementService;
+
+    @Mock
+    private ServerManagementService serverManagementService;
+
+    private static final Long CHANNEL_ID = 4L;
+
     @Test
     public void executeCommand() {
         CommandContext context = CommandTestUtilities.getNoParameters();
-        AServer server = context.getUserInitiatedContext().getServer();
+        AServer server = Mockito.mock(AServer.class);
-        AChannel channel = context.getUserInitiatedContext().getChannel();
+        when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
-        when(userExperienceService.syncUserRolesWithFeedback(server, channel)).thenReturn(CompletableFuture.completedFuture(null));
+        when(context.getChannel().getIdLong()).thenReturn(CHANNEL_ID);
+        when(userExperienceService.syncUserRolesWithFeedback(server, CHANNEL_ID)).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
         CommandTestUtilities.checkSuccessfulCompletionAsync(result);
     }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/UnSetExpRoleTest.java

@@ -5,7 +5,6 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
-import dev.sheldan.abstracto.core.test.MockUtils;
 import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
 import org.junit.Test;
@@ -32,14 +31,17 @@ public class UnSetExpRoleTest {
     @Mock
     private RoleManagementService roleManagementService;
 
+    private static final Long CHANNEL_ID = 4L;
+
     @Test
     public void setUnSetExpRole() {
         CommandContext noParameters = CommandTestUtilities.getNoParameters();
-        ARole changedRole = MockUtils.getRole(4L, noParameters.getUserInitiatedContext().getServer());
+        ARole changedRole = Mockito.mock(ARole.class);
         CommandContext context = CommandTestUtilities.enhanceWithParameters(noParameters, Arrays.asList(changedRole));
+        when(context.getChannel().getIdLong()).thenReturn(CHANNEL_ID);
         ARole actualRole = Mockito.mock(ARole.class);
         when(roleManagementService.findRole(changedRole.getId())).thenReturn(actualRole);
-        when(experienceRoleService.unsetRole(actualRole, context.getUserInitiatedContext().getChannel())).thenReturn(CompletableFuture.completedFuture(null));
+        when(experienceRoleService.unsetRole(actualRole, CHANNEL_ID)).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
         CommandTestUtilities.checkSuccessfulCompletionAsync(result);
     }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/AUserExperienceServiceBeanTest.java

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.service.BotService;
 import dev.sheldan.abstracto.core.service.ConfigService;
 import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.core.service.RoleService;
+import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
@@ -67,6 +68,9 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
     @Mock
     private TemplateService templateService;
 
+    @Mock
+    private ChannelManagementService channelManagementService;
+
     @Mock
     private DisabledExpRoleManagementService disabledExpRoleManagementService;
 
@@ -124,6 +128,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
     private static final Long USER_IN_SERVER_ID = 4L;
     private static final Long USER_ID = 8L;
     private static final Long SERVER_ID = 9L;
+    private static final Long CHANNEL_ID = 7L;
 
     @Test
     public void testCalculateLevelTooLow() {
@@ -583,7 +588,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testSyncRolesWithFeedBack() {
-        AChannel channel = AChannel.builder().id(2L).build();
+        AChannel channel = Mockito.mock(AChannel.class);
         List<AUserExperience> experiences = getUserExperiences(25, server);
 
         checkStatusMessages(server, channel, experiences, 13);
@@ -591,7 +596,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testSyncRolesWithNoUsers() {
-        AChannel channel = AChannel.builder().id(2L).build();
+        AChannel channel = Mockito.mock(AChannel.class);
         List<AUserExperience> experiences = new ArrayList<>();
 
         checkStatusMessages(server, channel, experiences, 1);
@@ -631,7 +636,8 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         Message statusMessageJDA = Mockito.mock(Message.class);
         when(statusMessageJDA.getIdLong()).thenReturn(messageId);
         when(messageService.createStatusMessage(statusMessage, channel)).thenReturn(CompletableFuture.completedFuture(statusMessageJDA));
-        testUnit.syncUserRolesWithFeedback(server, channel);
+        when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(channel);
+        testUnit.syncUserRolesWithFeedback(server, CHANNEL_ID);
         verify(messageService, times(messageCount)).updateStatusMessage(channel, messageId, statusMessage);
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/ExperienceRoleServiceBeanTest.java

@@ -4,6 +4,7 @@ import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.AChannelType;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
 import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
@@ -48,17 +49,21 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
     @Mock
     private RoleManagementService roleManagementService;
 
+    @Mock
+    private ChannelManagementService channelManagementService;
+
     @Mock
     private ExperienceRoleServiceBean self;
 
     @Mock
     private AServer server;
 
+    private static final Long CHANNEL_ID = 4L;
 
     @Test
     public void testSettingRoleToLevelWithoutOldUsers() {
         Integer levelCount = 10;
-        AExperienceLevel level = AExperienceLevel.builder().experienceNeeded(10L).level(levelCount).build();
+        AExperienceLevel level = Mockito.mock(AExperienceLevel.class);
         Role roleToChange = Mockito.mock(Role.class);
         ARole role = Mockito.mock(ARole.class);
         Long roleId = 5L;
@@ -66,10 +71,11 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
         when(roleManagementService.findRole(roleId)).thenReturn(role);
         AExperienceRole previousExperienceRole = AExperienceRole.builder().role(role).roleServer(server).level(level).build();
         when(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
-        CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, getFeedbackChannel(server));
+        CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, CHANNEL_ID);
 
         future.join();
         verify(experienceRoleManagementService, times(1)).unsetRole(previousExperienceRole);
+        verify(self, times(1)).unsetRoleInDb(levelCount, roleId);
     }
 
     @Test
@@ -105,12 +111,13 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
         AExperienceRole newExperienceRole = AExperienceRole.builder().role(newRoleToAward).id(newRoleToAward.getId()).roleServer(server).level(level).build();
         when(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
         when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(new ArrayList<>(Arrays.asList(newExperienceRole, previousExperienceRole)));
-        AChannel feedBackChannel = getFeedbackChannel(server);
         List<CompletableFuture<RoleCalculationResult>> futures = new ArrayList<>();
         futures.add(CompletableFuture.completedFuture(null));
+        AChannel feedbackChannel = Mockito.mock(AChannel.class);
+        when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(feedbackChannel);
         CompletableFutureList<RoleCalculationResult> futuresList = new CompletableFutureList<>(futures);
-        when(userExperienceService.executeActionOnUserExperiencesWithFeedBack(eq(users), eq(feedBackChannel), any())).thenReturn(futuresList);
+        when(userExperienceService.executeActionOnUserExperiencesWithFeedBack(eq(users), eq(feedbackChannel), any())).thenReturn(futuresList);
-        CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, feedBackChannel);
+        CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, CHANNEL_ID);
         future.join();
         verify(experienceRoleManagementService, times(0)).unsetRole(previousExperienceRole);
     }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/service/AUserExperienceService.java

@@ -88,7 +88,7 @@ public interface AUserExperienceService {
      * @param channel The {@link AChannel} in which the {@link dev.sheldan.abstracto.experience.models.templates.UserSyncStatusModel}
      *                should be posted to
      */
-    CompletableFuture<Void> syncUserRolesWithFeedback(AServer server, AChannel channel);
+    CompletableFuture<Void> syncUserRolesWithFeedback(AServer server, Long channelId);
 
     /**
      * Recalculates the role of a single user in a server and synchronize the {@link net.dv8tion.jda.api.entities.Role}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/service/ExperienceRoleService.java

@@ -1,6 +1,5 @@
 package dev.sheldan.abstracto.experience.service;
 
-import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
@@ -21,14 +20,14 @@ public interface ExperienceRoleService {
      * @param role The {@link ARole} to set the level to
      * @param level The level the {@link ARole} should be awarded at
      */
-    CompletableFuture<Void> setRoleToLevel(Role role, Integer level, AChannel channel);
+    CompletableFuture<Void> setRoleToLevel(Role role, Integer level, Long channelId);
 
     /**
      * Removes the role from the {@link dev.sheldan.abstracto.experience.models.database.AExperienceRole} configuration
      * @param role The {@link ARole} to remove from the {@link dev.sheldan.abstracto.experience.models.database.AExperienceRole}
      *             configuration
      */
-    CompletableFuture<Void> unsetRole(ARole role, AChannel feedbackChannel);
+    CompletableFuture<Void> unsetRole(ARole role, Long channelId);
 
     /**
      * Calculates the appropriate {@link AExperienceRole} based on the provided list of {@link AExperienceRole}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/DecayAllWarnings.java

@@ -7,6 +7,8 @@ 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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.service.WarnService;
@@ -23,9 +25,13 @@ public class DecayAllWarnings extends AbstractConditionableCommand {
     @Autowired
     private WarnService warnService;
 
+     @Autowired
+     private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        return warnService.decayAllWarningsForServer(commandContext.getUserInitiatedContext().getServer())
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return warnService.decayAllWarningsForServer(server)
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/DecayWarnings.java

@@ -7,6 +7,8 @@ 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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.service.WarnService;
@@ -23,9 +25,13 @@ public class DecayWarnings extends AbstractConditionableCommand {
     @Autowired
     private WarnService warnService;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
-        return warnService.decayWarningsForServer(commandContext.getUserInitiatedContext().getServer())
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        return warnService.decayWarningsForServer(server)
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/DeleteNote.java

@@ -9,6 +9,8 @@ import dev.sheldan.abstracto.core.command.config.validator.MinIntegerValueValida
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.service.management.UserNoteManagementService;
@@ -30,13 +32,15 @@ public class DeleteNote extends AbstractConditionableCommand {
     @Autowired
     private TemplateService templateService;
 
-
+    @Autowired
+    private ServerManagementService serverManagementService;
 
     @Override
     public CommandResult execute(CommandContext commandContext) {
         Long id = (Long) commandContext.getParameters().getParameters().get(0);
-        if(userNoteManagementService.noteExists(id, commandContext.getUserInitiatedContext().getServer())) {
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
-           userNoteManagementService.deleteNote(id, commandContext.getUserInitiatedContext().getServer());
+        if(userNoteManagementService.noteExists(id, server)) {
+           userNoteManagementService.deleteNote(id, server);
         } else {
             // TODO replace with exception
             return CommandResult.fromError(templateService.renderSimpleTemplate(NOTE_NOT_FOUND_EXCEPTION_TEMPLATE));

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/MyWarnings.java

@@ -8,7 +8,9 @@ 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.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.models.template.commands.MyWarningsModel;
@@ -30,12 +32,16 @@ public class MyWarnings extends AbstractConditionableCommand {
     @Autowired
     private WarnManagementService warnManagementService;
 
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         MyWarningsModel model = (MyWarningsModel) ContextConverter.fromCommandContext(commandContext, MyWarningsModel.class);
-        Long currentWarnCount = warnManagementService.getActiveWarnsForUser(commandContext.getUserInitiatedContext().getAUserInAServer());
+        AUserInAServer userInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
+        Long currentWarnCount = warnManagementService.getActiveWarnsForUser(userInAServer);
         model.setCurrentWarnCount(currentWarnCount);
-        Long totalWarnCount = warnManagementService.getTotalWarnsForUser(commandContext.getUserInitiatedContext().getAUserInAServer());
+        Long totalWarnCount = warnManagementService.getTotalWarnsForUser(userInAServer);
         model.setTotalWarnCount(totalWarnCount);
         channelService.sendEmbedTemplateInChannel(MY_WARNINGS_RESPONSE_EMBED_TEMPLATE, model, commandContext.getChannel());
         return CommandResult.fromIgnored();

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/UserNotes.java

@@ -9,8 +9,10 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.command.execution.ContextConverter;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.models.FullUserInServer;
+import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
@@ -47,6 +49,9 @@ public class UserNotes extends AbstractConditionableCommand {
     @Autowired
     private UserNotesConverter userNotesConverter;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
@@ -64,7 +69,8 @@ public class UserNotes extends AbstractConditionableCommand {
                     .build();
             model.setSpecifiedUser(specifiedUser);
         } else {
-            userNotes = userNoteManagementService.loadNotesForServer(commandContext.getUserInitiatedContext().getServer());
+            AServer server = serverManagementService.loadServer(commandContext.getGuild());
+            userNotes = userNoteManagementService.loadNotesForServer(server);
         }
         CompletableFuture<List<NoteEntryModel>> listCompletableFuture = userNotesConverter.fromNotes(userNotes);
         return listCompletableFuture.thenCompose(noteEntryModels -> {

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/Warnings.java

@@ -10,7 +10,9 @@ 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.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.PaginatorService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
@@ -47,6 +49,9 @@ public class Warnings extends AbstractConditionableCommand {
     @Autowired
     private EventWaiter eventWaiter;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Autowired
     private Warnings self;
 
@@ -57,7 +62,8 @@ public class Warnings extends AbstractConditionableCommand {
             Member member = (Member) commandContext.getParameters().getParameters().get(0);
             warnsToDisplay = warnManagementService.getAllWarnsForUser(userInServerManagementService.loadUser(member));
         } else {
-            warnsToDisplay = warnManagementService.getAllWarningsOfServer(commandContext.getUserInitiatedContext().getServer());
+            AServer server = serverManagementService.loadServer(commandContext.getGuild());
+            warnsToDisplay = warnManagementService.getAllWarningsOfServer(server);
         }
         return warnEntryConverter.fromWarnings(warnsToDisplay).thenApply(warnEntries -> {
             self.renderWarnings(commandContext, warnEntries);

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/invite/AllowInvite.java

@@ -0,0 +1,52 @@
+package dev.sheldan.abstracto.moderation.commands.invite;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+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.config.FeatureEnum;
+import dev.sheldan.abstracto.moderation.config.ModerationModule;
+import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
+import dev.sheldan.abstracto.moderation.service.InviteLinkFilterServiceBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Component
+public class AllowInvite extends AbstractConditionableCommand {
+
+    @Autowired
+    private InviteLinkFilterServiceBean inviteLinkFilterServiceBean;
+
+    @Override
+    public CommandResult execute(CommandContext commandContext) {
+        String inviteLink = (String) commandContext.getParameters().getParameters().get(0);
+        inviteLinkFilterServiceBean.allowInvite(inviteLink, commandContext.getGuild().getIdLong());
+        return CommandResult.fromSuccess();
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        parameters.add(Parameter.builder().name("invite").type(String.class).templated(true).build());
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("allowInvite")
+                .module(ModerationModule.MODERATION)
+                .templated(true)
+                .supportsEmbedException(true)
+                .causesReaction(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModerationFeatures.INVITE_FILTER;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/invite/DisAllowInvite.java

@@ -0,0 +1,52 @@
+package dev.sheldan.abstracto.moderation.commands.invite;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+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.config.FeatureEnum;
+import dev.sheldan.abstracto.moderation.config.ModerationModule;
+import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
+import dev.sheldan.abstracto.moderation.service.InviteLinkFilterServiceBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Component
+public class DisAllowInvite extends AbstractConditionableCommand {
+
+    @Autowired
+    private InviteLinkFilterServiceBean inviteLinkFilterServiceBean;
+
+    @Override
+    public CommandResult execute(CommandContext commandContext) {
+        String inviteLink = (String) commandContext.getParameters().getParameters().get(0);
+        inviteLinkFilterServiceBean.disAllowInvite(inviteLink, commandContext.getGuild().getIdLong());
+        return CommandResult.fromSuccess();
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        parameters.add(Parameter.builder().name("invite").type(String.class).templated(true).build());
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("disAllowInvite")
+                .module(ModerationModule.MODERATION)
+                .templated(true)
+                .supportsEmbedException(true)
+                .causesReaction(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModerationFeatures.INVITE_FILTER;
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/invite/RemoveTrackedInviteLinks.java

@@ -0,0 +1,65 @@
+package dev.sheldan.abstracto.moderation.commands.invite;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+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.config.FeatureEnum;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.moderation.config.ModerationModule;
+import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
+import dev.sheldan.abstracto.moderation.config.features.mode.InviteFilterMode;
+import dev.sheldan.abstracto.moderation.service.InviteLinkFilterService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Component
+public class RemoveTrackedInviteLinks extends AbstractConditionableCommand {
+
+    @Autowired
+    private InviteLinkFilterService inviteLinkFilterService;
+
+    @Override
+    public CommandResult execute(CommandContext commandContext) {
+        List<Object> parameters = commandContext.getParameters().getParameters();
+        if(!parameters.isEmpty()) {
+            String invite = (String) parameters.get(0);
+            inviteLinkFilterService.clearAllUses(invite, commandContext.getGuild().getIdLong());
+        } else {
+            inviteLinkFilterService.clearAllTrackedInviteCodes(commandContext.getGuild().getIdLong());
+        }
+        return CommandResult.fromSuccess();
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        parameters.add(Parameter.builder().name("invite").type(String.class).optional(true).templated(true).build());
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("removeTrackedInviteLinks")
+                .module(ModerationModule.MODERATION)
+                .templated(true)
+                .supportsEmbedException(true)
+                .causesReaction(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModerationFeatures.INVITE_FILTER;
+    }
+
+    @Override
+    public List<FeatureMode> getFeatureModeLimitations() {
+        return Arrays.asList(InviteFilterMode.TRACK_USES);
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/invite/ShowTrackedInviteLinks.java

@@ -0,0 +1,86 @@
+package dev.sheldan.abstracto.moderation.commands.invite;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+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.FeatureEnum;
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.moderation.config.ModerationModule;
+import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
+import dev.sheldan.abstracto.moderation.config.features.mode.InviteFilterMode;
+import dev.sheldan.abstracto.moderation.models.database.FilteredInviteLink;
+import dev.sheldan.abstracto.moderation.models.template.commands.TrackedInviteLinksModel;
+import dev.sheldan.abstracto.moderation.service.InviteLinkFilterService;
+import dev.sheldan.abstracto.templating.model.MessageToSend;
+import dev.sheldan.abstracto.templating.service.TemplateService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class ShowTrackedInviteLinks extends AbstractConditionableCommand {
+
+    @Autowired
+    private InviteLinkFilterService inviteLinkFilterService;
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    public static final String TRACKED_INVITE_LINKS_EMBED_TEMPLATE_KEY = "showTrackedInviteLinks_response";
+
+    @Override
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+        TrackedInviteLinksModel model = (TrackedInviteLinksModel) ContextConverter.slimFromCommandContext(commandContext, TrackedInviteLinksModel.class);
+        List<Object> parameters = commandContext.getParameters().getParameters();
+        List<FilteredInviteLink> inviteLinks;
+        if(!parameters.isEmpty()) {
+            Integer count = (Integer) parameters.get(0);
+            inviteLinks = inviteLinkFilterService.getTopFilteredInviteLinks(commandContext.getGuild().getIdLong(), count);
+        } else {
+            inviteLinks = inviteLinkFilterService.getTopFilteredInviteLinks(commandContext.getGuild().getIdLong());
+        }
+        model.setInviteLinks(inviteLinks);
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(TRACKED_INVITE_LINKS_EMBED_TEMPLATE_KEY, model);
+        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
+                .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        parameters.add(Parameter.builder().name("amount").type(Integer.class).optional(true).templated(true).build());
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("showTrackedInviteLinks")
+                .module(ModerationModule.MODERATION)
+                .templated(true)
+                .async(true)
+                .supportsEmbedException(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModerationFeatures.INVITE_FILTER;
+    }
+
+    @Override
+    public List<FeatureMode> getFeatureModeLimitations() {
+        return Arrays.asList(InviteFilterMode.TRACK_USES);
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/mute/SetMuteRole.java

@@ -8,7 +8,9 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.models.database.ARole;
+import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.RoleManagementService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.config.ModerationModule;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
 import dev.sheldan.abstracto.moderation.service.management.MuteRoleManagementService;
@@ -28,11 +30,15 @@ public class SetMuteRole extends AbstractConditionableCommand {
     @Autowired
     private RoleManagementService roleManagementService;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Override
     public CommandResult execute(CommandContext commandContext) {
         Role jdaRole = (Role) commandContext.getParameters().getParameters().get(0);
         ARole role = roleManagementService.findRole(jdaRole.getIdLong());
-        muteRoleManagementService.setMuteRoleForServer(commandContext.getUserInitiatedContext().getServer(), role);
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        muteRoleManagementService.setMuteRoleForServer(server, role);
         return CommandResult.fromSuccess();
     }
 

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

@@ -0,0 +1,114 @@
+package dev.sheldan.abstracto.moderation.listener.async;
+
+import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.execution.result.MessageReceivedListenerResult;
+import dev.sheldan.abstracto.core.listener.sync.jda.MessageReceivedListener;
+import dev.sheldan.abstracto.core.models.ServerUser;
+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.features.ModerationFeatures;
+import dev.sheldan.abstracto.moderation.config.features.mode.InviteFilterMode;
+import dev.sheldan.abstracto.moderation.config.posttargets.InviteFilterPostTarget;
+import dev.sheldan.abstracto.moderation.models.template.listener.InviteDeletedModel;
+import dev.sheldan.abstracto.moderation.service.InviteLinkFilterService;
+import dev.sheldan.abstracto.templating.model.MessageToSend;
+import dev.sheldan.abstracto.templating.service.TemplateService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Message;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.regex.Matcher;
+
+@Component
+@Slf4j
+public class InviteLinkFilterListener implements MessageReceivedListener {
+
+    @Autowired
+    private InviteLinkFilterService inviteLinkFilterService;
+
+    @Autowired
+    private FeatureModeService featureModeService;
+
+    @Autowired
+    private PostTargetService postTargetService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    public static final String INVITE_LINK_DELETED_NOTIFICATION_EMBED_TEMPLATE_KEY = "invite_link_deleted_notification";
+
+    @Override
+    public MessageReceivedListenerResult execute(Message message) {
+        Long serverId = message.getGuild().getIdLong();
+        Matcher matcher = Message.INVITE_PATTERN.matcher(message.getContentRaw());
+        ServerUser author = ServerUser.builder().userId(message.getAuthor().getIdLong()).serverId(message.getGuild().getIdLong()).build();
+        boolean toDelete = false;
+        List<String> codesToTrack = new ArrayList<>();
+        while(matcher.find()) {
+            String code = matcher.group("code");
+            boolean codeFiltered = inviteLinkFilterService.isCodeFiltered(code, author);
+            if(codeFiltered) {
+                codesToTrack.add(code);
+                toDelete = true;
+            }
+        }
+
+        if(toDelete) {
+            message.delete().queue();
+            boolean trackUsages = featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, serverId, InviteFilterMode.TRACK_USES);
+            if(trackUsages) {
+                codesToTrack.forEach(s -> inviteLinkFilterService.storeFilteredInviteLinkUsage(s, author));
+            }
+            boolean sendNotification = featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, serverId, InviteFilterMode.FILTER_NOTIFICATIONS);
+            if(sendNotification) {
+                sendDeletionNotification(codesToTrack, message);
+            }
+            return MessageReceivedListenerResult.DELETED;
+        } else {
+            return MessageReceivedListenerResult.PROCESSED;
+        }
+    }
+
+    private void sendDeletionNotification(List<String> codes, Message message) {
+        Long serverId = message.getGuild().getIdLong();
+        if(!postTargetService.postTargetDefinedInServer(InviteFilterPostTarget.INVITE_DELETE_LOG, serverId)) {
+            log.info("Post target {} not defined for server {} - not sending invite link deletion notification.", InviteFilterPostTarget.INVITE_DELETE_LOG.getKey(), serverId);
+            return;
+        }
+        InviteDeletedModel model = InviteDeletedModel
+                .builder()
+                .author(message.getMember())
+                .guild(message.getGuild())
+                .message(message)
+                .channel(message.getTextChannel())
+                .invites(codes)
+                .build();
+        log.info("Sending notification about {} deleted invite links in guild {} from user {} in channel {} in message {}.",
+                codes.size(), serverId, message.getAuthor().getIdLong(), message.getTextChannel().getIdLong(), message.getIdLong());
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(INVITE_LINK_DELETED_NOTIFICATION_EMBED_TEMPLATE_KEY, model);
+        List<CompletableFuture<Message>> messageFutures = postTargetService.sendEmbedInPostTarget(messageToSend, InviteFilterPostTarget.INVITE_DELETE_LOG, serverId);
+        FutureUtils.toSingleFutureGeneric(messageFutures).thenAccept(unused ->
+            log.trace("Successfully send notification about deleted invite link in message {}.", message.getIdLong())
+        ).exceptionally(throwable -> {
+            log.error("Failed to send notification about deleted invite link in message {}.", message.getIdLong());
+            return null;
+        });
+
+    }
+
+    @Override
+    public FeatureEnum getFeature() {
+        return ModerationFeatures.INVITE_FILTER;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.HIGH;
+    }
+}

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

@@ -1,4 +1,4 @@
-package dev.sheldan.abstracto.moderation.listener;
+package dev.sheldan.abstracto.moderation.listener.async;
 
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncMessageDeletedListener;

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

@@ -1,4 +1,4 @@
-package dev.sheldan.abstracto.moderation.listener;
+package dev.sheldan.abstracto.moderation.listener.async;
 
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncMessageTextUpdatedListener;

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/repository/AllowedInviteLinkRepository.java

@@ -0,0 +1,20 @@
+package dev.sheldan.abstracto.moderation.repository;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.moderation.models.database.AllowedInviteLink;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.QueryHints;
+import org.springframework.stereotype.Repository;
+
+import javax.persistence.QueryHint;
+import java.util.Optional;
+
+@Repository
+public interface AllowedInviteLinkRepository extends JpaRepository<AllowedInviteLink, Long> {
+
+    @QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
+    Optional<AllowedInviteLink> findByCodeAndServer(String code, AServer server);
+
+    @QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
+    Optional<AllowedInviteLink> findByCodeAndServer_Id(String code, Long serverId);
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/repository/FilteredInviteLinkRepository.java

@@ -0,0 +1,27 @@
+package dev.sheldan.abstracto.moderation.repository;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.moderation.models.database.FilteredInviteLink;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.QueryHints;
+import org.springframework.stereotype.Repository;
+
+import javax.persistence.QueryHint;
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface FilteredInviteLinkRepository extends JpaRepository<FilteredInviteLink, Long> {
+    @QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
+    Optional<FilteredInviteLink> findByCodeAndServer(String code, AServer server);
+
+    @QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
+    Optional<FilteredInviteLink> findByCodeAndServer_Id(String code, Long serverId);
+
+    void deleteByServer_Id(Long serverId);
+
+    void deleteByCodeAndServer_Id(String code, Long serverId);
+
+    List<FilteredInviteLink> findAllByServer_IdOrderByUsesDesc(Long serverId, Pageable pageable);
+}

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

@@ -7,7 +7,7 @@ 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.features.ModerationFeatures;
-import dev.sheldan.abstracto.moderation.config.features.ModerationMode;
+import dev.sheldan.abstracto.moderation.config.features.mode.ModerationMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.ModerationPostTarget;
 import dev.sheldan.abstracto.templating.model.MessageToSend;
 import dev.sheldan.abstracto.templating.service.TemplateService;

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

@@ -0,0 +1,112 @@
+package dev.sheldan.abstracto.moderation.service;
+
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.moderation.exception.InvalidInviteException;
+import dev.sheldan.abstracto.moderation.models.database.FilteredInviteLink;
+import dev.sheldan.abstracto.moderation.service.management.AllowedInviteLinkManagement;
+import dev.sheldan.abstracto.moderation.service.management.FilteredInviteLinkManagement;
+import net.dv8tion.jda.api.entities.Message;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@Component
+public class InviteLinkFilterServiceBean implements InviteLinkFilterService {
+
+    @Autowired
+    private AllowedInviteLinkManagement allowedInviteLinkManagement;
+
+    @Autowired
+    private FilteredInviteLinkManagement filteredInviteLinkManagement;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    private static final Pattern INVITE_CODE_PATTERN = Pattern.compile("(?<code>[a-z0-9-]+)", Pattern.CASE_INSENSITIVE);
+
+    @Override
+    public boolean isCodeFiltered(String code, ServerUser serverUser) {
+        return !isCodeAllowed(code, serverUser);
+    }
+
+    @Override
+    public boolean isCodeAllowed(String code, ServerUser serverUser) {
+        return allowedInviteLinkManagement.allowedInviteLinkExists(serverUser, code);
+    }
+
+    @Override
+    public boolean isCodeAllowed(String code, Long serverId) {
+        return allowedInviteLinkManagement.allowedInviteLinkExists(serverId, code);
+    }
+
+    @Override
+    public void storeFilteredInviteLinkUsage(String code, ServerUser serverUser) {
+        Optional<FilteredInviteLink> inviteLinkOptional = filteredInviteLinkManagement.findInviteLinkViaCode(serverUser.getServerId(), code);
+        if(inviteLinkOptional.isPresent()) {
+            inviteLinkOptional.ifPresent(filteredInviteLink -> filteredInviteLink.setUses(filteredInviteLink.getUses() + 1));
+        } else {
+            AServer server = serverManagementService.loadServer(serverUser.getServerId());
+            filteredInviteLinkManagement.createFilteredInviteLink(server, code);
+        }
+    }
+
+    @Override
+    public void allowInvite(String invite, Long serverId) {
+        String inviteCode = extractCode(invite);
+        if(isCodeAllowed(inviteCode, serverId)) {
+            return;
+        }
+        AServer server = serverManagementService.loadServer(serverId);
+        allowedInviteLinkManagement.createAllowedInviteLink(server, inviteCode);
+    }
+
+    private String extractCode(String invite) {
+        Matcher matcher = Message.INVITE_PATTERN.matcher(invite);
+        String inviteCode;
+        if(matcher.find()) {
+            inviteCode = matcher.group("code");
+        } else {
+            Matcher codeOnlyMatcher = INVITE_CODE_PATTERN.matcher(invite);
+            if(codeOnlyMatcher.find()) {
+                inviteCode = codeOnlyMatcher.group("code");
+            } else {
+                throw new InvalidInviteException("Invalid invite was provided.");
+            }
+        }
+        return inviteCode;
+    }
+
+    @Override
+    public void disAllowInvite(String invite, Long serverId) {
+        String inviteCode = extractCode(invite);
+        AServer server = serverManagementService.loadServer(serverId);
+        allowedInviteLinkManagement.removeAllowedInviteLink(server, inviteCode);
+    }
+
+    @Override
+    public void clearAllTrackedInviteCodes(Long serverId) {
+        filteredInviteLinkManagement.clearFilteredInviteLinks(serverId);
+    }
+
+    @Override
+    public void clearAllUses(String code, Long serverId) {
+        String inviteCode = extractCode(code);
+        filteredInviteLinkManagement.clearFilteredInviteLink(inviteCode, serverId);
+    }
+
+    @Override
+    public List<FilteredInviteLink> getTopFilteredInviteLinks(Long serverId, Integer count) {
+        return filteredInviteLinkManagement.getTopFilteredInviteLink(serverId, count);
+    }
+
+    @Override
+    public List<FilteredInviteLink> getTopFilteredInviteLinks(Long serverId) {
+        return getTopFilteredInviteLinks(serverId, 5);
+    }
+}

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

@@ -4,7 +4,7 @@ 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.features.ModerationFeatures;
-import dev.sheldan.abstracto.moderation.config.features.ModerationMode;
+import dev.sheldan.abstracto.moderation.config.features.mode.ModerationMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.ModerationPostTarget;
 import dev.sheldan.abstracto.moderation.models.template.commands.KickLogModel;
 import dev.sheldan.abstracto.templating.model.MessageToSend;

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

@@ -12,7 +12,7 @@ import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
-import dev.sheldan.abstracto.moderation.config.features.MutingMode;
+import dev.sheldan.abstracto.moderation.config.features.mode.MutingMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.MutingPostTarget;
 import dev.sheldan.abstracto.moderation.exception.MuteRoleNotSetupException;
 import dev.sheldan.abstracto.moderation.exception.NoMuteFoundException;
@@ -252,7 +252,7 @@ public class MuteServiceBean implements MuteService {
         if(featureModeService.featureModeActive(ModerationFeatures.MUTING, server, MutingMode.MUTE_LOGGING)) {
             log.trace("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);
-            List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, muteLogModel.getServer().getId());
+            List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, server.getId());
             completableFuture = FutureUtils.toSingleFutureGeneric(completableFutures);
         } else {
             completableFuture = CompletableFuture.completedFuture(null);
@@ -338,7 +338,6 @@ public class MuteServiceBean implements MuteService {
                 .mutingUser(mutingMemberFuture.join())
                 .unMutedUser(mutedMemberFuture.join())
                 .guild(guild)
-                .server(mutingServer)
                 .build();
         CompletableFuture<Void> notificationFuture = sendUnMuteLogMessage(unMuteLog, mutingServer);
         return CompletableFuture.allOf(notificationFuture).thenAccept(aVoid ->

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

@@ -7,9 +7,9 @@ import dev.sheldan.abstracto.core.service.*;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
-import dev.sheldan.abstracto.moderation.config.features.WarnDecayMode;
+import dev.sheldan.abstracto.moderation.config.features.mode.WarnDecayMode;
 import dev.sheldan.abstracto.moderation.config.features.WarningDecayFeature;
-import dev.sheldan.abstracto.moderation.config.features.WarningMode;
+import dev.sheldan.abstracto.moderation.config.features.mode.WarningMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.WarnDecayPostTarget;
 import dev.sheldan.abstracto.moderation.config.posttargets.WarningPostTarget;
 import dev.sheldan.abstracto.moderation.models.template.job.WarnDecayLogModel;
@@ -215,7 +215,6 @@ public class WarnServiceBean implements WarnService {
         WarnDecayLogModel warnDecayLogModel = WarnDecayLogModel
                 .builder()
                 .guild(botService.getGuildById(server.getId()))
-                .server(server)
                 .warnings(warnDecayWarnings)
                 .build();
         MessageToSend messageToSend = templateService.renderEmbedTemplate(WARN_DECAY_LOG_TEMPLATE_KEY, warnDecayLogModel);

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

@@ -0,0 +1,48 @@
+package dev.sheldan.abstracto.moderation.service.management;
+
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.moderation.exception.AllowedInviteLinkNotFound;
+import dev.sheldan.abstracto.moderation.models.database.AllowedInviteLink;
+import dev.sheldan.abstracto.moderation.repository.AllowedInviteLinkRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class AllowedInviteLinkManagementBean implements AllowedInviteLinkManagement {
+
+    @Autowired
+    private AllowedInviteLinkRepository repository;
+
+    @Override
+    public AllowedInviteLink createAllowedInviteLink(AServer server, String code) {
+        AllowedInviteLink inviteLink = AllowedInviteLink.builder().code(code).server(server).build();
+        return repository.save(inviteLink);
+    }
+
+    @Override
+    public void removeAllowedInviteLink(AServer server, String code) {
+        AllowedInviteLink existingCode = findAllowedInviteLinkByCode(server, code);
+        repository.delete(existingCode);
+    }
+
+    @Override
+    public AllowedInviteLink findAllowedInviteLinkByCode(AServer server, String code) {
+        return repository.findByCodeAndServer(code, server).orElseThrow(() -> new AllowedInviteLinkNotFound("Allowed invite code not found."));
+    }
+
+    @Override
+    public boolean allowedInviteLinkExists(AServer server, String code) {
+        return repository.findByCodeAndServer(code, server).isPresent();
+    }
+
+    @Override
+    public boolean allowedInviteLinkExists(Long serverId, String code) {
+        return repository.findByCodeAndServer_Id(code, serverId).isPresent();
+    }
+
+    @Override
+    public boolean allowedInviteLinkExists(ServerUser serverUser, String code) {
+        return repository.findByCodeAndServer_Id(code, serverUser.getServerId()).isPresent();
+    }
+}

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

@@ -0,0 +1,64 @@
+package dev.sheldan.abstracto.moderation.service.management;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.moderation.models.database.FilteredInviteLink;
+import dev.sheldan.abstracto.moderation.repository.FilteredInviteLinkRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Optional;
+
+@Component
+public class FilteredInviteLinkManagementBean implements FilteredInviteLinkManagement {
+
+    @Autowired
+    private FilteredInviteLinkRepository repository;
+
+    @Override
+    public FilteredInviteLink createFilteredInviteLink(AServer server, String code) {
+        FilteredInviteLink inviteLink = FilteredInviteLink
+                .builder()
+                .code(code)
+                .server(server)
+                .uses(1L)
+                .build();
+        return repository.save(inviteLink);
+    }
+
+    @Override
+    public Optional<FilteredInviteLink> findInviteLinkViaCode(AServer server, String code) {
+        return repository.findByCodeAndServer(code, server);
+    }
+
+    @Override
+    public Optional<FilteredInviteLink> findInviteLinkViaCode(Long serverId, String code) {
+        return repository.findByCodeAndServer_Id(code, serverId);
+    }
+
+    @Override
+    public void clearFilteredInviteLinks(Long serverId) {
+        repository.deleteByServer_Id(serverId);
+    }
+
+    @Override
+    public void clearFilteredInviteLinks(AServer server) {
+        clearFilteredInviteLinks(server.getId());
+    }
+
+    @Override
+    public void clearFilteredInviteLink(String code, Long serverId) {
+        repository.deleteByCodeAndServer_Id(code, serverId);
+    }
+
+    @Override
+    public void clearFilteredInviteLink(String code, AServer server) {
+        clearFilteredInviteLink(code, server.getId());
+    }
+
+    @Override
+    public List<FilteredInviteLink> getTopFilteredInviteLink(Long serverId, Integer count) {
+        return repository.findAllByServer_IdOrderByUsesDesc(serverId,  PageRequest.of(0, count));
+    }
+}

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

@@ -13,6 +13,7 @@
     <property name="mutingFeature" value="(SELECT id FROM feature WHERE key = 'muting')"/>
     <property name="warnDecayFeature" value="(SELECT id FROM feature WHERE key = 'warnDecay')"/>
     <property name="userNotesFeature" value="(SELECT id FROM feature WHERE key = 'userNotes')"/>
+    <property name="inviteLinkFilteringFeature" value="(SELECT id FROM feature WHERE key = 'inviteFilter')"/>
     <property name="today" value="(SELECT NOW())"/>
 
     <changeSet  author="Sheldan"  id="moderation_moderation-commands">
@@ -131,4 +132,31 @@
         </insert>
     </changeSet>
 
+    <changeSet  author="Sheldan"  id="moderation_inviteFilter-commands">
+        <insert tableName="command">
+            <column name="name" value="allowInvite"/>
+            <column name="module_id" valueComputed="${moderationModule}"/>
+            <column name="feature_id" valueComputed="${inviteLinkFilteringFeature}"/>
+            <column name="created" valueComputed="${today}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="disAllowInvite"/>
+            <column name="module_id" valueComputed="${moderationModule}"/>
+            <column name="feature_id" valueComputed="${inviteLinkFilteringFeature}"/>
+            <column name="created" valueComputed="${today}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="removeTrackedInviteLinks"/>
+            <column name="module_id" valueComputed="${moderationModule}"/>
+            <column name="feature_id" valueComputed="${inviteLinkFilteringFeature}"/>
+            <column name="created" valueComputed="${today}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="showTrackedInviteLinks"/>
+            <column name="module_id" valueComputed="${moderationModule}"/>
+            <column name="feature_id" valueComputed="${inviteLinkFilteringFeature}"/>
+            <column name="created" valueComputed="${today}"/>
+        </insert>
+    </changeSet>
+
 </databaseChangeLog>

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

@@ -13,7 +13,6 @@
             <column name="long_value"  value="90"/>
             <column name="created" valueComputed="${today}"/>
         </insert>
-
     </changeSet>
 
 </databaseChangeLog>

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

@@ -12,6 +12,7 @@
     <property name="loggingFeature" value="(SELECT id FROM feature WHERE key = 'logging')"/>
     <property name="mutingFeature" value="(SELECT id FROM feature WHERE key = 'muting')"/>
     <property name="userNotesFeature" value="(SELECT id FROM feature WHERE key = 'userNotes')"/>
+    <property name="inviteLinkFilteringFeature" value="(SELECT id FROM feature WHERE key = 'inviteFilter')"/>
     <property name="today" value="(SELECT NOW())"/>
     <changeSet author="Sheldan"  id="moderation_default_feature_flag-insertion">
         <insert tableName="default_feature_flag">
@@ -44,5 +45,10 @@
             <column name="feature_id" valueComputed="${userNotesFeature}" />
             <column name="created" valueComputed="${today}"/>
         </insert>
+        <insert tableName="default_feature_flag">
+            <column name="enabled" value="false"/>
+            <column name="feature_id" valueComputed="${inviteLinkFilteringFeature}" />
+            <column name="created" valueComputed="${today}"/>
+        </insert>
     </changeSet>
 </databaseChangeLog>

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

@@ -10,6 +10,7 @@
     <property name="warningsFeature" value="(SELECT id FROM feature WHERE key = 'warnings')"/>
     <property name="warnDecayFeature" value="(SELECT id FROM feature WHERE key = 'warnDecay')"/>
     <property name="mutingFeature" value="(SELECT id FROM feature WHERE key = 'muting')"/>
+    <property name="inviteLinkFilteringFeature" value="(SELECT id FROM feature WHERE key = 'inviteFilter')"/>
     <property name="today" value="(SELECT NOW())"/>
     <changeSet author="Sheldan"  id="moderation_default_feature_mode-insertion">
         <insert tableName="default_feature_mode">
@@ -60,5 +61,17 @@
             <column name="feature_id" valueComputed="${mutingFeature}" />
             <column name="created" valueComputed="${today}"/>
         </insert>
+        <insert tableName="default_feature_mode">
+            <column name="enabled" value="true"/>
+            <column name="mode" value="trackUses"/>
+            <column name="feature_id" valueComputed="${inviteLinkFilteringFeature}" />
+            <column name="created" valueComputed="${today}"/>
+        </insert>
+        <insert tableName="default_feature_mode">
+            <column name="enabled" value="true"/>
+            <column name="mode" value="filterNotifications"/>
+            <column name="feature_id" valueComputed="${inviteLinkFilteringFeature}" />
+            <column name="created" valueComputed="${today}"/>
+        </insert>
     </changeSet>
 </databaseChangeLog>

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

@@ -44,5 +44,9 @@
             <column name="name" value="decayLog"/>
             <column name="created" valueComputed="${today}"/>
         </insert>
+        <insert tableName="default_posttarget">
+            <column name="name" value="inviteDeleteLog"/>
+            <column name="created" valueComputed="${today}"/>
+        </insert>
     </changeSet>
 </databaseChangeLog>

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

@@ -32,5 +32,9 @@
             <column name="key" value="userNotes"/>
             <column name="created" valueComputed="${today}"/>
         </insert>
+        <insert tableName="feature">
+            <column name="key" value="inviteFilter"/>
+            <column name="created" valueComputed="${today}"/>
+        </insert>
     </changeSet>
 </databaseChangeLog>

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/resources/migrations/1.0-moderation/moderation-tables/allowed_invite_link.xml

@@ -0,0 +1,30 @@
+<?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-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
+
+    <changeSet author="Sheldan" id="allowed_invite_link-table">
+        <createTable tableName="allowed_invite_link">
+            <column autoIncrement="true" name="id" type="BIGINT">
+                <constraints nullable="false" primaryKey="true" primaryKeyName="allowed_invite_link_pkey"/>
+            </column>
+            <column name="created" type="TIMESTAMP WITHOUT TIME ZONE"/>
+            <column name="code" type="VARCHAR(32)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="server_id" type="BIGINT">
+                <constraints nullable="false"/>
+            </column>
+        </createTable>
+    </changeSet>
+
+
+    <changeSet author="Sheldan" id="allowed_invite_link-fk_allowed_invite_link_server">
+        <addForeignKeyConstraint baseColumnNames="server_id" baseTableName="allowed_invite_link" constraintName="fk_allowed_invite_link_server" deferrable="false" initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="id" referencedTableName="server" validate="true"/>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/resources/migrations/1.0-moderation/moderation-tables/filtered_invite_link.xml

@@ -0,0 +1,34 @@
+<?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-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
+
+    <changeSet author="Sheldan" id="filtered_invite_link-table">
+        <createTable tableName="filtered_invite_link">
+            <column autoIncrement="true" name="id" type="BIGINT">
+                <constraints nullable="false" primaryKey="true" primaryKeyName="filtered_invite_link_pkey"/>
+            </column>
+            <column name="created" type="TIMESTAMP WITHOUT TIME ZONE"/>
+            <column name="updated" type="TIMESTAMP WITHOUT TIME ZONE"/>
+            <column name="uses" type="BIGINT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="code" type="VARCHAR(32)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="server_id" type="BIGINT">
+                <constraints nullable="false"/>
+            </column>
+        </createTable>
+    </changeSet>
+
+
+    <changeSet author="Sheldan" id="filtered_invite_link-fk_filtered_invite_link_server">
+        <addForeignKeyConstraint baseColumnNames="server_id" baseTableName="filtered_invite_link" constraintName="fk_filtered_invite_link_server" deferrable="false" initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="id" referencedTableName="server" validate="true"/>
+    </changeSet>
+
+</databaseChangeLog>

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

@@ -10,4 +10,6 @@
     <include file="mute_role.xml" relativeToChangelogFile="true"/>
     <include file="user_note.xml" relativeToChangelogFile="true"/>
     <include file="warning.xml" relativeToChangelogFile="true"/>
+    <include file="allowed_invite_link.xml" relativeToChangelogFile="true"/>
+    <include file="filtered_invite_link.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>

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

@@ -35,14 +35,14 @@ public class BanIdTest {
 
     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));
-        Long guildId = parameters.getUserInitiatedContext().getServer().getId();
         when(templateService.renderSimpleTemplate(Ban.BAN_DEFAULT_REASON_TEMPLATE)).thenReturn(REASON);
-        when(parameters.getGuild().getIdLong()).thenReturn(guildId);
+        when(parameters.getGuild().getIdLong()).thenReturn(SERVER_ID);
-        when(banService.banUserViaId(eq(guildId), eq(BANNED_USER_ID), eq(REASON), banLogModelCaptor.capture())).thenReturn(CompletableFuture.completedFuture(null));
+        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());
@@ -55,10 +55,9 @@ public class BanIdTest {
     public void testBanWithReason() {
         String customReason = "reason2";
         CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(BANNED_USER_ID, customReason));
-        Long guildId = parameters.getUserInitiatedContext().getServer().getId();
+        when(parameters.getGuild().getIdLong()).thenReturn(SERVER_ID);
-        when(parameters.getGuild().getIdLong()).thenReturn(guildId);
         when(templateService.renderSimpleTemplate(Ban.BAN_DEFAULT_REASON_TEMPLATE)).thenReturn(REASON);
-        when(banService.banUserViaId(eq(guildId), eq(BANNED_USER_ID), eq(customReason), banLogModelCaptor.capture())).thenReturn(CompletableFuture.completedFuture(null));
+        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());

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/DecayAllWarningsTest.java

@@ -2,6 +2,8 @@ package dev.sheldan.abstracto.moderation.commands;
 
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.service.WarnService;
 import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
@@ -9,6 +11,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnitRunner;
 
 import java.util.concurrent.CompletableFuture;
@@ -24,10 +27,15 @@ public class DecayAllWarningsTest {
     @Mock
     private WarnService warnService;
 
+    @Mock
+    private ServerManagementService serverManagementService;
+
     @Test
     public void testDecayAllWarnings() {
         CommandContext commandContext = CommandTestUtilities.getNoParameters();
-        when(warnService.decayAllWarningsForServer(commandContext.getUserInitiatedContext().getServer())).thenReturn(CompletableFuture.completedFuture(null));
+        AServer server = Mockito.mock(AServer.class);
+        when(serverManagementService.loadServer(commandContext.getGuild())).thenReturn(server);
+        when(warnService.decayAllWarningsForServer(server)).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<CommandResult> result = testUnit.executeAsync(commandContext);
         CommandTestUtilities.checkSuccessfulCompletionAsync(result);
     }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/DecayWarningsTest.java

@@ -2,6 +2,8 @@ package dev.sheldan.abstracto.moderation.commands;
 
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.service.WarnService;
 import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
@@ -10,6 +12,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnitRunner;
 
 import java.util.concurrent.CompletableFuture;
@@ -26,10 +29,15 @@ public class DecayWarningsTest {
     @Mock
     private WarnService warnService;
 
+    @Mock
+    private ServerManagementService serverManagementService;
+
     @Test
     public void testExecuteCommand() {
         CommandContext noParameters = CommandTestUtilities.getNoParameters();
-        when(warnService.decayWarningsForServer(noParameters.getUserInitiatedContext().getServer())).thenReturn(CompletableFuture.completedFuture(null));
+        AServer server = Mockito.mock(AServer.class);
+        when(serverManagementService.loadServer(noParameters.getGuild())).thenReturn(server);
+        when(warnService.decayWarningsForServer(server)).thenReturn(CompletableFuture.completedFuture(null));
         CompletableFuture<CommandResult> result = testUnit.executeAsync(noParameters);
         CommandTestUtilities.checkSuccessfulCompletionAsync(result);
     }

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/DeleteNoteTest.java

@@ -3,6 +3,8 @@ package dev.sheldan.abstracto.moderation.commands;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.command.execution.ResultState;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.service.management.UserNoteManagementService;
 import dev.sheldan.abstracto.templating.service.TemplateService;
 import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
@@ -12,6 +14,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnitRunner;
 
 import java.util.Arrays;
@@ -30,21 +33,28 @@ public class DeleteNoteTest {
     @Mock
     private TemplateService templateService;
 
+    @Mock
+    private ServerManagementService serverManagementService;
+
     private static final Long NOTE_ID = 5L;
 
     @Test
     public void testDeleteExistingNote() {
         CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(NOTE_ID));
-        when(userNoteManagementService.noteExists(NOTE_ID, parameters.getUserInitiatedContext().getServer())).thenReturn(true);
+        AServer server = Mockito.mock(AServer.class);
+        when(serverManagementService.loadServer(parameters.getGuild())).thenReturn(server);
+        when(userNoteManagementService.noteExists(NOTE_ID, server)).thenReturn(true);
         CommandResult result = testUnit.execute(parameters);
         CommandTestUtilities.checkSuccessfulCompletion(result);
-        verify(userNoteManagementService, times(1)).deleteNote(NOTE_ID, parameters.getUserInitiatedContext().getServer());
+        verify(userNoteManagementService, times(1)).deleteNote(NOTE_ID, server);
     }
 
     @Test
     public void testDeleteNotExistingNote() {
         CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(NOTE_ID));
-        when(userNoteManagementService.noteExists(NOTE_ID, parameters.getUserInitiatedContext().getServer())).thenReturn(false);
+        AServer server = Mockito.mock(AServer.class);
+        when(serverManagementService.loadServer(parameters.getGuild())).thenReturn(server);
+        when(userNoteManagementService.noteExists(NOTE_ID, server)).thenReturn(false);
         when(templateService.renderSimpleTemplate(DeleteNote.NOTE_NOT_FOUND_EXCEPTION_TEMPLATE)).thenReturn("error");
         CommandResult result = testUnit.execute(parameters);
         Assert.assertEquals(ResultState.ERROR, result.getResult());

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/MyWarningsTest.java

@@ -2,8 +2,10 @@ package dev.sheldan.abstracto.moderation.commands;
 
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.FeatureFlagService;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.moderation.config.features.WarningDecayFeature;
 import dev.sheldan.abstracto.moderation.models.template.commands.MyWarningsModel;
 import dev.sheldan.abstracto.moderation.service.management.WarnManagementService;
@@ -12,10 +14,7 @@ import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
+import org.mockito.*;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
 import static org.mockito.Mockito.*;
@@ -38,6 +37,9 @@ public class MyWarningsTest {
     @Mock
     private WarningDecayFeature warningDecayFeature;
 
+    @Mock
+    private UserInServerManagementService userInServerManagementService;
+
     @Captor
     private ArgumentCaptor<MyWarningsModel> argumentCaptor;
 
@@ -45,9 +47,11 @@ public class MyWarningsTest {
     public void testExecuteMyWarningsCommand() {
         CommandContext noParameter = CommandTestUtilities.getNoParameters();
         Long activeWarnCount = 8L;
-        when(warnManagementService.getActiveWarnsForUser(noParameter.getUserInitiatedContext().getAUserInAServer())).thenReturn(activeWarnCount);
+        AUserInAServer aUserInAServer = Mockito.mock(AUserInAServer.class);
+        when(userInServerManagementService.loadUser(noParameter.getAuthor())).thenReturn(aUserInAServer);
+        when(warnManagementService.getActiveWarnsForUser(aUserInAServer)).thenReturn(activeWarnCount);
         Long totalWarnCount = 10L;
-        when(warnManagementService.getTotalWarnsForUser(noParameter.getUserInitiatedContext().getAUserInAServer())).thenReturn(totalWarnCount);
+        when(warnManagementService.getTotalWarnsForUser(aUserInAServer)).thenReturn(totalWarnCount);
         CommandResult result = testUnit.execute(noParameter);
         verify(channelService, times(1)).sendEmbedTemplateInChannel(eq(MyWarnings.MY_WARNINGS_RESPONSE_EMBED_TEMPLATE), argumentCaptor.capture(), eq(noParameter.getChannel()));
         CommandTestUtilities.checkSuccessfulCompletion(result);

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/UserNotesTest.java

@@ -2,8 +2,10 @@ package dev.sheldan.abstracto.moderation.commands;
 
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.moderation.converter.UserNotesConverter;
 import dev.sheldan.abstracto.moderation.models.database.UserNote;
@@ -48,6 +50,9 @@ public class UserNotesTest {
     @Mock
     private UserNotesConverter userNotesConverter;
 
+    @Mock
+    private ServerManagementService serverManagementService;
+
     @Captor
     private ArgumentCaptor<ListNotesModel> captor;
 
@@ -55,7 +60,8 @@ public class UserNotesTest {
     public void testExecuteUserNotesCommandForMember() {
         Member member = Mockito.mock(Member.class);
         CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(member));
-        AUserInAServer userNoteUser = MockUtils.getUserObject(4L, parameters.getUserInitiatedContext().getServer());
+        AServer server = Mockito.mock(AServer.class);
+        AUserInAServer userNoteUser = MockUtils.getUserObject(4L, server);
         when(userInServerManagementService.loadUser(member)).thenReturn(userNoteUser);
         UserNote firstNote = UserNote.builder().build();
         UserNote secondNote = UserNote.builder().build();
@@ -86,7 +92,9 @@ public class UserNotesTest {
         UserNote firstNote = UserNote.builder().build();
         UserNote secondNote = UserNote.builder().build();
         List<UserNote> userNotes = Arrays.asList(firstNote, secondNote);
-        when(userNoteManagementService.loadNotesForServer(parameters.getUserInitiatedContext().getServer())).thenReturn(userNotes);
+        AServer server = Mockito.mock(AServer.class);
+        when(serverManagementService.loadServer(parameters.getGuild())).thenReturn(server);
+        when(userNoteManagementService.loadNotesForServer(server)).thenReturn(userNotes);
         NoteEntryModel firstConvertedNote = NoteEntryModel.builder().build();
         NoteEntryModel secondConvertedNote = NoteEntryModel.builder().build();
         CompletableFuture<List<NoteEntryModel>> convertedNotes = CompletableFuture.completedFuture(Arrays.asList(firstConvertedNote, secondConvertedNote));

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/WarningsTest.java

@@ -4,8 +4,10 @@ import com.jagrosh.jdautilities.commons.waiter.EventWaiter;
 import com.jagrosh.jdautilities.menu.Paginator;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.PaginatorService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.moderation.converter.WarnEntryConverter;
 import dev.sheldan.abstracto.moderation.models.database.Warning;
@@ -45,6 +47,9 @@ public class WarningsTest {
     @Mock
     private PaginatorService paginatorService;
 
+    @Mock
+    private ServerManagementService serverManagementService;
+
     @Mock
     private EventWaiter eventWaiter;
 
@@ -63,7 +68,9 @@ public class WarningsTest {
         WarnEntry secondModelWarning = Mockito.mock(WarnEntry.class);
         List<Warning> warningsToDisplay = Arrays.asList(firstWarning, secondWarning);
         List<WarnEntry> modelWarnings = Arrays.asList(firstModelWarning, secondModelWarning);
-        when(warnManagementService.getAllWarningsOfServer(noParams.getUserInitiatedContext().getServer())).thenReturn(warningsToDisplay);
+        AServer server = Mockito.mock(AServer.class);
+        when(serverManagementService.loadServer(noParams.getGuild())).thenReturn(server);
+        when(warnManagementService.getAllWarningsOfServer(server)).thenReturn(warningsToDisplay);
         when(warnEntryConverter.fromWarnings(warningsToDisplay)).thenReturn(CompletableFuture.completedFuture(modelWarnings));
 
         CompletableFuture<CommandResult> result = testUnit.executeAsync(noParams);

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/invite/AllowInviteTest.java

@@ -0,0 +1,43 @@
+package dev.sheldan.abstracto.moderation.commands.invite;
+
+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.service.InviteLinkFilterServiceBean;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+@RunWith(MockitoJUnitRunner.class)
+public class AllowInviteTest {
+
+    @InjectMocks
+    private AllowInvite testUnit;
+
+    @Mock
+    private InviteLinkFilterServiceBean inviteLinkFilterServiceBean;
+
+    private static final String INVITE_STRING = "invite";
+
+    @Test
+    public void testExecuteCommand() {
+        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(INVITE_STRING));
+        CommandResult result = testUnit.execute(parameters);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+        verify(inviteLinkFilterServiceBean, times(1)).allowInvite(INVITE_STRING, parameters.getGuild().getIdLong());
+    }
+
+    @Test
+    public void validateCommand() {
+        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
+    }
+
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/invite/DisAllowInviteTest.java

@@ -0,0 +1,43 @@
+package dev.sheldan.abstracto.moderation.commands.invite;
+
+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.service.InviteLinkFilterServiceBean;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+@RunWith(MockitoJUnitRunner.class)
+public class DisAllowInviteTest {
+
+    @InjectMocks
+    private DisAllowInvite testUnit;
+
+    @Mock
+    private InviteLinkFilterServiceBean inviteLinkFilterServiceBean;
+
+    private static final String INVITE_STRING = "invite";
+
+    @Test
+    public void testExecuteCommand() {
+        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(INVITE_STRING));
+        CommandResult result = testUnit.execute(parameters);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+        verify(inviteLinkFilterServiceBean, times(1)).disAllowInvite(INVITE_STRING, parameters.getGuild().getIdLong());
+    }
+
+    @Test
+    public void validateCommand() {
+        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
+    }
+
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/invite/RemoveTrackedInviteLinksTest.java

@@ -0,0 +1,51 @@
+package dev.sheldan.abstracto.moderation.commands.invite;
+
+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.service.InviteLinkFilterService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RemoveTrackedInviteLinksTest {
+
+    @InjectMocks
+    private RemoveTrackedInviteLinks testUnit;
+
+    @Mock
+    private InviteLinkFilterService inviteLinkFilterService;
+
+    private static final String INVITE_STRING = "invite";
+
+    @Test
+    public void testExecuteCommandNoParameter() {
+        CommandContext parameters = CommandTestUtilities.getNoParameters();
+        CommandResult result = testUnit.execute(parameters);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+        verify(inviteLinkFilterService, times(1)).clearAllTrackedInviteCodes(parameters.getGuild().getIdLong());
+    }
+
+    @Test
+    public void testExecuteCommandForSpecificInvite() {
+        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(INVITE_STRING));
+        CommandResult result = testUnit.execute(parameters);
+        CommandTestUtilities.checkSuccessfulCompletion(result);
+        verify(inviteLinkFilterService, times(1)).clearAllUses(INVITE_STRING, parameters.getGuild().getIdLong());
+    }
+
+    @Test
+    public void validateCommand() {
+        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
+    }
+
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/invite/ShowTrackedInviteLinksTest.java

@@ -0,0 +1,71 @@
+package dev.sheldan.abstracto.moderation.commands.invite;
+
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
+import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
+import dev.sheldan.abstracto.moderation.models.database.FilteredInviteLink;
+import dev.sheldan.abstracto.moderation.models.template.commands.TrackedInviteLinksModel;
+import dev.sheldan.abstracto.moderation.service.InviteLinkFilterService;
+import dev.sheldan.abstracto.templating.model.MessageToSend;
+import dev.sheldan.abstracto.templating.service.TemplateService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.concurrent.CompletableFuture;
+
+import static dev.sheldan.abstracto.moderation.commands.invite.ShowTrackedInviteLinks.TRACKED_INVITE_LINKS_EMBED_TEMPLATE_KEY;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ShowTrackedInviteLinksTest {
+
+    @InjectMocks
+    private ShowTrackedInviteLinks testUnit;
+
+    @Mock
+    private InviteLinkFilterService inviteLinkFilterService;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Mock
+    private TemplateService templateService;
+
+    @Test
+    public void testExecuteCommandNoParameter() {
+        CommandContext parameters = CommandTestUtilities.getNoParameters();
+        FilteredInviteLink filteredInviteLink = Mockito.mock(FilteredInviteLink.class);
+        when(inviteLinkFilterService.getTopFilteredInviteLinks(parameters.getGuild().getIdLong())).thenReturn(Arrays.asList(filteredInviteLink));
+        MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
+        when(templateService.renderEmbedTemplate(eq(TRACKED_INVITE_LINKS_EMBED_TEMPLATE_KEY), any(TrackedInviteLinksModel.class))).thenReturn(messageToSend);
+        when(channelService.sendMessageToSendToChannel(messageToSend, parameters.getChannel())).thenReturn(CommandTestUtilities.messageFutureList());
+        CompletableFuture<CommandResult> resultFuture = testUnit.executeAsync(parameters);
+        CommandTestUtilities.checkSuccessfulCompletionAsync(resultFuture);
+    }
+
+    @Test
+    public void testExecuteCommandAmountParameter() {
+        Integer amount = 4;
+        CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(amount));
+        FilteredInviteLink filteredInviteLink = Mockito.mock(FilteredInviteLink.class);
+        when(inviteLinkFilterService.getTopFilteredInviteLinks(parameters.getGuild().getIdLong(), amount)).thenReturn(Arrays.asList(filteredInviteLink));
+        MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
+        when(templateService.renderEmbedTemplate(eq(TRACKED_INVITE_LINKS_EMBED_TEMPLATE_KEY), any(TrackedInviteLinksModel.class))).thenReturn(messageToSend);
+        when(channelService.sendMessageToSendToChannel(messageToSend, parameters.getChannel())).thenReturn(CommandTestUtilities.messageFutureList());
+        CompletableFuture<CommandResult> resultFuture = testUnit.executeAsync(parameters);
+        CommandTestUtilities.checkSuccessfulCompletionAsync(resultFuture);
+    }
+
+    @Test
+    public void validateCommand() {
+        CommandConfigValidator.validateCommandConfiguration(testUnit.getConfiguration());
+    }
+
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/mute/SetMuteRoleTest.java

@@ -3,7 +3,9 @@ package dev.sheldan.abstracto.moderation.commands.mute;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.models.database.ARole;
+import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.management.RoleManagementService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.service.management.MuteRoleManagementService;
 import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
 import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
@@ -31,6 +33,9 @@ public class SetMuteRoleTest {
     @Mock
     private RoleManagementService roleManagementService;
 
+    @Mock
+    private ServerManagementService serverManagementService;
+
     @Test
     public void testExecuteCommand() {
         Role role = Mockito.mock(Role.class);
@@ -39,8 +44,10 @@ public class SetMuteRoleTest {
         ARole aRole = Mockito.mock(ARole.class);
         when(roleManagementService.findRole(roleId)).thenReturn(aRole);
         CommandContext parameters = CommandTestUtilities.getWithParameters(Arrays.asList(role));
+        AServer server = Mockito.mock(AServer.class);
+        when(serverManagementService.loadServer(parameters.getGuild())).thenReturn(server);
         CommandResult result = testUnit.execute(parameters);
-        verify(muteRoleManagementService, times(1)).setMuteRoleForServer(parameters.getUserInitiatedContext().getServer(), aRole);
+        verify(muteRoleManagementService, times(1)).setMuteRoleForServer(server, aRole);
         CommandTestUtilities.checkSuccessfulCompletion(result);
     }
 

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/async/InviteLinkFilterListenerTest.java

@@ -0,0 +1,177 @@
+package dev.sheldan.abstracto.moderation.listener.async;
+
+import dev.sheldan.abstracto.core.execution.result.MessageReceivedListenerResult;
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.service.FeatureModeService;
+import dev.sheldan.abstracto.core.service.PostTargetService;
+import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
+import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
+import dev.sheldan.abstracto.moderation.config.features.mode.InviteFilterMode;
+import dev.sheldan.abstracto.moderation.config.posttargets.InviteFilterPostTarget;
+import dev.sheldan.abstracto.moderation.models.template.listener.InviteDeletedModel;
+import dev.sheldan.abstracto.moderation.service.InviteLinkFilterService;
+import dev.sheldan.abstracto.templating.model.MessageToSend;
+import dev.sheldan.abstracto.templating.service.TemplateService;
+import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.requests.restaction.AuditableRestAction;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static dev.sheldan.abstracto.moderation.listener.async.InviteLinkFilterListener.INVITE_LINK_DELETED_NOTIFICATION_EMBED_TEMPLATE_KEY;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class InviteLinkFilterListenerTest {
+
+    @InjectMocks
+    private InviteLinkFilterListener testUnit;
+
+    @Mock
+    private InviteLinkFilterService inviteLinkFilterService;
+
+    @Mock
+    private FeatureModeService featureModeService;
+
+    @Mock
+    private PostTargetService postTargetService;
+
+    @Mock
+    private TemplateService templateService;
+
+    @Mock
+    private Message message;
+
+    @Mock
+    private User author;
+
+    @Mock
+    private TextChannel textChannel;
+
+    @Mock
+    private Guild guild;
+
+    private static final Long SERVER_ID = 1L;
+    private static final Long CHANNEL_ID = 2L;
+    private static final Long USER_ID = 3L;
+    private static final Long MESSAGE_ID = 4L;
+    private static final String INVITE_CODE = "asdf";
+    private static final String INVITE_LINK = "discord.gg/" + INVITE_CODE;
+
+    @Test
+    public void testExecutionWithNoInvite() {
+        when(message.getContentRaw()).thenReturn("text");
+        setupBasicMessage();
+        MessageReceivedListenerResult result = testUnit.execute(message);
+        Assert.assertEquals(MessageReceivedListenerResult.PROCESSED, result);
+    }
+
+    @Test
+    public void testExecutionWithOneAllowedInvite() {
+        when(message.getContentRaw()).thenReturn(INVITE_LINK);
+        when(inviteLinkFilterService.isCodeFiltered(eq(INVITE_CODE), any(ServerUser.class))).thenReturn(false);
+        setupBasicMessage();
+        MessageReceivedListenerResult result = testUnit.execute(message);
+        Assert.assertEquals(MessageReceivedListenerResult.PROCESSED, result);
+    }
+
+    @Test
+    public void testExecutionWithOneNotAllowedInviteNoTrackNoNotification() {
+        when(message.getContentRaw()).thenReturn(INVITE_LINK);
+        AuditableRestAction auditableRestAction = Mockito.mock(AuditableRestAction.class);
+        when(message.delete()).thenReturn(auditableRestAction);
+        when(inviteLinkFilterService.isCodeFiltered(eq(INVITE_CODE), any(ServerUser.class))).thenReturn(true);
+        when(featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, SERVER_ID, InviteFilterMode.TRACK_USES)).thenReturn(false);
+        when(featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, SERVER_ID, InviteFilterMode.FILTER_NOTIFICATIONS)).thenReturn(false);
+        setupBasicMessage();
+        MessageReceivedListenerResult result = testUnit.execute(message);
+        Assert.assertEquals(MessageReceivedListenerResult.DELETED, result);
+    }
+
+    @Test
+    public void testExecutionWithOneNotAllowedInviteTrackNoNotification() {
+        when(message.getContentRaw()).thenReturn(INVITE_LINK);
+        AuditableRestAction auditableRestAction = Mockito.mock(AuditableRestAction.class);
+        when(message.delete()).thenReturn(auditableRestAction);
+        when(inviteLinkFilterService.isCodeFiltered(eq(INVITE_CODE), any(ServerUser.class))).thenReturn(true);
+        when(featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, SERVER_ID, InviteFilterMode.TRACK_USES)).thenReturn(true);
+        when(featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, SERVER_ID, InviteFilterMode.FILTER_NOTIFICATIONS)).thenReturn(false);
+        setupBasicMessage();
+        MessageReceivedListenerResult result = testUnit.execute(message);
+        Assert.assertEquals(MessageReceivedListenerResult.DELETED, result);
+        verifyTracking();
+    }
+
+    @Test
+    public void testExecutionWithOneNotAllowedInviteTrackNotification() {
+        when(message.getContentRaw()).thenReturn(INVITE_LINK);
+        AuditableRestAction auditableRestAction = Mockito.mock(AuditableRestAction.class);
+        when(message.delete()).thenReturn(auditableRestAction);
+        when(inviteLinkFilterService.isCodeFiltered(eq(INVITE_CODE), any(ServerUser.class))).thenReturn(true);
+        when(featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, SERVER_ID, InviteFilterMode.TRACK_USES)).thenReturn(true);
+        when(featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, SERVER_ID, InviteFilterMode.FILTER_NOTIFICATIONS)).thenReturn(true);
+        setupForNotification();
+        setupBasicMessage();
+        MessageReceivedListenerResult result = testUnit.execute(message);
+        Assert.assertEquals(MessageReceivedListenerResult.DELETED, result);
+        verifyTracking();
+    }
+
+    @Test
+    public void testExecutionWithOneNotAllowedInviteNoTrackNotification() {
+        when(message.getContentRaw()).thenReturn(INVITE_LINK);
+        AuditableRestAction auditableRestAction = Mockito.mock(AuditableRestAction.class);
+        when(message.delete()).thenReturn(auditableRestAction);
+        when(inviteLinkFilterService.isCodeFiltered(eq(INVITE_CODE), any(ServerUser.class))).thenReturn(true);
+        when(featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, SERVER_ID, InviteFilterMode.TRACK_USES)).thenReturn(false);
+        when(featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, SERVER_ID, InviteFilterMode.FILTER_NOTIFICATIONS)).thenReturn(true);
+        setupForNotification();
+        setupBasicMessage();
+        MessageReceivedListenerResult result = testUnit.execute(message);
+        Assert.assertEquals(MessageReceivedListenerResult.DELETED, result);
+        verify(inviteLinkFilterService, times(0)).storeFilteredInviteLinkUsage(eq(INVITE_CODE), any(ServerUser.class));
+    }
+
+    @Test
+    public void testExecutionWithOneNotAllowedInviteNoTrackNotificationNoPostTarget() {
+        when(message.getContentRaw()).thenReturn(INVITE_LINK);
+        AuditableRestAction auditableRestAction = Mockito.mock(AuditableRestAction.class);
+        when(message.delete()).thenReturn(auditableRestAction);
+        when(inviteLinkFilterService.isCodeFiltered(eq(INVITE_CODE), any(ServerUser.class))).thenReturn(true);
+        when(featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, SERVER_ID, InviteFilterMode.TRACK_USES)).thenReturn(false);
+        when(featureModeService.featureModeActive(ModerationFeatures.INVITE_FILTER, SERVER_ID, InviteFilterMode.FILTER_NOTIFICATIONS)).thenReturn(true);
+        when(postTargetService.postTargetDefinedInServer(InviteFilterPostTarget.INVITE_DELETE_LOG, SERVER_ID)).thenReturn(false);
+        setupBasicMessage();
+        MessageReceivedListenerResult result = testUnit.execute(message);
+        Assert.assertEquals(MessageReceivedListenerResult.DELETED, result);
+        verify(inviteLinkFilterService, times(0)).storeFilteredInviteLinkUsage(eq(INVITE_CODE), any(ServerUser.class));
+        verify(templateService, times(0)).renderEmbedTemplate(eq(INVITE_LINK_DELETED_NOTIFICATION_EMBED_TEMPLATE_KEY), any(InviteDeletedModel.class));
+    }
+
+    private void verifyTracking() {
+        verify(inviteLinkFilterService, times(1)).storeFilteredInviteLinkUsage(eq(INVITE_CODE), any(ServerUser.class));
+    }
+
+    private void setupForNotification() {
+        when(postTargetService.postTargetDefinedInServer(InviteFilterPostTarget.INVITE_DELETE_LOG, SERVER_ID)).thenReturn(true);
+        MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
+        when(templateService.renderEmbedTemplate(eq(INVITE_LINK_DELETED_NOTIFICATION_EMBED_TEMPLATE_KEY), any(InviteDeletedModel.class))).thenReturn(messageToSend);
+        when(postTargetService.sendEmbedInPostTarget(messageToSend, InviteFilterPostTarget.INVITE_DELETE_LOG, SERVER_ID)).thenReturn(CommandTestUtilities.messageFutureList());
+        when(textChannel.getIdLong()).thenReturn(CHANNEL_ID);
+        when(message.getIdLong()).thenReturn(MESSAGE_ID);
+        when(message.getTextChannel()).thenReturn(textChannel);
+    }
+
+    private void setupBasicMessage() {
+        when(message.getAuthor()).thenReturn(author);
+        when(author.getIdLong()).thenReturn(USER_ID);
+        when(message.getGuild()).thenReturn(guild);
+        when(guild.getIdLong()).thenReturn(SERVER_ID);
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/async/JoinLoggerTest.java

@@ -1,10 +1,9 @@
-package dev.sheldan.abstracto.moderation.listener;
+package dev.sheldan.abstracto.moderation.listener.async;
 
 import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.service.BotService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.posttargets.LoggingPostTarget;
-import dev.sheldan.abstracto.moderation.listener.async.JoinLogger;
 import dev.sheldan.abstracto.templating.service.TemplateService;
 import net.dv8tion.jda.api.entities.Member;
 import org.junit.Test;

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/async/JoinMuteListenerTest.java

@@ -1,9 +1,8 @@
-package dev.sheldan.abstracto.moderation.listener;
+package dev.sheldan.abstracto.moderation.listener.async;
 
 import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
-import dev.sheldan.abstracto.moderation.listener.async.JoinMuteListener;
 import dev.sheldan.abstracto.moderation.service.MuteService;
 import dev.sheldan.abstracto.moderation.service.management.MuteManagementService;
 import net.dv8tion.jda.api.entities.Guild;

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/async/LeaveLoggerTest.java

@@ -1,10 +1,9 @@
-package dev.sheldan.abstracto.moderation.listener;
+package dev.sheldan.abstracto.moderation.listener.async;
 
 import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.service.BotService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.posttargets.LoggingPostTarget;
-import dev.sheldan.abstracto.moderation.listener.async.LeaveLogger;
 import dev.sheldan.abstracto.templating.service.TemplateService;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.User;

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/async/MessageDeleteLogListenerTest.java

@@ -1,4 +1,4 @@
-package dev.sheldan.abstracto.moderation.listener;
+package dev.sheldan.abstracto.moderation.listener.async;
 
 import dev.sheldan.abstracto.core.models.cache.CachedAttachment;
 import dev.sheldan.abstracto.core.models.cache.CachedAuthor;

abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/async/MessageEditedListenerTest.java

@@ -1,4 +1,4 @@
-package dev.sheldan.abstracto.moderation.listener;
+package dev.sheldan.abstracto.moderation.listener.async;
 
 import dev.sheldan.abstracto.core.models.cache.CachedAuthor;
 import dev.sheldan.abstracto.core.models.cache.CachedMessage;

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

@@ -6,7 +6,7 @@ import dev.sheldan.abstracto.core.service.BotService;
 import dev.sheldan.abstracto.core.service.FeatureModeService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
-import dev.sheldan.abstracto.moderation.config.features.ModerationMode;
+import dev.sheldan.abstracto.moderation.config.features.mode.ModerationMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.ModerationPostTarget;
 import dev.sheldan.abstracto.templating.model.MessageToSend;
 import dev.sheldan.abstracto.templating.service.TemplateService;

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

@@ -0,0 +1,155 @@
+package dev.sheldan.abstracto.moderation.service;
+
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.moderation.exception.InvalidInviteException;
+import dev.sheldan.abstracto.moderation.models.database.FilteredInviteLink;
+import dev.sheldan.abstracto.moderation.service.management.AllowedInviteLinkManagement;
+import dev.sheldan.abstracto.moderation.service.management.FilteredInviteLinkManagement;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class InviteLinkFilterServiceBeanTest {
+
+    @InjectMocks
+    private InviteLinkFilterServiceBean testUnit;
+
+    @Mock
+    private AllowedInviteLinkManagement allowedInviteLinkManagement;
+
+    @Mock
+    private FilteredInviteLinkManagement filteredInviteLinkManagement;
+
+    @Mock
+    private ServerManagementService serverManagementService;
+
+    @Mock
+    private AServer server;
+
+    @Mock
+    private ServerUser serverUser;
+
+    private static final String INVITE_CODE = "asdf";
+    private static final String FULL_INVITE = "discord.gg/" + INVITE_CODE;
+    private static final Long SERVER_ID = 1L;
+
+    @Test
+    public void testIsCodeAllowedViaId() {
+        when(allowedInviteLinkManagement.allowedInviteLinkExists(SERVER_ID, FULL_INVITE)).thenReturn(true);
+        boolean codeAllowed = testUnit.isCodeAllowed(FULL_INVITE, SERVER_ID);
+        Assert.assertTrue(codeAllowed);
+    }
+
+    @Test
+    public void testIsCodeAllowed() {
+        when(allowedInviteLinkManagement.allowedInviteLinkExists(serverUser, FULL_INVITE)).thenReturn(true);
+        boolean codeAllowed = testUnit.isCodeAllowed(FULL_INVITE, serverUser);
+        Assert.assertTrue(codeAllowed);
+    }
+
+    @Test
+    public void testIsCodeFiltered() {
+        when(allowedInviteLinkManagement.allowedInviteLinkExists(serverUser, FULL_INVITE)).thenReturn(true);
+        boolean codeAllowed = testUnit.isCodeFiltered(FULL_INVITE, serverUser);
+        Assert.assertFalse(codeAllowed);
+    }
+
+    @Test
+    public void testStoreFilteredInviteLinkUsage() {
+        when(serverUser.getServerId()).thenReturn(SERVER_ID);
+        FilteredInviteLink mockedFilteredInviteLink = Mockito.mock(FilteredInviteLink.class);
+        when(mockedFilteredInviteLink.getUses()).thenReturn(1L);
+        when(filteredInviteLinkManagement.findInviteLinkViaCode(SERVER_ID, FULL_INVITE)).thenReturn(Optional.of(mockedFilteredInviteLink));
+        testUnit.storeFilteredInviteLinkUsage(FULL_INVITE, serverUser);
+        verify(mockedFilteredInviteLink, times(1)).setUses(2L);
+    }
+
+    @Test
+    public void testStoreFilteredInviteLinkUsageNotPresent() {
+        when(serverUser.getServerId()).thenReturn(SERVER_ID);
+        when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
+        when(filteredInviteLinkManagement.findInviteLinkViaCode(SERVER_ID, FULL_INVITE)).thenReturn(Optional.empty());
+        testUnit.storeFilteredInviteLinkUsage(FULL_INVITE, serverUser);
+        verify(filteredInviteLinkManagement, times(1)).createFilteredInviteLink(server, FULL_INVITE);
+    }
+
+    @Test
+    public void testAllowInvite() {
+        when(allowedInviteLinkManagement.allowedInviteLinkExists(SERVER_ID, INVITE_CODE)).thenReturn(false);
+        when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
+        testUnit.allowInvite(FULL_INVITE, SERVER_ID);
+        verify(allowedInviteLinkManagement, times(1)).createAllowedInviteLink(server, INVITE_CODE);
+    }
+
+    @Test(expected = InvalidInviteException.class)
+    public void testAllowInviteIllegalInvite() {
+        testUnit.allowInvite("#", SERVER_ID);
+    }
+
+    @Test
+    public void testAllowInviteInviteCode() {
+        when(allowedInviteLinkManagement.allowedInviteLinkExists(SERVER_ID, INVITE_CODE)).thenReturn(false);
+        when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
+        testUnit.allowInvite(INVITE_CODE, SERVER_ID);
+        verify(allowedInviteLinkManagement, times(1)).createAllowedInviteLink(server, INVITE_CODE);
+    }
+
+    @Test
+    public void testAllowInviteAlreadyPresent() {
+        when(allowedInviteLinkManagement.allowedInviteLinkExists(SERVER_ID, INVITE_CODE)).thenReturn(true);
+        testUnit.allowInvite(FULL_INVITE, SERVER_ID);
+        verify(allowedInviteLinkManagement, times(0)).createAllowedInviteLink(any(AServer.class), anyString());
+    }
+
+    @Test
+    public void testDisallowInvite() {
+        when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
+        testUnit.disAllowInvite(FULL_INVITE, SERVER_ID);
+        verify(allowedInviteLinkManagement, times(1)).removeAllowedInviteLink(server, INVITE_CODE);
+    }
+
+    @Test
+    public void testClearAllTrackedInviteCodes() {
+        testUnit.clearAllTrackedInviteCodes(SERVER_ID);
+        verify(filteredInviteLinkManagement, times(1)).clearFilteredInviteLinks(SERVER_ID);
+    }
+
+    @Test
+    public void testClearAllUses() {
+        testUnit.clearAllUses(FULL_INVITE, SERVER_ID);
+        verify(filteredInviteLinkManagement, times(1)).clearFilteredInviteLink(INVITE_CODE, SERVER_ID);
+    }
+
+    @Test
+    public void testGetTopFilteredInviteLinksWithCount() {
+        int count = 4;
+        FilteredInviteLink mockedFilteredInviteLink = Mockito.mock(FilteredInviteLink.class);
+        when(filteredInviteLinkManagement.getTopFilteredInviteLink(SERVER_ID, count)).thenReturn(Arrays.asList(mockedFilteredInviteLink));
+        List<FilteredInviteLink> filteredInviteLinks = testUnit.getTopFilteredInviteLinks(SERVER_ID, count);
+        Assert.assertEquals(1, filteredInviteLinks.size());
+        Assert.assertEquals(mockedFilteredInviteLink, filteredInviteLinks.get(0));
+    }
+
+    @Test
+    public void testGetTopFilteredInviteLinksDefaultCount() {
+        FilteredInviteLink mockedFilteredInviteLink = Mockito.mock(FilteredInviteLink.class);
+        when(filteredInviteLinkManagement.getTopFilteredInviteLink(SERVER_ID, 5)).thenReturn(Arrays.asList(mockedFilteredInviteLink));
+        List<FilteredInviteLink> filteredInviteLinks = testUnit.getTopFilteredInviteLinks(SERVER_ID);
+        Assert.assertEquals(1, filteredInviteLinks.size());
+        Assert.assertEquals(mockedFilteredInviteLink, filteredInviteLinks.get(0));
+    }
+
+}

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

@@ -4,7 +4,7 @@ import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.service.FeatureModeService;
 import dev.sheldan.abstracto.core.service.PostTargetService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
-import dev.sheldan.abstracto.moderation.config.features.ModerationMode;
+import dev.sheldan.abstracto.moderation.config.features.mode.ModerationMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.ModerationPostTarget;
 import dev.sheldan.abstracto.moderation.models.template.commands.KickLogModel;
 import dev.sheldan.abstracto.templating.model.MessageToSend;

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

@@ -12,7 +12,7 @@ import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
-import dev.sheldan.abstracto.moderation.config.features.MutingMode;
+import dev.sheldan.abstracto.moderation.config.features.mode.MutingMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.MutingPostTarget;
 import dev.sheldan.abstracto.moderation.exception.MuteRoleNotSetupException;
 import dev.sheldan.abstracto.moderation.exception.NoMuteFoundException;

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

@@ -6,16 +6,14 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.*;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
-import dev.sheldan.abstracto.moderation.config.features.WarnDecayMode;
+import dev.sheldan.abstracto.moderation.config.features.mode.WarnDecayMode;
 import dev.sheldan.abstracto.moderation.config.features.WarningDecayFeature;
-import dev.sheldan.abstracto.moderation.config.features.WarningMode;
+import dev.sheldan.abstracto.moderation.config.features.mode.WarningMode;
-import dev.sheldan.abstracto.moderation.config.posttargets.WarnDecayPostTarget;
 import dev.sheldan.abstracto.moderation.config.posttargets.WarningPostTarget;
 import dev.sheldan.abstracto.moderation.models.database.Warning;
 import dev.sheldan.abstracto.moderation.models.template.commands.WarnContext;
 import dev.sheldan.abstracto.moderation.models.template.commands.WarnNotification;
 import dev.sheldan.abstracto.moderation.models.template.job.WarnDecayLogModel;
-import dev.sheldan.abstracto.moderation.models.template.job.WarnDecayWarning;
 import dev.sheldan.abstracto.moderation.service.management.WarnManagementService;
 import dev.sheldan.abstracto.templating.model.MessageToSend;
 import dev.sheldan.abstracto.templating.service.TemplateService;
@@ -23,7 +21,6 @@ import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.User;
-import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.*;

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

@@ -0,0 +1,98 @@
+package dev.sheldan.abstracto.moderation.service.management;
+
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.moderation.exception.AllowedInviteLinkNotFound;
+import dev.sheldan.abstracto.moderation.models.database.AllowedInviteLink;
+import dev.sheldan.abstracto.moderation.repository.AllowedInviteLinkRepository;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.*;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Optional;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class AllowedInviteLinkManagementBeanTest {
+
+    @InjectMocks
+    private AllowedInviteLinkManagementBean testUnit;
+
+    @Mock
+    private AllowedInviteLinkRepository repository;
+
+    @Mock
+    private AServer server;
+
+    @Mock
+    private AllowedInviteLink mockedInviteLink;
+
+    private static final Long SERVER_ID = 1L;
+    private static final String INVITE = "invite";
+
+    @Captor
+    private ArgumentCaptor<AllowedInviteLink> linkCaptor;
+
+    @Test
+    public void testCreateAllowedInviteLink() {
+        when(repository.save(linkCaptor.capture())).thenReturn(mockedInviteLink);
+        AllowedInviteLink allowedInviteLink = testUnit.createAllowedInviteLink(server, INVITE);
+        verify(repository, times(1)).save(linkCaptor.capture());
+        Assert.assertEquals(allowedInviteLink, mockedInviteLink);
+        AllowedInviteLink repositoryAllowedInviteLink = linkCaptor.getValue();
+        Assert.assertEquals(server, repositoryAllowedInviteLink.getServer());
+        Assert.assertEquals(INVITE, repositoryAllowedInviteLink.getCode());
+    }
+
+    @Test
+    public void testRemoveAllowedInviteLink() {
+        when(repository.findByCodeAndServer(INVITE, server)).thenReturn(Optional.of(mockedInviteLink));
+        testUnit.removeAllowedInviteLink(server, INVITE);
+        verify(repository, times(1)).delete(mockedInviteLink);
+    }
+
+    @Test(expected = AllowedInviteLinkNotFound.class)
+    public void testRemoveNotPresentAllowedInviteLink() {
+        when(repository.findByCodeAndServer(INVITE, server)).thenReturn(Optional.empty());
+        testUnit.removeAllowedInviteLink(server, INVITE);
+    }
+
+    @Test
+    public void testFindAllowedInviteLinkByCode() {
+        when(repository.findByCodeAndServer(INVITE, server)).thenReturn(Optional.of(mockedInviteLink));
+        AllowedInviteLink allowedInviteLinkByCode = testUnit.findAllowedInviteLinkByCode(server, INVITE);
+        Assert.assertEquals(mockedInviteLink, allowedInviteLinkByCode);
+    }
+
+    @Test(expected = AllowedInviteLinkNotFound.class)
+    public void testFindNotPresentAllowedInviteLinkByCode() {
+        when(repository.findByCodeAndServer(INVITE, server)).thenReturn(Optional.empty());
+        testUnit.findAllowedInviteLinkByCode(server, INVITE);
+    }
+
+    @Test
+    public void testAllowedInviteLinkExists() {
+        when(repository.findByCodeAndServer(INVITE, server)).thenReturn(Optional.of(mockedInviteLink));
+        boolean exists = testUnit.allowedInviteLinkExists(server, INVITE);
+        Assert.assertTrue(exists);
+    }
+
+    @Test
+    public void testAllowedInviteLinkExistsViaId() {
+        when(repository.findByCodeAndServer_Id(INVITE, SERVER_ID)).thenReturn(Optional.of(mockedInviteLink));
+        boolean exists = testUnit.allowedInviteLinkExists(SERVER_ID, INVITE);
+        Assert.assertTrue(exists);
+    }
+
+    @Test
+    public void testAllowedInviteLinkExistsViaServerUser() {
+        ServerUser serverUser = Mockito.mock(ServerUser.class);
+        when(serverUser.getServerId()).thenReturn(SERVER_ID);
+        when(repository.findByCodeAndServer_Id(INVITE, SERVER_ID)).thenReturn(Optional.of(mockedInviteLink));
+        boolean exists = testUnit.allowedInviteLinkExists(serverUser, INVITE);
+        Assert.assertTrue(exists);
+    }
+}

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

@@ -0,0 +1,102 @@
+package dev.sheldan.abstracto.moderation.service.management;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.moderation.models.database.FilteredInviteLink;
+import dev.sheldan.abstracto.moderation.repository.FilteredInviteLinkRepository;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.*;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.data.domain.Pageable;
+
+import java.util.Optional;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class FilteredInviteLinkManagementBeanTest {
+
+    @InjectMocks
+    private FilteredInviteLinkManagementBean testUnit;
+
+    @Mock
+    private FilteredInviteLinkRepository repository;
+
+    @Mock
+    private AServer server;
+
+    @Mock
+    private FilteredInviteLink mockedFilteredLink;
+
+    private static final String INVITE = "invite";
+    private static final Long SERVER_ID = 1L;
+
+    @Captor
+    private ArgumentCaptor<FilteredInviteLink> linkCaptor;
+
+    @Test
+    public void testCreateFilteredInviteLink() {
+        when(repository.save(linkCaptor.capture())).thenReturn(mockedFilteredLink);
+        FilteredInviteLink filteredInviteLink = testUnit.createFilteredInviteLink(server, INVITE);
+        verify(repository, times(1)).save(linkCaptor.capture());
+        Assert.assertEquals(filteredInviteLink, mockedFilteredLink);
+        FilteredInviteLink repositoryFilteredInviteLink = linkCaptor.getValue();
+        Assert.assertEquals(server, repositoryFilteredInviteLink.getServer());
+        Assert.assertEquals(INVITE, repositoryFilteredInviteLink.getCode());
+        Assert.assertEquals(1, repositoryFilteredInviteLink.getUses().intValue());
+    }
+
+    @Test
+    public void testFindInviteLinkViaCode() {
+        when(repository.findByCodeAndServer(INVITE, server)).thenReturn(Optional.of(mockedFilteredLink));
+        Optional<FilteredInviteLink> filteredInviteLinkOptional = testUnit.findInviteLinkViaCode(server, INVITE);
+        Assert.assertTrue(filteredInviteLinkOptional.isPresent());
+        filteredInviteLinkOptional.ifPresent(filteredInviteLink -> Assert.assertEquals(mockedFilteredLink, filteredInviteLink));
+    }
+
+    @Test
+    public void testFindInviteLinkViaCodeById() {
+        when(repository.findByCodeAndServer_Id(INVITE, SERVER_ID)).thenReturn(Optional.of(mockedFilteredLink));
+        Optional<FilteredInviteLink> filteredInviteLinkOptional = testUnit.findInviteLinkViaCode(SERVER_ID, INVITE);
+        Assert.assertTrue(filteredInviteLinkOptional.isPresent());
+        filteredInviteLinkOptional.ifPresent(filteredInviteLink -> Assert.assertEquals(mockedFilteredLink, filteredInviteLink));
+    }
+
+    @Test
+    public void testClearFilteredInviteLinksViaId() {
+        testUnit.clearFilteredInviteLinks(SERVER_ID);
+        verify(repository, times(1)).deleteByServer_Id(SERVER_ID);
+    }
+
+    @Test
+    public void testClearFilteredInviteLinks() {
+        when(server.getId()).thenReturn(SERVER_ID);
+        testUnit.clearFilteredInviteLinks(server);
+        verify(repository, times(1)).deleteByServer_Id(SERVER_ID);
+    }
+
+    @Test
+    public void testClearFilteredInviteLinkViaId() {
+        testUnit.clearFilteredInviteLink(INVITE, SERVER_ID);
+        verify(repository, times(1)).deleteByCodeAndServer_Id(INVITE, SERVER_ID);
+    }
+
+    @Test
+    public void testClearFilteredInviteLink() {
+        when(server.getId()).thenReturn(SERVER_ID);
+        testUnit.clearFilteredInviteLink(INVITE, server);
+        verify(repository, times(1)).deleteByCodeAndServer_Id(INVITE, SERVER_ID);
+    }
+
+    @Test
+    public void testGetTopFilteredInviteLink() {
+        Integer count = 4;
+        testUnit.getTopFilteredInviteLink(SERVER_ID, count);
+        ArgumentCaptor<Pageable> pageableArgumentCaptor = ArgumentCaptor.forClass(Pageable.class);
+        verify(repository, times(1)).findAllByServer_IdOrderByUsesDesc(eq(SERVER_ID), pageableArgumentCaptor.capture());
+        Pageable paginator = pageableArgumentCaptor.getValue();
+        Assert.assertEquals(count.intValue(), paginator.getPageSize());
+        Assert.assertEquals(0, paginator.getPageNumber());
+    }
+}

abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/config/features/InviteFilterFeature.java

@@ -0,0 +1,24 @@
+package dev.sheldan.abstracto.moderation.config.features;
+
+import dev.sheldan.abstracto.core.config.FeatureConfig;
+import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.config.PostTargetEnum;
+import dev.sheldan.abstracto.moderation.config.posttargets.InviteFilterPostTarget;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Component
+public class InviteFilterFeature implements FeatureConfig {
+    @Override
+    public FeatureEnum getFeature() {
+        return ModerationFeatures.INVITE_FILTER;
+    }
+
+    @Override
+    public List<PostTargetEnum> getRequiredPostTargets() {
+        return Arrays.asList(InviteFilterPostTarget.INVITE_DELETE_LOG);
+    }
+
+}

abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/config/features/ModerationFeature.java

@@ -4,6 +4,7 @@ import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.config.FeatureConfig;
 import dev.sheldan.abstracto.core.config.FeatureMode;
 import dev.sheldan.abstracto.core.config.PostTargetEnum;
+import dev.sheldan.abstracto.moderation.config.features.mode.ModerationMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.ModerationPostTarget;
 import org.springframework.stereotype.Component;
 

abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/config/features/ModerationFeatures.java

@@ -5,7 +5,13 @@ import lombok.Getter;
 
 @Getter
 public enum ModerationFeatures implements FeatureEnum {
-    MODERATION("moderation"), WARNING("warnings"), LOGGING("logging"), MUTING("muting"), AUTOMATIC_WARN_DECAY("warnDecay"), USER_NOTES("userNotes");
+    MODERATION("moderation"),
+    WARNING("warnings"),
+    LOGGING("logging"),
+    MUTING("muting"),
+    AUTOMATIC_WARN_DECAY("warnDecay"),
+    USER_NOTES("userNotes"),
+    INVITE_FILTER("inviteFilter");
 
     private final String key;
 

abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/config/features/MutingFeature.java

@@ -4,6 +4,7 @@ import dev.sheldan.abstracto.core.config.FeatureConfig;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.config.FeatureMode;
 import dev.sheldan.abstracto.core.config.PostTargetEnum;
+import dev.sheldan.abstracto.moderation.config.features.mode.MutingMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.MutingPostTarget;
 import org.springframework.stereotype.Component;
 

abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/config/features/WarningDecayFeature.java

@@ -4,6 +4,7 @@ import dev.sheldan.abstracto.core.config.FeatureConfig;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.config.FeatureMode;
 import dev.sheldan.abstracto.core.config.PostTargetEnum;
+import dev.sheldan.abstracto.moderation.config.features.mode.WarnDecayMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.WarnDecayPostTarget;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/config/features/WarningFeature.java

@@ -4,6 +4,7 @@ import dev.sheldan.abstracto.core.config.FeatureConfig;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
 import dev.sheldan.abstracto.core.config.FeatureMode;
 import dev.sheldan.abstracto.core.config.PostTargetEnum;
+import dev.sheldan.abstracto.moderation.config.features.mode.WarningMode;
 import dev.sheldan.abstracto.moderation.config.posttargets.WarningPostTarget;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/config/features/mode/InviteFilterMode.java

@@ -0,0 +1,16 @@
+package dev.sheldan.abstracto.moderation.config.features.mode;
+
+import dev.sheldan.abstracto.core.config.FeatureMode;
+import lombok.Getter;
+
+@Getter
+public enum  InviteFilterMode implements FeatureMode {
+    TRACK_USES("trackUses"), FILTER_NOTIFICATIONS("filterNotifications");
+
+    private final String key;
+
+    InviteFilterMode(String key) {
+        this.key = key;
+    }
+
+}

abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/config/features/mode/ModerationMode.java

@@ -1,4 +1,4 @@
-package dev.sheldan.abstracto.moderation.config.features;
+package dev.sheldan.abstracto.moderation.config.features.mode;
 
 import dev.sheldan.abstracto.core.config.FeatureMode;
 import lombok.Getter;