hammy
/
Enso-Bot
mirror of https://github.com/sgoudham/Enso-Bot.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use Bean Introspection to get AnnotationMetaData and load SlashCommands

Browse Source
java-rewrite
Hammy 3 years ago
parent 4788fa3e8b
commit 30aa9f960c
1 changed files with 67 additions and 95 deletions
Show Stats Download Patch File Download Diff File

150
src/main/java/me/goudham/command/SlashCommandLoader.java
Unescape Escape View File

@ -3,11 +3,12 @@ package me.goudham.command;
import io.micronaut.context.ApplicationContext; import io.micronaut.context.ApplicationContext;
import io.micronaut.context.BeanContext; import io.micronaut.context.BeanContext;
import io.micronaut.core.annotation.AnnotationValue; import io.micronaut.core.annotation.AnnotationValue;
import io.micronaut.inject.BeanDefinition; import io.micronaut.core.beans.BeanIntrospection;
import io.micronaut.inject.qualifiers.Qualifiers; import io.micronaut.core.beans.BeanIntrospector;
import io.micronaut.core.beans.BeanMethod;
import io.micronaut.inject.ExecutableMethod;
import jakarta.inject.Inject; import jakarta.inject.Inject;
import jakarta.inject.Singleton; import jakarta.inject.Singleton;
import java.lang.reflect.Method;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collection; import java.util.Collection;
@ -17,14 +18,12 @@ import java.util.Map;
import java.util.Optional; import java.util.Optional;
import java.util.OptionalDouble; import java.util.OptionalDouble;
import java.util.OptionalInt; import java.util.OptionalInt;
import java.util.stream.Collectors;
import me.goudham.command.annotation.Choice; import me.goudham.command.annotation.Choice;
import me.goudham.command.annotation.Option; import me.goudham.command.annotation.Option;
import me.goudham.command.annotation.SlashCommand; import me.goudham.command.annotation.SlashCommand;
import me.goudham.command.annotation.SubCommand; import me.goudham.command.annotation.SubCommand;
import me.goudham.command.annotation.SubCommandGroup; import me.goudham.command.annotation.SubCommandGroup;
import net.dv8tion.jda.api.events.interaction.SlashCommandEvent; import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
import net.dv8tion.jda.api.interactions.commands.Command;
import net.dv8tion.jda.api.interactions.commands.OptionType; import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData; import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.OptionData; import net.dv8tion.jda.api.interactions.commands.build.OptionData;
@ -36,58 +35,75 @@ import net.dv8tion.jda.internal.utils.tuple.Pair;
@Singleton @Singleton
public class SlashCommandLoader implements CommandLoader { public class SlashCommandLoader implements CommandLoader {
private final BeanContext beanContext; private final BeanContext beanContext;
private final ApplicationContext applicationContext;
@Inject @Inject
public SlashCommandLoader(BeanContext beanContext, ApplicationContext applicationContext) { public SlashCommandLoader(BeanContext beanContext, ApplicationContext applicationContext) {
this.beanContext = beanContext; this.beanContext = beanContext;
this.applicationContext = applicationContext;
} }
@Override @Override
public List<CommandData> loadIntoMapAndReturnCommands(Map<String, Pair<Object, Method>> commandMap) { public List<CommandData> loadIntoMapAndReturnCommands(Map<String, Pair<Object, ExecutableMethod<Object, Object>>> commandMap) {
Collection<BeanDefinition<?>> slashCommandDefinitions = beanContext.getBeanDefinitions(Qualifiers.byStereotype(SlashCommand.class));
Collection<BeanDefinition<?>> subCommandGroupDefinitions = beanContext.getBeanDefinitions(Qualifiers.byStereotype(SubCommandGroup.class));
Collection<BeanDefinition<?>> subCommandDefinitions = beanContext.getBeanDefinitions(Qualifiers.byStereotype(SubCommand.class));
Map<String, CommandData> commandDataMap = new HashMap<>(); Map<String, CommandData> commandDataMap = new HashMap<>();
List<CommandData> commandDataList = new ArrayList<>(); List<CommandData> commandDataList = new ArrayList<>();
Collection<BeanIntrospection<Object>> slashCommandIntrospections = BeanIntrospector.forClassLoader(ClassLoader.getSystemClassLoader()).findIntrospections(SlashCommand.class);
Collection<BeanIntrospection<Object>> subCommandGroupIntrospections = BeanIntrospector.forClassLoader(ClassLoader.getSystemClassLoader()).findIntrospections(SubCommandGroup.class);
for (BeanIntrospection<Object> slashCommandIntrospection : slashCommandIntrospections) {
AnnotationValue<SlashCommand> slashCommand = slashCommandIntrospection.getDeclaredAnnotation(SlashCommand.class);
Collection<BeanMethod<Object, Object>> subCommands = slashCommandIntrospection.getBeanMethods();
for (BeanDefinition<?> slashCommandDefinition : slashCommandDefinitions) {
AnnotationValue<SlashCommand> slashCommand = slashCommandDefinition.getDeclaredAnnotation(SlashCommand.class);
if (slashCommand != null) { if (slashCommand != null) {
String name = slashCommand.stringValue("name").orElseThrow(); String name = slashCommand.stringValue("name").orElseThrow();
String description = slashCommand.stringValue("description").orElseThrow(); String description = slashCommand.stringValue("description").orElseThrow();
boolean isVisible = slashCommand.booleanValue("isVisible").orElseThrow(); boolean isVisible = slashCommand.booleanValue("isVisible").orElseThrow();
String[] subCommandGroups = slashCommand.stringValues("subCommandGroups"); String[] subCommandGroups = slashCommand.stringValues("subCommandGroups");
String[] subCommands = slashCommand.stringValues("subCommands");
CommandData commandData = new CommandData(name, description); CommandData commandData = new CommandData(name, description).setDefaultEnabled(isVisible);
commandData.setDefaultEnabled(isVisible); Arrays.stream(subCommandGroups)
.map(subCommandGroup -> name + "/" + subCommandGroup)
.forEach(subCommandGroupName -> commandDataMap.put(subCommandGroupName, commandData));
if (subCommandGroups.length == 0 && subCommands.length == 0) { boolean noHandleMethod = slashCommandIntrospection.getBeanMethods().stream().noneMatch(method -> method.getName().equals("handle"));
if (subCommands.size() > 1 && !noHandleMethod) {
throw new RuntimeException("Cannot Have Main Command And Sub Commands In " + slashCommandIntrospection);
}
if (subCommandGroups.length < 1 && !noHandleMethod) {
List<OptionData> optionData = loadOptions(slashCommand); List<OptionData> optionData = loadOptions(slashCommand);
if (optionData != null) commandData.addOptions(optionData); if (optionData != null) commandData.addOptions(optionData);
storeIntoCommandMap(commandMap, slashCommandDefinition, name, "handle"); storeIntoCommandMap(commandMap, slashCommandIntrospection, name, "handle");
commandDataMap.put(name, commandData);
} else { } else {
Arrays.stream(subCommandGroups) List<SubcommandData> subCommandList = new ArrayList<>();
.map(subCommandGroup -> name + "/" + subCommandGroup)
.forEach(subCommandGroupName -> commandDataMap.put(subCommandGroupName, commandData)); for (BeanMethod<Object, Object> subCommandMethod : subCommands) {
Arrays.stream(subCommands) AnnotationValue<SubCommand> subCommand = subCommandMethod.getDeclaredAnnotation(SubCommand.class);
.map(subCommand -> name + "/" + subCommand) if (subCommand != null) {
.forEach(subCommandName -> commandDataMap.put(subCommandName, commandData)); String subCommandName = subCommand.stringValue("name").orElseThrow();
String subCommandDescription = subCommand.stringValue("description").orElseThrow();
List<OptionData> optionDataList = loadOptions(subCommand);
SubcommandData subcommandData = new SubcommandData(subCommandName, subCommandDescription);
if (optionDataList != null) subcommandData.addOptions(optionDataList);
subCommandList.add(subcommandData);
String subCommandPath = name + "/" + subCommandName;
storeIntoCommandMap(commandMap, slashCommandIntrospection, subCommandPath, subCommandMethod.getName());
}
} }
commandData.addSubcommands(subCommandList);
}
commandDataList.add(commandData); commandDataList.add(commandData);
} else { } else {
throw new RuntimeException("Slash Command Annotation For " + slashCommandDefinition + " Was Null"); throw new RuntimeException("Slash Command Annotation For " + slashCommandIntrospection + " Was Null");
} }
} }
for (BeanDefinition<?> subCommandGroupDefinition : subCommandGroupDefinitions) { for (BeanIntrospection<Object> subCommandGroupIntrospection : subCommandGroupIntrospections) {
AnnotationValue<SubCommandGroup> subCommandGroup = subCommandGroupDefinition.getDeclaredAnnotation(SubCommandGroup.class); AnnotationValue<SubCommandGroup> subCommandGroup = subCommandGroupIntrospection.getDeclaredAnnotation(SubCommandGroup.class);
Collection<BeanMethod<Object, Object>> subCommands = subCommandGroupIntrospection.getBeanMethods();
if (subCommandGroup != null) { if (subCommandGroup != null) {
String parent = subCommandGroup.stringValue("parent").orElseThrow(); String parent = subCommandGroup.stringValue("parent").orElseThrow();
String name = subCommandGroup.stringValue("name").orElseThrow(); String name = subCommandGroup.stringValue("name").orElseThrow();
@ -97,74 +113,30 @@ public class SlashCommandLoader implements CommandLoader {
CommandData commandData = commandDataMap.get(commandPath); CommandData commandData = commandDataMap.get(commandPath);
SubcommandGroupData subcommandGroupData = new SubcommandGroupData(name, description); SubcommandGroupData subcommandGroupData = new SubcommandGroupData(name, description);
Class<?> beanType = subCommandGroupDefinition.getBeanType();
List<SubcommandData> subCommandList = new ArrayList<>(); List<SubcommandData> subCommandList = new ArrayList<>();
List<Method> subCommands = Arrays.stream(beanType.getDeclaredMethods()) for (BeanMethod<Object, Object> subCommandMethod : subCommands) {
.filter(method -> method.isAnnotationPresent(SubCommand.class)) AnnotationValue<SubCommand> subCommand = subCommandMethod.getDeclaredAnnotation(SubCommand.class);
.collect(Collectors.toList()); if (subCommand != null) {
String subCommandName = subCommand.stringValue("name").orElseThrow();
for (Method subCommand : subCommands) { String subCommandDescription = subCommand.stringValue("description").orElseThrow();
SubCommand annotation = subCommand.getDeclaredAnnotation(SubCommand.class); List<OptionData> optionDataList = loadOptions(subCommand);
String subCommandName = annotation.name();
String subCommandDescription = annotation.description();
List<OptionData> optionDataList = Arrays.stream(annotation.options())
.map(option -> {
OptionData optionData = new OptionData(option.optionType(), option.name(), option.description(), option.isRequired());
List<Command.Choice> choiceDataList = Arrays.stream(option.choices())
.map(choice -> {
int intValue = (int) choice.intValue();
double doubleValue = choice.doubleValue();
String stringValue = choice.stringValue();
Command.Choice choiceData = null;
if (intValue != 0) {
choiceData = new Command.Choice(name, intValue);
} else if (!Double.isNaN(doubleValue)) {
choiceData = new Command.Choice(name, doubleValue);
} else if (!stringValue.isBlank()) {
choiceData = new Command.Choice(name, stringValue);
}
return choiceData;
}).collect(Collectors.toList());
return optionData.addChoices(choiceDataList);
}).collect(Collectors.toList());
SubcommandData subcommandData = new SubcommandData(subCommandName, subCommandDescription); SubcommandData subcommandData = new SubcommandData(subCommandName, subCommandDescription);
subcommandData.addOptions(optionDataList); if (optionDataList != null) subcommandData.addOptions(optionDataList);
subCommandList.add(subcommandData); subCommandList.add(subcommandData);
String subCommandPath = parent + "/" + name + "/" + subCommandName; String subCommandPath = parent + "/" + name + "/" + subCommandName;
storeIntoCommandMap(commandMap, subCommandGroupDefinition, subCommandPath, subCommandName); storeIntoCommandMap(commandMap, subCommandGroupIntrospection, subCommandPath, subCommandMethod.getName());
commandDataMap.put(subCommandPath, commandData); }
} }
subcommandGroupData.addSubcommands(subCommandList); subcommandGroupData.addSubcommands(subCommandList);
commandData.addSubcommandGroups(subcommandGroupData); commandData.addSubcommandGroups(subcommandGroupData);
} else { } else {
throw new RuntimeException("Sub Command Annotation For " + subCommandGroupDefinition + " Was Null"); throw new RuntimeException("SubCommandGroup Annotation For " + subCommandGroupIntrospection + " Was Null");
} }
} }
for (BeanDefinition<?> subCommandDefinition : subCommandDefinitions) {
AnnotationValue<SubCommand> subCommand = subCommandDefinition.getDeclaredAnnotation(SubCommand.class);
if (subCommand != null) {
String commandParent = subCommand.stringValue("commandParent").orElseThrow();
String name = subCommand.stringValue("name").orElseThrow();
String description = subCommand.stringValue("description").orElseThrow();
String commandPath = commandParent + "/" + name;
CommandData commandData = commandDataMap.get(commandPath);
SubcommandData subcommandData = new SubcommandData(name, description);
List<OptionData> optionData = loadOptions(subCommand);
if (optionData != null) subcommandData.addOptions(optionData);
storeIntoCommandMap(commandMap, subCommandDefinition, commandPath, "handle");
commandData.addSubcommands(subcommandData);
} else {
throw new RuntimeException("Sub Command Annotation For " + subCommandDefinition + " Was Null");
}
}
return commandDataList; return commandDataList;
} }
@ -236,17 +208,17 @@ public class SlashCommandLoader implements CommandLoader {
return null; return null;
} }
private void storeIntoCommandMap(Map<String, Pair<Object, Method>> commandMap, BeanDefinition<?> beanDefinition, String commandPath, String methodName) { private void storeIntoCommandMap(Map<String, Pair<Object, ExecutableMethod<Object, Object>>> commandMap, BeanIntrospection<Object> beanIntrospection, String commandPath, String methodName) {
Class<?> clazz = beanDefinition.getBeanType(); Class<Object> clazz = beanIntrospection.getBeanType();
Object bean = applicationContext.getBean(clazz); Object bean = beanContext.getBean(clazz);
Method method = null; ExecutableMethod<Object, Object> executableMethod = null;
try { try {
method = clazz.getMethod(methodName, SlashCommandEvent.class); executableMethod = beanContext.getExecutableMethod(clazz, methodName, SlashCommandEvent.class);
} catch (NoSuchMethodException e) { } catch (NoSuchMethodException e) {
e.printStackTrace(); e.printStackTrace();
} }
commandMap.put(commandPath, new ImmutablePair<>(bean, method)); commandMap.put(commandPath, new ImmutablePair<>(bean, executableMethod));
} }
} }

Write Preview
Loading…
Cancel
Save