Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-06-17 23:43:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
removing database entities from command context
This commit is contained in:
Sheldan
2021-01-23 15:33:00 +01:00
parent fb3ed69650
commit 2a2a3aea70
182 changed files with 2571 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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();
}

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

@@ -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());
}

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

@@ -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());
}

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

@@ -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();
}

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

@@ -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();
}

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

@@ -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());
}

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

@@ -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);
return service.changeText(commandContext.getUserInitiatedContext().getServer(), name, newText)
AServer server = serverManagementService.loadServer(commandContext.getGuild());
return service.changeText(server, name, newText)
.thenApply(aVoid -> CommandResult.fromSuccess());
}

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

@@ -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();
}

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

@@ -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());
}

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

@@ -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();
}

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

@@ -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());
}

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

@@ -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();
}

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

@@ -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());
}

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

@@ -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");
}

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

@@ -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());
}

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

@@ -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());
LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(commandContext.getUserInitiatedContext().getAUserInAServer());
AUserInAServer aUserInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(aUserInAServer);
CompletableFuture<LeaderBoardEntryModel> userRankFuture = converter.fromLeaderBoardEntry(userRank);
futures.add(userRankFuture);
return FutureUtils.toSingleFutureGeneric(futures).thenCompose(aVoid -> {

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

@@ -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

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

@@ -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)

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

@@ -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());
}

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

@@ -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());
}

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

@@ -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());
}

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

@@ -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.ConfigService;
import dev.sheldan.abstracto.core.service.MessageService;
import dev.sheldan.abstracto.core.service.RoleService;
import dev.sheldan.abstracto.core.service.*;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.utils.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);

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

@@ -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)

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

@@ -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);

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

@@ -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);

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

@@ -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();
when(userExperienceService.findLeaderBoardData(context.getUserInitiatedContext().getServer(), expectedPage)).thenReturn(leaderBoard);
LeaderBoard leaderBoard = Mockito.mock(LeaderBoard.class);
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();

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

@@ -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);

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

@@ -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));

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

@@ -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);
}

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

@@ -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();
AChannel channel = context.getUserInitiatedContext().getChannel();
when(userExperienceService.syncUserRolesWithFeedback(server, channel)).thenReturn(CompletableFuture.completedFuture(null));
AServer server = Mockito.mock(AServer.class);
when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
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);
}

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

@@ -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);
}

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

@@ -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);
}

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

@@ -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);
CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, feedBackChannel);
when(userExperienceService.executeActionOnUserExperiencesWithFeedBack(eq(users), eq(feedbackChannel), any())).thenReturn(futuresList);
CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, CHANNEL_ID);
future.join();
verify(experienceRoleManagementService, times(0)).unsetRole(previousExperienceRole);
}

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

@@ -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}

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

@@ -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}

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

@@ -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());
}

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

@@ -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());
}

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

@@ -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())) {
userNoteManagementService.deleteNote(id, commandContext.getUserInitiatedContext().getServer());
AServer server = serverManagementService.loadServer(commandContext.getGuild());
if(userNoteManagementService.noteExists(id, server)) {
userNoteManagementService.deleteNote(id, server);
} else {
// TODO replace with exception
return CommandResult.fromError(templateService.renderSimpleTemplate(NOTE_NOT_FOUND_EXCEPTION_TEMPLATE));

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

@@ -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();

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

@@ -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 -> {

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

@@ -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);

52
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/invite/AllowInvite.java Normal file
View File

@@ -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;
}
}

52
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/invite/DisAllowInvite.java Normal file
View File

@@ -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;
}
}

65
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/invite/RemoveTrackedInviteLinks.java Normal file
View File

@@ -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);
}
}

86
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/invite/ShowTrackedInviteLinks.java Normal file
View File

@@ -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);
}
}

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

@@ -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();
}

114
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/async/InviteLinkFilterListener.java Normal file
View File

@@ -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;
}
}

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

@@ -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;

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

@@ -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;

20
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/repository/AllowedInviteLinkRepository.java Normal file
View File

@@ -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);
}

27
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/repository/FilteredInviteLinkRepository.java Normal file
View File

@@ -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);
}

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

@@ -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;

112
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/InviteLinkFilterServiceBean.java Normal file
View File

@@ -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);
}
}

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

@@ -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;

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

@@ -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 ->

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

@@ -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);

48
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/AllowedInviteLinkManagementBean.java Normal file
View File

@@ -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();
}
}

64
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/FilteredInviteLinkManagementBean.java Normal file
View File

@@ -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));
}
}

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

@@ -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>

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

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

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

@@ -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>

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

@@ -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>

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

@@ -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>

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

@@ -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>

30
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/resources/migrations/1.0-moderation/moderation-tables/allowed_invite_link.xml Normal file
View File

@@ -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>

34
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/resources/migrations/1.0-moderation/moderation-tables/filtered_invite_link.xml Normal file
View File

@@ -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>

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

@@ -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>

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

@@ -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(banService.banUserViaId(eq(guildId), eq(BANNED_USER_ID), eq(REASON), banLogModelCaptor.capture())).thenReturn(CompletableFuture.completedFuture(null));
when(parameters.getGuild().getIdLong()).thenReturn(SERVER_ID);
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(guildId);
when(parameters.getGuild().getIdLong()).thenReturn(SERVER_ID);
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());

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

@@ -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);
}

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

@@ -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);
}

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

@@ -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());

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

@@ -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.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.*;
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);

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

@@ -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));

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

@@ -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);

43
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/invite/AllowInviteTest.java Normal file
View File

@@ -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());
}
}

43
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/invite/DisAllowInviteTest.java Normal file
View File

@@ -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());
}
}

51
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/invite/RemoveTrackedInviteLinksTest.java Normal file
View File

@@ -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());
}
}

71
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/invite/ShowTrackedInviteLinksTest.java Normal file
View File

@@ -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());
}
}

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

@@ -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);
}

177
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/async/InviteLinkFilterListenerTest.java Normal file
View File

@@ -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);
}
}

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

@@ -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;

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

@@ -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;

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

@@ -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;

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

@@ -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;

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

@@ -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;

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

@@ -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;

155
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/InviteLinkFilterServiceBeanTest.java Normal file
View File

@@ -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));
}
}

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

@@ -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;

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

@@ -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;

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

@@ -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.posttargets.WarnDecayPostTarget;
import dev.sheldan.abstracto.moderation.config.features.mode.WarningMode;
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.*;

98
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/AllowedInviteLinkManagementBeanTest.java Normal file
View File

@@ -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);
}
}

102
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/FilteredInviteLinkManagementBeanTest.java Normal file
View File

@@ -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());
}
}

24
abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/config/features/InviteFilterFeature.java Normal file
View File

@@ -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);
}
}

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

@@ -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;

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

@@ -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;

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

@@ -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;

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

@@ -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;

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

@@ -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;

16
abstracto-application/abstracto-modules/moderation/moderation-int/src/main/java/dev/sheldan/abstracto/moderation/config/features/mode/InviteFilterMode.java Normal file
View File

@@ -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;
}
}

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

@@ -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;

Some files were not shown because too many files have changed in this diff Show More