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

I. Don't. Even. Know.

Browse Source
java-rewrite
Hammy 3 years ago
parent 30ca94fd43
commit a900e78472
1 changed files with 115 additions and 49 deletions
Show Stats Download Patch File Download Diff File

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

@ -3,31 +3,37 @@ package me.goudham.command;
import io.micronaut.context.ApplicationContext;
import io.micronaut.context.BeanContext;
import io.micronaut.core.annotation.AnnotationValue;
import io.micronaut.core.annotation.Introspected;
import io.micronaut.inject.BeanDefinition;
import io.micronaut.inject.qualifiers.Qualifiers;
import jakarta.inject.Inject;
import jakarta.inject.Singleton;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.OptionalInt;
import me.goudham.bot.command.ISlashCommand;
import java.util.stream.Collectors;
import me.goudham.command.annotation.Choice;
import me.goudham.command.annotation.Option;
import me.goudham.command.annotation.SlashCommand;
import me.goudham.command.annotation.SubCommand;
import me.goudham.command.annotation.SubCommandGroup;
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.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.OptionData;
import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
import net.dv8tion.jda.api.interactions.commands.build.SubcommandGroupData;
import net.dv8tion.jda.internal.utils.tuple.ImmutablePair;
import net.dv8tion.jda.internal.utils.tuple.Pair;
@Singleton
@Introspected
public class SlashCommandLoader implements CommandLoader {
private final BeanContext beanContext;
private final ApplicationContext applicationContext;
@ -40,80 +46,126 @@ public class SlashCommandLoader implements CommandLoader {
}
@Override
public List<CommandData> loadIntoMapAndReturnCommands(Map<String, ISlashCommand> commandMap) {
Collection<BeanDefinition<ISlashCommand>> beanDefinitions = beanContext.getBeanDefinitions(ISlashCommand.class);
public List<CommandData> loadIntoMapAndReturnCommands(Map<String, Pair<Object, Method>> 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<>();
List<CommandData> commandDataList = new ArrayList<>();
for (BeanDefinition<ISlashCommand> beanDefinition : beanDefinitions) {
AnnotationValue<Annotation> slashCommand = beanDefinition.getDeclaredAnnotation("me.goudham.command.annotation.SlashCommand");
for (BeanDefinition<?> slashCommandDefinition : slashCommandDefinitions) {
AnnotationValue<SlashCommand> slashCommand = slashCommandDefinition.getDeclaredAnnotation(SlashCommand.class);
if (slashCommand != null) {
String name = slashCommand.stringValue("name").orElseThrow();
String description = slashCommand.stringValue("description").orElseThrow();
boolean isVisible = slashCommand.booleanValue("isVisible").orElseThrow();
String[] subCommandGroups = slashCommand.stringValues("subCommandGroups");
String[] subCommands = slashCommand.stringValues("subCommands");
CommandData commandData = new CommandData(name, description);
commandData.setDefaultEnabled(isVisible);
List<SubcommandGroupData> subcommandGroupDataList = loadSubCommandGroups(slashCommand);
List<SubcommandData> subcommandData = loadSubCommands(slashCommand);
if (subCommandGroups.length == 0 && subCommands.length == 0) {
List<OptionData> optionData = loadOptions(slashCommand);
if (subcommandGroupDataList != null) commandData.addSubcommandGroups(subcommandGroupDataList);
if (subcommandData != null) commandData.addSubcommands(subcommandData);
if (optionData != null) commandData.addOptions(optionData);
commandDataList.add(commandData);
commandMap.put(name, applicationContext.getBean(beanDefinition));
storeIntoCommandMap(commandMap, slashCommandDefinition, name, "handle");
commandDataMap.put(name, commandData);
} else {
throw new RuntimeException("Slash Command Annotation For " + beanDefinition + " Was Null");
}
Arrays.stream(subCommandGroups)
.map(subCommandGroup -> name + "/" + subCommandGroup)
.forEach(subCommandGroupName -> commandDataMap.put(subCommandGroupName, commandData));
Arrays.stream(subCommands)
.map(subCommand -> name + "/" + subCommand)
.forEach(subCommandName -> commandDataMap.put(subCommandName, commandData));
}
return commandDataList;
commandDataList.add(commandData);
} else {
throw new RuntimeException("Slash Command Annotation For " + slashCommandDefinition + " Was Null");
}
}
private List<SubcommandGroupData> loadSubCommandGroups(AnnotationValue<?> slashCommand) {
if (slashCommand.contains("subCommandGroups")) {
List<SubcommandGroupData> subcommandGroupDataList = new ArrayList<>();
List<AnnotationValue<SubCommandGroup>> subCommandGroupAnnotations = slashCommand.getAnnotations("subCommandGroups", SubCommandGroup.class);
for (AnnotationValue<SubCommandGroup> subCommandGroup : subCommandGroupAnnotations) {
for (BeanDefinition<?> subCommandGroupDefinition : subCommandGroupDefinitions) {
AnnotationValue<SubCommandGroup> subCommandGroup = subCommandGroupDefinition.getDeclaredAnnotation(SubCommandGroup.class);
if (subCommandGroup != null) {
String parent = subCommandGroup.stringValue("parent").orElseThrow();
String name = subCommandGroup.stringValue("name").orElseThrow();
String description = subCommandGroup.stringValue("description").orElseThrow();
String commandPath = parent + "/" + name;
CommandData commandData = commandDataMap.get(commandPath);
SubcommandGroupData subcommandGroupData = new SubcommandGroupData(name, description);
List<SubcommandData> subcommandData = loadSubCommands(subCommandGroup);
if (subcommandData != null) subcommandGroupData.addSubcommands(subcommandData);
subcommandGroupDataList.add(subcommandGroupData);
Class<?> beanType = subCommandGroupDefinition.getBeanType();
List<SubcommandData> subCommandList = new ArrayList<>();
List<Method> subCommands = Arrays.stream(beanType.getDeclaredMethods())
.filter(method -> method.isAnnotationPresent(SubCommand.class))
.collect(Collectors.toList());
for (Method subCommand : subCommands) {
SubCommand annotation = subCommand.getDeclaredAnnotation(SubCommand.class);
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 subcommandGroupDataList;
}
return choiceData;
}).collect(Collectors.toList());
return optionData.addChoices(choiceDataList);
}).collect(Collectors.toList());
return null;
SubcommandData subcommandData = new SubcommandData(subCommandName, subCommandDescription);
subcommandData.addOptions(optionDataList);
subCommandList.add(subcommandData);
String subCommandPath = parent + "/" + name + "/" + subCommandName;
storeIntoCommandMap(commandMap, subCommandGroupDefinition, subCommandPath, subCommandName);
commandDataMap.put(subCommandPath, commandData);
}
private List<SubcommandData> loadSubCommands(AnnotationValue<?> slashCommand) {
if (slashCommand.contains("subCommands")) {
List<SubcommandData> subcommandDataList = new ArrayList<>();
List<AnnotationValue<SubCommand>> subCommandAnnotations = slashCommand.getAnnotations("subCommands", SubCommand.class);
subcommandGroupData.addSubcommands(subCommandList);
commandData.addSubcommandGroups(subcommandGroupData);
} else {
throw new RuntimeException("Sub Command Annotation For " + subCommandGroupDefinition + " Was Null");
}
}
for (AnnotationValue<SubCommand> subCommand : subCommandAnnotations) {
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;
SubcommandData subCommandData = new SubcommandData(name, description);
CommandData commandData = commandDataMap.get(commandPath);
SubcommandData subcommandData = new SubcommandData(name, description);
List<OptionData> optionData = loadOptions(subCommand);
if (optionData != null) subCommandData.addOptions(optionData);
if (optionData != null) subcommandData.addOptions(optionData);
subcommandDataList.add(subCommandData);
storeIntoCommandMap(commandMap, subCommandDefinition, commandPath, "handle");
commandData.addSubcommands(subcommandData);
} else {
throw new RuntimeException("Sub Command Annotation For " + subCommandDefinition + " Was Null");
}
return subcommandDataList;
}
return null;
return commandDataList;
}
private List<OptionData> loadOptions(AnnotationValue<?> slashCommand) {
@ -183,4 +235,18 @@ public class SlashCommandLoader implements CommandLoader {
return null;
}
private void storeIntoCommandMap(Map<String, Pair<Object, Method>> commandMap, BeanDefinition<?> beanDefinition, String commandPath, String methodName) {
Class<?> clazz = beanDefinition.getBeanType();
Object bean = applicationContext.getBean(clazz);
Method method = null;
try {
method = clazz.getMethod(methodName, SlashCommandEvent.class);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
commandMap.put(commandPath, new ImmutablePair<>(bean, method));
}
}

Write Preview
Loading…
Cancel
Save