Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-04-09 02:09:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AB-54] adding various command parameter handlers

Browse Source 
removing old parameter length validation
This commit is contained in:
Sheldan
2020-10-03 10:31:33 +02:00
parent f0d517af22
commit 0f6f6a1e49
49 changed files with 1506 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/CommandConstants.java Normal file
View File

@@ -0,0 +1,11 @@
package dev.sheldan.abstracto.core.command;
public class CommandConstants {
private CommandConstants() {
}
public static final Integer CORE_HANDLER_PRIORITY = 50;
public static final Integer CUSTOM_HANDLER_PRIORITY = 100;
}

153
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/CommandReceivedHandler.java
View File

@@ -6,37 +6,33 @@ import dev.sheldan.abstracto.core.command.config.ParameterValidator;
import dev.sheldan.abstracto.core.command.config.Parameters;
import dev.sheldan.abstracto.core.command.exception.CommandParameterValidationException;
import dev.sheldan.abstracto.core.command.exception.IncorrectParameterException;
import dev.sheldan.abstracto.core.command.exception.ParameterTooLongException;
import dev.sheldan.abstracto.core.command.handler.CommandParameterHandler;
import dev.sheldan.abstracto.core.command.handler.CommandParameterIterators;
import dev.sheldan.abstracto.core.command.service.CommandManager;
import dev.sheldan.abstracto.core.command.service.CommandService;
import dev.sheldan.abstracto.core.command.service.ExceptionService;
import dev.sheldan.abstracto.core.command.service.PostCommandExecution;
import dev.sheldan.abstracto.core.command.execution.*;
import dev.sheldan.abstracto.core.command.execution.UnParsedCommandParameter;
import dev.sheldan.abstracto.core.Constants;
import dev.sheldan.abstracto.core.exception.MemberNotFoundException;
import dev.sheldan.abstracto.core.exception.RoleNotFoundInDBException;
import dev.sheldan.abstracto.core.models.FullEmote;
import dev.sheldan.abstracto.core.models.FullRole;
import dev.sheldan.abstracto.core.models.database.*;
import dev.sheldan.abstracto.core.service.EmoteService;
import dev.sheldan.abstracto.core.service.RoleService;
import dev.sheldan.abstracto.core.service.management.*;
import dev.sheldan.abstracto.core.models.context.UserInitiatedServerContext;
import dev.sheldan.abstracto.core.utils.ParseUtils;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.*;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Nonnull;
import java.time.Duration;
import java.util.*;
import java.util.stream.Collectors;
import static java.util.Comparator.comparing;
@Service
@Slf4j
@@ -79,6 +75,9 @@ public class CommandReceivedHandler extends ListenerAdapter {
@Autowired
private RoleService roleService;
@Autowired
private List<CommandParameterHandler> parameterHandlers;
@Override
@Transactional
public void onMessageReceived(@Nonnull MessageReceivedEvent event) {
@@ -99,7 +98,7 @@ public class CommandReceivedHandler extends ListenerAdapter {
.userInitiatedContext(userInitiatedContext);
final Command foundCommand;
try {
String contentStripped = event.getMessage().getContentStripped();
String contentStripped = event.getMessage().getContentRaw();
List<String> parameters = Arrays.asList(contentStripped.split(" "));
UnParsedCommandParameter unParsedParameter = new UnParsedCommandParameter(contentStripped);
String commandName = commandManager.getCommandName(parameters.get(0), event.getGuild().getIdLong());
@@ -214,120 +213,42 @@ public class CommandReceivedHandler extends ListenerAdapter {
Iterator<Member> memberIterator = message.getMentionedMembers().iterator();
Iterator<Role> roleIterator = message.getMentionedRolesBag().iterator();
Parameter param = command.getConfiguration().getParameters().get(0);
CommandParameterIterators iterators = new CommandParameterIterators(channelIterator, emoteIterator, memberIterator, roleIterator);
boolean reminderActive = false;
List<CommandParameterHandler> orderedHandlers = parameterHandlers.stream().sorted(comparing(CommandParameterHandler::getPriority)).collect(Collectors.toList());
for (int i = 0; i < unParsedCommandParameter.getParameters().size(); i++) {
if(i < command.getConfiguration().getParameters().size() && !param.isRemainder()) {
param = command.getConfiguration().getParameters().get(i);
} else {
reminderActive = true;
}
String value = unParsedCommandParameter.getParameters().get(i);
if(param.getMaxLength() != null && (value.length() + Constants.PARAMETER_LIMIT) > param.getMaxLength()) {
throw new ParameterTooLongException(command, param.getName(), value.length(), param.getMaxLength());
}
if(i < command.getConfiguration().getParameters().size() && !param.isRemainder()) {
param = command.getConfiguration().getParameters().get(i);
} else {
reminderActive = true;
}
String value = unParsedCommandParameter.getParameters().get(i);
boolean handlerMatched = false;
for (CommandParameterHandler handler : orderedHandlers) {
try {
if(param.getType().equals(Integer.class)){
parsedParameters.add(Integer.parseInt(value));
} else if(param.getType().equals(Double.class)){
parsedParameters.add(Double.parseDouble(value));
} else if(param.getType().equals(Long.class)){
parsedParameters.add(Long.parseLong(value));
} else if(param.getType().equals(TextChannel.class)){
parsedParameters.add(channelIterator.next());
} else if(param.getType().equals(Member.class)) {
if(StringUtils.isNumeric(value)) {
Member memberById = message.getGuild().getMemberById(Long.parseLong(value));
if(memberById == null) {
throw new MemberNotFoundException();
}
parsedParameters.add(memberById);
} else {
parsedParameters.add(memberIterator.next());
}
} else if(param.getType().equals(FullEmote.class)) {
// TODO maybe rework, this fails if two emotes are needed, and the second one is an emote, the first one a default one
// the second one shadows the first one, and there are too little parameters to go of
if (emoteIterator.hasNext()) {
try {
Long emoteId = Long.parseLong(value);
if(emoteManagementService.emoteExists(emoteId)) {
AEmote aEmote = AEmote.builder().emoteId(emoteId).custom(true).build();
FullEmote emote = FullEmote.builder().fakeEmote(aEmote).build();
parsedParameters.add(emote);
}
} catch (Exception ex) {
Emote actualEmote = emoteIterator.next();
AEmote fakeEmote = emoteService.getFakeEmote(actualEmote);
FullEmote emote = FullEmote.builder().fakeEmote(fakeEmote).emote(actualEmote).build();
parsedParameters.add(emote);
}
} else {
try {
Long emoteId = Long.parseLong(value);
if(emoteManagementService.emoteExists(emoteId)) {
// we do not need to load the actual emote, as there is no guarantee that it exists anyway
// there might be multiple emotes with the same emoteId, so we dont have any gain to fetch any of them
AEmote aEmote = AEmote.builder().emoteId(emoteId).custom(true).build();
FullEmote emote = FullEmote.builder().fakeEmote(aEmote).build();
parsedParameters.add(emote);
}
} catch (Exception ex) {
AEmote fakeEmote = emoteService.getFakeEmote(value);
FullEmote emote = FullEmote.builder().fakeEmote(fakeEmote).build();
parsedParameters.add(emote);
}
}
} else if(param.getType().equals(AEmote.class)) {
// TODO maybe rework, this fails if two emotes are needed, and the second one is an emote, the first one a default one
// the second one shadows the first one, and there are too little parameters to go of
if (emoteIterator.hasNext()) {
parsedParameters.add(emoteService.getFakeEmote(emoteIterator.next()));
} else {
parsedParameters.add(emoteService.getFakeEmote(value));
}
} else if(CommandParameterKey.class.isAssignableFrom(param.getType())) {
CommandParameterKey cast = (CommandParameterKey) CommandParameterKey.getEnumFromKey(param.getType(), value);
parsedParameters.add(cast);
} else if(param.getType().equals(FullRole.class)) {
ARole aRole;
if(StringUtils.isNumeric(value)) {
long roleId = Long.parseLong(value);
aRole = roleManagementService.findRoleOptional(roleId).orElseThrow(() -> new RoleNotFoundInDBException(roleId));
} else {
long roleId = roleIterator.next().getIdLong();
aRole = roleManagementService.findRoleOptional(roleId).orElseThrow(() -> new RoleNotFoundInDBException(roleId));
}
Role role = roleService.getRoleFromGuild(aRole);
FullRole fullRole = FullRole.builder().role(aRole).serverRole(role).build();
parsedParameters.add(fullRole);
} else if(param.getType().equals(ARole.class)) {
if(StringUtils.isNumeric(value)) {
long roleId = Long.parseLong(value);
parsedParameters.add(roleManagementService.findRoleOptional(roleId).orElseThrow(() -> new RoleNotFoundInDBException(roleId)));
} else {
long roleId = roleIterator.next().getIdLong();
parsedParameters.add(roleManagementService.findRoleOptional(roleId).orElseThrow(() -> new RoleNotFoundInDBException(roleId)));
}
} else if(param.getType().equals(Boolean.class)) {
parsedParameters.add(Boolean.valueOf(value));
} else if (param.getType().equals(Duration.class)) {
parsedParameters.add(ParseUtils.parseDuration(value));
} else {
if(!reminderActive) {
parsedParameters.add(value);
} else {
if(parsedParameters.isEmpty()) {
parsedParameters.add(value);
} else {
int lastIndex = parsedParameters.size() - 1;
parsedParameters.set(lastIndex, parsedParameters.get(lastIndex) + " " + value);
}
}
if(handler.handles(param.getType())) {
handlerMatched = true;
parsedParameters.add(handler.handle(value, iterators, param.getType(), message));
break;
}
} catch (NoSuchElementException e) {
throw new IncorrectParameterException(command, param.getType(), param.getName());
}
}
if(!handlerMatched) {
if(!reminderActive) {
parsedParameters.add(value);
} else {
if(parsedParameters.isEmpty()) {
parsedParameters.add(value);
} else {
int lastIndex = parsedParameters.size() - 1;
parsedParameters.set(lastIndex, parsedParameters.get(lastIndex) + " " + value);
}
}
}
}
return Parameters.builder().parameters(parsedParameters).build();
}

35
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/AChannelParameterHandler.java Normal file
View File

@@ -0,0 +1,35 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.service.ChannelService;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class AChannelParameterHandler implements CommandParameterHandler {
@Autowired
private TextChannelParameterHandler textChannelParameterHandler;
@Autowired
private ChannelService channelService;
@Override
public boolean handles(Class clazz) {
return clazz.equals(AChannel.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
TextChannel textChannel = (TextChannel) textChannelParameterHandler.handle(input, iterators, clazz, context);
return channelService.getFakeChannelFromTextChannel(textChannel);
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

35
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/AEmoteParameterHandler.java Normal file
View File

@@ -0,0 +1,35 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import dev.sheldan.abstracto.core.models.database.AEmote;
import dev.sheldan.abstracto.core.service.EmoteService;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class AEmoteParameterHandler implements CommandParameterHandler {
@Autowired
private EmoteParameterHandler emoteParameterHandler;
@Autowired
private EmoteService emoteService;
@Override
public boolean handles(Class clazz) {
return clazz.equals(AEmote.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
Emote emote = (Emote) emoteParameterHandler.handle(input, iterators, Emote.class, context);
return emoteService.getFakeEmoteFromEmote(emote);
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

35
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/ARoleParameterHandler.java Normal file
View File

@@ -0,0 +1,35 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.service.RoleService;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.Role;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class ARoleParameterHandler implements CommandParameterHandler {
@Autowired
private RoleParameterHandler roleParameterHandler;
@Autowired
private RoleService roleService;
@Override
public boolean handles(Class clazz) {
return clazz.equals(ARole.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
Role role = (Role) roleParameterHandler.handle(input, iterators, Role.class, context);
return roleService.getFakeRoleFromRole(role);
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

23
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/BooleanParameterHandler.java Normal file
View File

@@ -0,0 +1,23 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.stereotype.Component;
@Component
public class BooleanParameterHandler implements CommandParameterHandler {
@Override
public boolean handles(Class clazz) {
return clazz.equals(Boolean.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
return Boolean.valueOf(input);
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

26
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/CommandKeyParameterHandler.java Normal file
View File

@@ -0,0 +1,26 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import dev.sheldan.abstracto.core.command.execution.CommandParameterKey;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.stereotype.Component;
@Component
public class CommandKeyParameterHandler implements CommandParameterHandler {
@Override
public boolean handles(Class clazz) {
return false;
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
return CommandParameterKey.getEnumFromKey(clazz, input);
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

23
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/DoubleParameterHandler.java Normal file
View File

@@ -0,0 +1,23 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.stereotype.Component;
@Component
public class DoubleParameterHandler implements CommandParameterHandler {
@Override
public boolean handles(Class clazz) {
return clazz.equals(Double.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
return Double.parseDouble(input);
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

26
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/DurationParameterHandler.java Normal file
View File

@@ -0,0 +1,26 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import dev.sheldan.abstracto.core.utils.ParseUtils;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.stereotype.Component;
import java.time.Duration;
@Component
public class DurationParameterHandler implements CommandParameterHandler {
@Override
public boolean handles(Class clazz) {
return clazz.equals(Duration.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
return ParseUtils.parseDuration(input);
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

33
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/EmoteParameterHandler.java Normal file
View File

@@ -0,0 +1,33 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.stereotype.Component;
import java.util.regex.Matcher;
@Component
public class EmoteParameterHandler implements CommandParameterHandler {
@Override
public boolean handles(Class clazz) {
return clazz.equals(Emote.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
Matcher matcher = Message.MentionType.EMOTE.getPattern().matcher(input);
if(matcher.matches()) {
return iterators.getEmoteIterator().next();
} else {
long emoteId = Long.parseLong(input);
return context.getGuild().getEmoteById(emoteId);
}
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

37
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/FullEmoteParameterHandler.java Normal file
View File

@@ -0,0 +1,37 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import dev.sheldan.abstracto.core.models.FullEmote;
import dev.sheldan.abstracto.core.models.database.AEmote;
import dev.sheldan.abstracto.core.service.EmoteService;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class FullEmoteParameterHandler implements CommandParameterHandler {
@Autowired
private EmoteParameterHandler emoteParameterHandler;
@Autowired
private EmoteService emoteService;
@Override
public boolean handles(Class clazz) {
return clazz.equals(FullEmote.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
Emote emote = (Emote) emoteParameterHandler.handle(input, iterators, Emote.class, context);
AEmote aEmote = emoteService.getFakeEmoteFromEmote(emote);
return FullEmote.builder().emote(emote).fakeEmote(aEmote).build();
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

37
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/FullRoleParameterHandler.java Normal file
View File

@@ -0,0 +1,37 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import dev.sheldan.abstracto.core.models.FullRole;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.service.RoleService;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.Role;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class FullRoleParameterHandler implements CommandParameterHandler {
@Autowired
private RoleParameterHandler roleParameterHandler;
@Autowired
private RoleService roleService;
@Override
public boolean handles(Class clazz) {
return clazz.equals(FullRole.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
Role role = (Role) roleParameterHandler.handle(input, iterators, Role.class, context);
ARole aRole = roleService.getFakeRoleFromRole(role);
return FullRole.builder().role(aRole).serverRole(role).build();
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

25
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/IntegerParameterHandler.java Normal file
View File

@@ -0,0 +1,25 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.stereotype.Component;
@Component
public class IntegerParameterHandler implements CommandParameterHandler {
@Override
public boolean handles(Class clazz) {
return clazz.equals(Integer.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
return Integer.parseInt(input);
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

25
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/LongParameterHandler.java Normal file
View File

@@ -0,0 +1,25 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.stereotype.Component;
@Component
public class LongParameterHandler implements CommandParameterHandler {
@Override
public boolean handles(Class clazz) {
return clazz.equals(Long.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
return Long.parseLong(input);
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

33
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/MemberParameterHandler.java Normal file
View File

@@ -0,0 +1,33 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.stereotype.Component;
import java.util.regex.Matcher;
@Component
public class MemberParameterHandler implements CommandParameterHandler {
@Override
public boolean handles(Class clazz) {
return clazz.equals(Member.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
Matcher matcher = Message.MentionType.USER.getPattern().matcher(input);
if(matcher.matches()) {
return iterators.getMemberIterator().next();
} else {
// TODO add handling for names
long emoteId = Long.parseLong(input);
return context.getGuild().getMemberById(emoteId);
}
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

32
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/RoleParameterHandler.java Normal file
View File

@@ -0,0 +1,32 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.Role;
import org.springframework.stereotype.Component;
import java.util.regex.Matcher;
@Component
public class RoleParameterHandler implements CommandParameterHandler {
@Override
public boolean handles(Class clazz) {
return clazz.equals(Role.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
Matcher matcher = Message.MentionType.ROLE.getPattern().matcher(input);
if(matcher.matches()) {
return iterators.getRoleIterator().next();
} else {
long roleId = Long.parseLong(input);
return context.getGuild().getRoleById(roleId);
}
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

32
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/TextChannelParameterHandler.java Normal file
View File

@@ -0,0 +1,32 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.command.CommandConstants;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import org.springframework.stereotype.Component;
import java.util.regex.Matcher;
@Component
public class TextChannelParameterHandler implements CommandParameterHandler {
@Override
public boolean handles(Class clazz) {
return clazz.equals(TextChannel.class);
}
@Override
public Object handle(String input, CommandParameterIterators iterators, Class clazz, Message context) {
Matcher matcher = Message.MentionType.CHANNEL.getPattern().matcher(input);
if(matcher.matches()) {
return iterators.getChannelIterator().next();
} else {
long channelId = Long.parseLong(input);
return context.getGuild().getTextChannelById(channelId);
}
}
@Override
public Integer getPriority() {
return CommandConstants.CORE_HANDLER_PRIORITY;
}
}

15
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/ChannelServiceBean.java
View File

@@ -256,4 +256,19 @@ public class ChannelServiceBean implements ChannelService {
public Optional<TextChannel> getChannelFromAChannel(AChannel channel) {
return botService.getTextChannelFromServerOptional(channel.getServer().getId(), channel.getId());
}
@Override
public AChannel getFakeChannelFromTextChannel(TextChannel textChannel) {
AServer server = AServer
.builder()
.id(textChannel.getIdLong())
.fake(true)
.build();
return AChannel
.builder()
.fake(true)
.id(textChannel.getIdLong())
.server(server)
.build();
}
}

24
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/EmoteServiceBean.java
View File

@@ -4,8 +4,10 @@ import dev.sheldan.abstracto.core.exception.EmoteNotDefinedException;
import dev.sheldan.abstracto.core.models.cache.CachedMessage;
import dev.sheldan.abstracto.core.models.cache.CachedReaction;
import dev.sheldan.abstracto.core.models.database.AEmote;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.DefaultEmoteManagementService;
import dev.sheldan.abstracto.core.service.management.EmoteManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.Guild;
@@ -28,6 +30,9 @@ public class EmoteServiceBean implements EmoteService {
@Autowired
private DefaultEmoteManagementService defaultEmoteManagementService;
@Autowired
private ServerManagementService serverManagementService;
@Override
public boolean isEmoteUsableByBot(Emote emote) {
for (Guild guild : botService.getInstance().getGuilds()) {
@@ -128,7 +133,7 @@ public class EmoteServiceBean implements EmoteService {
public AEmote getFakeEmote(Object object) {
if(object instanceof Emote) {
Emote emote = (Emote) object;
return AEmote.builder().fake(true).emoteKey(emote.getName()).custom(true).animated(emote.isAnimated()).emoteId(emote.getIdLong()).build();
return getFakeEmoteFromEmote(emote);
} else if(object instanceof String) {
String emoteText = (String) object;
return AEmote.builder().fake(true).custom(false).emoteKey(emoteText).build();
@@ -136,4 +141,21 @@ public class EmoteServiceBean implements EmoteService {
throw new IllegalArgumentException("Not possible to convert given object to AEmote.");
}
@Override
public AEmote getFakeEmoteFromEmote(Emote emote) {
AServer server = null;
if(emote.getGuild() != null) {
server = AServer.builder().id(emote.getGuild().getIdLong()).fake(true).build();
}
return AEmote
.builder()
.fake(true)
.emoteKey(emote.getName())
.custom(true)
.animated(emote.isAnimated())
.emoteId(emote.getIdLong())
.serverRef(server)
.build();
}
}

16
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/RoleServiceBean.java
View File

@@ -187,4 +187,20 @@ public class RoleServiceBean implements RoleService {
Member selfMember = jdaRole.getGuild().getSelfMember();
return selfMember.canInteract(jdaRole);
}
@Override
public ARole getFakeRoleFromRole(Role role) {
AServer server = AServer
.builder()
.id(role.getGuild().getIdLong())
.fake(true)
.build();
return ARole
.builder()
.fake(true)
.deleted(false)
.id(role.getIdLong())
.server(server)
.build();
}
}

2
abstracto-application/core/core-impl/src/main/resources/abstracto.properties
View File

@@ -1,5 +1,3 @@
abstracto.startup.synchronize=true
abstracto.parameter.lowerBound=50
abstracto.eventWaiter.threads=10

60
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AChannelParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,60 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.service.ChannelService;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class AChannelParameterHandlerTest {
@InjectMocks
private AChannelParameterHandler testUnit;
@Mock
private TextChannelParameterHandler textChannelParameterHandler;
@Mock
private ChannelService channelService;
@Mock
private CommandParameterIterators iterators;
@Mock
private TextChannel channel;
@Mock
private Message message;
@Mock
private AChannel aChannel;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(AChannel.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testProperChannelMention() {
String input = "test";
when(textChannelParameterHandler.handle(input, iterators, TextChannel.class, message)).thenReturn(channel);
when(channelService.getFakeChannelFromTextChannel(channel)).thenReturn(aChannel);
AChannel parsed = (AChannel) testUnit.handle(input, iterators, TextChannel.class, message);
Assert.assertEquals(aChannel, parsed);
}
}

60
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AEmoteParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,60 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.models.database.AEmote;
import dev.sheldan.abstracto.core.service.EmoteService;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.Message;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class AEmoteParameterHandlerTest {
@InjectMocks
private AEmoteParameterHandler testUnit;
@Mock
private EmoteParameterHandler emoteParameterHandler;
@Mock
private EmoteService emoteService;
@Mock
private CommandParameterIterators iterators;
@Mock
private Emote emote;
@Mock
private Message message;
@Mock
private AEmote aEmote;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(AEmote.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testProperEmoteMention() {
String input = "test";
when(emoteParameterHandler.handle(input, iterators, Emote.class, message)).thenReturn(emote);
when(emoteService.getFakeEmoteFromEmote(emote)).thenReturn(aEmote);
AEmote parsed = (AEmote) testUnit.handle(input, iterators, AEmote.class, message);
Assert.assertEquals(aEmote, parsed);
}
}

61
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/ARoleParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,61 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.models.database.AEmote;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.service.RoleService;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.Role;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class ARoleParameterHandlerTest {
@InjectMocks
private ARoleParameterHandler testUnit;
@Mock
private RoleParameterHandler roleParameterHandler;
@Mock
private RoleService roleService;
@Mock
private CommandParameterIterators iterators;
@Mock
private Role role;
@Mock
private Message message;
@Mock
private ARole aRole;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(ARole.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testProperRoleMention() {
String input = "test";
when(roleParameterHandler.handle(input, iterators, Role.class, message)).thenReturn(role);
when(roleService.getFakeRoleFromRole(role)).thenReturn(aRole);
ARole parsed = (ARole) testUnit.handle(input, iterators, AEmote.class, message);
Assert.assertEquals(aRole, parsed);
}
}

45
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/BooleanParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,45 @@
package dev.sheldan.abstracto.core.command.handler;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class BooleanParameterHandlerTest {
@InjectMocks
private BooleanParameterHandler testUnit;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(Boolean.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testTrueParsing() {
Assert.assertTrue((Boolean)testUnit.handle("true", null, null, null));
}
@Test
public void testAnyOtherText() {
Assert.assertFalse((Boolean)testUnit.handle("test", null, null, null));
}
@Test
public void testNullInput() {
Assert.assertFalse((Boolean)testUnit.handle(null, null, null, null));
}
@Test
public void testEmptyStringAsInput() {
Assert.assertFalse((Boolean)testUnit.handle("", null, null, null));
}
}

55
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DoubleParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,55 @@
package dev.sheldan.abstracto.core.command.handler;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class DoubleParameterHandlerTest {
@InjectMocks
private DoubleParameterHandler testUnit;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(Double.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testSuccessfulParse() {
Assert.assertEquals(5D, testUnit.handle("5", null, null, null));
}
@Test
public void testNegativeNumber() {
Assert.assertEquals(-5D, testUnit.handle("-5", null, null, null));
}
public void testDecimal() {
Assert.assertEquals(3.14D, testUnit.handle("3.14", null, null, null));
}
@Test(expected = NumberFormatException.class)
public void testTextAsInput() {
testUnit.handle("someText", null, null, null);
}
@Test(expected = NullPointerException.class)
public void testNullInput() {
testUnit.handle(null, null, null, null);
}
@Test(expected = NumberFormatException.class)
public void testEmptyStringAsInput() {
testUnit.handle("", null, null, null);
}
}

50
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DurationParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,50 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.exception.DurationFormatException;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.junit.MockitoJUnitRunner;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
@RunWith(MockitoJUnitRunner.class)
public class DurationParameterHandlerTest {
@InjectMocks
private DurationParameterHandler testUnit;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(Duration.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testSimpleParsing() {
Assert.assertEquals(Duration.ofMinutes(1), testUnit.handle("1m", null, null, null));
}
@Test
public void testMoreComplicatedParsing() {
Duration targetDuration = Duration.ofDays(4).plus(5, ChronoUnit.HOURS).plus(5, ChronoUnit.MINUTES);
Assert.assertEquals(targetDuration, testUnit.handle("5m5h4d", null, null, null));
}
@Test(expected = DurationFormatException.class)
public void testNullInput() {
testUnit.handle(null, null, null, null);
}
@Test(expected = DurationFormatException.class)
public void testEmptyStringAsInput() {
testUnit.handle("", null, null, null);
}
}

85
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/EmoteParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,85 @@
package dev.sheldan.abstracto.core.command.handler;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import org.junit.Assert;
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 java.util.List;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class EmoteParameterHandlerTest {
@InjectMocks
private EmoteParameterHandler testUnit;
@Mock
private CommandParameterIterators iterators;
@Mock
private Emote emote;
@Mock
private Message message;
@Mock
private Guild guild;
private static final Long EMOTE_ID = 111111111111111111L;
private static final String EMOTE_NAME = "test";
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(Emote.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testProperEmoteMention() {
oneEmoteInIterator();
String input = getEmoteMention();
Emote parsed = (Emote) testUnit.handle(input, iterators, Emote.class, null);
Assert.assertEquals(parsed, emote);
}
@Test
public void testEmoteById() {
setupMessage();
String input = EMOTE_ID.toString();
Emote parsed = (Emote) testUnit.handle(input, null, Emote.class, message);
Assert.assertEquals(parsed, emote);
}
@Test(expected = NumberFormatException.class)
public void testInvalidEmoteMention() {
String input = "test";
testUnit.handle(input, null, Emote.class, null);
}
private String getEmoteMention() {
return String.format("<:%s:%d>", EMOTE_NAME, EMOTE_ID);
}
private void oneEmoteInIterator() {
List<Emote> emotes = Arrays.asList(emote);
when(iterators.getEmoteIterator()).thenReturn(emotes.iterator());
}
private void setupMessage() {
when(message.getGuild()).thenReturn(guild);
when(guild.getEmoteById(EMOTE_ID)).thenReturn(emote);
}
}

62
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullEmoteParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,62 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.models.FullEmote;
import dev.sheldan.abstracto.core.models.database.AEmote;
import dev.sheldan.abstracto.core.service.EmoteService;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.Message;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class FullEmoteParameterHandlerTest {
@InjectMocks
private FullEmoteParameterHandler testUnit;
@Mock
private EmoteParameterHandler emoteParameterHandler;
@Mock
private EmoteService emoteService;
@Mock
private CommandParameterIterators iterators;
@Mock
private Emote emote;
@Mock
private Message message;
@Mock
private AEmote aEmote;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(FullEmote.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testProperEmoteMention() {
String input = "test";
when(emoteParameterHandler.handle(input, iterators, Emote.class, message)).thenReturn(emote);
when(emoteService.getFakeEmoteFromEmote(emote)).thenReturn(aEmote);
FullEmote parsed = (FullEmote) testUnit.handle(input, iterators, FullEmote.class, message);
Assert.assertEquals(aEmote, parsed.getFakeEmote());
Assert.assertEquals(emote, parsed.getEmote());
}
}

62
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullRoleParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,62 @@
package dev.sheldan.abstracto.core.command.handler;
import dev.sheldan.abstracto.core.models.FullRole;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.service.RoleService;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.Role;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class FullRoleParameterHandlerTest {
@InjectMocks
private FullRoleParameterHandler testUnit;
@Mock
private RoleParameterHandler roleParameterHandler;
@Mock
private RoleService roleService;
@Mock
private CommandParameterIterators iterators;
@Mock
private Role role;
@Mock
private Message message;
@Mock
private ARole aRole;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(FullRole.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testProperEmoteMention() {
String input = "test";
when(roleParameterHandler.handle(input, iterators, Role.class, message)).thenReturn(role);
when(roleService.getFakeRoleFromRole(role)).thenReturn(aRole);
FullRole parsed = (FullRole) testUnit.handle(input, iterators, FullRole.class, message);
Assert.assertEquals(aRole, parsed.getRole());
Assert.assertEquals(role, parsed.getServerRole());
}
}

56
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/IntegerParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,56 @@
package dev.sheldan.abstracto.core.command.handler;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class IntegerParameterHandlerTest {
@InjectMocks
private IntegerParameterHandler testUnit;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(Integer.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testSuccessfulParse() {
Assert.assertEquals(5, testUnit.handle("5", null, null, null));
}
@Test
public void testNegativeNumber() {
Assert.assertEquals(-5, testUnit.handle("-5", null, null, null));
}
@Test(expected = NumberFormatException.class)
public void testDecimal() {
testUnit.handle("3.14", null, null, null);
}
@Test(expected = NumberFormatException.class)
public void testTextAsInput() {
testUnit.handle("someText", null, null, null);
}
@Test(expected = NumberFormatException.class)
public void testNullInput() {
testUnit.handle(null, null, null, null);
}
@Test(expected = NumberFormatException.class)
public void testEmptyStringAsInput() {
testUnit.handle("", null, null, null);
}
}

55
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/LongParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,55 @@
package dev.sheldan.abstracto.core.command.handler;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class LongParameterHandlerTest {
@InjectMocks
private LongParameterHandler testUnit;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(Long.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testSuccessfulParse() {
Assert.assertEquals(5L, testUnit.handle("5", null, null, null));
}
@Test
public void testNegativeNumber() {
Assert.assertEquals(-5L, testUnit.handle("-5", null, null, null));
}
@Test(expected = NumberFormatException.class)
public void testDecimal() {
testUnit.handle("3.14", null, null, null);
}
@Test(expected = NumberFormatException.class)
public void testTextAsInput() {
testUnit.handle("someText", null, null, null);
}
@Test(expected = NumberFormatException.class)
public void testNullInput() {
testUnit.handle(null, null, null, null);
}
@Test(expected = NumberFormatException.class)
public void testEmptyStringAsInput() {
testUnit.handle("", null, null, null);
}
}

82
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/MemberParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,82 @@
package dev.sheldan.abstracto.core.command.handler;
import net.dv8tion.jda.api.entities.*;
import org.junit.Assert;
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 java.util.List;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class MemberParameterHandlerTest {
@InjectMocks
private MemberParameterHandler testUnit;
@Mock
private CommandParameterIterators iterators;
@Mock
private Member member;
@Mock
private Message message;
@Mock
private Guild guild;
private static final Long USER_ID = 111111111111111111L;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(Member.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testProperMemberMention() {
oneMemberInIterator();
String input = getUserMention();
Member parsed = (Member) testUnit.handle(input, iterators, Member.class, null);
Assert.assertEquals(parsed, member);
}
@Test
public void testMemberById() {
setupMessage();
String input = USER_ID.toString();
Member parsed = (Member) testUnit.handle(input, null, Member.class, message);
Assert.assertEquals(parsed, member);
}
@Test(expected = NumberFormatException.class)
public void testInvalidMemberMention() {
String input = "test";
testUnit.handle(input, null, Member.class, null);
}
private String getUserMention() {
return String.format("<@%d>", USER_ID);
}
private void oneMemberInIterator() {
List<Member> members = Arrays.asList(member);
when(iterators.getMemberIterator()).thenReturn(members.iterator());
}
private void setupMessage() {
when(message.getGuild()).thenReturn(guild);
when(guild.getMemberById(USER_ID)).thenReturn(member);
}
}

84
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/RoleParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,84 @@
package dev.sheldan.abstracto.core.command.handler;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.Role;
import org.junit.Assert;
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 java.util.List;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class RoleParameterHandlerTest {
@InjectMocks
private RoleParameterHandler testUnit;
@Mock
private CommandParameterIterators iterators;
@Mock
private Role role;
@Mock
private Message message;
@Mock
private Guild guild;
private static final Long ROLE_ID = 111111111111111111L;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(Role.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testProperRoleMention() {
oneRoleIterator();
String input = getRoleMention();
Role parsed = (Role) testUnit.handle(input, iterators, Role.class, null);
Assert.assertEquals(parsed, role);
}
@Test
public void testRoleById() {
setupMessage();
String input = ROLE_ID.toString();
Role parsed = (Role) testUnit.handle(input, null, Role.class, message);
Assert.assertEquals(parsed, role);
}
@Test(expected = NumberFormatException.class)
public void testInvalidRoleMention() {
String input = "test";
testUnit.handle(input, null, Role.class, null);
}
private String getRoleMention() {
return String.format("<@&%d>", ROLE_ID);
}
private void oneRoleIterator() {
List<Role> members = Arrays.asList(role);
when(iterators.getRoleIterator()).thenReturn(members.iterator());
}
private void setupMessage() {
when(message.getGuild()).thenReturn(guild);
when(guild.getRoleById(ROLE_ID)).thenReturn(role);
}
}

85
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/TextChannelParameterHandlerTest.java Normal file
View File

@@ -0,0 +1,85 @@
package dev.sheldan.abstracto.core.command.handler;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import org.junit.Assert;
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 java.util.List;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class TextChannelParameterHandlerTest {
@InjectMocks
private TextChannelParameterHandler testUnit;
@Mock
private CommandParameterIterators iterators;
@Mock
private TextChannel channel;
@Mock
private Message message;
@Mock
private Guild guild;
private static final Long CHANNEL_ID = 111111111111111111L;
@Test
public void testSuccessfulCondition() {
Assert.assertTrue(testUnit.handles(TextChannel.class));
}
@Test
public void testWrongCondition() {
Assert.assertFalse(testUnit.handles(String.class));
}
@Test
public void testProperChannelMention() {
oneChannelInIterator();
String input = getChannelMention();
TextChannel parsed = (TextChannel) testUnit.handle(input, iterators, TextChannel.class, null);
Assert.assertEquals(parsed, channel);
}
@Test
public void testChannelMentionById() {
setupMessage();
String input = CHANNEL_ID.toString();
TextChannel parsed = (TextChannel) testUnit.handle(input, null, TextChannel.class, message);
Assert.assertEquals(parsed, channel);
}
@Test(expected = NumberFormatException.class)
public void testInvalidChannelMention() {
String input = "test";
testUnit.handle(input, null, TextChannel.class, null);
}
private String getChannelMention() {
return String.format("<#%d>", CHANNEL_ID);
}
private void oneChannelInIterator() {
List<TextChannel> channels = Arrays.asList(channel);
when(iterators.getChannelIterator()).thenReturn(channels.iterator());
}
private void setupMessage() {
when(message.getGuild()).thenReturn(guild);
when(guild.getTextChannelById(CHANNEL_ID)).thenReturn(channel);
}
}