From f64c64c127ac5e8d7d04c9c512d2a2155cf7c915 Mon Sep 17 00:00:00 2001 From: Tyler Murphy Date: Sun, 21 Aug 2022 23:48:35 -0400 Subject: v1 --- src/main/java/net/tylermurphy/ken/Config.java | 247 +++++++++++++++++++++ src/main/java/net/tylermurphy/ken/Ken.java | 122 ++++++++++ src/main/java/net/tylermurphy/ken/api/E621API.java | 28 +++ .../java/net/tylermurphy/ken/api/Rule34API.java | 30 +++ .../tylermurphy/ken/api/wrapper/HTTPMethod.java | 10 + .../tylermurphy/ken/api/wrapper/JsonRequest.java | 38 ++++ .../net/tylermurphy/ken/api/wrapper/Request.java | 76 +++++++ .../tylermurphy/ken/api/wrapper/XmlRequest.java | 40 ++++ .../tylermurphy/ken/command/ButtonCallback.java | 12 + .../java/net/tylermurphy/ken/command/Command.java | 13 ++ .../net/tylermurphy/ken/command/Container.java | 49 ++++ .../java/net/tylermurphy/ken/command/Option.java | 16 ++ .../java/net/tylermurphy/ken/command/Options.java | 12 + .../net/tylermurphy/ken/command/Requirement.java | 12 + .../net/tylermurphy/ken/command/Responder.java | 230 +++++++++++++++++++ .../java/net/tylermurphy/ken/command/Response.java | 89 ++++++++ .../java/net/tylermurphy/ken/command/fun/Dice.java | 59 +++++ .../net/tylermurphy/ken/command/fun/Eject.java | 23 ++ .../tylermurphy/ken/command/music/ForceSkip.java | 47 ++++ .../net/tylermurphy/ken/command/music/Join.java | 48 ++++ .../net/tylermurphy/ken/command/music/Leave.java | 37 +++ .../net/tylermurphy/ken/command/music/Loop.java | 49 ++++ .../tylermurphy/ken/command/music/LoopQueue.java | 53 +++++ .../tylermurphy/ken/command/music/NowPlaying.java | 67 ++++++ .../net/tylermurphy/ken/command/music/Pause.java | 48 ++++ .../net/tylermurphy/ken/command/music/Play.java | 94 ++++++++ .../net/tylermurphy/ken/command/music/Queue.java | 85 +++++++ .../net/tylermurphy/ken/command/music/Remove.java | 54 +++++ .../net/tylermurphy/ken/command/music/Resume.java | 49 ++++ .../net/tylermurphy/ken/command/music/Skip.java | 78 +++++++ .../net/tylermurphy/ken/command/music/Stop.java | 49 ++++ .../net/tylermurphy/ken/command/nsfw/E621.java | 36 +++ .../net/tylermurphy/ken/command/nsfw/Rule34.java | 36 +++ .../net/tylermurphy/ken/command/util/Help.java | 52 +++++ .../net/tylermurphy/ken/command/util/Purge.java | 33 +++ .../java/net/tylermurphy/ken/image/GifFactory.java | 132 +++++++++++ .../net/tylermurphy/ken/image/ImageFactory.java | 96 ++++++++ .../ken/music/AudioPlayerSendHandler.java | 40 ++++ .../tylermurphy/ken/music/AutoLeaveManager.java | 68 ++++++ .../tylermurphy/ken/music/BotLeaveListener.java | 38 ++++ .../tylermurphy/ken/music/GuildMusicManager.java | 28 +++ .../tylermurphy/ken/music/MusicPermissions.java | 27 +++ .../net/tylermurphy/ken/music/PlayerManager.java | 157 +++++++++++++ .../net/tylermurphy/ken/music/TrackScheduler.java | 161 ++++++++++++++ 44 files changed, 2768 insertions(+) create mode 100644 src/main/java/net/tylermurphy/ken/Config.java create mode 100644 src/main/java/net/tylermurphy/ken/Ken.java create mode 100644 src/main/java/net/tylermurphy/ken/api/E621API.java create mode 100644 src/main/java/net/tylermurphy/ken/api/Rule34API.java create mode 100644 src/main/java/net/tylermurphy/ken/api/wrapper/HTTPMethod.java create mode 100644 src/main/java/net/tylermurphy/ken/api/wrapper/JsonRequest.java create mode 100644 src/main/java/net/tylermurphy/ken/api/wrapper/Request.java create mode 100644 src/main/java/net/tylermurphy/ken/api/wrapper/XmlRequest.java create mode 100644 src/main/java/net/tylermurphy/ken/command/ButtonCallback.java create mode 100644 src/main/java/net/tylermurphy/ken/command/Command.java create mode 100644 src/main/java/net/tylermurphy/ken/command/Container.java create mode 100644 src/main/java/net/tylermurphy/ken/command/Option.java create mode 100644 src/main/java/net/tylermurphy/ken/command/Options.java create mode 100644 src/main/java/net/tylermurphy/ken/command/Requirement.java create mode 100644 src/main/java/net/tylermurphy/ken/command/Responder.java create mode 100644 src/main/java/net/tylermurphy/ken/command/Response.java create mode 100644 src/main/java/net/tylermurphy/ken/command/fun/Dice.java create mode 100644 src/main/java/net/tylermurphy/ken/command/fun/Eject.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/ForceSkip.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/Join.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/Leave.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/Loop.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/LoopQueue.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/NowPlaying.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/Pause.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/Play.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/Queue.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/Remove.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/Resume.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/Skip.java create mode 100644 src/main/java/net/tylermurphy/ken/command/music/Stop.java create mode 100644 src/main/java/net/tylermurphy/ken/command/nsfw/E621.java create mode 100644 src/main/java/net/tylermurphy/ken/command/nsfw/Rule34.java create mode 100644 src/main/java/net/tylermurphy/ken/command/util/Help.java create mode 100644 src/main/java/net/tylermurphy/ken/command/util/Purge.java create mode 100644 src/main/java/net/tylermurphy/ken/image/GifFactory.java create mode 100644 src/main/java/net/tylermurphy/ken/image/ImageFactory.java create mode 100644 src/main/java/net/tylermurphy/ken/music/AudioPlayerSendHandler.java create mode 100644 src/main/java/net/tylermurphy/ken/music/AutoLeaveManager.java create mode 100644 src/main/java/net/tylermurphy/ken/music/BotLeaveListener.java create mode 100644 src/main/java/net/tylermurphy/ken/music/GuildMusicManager.java create mode 100644 src/main/java/net/tylermurphy/ken/music/MusicPermissions.java create mode 100644 src/main/java/net/tylermurphy/ken/music/PlayerManager.java create mode 100644 src/main/java/net/tylermurphy/ken/music/TrackScheduler.java (limited to 'src/main/java/net') diff --git a/src/main/java/net/tylermurphy/ken/Config.java b/src/main/java/net/tylermurphy/ken/Config.java new file mode 100644 index 0000000..c5a5991 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/Config.java @@ -0,0 +1,247 @@ +package net.tylermurphy.ken; + +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.error.YAMLException; + +import java.io.*; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class Config { + + private final File file; + private final Map config = new HashMap<>(); + private final Map defaultConfig = new HashMap<>(); + private final String defaultFilename; + + public static Config create(String filename) { + return new Config(filename, filename); + } + + public static Config create(String filename, String defaultFilename) { + return new Config(filename, defaultFilename); + } + + private Config(String filename, String defaultFilename) { + + File dataFolder = Ken.getInstance().getConfigFolder(); + + this.defaultFilename = defaultFilename; + this.file = new File(dataFolder, filename); + + if (!dataFolder.exists()) { + if (!dataFolder.mkdirs()) { + throw new RuntimeException("Failed to make directory: " + file.getPath()); + } + } + + if (!file.exists()) { + try{ + InputStream input = Ken.getInstance().getResource(defaultFilename); + if (input == null) { + throw new RuntimeException("Could not create input stream for "+defaultFilename); + } + Files.copy(input, file.toPath()); + input.close(); + } catch(IOException e) { + e.printStackTrace(); + } + } + + FileInputStream fileInputStream; + try { + fileInputStream = new FileInputStream(file); + } catch (FileNotFoundException e) { + throw new RuntimeException("Could not create inputstream for "+file.getPath()); + } + InputStreamReader reader = new InputStreamReader(fileInputStream, StandardCharsets.UTF_8); + Yaml yaml = new Yaml(); + Map temp = null; + try { + temp = yaml.load(reader); + } catch(YAMLException e) { + throw new RuntimeException("Invalid configuration in config file: "+file.getPath()); + } catch(Exception e) { + throw new RuntimeException("Could not access file: "+file.getPath()); + } + parseYAML(temp, this.config, ""); + + InputStream input = Ken.getInstance().getResource(defaultFilename); + if (input == null) { + throw new RuntimeException("Could not create input stream for "+defaultFilename); + } + InputStreamReader default_reader = new InputStreamReader(input, StandardCharsets.UTF_8); + try { + temp = yaml.load(default_reader); + } catch(YAMLException e) { + throw new RuntimeException("Invalid configuration in config file: "+file.getPath()); + } catch(Exception e) { + throw new RuntimeException("Could not access file: "+file.getPath()); + } + parseYAML(temp, this.defaultConfig, ""); + + try{ + fileInputStream.close(); + reader.close(); + default_reader.close(); + input.close(); + } catch (IOException e) { + throw new RuntimeException("Unable to finalize loading of config files."); + } + + } + + @SuppressWarnings({"rawtypes", "unchecked"}) + private void parseYAML(Map temp, Map target, String prefix){ + for(Map.Entry entry : temp.entrySet()) { + String path = entry.getKey(); + Object data = entry.getValue(); + if (data instanceof Map) { + Map map = (Map) data; + parseYAML(map, target, path+"."); + } else { + target.put(prefix+path, data); + } + } + } + + public boolean contains(String path) { + return config.containsKey(path); + } + + private Object getValue(String path){ + if (!contains(path)) { + return defaultConfig.get(path); + } else { + return config.get(path); + } + } + + public Integer getInt(String path) { + Object v = getValue(path); + if(v instanceof Integer) + return (Integer)v; + else + return 0; + } + + public Double getDouble(String path) { + Object v = getValue(path); + if(v instanceof Double) + return (Double) v; + else + return 0.0; + } + + public Float getFloat(String path) { + Object v = getValue(path); + if(v instanceof Float) + return (Float)v; + else + return 0.0f; + } + + public Long getLong(String path) { + Object v = getValue(path); + if(v instanceof Long) + return (Long)v; + else + return 0L; + } + + public String getString(String path) { + Object v = getValue(path); + if(v instanceof String) + return (String)v; + else + return null; + } + + public Boolean getBoolean(String path) { + Object v = getValue(path); + if(v instanceof Boolean) + return (Boolean) v; + else + return false; + } + + public void reset(String path) { + config.put(path, defaultConfig.get(path)); + } + + public void set(String path, Object value) { + config.put(path, value); + } + + public void saveConfig() { + try { + InputStream is = Ken.getInstance().getResource(defaultFilename); + if (is == null) { + throw new RuntimeException("Could not create input stream for "+defaultFilename); + } + StringBuilder textBuilder = new StringBuilder(new String("".getBytes(), StandardCharsets.UTF_8)); + Reader reader = new BufferedReader(new InputStreamReader(is, Charset.forName(StandardCharsets.UTF_8.name()))); + int c; + while((c = reader.read()) != -1) { + textBuilder.append((char) c); + } + String yamlString = new String(textBuilder.toString().getBytes(), StandardCharsets.UTF_8); + Map temp = new HashMap<>(this.config); + for(Map.Entry entry: temp.entrySet()) { + if (entry.getValue() instanceof Integer || entry.getValue() instanceof Double || entry.getValue() instanceof String || entry.getValue() instanceof Boolean || entry.getValue() instanceof List) { + String[] parts = entry.getKey().split("\\."); + int index = 0; + int i = 0; + for(String part : parts) { + if (i == 0) { + index = yamlString.indexOf(part+":", index); + } else { + index = yamlString.indexOf(" " + part+":", index); + index++; + } + i++; + if (index == -1) break; + } + if (index < 10) continue; + int start = yamlString.indexOf(' ', index); + int end = yamlString.indexOf('\n', index); + if (end == -1) end = yamlString.length(); + StringBuilder replace = new StringBuilder(new String("".getBytes(), StandardCharsets.UTF_8)); + if (entry.getValue() instanceof List) { + if (((List) entry.getValue()).isEmpty()) { + replace.append("[]"); + } else { + replace.append("["); + for (Object o : (List) entry.getValue()) { + replace.append(o.toString()).append(", "); + } + replace = new StringBuilder(replace.substring(0, replace.length() - 2)); + replace.append("]"); + } + } else { + replace.append(entry.getValue()); + } + if (entry.getValue() instanceof String) { + replace.append("\""); + replace.reverse(); + replace.append("\""); + replace.reverse(); + } + StringBuilder builder = new StringBuilder(yamlString); + builder.replace(start+1, end, replace.toString()); + yamlString = builder.toString(); + } + } + Writer fileWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8)); + fileWriter.write(yamlString); + fileWriter.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + +} \ No newline at end of file diff --git a/src/main/java/net/tylermurphy/ken/Ken.java b/src/main/java/net/tylermurphy/ken/Ken.java new file mode 100644 index 0000000..0481bb6 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/Ken.java @@ -0,0 +1,122 @@ +package net.tylermurphy.ken; + +import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport; +import com.google.api.client.json.jackson2.JacksonFactory; +import com.google.api.services.youtube.YouTube; +import net.dv8tion.jda.api.EmbedBuilder; +import net.dv8tion.jda.api.JDA; +import net.dv8tion.jda.api.JDABuilder; +import net.dv8tion.jda.api.entities.Activity; +import net.dv8tion.jda.api.entities.TextChannel; +import net.dv8tion.jda.api.entities.VoiceChannel; +import net.dv8tion.jda.api.hooks.ListenerAdapter; +import net.dv8tion.jda.api.requests.GatewayIntent; +import net.dv8tion.jda.api.utils.MemberCachePolicy; +import net.tylermurphy.ken.command.Responder; +import net.tylermurphy.ken.music.PlayerManager; +import org.jetbrains.annotations.NotNull; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.awt.Color; +import java.io.File; +import java.io.InputStream; +import java.lang.reflect.InvocationTargetException; + +public class Ken { + + private static Ken instance; + private final Config config; + private final Logger log; + private final JDA api; + private final PlayerManager playerManager; + private final YouTube youTube; + private final Responder responder; + + private Ken(){ + Ken.instance = this; + this.config = Config.create("config.yml"); + this.log = LoggerFactory.getLogger(Ken.class); + try { + api = JDABuilder.createDefault(config.getString("botToken")) + .setActivity(Activity.playing("Use "+config.getString("prefix")+"help")) + .setMemberCachePolicy(MemberCachePolicy.ALL) + .enableIntents(GatewayIntent.GUILD_MEMBERS) + .build() + .awaitReady(); + } catch (Exception e) { + log.error(e.getMessage()); + throw new RuntimeException("Unable to Initialize JDA"); + } + this.responder = new Responder(api); + try{ + responder.registerCommands(); + } catch (InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException e) { + log.error(e.getMessage()); + throw new RuntimeException("Unable to register commands"); + } + this.addEventListener(responder); + this.playerManager = new PlayerManager(); + try { + youTube = new YouTube.Builder( + GoogleNetHttpTransport.newTrustedTransport(), + JacksonFactory.getDefaultInstance(), + null + ).setApplicationName("Ken").build(); + } catch(Exception e) { + log.error(e.getMessage()); + throw new RuntimeException("Unable to connect with YouTube API"); + } + } + + public static Ken getInstance(){ + return instance; + } + + public File getConfigFolder() { + return new File("config"); + } + + public InputStream getResource(@NotNull String filename) { + return getClass().getClassLoader().getResourceAsStream(filename); + } + + public Config getConfig(){ + return config; + } + + public Logger getLogger(){ + return log; + } + + public PlayerManager getPlayerManager() { return playerManager; } + + public YouTube getYouTube() { return youTube; } + + public EmbedBuilder getDefaultEmbed() { + EmbedBuilder builder = new EmbedBuilder(); + builder.setColor(new Color( + config.getInt("colors.r"), + config.getInt("colors.g"), + config.getInt("colors.b") + )); + return builder; + } + + public TextChannel getTextChannel(long id) { + return api.getTextChannelById(id); + } + + public VoiceChannel getVoiceChannel(long id) { + return api.getVoiceChannelById(id); + } + + public void addEventListener(ListenerAdapter listener){ + api.addEventListener(listener); + } + + public static void main(String[] args){ + new Ken(); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/api/E621API.java b/src/main/java/net/tylermurphy/ken/api/E621API.java new file mode 100644 index 0000000..06aa02e --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/E621API.java @@ -0,0 +1,28 @@ +package net.tylermurphy.ken.api; + +import net.tylermurphy.ken.api.wrapper.HTTPMethod; +import net.tylermurphy.ken.api.wrapper.JsonRequest; +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +public class E621API { + + public static String request(String query){ + JSONObject json = (JSONObject) new JsonRequest() + .setURL("https://e621.net/posts.json?tags="+query) + .setType(HTTPMethod.GET) + .request(); + try { + System.out.println(json.toString()); + JSONArray results = json.getJSONArray("posts"); + int choice = (int) (Math.random()*results.length()-1); + JSONObject post = (JSONObject) results.get(choice); + JSONObject file = post.getJSONObject("file"); + return file.getString("url"); + } catch (JSONException e) { + return null; + } + } + +} diff --git a/src/main/java/net/tylermurphy/ken/api/Rule34API.java b/src/main/java/net/tylermurphy/ken/api/Rule34API.java new file mode 100644 index 0000000..3c78522 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/Rule34API.java @@ -0,0 +1,30 @@ +package net.tylermurphy.ken.api; + +import net.tylermurphy.ken.api.wrapper.HTTPMethod; +import net.tylermurphy.ken.api.wrapper.XmlRequest; +import org.json.JSONException; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +public class Rule34API { + + public static String request(String query){ + Document doc = (Document) new XmlRequest() + .setURL("https://rule34.xxx/index.php?page=dapi&s=post&q=index&tags="+ query) + .setType(HTTPMethod.GET) + .request(); + try { + NodeList nList = doc.getElementsByTagName("post"); + int choice = (int) (Math.random()*nList.getLength()-1); + if(choice < 0) return null; + Node node = nList.item(choice); + Element element = (Element) node; + return element.getAttribute("file_url"); + } catch (JSONException e) { + return null; + } + } + +} diff --git a/src/main/java/net/tylermurphy/ken/api/wrapper/HTTPMethod.java b/src/main/java/net/tylermurphy/ken/api/wrapper/HTTPMethod.java new file mode 100644 index 0000000..094a8c6 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/wrapper/HTTPMethod.java @@ -0,0 +1,10 @@ +package net.tylermurphy.ken.api.wrapper; + +public enum HTTPMethod { + + GET, + POST, + PUT, + DELETE + +} diff --git a/src/main/java/net/tylermurphy/ken/api/wrapper/JsonRequest.java b/src/main/java/net/tylermurphy/ken/api/wrapper/JsonRequest.java new file mode 100644 index 0000000..f95d23f --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/wrapper/JsonRequest.java @@ -0,0 +1,38 @@ +package net.tylermurphy.ken.api.wrapper; + +import org.json.JSONException; +import org.json.JSONObject; + +import java.io.*; +import java.net.HttpURLConnection; +import java.nio.charset.StandardCharsets; + +public class JsonRequest extends Request { + + public Object request() { + super.addHeaders("Content-type","application/json"); + HttpURLConnection connection = super.getConnection(); + try { + return parseJson(connection.getInputStream()); + } catch (Exception ignored) {} finally { + if (connection != null) { + connection.disconnect(); + } + } + return null; + } + + public static JSONObject parseJson(InputStream is) throws JSONException { + char[] buffer = new char[1024 * 4]; + int n; + try (BufferedInputStream stream = new BufferedInputStream(is); InputStreamReader reader = new InputStreamReader(stream, StandardCharsets.UTF_8)) { + StringWriter writer = new StringWriter(); + while (-1 != (n = reader.read(buffer))) { + writer.write(buffer, 0, n); + } + return new JSONObject(writer.toString()); + } catch (IOException ignored) {} + return new JSONObject(""); + } + +} diff --git a/src/main/java/net/tylermurphy/ken/api/wrapper/Request.java b/src/main/java/net/tylermurphy/ken/api/wrapper/Request.java new file mode 100644 index 0000000..a5b8e4d --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/api/wrapper/Request.java @@ -0,0 +1,76 @@ +package net.tylermurphy.ken.api.wrapper; + +import java.io.OutputStream; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public abstract class Request { + + private HTTPMethod method; + private String url; + private String body; + private List headers; + + protected Request(){ + this.method = HTTPMethod.GET; + this.url = null; + this.body = null; + this.headers = new ArrayList<>(); + } + + public Request setType(HTTPMethod method){ + this.method = method; + return this; + } + + public Request setURL(String url){ + this.url = url; + return this; + } + + public Request setBody(String body){ + this.body = body; + return this; + } + + public Request addHeaders(String... headers){ + this.headers.addAll(Arrays.asList(headers)); + return this; + } + + public abstract Object request(); + + protected HttpURLConnection getConnection() { + HttpURLConnection connection = null; + try { + connection = (HttpURLConnection) new URL(url).openConnection(); + connection.setDoInput(true); + connection.setDoOutput(true); + connection.setRequestMethod(method.toString()); + connection.addRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:25.0) Gecko/20100101 Firefox/25.0"); + + for(int i=0; i+1 register; + private final JDA api; + + public Responder(JDA api) { + this.register = new HashMap<>(); + this.api = api; + } + + public void registerCommands() throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException { + + // Reset register + register.clear(); + + // Get all Methods that use the @Command annotation + for (Method method : new Reflections("net.tylermurphy.ken.command", new MethodAnnotationsScanner()).getMethodsAnnotatedWith(Command.class)) { + if(method.getReturnType() != Response.class) continue; + // Register Main Command Information If Not Already Registered; + Command command = method.getAnnotation(Command.class); + if (register.containsKey(command.name())) continue; + // Create Command Container + Container container = new Container(method); + // Check For Permissions + if (method.isAnnotationPresent(Requirement.class)) + container.setPermission(method.getAnnotation(Requirement.class).value()); + // Add Command To Register + register.put(command.name(), container); + // Create Slash Command Data + SlashCommandData data = Commands.slash(command.name(), command.description()); + // Add Options to Slash Command Data if @Option is used + if(method.isAnnotationPresent(Options.class)) { + Option[] options = method.getAnnotation(Options.class).value(); + for(Option option : options){ + data = data.addOption(option.type(), option.name(), option.description(), option.required()); + } + } else if (method.isAnnotationPresent(Option.class)) { + Option option = method.getAnnotation(Option.class); + data = data.addOption(option.type(), option.name(), option.description(), option.required()); + } + api.upsertCommand(data).queue(); + } + + // Get all Methods that use the @ButtonCallback annotation + for (Method method : new Reflections("net.tylermurphy.ken.command", new MethodAnnotationsScanner()).getMethodsAnnotatedWith(ButtonCallback.class)) { + if(method.getReturnType() != Response.class) continue; + ButtonCallback callback = method.getAnnotation(ButtonCallback.class); + if(!register.containsKey(callback.name())) continue; + Container container = register.get(callback.name()); + container.setButtonCallback(method); + register.put(callback.name(), container); + } + } + + public void onSlashCommandInteraction(SlashCommandInteractionEvent event) { + + // Make sure the Bot can Talk + if(!event.getChannel().canTalk()) return; + + // Bots are not allowed to use commands + if (event.getMember() == null || event.getUser().isBot()) return; + + // Get Command Information From Invoke + final String invoke = event.getName().toLowerCase(Locale.ROOT); + if(!register.containsKey(invoke)) return; + Container container = register.get(invoke); + Method method = container.getMethod(); + + // Check Permissions + if(!event.getMember().hasPermission(container.getPermission())) { + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .appendDescription(":x: **Invalid Permissions**\n") + .appendDescription("You require the "+ container.getPermission().toString()+" permission to use this command."); + event.getHook().sendMessageEmbeds(builder.build()).queue(); + return; + } + + // Defer Reply + event.deferReply().queue(); + + // Get slash command options if there are any + List args = new ArrayList<>(); + event.getOptions().forEach(option -> { + switch (option.getType()){ + case STRING: args.add(option.getAsString()); break; + case INTEGER: args.add(option.getAsInt()); break; + case BOOLEAN: args.add(option.getAsBoolean()); break; + case USER: args.add(option.getAsMember()); break; + case CHANNEL: args.add(option.getAsChannel()); break; + case ROLE: args.add(option.getAsRole()); break; + case MENTIONABLE: args.add(option.getAsMentionable()); break; + default: break; + } + }); + + // Get parameters to send to Method + Object[] parameters = new Object[method.getParameterTypes().length]; + Class[] types = method.getParameterTypes(); + for(int i = 0; i < types.length; i++){ + if(types[i] == Member.class){ + parameters[i] = event.getMember(); + } else if(types[i] == GuildMessageChannel.class){ + parameters[i] = event.getGuildChannel(); + } else if(types[i] == Guild.class) { + parameters[i] = event.getGuild(); + } else if(types[i] == List.class) { + parameters[i] = args; + } else { + parameters[i] = null; + } + } + + // Invoke Method and Respond to User + try { + Object temp = method.invoke(container.getHandle(), parameters); + Response response = (Response)temp; + if(response.error()) { + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setColor(Color.RED) + .setTitle(":x: **Error**") + .setDescription(response.getMessage()); + event.getHook().sendMessageEmbeds(builder.build()).queue(); + } else { + WebhookMessageAction message; + if(response.hasEmbed()) { + message = event.getHook().sendMessageEmbeds(response.getEmbeds()); + } else { + message = event.getHook().sendMessage(response.getMessage()); + } + if(response.hasButtons()) message = message.addActionRow(response.getButtons()); + if(response.hasFile()) message = message.addFile(response.getFile()); + message.queue(); + } + } catch (Exception e) { + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setColor(Color.RED) + .setTitle(":x: **Error**") + .setDescription(e.getMessage()); + event.getHook().sendMessageEmbeds(builder.build()).queue(); + e.printStackTrace(); + } + } + + public void onButtonInteraction(ButtonInteractionEvent event) { + + // Make sure the Bot can Talk + if(!event.getChannel().canTalk()) return; + // Bots are not allowed to use commands + if (event.getMember() == null || event.getUser().isBot()) return; + + // Get Command Information From Invoke + final String invoke = event.getComponentId().toLowerCase(Locale.ROOT).split("_")[0]; + if(!register.containsKey(invoke)) return; + Container container = register.get(invoke); + Method method = container.getButtonCallback(); + + // Defer Reply + event.deferEdit().queue(); + + // Get parameters to send to Method + Object[] parameters = new Object[method.getParameterTypes().length]; + Class[] types = method.getParameterTypes(); + for(int i = 0; i < types.length; i++){ + if(types[i] == Member.class){ + parameters[i] = event.getMember(); + } else if(types[i] == GuildMessageChannel.class){ + parameters[i] = event.getGuildChannel(); + } else if(types[i] == Guild.class) { + parameters[i] = event.getGuild(); + } else if(types[i] == Button.class) { + parameters[i] = event.getButton(); + } else if(types[i] == Message.class) { + parameters[i] = event.getMessage(); + } else if(types[i] == String.class) { + parameters[i] = event.getComponentId().substring(invoke.length()+1); + } else { + parameters[i] = null; + } + } + + // Invoke Method and Respond to User + try { + Object temp = method.invoke(container.getHandle(), parameters); + Response response = (Response) temp; + if(response.error()) { + EmbedBuilder builder = Ken.getInstance().getDefaultEmbed() + .setColor(Color.RED) + .setTitle(":x: **Error**") + .setDescription(response.getMessage()); + event.getHook().sendMessageEmbeds(builder.build()).queue(); + } else { + if(response.hasEmbed()) { + event.getHook().editOriginalEmbeds(response.getEmbeds()).queue(); + } else { + event.getHook().editOriginal(response.getMessage()).queue(); + } + } + } catch (Exception e) { + event.getHook().sendMessage(e.getMessage()).queue(); + e.printStackTrace(); + } + + } + +} diff --git a/src/main/java/net/tylermurphy/ken/command/Response.java b/src/main/java/net/tylermurphy/ken/command/Response.java new file mode 100644 index 0000000..9b87905 --- /dev/null +++ b/src/main/java/net/tylermurphy/ken/command/Response.java @@ -0,0 +1,89 @@ +package net.tylermurphy.ken.command; + +import net.dv8tion.jda.api.entities.MessageEmbed; +import net.dv8tion.jda.api.interactions.components.buttons.Button; + +import java.io.File; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class Response { + + private final String message; + private final String type; + private final MessageEmbed[] embeds; + private final List