Steven/ModBot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Last Day

Browse Source
This commit is contained in:
Steven Tracey 2023-07-06 12:40:57 -04:00
parent 373a889f95
commit ca5aa87019
4 changed files with 165 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
src/main/java/tech/nevets/modbot/CommandManager.java
View File

@ -1,82 +1,79 @@
package tech.nevets.modbot;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Role;
import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
import net.dv8tion.jda.api.events.message.guild.GuildMessageReceivedEvent;
import tech.nevets.modbot.api.commands.*;
import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
public class CommandManager {
public static final List<ICommand> ALL_COMMANDS = new ArrayList<>();
public static final List<IPrefixCommand> ALL_PREFIX_COMMANDS = new ArrayList<>();
public static final List<ISlashCommand> ALL_SLASH_COMMANDS = new ArrayList<>();
public static void addFromRegistry(List<? extends ICommand> cmds) {
for (ICommand cmd : cmds) {
ALL_COMMANDS.add(cmd);
if (cmd instanceof IPrefixCommand) {
ALL_PREFIX_COMMANDS.add((IPrefixCommand) cmd);
}
if (cmd instanceof ISlashCommand) {
ALL_SLASH_COMMANDS.add((ISlashCommand) cmd);
public boolean hasPermission(Member member, ICommand cmd) {
List<Role> memberRoles = member.getRoles();
int permLevel = 0;
for (Role memberRole : memberRoles) {
switch (memberRole.getName().toLowerCase()) {
case "helper", "1":
if (permLevel < 1) permLevel = 1;
continue;
case "moderator", "mod", "2":
if (permLevel < 2) permLevel = 2;
continue;
case "administrator", "admin", "3":
if (permLevel < 3) permLevel = 3;
continue;
case "owner", "4":
if (permLevel < 4) permLevel = 4;
}
}
return permLevel >= cmd.getPermissionLevel();
}
public void handle(GuildMessageReceivedEvent event) {
String[] split = event.getMessage().getContentRaw()
.replaceFirst("(?i)" + Pattern.quote(CoreBot.CORE_CONFIG.getConfig().getString("bot.prefix")), "")
.split("\\s+");
String invoke = split[0].toLowerCase();
IPrefixCommand cmd = Registry.getPrefixCommand(invoke);
public static void addFromRegistry(CommandRegistry registry) {
ALL_COMMANDS.addAll(registry.getCommands());
ALL_PREFIX_COMMANDS.addAll(registry.getPrefixCommands());
ALL_SLASH_COMMANDS.addAll(registry.getSlashCommands());
}
@Nullable
public static ICommand getCommand(String search) {
String searchLower = search.toLowerCase();
for (ICommand cmd : ALL_COMMANDS) {
if (cmd.getName().equals(searchLower) || cmd.getAliases().contains(searchLower)) {
return cmd;
}
assert event.getMember() != null;
assert cmd != null;
if (!hasPermission(event.getMember(), cmd)) {
event.getMessage().reply("You do not have permission to use this command.").queue();
return;
}
return null;
event.getChannel().sendTyping().queue();
List<String> args = Arrays.asList(split).subList(1, split.length);
CommandContext ctx = new CommandContext(event, args);
cmd.handle(ctx);
}
public static List<ICommand> getAllCommands() {
return ALL_COMMANDS;
}
public void handle(SlashCommandEvent event) {
String invoke = event.getName();
ISlashCommand cmd = Registry.getSlashCommand(invoke);
if (cmd != null) {
event.deferReply().queue();
@Nullable
public static IPrefixCommand getPrefixCommand(String search) {
String searchLower = search.toLowerCase();
for (IPrefixCommand cmd : ALL_PREFIX_COMMANDS) {
if (cmd.getName().equals(searchLower) || cmd.getAliases().contains(searchLower)) {
return cmd;
assert event.getMember() != null;
if (!hasPermission(event.getMember(), cmd)) {
event.getHook().sendMessage("You do not have permission to use this command.").queue();
return;
}
CommandContext ctx = new CommandContext(event);
cmd.handleSlash(ctx);
}
return null;
}
public static List<IPrefixCommand> getAllPrefixCommands() {
return ALL_PREFIX_COMMANDS;
}
@Nullable
public static ISlashCommand getSlashCommand(String search) {
String searchLower = search.toLowerCase();
for (ISlashCommand cmd : ALL_SLASH_COMMANDS) {
if (cmd.getName().equals(searchLower) || cmd.getAliases().contains(searchLower)) {
return cmd;
}
}
return null;
}
public static List<ISlashCommand> getAllSlashCommands() {
return ALL_SLASH_COMMANDS;
}
}

15
src/main/java/tech/nevets/modbot/CoreBot.java
View File

@ -4,18 +4,18 @@ import ch.qos.logback.classic.Level;
import net.dv8tion.jda.api.JDA;
import net.dv8tion.jda.api.JDABuilder;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.utils.cache.CacheFlag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import tech.nevets.modbot.api.BotModule;
import tech.nevets.modbot.api.Config;
import tech.nevets.modbot.internal.InternalListener;
import javax.security.auth.login.LoginException;
import java.util.*;
public class CoreBot {
public static JDA jda;
private static JDA jda;
public static final Config CORE_CONFIG = new Config("core");
public static final List<ListenerAdapter> PLUGIN_LISTENERS = new ArrayList<>();
private static String botPrefix;
@ -28,11 +28,10 @@ public class CoreBot {
CORE_CONFIG.loadConfig();
botPrefix = CORE_CONFIG.getConfig().getString("bot.prefix");
modules = ModuleLoader.loadModules();
InternalListener coreListener = new InternalListener();
JDABuilder builder = JDABuilder.createDefault(CORE_CONFIG.getConfig().getString("bot.token"))
.enableCache(CacheFlag.VOICE_STATE)
.addEventListeners(coreListener);
.addEventListeners(Registry.getListeners());
for (ListenerAdapter listener : PLUGIN_LISTENERS) {
builder.addEventListeners(listener);
@ -44,7 +43,8 @@ public class CoreBot {
e.printStackTrace();
}
coreListener.getCommandRegistry().registerSlashCommands();
Registry.loadSlashCommands();
for (BotModule module : modules) {
if (module.loadCommandRegistry() == null) {
LOGGER.warn("Module has no commands to load");
@ -56,11 +56,10 @@ public class CoreBot {
}
public static void addListener(ListenerAdapter listener) {
PLUGIN_LISTENERS.add(listener);
public static void loadSlashCommands(List<CommandData> commandData) {
jda.updateCommands().addCommands(commandData).queue();
}
private static Map<String, Object> getDefaults() {
Map<String, Object> defaults = new HashMap<>();
defaults.put("bot.token", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");

104
src/main/java/tech/nevets/modbot/Registry.java
View File

@ -1,20 +1,120 @@
package tech.nevets.modbot;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Role;
import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
import net.dv8tion.jda.api.events.message.guild.GuildMessageReceivedEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import tech.nevets.modbot.api.commands.CommandContext;
import tech.nevets.modbot.api.commands.ICommand;
import tech.nevets.modbot.api.commands.IPrefixCommand;
import tech.nevets.modbot.api.commands.ISlashCommand;
import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
public class Registry {
private static final Logger LOGGER = LoggerFactory.getLogger(Registry.class);
public static final List<ICommand> COMMANDS = new ArrayList<>();
public static final List<IPrefixCommand> PREFIX_COMMANDS = new ArrayList<>();
public static final List<ISlashCommand> SLASH_COMMANDS = new ArrayList<>();
private static final EventExecutor EVENT_EXECUTOR = new EventExecutor();
@Nullable
public static ICommand getCommand(String search) {
String searchLower = search.toLowerCase();
for (ICommand cmd : COMMANDS) {
if (cmd.getName().equals(searchLower) || cmd.getAliases().contains(searchLower)) {
return cmd;
}
}
return null;
}
@Nullable
public static IPrefixCommand getPrefixCommand(String search) {
String searchLower = search.toLowerCase();
for (IPrefixCommand cmd : PREFIX_COMMANDS) {
if (cmd.getName().equals(searchLower) || cmd.getAliases().contains(searchLower)) {
return cmd;
}
}
LOGGER.warn("Returned null for command search: " + searchLower);
return null;
}
@Nullable
public static ISlashCommand getSlashCommand(String search) {
String searchLower = search.toLowerCase();
for (ISlashCommand cmd : SLASH_COMMANDS) {
if (cmd.getName().equals(searchLower) || cmd.getAliases().contains(searchLower)) {
return cmd;
}
}
LOGGER.warn("Returned null for command search: " + searchLower);
return null;
}
public static List<ICommand> getCommands() {
return COMMANDS;
}
public static List<IPrefixCommand> getPrefixCommands() {
return PREFIX_COMMANDS;
}
public static List<ISlashCommand> getSlashCommands() {
return SLASH_COMMANDS;
}
public static EventExecutor getListeners() {
return EVENT_EXECUTOR;
}
public static boolean exists(ICommand cmd) {
boolean nameExists = COMMANDS.stream().anyMatch(it -> it.getName().equalsIgnoreCase(cmd.getName()));
if (nameExists) {
throw new IllegalArgumentException("A command with that name already exists!");
}
return false;
}
public static void register(IPrefixCommand cmd) {
if (!exists(cmd)) {
COMMANDS.add(cmd);
PREFIX_COMMANDS.add(cmd);
}
}
public static void register(ISlashCommand cmd) {
if (!exists(cmd)) {
COMMANDS.add(cmd);
SLASH_COMMANDS.add(cmd);
}
}
public static void register(ListenerAdapter listener) {
EVENT_EXECUTOR.registerListener(listener);
}
public static void loadSlashCommands() {
if (SLASH_COMMANDS.size() > 0) {
List<CommandData> cmdDataList = new ArrayList<>();
for (ISlashCommand slashCmd : SLASH_COMMANDS) {
cmdDataList.add(slashCmd.getCommandData());
}
CoreBot.loadSlashCommands(cmdDataList);
}
}
}

67
src/main/java/tech/nevets/modbot/api/commands/CommandRegistry.java
View File

@ -23,33 +23,6 @@ public class CommandRegistry {
public CommandRegistry() {}
public void addCommand(ICommand cmd) {
boolean nameFound = commands.stream().anyMatch(it -> it.getName().equalsIgnoreCase(cmd.getName()));
if (nameFound) {
throw new IllegalArgumentException("A command with that name is already present!");
}
commands.add(cmd);
if (cmd instanceof IPrefixCommand) {
prefixCommands.add((IPrefixCommand) cmd);
}
if (cmd instanceof ISlashCommand) {
slashCommands.add((ISlashCommand) cmd);
}
}
public void registerSlashCommands() {
if (slashCommands.size() > 0) {
List<CommandData> cmdDataList = new ArrayList<>();
for (ISlashCommand slashCmd : slashCommands) {
cmdDataList.add(slashCmd.getCommandData());
}
CoreBot.jda.updateCommands().addCommands(cmdDataList).queue();
}
}
@Nullable
public IPrefixCommand getPrefixCommand(String search) {
String searchLower = search.toLowerCase();
@ -109,45 +82,5 @@ public class CommandRegistry {
return permLevel >= cmd.getPermissionLevel();
}
public void handle(GuildMessageReceivedEvent event) {
String[] split = event.getMessage().getContentRaw()
.replaceFirst("(?i)" + Pattern.quote(CoreBot.CORE_CONFIG.getConfig().getString("bot.prefix")), "")
.split("\\s+");
String invoke = split[0].toLowerCase();
IPrefixCommand cmd = getPrefixCommand(invoke);
assert event.getMember() != null;
assert cmd != null;
if (!hasPermission(event.getMember(), cmd)) {
event.getMessage().reply("You do not have permission to use this command.").queue();
return;
}
event.getChannel().sendTyping().queue();
List<String> args = Arrays.asList(split).subList(1, split.length);
CommandContext ctx = new CommandContext(event, args);
cmd.handle(ctx);
}
public void handle(SlashCommandEvent event) {
String invoke = event.getName();
ISlashCommand cmd = getSlashCommand(invoke);
if (cmd != null) {
event.deferReply().queue();
assert event.getMember() != null;
if (!hasPermission(event.getMember(), cmd)) {
event.getHook().sendMessage("You do not have permission to use this command.").queue();
return;
}
CommandContext ctx = new CommandContext(event);
cmd.handleSlash(ctx);
}
}
}