.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot;
17 |
18 | import com.jagrosh.jmusicbot.utils.OtherUtil;
19 | import java.util.concurrent.TimeUnit;
20 | import net.dv8tion.jda.api.JDA;
21 | import net.dv8tion.jda.api.entities.Guild;
22 | import net.dv8tion.jda.api.entities.User;
23 | import net.dv8tion.jda.api.entities.VoiceChannel;
24 | import net.dv8tion.jda.api.events.ReadyEvent;
25 | import net.dv8tion.jda.api.events.ShutdownEvent;
26 | import net.dv8tion.jda.api.events.guild.GuildJoinEvent;
27 | import net.dv8tion.jda.api.events.guild.voice.GuildVoiceUpdateEvent;
28 | import net.dv8tion.jda.api.events.message.guild.GuildMessageDeleteEvent;
29 | import net.dv8tion.jda.api.hooks.ListenerAdapter;
30 | import org.jetbrains.annotations.NotNull;
31 | import org.slf4j.Logger;
32 | import org.slf4j.LoggerFactory;
33 |
34 | /**
35 | *
36 | * @author John Grosh (john.a.grosh@gmail.com)
37 | */
38 | public class Listener extends ListenerAdapter
39 | {
40 | private final Bot bot;
41 |
42 | public Listener(Bot bot)
43 | {
44 | this.bot = bot;
45 | }
46 |
47 | @Override
48 | public void onReady(ReadyEvent event)
49 | {
50 | if(event.getJDA().getGuildCache().isEmpty())
51 | {
52 | Logger log = LoggerFactory.getLogger("MusicBot");
53 | log.warn("This bot is not on any guilds! Use the following link to add the bot to your guilds!");
54 | log.warn(event.getJDA().getInviteUrl(JMusicBot.RECOMMENDED_PERMS));
55 | }
56 | credit(event.getJDA());
57 | event.getJDA().getGuilds().forEach((guild) ->
58 | {
59 | try
60 | {
61 | String defpl = bot.getSettingsManager().getSettings(guild).getDefaultPlaylist();
62 | VoiceChannel vc = bot.getSettingsManager().getSettings(guild).getVoiceChannel(guild);
63 | if(defpl!=null && vc!=null && bot.getPlayerManager().setUpHandler(guild).playFromDefault())
64 | {
65 | guild.getAudioManager().openAudioConnection(vc);
66 | }
67 | }
68 | catch(Exception ignore) {}
69 | });
70 | if(bot.getConfig().useUpdateAlerts())
71 | {
72 | bot.getThreadpool().scheduleWithFixedDelay(() ->
73 | {
74 | try
75 | {
76 | User owner = bot.getJDA().retrieveUserById(bot.getConfig().getOwnerId()).complete();
77 | String currentVersion = OtherUtil.getCurrentVersion();
78 | String latestVersion = OtherUtil.getLatestVersion();
79 | if(latestVersion!=null && !currentVersion.equalsIgnoreCase(latestVersion))
80 | {
81 | String msg = String.format(OtherUtil.NEW_VERSION_AVAILABLE, currentVersion, latestVersion);
82 | owner.openPrivateChannel().queue(pc -> pc.sendMessage(msg).queue());
83 | }
84 | }
85 | catch(Exception ex) {} // ignored
86 | }, 0, 24, TimeUnit.HOURS);
87 | }
88 | }
89 |
90 | @Override
91 | public void onGuildMessageDelete(GuildMessageDeleteEvent event)
92 | {
93 | bot.getNowplayingHandler().onMessageDelete(event.getGuild(), event.getMessageIdLong());
94 | }
95 |
96 | @Override
97 | public void onGuildVoiceUpdate(@NotNull GuildVoiceUpdateEvent event)
98 | {
99 | bot.getAloneInVoiceHandler().onVoiceUpdate(event);
100 | }
101 |
102 | @Override
103 | public void onShutdown(ShutdownEvent event)
104 | {
105 | bot.shutdown();
106 | }
107 |
108 | @Override
109 | public void onGuildJoin(GuildJoinEvent event)
110 | {
111 | credit(event.getJDA());
112 | }
113 |
114 | // make sure people aren't adding clones to dbots
115 | private void credit(JDA jda)
116 | {
117 | Guild dbots = jda.getGuildById(110373943822540800L);
118 | if(dbots==null)
119 | return;
120 | if(bot.getConfig().getDBots())
121 | return;
122 | jda.getTextChannelById(119222314964353025L)
123 | .sendMessage("This account is running JMusicBot. Please do not list bot clones on this server, <@"+bot.getConfig().getOwnerId()+">.").complete();
124 | dbots.leave().queue();
125 | }
126 | }
127 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/entities/Prompt.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2018 John Grosh (jagrosh)
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.entities;
17 |
18 | import java.util.Scanner;
19 | import javax.swing.JOptionPane;
20 | import org.slf4j.Logger;
21 | import org.slf4j.LoggerFactory;
22 |
23 | /**
24 | *
25 | * @author John Grosh (john.a.grosh@gmail.com)
26 | */
27 | public class Prompt
28 | {
29 | private final String title;
30 | private final String noguiMessage;
31 |
32 | private boolean nogui;
33 | private boolean noprompt;
34 | private Scanner scanner;
35 |
36 | public Prompt(String title)
37 | {
38 | this(title, null);
39 | }
40 |
41 | public Prompt(String title, String noguiMessage)
42 | {
43 | this(title, noguiMessage, "true".equalsIgnoreCase(System.getProperty("nogui")), "true".equalsIgnoreCase(System.getProperty("noprompt")));
44 | }
45 |
46 | public Prompt(String title, String noguiMessage, boolean nogui, boolean noprompt)
47 | {
48 | this.title = title;
49 | this.noguiMessage = noguiMessage == null ? "Switching to nogui mode. You can manually start in nogui mode by including the -Dnogui=true flag." : noguiMessage;
50 | this.nogui = nogui;
51 | this.noprompt = noprompt;
52 | }
53 |
54 | public boolean isNoGUI()
55 | {
56 | return nogui;
57 | }
58 |
59 | public void alert(Level level, String context, String message)
60 | {
61 | if(nogui)
62 | {
63 | Logger log = LoggerFactory.getLogger(context);
64 | switch(level)
65 | {
66 | case INFO:
67 | log.info(message);
68 | break;
69 | case WARNING:
70 | log.warn(message);
71 | break;
72 | case ERROR:
73 | log.error(message);
74 | break;
75 | default:
76 | log.info(message);
77 | break;
78 | }
79 | }
80 | else
81 | {
82 | try
83 | {
84 | int option = 0;
85 | switch(level)
86 | {
87 | case INFO:
88 | option = JOptionPane.INFORMATION_MESSAGE;
89 | break;
90 | case WARNING:
91 | option = JOptionPane.WARNING_MESSAGE;
92 | break;
93 | case ERROR:
94 | option = JOptionPane.ERROR_MESSAGE;
95 | break;
96 | default:
97 | option = JOptionPane.PLAIN_MESSAGE;
98 | break;
99 | }
100 | JOptionPane.showMessageDialog(null, ""+message, title, option);
101 | }
102 | catch(Exception e)
103 | {
104 | nogui = true;
105 | alert(Level.WARNING, context, noguiMessage);
106 | alert(level, context, message);
107 | }
108 | }
109 | }
110 |
111 | public String prompt(String content)
112 | {
113 | if(noprompt)
114 | return null;
115 | if(nogui)
116 | {
117 | if(scanner==null)
118 | scanner = new Scanner(System.in);
119 | try
120 | {
121 | System.out.println(content);
122 | if(scanner.hasNextLine())
123 | return scanner.nextLine();
124 | return null;
125 | }
126 | catch(Exception e)
127 | {
128 | alert(Level.ERROR, title, "Unable to read input from command line.");
129 | e.printStackTrace();
130 | return null;
131 | }
132 | }
133 | else
134 | {
135 | try
136 | {
137 | return JOptionPane.showInputDialog(null, content, title, JOptionPane.QUESTION_MESSAGE);
138 | }
139 | catch(Exception e)
140 | {
141 | nogui = true;
142 | alert(Level.WARNING, title, noguiMessage);
143 | return prompt(content);
144 | }
145 | }
146 | }
147 |
148 | public static enum Level
149 | {
150 | INFO, WARNING, ERROR;
151 | }
152 | }
153 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/commands/music/QueueCmd.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2018 John Grosh .
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.commands.music;
17 |
18 | import java.util.List;
19 | import java.util.concurrent.TimeUnit;
20 | import com.jagrosh.jdautilities.command.CommandEvent;
21 | import com.jagrosh.jdautilities.menu.Paginator;
22 | import com.jagrosh.jmusicbot.Bot;
23 | import com.jagrosh.jmusicbot.JMusicBot;
24 | import com.jagrosh.jmusicbot.audio.AudioHandler;
25 | import com.jagrosh.jmusicbot.audio.QueuedTrack;
26 | import com.jagrosh.jmusicbot.commands.MusicCommand;
27 | import com.jagrosh.jmusicbot.settings.RepeatMode;
28 | import com.jagrosh.jmusicbot.settings.Settings;
29 | import com.jagrosh.jmusicbot.utils.FormatUtil;
30 | import net.dv8tion.jda.api.MessageBuilder;
31 | import net.dv8tion.jda.api.Permission;
32 | import net.dv8tion.jda.api.entities.Message;
33 | import net.dv8tion.jda.api.exceptions.PermissionException;
34 |
35 | /**
36 | *
37 | * @author John Grosh
38 | */
39 | public class QueueCmd extends MusicCommand
40 | {
41 | private final Paginator.Builder builder;
42 |
43 | public QueueCmd(Bot bot)
44 | {
45 | super(bot);
46 | this.name = "queue";
47 | this.help = "shows the current queue";
48 | this.arguments = "[pagenum]";
49 | this.aliases = bot.getConfig().getAliases(this.name);
50 | this.bePlaying = true;
51 | this.botPermissions = new Permission[]{Permission.MESSAGE_ADD_REACTION,Permission.MESSAGE_EMBED_LINKS};
52 | builder = new Paginator.Builder()
53 | .setColumns(1)
54 | .setFinalAction(m -> {try{m.clearReactions().queue();}catch(PermissionException ignore){}})
55 | .setItemsPerPage(10)
56 | .waitOnSinglePage(false)
57 | .useNumberedItems(true)
58 | .showPageNumbers(true)
59 | .wrapPageEnds(true)
60 | .setEventWaiter(bot.getWaiter())
61 | .setTimeout(1, TimeUnit.MINUTES);
62 | }
63 |
64 | @Override
65 | public void doCommand(CommandEvent event)
66 | {
67 | int pagenum = 1;
68 | try
69 | {
70 | pagenum = Integer.parseInt(event.getArgs());
71 | }
72 | catch(NumberFormatException ignore){}
73 | AudioHandler ah = (AudioHandler)event.getGuild().getAudioManager().getSendingHandler();
74 | List list = ah.getQueue().getList();
75 | if(list.isEmpty())
76 | {
77 | Message nowp = ah.getNowPlaying(event.getJDA());
78 | Message nonowp = ah.getNoMusicPlaying(event.getJDA());
79 | Message built = new MessageBuilder()
80 | .setContent(event.getClient().getWarning() + " There is no music in the queue!")
81 | .setEmbeds((nowp==null ? nonowp : nowp).getEmbeds().get(0)).build();
82 | event.reply(built, m ->
83 | {
84 | if(nowp!=null)
85 | bot.getNowplayingHandler().setLastNPMessage(m);
86 | });
87 | return;
88 | }
89 | String[] songs = new String[list.size()];
90 | long total = 0;
91 | for(int i=0; i getQueueTitle(ah, event.getClient().getSuccess(), songs.length, fintotal, settings.getRepeatMode()))
99 | .setItems(songs)
100 | .setUsers(event.getAuthor())
101 | .setColor(event.getSelfMember().getColor())
102 | ;
103 | builder.build().paginate(event.getChannel(), pagenum);
104 | }
105 |
106 | private String getQueueTitle(AudioHandler ah, String success, int songslength, long total, RepeatMode repeatmode)
107 | {
108 | StringBuilder sb = new StringBuilder();
109 | if(ah.getPlayer().getPlayingTrack()!=null)
110 | {
111 | sb.append(ah.getStatusEmoji()).append(" **")
112 | .append(ah.getPlayer().getPlayingTrack().getInfo().title).append("**\n");
113 | }
114 | return FormatUtil.filter(sb.append(success).append(" Current Queue | ").append(songslength)
115 | .append(" entries | `").append(FormatUtil.formatTime(total)).append("` ")
116 | .append(repeatmode.getEmoji() != null ? "| "+repeatmode.getEmoji() : "").toString());
117 | }
118 | }
119 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/settings/SettingsManager.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2018 John Grosh .
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.settings;
17 |
18 | import com.jagrosh.jdautilities.command.GuildSettingsManager;
19 | import com.jagrosh.jmusicbot.utils.OtherUtil;
20 | import java.io.IOException;
21 | import java.nio.file.Files;
22 | import java.util.HashMap;
23 | import net.dv8tion.jda.api.entities.Guild;
24 | import org.json.JSONException;
25 | import org.json.JSONObject;
26 | import org.slf4j.LoggerFactory;
27 |
28 | /**
29 | *
30 | * @author John Grosh (john.a.grosh@gmail.com)
31 | */
32 | public class SettingsManager implements GuildSettingsManager
33 | {
34 | private final static double SKIP_RATIO = .55;
35 | private final HashMap settings;
36 |
37 | public SettingsManager()
38 | {
39 | this.settings = new HashMap<>();
40 | try {
41 | JSONObject loadedSettings = new JSONObject(new String(Files.readAllBytes(OtherUtil.getPath("serversettings.json"))));
42 | loadedSettings.keySet().forEach((id) -> {
43 | JSONObject o = loadedSettings.getJSONObject(id);
44 |
45 | // Legacy version support: On versions 0.3.3 and older, the repeat mode was represented as a boolean.
46 | if (!o.has("repeat_mode") && o.has("repeat") && o.getBoolean("repeat"))
47 | o.put("repeat_mode", RepeatMode.ALL);
48 |
49 |
50 | settings.put(Long.parseLong(id), new Settings(this,
51 | o.has("text_channel_id") ? o.getString("text_channel_id") : null,
52 | o.has("voice_channel_id")? o.getString("voice_channel_id") : null,
53 | o.has("dj_role_id") ? o.getString("dj_role_id") : null,
54 | o.has("volume") ? o.getInt("volume") : 100,
55 | o.has("default_playlist")? o.getString("default_playlist") : null,
56 | o.has("repeat_mode") ? o.getEnum(RepeatMode.class, "repeat_mode"): RepeatMode.OFF,
57 | o.has("prefix") ? o.getString("prefix") : null,
58 | o.has("skip_ratio") ? o.getDouble("skip_ratio") : SKIP_RATIO));
59 | });
60 | } catch(IOException | JSONException e) {
61 | LoggerFactory.getLogger("Settings").warn("Failed to load server settings (this is normal if no settings have been set yet): "+e);
62 | }
63 | }
64 |
65 | /**
66 | * Gets non-null settings for a Guild
67 | *
68 | * @param guild the guild to get settings for
69 | * @return the existing settings, or new settings for that guild
70 | */
71 | @Override
72 | public Settings getSettings(Guild guild)
73 | {
74 | return getSettings(guild.getIdLong());
75 | }
76 |
77 | public Settings getSettings(long guildId)
78 | {
79 | return settings.computeIfAbsent(guildId, id -> createDefaultSettings());
80 | }
81 |
82 | private Settings createDefaultSettings()
83 | {
84 | return new Settings(this, 0, 0, 0, 100, null, RepeatMode.OFF, null, SKIP_RATIO);
85 | }
86 |
87 | protected void writeSettings()
88 | {
89 | JSONObject obj = new JSONObject();
90 | settings.keySet().stream().forEach(key -> {
91 | JSONObject o = new JSONObject();
92 | Settings s = settings.get(key);
93 | if(s.textId!=0)
94 | o.put("text_channel_id", Long.toString(s.textId));
95 | if(s.voiceId!=0)
96 | o.put("voice_channel_id", Long.toString(s.voiceId));
97 | if(s.roleId!=0)
98 | o.put("dj_role_id", Long.toString(s.roleId));
99 | if(s.getVolume()!=100)
100 | o.put("volume",s.getVolume());
101 | if(s.getDefaultPlaylist() != null)
102 | o.put("default_playlist", s.getDefaultPlaylist());
103 | if(s.getRepeatMode()!=RepeatMode.OFF)
104 | o.put("repeat_mode", s.getRepeatMode());
105 | if(s.getPrefix() != null)
106 | o.put("prefix", s.getPrefix());
107 | if(s.getSkipRatio() != SKIP_RATIO)
108 | o.put("skip_ratio", s.getSkipRatio());
109 | obj.put(Long.toString(key), o);
110 | });
111 | try {
112 | Files.write(OtherUtil.getPath("serversettings.json"), obj.toString(4).getBytes());
113 | } catch(IOException ex){
114 | LoggerFactory.getLogger("Settings").warn("Failed to write to file: "+ex);
115 | }
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/Bot.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2018 John Grosh .
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot;
17 |
18 | import java.util.concurrent.Executors;
19 | import java.util.concurrent.ScheduledExecutorService;
20 | import com.jagrosh.jdautilities.commons.waiter.EventWaiter;
21 | import com.jagrosh.jmusicbot.audio.AloneInVoiceHandler;
22 | import com.jagrosh.jmusicbot.audio.AudioHandler;
23 | import com.jagrosh.jmusicbot.audio.NowplayingHandler;
24 | import com.jagrosh.jmusicbot.audio.PlayerManager;
25 | import com.jagrosh.jmusicbot.gui.GUI;
26 | import com.jagrosh.jmusicbot.playlist.PlaylistLoader;
27 | import com.jagrosh.jmusicbot.settings.SettingsManager;
28 | import java.util.Objects;
29 | import net.dv8tion.jda.api.JDA;
30 | import net.dv8tion.jda.api.entities.Activity;
31 | import net.dv8tion.jda.api.entities.Guild;
32 |
33 | /**
34 | *
35 | * @author John Grosh
36 | */
37 | public class Bot
38 | {
39 | private final EventWaiter waiter;
40 | private final ScheduledExecutorService threadpool;
41 | private final BotConfig config;
42 | private final SettingsManager settings;
43 | private final PlayerManager players;
44 | private final PlaylistLoader playlists;
45 | private final NowplayingHandler nowplaying;
46 | private final AloneInVoiceHandler aloneInVoiceHandler;
47 |
48 | private boolean shuttingDown = false;
49 | private JDA jda;
50 | private GUI gui;
51 |
52 | public Bot(EventWaiter waiter, BotConfig config, SettingsManager settings)
53 | {
54 | this.waiter = waiter;
55 | this.config = config;
56 | this.settings = settings;
57 | this.playlists = new PlaylistLoader(config);
58 | this.threadpool = Executors.newSingleThreadScheduledExecutor();
59 | this.players = new PlayerManager(this);
60 | this.players.init();
61 | this.nowplaying = new NowplayingHandler(this);
62 | this.nowplaying.init();
63 | this.aloneInVoiceHandler = new AloneInVoiceHandler(this);
64 | this.aloneInVoiceHandler.init();
65 | }
66 |
67 | public BotConfig getConfig()
68 | {
69 | return config;
70 | }
71 |
72 | public SettingsManager getSettingsManager()
73 | {
74 | return settings;
75 | }
76 |
77 | public EventWaiter getWaiter()
78 | {
79 | return waiter;
80 | }
81 |
82 | public ScheduledExecutorService getThreadpool()
83 | {
84 | return threadpool;
85 | }
86 |
87 | public PlayerManager getPlayerManager()
88 | {
89 | return players;
90 | }
91 |
92 | public PlaylistLoader getPlaylistLoader()
93 | {
94 | return playlists;
95 | }
96 |
97 | public NowplayingHandler getNowplayingHandler()
98 | {
99 | return nowplaying;
100 | }
101 |
102 | public AloneInVoiceHandler getAloneInVoiceHandler()
103 | {
104 | return aloneInVoiceHandler;
105 | }
106 |
107 | public JDA getJDA()
108 | {
109 | return jda;
110 | }
111 |
112 | public void closeAudioConnection(long guildId)
113 | {
114 | Guild guild = jda.getGuildById(guildId);
115 | if(guild!=null)
116 | threadpool.submit(() -> guild.getAudioManager().closeAudioConnection());
117 | }
118 |
119 | public void resetGame()
120 | {
121 | Activity game = config.getGame()==null || config.getGame().getName().equalsIgnoreCase("none") ? null : config.getGame();
122 | if(!Objects.equals(jda.getPresence().getActivity(), game))
123 | jda.getPresence().setActivity(game);
124 | }
125 |
126 | public void shutdown()
127 | {
128 | if(shuttingDown)
129 | return;
130 | shuttingDown = true;
131 | threadpool.shutdownNow();
132 | if(jda.getStatus()!=JDA.Status.SHUTTING_DOWN)
133 | {
134 | jda.getGuilds().stream().forEach(g ->
135 | {
136 | g.getAudioManager().closeAudioConnection();
137 | AudioHandler ah = (AudioHandler)g.getAudioManager().getSendingHandler();
138 | if(ah!=null)
139 | {
140 | ah.stopAndClear();
141 | ah.getPlayer().destroy();
142 | nowplaying.updateTopic(g.getIdLong(), ah, true);
143 | }
144 | });
145 | jda.shutdown();
146 | }
147 | if(gui!=null)
148 | gui.dispose();
149 | System.exit(0);
150 | }
151 |
152 | public void setJDA(JDA jda)
153 | {
154 | this.jda = jda;
155 | }
156 |
157 | public void setGUI(GUI gui)
158 | {
159 | this.gui = gui;
160 | }
161 | }
162 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/settings/Settings.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2016 John Grosh .
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.settings;
17 |
18 | import com.jagrosh.jdautilities.command.GuildSettingsProvider;
19 | import java.util.Collection;
20 | import java.util.Collections;
21 | import net.dv8tion.jda.api.entities.Guild;
22 | import net.dv8tion.jda.api.entities.Role;
23 | import net.dv8tion.jda.api.entities.TextChannel;
24 | import net.dv8tion.jda.api.entities.VoiceChannel;
25 |
26 | /**
27 | *
28 | * @author John Grosh
29 | */
30 | public class Settings implements GuildSettingsProvider
31 | {
32 | private final SettingsManager manager;
33 | protected long textId;
34 | protected long voiceId;
35 | protected long roleId;
36 | private int volume;
37 | private String defaultPlaylist;
38 | private RepeatMode repeatMode;
39 | private String prefix;
40 | private double skipRatio;
41 |
42 | public Settings(SettingsManager manager, String textId, String voiceId, String roleId, int volume, String defaultPlaylist, RepeatMode repeatMode, String prefix, double skipRatio)
43 | {
44 | this.manager = manager;
45 | try
46 | {
47 | this.textId = Long.parseLong(textId);
48 | }
49 | catch(NumberFormatException e)
50 | {
51 | this.textId = 0;
52 | }
53 | try
54 | {
55 | this.voiceId = Long.parseLong(voiceId);
56 | }
57 | catch(NumberFormatException e)
58 | {
59 | this.voiceId = 0;
60 | }
61 | try
62 | {
63 | this.roleId = Long.parseLong(roleId);
64 | }
65 | catch(NumberFormatException e)
66 | {
67 | this.roleId = 0;
68 | }
69 | this.volume = volume;
70 | this.defaultPlaylist = defaultPlaylist;
71 | this.repeatMode = repeatMode;
72 | this.prefix = prefix;
73 | this.skipRatio = skipRatio;
74 | }
75 |
76 | public Settings(SettingsManager manager, long textId, long voiceId, long roleId, int volume, String defaultPlaylist, RepeatMode repeatMode, String prefix, double skipRatio)
77 | {
78 | this.manager = manager;
79 | this.textId = textId;
80 | this.voiceId = voiceId;
81 | this.roleId = roleId;
82 | this.volume = volume;
83 | this.defaultPlaylist = defaultPlaylist;
84 | this.repeatMode = repeatMode;
85 | this.prefix = prefix;
86 | this.skipRatio = skipRatio;
87 | }
88 |
89 | // Getters
90 | public TextChannel getTextChannel(Guild guild)
91 | {
92 | return guild == null ? null : guild.getTextChannelById(textId);
93 | }
94 |
95 | public VoiceChannel getVoiceChannel(Guild guild)
96 | {
97 | return guild == null ? null : guild.getVoiceChannelById(voiceId);
98 | }
99 |
100 | public Role getRole(Guild guild)
101 | {
102 | return guild == null ? null : guild.getRoleById(roleId);
103 | }
104 |
105 | public int getVolume()
106 | {
107 | return volume;
108 | }
109 |
110 | public String getDefaultPlaylist()
111 | {
112 | return defaultPlaylist;
113 | }
114 |
115 | public RepeatMode getRepeatMode()
116 | {
117 | return repeatMode;
118 | }
119 |
120 | public String getPrefix()
121 | {
122 | return prefix;
123 | }
124 |
125 | public double getSkipRatio()
126 | {
127 | return skipRatio;
128 | }
129 |
130 | @Override
131 | public Collection getPrefixes()
132 | {
133 | return prefix == null ? Collections.emptySet() : Collections.singleton(prefix);
134 | }
135 |
136 | // Setters
137 | public void setTextChannel(TextChannel tc)
138 | {
139 | this.textId = tc == null ? 0 : tc.getIdLong();
140 | this.manager.writeSettings();
141 | }
142 |
143 | public void setVoiceChannel(VoiceChannel vc)
144 | {
145 | this.voiceId = vc == null ? 0 : vc.getIdLong();
146 | this.manager.writeSettings();
147 | }
148 |
149 | public void setDJRole(Role role)
150 | {
151 | this.roleId = role == null ? 0 : role.getIdLong();
152 | this.manager.writeSettings();
153 | }
154 |
155 | public void setVolume(int volume)
156 | {
157 | this.volume = volume;
158 | this.manager.writeSettings();
159 | }
160 |
161 | public void setDefaultPlaylist(String defaultPlaylist)
162 | {
163 | this.defaultPlaylist = defaultPlaylist;
164 | this.manager.writeSettings();
165 | }
166 |
167 | public void setRepeatMode(RepeatMode mode)
168 | {
169 | this.repeatMode = mode;
170 | this.manager.writeSettings();
171 | }
172 |
173 | public void setPrefix(String prefix)
174 | {
175 | this.prefix = prefix;
176 | this.manager.writeSettings();
177 | }
178 |
179 | public void setSkipRatio(double skipRatio)
180 | {
181 | this.skipRatio = skipRatio;
182 | this.manager.writeSettings();
183 | }
184 | }
185 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/gui/TextAreaOutputStream.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017 John Grosh .
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.gui;
17 |
18 | import java.awt.*;
19 | import java.io.*;
20 | import java.util.*;
21 | import java.util.List;
22 | import javax.swing.*;
23 | /**
24 | *
25 | * @author Lawrence Dol
26 | */
27 | public class TextAreaOutputStream extends OutputStream {
28 |
29 | // *************************************************************************************************
30 | // INSTANCE MEMBERS
31 | // *************************************************************************************************
32 |
33 | private byte[] oneByte; // array for write(int val);
34 | private Appender appender; // most recent action
35 |
36 | public TextAreaOutputStream(JTextArea txtara) {
37 | this(txtara,1000);
38 | }
39 |
40 | public TextAreaOutputStream(JTextArea txtara, int maxlin) {
41 | if(maxlin<1) { throw new IllegalArgumentException("TextAreaOutputStream maximum lines must be positive (value="+maxlin+")"); }
42 | oneByte=new byte[1];
43 | appender=new Appender(txtara,maxlin);
44 | }
45 |
46 | /** Clear the current console text area. */
47 | public synchronized void clear() {
48 | if(appender!=null) { appender.clear(); }
49 | }
50 |
51 | @Override
52 | public synchronized void close() {
53 | appender=null;
54 | }
55 |
56 | @Override
57 | public synchronized void flush() {
58 | /* empty */
59 | }
60 |
61 | @Override
62 | public synchronized void write(int val) {
63 | oneByte[0]=(byte)val;
64 | write(oneByte,0,1);
65 | }
66 |
67 | @Override
68 | public synchronized void write(byte[] ba) {
69 | write(ba,0,ba.length);
70 | }
71 |
72 | @Override
73 | public synchronized void write(byte[] ba,int str,int len) {
74 | if(appender!=null) { appender.append(bytesToString(ba,str,len)); }
75 | }
76 |
77 | //@edu.umd.cs.findbugs.annotations.SuppressWarnings("DM_DEFAULT_ENCODING")
78 | static private String bytesToString(byte[] ba, int str, int len) {
79 | try {
80 | return new String(ba,str,len,"UTF-8");
81 | } catch(UnsupportedEncodingException thr) {
82 | return new String(ba,str,len);
83 | } // all JVMs are required to support UTF-8
84 | }
85 |
86 | // *************************************************************************************************
87 | // STATIC MEMBERS
88 | // *************************************************************************************************
89 |
90 | static class Appender
91 | implements Runnable
92 | {
93 | static private final String EOL1="\n";
94 | static private final String EOL2=System.getProperty("line.separator",EOL1);
95 |
96 | private final JTextArea textArea;
97 | private final int maxLines; // maximum lines allowed in text area
98 | private final LinkedList lengths; // length of lines within text area
99 | private final List values; // values waiting to be appended
100 |
101 | private int curLength; // length of current line
102 | private boolean clear;
103 | private boolean queue;
104 |
105 | Appender(JTextArea txtara, int maxlin) {
106 | textArea =txtara;
107 | maxLines =maxlin;
108 | lengths =new LinkedList<>();
109 | values =new ArrayList<>();
110 |
111 | curLength=0;
112 | clear =false;
113 | queue =true;
114 | }
115 |
116 | private synchronized void append(String val) {
117 | values.add(val);
118 | if(queue) {
119 | queue=false;
120 | EventQueue.invokeLater(this);
121 | }
122 | }
123 |
124 | private synchronized void clear() {
125 | clear=true;
126 | curLength=0;
127 | lengths.clear();
128 | values.clear();
129 | if(queue) {
130 | queue=false;
131 | EventQueue.invokeLater(this);
132 | }
133 | }
134 |
135 | // MUST BE THE ONLY METHOD THAT TOUCHES textArea!
136 | @Override
137 | public synchronized void run() {
138 | if(clear) { textArea.setText(""); }
139 | values.stream().map((val) -> {
140 | curLength+=val.length();
141 | return val;
142 | }).map((val) -> {
143 | if(val.endsWith(EOL1) || val.endsWith(EOL2)) {
144 | if(lengths.size()>=maxLines) { textArea.replaceRange("",0,lengths.removeFirst()); }
145 | lengths.addLast(curLength);
146 | curLength=0;
147 | }
148 | return val;
149 | }).forEach((val) -> {
150 | textArea.append(val);
151 | });
152 | values.clear();
153 | clear =false;
154 | queue =true;
155 | }
156 | }
157 | } /* END PUBLIC CLASS */
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/commands/dj/PlaynextCmd.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2018 John Grosh .
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.commands.dj;
17 |
18 | import com.jagrosh.jdautilities.command.CommandEvent;
19 | import com.jagrosh.jmusicbot.Bot;
20 | import com.jagrosh.jmusicbot.audio.AudioHandler;
21 | import com.jagrosh.jmusicbot.audio.QueuedTrack;
22 | import com.jagrosh.jmusicbot.commands.DJCommand;
23 | import com.jagrosh.jmusicbot.utils.FormatUtil;
24 | import com.sedmelluq.discord.lavaplayer.player.AudioLoadResultHandler;
25 | import com.sedmelluq.discord.lavaplayer.tools.FriendlyException;
26 | import com.sedmelluq.discord.lavaplayer.track.AudioPlaylist;
27 | import com.sedmelluq.discord.lavaplayer.track.AudioTrack;
28 | import net.dv8tion.jda.api.entities.Message;
29 |
30 | /**
31 | *
32 | * @author John Grosh (john.a.grosh@gmail.com)
33 | */
34 | public class PlaynextCmd extends DJCommand
35 | {
36 | private final String loadingEmoji;
37 |
38 | public PlaynextCmd(Bot bot)
39 | {
40 | super(bot);
41 | this.loadingEmoji = bot.getConfig().getLoading();
42 | this.name = "playnext";
43 | this.arguments = "";
44 | this.help = "plays a single song next";
45 | this.aliases = bot.getConfig().getAliases(this.name);
46 | this.beListening = true;
47 | this.bePlaying = false;
48 | }
49 |
50 | @Override
51 | public void doCommand(CommandEvent event)
52 | {
53 | if(event.getArgs().isEmpty() && event.getMessage().getAttachments().isEmpty())
54 | {
55 | event.replyWarning("Please include a song title or URL!");
56 | return;
57 | }
58 | String args = event.getArgs().startsWith("<") && event.getArgs().endsWith(">")
59 | ? event.getArgs().substring(1,event.getArgs().length()-1)
60 | : event.getArgs().isEmpty() ? event.getMessage().getAttachments().get(0).getUrl() : event.getArgs();
61 | event.reply(loadingEmoji+" Loading... `["+args+"]`", m -> bot.getPlayerManager().loadItemOrdered(event.getGuild(), args, new ResultHandler(m,event,false)));
62 | }
63 |
64 | private class ResultHandler implements AudioLoadResultHandler
65 | {
66 | private final Message m;
67 | private final CommandEvent event;
68 | private final boolean ytsearch;
69 |
70 | private ResultHandler(Message m, CommandEvent event, boolean ytsearch)
71 | {
72 | this.m = m;
73 | this.event = event;
74 | this.ytsearch = ytsearch;
75 | }
76 |
77 | private void loadSingle(AudioTrack track)
78 | {
79 | if(bot.getConfig().isTooLong(track))
80 | {
81 | m.editMessage(FormatUtil.filter(event.getClient().getWarning()+" This track (**"+track.getInfo().title+"**) is longer than the allowed maximum: `"
82 | +FormatUtil.formatTime(track.getDuration())+"` > `"+FormatUtil.formatTime(bot.getConfig().getMaxSeconds()*1000)+"`")).queue();
83 | return;
84 | }
85 | AudioHandler handler = (AudioHandler)event.getGuild().getAudioManager().getSendingHandler();
86 | int pos = handler.addTrackToFront(new QueuedTrack(track, event.getAuthor()))+1;
87 | String addMsg = FormatUtil.filter(event.getClient().getSuccess()+" Added **"+track.getInfo().title
88 | +"** (`"+FormatUtil.formatTime(track.getDuration())+"`) "+(pos==0?"to begin playing":" to the queue at position "+pos));
89 | m.editMessage(addMsg).queue();
90 | }
91 |
92 | @Override
93 | public void trackLoaded(AudioTrack track)
94 | {
95 | loadSingle(track);
96 | }
97 |
98 | @Override
99 | public void playlistLoaded(AudioPlaylist playlist)
100 | {
101 | AudioTrack single;
102 | if(playlist.getTracks().size()==1 || playlist.isSearchResult())
103 | single = playlist.getSelectedTrack()==null ? playlist.getTracks().get(0) : playlist.getSelectedTrack();
104 | else if (playlist.getSelectedTrack()!=null)
105 | single = playlist.getSelectedTrack();
106 | else
107 | single = playlist.getTracks().get(0);
108 | loadSingle(single);
109 | }
110 |
111 | @Override
112 | public void noMatches()
113 | {
114 | if(ytsearch)
115 | m.editMessage(FormatUtil.filter(event.getClient().getWarning()+" No results found for `"+event.getArgs()+"`.")).queue();
116 | else
117 | bot.getPlayerManager().loadItemOrdered(event.getGuild(), "ytsearch:"+event.getArgs(), new ResultHandler(m,event,true));
118 | }
119 |
120 | @Override
121 | public void loadFailed(FriendlyException throwable)
122 | {
123 | if(throwable.severity==FriendlyException.Severity.COMMON)
124 | m.editMessage(event.getClient().getError()+" Error loading: "+throwable.getMessage()).queue();
125 | else
126 | m.editMessage(event.getClient().getError()+" Error loading track.").queue();
127 | }
128 | }
129 | }
130 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/commands/owner/SetgameCmd.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017 John Grosh .
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.commands.owner;
17 |
18 | import com.jagrosh.jdautilities.command.CommandEvent;
19 | import com.jagrosh.jmusicbot.Bot;
20 | import com.jagrosh.jmusicbot.commands.OwnerCommand;
21 | import net.dv8tion.jda.api.entities.Activity;
22 |
23 | /**
24 | *
25 | * @author John Grosh
26 | */
27 | public class SetgameCmd extends OwnerCommand
28 | {
29 | public SetgameCmd(Bot bot)
30 | {
31 | this.name = "setgame";
32 | this.help = "sets the game the bot is playing";
33 | this.arguments = "[action] [game]";
34 | this.aliases = bot.getConfig().getAliases(this.name);
35 | this.guildOnly = false;
36 | this.children = new OwnerCommand[]{
37 | new SetlistenCmd(),
38 | new SetstreamCmd(),
39 | new SetwatchCmd()
40 | };
41 | }
42 |
43 | @Override
44 | protected void execute(CommandEvent event)
45 | {
46 | String title = event.getArgs().toLowerCase().startsWith("playing") ? event.getArgs().substring(7).trim() : event.getArgs();
47 | try
48 | {
49 | event.getJDA().getPresence().setActivity(title.isEmpty() ? null : Activity.playing(title));
50 | event.reply(event.getClient().getSuccess()+" **"+event.getSelfUser().getName()
51 | +"** is "+(title.isEmpty() ? "no longer playing anything." : "now playing `"+title+"`"));
52 | }
53 | catch(Exception e)
54 | {
55 | event.reply(event.getClient().getError()+" The game could not be set!");
56 | }
57 | }
58 |
59 | private class SetstreamCmd extends OwnerCommand
60 | {
61 | private SetstreamCmd()
62 | {
63 | this.name = "stream";
64 | this.aliases = new String[]{"twitch","streaming"};
65 | this.help = "sets the game the bot is playing to a stream";
66 | this.arguments = " ";
67 | this.guildOnly = false;
68 | }
69 |
70 | @Override
71 | protected void execute(CommandEvent event)
72 | {
73 | String[] parts = event.getArgs().split("\\s+", 2);
74 | if(parts.length<2)
75 | {
76 | event.replyError("Please include a twitch username and the name of the game to 'stream'");
77 | return;
78 | }
79 | try
80 | {
81 | event.getJDA().getPresence().setActivity(Activity.streaming(parts[1], "https://twitch.tv/"+parts[0]));
82 | event.replySuccess("**"+event.getSelfUser().getName()
83 | +"** is now streaming `"+parts[1]+"`");
84 | }
85 | catch(Exception e)
86 | {
87 | event.reply(event.getClient().getError()+" The game could not be set!");
88 | }
89 | }
90 | }
91 |
92 | private class SetlistenCmd extends OwnerCommand
93 | {
94 | private SetlistenCmd()
95 | {
96 | this.name = "listen";
97 | this.aliases = new String[]{"listening"};
98 | this.help = "sets the game the bot is listening to";
99 | this.arguments = "";
100 | this.guildOnly = false;
101 | }
102 |
103 | @Override
104 | protected void execute(CommandEvent event)
105 | {
106 | if(event.getArgs().isEmpty())
107 | {
108 | event.replyError("Please include a title to listen to!");
109 | return;
110 | }
111 | String title = event.getArgs().toLowerCase().startsWith("to") ? event.getArgs().substring(2).trim() : event.getArgs();
112 | try
113 | {
114 | event.getJDA().getPresence().setActivity(Activity.listening(title));
115 | event.replySuccess("**"+event.getSelfUser().getName()+"** is now listening to `"+title+"`");
116 | } catch(Exception e) {
117 | event.reply(event.getClient().getError()+" The game could not be set!");
118 | }
119 | }
120 | }
121 |
122 | private class SetwatchCmd extends OwnerCommand
123 | {
124 | private SetwatchCmd()
125 | {
126 | this.name = "watch";
127 | this.aliases = new String[]{"watching"};
128 | this.help = "sets the game the bot is watching";
129 | this.arguments = "<title>";
130 | this.guildOnly = false;
131 | }
132 |
133 | @Override
134 | protected void execute(CommandEvent event)
135 | {
136 | if(event.getArgs().isEmpty())
137 | {
138 | event.replyError("Please include a title to watch!");
139 | return;
140 | }
141 | String title = event.getArgs();
142 | try
143 | {
144 | event.getJDA().getPresence().setActivity(Activity.watching(title));
145 | event.replySuccess("**"+event.getSelfUser().getName()+"** is now watching `"+title+"`");
146 | } catch(Exception e) {
147 | event.reply(event.getClient().getError()+" The game could not be set!");
148 | }
149 | }
150 | }
151 | }
152 |
--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3 | <modelVersion>4.0.0</modelVersion>
4 | <groupId>com.jagrosh</groupId>
5 | <artifactId>JMusicBot</artifactId>
6 | <version>Snapshot</version>
7 | <packaging>jar</packaging>
8 |
9 | <repositories>
10 | <repository>
11 | <id>dv8tion</id>
12 | <name>m2-dv8tion</name>
13 | <url>https://m2.dv8tion.net/releases</url>
14 | </repository>
15 | <repository>
16 | <id>central</id>
17 | <name>bintray</name>
18 | <url>https://jcenter.bintray.com</url>
19 | </repository>
20 | <repository>
21 | <id>jitpack.io</id>
22 | <url>https://jitpack.io</url>
23 | <snapshots>
24 | <enabled>true</enabled>
25 | <updatePolicy>always</updatePolicy>
26 | </snapshots>
27 | </repository>
28 | </repositories>
29 |
30 | <dependencies>
31 | <!-- Discord Dependencies -->
32 | <dependency>
33 | <groupId>net.dv8tion</groupId>
34 | <artifactId>JDA</artifactId>
35 | <version>4.4.1_353</version>
36 | </dependency>
37 | <dependency>
38 | <groupId>com.jagrosh</groupId>
39 | <artifactId>jda-utilities</artifactId>
40 | <version>3.0.5</version>
41 | <type>pom</type>
42 | </dependency>
43 |
44 | <!-- Music Dependencies -->
45 | <!-- using a fork of this to fix some issues faster -->
46 | <!-- dependency>
47 | <groupId>com.sedmelluq</groupId>
48 | <artifactId>lavaplayer</artifactId>
49 | <version>1.3.78</version>
50 | </dependency -->
51 | <dependency>
52 | <groupId>com.github.jagrosh</groupId>
53 | <artifactId>lavaplayer</artifactId>
54 | <version>jmusicbot-SNAPSHOT</version>
55 | </dependency>
56 | <!-- this is needed, but isn't actually hosted anywhere anymore... uh -->
57 | <!--dependency>
58 | <groupId>com.sedmelluq</groupId>
59 | <artifactId>lavaplayer-natives-extra</artifactId>
60 | <version>1.3.13</version>
61 | </dependency-->
62 | <dependency>
63 | <groupId>com.github.jagrosh</groupId>
64 | <artifactId>JLyrics</artifactId>
65 | <version>master-SNAPSHOT</version>
66 | </dependency>
67 |
68 | <!-- Misc Internal Dependencies -->
69 | <dependency>
70 | <groupId>ch.qos.logback</groupId>
71 | <artifactId>logback-classic</artifactId>
72 | <version>1.2.3</version>
73 | </dependency>
74 | <dependency>
75 | <groupId>com.typesafe</groupId>
76 | <artifactId>config</artifactId>
77 | <version>1.3.2</version>
78 | </dependency>
79 | <dependency>
80 | <groupId>org.jsoup</groupId>
81 | <artifactId>jsoup</artifactId>
82 | <version>1.15.3</version>
83 | </dependency>
84 |
85 | <!-- Testing Dependencies -->
86 | <dependency>
87 | <groupId>junit</groupId>
88 | <artifactId>junit</artifactId>
89 | <version>4.13.1</version>
90 | <scope>test</scope>
91 | </dependency>
92 | <dependency>
93 | <groupId>org.hamcrest</groupId>
94 | <artifactId>hamcrest-core</artifactId>
95 | <version>1.3</version>
96 | <scope>test</scope>
97 | </dependency>
98 | </dependencies>
99 |
100 | <build>
101 | <plugins>
102 | <plugin>
103 | <groupId>org.apache.maven.plugins</groupId>
104 | <artifactId>maven-shade-plugin</artifactId>
105 | <version>1.5</version>
106 | <executions>
107 | <execution>
108 | <phase>package</phase>
109 | <goals>
110 | <goal>shade</goal>
111 | </goals>
112 | <configuration>
113 | <shadedArtifactAttached>true</shadedArtifactAttached>
114 | <shadedClassifierName>All</shadedClassifierName>
115 | <artifactSet>
116 | <includes>
117 | <include>*:*</include>
118 | </includes>
119 | </artifactSet>
120 | <transformers>
121 | <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
122 | <resource>reference.conf</resource>
123 | </transformer>
124 | <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
125 | <manifestEntries>
126 | <Main-Class>com.jagrosh.jmusicbot.JMusicBot</Main-Class>
127 | <Specification-Title>${project.artifactId}</Specification-Title>
128 | <Specification-Version>${project.version}</Specification-Version>
129 | <Implementation-Title>${project.artifactId}</Implementation-Title>
130 | <Implementation-Version>${project.version}</Implementation-Version>
131 | <Implementation-Vendor-Id>${project.groupId}</Implementation-Vendor-Id>
132 | </manifestEntries>
133 | </transformer>
134 | </transformers>
135 | </configuration>
136 | </execution>
137 | </executions>
138 | </plugin>
139 | </plugins>
140 | </build>
141 |
142 | <properties>
143 | <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
144 | <maven.compiler.source>1.8</maven.compiler.source>
145 | <maven.compiler.target>1.8</maven.compiler.target>
146 | </properties>
147 | </project>
148 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/audio/NowplayingHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2018 John Grosh <john.a.grosh@gmail.com>.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.audio;
17 |
18 | import com.jagrosh.jmusicbot.Bot;
19 | import com.jagrosh.jmusicbot.entities.Pair;
20 | import com.jagrosh.jmusicbot.settings.Settings;
21 | import com.sedmelluq.discord.lavaplayer.track.AudioTrack;
22 | import java.util.HashMap;
23 | import java.util.HashSet;
24 | import java.util.Set;
25 | import java.util.concurrent.TimeUnit;
26 | import net.dv8tion.jda.api.Permission;
27 | import net.dv8tion.jda.api.entities.Activity;
28 | import net.dv8tion.jda.api.entities.Guild;
29 | import net.dv8tion.jda.api.entities.Message;
30 | import net.dv8tion.jda.api.entities.TextChannel;
31 | import net.dv8tion.jda.api.exceptions.PermissionException;
32 | import net.dv8tion.jda.api.exceptions.RateLimitedException;
33 |
34 | /**
35 | *
36 | * @author John Grosh (john.a.grosh@gmail.com)
37 | */
38 | public class NowplayingHandler
39 | {
40 | private final Bot bot;
41 | private final HashMap<Long,Pair<Long,Long>> lastNP; // guild -> channel,message
42 |
43 | public NowplayingHandler(Bot bot)
44 | {
45 | this.bot = bot;
46 | this.lastNP = new HashMap<>();
47 | }
48 |
49 | public void init()
50 | {
51 | if(!bot.getConfig().useNPImages())
52 | bot.getThreadpool().scheduleWithFixedDelay(() -> updateAll(), 0, 5, TimeUnit.SECONDS);
53 | }
54 |
55 | public void setLastNPMessage(Message m)
56 | {
57 | lastNP.put(m.getGuild().getIdLong(), new Pair<>(m.getTextChannel().getIdLong(), m.getIdLong()));
58 | }
59 |
60 | public void clearLastNPMessage(Guild guild)
61 | {
62 | lastNP.remove(guild.getIdLong());
63 | }
64 |
65 | private void updateAll()
66 | {
67 | Set<Long> toRemove = new HashSet<>();
68 | for(long guildId: lastNP.keySet())
69 | {
70 | Guild guild = bot.getJDA().getGuildById(guildId);
71 | if(guild==null)
72 | {
73 | toRemove.add(guildId);
74 | continue;
75 | }
76 | Pair<Long,Long> pair = lastNP.get(guildId);
77 | TextChannel tc = guild.getTextChannelById(pair.getKey());
78 | if(tc==null)
79 | {
80 | toRemove.add(guildId);
81 | continue;
82 | }
83 | AudioHandler handler = (AudioHandler)guild.getAudioManager().getSendingHandler();
84 | Message msg = handler.getNowPlaying(bot.getJDA());
85 | if(msg==null)
86 | {
87 | msg = handler.getNoMusicPlaying(bot.getJDA());
88 | toRemove.add(guildId);
89 | }
90 | try
91 | {
92 | tc.editMessageById(pair.getValue(), msg).queue(m->{}, t -> lastNP.remove(guildId));
93 | }
94 | catch(Exception e)
95 | {
96 | toRemove.add(guildId);
97 | }
98 | }
99 | toRemove.forEach(id -> lastNP.remove(id));
100 | }
101 |
102 | public void updateTopic(long guildId, AudioHandler handler, boolean wait)
103 | {
104 | Guild guild = bot.getJDA().getGuildById(guildId);
105 | if(guild==null)
106 | return;
107 | Settings settings = bot.getSettingsManager().getSettings(guildId);
108 | TextChannel tchan = settings.getTextChannel(guild);
109 | if(tchan!=null && guild.getSelfMember().hasPermission(tchan, Permission.MANAGE_CHANNEL))
110 | {
111 | String otherText;
112 | String topic = tchan.getTopic();
113 | if(topic==null || topic.isEmpty())
114 | otherText = "\u200B";
115 | else if(topic.contains("\u200B"))
116 | otherText = topic.substring(topic.lastIndexOf("\u200B"));
117 | else
118 | otherText = "\u200B\n "+topic;
119 | String text = handler.getTopicFormat(bot.getJDA()) + otherText;
120 | if(!text.equals(tchan.getTopic()))
121 | {
122 | try
123 | {
124 | // normally here if 'wait' was false, we'd want to queue, however,
125 | // new discord ratelimits specifically limiting changing channel topics
126 | // mean we don't want a backlog of changes piling up, so if we hit a
127 | // ratelimit, we just won't change the topic this time
128 | tchan.getManager().setTopic(text).complete(wait);
129 | }
130 | catch(PermissionException | RateLimitedException ignore) {}
131 | }
132 | }
133 | }
134 |
135 | // "event"-based methods
136 | public void onTrackUpdate(long guildId, AudioTrack track, AudioHandler handler)
137 | {
138 | // update bot status if applicable
139 | if(bot.getConfig().getSongInStatus())
140 | {
141 | if(track!=null && bot.getJDA().getGuilds().stream().filter(g -> g.getSelfMember().getVoiceState().inVoiceChannel()).count()<=1)
142 | bot.getJDA().getPresence().setActivity(Activity.listening(track.getInfo().title));
143 | else
144 | bot.resetGame();
145 | }
146 |
147 | // update channel topic if applicable
148 | updateTopic(guildId, handler, false);
149 | }
150 |
151 | public void onMessageDelete(Guild guild, long messageId)
152 | {
153 | Pair<Long,Long> pair = lastNP.get(guild.getIdLong());
154 | if(pair==null)
155 | return;
156 | if(pair.getValue() == messageId)
157 | lastNP.remove(guild.getIdLong());
158 | }
159 | }
160 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/commands/music/SearchCmd.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2016 John Grosh <john.a.grosh@gmail.com>.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.commands.music;
17 |
18 | import com.sedmelluq.discord.lavaplayer.player.AudioLoadResultHandler;
19 | import com.sedmelluq.discord.lavaplayer.tools.FriendlyException;
20 | import com.sedmelluq.discord.lavaplayer.tools.FriendlyException.Severity;
21 | import com.sedmelluq.discord.lavaplayer.track.AudioPlaylist;
22 | import com.sedmelluq.discord.lavaplayer.track.AudioTrack;
23 | import java.util.concurrent.TimeUnit;
24 | import com.jagrosh.jdautilities.command.CommandEvent;
25 | import com.jagrosh.jdautilities.menu.OrderedMenu;
26 | import com.jagrosh.jmusicbot.Bot;
27 | import com.jagrosh.jmusicbot.audio.AudioHandler;
28 | import com.jagrosh.jmusicbot.audio.QueuedTrack;
29 | import com.jagrosh.jmusicbot.commands.MusicCommand;
30 | import com.jagrosh.jmusicbot.utils.FormatUtil;
31 | import net.dv8tion.jda.api.Permission;
32 | import net.dv8tion.jda.api.entities.Message;
33 |
34 | /**
35 | *
36 | * @author John Grosh <john.a.grosh@gmail.com>
37 | */
38 | public class SearchCmd extends MusicCommand
39 | {
40 | protected String searchPrefix = "ytsearch:";
41 | private final OrderedMenu.Builder builder;
42 | private final String searchingEmoji;
43 |
44 | public SearchCmd(Bot bot)
45 | {
46 | super(bot);
47 | this.searchingEmoji = bot.getConfig().getSearching();
48 | this.name = "search";
49 | this.aliases = bot.getConfig().getAliases(this.name);
50 | this.arguments = "<query>";
51 | this.help = "searches Youtube for a provided query";
52 | this.beListening = true;
53 | this.bePlaying = false;
54 | this.botPermissions = new Permission[]{Permission.MESSAGE_EMBED_LINKS};
55 | builder = new OrderedMenu.Builder()
56 | .allowTextInput(true)
57 | .useNumbers()
58 | .useCancelButton(true)
59 | .setEventWaiter(bot.getWaiter())
60 | .setTimeout(1, TimeUnit.MINUTES);
61 | }
62 | @Override
63 | public void doCommand(CommandEvent event)
64 | {
65 | if(event.getArgs().isEmpty())
66 | {
67 | event.replyError("Please include a query.");
68 | return;
69 | }
70 | event.reply(searchingEmoji+" Searching... `["+event.getArgs()+"]`",
71 | m -> bot.getPlayerManager().loadItemOrdered(event.getGuild(), searchPrefix + event.getArgs(), new ResultHandler(m,event)));
72 | }
73 |
74 | private class ResultHandler implements AudioLoadResultHandler
75 | {
76 | private final Message m;
77 | private final CommandEvent event;
78 |
79 | private ResultHandler(Message m, CommandEvent event)
80 | {
81 | this.m = m;
82 | this.event = event;
83 | }
84 |
85 | @Override
86 | public void trackLoaded(AudioTrack track)
87 | {
88 | if(bot.getConfig().isTooLong(track))
89 | {
90 | m.editMessage(FormatUtil.filter(event.getClient().getWarning()+" This track (**"+track.getInfo().title+"**) is longer than the allowed maximum: `"
91 | +FormatUtil.formatTime(track.getDuration())+"` > `"+bot.getConfig().getMaxTime()+"`")).queue();
92 | return;
93 | }
94 | AudioHandler handler = (AudioHandler)event.getGuild().getAudioManager().getSendingHandler();
95 | int pos = handler.addTrack(new QueuedTrack(track, event.getAuthor()))+1;
96 | m.editMessage(FormatUtil.filter(event.getClient().getSuccess()+" Added **"+track.getInfo().title
97 | +"** (`"+FormatUtil.formatTime(track.getDuration())+"`) "+(pos==0 ? "to begin playing"
98 | : " to the queue at position "+pos))).queue();
99 | }
100 |
101 | @Override
102 | public void playlistLoaded(AudioPlaylist playlist)
103 | {
104 | builder.setColor(event.getSelfMember().getColor())
105 | .setText(FormatUtil.filter(event.getClient().getSuccess()+" Search results for `"+event.getArgs()+"`:"))
106 | .setChoices(new String[0])
107 | .setSelection((msg,i) ->
108 | {
109 | AudioTrack track = playlist.getTracks().get(i-1);
110 | if(bot.getConfig().isTooLong(track))
111 | {
112 | event.replyWarning("This track (**"+track.getInfo().title+"**) is longer than the allowed maximum: `"
113 | +FormatUtil.formatTime(track.getDuration())+"` > `"+bot.getConfig().getMaxTime()+"`");
114 | return;
115 | }
116 | AudioHandler handler = (AudioHandler)event.getGuild().getAudioManager().getSendingHandler();
117 | int pos = handler.addTrack(new QueuedTrack(track, event.getAuthor()))+1;
118 | event.replySuccess("Added **" + FormatUtil.filter(track.getInfo().title)
119 | + "** (`" + FormatUtil.formatTime(track.getDuration()) + "`) " + (pos==0 ? "to begin playing"
120 | : " to the queue at position "+pos));
121 | })
122 | .setCancel((msg) -> {})
123 | .setUsers(event.getAuthor())
124 | ;
125 | for(int i=0; i<4 && i<playlist.getTracks().size(); i++)
126 | {
127 | AudioTrack track = playlist.getTracks().get(i);
128 | builder.addChoices("`["+FormatUtil.formatTime(track.getDuration())+"]` [**"+track.getInfo().title+"**]("+track.getInfo().uri+")");
129 | }
130 | builder.build().display(m);
131 | }
132 |
133 | @Override
134 | public void noMatches()
135 | {
136 | m.editMessage(FormatUtil.filter(event.getClient().getWarning()+" No results found for `"+event.getArgs()+"`.")).queue();
137 | }
138 |
139 | @Override
140 | public void loadFailed(FriendlyException throwable)
141 | {
142 | if(throwable.severity==Severity.COMMON)
143 | m.editMessage(event.getClient().getError()+" Error loading: "+throwable.getMessage()).queue();
144 | else
145 | m.editMessage(event.getClient().getError()+" Error loading track.").queue();
146 | }
147 | }
148 | }
149 |
--------------------------------------------------------------------------------
/src/main/resources/reference.conf:
--------------------------------------------------------------------------------
1 | /// START OF JMUSICBOT CONFIG ///
2 | /////////////////////////////////////////////////////////
3 | // Config for the JMusicBot //
4 | /////////////////////////////////////////////////////////
5 | // Any line starting with // is ignored //
6 | // You MUST set the token and owner //
7 | // All other items have defaults if you don't set them //
8 | // Open in Notepad++ for best results //
9 | /////////////////////////////////////////////////////////
10 |
11 |
12 | // This sets the token for the bot to log in with
13 | // This MUST be a bot token (user tokens will not work)
14 | // If you don't know how to get a bot token, please see the guide here:
15 | // https://github.com/jagrosh/MusicBot/wiki/Getting-a-Bot-Token
16 |
17 | token = BOT_TOKEN_HERE
18 |
19 |
20 | // This sets the owner of the bot
21 | // This needs to be the owner's ID (a 17-18 digit number)
22 | // https://github.com/jagrosh/MusicBot/wiki/Finding-Your-User-ID
23 |
24 | owner = 0 // OWNER ID
25 |
26 |
27 | // This sets the prefix for the bot
28 | // The prefix is used to control the commands
29 | // If you use !!, the play command will be !!play
30 | // If you do not set this, the prefix will be a mention of the bot (@Botname play)
31 |
32 | prefix = "@mention"
33 |
34 |
35 | // If you set this, it modifies the default game of the bot
36 | // Set this to NONE to have no game
37 | // Set this to DEFAULT to use the default game
38 | // You can make the game "Playing X", "Listening to X", or "Watching X"
39 | // where X is the title. If you don't include an action, it will use the
40 | // default of "Playing"
41 |
42 | game = "DEFAULT"
43 |
44 |
45 | // If you set this, it will modify the default status of bot
46 | // Valid values: ONLINE IDLE DND INVISIBLE
47 |
48 | status = ONLINE
49 |
50 |
51 | // If you set this to true, the bot will list the title of the song it is currently playing in its
52 | // "Playing" status. Note that this will ONLY work if the bot is playing music on ONE guild;
53 | // if the bot is playing on multiple guilds, this will not work.
54 |
55 | songinstatus=false
56 |
57 |
58 | // If you set this, the bot will also use this prefix in addition to
59 | // the one provided above
60 |
61 | altprefix = "NONE"
62 |
63 |
64 | // If you set these, it will change the various emojis
65 |
66 | success = "🎶"
67 | warning = "💡"
68 | error = "🚫"
69 | loading = "⌚"
70 | searching = "🔎"
71 |
72 |
73 | // If you set this, you change the word used to view the help.
74 | // For example, if you set the prefix to !! and the help to cmds, you would type
75 | // !!cmds to see the help text
76 |
77 | help = help
78 |
79 |
80 | // If you set this, the "nowplaying" command will show youtube thumbnails
81 | // Note: If you set this to true, the nowplaying boxes will NOT refresh
82 | // This is because refreshing the boxes causes the image to be reloaded
83 | // every time it refreshes.
84 |
85 | npimages = false
86 |
87 |
88 | // If you set this, the bot will not leave a voice channel after it finishes a queue.
89 | // Keep in mind that being connected to a voice channel uses additional bandwith,
90 | // so this option is not recommended if bandwidth is a concern.
91 |
92 | stayinchannel = false
93 |
94 |
95 | // This sets the maximum amount of seconds any track loaded can be. If not set or set
96 | // to any number less than or equal to zero, there is no maximum time length. This time
97 | // restriction applies to songs loaded from any source.
98 |
99 | maxtime = 0
100 |
101 |
102 | // This sets the amount of seconds the bot will stay alone on a voice channel until it
103 | // automatically leaves the voice channel and clears the queue. If not set or set
104 | // to any number less than or equal to zero, the bot won't leave when alone.
105 |
106 | alonetimeuntilstop = 0
107 |
108 |
109 | // This sets an alternative folder to be used as the Playlists folder
110 | // This can be a relative or absolute path
111 |
112 | playlistsfolder = "Playlists"
113 |
114 |
115 | // By default, the bot will DM the owner if the bot is running and a new version of the bot
116 | // becomes available. Set this to false to disable this feature.
117 |
118 | updatealerts=true
119 |
120 |
121 | // Changing this changes the lyrics provider
122 | // Currently available providers: "A-Z Lyrics", "Genius", "MusicMatch", "LyricsFreak"
123 | // At the time of writing, I would recommend sticking with A-Z Lyrics or MusicMatch,
124 | // as Genius tends to have a lot of non-song results and you might get something
125 | // completely unrelated to what you want.
126 | // If you are interested in contributing a provider, please see
127 | // https://github.com/jagrosh/JLyrics
128 |
129 | lyrics.default = "A-Z Lyrics"
130 |
131 |
132 | // These settings allow you to configure custom aliases for all commands.
133 | // Multiple aliases may be given, separated by commas.
134 | //
135 | // Example 1: Giving command "play" the alias "p":
136 | // play = [ p ]
137 | //
138 | // Example 2: Giving command "search" the aliases "yts" and "find":
139 | // search = [ yts, find ]
140 |
141 | aliases {
142 | // General commands
143 | settings = [ status ]
144 |
145 | // Music commands
146 | lyrics = []
147 | nowplaying = [ np, current ]
148 | play = []
149 | playlists = [ pls ]
150 | queue = [ list ]
151 | remove = [ delete ]
152 | scsearch = []
153 | search = [ ytsearch ]
154 | shuffle = []
155 | skip = [ voteskip ]
156 |
157 | // Admin commands
158 | prefix = [ setprefix ]
159 | setdj = []
160 | setskip = [ setskippercent, skippercent, setskipratio ]
161 | settc = []
162 | setvc = []
163 |
164 | // DJ Commands
165 | forceremove = [ forcedelete, modremove, moddelete, modelete ]
166 | forceskip = [ modskip ]
167 | movetrack = [ move ]
168 | pause = []
169 | playnext = []
170 | repeat = []
171 | skipto = [ jumpto ]
172 | stop = [ leave ]
173 | volume = [ vol ]
174 | }
175 |
176 |
177 | // Transforms are used to modify specific play inputs and convert them to different kinds of inputs
178 | // These are quite complicated to use, and have limited use-cases, but in theory allow for rough
179 | // whitelists or blacklists, roundabout loading from some sources, and customization of how things are
180 | // requested.
181 | //
182 | // These are NOT EASY to set up, so if you want to use these, you'll need to look through the code
183 | // for how they work and what fields are needed. Also, it's possible this feature might get entirely
184 | // removed in the future if I find a better way to do this.
185 |
186 | transforms = {}
187 |
188 |
189 | // If you set this to true, it will enable the eval command for the bot owner. This command
190 | // allows the bot owner to run arbitrary code from the bot's account.
191 | //
192 | // WARNING:
193 | // This command can be extremely dangerous. If you don't know what you're doing, you could
194 | // cause horrific problems on your Discord server or on whatever computer this bot is running
195 | // on. Never run this command unless you are completely positive what you are running.
196 | //
197 | // DO NOT ENABLE THIS IF YOU DON'T KNOW WHAT THIS DOES OR HOW TO USE IT
198 | // IF SOMEONE ASKS YOU TO ENABLE THIS, THERE IS AN 11/10 CHANCE THEY ARE TRYING TO SCAM YOU
199 |
200 | eval=false
201 |
202 |
203 | /// END OF JMUSICBOT CONFIG ///
204 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/utils/OtherUtil.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2018 John Grosh <john.a.grosh@gmail.com>.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.utils;
17 |
18 | import com.jagrosh.jmusicbot.JMusicBot;
19 | import com.jagrosh.jmusicbot.entities.Prompt;
20 | import java.io.*;
21 | import java.net.URISyntaxException;
22 | import java.net.URL;
23 | import java.net.URLConnection;
24 | import java.nio.file.Path;
25 | import java.nio.file.Paths;
26 | import net.dv8tion.jda.api.OnlineStatus;
27 | import net.dv8tion.jda.api.entities.Activity;
28 | import okhttp3.*;
29 | import org.json.JSONException;
30 | import org.json.JSONObject;
31 | import org.json.JSONTokener;
32 |
33 | /**
34 | *
35 | * @author John Grosh <john.a.grosh@gmail.com>
36 | */
37 | public class OtherUtil
38 | {
39 | public final static String NEW_VERSION_AVAILABLE = "There is a new version of JMusicBot available!\n"
40 | + "Current version: %s\n"
41 | + "New Version: %s\n\n"
42 | + "Please visit https://github.com/jagrosh/MusicBot/releases/latest to get the latest release.";
43 | private final static String WINDOWS_INVALID_PATH = "c:\\windows\\system32\\";
44 |
45 | /**
46 | * gets a Path from a String
47 | * also fixes the windows tendency to try to start in system32
48 | * any time the bot tries to access this path, it will instead start in the location of the jar file
49 | *
50 | * @param path the string path
51 | * @return the Path object
52 | */
53 | public static Path getPath(String path)
54 | {
55 | Path result = Paths.get(path);
56 | // special logic to prevent trying to access system32
57 | if(result.toAbsolutePath().toString().toLowerCase().startsWith(WINDOWS_INVALID_PATH))
58 | {
59 | try
60 | {
61 | result = Paths.get(new File(JMusicBot.class.getProtectionDomain().getCodeSource().getLocation().toURI()).getParentFile().getPath() + File.separator + path);
62 | }
63 | catch(URISyntaxException ex) {}
64 | }
65 | return result;
66 | }
67 |
68 | /**
69 | * Loads a resource from the jar as a string
70 | *
71 | * @param clazz class base object
72 | * @param name name of resource
73 | * @return string containing the contents of the resource
74 | */
75 | public static String loadResource(Object clazz, String name)
76 | {
77 | try(BufferedReader reader = new BufferedReader(new InputStreamReader(clazz.getClass().getResourceAsStream(name))))
78 | {
79 | StringBuilder sb = new StringBuilder();
80 | reader.lines().forEach(line -> sb.append("\r\n").append(line));
81 | return sb.toString().trim();
82 | }
83 | catch(IOException ex)
84 | {
85 | return null;
86 | }
87 | }
88 |
89 | /**
90 | * Loads image data from a URL
91 | *
92 | * @param url url of image
93 | * @return inputstream of url
94 | */
95 | public static InputStream imageFromUrl(String url)
96 | {
97 | if(url==null)
98 | return null;
99 | try
100 | {
101 | URL u = new URL(url);
102 | URLConnection urlConnection = u.openConnection();
103 | urlConnection.setRequestProperty("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.112 Safari/537.36");
104 | return urlConnection.getInputStream();
105 | }
106 | catch(IOException | IllegalArgumentException ignore) {}
107 | return null;
108 | }
109 |
110 | /**
111 | * Parses an activity from a string
112 | *
113 | * @param game the game, including the action such as 'playing' or 'watching'
114 | * @return the parsed activity
115 | */
116 | public static Activity parseGame(String game)
117 | {
118 | if(game==null || game.trim().isEmpty() || game.trim().equalsIgnoreCase("default"))
119 | return null;
120 | String lower = game.toLowerCase();
121 | if(lower.startsWith("playing"))
122 | return Activity.playing(makeNonEmpty(game.substring(7).trim()));
123 | if(lower.startsWith("listening to"))
124 | return Activity.listening(makeNonEmpty(game.substring(12).trim()));
125 | if(lower.startsWith("listening"))
126 | return Activity.listening(makeNonEmpty(game.substring(9).trim()));
127 | if(lower.startsWith("watching"))
128 | return Activity.watching(makeNonEmpty(game.substring(8).trim()));
129 | if(lower.startsWith("streaming"))
130 | {
131 | String[] parts = game.substring(9).trim().split("\\s+", 2);
132 | if(parts.length == 2)
133 | {
134 | return Activity.streaming(makeNonEmpty(parts[1]), "https://twitch.tv/"+parts[0]);
135 | }
136 | }
137 | return Activity.playing(game);
138 | }
139 |
140 | public static String makeNonEmpty(String str)
141 | {
142 | return str == null || str.isEmpty() ? "\u200B" : str;
143 | }
144 |
145 | public static OnlineStatus parseStatus(String status)
146 | {
147 | if(status==null || status.trim().isEmpty())
148 | return OnlineStatus.ONLINE;
149 | OnlineStatus st = OnlineStatus.fromKey(status);
150 | return st == null ? OnlineStatus.ONLINE : st;
151 | }
152 |
153 | public static void checkJavaVersion(Prompt prompt)
154 | {
155 | if(!System.getProperty("java.vm.name").contains("64"))
156 | prompt.alert(Prompt.Level.WARNING, "Java Version",
157 | "It appears that you may not be using a supported Java version. Please use 64-bit java.");
158 | }
159 |
160 | public static void checkVersion(Prompt prompt)
161 | {
162 | // Get current version number
163 | String version = getCurrentVersion();
164 |
165 | // Check for new version
166 | String latestVersion = getLatestVersion();
167 |
168 | if(latestVersion!=null && !latestVersion.equals(version))
169 | {
170 | prompt.alert(Prompt.Level.WARNING, "JMusicBot Version", String.format(NEW_VERSION_AVAILABLE, version, latestVersion));
171 | }
172 | }
173 |
174 | public static String getCurrentVersion()
175 | {
176 | if(JMusicBot.class.getPackage()!=null && JMusicBot.class.getPackage().getImplementationVersion()!=null)
177 | return JMusicBot.class.getPackage().getImplementationVersion();
178 | else
179 | return "UNKNOWN";
180 | }
181 |
182 | public static String getLatestVersion()
183 | {
184 | try
185 | {
186 | Response response = new OkHttpClient.Builder().build()
187 | .newCall(new Request.Builder().get().url("https://api.github.com/repos/jagrosh/MusicBot/releases/latest").build())
188 | .execute();
189 | ResponseBody body = response.body();
190 | if(body != null)
191 | {
192 | try(Reader reader = body.charStream())
193 | {
194 | JSONObject obj = new JSONObject(new JSONTokener(reader));
195 | return obj.getString("tag_name");
196 | }
197 | finally
198 | {
199 | response.close();
200 | }
201 | }
202 | else
203 | return null;
204 | }
205 | catch(IOException | JSONException | NullPointerException ex)
206 | {
207 | return null;
208 | }
209 | }
210 | }
211 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/commands/owner/PlaylistCmd.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2016 John Grosh <john.a.grosh@gmail.com>.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot.commands.owner;
17 |
18 | import java.io.IOException;
19 | import java.util.List;
20 | import com.jagrosh.jdautilities.command.Command;
21 | import com.jagrosh.jdautilities.command.CommandEvent;
22 | import com.jagrosh.jmusicbot.Bot;
23 | import com.jagrosh.jmusicbot.commands.OwnerCommand;
24 | import com.jagrosh.jmusicbot.playlist.PlaylistLoader.Playlist;
25 |
26 | /**
27 | *
28 | * @author John Grosh <john.a.grosh@gmail.com>
29 | */
30 | public class PlaylistCmd extends OwnerCommand
31 | {
32 | private final Bot bot;
33 | public PlaylistCmd(Bot bot)
34 | {
35 | this.bot = bot;
36 | this.guildOnly = false;
37 | this.name = "playlist";
38 | this.arguments = "<append|delete|make|setdefault>";
39 | this.help = "playlist management";
40 | this.aliases = bot.getConfig().getAliases(this.name);
41 | this.children = new OwnerCommand[]{
42 | new ListCmd(),
43 | new AppendlistCmd(),
44 | new DeletelistCmd(),
45 | new MakelistCmd(),
46 | new DefaultlistCmd(bot)
47 | };
48 | }
49 |
50 | @Override
51 | public void execute(CommandEvent event)
52 | {
53 | StringBuilder builder = new StringBuilder(event.getClient().getWarning()+" Playlist Management Commands:\n");
54 | for(Command cmd: this.children)
55 | builder.append("\n`").append(event.getClient().getPrefix()).append(name).append(" ").append(cmd.getName())
56 | .append(" ").append(cmd.getArguments()==null ? "" : cmd.getArguments()).append("` - ").append(cmd.getHelp());
57 | event.reply(builder.toString());
58 | }
59 |
60 | public class MakelistCmd extends OwnerCommand
61 | {
62 | public MakelistCmd()
63 | {
64 | this.name = "make";
65 | this.aliases = new String[]{"create"};
66 | this.help = "makes a new playlist";
67 | this.arguments = "<name>";
68 | this.guildOnly = false;
69 | }
70 |
71 | @Override
72 | protected void execute(CommandEvent event)
73 | {
74 | String pname = event.getArgs().replaceAll("\\s+", "_");
75 | pname = pname.replaceAll("[*?|\\/\":<>]", "");
76 | if(pname == null || pname.isEmpty())
77 | {
78 | event.replyError("Please provide a name for the playlist!");
79 | }
80 | else if(bot.getPlaylistLoader().getPlaylist(pname) == null)
81 | {
82 | try
83 | {
84 | bot.getPlaylistLoader().createPlaylist(pname);
85 | event.reply(event.getClient().getSuccess()+" Successfully created playlist `"+pname+"`!");
86 | }
87 | catch(IOException e)
88 | {
89 | event.reply(event.getClient().getError()+" I was unable to create the playlist: "+e.getLocalizedMessage());
90 | }
91 | }
92 | else
93 | event.reply(event.getClient().getError()+" Playlist `"+pname+"` already exists!");
94 | }
95 | }
96 |
97 | public class DeletelistCmd extends OwnerCommand
98 | {
99 | public DeletelistCmd()
100 | {
101 | this.name = "delete";
102 | this.aliases = new String[]{"remove"};
103 | this.help = "deletes an existing playlist";
104 | this.arguments = "<name>";
105 | this.guildOnly = false;
106 | }
107 |
108 | @Override
109 | protected void execute(CommandEvent event)
110 | {
111 | String pname = event.getArgs().replaceAll("\\s+", "_");
112 | if(bot.getPlaylistLoader().getPlaylist(pname)==null)
113 | event.reply(event.getClient().getError()+" Playlist `"+pname+"` doesn't exist!");
114 | else
115 | {
116 | try
117 | {
118 | bot.getPlaylistLoader().deletePlaylist(pname);
119 | event.reply(event.getClient().getSuccess()+" Successfully deleted playlist `"+pname+"`!");
120 | }
121 | catch(IOException e)
122 | {
123 | event.reply(event.getClient().getError()+" I was unable to delete the playlist: "+e.getLocalizedMessage());
124 | }
125 | }
126 | }
127 | }
128 |
129 | public class AppendlistCmd extends OwnerCommand
130 | {
131 | public AppendlistCmd()
132 | {
133 | this.name = "append";
134 | this.aliases = new String[]{"add"};
135 | this.help = "appends songs to an existing playlist";
136 | this.arguments = "<name> <URL> | <URL> | ...";
137 | this.guildOnly = false;
138 | }
139 |
140 | @Override
141 | protected void execute(CommandEvent event)
142 | {
143 | String[] parts = event.getArgs().split("\\s+", 2);
144 | if(parts.length<2)
145 | {
146 | event.reply(event.getClient().getError()+" Please include a playlist name and URLs to add!");
147 | return;
148 | }
149 | String pname = parts[0];
150 | Playlist playlist = bot.getPlaylistLoader().getPlaylist(pname);
151 | if(playlist==null)
152 | event.reply(event.getClient().getError()+" Playlist `"+pname+"` doesn't exist!");
153 | else
154 | {
155 | StringBuilder builder = new StringBuilder();
156 | playlist.getItems().forEach(item -> builder.append("\r\n").append(item));
157 | String[] urls = parts[1].split("\\|");
158 | for(String url: urls)
159 | {
160 | String u = url.trim();
161 | if(u.startsWith("<") && u.endsWith(">"))
162 | u = u.substring(1, u.length()-1);
163 | builder.append("\r\n").append(u);
164 | }
165 | try
166 | {
167 | bot.getPlaylistLoader().writePlaylist(pname, builder.toString());
168 | event.reply(event.getClient().getSuccess()+" Successfully added "+urls.length+" items to playlist `"+pname+"`!");
169 | }
170 | catch(IOException e)
171 | {
172 | event.reply(event.getClient().getError()+" I was unable to append to the playlist: "+e.getLocalizedMessage());
173 | }
174 | }
175 | }
176 | }
177 |
178 | public class DefaultlistCmd extends AutoplaylistCmd
179 | {
180 | public DefaultlistCmd(Bot bot)
181 | {
182 | super(bot);
183 | this.name = "setdefault";
184 | this.aliases = new String[]{"default"};
185 | this.arguments = "<playlistname|NONE>";
186 | this.guildOnly = true;
187 | }
188 | }
189 |
190 | public class ListCmd extends OwnerCommand
191 | {
192 | public ListCmd()
193 | {
194 | this.name = "all";
195 | this.aliases = new String[]{"available","list"};
196 | this.help = "lists all available playlists";
197 | this.guildOnly = true;
198 | }
199 |
200 | @Override
201 | protected void execute(CommandEvent event)
202 | {
203 | if(!bot.getPlaylistLoader().folderExists())
204 | bot.getPlaylistLoader().createFolder();
205 | if(!bot.getPlaylistLoader().folderExists())
206 | {
207 | event.reply(event.getClient().getWarning()+" Playlists folder does not exist and could not be created!");
208 | return;
209 | }
210 | List<String> list = bot.getPlaylistLoader().getPlaylistNames();
211 | if(list==null)
212 | event.reply(event.getClient().getError()+" Failed to load available playlists!");
213 | else if(list.isEmpty())
214 | event.reply(event.getClient().getWarning()+" There are no playlists in the Playlists folder!");
215 | else
216 | {
217 | StringBuilder builder = new StringBuilder(event.getClient().getSuccess()+" Available playlists:\n");
218 | list.forEach(str -> builder.append("`").append(str).append("` "));
219 | event.reply(builder.toString());
220 | }
221 | }
222 | }
223 | }
224 |
--------------------------------------------------------------------------------
/src/main/java/com/jagrosh/jmusicbot/JMusicBot.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2016 John Grosh (jagrosh).
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.jagrosh.jmusicbot;
17 |
18 | import com.jagrosh.jdautilities.command.CommandClientBuilder;
19 | import com.jagrosh.jdautilities.commons.waiter.EventWaiter;
20 | import com.jagrosh.jdautilities.examples.command.*;
21 | import com.jagrosh.jmusicbot.commands.admin.*;
22 | import com.jagrosh.jmusicbot.commands.dj.*;
23 | import com.jagrosh.jmusicbot.commands.general.*;
24 | import com.jagrosh.jmusicbot.commands.music.*;
25 | import com.jagrosh.jmusicbot.commands.owner.*;
26 | import com.jagrosh.jmusicbot.entities.Prompt;
27 | import com.jagrosh.jmusicbot.gui.GUI;
28 | import com.jagrosh.jmusicbot.settings.SettingsManager;
29 | import com.jagrosh.jmusicbot.utils.OtherUtil;
30 | import java.awt.Color;
31 | import java.util.Arrays;
32 | import javax.security.auth.login.LoginException;
33 | import net.dv8tion.jda.api.*;
34 | import net.dv8tion.jda.api.entities.Activity;
35 | import net.dv8tion.jda.api.requests.GatewayIntent;
36 | import net.dv8tion.jda.api.utils.cache.CacheFlag;
37 | import org.slf4j.Logger;
38 | import org.slf4j.LoggerFactory;
39 |
40 | /**
41 | *
42 | * @author John Grosh (jagrosh)
43 | */
44 | public class JMusicBot
45 | {
46 | public final static Logger LOG = LoggerFactory.getLogger(JMusicBot.class);
47 | public final static Permission[] RECOMMENDED_PERMS = {Permission.MESSAGE_READ, Permission.MESSAGE_WRITE, Permission.MESSAGE_HISTORY, Permission.MESSAGE_ADD_REACTION,
48 | Permission.MESSAGE_EMBED_LINKS, Permission.MESSAGE_ATTACH_FILES, Permission.MESSAGE_MANAGE, Permission.MESSAGE_EXT_EMOJI,
49 | Permission.MANAGE_CHANNEL, Permission.VOICE_CONNECT, Permission.VOICE_SPEAK, Permission.NICKNAME_CHANGE};
50 | public final static GatewayIntent[] INTENTS = {GatewayIntent.DIRECT_MESSAGES, GatewayIntent.GUILD_MESSAGES, GatewayIntent.GUILD_MESSAGE_REACTIONS, GatewayIntent.GUILD_VOICE_STATES};
51 |
52 | /**
53 | * @param args the command line arguments
54 | */
55 | public static void main(String[] args)
56 | {
57 | if(args.length > 0)
58 | switch(args[0].toLowerCase())
59 | {
60 | case "generate-config":
61 | BotConfig.writeDefaultConfig();
62 | return;
63 | default:
64 | }
65 | startBot();
66 | }
67 |
68 | private static void startBot()
69 | {
70 | // create prompt to handle startup
71 | Prompt prompt = new Prompt("JMusicBot");
72 |
73 | // startup checks
74 | OtherUtil.checkVersion(prompt);
75 | OtherUtil.checkJavaVersion(prompt);
76 |
77 | // load config
78 | BotConfig config = new BotConfig(prompt);
79 | config.load();
80 | if(!config.isValid())
81 | return;
82 | LOG.info("Loaded config from " + config.getConfigLocation());
83 |
84 | // set up the listener
85 | EventWaiter waiter = new EventWaiter();
86 | SettingsManager settings = new SettingsManager();
87 | Bot bot = new Bot(waiter, config, settings);
88 |
89 | AboutCommand aboutCommand = new AboutCommand(Color.BLUE.brighter(),
90 | "a music bot that is [easy to host yourself!](https://github.com/jagrosh/MusicBot) (v" + OtherUtil.getCurrentVersion() + ")",
91 | new String[]{"High-quality music playback", "FairQueue™ Technology", "Easy to host yourself"},
92 | RECOMMENDED_PERMS);
93 | aboutCommand.setIsAuthor(false);
94 | aboutCommand.setReplacementCharacter("\uD83C\uDFB6"); // 🎶
95 |
96 | // set up the command client
97 | CommandClientBuilder cb = new CommandClientBuilder()
98 | .setPrefix(config.getPrefix())
99 | .setAlternativePrefix(config.getAltPrefix())
100 | .setOwnerId(Long.toString(config.getOwnerId()))
101 | .setEmojis(config.getSuccess(), config.getWarning(), config.getError())
102 | .setHelpWord(config.getHelp())
103 | .setLinkedCacheSize(200)
104 | .setGuildSettingsManager(settings)
105 | .addCommands(aboutCommand,
106 | new PingCommand(),
107 | new SettingsCmd(bot),
108 |
109 | new LyricsCmd(bot),
110 | new NowplayingCmd(bot),
111 | new PlayCmd(bot),
112 | new PlaylistsCmd(bot),
113 | new QueueCmd(bot),
114 | new RemoveCmd(bot),
115 | new SearchCmd(bot),
116 | new SCSearchCmd(bot),
117 | new ShuffleCmd(bot),
118 | new SkipCmd(bot),
119 |
120 | new ForceRemoveCmd(bot),
121 | new ForceskipCmd(bot),
122 | new MoveTrackCmd(bot),
123 | new PauseCmd(bot),
124 | new PlaynextCmd(bot),
125 | new RepeatCmd(bot),
126 | new SkiptoCmd(bot),
127 | new StopCmd(bot),
128 | new VolumeCmd(bot),
129 |
130 | new PrefixCmd(bot),
131 | new SetdjCmd(bot),
132 | new SkipratioCmd(bot),
133 | new SettcCmd(bot),
134 | new SetvcCmd(bot),
135 |
136 | new AutoplaylistCmd(bot),
137 | new DebugCmd(bot),
138 | new PlaylistCmd(bot),
139 | new SetavatarCmd(bot),
140 | new SetgameCmd(bot),
141 | new SetnameCmd(bot),
142 | new SetstatusCmd(bot),
143 | new ShutdownCmd(bot)
144 | );
145 | if(config.useEval())
146 | cb.addCommand(new EvalCmd(bot));
147 | boolean nogame = false;
148 | if(config.getStatus()!=OnlineStatus.UNKNOWN)
149 | cb.setStatus(config.getStatus());
150 | if(config.getGame()==null)
151 | cb.useDefaultGame();
152 | else if(config.getGame().getName().equalsIgnoreCase("none"))
153 | {
154 | cb.setActivity(null);
155 | nogame = true;
156 | }
157 | else
158 | cb.setActivity(config.getGame());
159 |
160 | if(!prompt.isNoGUI())
161 | {
162 | try
163 | {
164 | GUI gui = new GUI(bot);
165 | bot.setGUI(gui);
166 | gui.init();
167 | }
168 | catch(Exception e)
169 | {
170 | LOG.error("Could not start GUI. If you are "
171 | + "running on a server or in a location where you cannot display a "
172 | + "window, please run in nogui mode using the -Dnogui=true flag.");
173 | }
174 | }
175 |
176 | // attempt to log in and start
177 | try
178 | {
179 | JDA jda = JDABuilder.create(config.getToken(), Arrays.asList(INTENTS))
180 | .enableCache(CacheFlag.MEMBER_OVERRIDES, CacheFlag.VOICE_STATE)
181 | .disableCache(CacheFlag.ACTIVITY, CacheFlag.CLIENT_STATUS, CacheFlag.EMOTE, CacheFlag.ONLINE_STATUS)
182 | .setActivity(nogame ? null : Activity.playing("loading..."))
183 | .setStatus(config.getStatus()==OnlineStatus.INVISIBLE || config.getStatus()==OnlineStatus.OFFLINE
184 | ? OnlineStatus.INVISIBLE : OnlineStatus.DO_NOT_DISTURB)
185 | .addEventListeners(cb.build(), waiter, new Listener(bot))
186 | .setBulkDeleteSplittingEnabled(true)
187 | .build();
188 | bot.setJDA(jda);
189 | }
190 | catch (LoginException ex)
191 | {
192 | prompt.alert(Prompt.Level.ERROR, "JMusicBot", ex + "\nPlease make sure you are "
193 | + "editing the correct config.txt file, and that you have used the "
194 | + "correct token (not the 'secret'!)\nConfig Location: " + config.getConfigLocation());
195 | System.exit(1);
196 | }
197 | catch(IllegalArgumentException ex)
198 | {
199 | prompt.alert(Prompt.Level.ERROR, "JMusicBot", "Some aspect of the configuration is "
200 | + "invalid: " + ex + "\nConfig Location: " + config.getConfigLocation());
201 | System.exit(1);
202 | }
203 | }
204 | }
205 |
--------------------------------------------------------------------------------