Merge pull request #280 from musix-org/dependabot/npm_and_yarn/v2/discord.js-14.25.1

Bump discord.js from 14.25.0 to 14.25.1

.gitignore

@@ -1,4 +1,4 @@
-node_modules
 .env
 .vscode
+node_modules
 serviceAccount.json

Client.js

@@ -0,0 +1,58 @@
+const { Client, Collection } = require('discord.js');
+const admin = require('firebase-admin');
+require('dotenv/config');
+
+module.exports = class extends Client {
+    constructor() {
+        super({
+            intents: [
+                "Guilds",
+                "GuildMessages",
+                "GuildVoiceStates",
+                "MessageContent"
+            ],
+            disableMentions: "everyone",
+            disabledEvents: ["TYPING_START"]
+        });
+
+        this.commands = new Collection();
+
+        this.commandAliases = new Collection();
+
+        this.playlistCmd = new Collection();
+
+        this.settingCmd = new Collection();
+
+        this.events = new Collection();
+
+        this.queue = new Map();
+
+        this.funcs = {};
+
+        this.funcs.handleVideo = require('./funcs/handleVideo.js');
+        this.funcs.play = require('./funcs/play.js');
+        this.funcs.msToTime = require('./funcs/msToTime.js');
+        this.funcs.exe = require('./funcs/exe.js');
+
+        this.config = require('./config.js');
+
+        this.global = {
+            db: {
+                guilds: {},
+                playlists: {},
+            },
+        };
+
+        if(this.config.firebase.serviceAccount){
+            this.funcs.dbget = require('./funcs/dbget.js');
+
+            admin.initializeApp({
+                credential: admin.credential.cert(this.config.firebase.serviceAccount),
+            });
+
+            this.db = admin.firestore();
+
+            this.db.FieldValue = require('firebase-admin').firestore.FieldValue;
+        }
+    }
+};

Dockerfile

@@ -3,6 +3,9 @@ FROM docker.io/node:20-alpine
 #Dependencies
 RUN apk add --virtual .build-deps python3 make g++ gcc git
 
+#Code Dependencies
+RUN apk add --virtual .code-deps ffmpeg
+
 WORKDIR /usr/src/app
 
 COPY / /usr/src/app/

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-2024 Musix Org
+Copyright (c) 2019-2024 Musix Org
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1 +1,21 @@
-# Musix OSS - V3
+# Musix-V2
+
+THIS VERSION OF MUSIX IS NO LONGER SUPPORTED!
+
+## Discord music bot
+
+Second version of Musix discord music bot.
+
+Made with discord.js V11
+
+NOTE! THIS BOT CANNOT BE USED AFTER OCTOBER 4TH 2020! This is due to new rules for bots by discord.
+
+## Installation
+
+npm install (idk how yarn works)
+
+Some modules are outdated to updating is recommended!
+
+## Usage
+
+You will need you own .env file and serviceAccount.json for database!

commands/help.js

@@ -0,0 +1,32 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+    name: 'help',
+    description: 'Help command.',
+    alias: 'help',
+    cooldown: 5,
+    execute(message, args, client, prefix) {
+        const embed = new EmbedBuilder()
+            .setTitle(`Commands for ${client.user.username}!`)
+            .addFields(
+                { name: `${prefix}play | ${prefix}p`, value: 'Play a song.', inline: true },
+                { name: `${prefix}skip | ${prefix}s`, value: 'Skip a song.', inline: true },
+                { name: `${prefix}queue | ${prefix}q`, value: 'Display the queue.', inline: true },
+                { name: `${prefix}nowplaying | ${prefix}np`, value: 'Display what\'s currently playing.', inline: true },
+                { name: `${prefix}remove | ${prefix}rm`, value: 'Remove songs from the queue.', inline: true },
+                { name: `${prefix}volume`, value: 'Change or check the volume.', inline: true },
+                { name: `${prefix}pause`, value: 'Pause the music.', inline: true },
+                { name: `${prefix}resume`, value: 'Resume the music.', inline: true },
+                { name: `${prefix}loop`, value: 'Loop the queue.', inline: true },
+                { name: `${prefix}seek`, value: 'Seek music.', inline: true },
+                { name: `${prefix}stop`, value: 'Stop the music, Clear the queue and leave the current voice channel.', inline: true },
+                { name: `${prefix}invite`, value: 'Invite Musix.', inline: true },
+                { name: `${prefix}status`, value: 'See different information for Musix.', inline: true },
+                { name: `${prefix}settings`, value: 'Change the guild specific settings.', inline: true },
+                { name: `${prefix}help`, value: 'Display the help.', inline: true }
+            )
+            .setAuthor({ name: client.user.username, iconURL: client.user.avatarURL()})
+            .setColor(client.config.embedColor)
+        return message.channel.send({ embeds: [embed] });
+    }
+};

commands/invite.js

@@ -0,0 +1,15 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+    name: 'invite',
+    description: 'Invite command.',
+    alias: 'invite',
+    cooldown: 5,
+    execute(message, args, client, prefix) {
+        const embed = new EmbedBuilder()
+            .setTitle(`Invite ${client.user.username} to your Discord server!`)
+            .setURL(`https://discord.com/oauth2/authorize?client_id=${client.user.id}&permissions=2184465408&scope=applications.commands+bot`)
+            .setColor(client.config.embedColor)
+        return message.channel.send({ embeds: [embed] });
+    }
+};

commands/loop.js

@@ -0,0 +1,27 @@
+const { PermissionFlagsBits } = require('discord.js');
+
+module.exports = {
+    name: 'loop',
+    description: 'loop command.',
+    alias: 'loop',
+    cooldown: 10,
+    async execute(message, args, client, prefix) {
+        const serverQueue = client.queue.get(message.guild.id);
+        const permissions = message.channel.permissionsFor(message.author);
+        const voiceChannel = message.member.voice.channel;
+        if (!serverQueue) return message.channel.send(':x: There is nothing playing.');
+        if (voiceChannel !== serverQueue.voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in the same voice channel as Musix to loop the queue!');
+        if (client.global.db.guilds[message.guild.id].permissions === true) {
+            if (client.global.db.guilds[message.guild.id].dj) {
+                if (!message.member.roles.cache.has(client.global.db.guilds[message.guild.id].djrole)) return message.channel.send(':x: You need the `DJ` role to loop the queue!');
+            } else if (!permissions.has(PermissionFlagsBits.ManageChannels)) return message.channel.send(':x: You need the `MANAGE_MESSAGES` permission to loop the queue!');
+        }
+        if (!serverQueue.looping) {
+            serverQueue.looping = true;
+            message.channel.send(':repeat: Looping the queue now!');
+        } else {
+            serverQueue.looping = false;
+            message.channel.send(':repeat: No longer looping the queue!');
+        }
+    }
+};

commands/nowplaying.js

@@ -0,0 +1,27 @@
+const { EmbedBuilder } = require('discord.js');
+
+module.exports = {
+    name: 'nowplaying',
+    description: 'Now playing command.',
+    alias: 'np',
+    cooldown: 5,
+    async execute(message, args, client, prefix) {
+        const ytdl = require('ytdl-core');
+        const serverQueue = client.queue.get(message.guild.id);
+        if (!serverQueue) return message.channel.send(':x: There is nothing playing.');
+        if (!serverQueue.playing) return message.channel.send(':x: There is nothing playing.');
+        let data = await Promise.resolve(ytdl.getInfo(serverQueue.songs[0].url));
+        let songtime = (data.length_seconds * 1000).toFixed(0);
+        let completed = (serverQueue.connection.dispatcher.time).toFixed(0);
+        let barlength = 30;
+        let completedpercent = ((completed / songtime) * barlength).toFixed(0);
+        let array = []; for (let i = 0; i < completedpercent - 1; i++) { array.push('⎯'); } array.push('⭗'); for (let i = 0; i < barlength - completedpercent - 1; i++) { array.push('⎯'); }
+        const embed = new EmbedBuilder()
+            .setTitle("__Now playing__")
+            .setDescription(`🎶**Now playing:** ${serverQueue.songs[0].title}\n${array.join('')} | \`${client.funcs.msToTime(completed)} / ${client.funcs.msToTime(songtime)}\``)
+            .setFooter({ text: `Queued by ${serverQueue.songs[0].author.tag}` })
+            .setURL(serverQueue.songs[0].url)
+            .setColor(client.config.embedColor)
+        return message.channel.send({ embeds: [embed] });
+    }
+};

commands/pause.js

@@ -0,0 +1,25 @@
+const { PermissionFlagsBits } = require('discord.js');
+
+module.exports = {
+	name: 'pause',
+	description: 'Pause command.',
+	alias: 'pause',
+	cooldown: 5,
+	execute(message, args, client, prefix) {
+		const serverQueue = client.queue.get(message.guild.id);
+		const permissions = message.channel.permissionsFor(message.author);
+		const voiceChannel = message.member.voice.channel;
+		if (!serverQueue) return message.channel.send(':x: There is nothing playing.');
+		if (serverQueue.playing && !serverQueue.paused) {
+			if (voiceChannel !== serverQueue.voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in the same voice channel as Musix to pause the music!');
+			if (client.global.db.guilds[message.guild.id].permissions === true) {
+				if (client.global.db.guilds[message.guild.id].dj) {
+					if (!message.member.roles.cache.has(client.global.db.guilds[message.guild.id].djrole)) return message.channel.send(':x: You need the `DJ` role to pause the music!');
+				} else if (!permissions.has(PermissionFlagsBits.ManageMessages)) return message.channel.send(':x: You need the `MANAGE_MESSAGES` permission to pause the music!');
+			}
+			serverQueue.paused = true;
+			serverQueue.audioPlayer.pause();
+			return message.channel.send('⏸ Paused the music!');
+		} else return message.channel.send(':x: There is nothing playing.');
+	}
+};

commands/play.js

@@ -0,0 +1,86 @@
+const YouTube = require("simple-youtube-api");
+const he = require('he');
+const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
+
+module.exports = {
+	name: 'play',
+	description: 'Play command.',
+	usage: '[song name]',
+	alias: 'p',
+	args: true,
+	cooldown: 3,
+	async execute(message, args, client, prefix) {
+		const youtube = new YouTube(client.config.youtube_api_key);
+		const searchString = args.slice(1).join(" ");
+		const url = args[1] ? args[1].replace(/<(.+)>/g, "$1") : "";
+		const serverQueue = client.queue.get(message.guild.id);
+		const voiceChannel = message.member.voice.channel;
+		if (!serverQueue) {
+			if (!voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in a voice channel to play music!');
+		} else {
+			if (voiceChannel !== serverQueue.voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in the same voice channel as Musix to play music!');
+		}
+		if (!args[1]) return message.channel.send(':x: You need to use a link or search for a song!');
+		const permissions = voiceChannel.permissionsFor(message.client.user);
+		if (!permissions.has(PermissionFlagsBits.Connect)) {
+			return message.channel.send(':x: I cannot connect to your voice channel, make sure I have the proper permissions!');
+		}
+		if (!permissions.has(PermissionFlagsBits.Speak)) {
+			return message.channel.send(':x: I cannot speak in your voice channel, make sure I have the proper permissions!');
+		}
+		if (url.match(/^https?:\/\/(www.youtube.com|youtube.com)\/playlist(.*)$/)) {
+			const playlist = await youtube.getPlaylist(url);
+			const videos = await playlist.getVideos();
+			for (const video of Object.values(videos)) {
+				const video2 = await youtube.getVideoByID(video.id);
+				await client.funcs.handleVideo(video2, message, voiceChannel, client, true);
+			}
+			return message.channel.send(`:white_check_mark: Playlist: **${playlist.title}** has been added to the queue!`);
+		} else if (client.global.db.guilds[message.guild.id].songSelection) {
+			try {
+				var video = await youtube.getVideo(url);
+			} catch (error) {
+				try {
+					var videos = await youtube.searchVideos(searchString, 10);
+					let index = 0;
+					const embed = new EmbedBuilder()
+						.setTitle("__Song Selection__")
+						.setDescription(`${videos.map(video2 => `**${++index}** ${he.decode(video2.title)} `).join('\n')}`)
+						.setFooter({ text: "Please provide a number ranging from 1-10 to select one of the search results." })
+						.setColor(client.config.embedColor)
+					message.channel.send({ embeds: [embed] });
+					try {
+						var response = await message.channel.awaitMessages({
+							filter: message2 => message2.content > 0 && message2.content < 11 && message2.author === message.author,
+							max: 1,
+							time: 10000,
+							errors: ['time']
+						});
+					} catch (err) {
+						console.error(err);
+						return message.channel.send(':x: Cancelling video selection');
+					}
+					const videoIndex = parseInt(response.first().content);
+					var video = await youtube.getVideoByID(videos[videoIndex - 1].id);
+				} catch (err) {
+					console.error(err);
+					return message.channel.send(':x: I could not obtain any search results!');
+				}
+			}
+			return client.funcs.handleVideo(video, message, voiceChannel, client, false);
+		} else {
+			try {
+				var video = await youtube.getVideo(url);
+			} catch (error) {
+				try {
+					var videos = await youtube.searchVideos(searchString, 1);
+					var video = await youtube.getVideoByID(videos[0].id);
+				} catch (err) {
+					console.error(err);
+					return message.channel.send(':x: I could not obtain any search results!');
+				}
+			}
+			return client.funcs.handleVideo(video, message, voiceChannel, client, false);
+		}
+	}
+};

commands/playlist.js

@@ -0,0 +1,44 @@
+const YouTube = require("simple-youtube-api");
+const he = require('he');
+const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
+
+module.exports = {
+    name: 'playlist',
+    usage: '[option]',
+    description: 'Save and load queues',
+    alias: 'pl',
+    cooldown: 10,
+    async execute(message, args, client, prefix) {
+        const embed = new EmbedBuilder()
+            .setTitle('Options for playlist!')
+            .addFields(
+                { name: 'play', value: 'Play the guild specific queue.', inline: true },
+                { name: 'save', value: 'Save the currently playing queue. Note that this will overwrite the currently saved queue!', inline: true },
+                { name: 'add', value: 'Add songs to the playlist. Like song selection', inline: true },
+                { name: 'remove', value: 'Remove songs from the playlist.', inline: true },
+                { name: 'list', value: 'Display the playlist.', inline: true }
+            )
+            .setFooter({ text: `how to use: ${prefix}playlist <Option> <Optional option>` })
+            .setAuthor({ name: client.user.username, iconURL: client.user.avatarURL()})
+            .setColor(client.config.embedColor)
+        const permissions = message.channel.permissionsFor(message.author);
+        if (client.global.db.guilds[message.guild.id].dj) {
+            if (!message.member.roles.cache.has(client.global.db.guilds[message.guild.id].djrole)) return message.channel.send(':x: You need the `DJ` role to modify or play the playlist!');
+        } else if (!permissions.has(PermissionFlagsBits.ManageGuild)) return message.channel.send(':x: You need the `MANAGE_SERVER` permission to modify the playlist!');
+        if (client.global.db.guilds[message.guild.id].premium) {
+            if (args[1]) {
+                const optionName = args[1].toLowerCase();
+                const option = client.playlistCmd.get(optionName) || client.playlistCmd.find(cmd => cmd.aliases && cmd.aliases.includes(optionName));
+                if (!option) return message.channel.send({ embeds: [embed] });
+                try {
+                    option.execute(message, args, client, prefix);
+                } catch (error) {
+                    message.reply(`:x: there was an error trying to execute that option!`);
+                    console.log(error);
+                }
+            } else {
+                return message.channel.send({ embeds: [embed] });
+            }
+        } else return message.channel.send(":x: This is not a premium guild!");
+    },
+};

commands/playlist/add.js

@@ -0,0 +1,53 @@
+const YouTube = require("simple-youtube-api");
+const he = require('he');
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+    name: 'add',
+    async execute(message, args, client, prefix) {
+        if (client.global.db.playlists[message.guild.id].saved) {
+            const serverQueue = client.queue.get(message.guild.id);
+            const youtube = new YouTube(client.config.youtube_api_key);
+            const searchString = args.slice(2).join(" ");
+            const url = args[2] ? args[2].replace(/<(.+)>/g, "$1") : "";
+            if (!args[2]) return message.channel.send(':x: You need to use a link or search for a song!');
+            try {
+                var video = await youtube.getVideo(url);
+            } catch (error) {
+                try {
+                    var videos = await youtube.searchVideos(searchString, 10);
+                    let index = 0;
+                    const embed = new EmbedBuilder()
+                        .setTitle("__Song Selection__")
+                        .setDescription(`${videos.map(video2 => `**${++index}** ${he.decode(video2.title)} `).join('\n')}`)
+                        .setFooter({ text: "Please provide a number ranging from 1-10 to select one of the search results." })
+                        .setColor("#b50002")
+                    message.channel.send({ embeds: [embed] });
+                    try {
+                        var response = await message.channel.awaitMessages({
+                            filter: message2 => message2.content > 0 && message2.content < 11,
+                            max: 1,
+                            time: 10000,
+                            errors: ['time']
+                        });
+                    } catch (err) {
+                        console.error(err);
+                        return message.channel.send(':x: Cancelling video selection');
+                    }
+                    const videoIndex = parseInt(response.first().content);
+                    var video = await youtube.getVideoByID(videos[videoIndex - 1].id);
+                } catch (err) {
+                    console.error(err);
+                    return message.channel.send(':x: I could not obtain any search results!');
+                }
+            }
+            let song = {
+                id: video.id,
+                title: he.decode(video.title),
+                url: `https://www.youtube.com/watch?v=${video.id}`
+            }
+            client.global.db.playlists[message.guild.id].songs.push(song);
+            message.channel.send(`:white_check_mark: ${song.title} added to the playlist!`);
+        } else return message.channel.send(':x: There is no playlist saved! Start by using the save option!');
+    }
+};

commands/playlist/delete.js

@@ -0,0 +1,11 @@
+module.exports = {
+    name: 'delete',
+    async execute(message, args, client, prefix) {
+        client.global.db.playlists[message.guild.id] = {
+            songs: [],
+            firstSong: undefined,
+            saved: false,
+        };
+        message.channel.send(':wastebasket: Deleted the playlist.');
+    }
+};

commands/playlist/list.js

@@ -0,0 +1,24 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+    name: 'list',
+    async execute(message, args, client, prefix) {
+        if (args[2]) {
+            if (isNaN(args[2])) return msg.channel.send(':x: I\'m sorry, But you need to enter a valid __number__.');
+        }
+        let page = parseInt(args[2]);
+        if (!page) page = 1;
+        let pagetext = `:page_facing_up: Page: ${page} :page_facing_up:`
+        let queuesongs = client.global.db.playlists[message.guild.id].songs.slice((page - 1) * 20, page * 20);
+        let queuemessage = `${queuesongs.map(song => `**#** ${song.title}`).join('\n')}`
+        const hashs = queuemessage.split('**#**').length;
+        for (let i = 0; i < hashs; i++) {
+            queuemessage = queuemessage.replace('**#**', `**${i + 1}**`);
+        }
+        const embed = new EmbedBuilder()
+            .setTitle("__playlist queue__")
+            .setDescription(`${pagetext}\n${queuemessage}`)
+            .setColor("#b50002")
+        return message.channel.send({ embeds: [embed] });
+    }
+};

commands/playlist/play.js

@@ -0,0 +1,69 @@
+const { PermissionFlagsBits } = require("discord.js");
+const { createAudioPlayer, getVoiceConnection, joinVoiceChannel, NoSubscriberBehavior } = require("@discordjs/voice");
+
+module.exports = {
+    name: 'play',
+    async execute(message, args, client, prefix) {
+        const serverQueue = client.queue.get(message.guild.id);
+        const voiceChannel = message.member.voice.channel;
+        if (!voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in a voice channel to play music!');
+        const permissions = voiceChannel.permissionsFor(message.client.user);
+        if (!permissions.has(PermissionFlagsBits.Connect)) {
+            return message.channel.send(':x: I cannot connect to your voice channel, make sure I have the proper permissions!');
+        }
+        if (!permissions.has(PermissionFlagsBits.Speak)) {
+            return message.channel.send(':x: I cannot speak in your voice channel, make sure I have the proper permissions!');
+        }
+        let songs;
+        if (!voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in a voice channel to play music!');
+        if (args[2]) {
+            if (client.global.db.guilds[args[2]].premium && client.global.db.playlists[args[2]].saved) {
+                songs = client.global.db.playlists[args[2]].songs;
+            } else return message.channel.send(':x: There is no queue saved for this guild!')
+        } else {
+            songs = client.global.db.playlists[message.guild.id].songs;
+        }
+        if (client.global.db.playlists[message.guild.id].saved) {
+            if (!serverQueue) {
+                const construct = {
+                    textChannel: message.channel,
+                    voiceChannel: message.member.voice.channel,
+                    connection: null,
+                    audioPlayer: createAudioPlayer({
+                        behaviors: {
+                            noSubscriber: NoSubscriberBehavior.Play,
+                        }
+                    }),
+                    songs: [...songs],
+                    volume: client.global.db.guilds[message.guild.id].defaultVolume,
+                    playing: false,
+                    looping: false,
+                    paused: false,
+                    votes: 0,
+                    voters: [],
+                    votesNeeded: null
+                };
+                client.queue.set(message.guild.id, construct);
+                message.channel.send(":white_check_mark: Queue set!");
+                try {
+                    const connection =
+                        getVoiceConnection(voiceChannel.guild.id) ??
+                        joinVoiceChannel({
+                            channelId: voiceChannel.id,
+                            guildId: voiceChannel.guild.id,
+                            adapterCreator: voiceChannel.guild.voiceAdapterCreator
+                        });
+                    construct.connection = connection;
+                    client.funcs.play(message.guild, construct.songs[0], client, message, 0, false);
+                } catch (error) {
+                    client.queue.delete(message.guild.id);
+                    return message.channel.send(`:x: An error occured: ${error}`);
+                }
+            } else {
+                serverQueue.audioPlayer.stop();
+                serverQueue.songs = [...client.global.db.playlists[message.guild.id].songs];
+                message.channel.send(":white_check_mark: Queue set!");
+            }
+        } else return message.channel.send(':x: There is no queue set for this server!')
+    }
+};

commands/playlist/remove.js

@@ -0,0 +1,13 @@
+module.exports = {
+    name: 'remove',
+    async execute(message, args, client, prefix) {
+        if (client.global.db.playlists[message.guild.id].saved) {
+            if (!args[2]) return message.channel.send(':x: Please provide a number on the position of the song that you wan\'t to remove!');
+            const songNum = parseInt(args[2]) - 1;
+            if (isNaN(songNum)) return message.channel.send(':x: You need to enter a __number__!');
+            if (parseInt(songNum) > client.global.db.playlists[message.guild.id].songs.size) return message.channel.send(`:x: There is only ${serverQueue.songs.size} amount of songs in the queue!`);
+            message.channel.send(`🗑️ removed \`${client.global.db.playlists[message.guild.id].songs[songNum].title}\` from the playlist!`);
+            return client.global.db.playlists[message.guild.id].songs.splice(songNum, 1);
+        } else return message.channel.send(':x: There is no playlist saved! Start by using the save option!');
+    }
+};

commands/playlist/save.js

@@ -0,0 +1,13 @@
+module.exports = {
+    name: 'save',
+    async execute(message, args, client, prefix) {
+        const serverQueue = client.queue.get(message.guild.id);
+        if (!serverQueue) return message.channel.send(':x: There is nothing playing!');
+        client.global.db.playlists[message.guild.id] = {
+            songs: serverQueue.songs,
+            firstSong: serverQueue.songs[0],
+            saved: true,
+        };
+        message.channel.send(":white_check_mark: Queue saved!");
+    }
+};

commands/queue.js

@@ -0,0 +1,39 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+	name: 'queue',
+	description: 'Queue command.',
+	alias: 'q',
+	cooldown: 5,
+	async execute(message, args, client, prefix) {
+		const serverQueue = client.queue.get(message.guild.id);
+		if (!serverQueue) return message.channel.send(':x: There is nothing playing.');
+		if (args[1]) {
+			if (isNaN(args[1])) return msg.channel.send(':x: I\'m sorry, But you need to enter a valid __number__.');
+		}
+		let page = parseInt(args[1]);
+		if (!page) page = 1;
+		let pagetext = `:page_facing_up: Page: ${page} :page_facing_up:`
+		if (page === 1) pagetext = ':arrow_down: Next in queue :arrow_down:'
+		let queuesongs = serverQueue.songs.slice((page - 1) * 20 + 1, page * 20 + 1);
+		let queuemessage = `${queuesongs.map(song => `**#** ${song.title}`).join('\n')}`
+		const hashs = queuemessage.split('**#**').length;
+		for (let i = 0; i < hashs; i++) {
+			queuemessage = queuemessage.replace('**#**', `**${i + 1}**`);
+		}
+		if (!serverQueue.looping) {
+			const embed = new EmbedBuilder()
+				.setTitle("__Song queue__")
+				.setDescription(`**Now playing:** ${serverQueue.songs[0].title}🎶\n${pagetext}\n${queuemessage}`)
+				.setColor(client.config.embedColor)
+			return message.channel.send({ embeds: [embed] });
+		} else {
+			const embed = new EmbedBuilder()
+				.setTitle("__Song queue__")
+				.setDescription(`**Now playing:** ${serverQueue.songs[0].title}🎶\n${pagetext}\n${queuemessage}`)
+				.setFooter({ text: '🔁 Currently looping the queue!' })
+				.setColor(client.config.embedColor)
+			return message.channel.send({ embeds: [embed] });
+		}
+	}
+};

commands/remove.js

@@ -0,0 +1,28 @@
+const { PermissionFlagsBits } = require("discord.js");
+
+module.exports = {
+    name: 'remove',
+    description: 'Remove command.',
+    alias: 'rm',
+    cooldown: 5,
+    execute(message, args, client, prefix) {
+        const voiceChannel = message.member.voice.channel;
+        const serverQueue = client.queue.get(message.guild.id);
+        const permissions = message.channel.permissionsFor(message.author);
+        if (!serverQueue) return message.channel.send(':x: There is nothing playing.');
+        if (!serverQueue.playing) return message.channel.send(':x: There is nothing playing');
+        if (!args[1]) return message.channel.send(':x: Please provide a song position in queue for me to remove!');
+        const pos = parseInt(args[1]);
+        if (isNaN(pos)) return message.channel.send(':x: You need to enter a number!');
+        if (pos === 0) return message.channel.send(':x: You can not remove the currently playing song!');
+        if (pos > serverQueue.songs.size) return message.channel.send(`:x: There is only ${serverQueue.songs.size} amount of songs in the queue!`);
+        if (voiceChannel !== serverQueue.voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in the same voice channel as Musix to remove songs!');
+        if (client.global.db.guilds[message.guild.id].dj) {
+            if (serverQueue.songs[pos].author !== message.author) {
+                if (!message.member.roles.cache.has(client.global.db.guilds[message.guild.id].djrole)) return message.channel.send(':x: You need the `DJ` role to remove songs queue by others!');
+            }
+        } else if (!permissions.has(PermissionFlagsBits.ManageMessages) && serverQueue.songs[pos].author !== message.author) return message.channel.send(':x: You need the `MANAGE_MESSAGES` permission to remove songs queued by others!');
+        message.channel.send(`🗑️ removed \`${serverQueue.songs[pos].title}\` from the queue!`);
+        return serverQueue.songs.splice(pos, 1);
+    }
+};

commands/resume.js

@@ -0,0 +1,26 @@
+const { PermissionFlagsBits } = require("discord.js");
+
+module.exports = {
+	name: 'resume',
+	description: 'Resume command.',
+	alias: 'resume',
+	cooldown: 5,
+	execute(message, args, client, prefix) {
+		const serverQueue = client.queue.get(message.guild.id);
+		const permissions = message.channel.permissionsFor(message.author);
+		const voiceChannel = message.member.voice.channel;
+		if (!serverQueue) return message.channel.send(':x: There is nothing playing.');
+		if (serverQueue.playing && serverQueue.paused) {
+			if (voiceChannel !== serverQueue.voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in the same voice channel as Musix to loop the queue!');
+			if (client.global.db.guilds[message.guild.id].permissions === true) {
+				if (client.global.db.guilds[message.guild.id].dj) {
+					if (!message.member.roles.cache.has(client.global.db.guilds[message.guild.id].djrole)) return message.channel.send(':x: You need the `DJ` role to resume the music!');
+				} else if (!permissions.has(PermissionFlagsBits.ManageMessages)) return message.channel.send(':x: You need the `MANAGE_MESSAGES` permission to resume the music!');
+			}
+			serverQueue.paused = false;
+			serverQueue.audioPlayer.unpause();
+			return message.channel.send('▶ Resumed the music!');
+		}
+		return message.channel.send(':x: The music is not paused!');
+	}
+};

commands/seek.js

@@ -0,0 +1,32 @@
+const { PermissionFlagsBits } = require("discord.js");
+module.exports = {
+    name: 'seek',
+    description: 'Seek music.',
+    alias: 'seek',
+    cooldown: 10,
+    async execute(message, args, client, prefix) {
+        const ytdl = require('ytdl-core');
+        const serverQueue = client.queue.get(message.guild.id);
+        const permissions = message.channel.permissionsFor(message.author);
+        const voiceChannel = message.member.voice.channel;
+        if (!serverQueue) return message.channel.send(':x: There is nothing playing.');
+        let data = await Promise.resolve(ytdl.getInfo(serverQueue.songs[0].url));
+        if (serverQueue.playing) {
+            if (voiceChannel !== serverQueue.voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in the same voice channel as Musix to seek the song!');
+            if (client.global.db.guilds[message.guild.id].permissions === true) {
+                if (client.global.db.guilds[message.guild.id].dj) {
+                    if (!message.member.roles.cache.has(client.global.db.guilds[message.guild.id].djrole)) return message.channel.send(':x: You need the `DJ` role to seek the song!');
+                } else if (!permissions.has(PermissionFlagsBits.ManageMessages)) return message.channel.send(':x: You need the `MANAGE_MESSAGES` permission to seek the song!');
+            }
+            if (!args[1]) return message.channel.send(`:x: Correct usage: \`${prefix}seek <seeking point in seconds>\``);
+            const pos = parseInt(args[1])
+            if (isNaN(pos)) return message.channel.send(':x: I\'m sorry, But you need to enter a valid __number__.');
+            if (pos < 0) return message.channel.send(':x: The seeking point needs to be a positive number!');
+            if (pos > data.length_seconds) return message.channel.send(`:x: The lenght of this song is ${data.length_seconds} seconds! You can't seek further than that!`);
+            serverQueue.audioPlayer.stop();
+            client.funcs.play(message.guild, serverQueue.songs[0], client, message, pos, false);
+        } else {
+            message.channel.send(':x: There is nothing playing!');
+        }
+    }
+};

commands/settings.js

@@ -0,0 +1,39 @@
+const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
+
+module.exports = {
+  name: 'settings',
+  usage: '[setting]',
+  description: 'Change the settings',
+  alias: 'settings',
+  cooldown: 10,
+  async execute(message, args, client, prefix) {
+    const embed = new EmbedBuilder()
+      .setTitle('Guild settings for Musix')
+      .addFields(
+        { name: 'prefix', value: 'Change the guild specific prefix. (string)', inline: true},
+        { name: 'volume', value: 'Change the default volume that the bot will start playing at. (number)', inline: true },
+        { name: 'permissions', value: 'Change whether to require permissions to use eg `skip, stop, pause, loop, etc...`', inline: true },
+        { name: 'setdj', value: 'Set a DJ role. This will allow chosen users to freely use all Musix commands. This will automatically set the `permissions` settings to true in order for the `DJ` role to have effect!', inline: true },
+        { name: 'announcesongs', value: 'Whether to announce songs that start playing or not.' },
+        { name: 'songselection', value: 'Will i ask to select a song from the top 10 queries or start playing the first result instantly.' }
+      )
+      .setFooter({ text: `how to use: ${prefix}settings <name> <value>` })
+      .setAuthor({ name: client.user.username, iconURL: client.user.avatarURL() })
+      .setColor(client.config.embedColor)
+    const permissions = message.channel.permissionsFor(message.author);
+    if (!permissions.has(PermissionFlagsBits.ManageGuild)) return message.channel.send(':x: You need the `MANAGE_SERVER` permission to change the settings!');
+    if (args[1]) {
+      const optionName = args[1].toLowerCase();
+      const option = client.settingCmd.get(optionName) || client.settingCmd.find(cmd => cmd.aliases && cmd.aliases.includes(optionName));
+      if (!option) return message.channel.send({ embeds: [embed] });
+      try {
+        option.execute(message, args, client, prefix);
+      } catch (error) {
+        message.reply(`:x: there was an error trying to execute that option!`);
+        console.log(error);
+      }
+    } else {
+      return message.channel.send({ embeds: [embed] });
+    }
+  },
+};

commands/settings/announcesongs.js

@@ -0,0 +1,12 @@
+module.exports = {
+    name: 'announcesongs',
+    async execute(message, args, client, prefix) {
+        if (client.global.db.guilds[message.guild.id].startPlaying) {
+            client.global.db.guilds[message.guild.id].startPlaying = false;
+            return message.channel.send(':white_check_mark: announcesongs now set to `false`!');
+        } else {
+            client.global.db.guilds[message.guild.id].startPlaying = true;
+            return message.channel.send(':white_check_mark: announcesongs now set to `true`!');
+        }
+    }
+};

commands/settings/permissions.js

@@ -0,0 +1,17 @@
+module.exports = {
+    name: 'permissions',
+    async execute(message, args, client, prefix) {
+        if (!args[2]) return message.channel.send(`🔒 Permission requirement: \`${client.global.db.guilds[message.guild.id].permissions}\``);
+        if (args[2] === 'true') {
+            if (!client.global.db.guilds[message.guild.id].permissions) {
+                client.global.db.guilds[message.guild.id].permissions = true;
+                message.channel.send(`:white_check_mark: Permissions requirement now set to: \`true\``);
+            } else return message.channel.send(':x: That value is already `true`!');
+        } else if (args[2] === 'false') {
+            if (client.global.db.guilds[message.guild.id].permissions) {
+                client.global.db.guilds[message.guild.id].permissions = false;
+                message.channel.send(`:white_check_mark: Permissions requirement now set to: \`false\``);
+            } else return message.channel.send(':x: That value is already `false`!');
+        } else return message.channel.send(':x: Please define a boolean! (true/false)');
+    }
+};

commands/settings/prefix.js

@@ -0,0 +1,8 @@
+module.exports = {
+    name: 'prefix',
+    async execute(message, args, client, prefix) {
+        if (!args[2]) return message.channel.send(`Current prefix: \`${client.global.db.guilds[message.guild.id].prefix}\``);
+        client.global.db.guilds[message.guild.id].prefix = args[2];
+        message.channel.send(`:white_check_mark: New prefix set to: \`${args[2]}\``);
+    }
+};

commands/settings/reset.js

@@ -0,0 +1,14 @@
+module.exports = {
+    name: 'reset',
+    async execute(message, args, client, prefix) {
+        client.global.db.guilds[message.guild.id] = {
+            prefix: client.config.prefix,
+            defaultVolume: 5,
+            permissions: false,
+            premium: false,
+            dj: false,
+            djrole: null
+        };
+        message.channel.send(':white_check_mark: Reset __all__ guild settings!');
+    }
+};

commands/settings/setDj.js

@@ -0,0 +1,28 @@
+const { PermissionFlagsBits } = require("discord.js");
+
+module.exports = {
+    name: 'setdj',
+    async execute(message, args, client, prefix) {
+        if (!client.global.db.guilds[message.guild.id].dj) {
+            if (!client.global.db.guilds[message.guild.id].permissions) {
+                client.global.db.guilds[message.guild.id].permissions = true;
+            }
+            if (message.guild.roles.cache.find(x => x.name === "DJ")) {
+                client.global.db.guilds[message.guild.id].djrole = message.guild.roles.cache.find(x => x.name === "DJ").id;
+                message.channel.send(':white_check_mark: I found a `DJ` role from this guild! This role is now the DJ role.');
+                client.global.db.guilds[message.guild.id].dj = true;
+            } else {
+                const permissions = message.channel.permissionsFor(message.client.user);
+                if (!permissions.has(PermissionFlagsBits.ManageRoles)) return message.channel.send(':x: I cannot create roles (Manage roles), make sure I have the proper permissions! I will need this permission to create a `DJ` role since i did not find one!');
+                message.guild.createRole({ name: 'DJ' })
+                    .then(role => client.global.db.guilds[message.guild.id].djrole = role.id)
+                    .catch(console.error)
+                client.global.db.guilds[message.guild.id].dj = true;
+                message.channel.send(':white_check_mark: I did not find a role `DJ` so i have created one for you!');
+            }
+        } else {
+            client.global.db.guilds[message.guild.id].dj = false;
+            message.channel.send(':white_check_mark: `DJ` now set to `false`');
+        }
+    }
+};

commands/settings/setpremium.js

@@ -0,0 +1,34 @@
+module.exports = {
+    name: 'setpremium',
+    async execute(message, args, client, prefix) {
+        //if (message.author.id !== client.config.devId) return;
+        if (args[2]) {
+            const guild = client.guilds.get(args[2]);
+            if (!client.global.db.guilds[guild.id].premium) {
+                client.global.db.playlists[guild.id] = {
+                    songs: [],
+                    firstSong: undefined,
+                    saved: false,
+                };
+                client.global.db.guilds[guild.id].premium = true;
+                message.channel.send(`:white_check_mark: Guild ${guild.name} | ${guild.id} is now premium! :tada:`)
+            } else {
+                client.global.db.guilds[guild.id].premium = false;
+                message.channel.send(`:white_check_mark: Guild ${guild.name} | ${guild.id} is no longer premium!`)
+            }
+        } else {
+            if (!client.global.db.guilds[message.guild.id].premium) {
+                client.global.db.playlists[message.guild.id] = {
+                    songs: [],
+                    firstSong: undefined,
+                    saved: false,
+                };
+                client.global.db.guilds[message.guild.id].premium = true;
+                message.channel.send(':white_check_mark: This guild is now premium! :tada:')
+            } else {
+                client.global.db.guilds[message.guild.id].premium = false;
+                message.channel.send(":white_check_mark: This guild is no longer premium!")
+            }
+        }
+    }
+};

commands/settings/songSelection.js

@@ -0,0 +1,12 @@
+module.exports = {
+    name: 'songselection',
+    async execute(message, args, client, prefix) {
+        if (!client.global.db.guilds[message.guild.id].songSelection) {
+            message.channel.send(':white_check_mark: Songselection now set to `true`!');
+            client.global.db.guilds[message.guild.id].songSelection = true;
+        } else {
+            client.global.db.guilds[message.guild.id].songSelection = false;
+            message.channel.send(':white_check_mark: Songselection now set to `false`');
+        }
+    }
+};

commands/settings/volume.js

@@ -0,0 +1,10 @@
+module.exports = {
+    name: 'volume',
+    async execute(message, args, client, prefix) {
+        if (!args[2]) return message.channel.send(`:speaker: Current default volume is: \`${client.global.db.guilds[message.guild.id].defaultVolume}\``);
+        if (isNaN(args[2])) return message.channel.send(':x: I\'m sorry, But the default volume needs to be a valid __number__.');
+        if (args[2].length > 2) return message.channel.send(':x: The default volume must be below `100` for quality and safety resons.');
+        client.global.db.guilds[message.guild.id].defaultVolume = args[2];
+        message.channel.send(`:white_check_mark: Default volume set to: \`${args[2]}\``);
+    }
+};

commands/shuffle.js

@@ -0,0 +1,21 @@
+module.exports = {
+    name: 'Shuffle',
+    description: 'Shuffle command.',
+    alias: 'shuffle',
+    cooldown: 5,
+    execute(message, args, client, prefix) {
+        const serverQueue = client.queue.get(message.guild.id);
+        let currentIndex = serverQueue.songs.length,
+            temporaryValue,
+            randomIndex;
+
+        while (0 !== currentIndex) {
+            randomIndex = Math.floor(Math.random() * currentIndex);
+            currentIndex -= 1;
+
+            temporaryValue = serverQueue.songs[currentIndex];
+            serverQueue.songs[currentIndex] = serverQueue.songs[randomIndex];
+            serverQueue.songs[randomIndex] = temporaryValue;
+        }
+    }
+};

commands/skip.js

@@ -0,0 +1,46 @@
+const { PermissionFlagsBits } = require("discord.js");
+
+module.exports = {
+	name: 'skip',
+	description: 'Skip command.',
+	alias: 's',
+	cooldown: 5,
+	execute(message, args, client, prefix) {
+		const voiceChannel = message.member.voice.channel;
+		const serverQueue = client.queue.get(message.guild.id);
+		const permissions = message.channel.permissionsFor(message.author);
+		if (!serverQueue) return message.channel.send(':x: There is nothing playing that I could skip for you.');
+		if (!serverQueue.playing) return message.channel.send(':x: There is nothing playing that I could skip for you.');
+		if (voiceChannel !== serverQueue.voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in the same voice channel as Musix to skip the song!');
+		if (client.global.db.guilds[message.guild.id].permissions === true) {
+			if (!message.member.roles.cache.has(client.global.db.guilds[message.guild.id].djrole) && !permissions.has(PermissionFlagsBits.ManageMessages)) {
+				return vote(serverQueue, message, client);
+			} else {
+				return skipSong(serverQueue, message);
+			}
+		} else {
+			return vote(serverQueue, message, client);
+		}
+	}
+};
+function skipSong(serverQueue, message) {
+	message.channel.send(':fast_forward: Skipped the song!');
+	serverQueue.audioPlayer.stop();
+};
+function vote(serverQueue, message) {
+	serverQueue.votesNeeded = Math.floor(serverQueue.voiceChannel.members.size / 2);
+	serverQueue.votesNeeded.toFixed();
+	if (serverQueue.voiceChannel.members.size > 2) {
+		if (serverQueue.voters.includes(message.member.id)) return message.channel.send(':x: You have already voted to skip!');
+		serverQueue.votes++;
+		serverQueue.voters.push(message.member.id);
+		if (serverQueue.votes >= serverQueue.votesNeeded) {
+			serverQueue.voters = [];
+			serverQueue.votes = 0;
+			serverQueue.votesNeeded = null;
+			return skipSong(serverQueue, message);
+		} else return message.channel.send(`:x: Not enough votes! ${serverQueue.votes} / ${serverQueue.votesNeeded}!`);
+	} else {
+		return skipSong(serverQueue, message);
+	}
+};

commands/status.js

@@ -0,0 +1,25 @@
+const { EmbedBuilder } = require("discord.js");
+const { getVoiceConnections } = require("@discordjs/voice");
+
+module.exports = {
+    name: 'status',
+    description: 'Status command.',
+    alias: 'status',
+    cooldown: 5,
+    async execute(message, args, client, prefix) {
+        const uptime = client.funcs.msToTime(client.uptime);
+        const ping = Math.floor(client.ws.ping * 10) / 10;
+
+        const embed = new EmbedBuilder()
+            .setTitle(`Status for ${client.user.username}`)
+            .addFields(
+                { name: ':signal_strength: Ping', value: ping + ' ms', inline: true },
+                { name: ':stopwatch: Uptime', value: uptime, inline: true },
+                { name: ':play_pause: Currently playing music on', value: `${getVoiceConnections.size ?? 0} guild(s)`, inline: true },
+                { name: ':cd: Operating system', value: process.platform, inline: true }
+            )
+            .setAuthor({ name: client.user.username, iconURL: client.user.avatarURL()})
+            .setColor(client.config.embedColor)
+        return message.channel.send({ embeds: [embed] });
+    }
+};

commands/stop.js

@@ -0,0 +1,25 @@
+const { PermissionFlagsBits } = require("discord.js");
+
+module.exports = {
+	name: 'stop',
+	description: 'Stop command.',
+	alias: 'stop',
+	cooldown: 5,
+	execute(message, args, client, prefix) {
+		const voiceChannel = message.member.voice.channel;
+		const serverQueue = client.queue.get(message.guild.id);
+		const permissions = message.channel.permissionsFor(message.author);
+		if (!serverQueue) return message.channel.send(':x: There is nothing playing that I could stop for you.');
+		if (!serverQueue.playing) return message.channel.send(':x: There is nothing playing that I could stop for you.');
+		if (voiceChannel !== serverQueue.voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in the same voice channel as Musix to stop the music!');
+		if (client.global.db.guilds[message.guild.id].permissions === true) {
+			if (client.global.db.guilds[message.guild.id].dj) {
+				if (!message.member.roles.cache.has(client.global.db.guilds[message.guild.id].djrole)) return message.channel.send(':x: You need the `DJ` role to stop the music!');
+			} else if (!permissions.has(PermissionFlagsBits.ManageChannels)) return message.channel.send(':x: You need the `MANAGE_CHANNELS` permission to stop the music!');
+		}
+		serverQueue.songs = [];
+		serverQueue.looping = false;
+		serverQueue.audioPlayer.stop();
+		message.channel.send(':stop_button: Stopped the music!')
+	}
+};

commands/volume.js

@@ -0,0 +1,29 @@
+const { PermissionFlagsBits } = require("discord.js");
+
+module.exports = {
+	name: 'volume',
+	description: 'Volume command.',
+	alias: 'volume',
+	cooldown: 5,
+	execute(message, args, client, Discord, prefix) {
+		const voiceChannel = message.member.voice.channel;
+		const serverQueue = client.queue.get(message.guild.id);
+		const permissions = message.channel.permissionsFor(message.author);
+		if (!serverQueue) return message.channel.send(':x: There is nothing playing.');
+		if (!serverQueue.playing) return message.channel.send(':x: There is nothing playing.');
+		if (!args[1]) return message.channel.send(`:loud_sound: The current volume is: **${serverQueue.volume}**`);
+		const volume = parseFloat(args[1]);
+		if (!voiceChannel) return message.channel.send(':x: I\'m sorry but you need to be in a voice channel to change the volume!');
+		if (client.global.db.guilds[message.guild.id].permissions === true) {
+			if (client.global.db.guilds[message.guild.id].dj) {
+				if (!message.member.roles.cache.has(client.global.db.guilds[message.guild.id].djrole)) return message.channel.send(':x: You need the `DJ` role to change the volume!');
+			} else if (!permissions.has(PermissionFlagsBits.ManageChannels)) return message.channel.send(':x: You need the `MANAGE_CHANNELS` permission to change the volume!');
+		}
+		if (isNaN(volume)) return message.channel.send(':x: I\'m sorry, But you need to enter a valid __number__.');
+		if (volume > 100) return message.channel.send(':x: The max volume is `100`!');
+		if (volume < 0) return message.channel.send(':x: The volume needs to be a positive number!');
+		serverQueue.volume = volume;
+		serverQueue.audioResource.volume.setVolume(volume / 100);
+		return message.channel.send(`:loud_sound: I set the volume to: **${volume}**`);
+	}
+};

config.js

@@ -0,0 +1,10 @@
+module.exports = {
+    discord_api_token: process.env.DISCORD_API_TOKEN,
+    firebase: {
+        serviceAccount: null
+        //serviceAccount: require('./serviceAccount.json')
+    },
+    youtube_api_key: process.env.YOUTUBE_API_KEY,
+    prefix: process.env.BOT_PREFIX ?? "mx>",
+    embedColor: "#b50002"
+}

events/guildcreate.js

@@ -0,0 +1,25 @@
+module.exports = {
+    name: 'guildcreate',
+    async execute(client, guild) {
+        if(client.config.firebase.serviceAccount){
+            client.db.collection('guilds').doc(guild.id).set({
+                prefix: client.config.prefix,
+                defaultVolume: 50,
+                permissions: false,
+                premium: false,
+                dj: false,
+                djrole: null,
+                startPlaying: true
+            });
+            client.global.db.guilds[guild.id] = {
+                prefix: client.config.prefix,
+                defaultVolume: 50,
+                permissions: false,
+                premium: false,
+                dj: false,
+                djrole: null,
+                startPlaying: true
+            };
+        }
+    }
+}

events/message.js

@@ -0,0 +1,24 @@
+module.exports = {
+    name: 'message',
+    async execute(client, message) {
+        if (message.author.bot || !message.guild) return;
+        let prefix = client.global.db.guilds[message.guild.id].prefix;
+        const args = message.content.slice(prefix.length).split(' ');
+        if (message.mentions.users.first()) {
+            if (message.mentions.users.first().id === client.user.id) {
+                if (!args[1]) return;
+                if (args[1] === 'prefix') return message.channel.send(`My prefix here is: \`${prefix}\`.`);
+                if (args[1] === 'help') {
+                    const command = client.commands.get("help");
+                    return client.funcs.exe(message, args, client, prefix, command);
+                }
+            }
+        }
+        if (!message.content.startsWith(prefix)) return;
+        if (!args[0]) return;
+        const commandName = args[0].toLowerCase();
+        const command = client.commands.get(commandName) || client.commands.find(cmd => cmd.aliases && cmd.aliases.includes(commandName)) || client.commandAliases.get(commandName);
+        if (!command && message.content !== `${prefix}`) return;
+        client.funcs.exe(message, args, client, prefix, command);
+    }
+}

events/ready.js

@@ -0,0 +1,53 @@
+module.exports = {
+    name: 'ready',
+    async execute(client) {
+
+        client.user.setActivity(`@${client.user.username} help | 🎶`, { type: 'LISTENING' });
+        client.user.setStatus('online');
+        console.log('- Activated -');
+
+        client.guilds.cache.forEach(guild => {
+            client.global.db.guilds[guild.id] = {
+                prefix: client.config.prefix,
+                defaultVolume: 50,
+                permissions: false,
+                premium: false,
+                dj: false,
+                djrole: null,
+                startPlaying: true
+            };
+        });
+
+        if(client.config.firebase.serviceAccount){
+            const remoteMusixGuildsData = await client.funcs.dbget('guilds', null, client);
+            const remoteMusixPlaylistsData = await client.funcs.dbget('playlists', null, client);
+            remoteMusixGuildsData.forEach(guildData => {
+                client.global.db.guilds[guildData.id] = guildData.d;
+            });
+            remoteMusixPlaylistsData.forEach(guildData => {
+                client.global.db.playlists[guildData.id] = guildData.d;
+            });
+            console.log('- DB Set -');
+
+            setInterval(async () => {
+                client.guilds.cache.forEach(guild => {
+                    client.db.collection('guilds').doc(guild.id).set({
+                        prefix: client.global.db.guilds[guild.id].prefix,
+                        defaultVolume: client.global.db.guilds[guild.id].defaultVolume,
+                        permissions: client.global.db.guilds[guild.id].permissions,
+                        premium: client.global.db.guilds[guild.id].premium,
+                        dj: client.global.db.guilds[guild.id].dj,
+                        djrole: client.global.db.guilds[guild.id].djrole,
+                        startPlaying: client.global.db.guilds[guild.id].startPlaying
+                    });
+                    if (client.global.db.guilds[guild.id].premium) {
+                        client.db.collection('playlists').doc(guild.id).set({
+                            songs: client.global.db.playlists[guild.id].songs,
+                            saved: client.global.db.playlists[guild.id].saved,
+                        });
+                    }
+                });
+            }, 1800000);
+        }
+    }
+}

funcs/dbget.js

@@ -0,0 +1,22 @@
+module.exports = async function (collection, doc, client) {
+  if (doc) {
+    let d = await client.db.collection(collection).doc(doc).get().catch(err => {
+      console.log('Error getting document', err);
+      return 'error';
+    });
+    return d.data();
+  } else {
+    let d = await client.db.collection(collection).get().catch(err => {
+      console.log('Error getting document', err);
+      return 'error';
+    });
+    let finalD = [];
+    d.forEach(doc => {
+      finalD.push({
+        id: doc.id,
+        d: doc.data(),
+      });
+    });
+    return finalD;
+  }
+};

funcs/exe.js

@@ -0,0 +1,13 @@
+const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
+
+module.exports = function (message, args, client, prefix, command) {
+    const permissions = message.channel.permissionsFor(message.client.user);
+    if (!permissions.has(PermissionFlagsBits.EmbedLinks)) return message.channel.send(':x: I cannot send embeds (Embed links), make sure I have the proper permissions!');
+    try {
+        command.uses++;
+        command.execute(message, args, client, prefix);
+    } catch (error) {
+        message.reply(`:x: there was an error trying to execute that command!`);
+        console.log(error);
+    }
+};

funcs/handleVideo.js

@@ -0,0 +1,53 @@
+const { createAudioPlayer, getVoiceConnection, joinVoiceChannel, NoSubscriberBehavior } = require("@discordjs/voice");
+
+module.exports = async function (video, message, voiceChannel, client, playlist = false) {
+    let song = {
+        id: video.id,
+        title: he.decode(video.title),
+        url: `https://www.youtube.com/watch?v=${video.id}`,
+        author: message.author
+    }
+    const serverQueue = client.queue.get(message.guild.id);
+    if (!serverQueue) {
+        const construct = {
+            textChannel: message.channel,
+            voiceChannel: voiceChannel,
+            connection: null,
+            audioPlayer: createAudioPlayer({
+				behaviors: {
+					noSubscriber: NoSubscriberBehavior.Play,
+				}
+			}),
+            songs: [],
+            volume: client.global.db.guilds[message.guild.id].defaultVolume,
+            playing: false,
+            paused: false,
+            looping: false,
+            votes: 0,
+            voters: [],
+            votesNeeded: null
+        };
+        construct.songs.push(song);
+        client.queue.set(message.guild.id, construct);
+        try {
+            const connection =
+				getVoiceConnection(voiceChannel.guild.id) ??
+				joinVoiceChannel({
+					channelId: voiceChannel.id,
+					guildId: voiceChannel.guild.id,
+					adapterCreator: voiceChannel.guild.voiceAdapterCreator
+				});
+            construct.connection = connection;
+            client.funcs.play(message.guild, construct.songs[0], client, message, 0, true);
+        } catch (error) {
+            client.queue.delete(message.guild.id);
+            console.log("Error with connecting to voice channel: " + error);
+            return message.channel.send(`:x: An error occured: ${error}`);
+        }
+    } else {
+        serverQueue.songs.push(song);
+        if (playlist) return undefined;
+        return message.channel.send(`:white_check_mark: **${song.title}** has been added to the queue!`);
+    }
+    return undefined;
+}

funcs/msToTime.js

@@ -0,0 +1,11 @@
+module.exports = function msToTime(duration) {
+    var seconds = Math.floor((duration / 1000) % 60),
+        minutes = Math.floor((duration / (1000 * 60)) % 60),
+        hours = Math.floor((duration / (1000 * 60 * 60)) % 24);
+
+    hours = (hours < 10) ? "0" + hours : hours;
+    minutes = (minutes < 10) ? "0" + minutes : minutes;
+    seconds = (seconds < 10) ? "0" + seconds : seconds;
+
+    return `${hours}:${minutes}:${seconds}`;
+}

funcs/play.js

@@ -0,0 +1,48 @@
+const { EmbedBuilder } = require('discord.js');
+const { AudioPlayerStatus, createAudioResource } = require('@discordjs/voice');
+const ytdl = require('ytdl-core');
+
+module.exports = async function (guild, song, client, message, seek, play) {
+    const serverQueue = client.queue.get(guild.id);
+    if (!song) {
+        serverQueue.connection.destroy();
+        client.queue.delete(guild.id);
+        return;
+    }
+
+    serverQueue.audioPlayer
+		.on(AudioPlayerStatus.Idle, () => {
+            serverQueue.playing = false;
+			serverQueue.audioPlayer.removeAllListeners();
+            if (serverQueue.looping) {
+                serverQueue.songs.push(serverQueue.songs[0]);
+            }
+            serverQueue.songs.shift();
+			client.funcs.play(guild, serverQueue.songs[0], client, message);
+		})
+		.on('error', (error) => {
+			console.error(error)
+		});
+
+    const audioResource = createAudioResource(ytdl(song.url, { filter: "audio", highWaterMark: 1 << 25 }),{
+        inlineVolume: true
+    });
+
+    audioResource.volume.setVolume(serverQueue.volume / 100);
+
+    serverQueue.audioPlayer.play(audioResource);
+    serverQueue.audioResource = audioResource;
+    serverQueue.connection.subscribe(serverQueue.audioPlayer);
+
+    /*.playStream(ytdl(song.url, { filter: "audio", highWaterMark: 1 << 25 }), { seek: seek, bitrate: 1024, passes: 10, volume: 1 })*/
+    if (client.global.db.guilds[guild.id].startPlaying || play) {
+        let data = await Promise.resolve(ytdl.getInfo(serverQueue.songs[0].url));
+        let songtime = (data.length_seconds * 1000).toFixed(0);
+        const embed = new EmbedBuilder()
+            .setTitle(`:musical_note: Start playing: **${song.title}**`)
+            .setDescription(`Song duration: \`${client.funcs.msToTime(songtime)}\``)
+            .setColor("#b50002")
+        serverQueue.textChannel.send({ embeds: [embed] });
+    }
+    serverQueue.playing = true;
+}

index.js

@@ -1,31 +1,50 @@
-const { ShardingManager} = require("discord.js");
-const config = require("./src/config/config.js");
-const DiscordWebhook = require("discord-webhook-node");
+const Discord = require('discord.js');
+const MusicClient = require('./Client');
+const client = new MusicClient({});
+const fs = require('fs');
 
-if (config.devMode) {
-  console.log("- dev mode- ");
-  config.shards = 1;
+const commandFiles = fs.readdirSync('./commands/').filter(f => f.endsWith('.js'));
+for (const file of commandFiles) {
+  const command = require(`./commands/${file}`);
+  command.uses = 0;
+  client.commands.set(command.name, command);
+  client.commandAliases.set(command.alias, command);
 }
 
-const manager = new ShardingManager("./src/bot.js", {
-  token: config.token,
-  respawn: config.respawn,
-  totalShards: config.shards,
+const eventFiles = fs.readdirSync('./events/').filter(f => f.endsWith('.js'));
+for (const file of eventFiles) {
+  const event = require(`./events/${file}`);
+  client.events.set(event.name, event);
+}
+
+const playlistFiles = fs.readdirSync('./commands/playlist/').filter(f => f.endsWith('.js'));
+for (const file of playlistFiles) {
+  const option = require(`./commands/playlist/${file}`);
+  client.playlistCmd.set(option.name, option);
+}
+
+const settingFiles = fs.readdirSync('./commands/settings/').filter(f => f.endsWith('.js'));
+for (const file of settingFiles) {
+  const option = require(`./commands/settings/${file}`);
+  client.settingCmd.set(option.name, option);
+}
+
+client.on('ready', async () => {
+  const eventName = 'ready';
+  const event = client.events.get(eventName) || client.events.find(ent => ent.aliases && ent.aliases.includes(eventName));
+  event.execute(client);
 });
 
-console.log("- Launching shards -");
-manager.spawn(config.shards, config.shardDelay, config.shardTimeout);
-manager.on("shardCreate", (shard) =>
-  console.log(`- Launched shard ${shard.id} -`)
-);
+client.on('messageCreate', message => {
+  const eventName = 'message';
+  const event = client.events.get(eventName) || client.events.find(ent => ent.aliases && ent.aliases.includes(eventName));
+  event.execute(client, message);
+});
 
-const oldConsole = {};
-oldConsole.log = console.log;
-console.log = function (arg) {
-  oldConsole.log(arg);
-};
+client.on('guildCreate', async (guild) => {
+  const eventName = 'guildcreate';
+  const event = client.events.get(eventName) || client.events.find(ent => ent.aliases && ent.aliases.includes(eventName));
+  event.execute(client, guild);
+});
 
-oldConsole.error = console.error;
-console.error = function (arg) {
-  oldConsole.error(arg);
-};
+client.login(client.config.discord_api_token).catch(err => { console.log('- Failed To Login -> ' + err); });

package.json

@@ -1,37 +1,32 @@
 {
   "name": "musix-oss",
-  "version": "3.11.0",
-  "description": "V3 for Musix the discord music bot",
-  "main": "./index.js",
+  "version": "2.22.0",
+  "description": "",
+  "main": "index.js",
   "scripts": {
-    "start": "node --max-old-space-size=3072 index.js",
+    "start": "node index.js",
     "start:dev": "nodemon"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/musix-org/musix-oss.git"
-  },
+  "keywords": [],
   "author": "Musix Org",
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/musix-org/musix-oss/issues",
-    "support": "https://discord.gg/rvHuJtB"
+  "homepage": "https://https://github.com/musix-oss/musix",
+  "repository": {
+    "type": "git",
+    "url": "https://https://github.com/musix-oss/musix"
   },
-  "homepage": "https://musix-org.github.io/",
   "dependencies": {
+    "discord.js": "^14.25.1",
+    "@discordjs/voice": "^0.19.0",
     "@discordjs/opus": "^0.10.0",
-    "discord-webhook-node": "^1.1.8",
-    "discord.js": "^14.24.2",
     "dotenv": "^17.2.3",
-    "firebase": "^12.5.0",
+    "firebase": "^12.6.0",
     "firebase-admin": "^13.6.0",
     "he": "^1.2.0",
-    "prism-media": "^1.3.5",
+    "ms": "^2.1.3",
     "request": "^2.88.2",
     "simple-youtube-api": "^5.2.1",
-    "spotify-web-api-node": "^5.0.2",
-    "ytdl-core": "^4.11.5",
-    "ytsr": "^3.8.4"
+    "ytdl-core": "^4.11.5"
   },
   "devDependencies": {
     "nodemon": "^3.1.11"

src/bot.js

@@ -1,14 +0,0 @@
-const MusicClient = require("./client.js");
-const DiscordWebhook = require("discord-webhook-node");
-const client = new MusicClient({});
-
-const oldConsole = {};
-oldConsole.log = console.log;
-console.log = function (arg) {
-  oldConsole.log(arg);
-};
-
-oldConsole.error = console.error;
-console.error = function (arg) {
-  oldConsole.error(arg);
-};

src/client.js

@@ -1,82 +0,0 @@
-const {
-  Client,
-  Collection,
-  Intents
-} = require("discord.js");
-const admin = require("firebase-admin");
-const serviceAccount = require("./config/serviceAccount.json");
-const fs = require("fs");
-const path = require("path");
-const SpotifyApi = require("spotify-web-api-node");
-const YouTube = require("simple-youtube-api");
-const config = require("./config/config");
-
-const GatewayIntents = new Intents();
-GatewayIntents.add(
-  1 << 0, // GUILDS
-  1 << 7, // GUILD_VOICE_STATES
-  1 << 9, // GUILD_MESSAGES,
-  1 << 15 // MESSAGE_CONTENT
-);
-
-module.exports = class extends Client {
-  constructor() {
-    super({
-      disableMentions: "everyone",
-      disabledEvents: ["TYPING_START"],
-      ws: {
-        intents: GatewayIntents
-      }
-    });
-
-    admin.initializeApp({
-      credential: admin.credential.cert(serviceAccount),
-    });
-    this.commands = new Collection();
-    this.settingCmd = new Collection();
-    this.queue = new Map();
-    this.spotify = new SpotifyApi({
-      id: config.spotify_client_id,
-      secret: config.spotify_client_secret,
-    });
-    this.youtube = new YouTube(config.youtube_api_key);
-    this.config = config;
-    this.funcs = {};
-    this.dispatcher = {};
-    this.messages = require("./config/messages.js");
-    this.db = admin.firestore();
-    this.db.FieldValue = require("firebase-admin").firestore.FieldValue;
-    this.global = {
-      db: {
-        guilds: {},
-      }
-    };
-    this.logs = [];
-
-    fs.readdirSync(path.join(__dirname, "funcs")).forEach((filename) => {
-      this.funcs[filename.slice(0, -3)] = require(`./funcs/${filename}`);
-    });
-
-    const commandFiles = fs
-      .readdirSync(path.join(path.dirname(__dirname), "commands"))
-      .filter((f) => f.endsWith(".js"));
-    for (const file of commandFiles) {
-      const command = require(`../commands/${file}`);
-      command.uses = 0;
-      this.commands.set(command.name, command);
-    }
-    const settingFiles = fs
-      .readdirSync(path.join(path.dirname(__dirname), "commands/settings"))
-      .filter((f) => f.endsWith(".js"));
-    for (const file of settingFiles) {
-      const option = require(`../commands/settings/${file}`);
-      this.settingCmd.set(option.name, option);
-    }
-
-    require("./events/clientEvents/handler.js")(this);
-
-    this.login(this.config.discord_api_token).catch((err) =>
-      console.log("Failed to login: " + err)
-    );
-  }
-};

src/commands/bass.js

@@ -1,33 +0,0 @@
-module.exports = {
-  name: "bass",
-  description: "Boost the bass in your music!",
-  alias: ["none"],
-  usage: "<bass>",
-  permission: "MANAGE_MESSAGES",
-  category: "audio modifiers",
-  execute(msg, args, client, command) {
-    const queue = client.queue.get(msg.guild.id);
-    if (!args[1] && queue)
-      return msg.channel.send(
-        `${client.messages.currentBass}**${queue.bass}**`
-      );
-    const bass = parseFloat(args[1]);
-    if (client.funcs.check(client, msg, command)) {
-      if (queue.nightCore)
-        return msg.channel.send(client.messages.disableNightCore);
-      if (isNaN(bass)) return msg.channel.send(client.messages.validNumber);
-      if (bass > 10) return msg.channel.send(client.messages.maxBass);
-      if (bass < 0) return msg.channel.send(client.messages.positiveBass);
-      queue.bass = bass;
-      client.funcs.end(
-        client,
-        msg,
-        (queue.connection.dispatcher.streamTime + queue.time) / 1000,
-        command
-      );
-      let message;
-      message = client.messages.bassApplied.replace("%BASS%", bass);
-      return msg.channel.send(message);
-    }
-  },
-};

src/commands/help.js

@@ -1,39 +0,0 @@
-const { EmbedBuilder } = require("discord.js");
-
-module.exports = {
-    name: 'help',
-    alias: ["h"],
-    usage: '<command(opt)>',
-    description: 'See the help for Musix.',
-    permission: 'none',
-    category: 'info',
-    execute(msg, args, client, command) {
-        if (args[1]) {
-            if (!client.commands.has(args[1]) || (client.commands.has(args[1]) && client.commands.get(args[1]).omitFromHelp === true && msg.guild.id !== '489083836240494593')) return msg.channel.send('That command does not exist');
-            const command = client.commands.get(args[1]);
-            const embed = new EmbedBuilder()
-                .setTitle(`${client.global.db.guilds[msg.guild.id].prefix}${command.name} ${command.usage}`)
-                .setDescription(command.description)
-                .setFooter({ text:`${client.messages.helpCmdFooter} \`${command.alias.map(a => `${a}, `)}\`` })
-                .setColor(client.config.embedColor)
-            msg.channel.send(embed);
-        } else {
-            const categories = [];
-            for (let i = 0; i < client.commands.size; i++) {
-                if (!categories.includes(client.commands.array()[i].category)) categories.push(client.commands.array()[i].category);
-            }
-            let commands = '';
-            for (let i = 0; i < categories.length; i++) {
-                commands += `**» ${categories[i].toUpperCase()}**\n${client.commands.filter(x => x.category === categories[i] && !x.omitFromHelp).map(x => `\`${x.name}\``).join(', ')}\n`;
-            }
-            let message;
-            message = client.messages.helpFooter.replace("%PREFIX%", client.global.db.guilds[msg.guild.id].prefix);
-            const embed = new EmbedBuilder()
-                .setTitle(`${client.user.username} ${client.messages.helpTitle}`)
-                .setDescription(commands)
-                .setFooter({ text: message })
-                .setColor(client.config.embedColor)
-            msg.channel.send(embed);
-        }
-    }
-};

src/commands/invite.js

@@ -1,17 +0,0 @@
-const { EmbedBuilder } = require("discord.js");
-
-module.exports = {
-    name: 'invite',
-    alias: ["i"],
-    usage: '',
-    description: 'Invite Musix.',
-    permission: 'none',
-    category: 'info',
-    execute(msg, args, client, command) {
-        const embed = new EmbedBuilder()
-            .setTitle(client.messages.inviteTitle)
-            .setURL(client.config.invite)
-            .setColor(client.config.embedColor)
-        msg.channel.send(embed);
-    }
-};

src/commands/loop.js

@@ -1,20 +0,0 @@
-module.exports = {
-    name: 'loop',
-    alias: [],
-    usage: '',
-    description: 'loop the queue.',
-    permission: 'MANAGE_MESSAGES',
-    category: 'music control',
-    async execute(msg, args, client, command) {
-        const queue = client.queue.get(msg.guild.id);
-        if (client.funcs.check(client, msg, command)) {
-            if (!queue.looping) {
-                queue.looping = true;
-                msg.channel.send(client.messages.looping);
-            } else {
-                queue.looping = false;
-                msg.channel.send(client.messages.noLooping);
-            }
-        }
-    }
-};

src/commands/loopsong.js

@@ -1,22 +0,0 @@
-module.exports = {
-    name: 'loopsong',
-    alias: ["none"],
-    usage: '',
-    description: 'loop the currently playing song.',
-    permission: 'MANAGE_MESSAGES',
-    category: 'music control',
-    async execute(msg, args, client, command) {
-        const queue = client.queue.get(msg.guild.id);
-        if (client.funcs.check(client, msg, command)) {
-            if (!queue.songLooping) {
-                queue.songLooping = true;
-                let message;
-                message = client.messages.loopingSong.replace("%TITLE%", queue.songs[0].title);
-                msg.channel.send(message);
-            } else {
-                queue.songLooping = false;
-                msg.channel.send(client.messages.noLoopingSong);
-            }
-        }
-    }
-};

src/commands/lyrics.js

@@ -1,37 +0,0 @@
-const { EmbedBuilder } = require("discord.js");
-const { getLyrics } = require("genius-lyrics-api");
-
-module.exports = {
-  name: "lyrics",
-  alias: ["l"],
-  usage: "<song>",
-  description: "see the lyrics for a song",
-  permission: "none",
-  category: "util",
-  async execute(msg, args, client, prefix, command) {
-    const searchString = args.slice(1).join(" ");
-    const options = {
-      apiKey: client.config.genius_api_key,
-      title: searchString,
-      artist: "",
-      optimizeQuery: true,
-    };
-    const queue = client.queue.get(msg.guild.id);
-    if (queue && !args[1]) options.title = queue.songs[0].title;
-    if (!queue && !args[1])
-      return msg.channel.send(client.messages.lyricsUsage);
-    getLyrics(options).then((lyrics) => {
-      if (lyrics === null)
-        return msg.channel.send(client.messages.noResultsLyrics);
-      for (let i = 0; i < lyrics.length; i += 2000) {
-        let toi = "";
-        toi = lyrics.substring(i, Math.min(lyrics.length, i + 2000));
-        const embed = new EmbedBuilder()
-          .setTitle(client.messages.lyricsTitle)
-          .setDescription(toi)
-          .setColor(client.config.embedColor);
-        msg.channel.send(embed);
-      }
-    });
-  },
-};

src/commands/nightcore.js

@@ -1,25 +0,0 @@
-module.exports = {
-  name: "nightcore",
-  alias: ["nc"],
-  usage: "<true/false>",
-  description: "Change nightcore audio modifier on/off",
-  permission: "MANAGE_MESSAGES",
-  category: "audio modifiers",
-  async execute(msg, args, client, command) {
-    const queue = client.queue.get(msg.guild.id);
-    if (!args[1] && queue)
-      return msg.channel.send(
-        `${client.messages.currentNightCore}**${queue.nightCore}**`
-      );
-    if (client.funcs.check(client, msg, command)) {
-      if (args[1] === "true") {
-        queue.nightCore = true;
-      } else if (args[1] === "false") {
-        queue.nightCore = false;
-      } else return msg.channel.send(client.messages.boolean);
-      let message;
-      message = client.messages.nightCoreApplied.replace("%BOOLEAN%", args[1]);
-      return msg.channel.send(message);
-    }
-  },
-};

src/commands/nowplaying.js

@@ -1,48 +0,0 @@
-const { EmbedBuilder } = require("discord.js");
-
-module.exports = {
-  name: "nowplaying",
-  alias: ["np", "playing"],
-  usage: "",
-  description: "See the currently playing song position and length.",
-  permission: "none",
-  category: "info",
-  async execute(msg, args, client, command) {
-    const queue = client.queue.get(msg.guild.id);
-    if (!queue || !queue.songs[0] || !queue.connection || !queue.connection.dispatcher) return msg.channel.send(client.messages.noServerQueue);
-    let songTime = (queue.songs[0].info.lengthSeconds * 1000).toFixed(0);
-    let completed = (
-      queue.connection.dispatcher.streamTime + queue.time
-    ).toFixed(0);
-    let barlength = 30;
-    let completedpercent = ((completed / songTime) * barlength).toFixed(0);
-    let array = [];
-    for (let i = 0; i < completedpercent - 1; i++) {
-      array.push("⎯");
-    }
-    array.push("🔘");
-    for (let i = 0; i < barlength - completedpercent - 1; i++) {
-      array.push("⎯");
-    }
-    const thumbnail = queue.songs[0].info.thumbnail.thumbnails[4] || queue.songs[0].info.thumbnail.thumbnails[3] || queue.songs[0].info.thumbnail.thumbnails[2] || queue.songs[0].info.thumbnail.thumbnails[1] || queue.songs[0].info.thumbnail.thumbnails[0];
-    const embed = new EmbedBuilder()
-      .setTitle(client.messages.nowPlaying)
-      .setDescription(
-        `${client.messages.nowPlayingDesc} ${
-          queue.songs[0].title
-        }\n\`${array.join("")}\`\n\`${client.funcs.msToTime(
-          completed,
-          "hh:mm:ss"
-        )} / ${client.funcs.msToTime(songTime, "hh:mm:ss")}\`\nchannel: \`${queue.songs[0].info.author.name}\``
-      )
-      .setFooter({ text: `Queued by ${queue.songs[0].author.tag}`})
-      .setURL(queue.songs[0].url)
-      .setThumbnail(thumbnail.url)
-      .setColor(client.config.embedColor);
-    if (queue.nightCore)
-      embed.setDescription(
-        `${client.messages.nowPlayingDesc} ${queue.songs[0].title} \nchannel: \`${queue.songs[0].info.author.name}\``
-      );
-    return msg.channel.send(embed);
-  },
-};

src/commands/pause.js

@@ -1,17 +0,0 @@
-module.exports = {
-	name: 'pause',
-	alias: ["none"],
-	usage: '',
-	description: 'Pause the currently playing music.',
-	permission: 'MANAGE_MESSAGES',
-	category: 'music control',
-	execute(msg, args, client, command) {
-		const queue = client.queue.get(msg.guild.id);
-		if (client.funcs.check(client, msg, command)) {
-			if (queue.paused) return msg.channel.send(client.messages.alreadyPaused);
-			queue.paused = true;
-			queue.connection.dispatcher.pause(true);
-			return msg.channel.send(client.messages.paused);
-		}
-	}
-};

src/commands/play.js

@@ -1,401 +0,0 @@
-const ytdl = require("ytdl-core");
-const ytsr = require("ytsr");
-
-module.exports = {
-  name: "play",
-  alias: ["p", "music"],
-  usage: "<song name>",
-  description: "Play some music.",
-  permission: "none",
-  category: "play",
-  async execute(msg, args, client, command) {
-    const searchString = args.slice(1).join(" ");
-    const url = args[1] ? args[1].replace(/<(.+)>/g, "$1") : "";
-    const queue = client.queue.get(msg.guild.id);
-    const voiceChannel = msg.member.voice.channel;
-    if (
-      client.global.db.guilds[msg.guild.id].blacklist.includes(
-        msg.member.voice.channelID
-      )
-    )
-      return msg.channel.send(client.messages.blackListedVC);
-    if (!queue) {
-      if (!msg.member.voice.channel)
-        return msg.channel.send(client.messages.noVoiceChannel);
-    } else {
-      if (voiceChannel !== queue.voiceChannel)
-        return msg.channel.send(client.messages.wrongVoiceChannel);
-    }
-    if (!args[1]) return msg.channel.send(client.messages.noQuery);
-    if (voiceChannel.full) return msg.channel.send(client.messages.channelFull);
-    if (!voiceChannel.joinable)
-      return msg.channel.send(client.messages.noPermsConnect);
-    if (!voiceChannel.speakable)
-      return msg.channel.send(client.messages.noPermsSpeak);
-    if (ytdl.validateURL(url)) {
-      client.funcs.handleVideo(url, msg, voiceChannel, client, false, "ytdl");
-    } else if (url.match(/^https?:\/\/(open.spotify.com|spotify.com)(.*)$/)) {
-      if (url.includes("playlist")) {
-        const playlistId = url.split("/playlist/")[1].split("?")[0];
-        client.spotify.getPlaylist(playlistId).then(
-          async function (data) {
-              searchPlaylist(data, client, msg, voiceChannel);
-            },
-            function (err) {
-              console.log(err);
-              msg.channel.send(client.messages.noResultsSpotify);
-            }
-        );
-      } else if (url.includes("album")) {
-        const albumId = url.split("/album/")[1].split("?")[0];
-        client.spotify.getAlbumTracks(albumId).then(
-          async function (data) {
-              searchAlbum(data, client, msg, voiceChannel);
-            },
-            function (err) {
-              console.log(err);
-              msg.channel.send(client.messages.noResultsSpotify);
-            }
-        );
-      } else if (url.includes("track")) {
-        return msg.channel.send(client.messages.disabledSpotifySongs);
-        /*const trackId = url.split("/track/")[1].split("?")[0];
-        spotify.searchTracks(trackId)
-          .then(function (data) {
-            console.log(data.body)
-          }, function (err) {
-            console.log('Something went wrong!', err);
-          });*/
-      } else msg.channel.send(client.messages.invalidSpotifyUrl);
-    } else if (
-      url.match(/^https?:\/\/(www.youtube.com|youtube.com)\/playlist(.*)$/)
-    ) {
-      const lmsg = await msg.channel.send(client.messages.loadingSongs);
-      const playlist = await client.youtube.getPlaylist(url).catch((err) => {
-        console.log("err1");
-      });
-      const videos = await playlist.getVideos().catch((err) => {
-        console.log("err2");
-      });
-      for (const video of Object.values(videos)) {
-        const video2 = await client.youtube.getVideoByID(video.id).catch((err) => {
-          console.log("err3");
-        });
-        client.spotify.searchTracks(`track:${video2.name}`).then(
-          function (data) {
-            client.funcs.handleVideo(
-              video2.url,
-              msg,
-              voiceChannel,
-              client,
-              true,
-              "ytdl",
-              data.body.tracks.items[0]
-            );
-          },
-          function (err) {
-            console.log("Something went wrong!", err);
-          }
-        );
-      }
-      const message = client.messages.playlistAdded.replace(
-        "%TITLE%",
-        playlist.title
-      );
-      return lmsg.edit(message);
-    } else {
-      ytsr(
-        searchString, {
-          limit: 5,
-        },
-        function (err, res) {
-          if (err) console.log(err);
-          if (!res.items[0]) return msg.channel.send(client.messages.noResults);
-          const videoResults = res.items.filter(
-            (item) => item.type === "video"
-          );
-          client.spotify.searchTracks(`track:${searchString}`).then(
-            function (data) {
-              client.funcs.handleVideo(
-                videoResults[0].link,
-                msg,
-                voiceChannel,
-                client,
-                false,
-                "ytdl",
-                data.body.tracks.items[0]
-              );
-            },
-            function (err) {
-              console.log(err);
-            }
-          );
-        }
-      );
-    }
-  },
-};
-
-async function searchPlaylist(data, client, msg, voiceChannel) {
-  const lmsg = await msg.channel.send(client.messages.loadingSongs);
-  let failed = 0;
-  for (let i = 0; data.body.tracks.items.length > i; i++) {
-    const track = await data.body.tracks.items[i].track;
-    await client.funcs.sleep(250);
-    ytsr(
-      `${track.artists[0].name} ${track.name} audio`, {
-        limit: 5,
-      },
-      async function (err, res) {
-        if (err) return console.log(err);
-        if (!res.items[0]) {
-          ytsr(
-            `${track.artists[0].name} ${track.name} lyrics`, {
-              limit: 5,
-            },
-            async function (err, res) {
-              if (err) return console.log(err);
-              if (!res.items[0]) {
-                ytsr(
-                  `${track.artists[0].name} ${track.name}`, {
-                    limit: 5,
-                  },
-                  async function (err, res) {
-                    if (err) console.log(err);
-                    if (!res.items[0]) {
-                      failed++;
-                    }
-                    const videoResults = res.items.filter(
-                      (item) => item.type === "video"
-                    );
-                    client.funcs.handleVideo(
-                      videoResults[0].link,
-                      msg,
-                      voiceChannel,
-                      client,
-                      false,
-                      "spotify",
-                      track
-                    );
-                  }
-                );
-                return;
-              }
-              const videoResults = res.items.filter(
-                (item) => item.type === "video"
-              );
-              await client.funcs.handleVideo(
-                videoResults[0].link,
-                msg,
-                voiceChannel,
-                client,
-                true,
-                "spotify",
-                track
-              );
-            }
-          );
-          failed++;
-          return;
-        }
-        const videoResults = res.items.filter((item) => item.type === "video");
-        await client.funcs.handleVideo(
-          videoResults[0].link,
-          msg,
-          voiceChannel,
-          client,
-          true,
-          "spotify",
-          track
-        );
-      }
-    );
-  }
-  let message;
-  if (failed === 0) {
-    message = client.messages.playlistAdded.replace("%TITLE%", data.body.name);
-  } else {
-    message = `${client.messages.playlistAdded.replace(
-      "%TITLE%",
-      data.body.name
-    )}\n${client.messages.failedToLoad + failed}`;
-  }
-  lmsg.edit(message);
-}
-
-async function searchAlbum(data, client, msg, voiceChannel) {
-  const lmsg = await msg.channel.send(client.messages.loadingSongs);
-  let failed = 0;
-  for (let i = 0; data.body.items.length > i; i++) {
-    const track = await data.body.items[i];
-    await client.funcs.sleep(250);
-    ytsr(
-      `${track.artists[0].name} ${track.name} audio`, {
-        limit: 5,
-      },
-      async function (err, res) {
-        if (err) return console.log(err);
-        if (!res.items[0]) {
-          ytsr(
-            `${track.artists[0].name} ${track.name} lyrics`, {
-              limit: 5,
-            },
-            async function (err, res) {
-              if (err) return console.log(err);
-              if (!res.items[0]) {
-                ytsr(
-                  `${track.artists[0].name} ${track.name}`, {
-                    limit: 5,
-                  },
-                  async function (err, res) {
-                    if (err) console.log(err);
-                    if (!res.items[0]) {
-                      failed++;
-                    }
-                    const videoResults = res.items.filter(
-                      (item) => item.type === "video"
-                    );
-                    client.funcs.handleVideo(
-                      videoResults[0].link,
-                      msg,
-                      voiceChannel,
-                      client,
-                      false,
-                      "spotify",
-                      track
-                    );
-                  }
-                );
-                return;
-              }
-              const videoResults = res.items.filter(
-                (item) => item.type === "video"
-              );
-              await client.funcs.handleVideo(
-                videoResults[0].link,
-                msg,
-                voiceChannel,
-                client,
-                true,
-                "spotify",
-                track
-              );
-            }
-          );
-          failed++;
-          return;
-        }
-        const videoResults = res.items.filter((item) => item.type === "video");
-        await client.funcs.handleVideo(
-          videoResults[0].link,
-          msg,
-          voiceChannel,
-          client,
-          true,
-          "spotify",
-          track
-        );
-      }
-    );
-  }
-  let message;
-  if (failed === 0) {
-    message = client.messages.albumAdded.replace(
-      "%TITLE%",
-      "yes taht palylist"
-    );
-  } else {
-    message = `${client.messages.albumAdded.replace(
-      "%TITLE%",
-      "yes taht palylist"
-    )}\n${client.messages.failedToLoad + failed}`;
-  }
-  lmsg.edit(message);
-}
-
-async function searchSong(data, client, msg, voiceChannel) {
-  const lmsg = await msg.channel.send(client.messages.loadingSongs);
-  let failed = 0;
-  for (let i = 0; data.body.tracks.items.length > i; i++) {
-    const track = await data.body.tracks.items[i].track;
-    await client.funcs.sleep(250);
-    ytsr(
-      `${track.artists[0].name} ${track.name} audio`, {
-        limit: 5,
-      },
-      async function (err, res) {
-        if (err) return console.log(err);
-        if (!res.items[0]) {
-          ytsr(
-            `${track.artists[0].name} ${track.name} lyrics`, {
-              limit: 5,
-            },
-            async function (err, res) {
-              if (err) return console.log(err);
-              if (!res.items[0]) {
-                ytsr(
-                  `${track.artists[0].name} ${track.name}`, {
-                    limit: 5,
-                  },
-                  async function (err, res) {
-                    if (err) console.log(err);
-                    if (!res.items[0]) {
-                      failed++;
-                    }
-                    const videoResults = res.items.filter(
-                      (item) => item.type === "video"
-                    );
-                    client.funcs.handleVideo(
-                      videoResults[0].link,
-                      msg,
-                      voiceChannel,
-                      client,
-                      false,
-                      "spotify",
-                      track
-                    );
-                  }
-                );
-                return;
-              }
-              const videoResults = res.items.filter(
-                (item) => item.type === "video"
-              );
-              await client.funcs.handleVideo(
-                videoResults[0].link,
-                msg,
-                voiceChannel,
-                client,
-                true,
-                "spotify",
-                track
-              );
-            }
-          );
-          failed++;
-          return;
-        }
-        const videoResults = res.items.filter((item) => item.type === "video");
-        await client.funcs.handleVideo(
-          videoResults[0].link,
-          msg,
-          voiceChannel,
-          client,
-          true,
-          "spotify",
-          track
-        );
-      }
-    );
-  }
-  let message;
-  if (failed === 0) {
-    message = client.messages.playlistAdded.replace("%TITLE%", data.body.name);
-  } else {
-    message = `${client.messages.playlistAdded.replace(
-      "%TITLE%",
-      data.body.name
-    )}\n${client.messages.failedToLoad + failed}`;
-  }
-  lmsg.edit(message);
-}

src/commands/previous.js

@@ -1,17 +0,0 @@
-module.exports = {
-    name: 'previous',
-    alias: ["prev", "return", "back"],
-    usage: '',
-    description: 'Play the previous song.',
-    permission: 'MANAGE_MESSAGES',
-    category: 'music control',
-    async execute(msg, args, client, command) {
-        const queue = client.queue.get(msg.guild.id)
-        if (client.funcs.check(client, msg, command)) {
-            if (queue.prevSongs.length < 1) return msg.channel.send(client.messages.noPreviousSongs);
-            queue.endReason = "previous";
-            queue.connection.dispatcher.end()
-            msg.channel.send(client.messages.previousSong)
-        }
-    }
-};

src/commands/queue.js

@@ -1,29 +0,0 @@
-const { EmbedBuilder } = require("discord.js");
-
-module.exports = {
-	name: 'queue',
-	alias: ["q", "list", "ls", "songs"],
-	usage: '',
-	description: 'See the queue.',
-	permission: 'none',
-	category: 'info',
-	async execute(msg, args, client, command) {
-		const queue = client.queue.get(msg.guild.id);
-		if (!queue) return msg.channel.send(client.messages.noServerQueue);
-		const page = 1;
-		let queuesongs = queue.songs.slice((page - 1) * 20 + 1, page * 20 + 1);
-		let queuemessage = `${queuesongs.map(song => `**#** ${song.title}`).join('\n')}`
-		const hashs = queuemessage.split('**#**').length;
-		for (let i = 0; i < hashs; i++) {
-			queuemessage = queuemessage.replace('**#**', `**${i + 1}**`);
-		}
-		let message;
-		message = client.messages.queueDesc.replace("%SONG%", queue.songs[0].title);
-		const embed = new EmbedBuilder()
-			.setTitle(client.messages.queueTitle)
-			.setDescription(`${message}\n${queuemessage}`)
-			.setFooter({ text: `${queue.songs.length - 1} ${client.messages.queueFooter}`})
-			.setColor(client.config.embedColor)
-		return msg.channel.send(embed);
-	}
-};

src/commands/remove.js

@@ -1,31 +0,0 @@
-module.exports = {
-  name: "remove",
-  alias: ["rm", "delete", "del"],
-  usage: "<song pos>",
-  description: "Remove a song from the queue",
-  permission: "MANAGE_MESSAGES",
-  category: "music control",
-  execute(msg, args, client, command) {
-    const queue = client.queue.get(msg.guild.id);
-    if (client.funcs.check(client, msg, command)) {
-      if (!args[1]) return msg.channel.send(client.messages.provideASong);
-      const pos = parseInt(args[1]);
-      if (isNaN(pos)) return msg.channel.send(client.messages.validNumber);
-      if (pos < 1) return msg.channel.send(client.messages.noSongs);
-      let message1;
-      let message2;
-      message1 = client.messages.queueLength.replace(
-        "%SONGS%",
-        queue.songs.length - 1
-      );
-      if (pos < 0) return msg.channel.send(client.messages.noSongsInQueue);
-      if (pos >= queue.songs.length) return msg.channel.send(message1);
-      message2 = client.messages.removed.replace(
-        "%SONG%",
-        queue.songs[pos].title
-      );
-      msg.channel.send(message2);
-      return queue.songs.splice(pos, 1);
-    }
-  },
-};

src/commands/replay.js

@@ -1,15 +0,0 @@
-module.exports = {
-    name: 'replay',
-    alias: ["rp"],
-    usage: '',
-    description: 'Replay the currently playing song.',
-    permission: 'MANAGE_MESSAGES',
-    category: 'play',
-    async execute(msg, args, client, command) {
-        const queue = client.queue.get(msg.guild.id);
-        if (client.funcs.check(client, msg, command)) {
-            queue.endReason = "replay";
-            queue.connection.dispatcher.end()
-        }
-    }
-};

src/commands/resume.js

@@ -1,17 +0,0 @@
-module.exports = {
-	name: 'resume',
-	alias: ["continue"],
-	usage: '',
-	description: 'Resume the paused music.',
-	permission: 'MANAGE_MESSAGES',
-	category: 'music control',
-	execute(msg, args, client, command) {
-		const queue = client.queue.get(msg.guild.id);
-		if (client.funcs.check(client, msg, command)) {
-			if (!queue.paused) return msg.channel.send(client.messages.notPaused);
-			queue.paused = false;
-			queue.connection.dispatcher.resume();
-			return msg.channel.send(client.messages.resumed);
-		}
-	}
-};

src/commands/search.js

@@ -1,61 +0,0 @@
-const ytsr = require('ytsr');
-const he = require('he');
-const { EmbedBuilder } = require('discord.js');
-
-module.exports = {
-    name: 'search',
-    alias: ["sr", "find"],
-    usage: '<search word(s)>',
-    description: 'Search the top 10 queryes and choose one.',
-    permission: 'none',
-    category: 'play',
-    async execute(msg, args, client, command) {
-        const searchString = args.slice(1).join(" ");
-        const queue = client.queue.get(msg.guild.id);
-        const voiceChannel = msg.member.voice.channel;
-        if (!queue) {
-            if (!msg.member.voice.channel) return msg.channel.send(client.messages.noVoiceChannel);
-        } else {
-            if (voiceChannel !== queue.voiceChannel) return msg.channel.send(client.messages.wrongVoiceChannel);
-        }
-        if (!args[1]) return msg.channel.send(client.messages.noQuery);
-        if (voiceChannel.full) return msg.channel.send(client.messages.channelFull);
-        if (!voiceChannel.joinable) return msg.channel.send(client.messages.noPermsConnect);
-        if (!voiceChannel.speakable) return msg.channel.send(client.messages.noPermsSpeak);
-        ytsr(searchString, {
-            limit: 20,
-        }, async function (err, res) {
-            if (err) return console.log(err);
-            if (!res.items[0]) return msg.channel.send(client.messages.noResults);
-            const videoResults = res.items.filter(item => item.type === "video");
-            const videos = videoResults.slice(0, 10);
-            let index = 0;
-            const embed = new EmbedBuilder()
-                .setTitle(client.messages.songSelection)
-                .setDescription(`${videos.map(video2 => `**${++index}** ${he.decode(video2.title)} `).join('\n')}`)
-                .setFooter({ text: client.messages.provideANumber })
-                .setColor(client.config.embedColor)
-            msg.channel.send(embed);
-            try {
-                var response = await msg.channel.awaitMessages(message2 => message2.content > 0 && message2.content < 11 && message2.author === msg.author, {
-                    max: 1,
-                    time: 10000,
-                    errors: ['time']
-                });
-            } catch (err) {
-                console.error(err);
-                return msg.channel.send(client.messages.cancellingVideoSelection);
-            }
-            const videoIndex = parseInt(response.first().content) - 1;
-            client.spotify.searchTracks(`track:${videos[videoIndex].title}`)
-                .then(function (data) {
-                    client.funcs.handleVideo(
-                        videos[videoIndex].link, msg, voiceChannel, client, false, "ytdl",
-                        data.body.tracks.items[0]
-                    );
-                }, function (err) {
-                    console.log('Something went wrong!', err);
-                });
-        })
-    }
-};

src/commands/seek.js

@@ -1,36 +0,0 @@
-module.exports = {
-  name: "seek",
-  alias: ["none"],
-  usage: "<point in song (seconds)>",
-  description: "Seek to a specific point in the currently playing song.",
-  permission: "MANAGE_MESSAGES",
-  category: "music control",
-  async execute(msg, args, client, command) {
-    const queue = client.queue.get(msg.guild.id);
-    if (client.funcs.check(client, msg, command)) {
-      if (queue.nightCore)
-        return msg.channel.send(client.messages.disableNightCore);
-      if (!args[1])
-        return msg.channel.send(
-          `${client.messages.correctUsage}\`${
-            client.global.db.guilds[msg.guild.id].prefix
-          }seek ${command.usage}\``
-        );
-      const pos = parseInt(args[1]);
-      if (isNaN(pos)) return msg.channel.send(client.messages.validNumber);
-      if (pos < 0)
-        return msg.channel.send(client.messages.seekingPointPositive);
-      const totalLength = parseInt(queue.songs[0].info.lengthSeconds);
-      let message;
-      if (pos > totalLength) {
-        message = client.messages.seekMax.replace(
-          "%LENGTH%",
-          queue.songs[0].info.lengthSeconds
-        );
-        return msg.channel.send(message);
-      }
-
-      client.funcs.end(client, msg, pos, command);
-    }
-  },
-};

src/commands/settings.js

@@ -1,55 +0,0 @@
-const { EmbedBuilder } = require("discord.js");
-
-module.exports = {
-  name: "settings",
-  alias: ["options", "ops", "preferences"],
-  usage: "<setting> <value(opt)>",
-  description: "Change the server settings for Musix.",
-  permission: "MANAGE_GUILD",
-  category: "util",
-  async execute(msg, args, client, command) {
-    let footer;
-    footer = client.messages.settingsFooter.replace(
-      "%PREFIX%",
-      client.global.db.guilds[msg.guild.id].prefix
-    );
-    const embed = new EmbedBuilder()
-      .setTitle(client.messages.settingsTitle)
-      .addFields(
-        { name: client.messages.settingsPrefix, value: client.messages.settingsPrefixDesc, inline: true },
-        { name: client.messages.settingsVolume, value: client.messages.settingsVolumeDesc, inline: true },
-        { name: client.messages.settingsBlacklist, value: client.messages.settingsBlacklistDesc, inline: true },
-        { name: client.messages.settingsPermissions, value: client.messages.settingsPermissionsDesc, inline: true },
-        { name: client.messages.settingsSetDj, value: client.messages.settingsSetDjDesc, inline: true },
-        { name: client.messages.settingsAnnounceSongs, value: client.messages.settingsAnnounceSongsDesc },
-        { name: client.messages.settingsBass, value: client.messages.settingsBassDesc, inline: true },
-        { name: client.messages.settingsAutoPlay, value: client.messages.settingsAutoPlayDesc, inline: true }
-      )
-      .setFooter({ text: footer })
-      .setAuthor({ name: client.user.username, iconURL: client.user.avatarURL() })
-      .setColor(client.config.embedColor);
-    const permissions = msg.channel.permissionsFor(msg.author);
-    if (msg.author.id !== client.config.devId) {
-      if (!permissions.has(command.permission))
-        return msg.channel.send(client.messages.noPermsManageSettings);
-    }
-    if (args[1]) {
-      const optionName = args[1].toLowerCase();
-      const option =
-        client.settingCmd.get(optionName) ||
-        client.settingCmd.find(
-          (cmd) => cmd.aliases && cmd.aliases.includes(optionName)
-        );
-      if (!option) return msg.channel.send(embed);
-      try {
-        option.execute(msg, args, client);
-      } catch (error) {
-        msg.reply(client.messages.errorExeOpt);
-        console.log(error.toString());
-        console.log(error.stack.replace(/at /g, "**at **"));
-      }
-    } else {
-      return msg.channel.send(embed);
-    }
-  },
-};

src/commands/settings/announcesongs.js

@@ -1,17 +0,0 @@
-module.exports = {
-    name: 'announcesongs',
-    async execute(msg, args, client) {
-        if (!args[2]) return msg.channel.send(`${client.messages.announceSongs} \`${client.global.db.guilds[msg.guild.id].announceSongs}\``);
-        if (args[2] === 'true') {
-            if (!client.global.db.guilds[msg.guild.id].announceSongs) {
-                client.global.db.guilds[msg.guild.id].announceSongs = true;
-                msg.channel.send(client.messages.announceSongsTrue);
-            } else return msg.channel.send(client.messages.announceSongsTrue);
-        } else if (args[2] === 'false') {
-            if (client.global.db.guilds[msg.guild.id].announceSongs) {
-                client.global.db.guilds[msg.guild.id].announceSongs = false;
-                msg.channel.send(client.messages.announceSongsFalse);
-            } else return msg.channel.send(client.messages.announceSongsFalse);
-        } else return msg.channel.send(client.messages.boolean);
-    }
-};

src/commands/settings/autoPlay.js

@@ -1,17 +0,0 @@
-module.exports = {
-    name: 'autoplay',
-    async execute(msg, args, client) {
-        if (!args[2]) return msg.channel.send(`${client.messages.autoPlay} \`${client.global.db.guilds[msg.guild.id].autoPlay}\``);
-        if (args[2] === 'true') {
-            if (!client.global.db.guilds[msg.guild.id].autoPlay) {
-                client.global.db.guilds[msg.guild.id].autoPlay = true;
-                msg.channel.send(client.messages.autoPlayTrue);
-            } else return msg.channel.send(client.messages.autoPlayTrue);
-        } else if (args[2] === 'false') {
-            if (client.global.db.guilds[msg.guild.id].autoPlay) {
-                client.global.db.guilds[msg.guild.id].autoPlay = false;
-                msg.channel.send(client.messages.autoPlayFalse);
-            } else return msg.channel.send(client.messages.autoPlayFalse);
-        } else return msg.channel.send(client.messages.boolean);
-    }
-};

src/commands/settings/bass.js

@@ -1,14 +0,0 @@
-module.exports = {
-    name: 'bass',
-    async execute(msg, args, client) {
-        if (!args[2]) return msg.channel.send(client.messages.currentDefaultBass + client.global.db.guilds[msg.guild.id].bass);
-        if (args[2] === "false") {
-            client.global.db.guilds[msg.guild.id].bass = false;
-            return msg.channel.send(client.messages.bassFalse);
-        }
-        const level = parseInt(args[2]);
-        if (isNaN(level)) return msg.channel.send(client.messages.validNumber);
-        client.global.db.guilds[msg.guild.id].bass = level;
-        msg.channel.send(`${client.messages.bassLevel} ${level}!`);
-    }
-};

src/commands/settings/blacklist.js

@@ -1,115 +0,0 @@
-const { EmbedBuilder } = require("discord.js");
-
-module.exports = {
-  name: "blacklist",
-  async execute(msg, args, client) {
-    let embed;
-    switch (args[2]) {
-      case "add":
-        if (msg.mentions.channels.first()) {
-          if (
-            client.global.db.guilds[msg.guild.id].blacklist.includes(
-              msg.mentions.channels.first().id
-            )
-          )
-            return msg.channel.send(client.messages.channelAlreadyBlackListed);
-        } else if (
-          client.global.db.guilds[msg.guild.id].blacklist.includes(args[3])
-        )
-          return msg.channel.send(client.messages.channelAlreadyBlackListed);
-        if (
-          !msg.guild.channels.cache.get(args[3]) &&
-          !msg.mentions.channels.first()
-        )
-          return msg.channel.send(client.messages.idOrMentionChannel);
-        if (msg.mentions.channels.first()) {
-          client.global.db.guilds[msg.guild.id].blacklist.push(
-            msg.mentions.channels.first().id
-          );
-          let message;
-          message = client.messages.channelAdded.replace(
-            "%CHANNEL%",
-            msg.mentions.channels.first().name
-          );
-          msg.channel.send(message);
-        } else {
-          client.global.db.guilds[msg.guild.id].blacklist.push(args[3]);
-          let message;
-          message = client.messages.channelAdded.replace(
-            "%CHANNEL%",
-            msg.guild.channels.cache.get(args[3]).name
-          );
-          msg.channel.send(message);
-        }
-        break;
-      case "remove":
-        if (msg.mentions.channels.first()) {
-          if (
-            !client.global.db.guilds[msg.guild.id].blacklist.includes(
-              msg.mentions.channels.first().id
-            )
-          )
-            return msg.channel.send(client.messages.channelNotBlackListed);
-          if (
-            client.global.db.guilds[msg.guild.id].blacklist.indexOf(
-              msg.mentions.channels.first().id
-            ) !== -1
-          ) {
-            client.global.db.guilds[msg.guild.id].blacklist.splice(
-              client.global.db.guilds[msg.guild.id].blacklist.indexOf(
-                msg.mentions.channels.first().id
-              ),
-              1
-            );
-            let message;
-            message = client.messages.channelRemoved.replace(
-              "%CHANNEL%",
-              msg.mentions.channels.first().name
-            );
-            msg.channel.send(message);
-          }
-        } else {
-          if (!client.global.db.guilds[msg.guild.id].blacklist.includes(args[3]))
-            return msg.channel.send(client.messages.channelNotBlackListed);
-          if (
-            client.global.db.guilds[msg.guild.id].blacklist.indexOf(args[3]) !==
-            -1
-          ) {
-            client.global.db.guilds[msg.guild.id].blacklist.splice(
-              client.global.db.guilds[msg.guild.id].blacklist.indexOf(args[3]),
-              1
-            );
-            let message;
-            message = client.messages.channelRemoved.replace(
-              "%CHANNEL%",
-              msg.guild.channels.cache.get(args[3]).name
-            );
-            msg.channel.send(message);
-          }
-        }
-        break;
-      case "list":
-        embed = new EmbedBuilder()
-          .setTitle(client.messages.blacklistTitle)
-          .setDescription(
-            `${client.global.db.guilds[msg.guild.id].blacklist
-            .map((c) => `**-** <#${c}>`)
-            .join("\n")}`
-          )
-          .setColor(client.config.embedColor);
-        msg.channel.send(embed);
-        break;
-      case undefined:
-        embed = new EmbedBuilder()
-          .setTitle(client.messages.blacklistTitle)
-          .addFields(
-            { name: "add", value: "Add a channel to the blacklist. (ID or mention)" },
-            { name: "remove", value: "Remove a channel from the blacklist. (ID or mention)" },
-            { name: "list", value: "List the currently blacklisted channels." }
-          )
-          .setColor(client.config.embedColor);
-        msg.channel.send(embed);
-        break;
-    }
-  },
-};

src/commands/settings/permissions.js

@@ -1,17 +0,0 @@
-module.exports = {
-    name: 'permissions',
-    async execute(msg, args, client) {
-        if (!args[2]) return msg.channel.send(`${client.messages.permission} \`${client.global.db.guilds[msg.guild.id].permissions}\``);
-        if (args[2] === 'true') {
-            if (!client.global.db.guilds[msg.guild.id].permissions) {
-                client.global.db.guilds[msg.guild.id].permissions = true;
-                msg.channel.send(client.messages.permissionsSetTrue);
-            } else return msg.channel.send(client.messages.permissionsTrue);
-        } else if (args[2] === 'false') {
-            if (client.global.db.guilds[msg.guild.id].permissions) {
-                client.global.db.guilds[msg.guild.id].permissions = false;
-                msg.channel.send(client.messages.permissionsSetFalse);
-            } else return msg.channel.send(client.messages.permissionsFalse);
-        } else return msg.channel.send(client.messages.boolean);
-    }
-};

src/commands/settings/prefix.js

@@ -1,9 +0,0 @@
-module.exports = {
-    name: 'prefix',
-    async execute(msg, args, client) {
-        if (!args[2]) return msg.channel.send(`${client.messages.currentPrefix} \`${client.global.db.guilds[msg.guild.id].prefix}\``);
-        if (args[2].length > 5) return msg.channel.send(client.messages.prefixMaxLength);
-        client.global.db.guilds[msg.guild.id].prefix = args[2];
-        msg.channel.send(`${client.messages.prefixSet} \`${args[2]}\``);
-    }
-};

src/commands/settings/premium.js

@@ -1,27 +0,0 @@
-module.exports = {
-  name: "premium",
-  async execute(msg, args, client) {
-    if (!args[2])
-      return msg.channel.send(
-        client.messages.premiumState +
-          client.global.db.guilds[msg.guild.id].premium
-      );
-    if (client.global.db.guilds[args[2]].premium === false) {
-      client.global.db.guilds[args[2]].premium = true;
-      let message;
-      message = client.messages.nowPremium.replace(
-        "%GUILD%",
-        client.guilds.cache.get(args[2]).name
-      );
-      msg.channel.send(message);
-    } else if (client.global.db.guilds[args[2]].premium === true) {
-      client.global.db.guilds[args[2]].premium = false;
-      let message;
-      message = client.messages.noMorePremium.replace(
-        "%GUILD%",
-        client.guilds.cache.get(args[2]).name
-      );
-      msg.channel.send(message);
-    }
-  },
-};

src/commands/settings/reset.js

@@ -1,18 +0,0 @@
-module.exports = {
-    name: 'reset',
-    async execute(msg, args, client) {
-        client.global.db.guilds[msg.guild.id] = {
-            prefix: client.config.prefix,
-            defaultVolume: client.config.defaultVolume,
-            permissions: client.config.permissions,
-            dj: client.config.dj,
-            djrole: client.config.djrole,
-            startPlaying: client.config.startPlaying,
-            bass: client.config.bass,
-            blacklist: [],
-            premium: false,
-            autoPlay: client.config.autoPlay,
-        };
-        msg.channel.send(client.messages.reset);
-    }
-};

src/commands/settings/setDj.js

@@ -1,30 +0,0 @@
-module.exports = {
-    name: 'setdj',
-    async execute(msg, args, client) {
-        if (!client.global.db.guilds[msg.guild.id].dj) {
-            if (!client.global.db.guilds[msg.guild.id].permissions) {
-                client.global.db.guilds[msg.guild.id].permissions = true;
-            }
-            if (msg.guild.roles.cache.find(x => x.name === "DJ")) {
-                client.global.db.guilds[msg.guild.id].djrole = msg.guild.roles.cache.find(x => x.name === "DJ").id;
-                msg.channel.send(client.messages.djRoleFound);
-                client.global.db.guilds[msg.guild.id].dj = true;
-            } else {
-                const permissions = msg.channel.permissionsFor(msg.client.user);
-                if (!permissions.has('MANAGE_ROLES')) return msg.channel.send(client.messages.noPermsManageRoles);
-                msg.guild.createRole({
-                        name: 'DJ',
-                    })
-                    .then(role => client.global.db.guilds[msg.guild.id].djrole = role.id)
-                    .catch((error) => {
-                        console.log(error);
-                    })
-                client.global.db.guilds[msg.guild.id].dj = true;
-                msg.channel.send(client.messages.djRoleCreated);
-            }
-        } else {
-            client.global.db.guilds[msg.guild.id].dj = false;
-            msg.channel.send(client.messages.djFalse);
-        }
-    }
-};

src/commands/settings/volume.js

@@ -1,10 +0,0 @@
-module.exports = {
-    name: 'volume',
-    async execute(msg, args, client) {
-        if (!args[2]) return msg.channel.send(`${client.messages.currentDefaultVolume} \`${client.global.db.guilds[msg.guild.id].defaultVolume}\``);
-        if (isNaN(args[2])) return msg.channel.send(client.messages.defaultVolumeNumber);
-        if (args[2].length > 2) return msg.channel.send(client.messages.defaultVolumeMax);
-        client.global.db.guilds[msg.guild.id].defaultVolume = args[2];
-        msg.channel.send(`${client.messages.defaultVolumeSet} \`${args[2]}\``);
-    }
-};

src/commands/shuffle.js

@@ -1,15 +0,0 @@
-module.exports = {
-    name: 'shuffle',
-    alias: ["none"],
-    usage: '',
-    description: 'Shuffle the queue.',
-    permission: 'MANAGE_MESSAGES',
-    category: 'music control',
-    execute(msg, args, client, command) {
-        const queue = client.queue.get(msg.guild.id);
-        if (client.funcs.check(client, msg, command)) {
-            client.funcs.shuffle(queue.songs);
-            msg.channel.send(client.messages.shuffled);
-        }
-    }
-};

src/commands/skip.js

@@ -1,63 +0,0 @@
-module.exports = {
-  name: "skip",
-  alias: ["s", "next"],
-  usage: "",
-  description: "Skip the currently playing song.",
-  permission: "MANAGE_MESSAGES",
-  category: "music control",
-  execute(msg, args, client, command) {
-    const queue = client.queue.get(msg.guild.id);
-    const permissions = msg.channel.permissionsFor(msg.author);
-    if (!queue || !queue.playing)
-      return msg.channel.send(client.messages.noServerQueue);
-    if (msg.author.id !== client.config.devId) {
-      if (msg.member.voice.channel !== queue.voiceChannel)
-        return msg.channel.send(client.messages.wrongVoiceChannel);
-      if (client.global.db.guilds[msg.guild.id].permissions) {
-        if (
-          !msg.member.roles.cache.has(
-            client.global.db.guilds[msg.guild.id].djrole
-          ) ||
-          !permissions.has(command.permission)
-        ) {
-          return vote(queue, msg, client);
-        } else {
-          return skipSong(queue, msg, client);
-        }
-      } else {
-        return skipSong(queue, msg, client);
-      }
-    } else {
-      return skipSong(queue, msg, client);
-    }
-  },
-};
-
-function skipSong(queue, msg, client) {
-  msg.channel.send(client.messages.skipped);
-  queue.endReason = "skip";
-  queue.time = 0;
-  queue.connection.dispatcher.end();
-}
-
-function vote(queue, msg, client) {
-  queue.votesNeeded = Math.floor(queue.voiceChannel.members.size / 2);
-  queue.votesNeeded.toFixed();
-  if (queue.voiceChannel.members.size > 2) {
-    if (queue.voters.includes(msg.member.id))
-      return msg.channel.send(client.messages.alreadyVoted);
-    queue.votes++;
-    queue.voters.push(msg.member.id);
-    if (queue.votes >= queue.votesNeeded) {
-      queue.voters = [];
-      queue.votes = 0;
-      queue.votesNeeded = null;
-      return skipSong(queue, msg, client);
-    } else
-      return msg.channel.send(
-        `${client.messages.notEnoughVotes} ${queue.votes} / ${queue.votesNeeded}!`
-      );
-  } else {
-    return skipSong(queue, msg, client);
-  }
-}

src/commands/skipto.js

@@ -1,30 +0,0 @@
-module.exports = {
-  name: "skipto",
-  alias: ["st"],
-  usage: "<point in queue>",
-  description: "Skip to a point in the queue",
-  permission: "MANAGE_MESSAGES",
-  category: "music control",
-  async execute(msg, args, client, command) {
-    const queue = client.queue.get(msg.guild.id);
-    if (client.funcs.check(client, msg, command)) {
-      if (!args[1])
-        return msg.channel.send(
-          `${client.messages.correctUsage}\`${command.usage}\``
-        );
-      let point = parseInt(args[1]);
-      point = point - 1;
-      if (isNaN(point)) return msg.channel.send(client.messages.validNumber);
-      if (point > queue.songs.length - 1)
-        return msg.channel.send(client.messages.noSongs);
-      if (point < 0) return msg.channel.send(client.messages.cantSkipToCurrent);
-      for (let i = 0; i < point; i++) {
-        queue.prevSongs.push(queue.songs.shift());
-      }
-      msg.channel.send(client.messages.skipped);
-      queue.endReason = "skipto";
-      queue.time = 0;
-      queue.connection.dispatcher.end();
-    }
-  },
-};

src/commands/status.js

@@ -1,29 +0,0 @@
-const { EmbedBuilder } = require("discord.js");
-
-module.exports = {
-    name: 'status',
-    alias: ["stats", "info"],
-    usage: '',
-    description: 'See the current status for Musix.',
-    permission: 'none',
-    category: 'info',
-    execute(msg, args, client, command) {
-        const uptime = client.funcs.msToTime(client.uptime, "dd:hh:mm:ss");
-        msg.channel.send(client.messages.pinging).then(m => {
-            const latency = m.createdTimestamp - msg.createdTimestamp;
-
-            const embed = new EmbedBuilder()
-                .setTitle(client.messages.statusTitle)
-                .addFields(
-                    { name: client.messages.statusField1, value: client.ws.ping, inline: true },
-                    { name: client.messages.statusField2, value: latency, inline: true },
-                    { name: client.messages.statusField3, value: uptime, inline: true },
-                    { name: client.messages.statusField4, value: client.shard.ids },
-                )
-                .setAuthor({ name: client.user.username, iconURL: client.user.avatarURL() })
-                .setColor(client.config.embedColor)
-            m.delete();
-            return msg.channel.send(embed);
-        });
-    }
-};

src/commands/stop.js

@@ -1,30 +0,0 @@
-module.exports = {
-	name: 'stop',
-	description: 'Stop the music and clear the queue.',
-	alias: ["none"],
-	usage: '',
-	permission: 'MANAGE_CHANNELS',
-	category: 'music control',
-	execute(msg, args, client, command) {
-		const queue = client.queue.get(msg.guild.id);
-		if (client.funcs.check(client, msg, command)) {
-			if (msg.content.includes("-force")) {
-				if (queue) {
-					queue.voiceChannel.leave();
-					queue.exists = false;
-				}
-				if (msg.guild.voice.channel) msg.guild.voice.channel.leave();
-				client.queue.delete(msg.guild.id);
-				return msg.channel.send(client.messages.stop);
-			}
-			if (!queue || !queue.playing) {
-				return msg.channel.send(client.messages.noServerQueue);
-			}
-			queue.songs = [];
-			queue.looping = false;
-			queue.endReason = "stop";
-			queue.connection.dispatcher.end();
-			msg.channel.send(client.messages.stop);
-		}
-	}
-};

src/commands/volume.js

@@ -1,22 +0,0 @@
-module.exports = {
-	name: 'volume',
-	description: 'Volume command.',
-	alias: ["none"],
-	usage: '<volume>',
-	cooldown: 5,
-	permission: 'MANAGE_MESSAGES',
-	category: 'music control',
-	execute(msg, args, client, command) {
-		const queue = client.queue.get(msg.guild.id);
-		if (!args[1] && queue) return msg.channel.send(`${client.messages.currentVolume}**${queue.volume}**`);
-		const volume = parseFloat(args[1]);
-		if (client.funcs.check(client, msg, command)) {
-			if (isNaN(volume)) return msg.channel.send(client.messages.validNumber);
-			if (volume > 100) return msg.channel.send(client.messages.maxVolume);
-			if (volume < 0) return msg.channel.send(client.messages.positiveVolume);
-			queue.volume = volume;
-			queue.connection.dispatcher.setVolume(volume / 100);
-			return msg.channel.send(`${client.messages.setVolume}**${volume}**`);
-		}
-	}
-};

src/config/config.js

@@ -1,99 +0,0 @@
-require("dotenv/config");
-
-module.exports = {
-  discord_api_token: process.env.DISCORD_API_TOKEN,
-  bodKey: process.env.BODKEY,
-  youtube_api_key: process.env.YOUTUBE_API_KEY,
-  genius_api_key: process.env.GENIUS_API_KEY,
-  soundcloud_api_key: process.env.SOUNDCLOUD_API_KEY,
-  spotify_access_key: process.env.SPOTIFY_ACCESS_KEY,
-  spotify_client_secret: process.env.SPOTIFY_CLIENT_SECRET,
-  spotify_client_id: process.env.SPOTIFY_CLIENT_ID,
-  spotify_refresh_token: process.env.SPOTIFY_REFRESH_TOKEN,
-  lastfm_api_key: process.env.LASTFM_API_KEY,
-  lastfm_secret: process.env.LASTFM_SECRET,
-  port: 8888,
-  redirectUri: "http://localhost:8888/callback/",
-  testServer: "489111553321336832",
-  primary_test_channel: "617633098296721409",
-  secondary_test_channel: "570531724002328577",
-  devId: "360363051792203779",
-  embedColor: "#b50002",
-  invite: "https://musix-web.herokuapp.com/releases",
-  supportServer: "https://musix-web.herokuapp.com/discord",
-  devMode: false,
-  api: false,
-  saveDB: true,
-  respawn: true,
-  shards: 10,
-  shardDelay: 10000,
-  spawnTimeout: 60000,
-  respawnDelay: 1000,
-  prefix: ">",
-  devPrefix: "-",
-  defaultVolume: 50,
-  permissions: false,
-  dj: false,
-  djrole: null,
-  startPlaying: true,
-  bass: 1,
-  autoPlay: false,
-};
-
-module.exports.streamConfig = {
-  ytdlOptions: {
-    filter: "audio",
-    highWaterMark: 1 << 25,
-    volume: false,
-    requestOptions: {
-      maxRedirects: 4,
-    },
-  },
-  options: {
-    seek: null,
-    bitrate: 1024,
-    volume: 1,
-    type: "converted",
-  },
-};
-
-module.exports.queueConfig = {
-  textChannel: null,
-  voiceChannel: null,
-  connection: null,
-  songs: [],
-  volume: null,
-  bass: null,
-  nightCore: false,
-  playing: false,
-  paused: false,
-  looping: false,
-  songLooping: false,
-  votes: 0,
-  voters: [],
-  votesNeeded: null,
-  time: 0,
-  endReason: null,
-};
-
-module.exports.emojis = {
-  garbage: "🗑️ ",
-  green_check_mark: "<:green_check_mark:674265384777416705> ",
-  loading: "<a:loading:674284196700618783> ",
-  loudSound: ":loud_sound: ",
-  megaPhone: "📣 ",
-  notes: "<a:aNotes:674602408105476106>",
-  pause: "<:pause:674685548610322462> ",
-  previous: "<:reverse:705012312142119012> ",
-  redx: "<:redx:674263474704220182> ",
-  repeat: "<:repeat1:674685561377914892> ",
-  repeatSong: "<:repeatsong:674685573419761716> ",
-  resume: "<:resume:674685585478254603> ",
-  shuffle: "<:shuffle:674685595980791871> ",
-  signal: ":signal_strength: ",
-  skip: "<:skip:674685614221688832> ",
-  speaker: ":speaker: ",
-  stop: "<:stop:674685626108477519> ",
-  stopWatch: ":stopwatch: ",
-  volumeHigh: "<:volumehigh:674685637626167307> ",
-};

src/config/messages.js

@@ -1,197 +0,0 @@
-const {
-  emojis
-} = require("./config.js");
-
-module.exports = {
-  emojis: emojis,
-  albumAdded: emojis.green_check_mark +
-    "Album has been added to the queue!",
-  alreadyPaused: emojis.redx + "The music is already paused!",
-  alreadyVoted: emojis.redx + "You have already voted to skip!",
-  announceSongs: emojis.megaPhone + "Current setting:",
-  announceSongsFalse: emojis.green_check_mark + "announcesongs now set to `false`!",
-  announceSongsTrue: emojis.green_check_mark + "announcesongs now set to `true`!",
-  autoPlay: "Current setting:",
-  autoPlayFalse: emojis.green_check_mark + "autoplay now set to `false`!",
-  autoPlayTrue: emojis.green_check_mark + "autoplay now set to `true`!",
-  bassApplied: emojis.volumeHigh + "The bass level **%BASS%** has been applied!",
-  bassFalse: emojis.green_check_mark + "Bass is now false!",
-  bassLevel: emojis.green_check_mark + "Bass level is now",
-  blacklistTitle: "Currently blacklisted channels:",
-  blackListedVC: emojis.redx +
-    "Your voiceChannel is blacklisted! Please choose another channel!",
-  boolean: emojis.redx + "Please define a boolean! (true/false)",
-  cancellingVideoSelection: emojis.redx + "Cancelling video selection",
-  cantSkipToCurrent: emojis.redx + "You can't skip to the song currently playing!",
-  channelAdded: emojis.green_check_mark + "Channel %CHANNEL% added to the blacklist!",
-  channelAlreadyBlackListed: emojis.redx + "That channel is already blacklisted!",
-  channelFull: emojis.redx + "Your voice channel is full!",
-  channelNotBlackListed: emojis.redx + "That channel is not blacklisted or does not exist!",
-  channelRemoved: emojis.green_check_mark +
-    "Channel %CHANNEL% has been removed from the blacklist!",
-  cmdUsesFooter: "These statistics are from the current uptime.",
-  cmdUsesTitle: "Musix Command Usage During Current Uptime",
-  correctUsage: emojis.redx + "correct usage: ",
-  currentBass: emojis.loudSound + "The current bass is: ",
-  currentDefaultBass: emojis.speaker + "Currect default bass level: ",
-  currentDefaultVolume: emojis.speaker + "Current default volume is:",
-  currentNightCore: emojis.speaker + "Currect Nightcore setting: ",
-  currentPrefix: "Current prefix:",
-  currentVolume: emojis.loudSound + "The current volume is: ",
-  dbSaved: emojis.green_check_mark + "DB Saved!",
-  defaultVolumeMax: emojis.redx +
-    "The default volume must be below `100` for quality and safety resons.",
-  defaultVolumeNumber: emojis.redx +
-    "I'm sorry, But the default volume needs to be a valid __number__.",
-  defaultVolumeSet: emojis.green_check_mark + "Default volume set to:",
-  devMode: emojis.redx +
-    "Dev mode has been turned on! Commands are only available to developer(s)!",
-  disabledSpotifySongs: emojis.redx + "Spotify songs cannot be played currently!",
-  disableNightCore: emojis.redx + "Please disable nightCore in order to use this command!",
-  dispatcherError: "Error with the dispatcher: ",
-  djFalse: emojis.green_check_mark + "`DJ` now set to `false`",
-  djRoleCreated: emojis.green_check_mark +
-    "I did not find a role `DJ` so i have created one for you!",
-  djRoleFound: emojis.green_check_mark +
-    "I found a `DJ` role from this guild! This role is now the DJ role.",
-  error: emojis.redx + "An error occured!.\nError: ",
-  errorConnecting: "Error with connecting to voice channel: ",
-  errorDetected: "Error detected: ",
-  errorDispatcher: emojis.redx +
-    "An error has occured while playing music! The queue has been deleted.\nError: ",
-  errorExe: emojis.redx + "there was an error trying to execute that command!",
-  errorExeOpt: emojis.redx + "there was an error trying to execute that option!",
-  evalTitle: "Evaluation Command",
-  failedToLoad: emojis.redx + "Songs failed to load: ",
-  helpCmdFooter: "Command Alias:",
-  helpFooter: '"%PREFIX%help <command>" to see more information about a command.',
-  helpTitle: "help",
-  idOrMentionChannel: emojis.redx + "Please provide a channel id or mention a channel!",
-  invalidGuild: emojis.redx + "Invalid guild id!",
-  invalidSpotifyUrl: emojis.redx + "That url cannot be played! If you believe this is a mistake please contact support!",
-  inviteTitle: "Invite a release of Musix to your discord server!",
-  joined: emojis.green_check_mark + "Joined",
-  joinSupport: "Join the musix support server: ",
-  keySet: emojis.green_check_mark + "Key set!",
-  leftAlone: "I have left the channel as i was left alone.",
-  loadingSongs: emojis.loading + "Loading song(s)",
-  looping: emojis.repeat + "Looping the queue now!",
-  loopingSong: emojis.repeatSong + "Looping **%TITLE%** now!",
-  lyricsTitle: "Lyrics",
-  lyricsUsage: emojis.redx + "Provide a song to search for!",
-  maxBass: emojis.redx + "The max bass is `10`!",
-  maxVolume: emojis.redx + "The max volume is `100`!",
-  mentionChannel: emojis.redx + "Please mention a channel!",
-  musicCommandsDisabled: emojis.redx +
-    "This channels has been blacklisted! Music commands cannot be used here!",
-  nightCoreApplied: emojis.green_check_mark +
-    "NightCore is now **%BOOLEAN%** this will be applied when the next song starts playing!",
-  noDj: emojis.redx + "You need the `DJ` role to use this command!",
-  noLooping: emojis.repeat + "No longer looping the queue!",
-  noLoopingSong: emojis.repeatSong + "No longer looping the song!",
-  noMorePremium: ":cry: Guild %GUILD% is no longer premium!",
-  noPerms: emojis.redx + `You need the %PERMS% permission to use this command!`,
-  noPermsConnect: emojis.redx +
-    "I cannot connect to your voice channel, make sure I have the proper permissions!",
-  noPermsEmbed: emojis.redx +
-    "I cannot send embeds (Embed links), make sure I have the proper permissions!",
-  noPermsManageRoles: emojis.redx +
-    "I cannot create roles (Manage roles), make sure I have the proper permissions! I will need this permission to create a `DJ` role since i did not find one!",
-  noPermsManageSettings: emojis.redx +
-    "You need the `MANAGE_SERVER` permission to change the settings!",
-  noPermsSpeak: emojis.redx +
-    "I cannot speak in your voice channel, make sure I have the proper permissions!",
-  noPermsUseExternalEmojis: emojis.redx +
-    "I cannot use external emojis, make sure I have the proper permissions!",
-  noPreviousSongs: emojis.redx + "No previous songs!",
-  noQuery: emojis.redx + "you need to use a link or search for a song!",
-  noResults: emojis.redx + "I could not obtain any search results!",
-  noResultsLyrics: emojis.redx + "I could not obtain any results!",
-  noResultsSpotify: emojis.redx +
-    "I could not obtain any results!",
-  noServerQueue: emojis.redx + "There is nothing playing!",
-  noSimilarResults: emojis.redx + "No similar songs found!",
-  noSongs: emojis.redx + "That song does not exist!",
-  noSongsInQueue: emojis.redx + "There are no songs in the queue!",
-  notPremium: emojis.redx + "This is not a premium guild!",
-  nowPlayingDesc: emojis.notes + "**Now playing:**",
-  notAllowed: emojis.redx + "You are not allowed to do that!",
-  notEnoughVotes: emojis.redx + "Not enough votes!",
-  notPaused: emojis.redx + "The music in not paused!",
-  noVoiceChannel: emojis.redx +
-    "I'm sorry but you need to be in a voice channel to play music!",
-  nowPlaying: "__Now playing__",
-  nowPremium: ":tada: Guild %GUILD% is now premium!",
-  paused: emojis.pause + "Paused the music!",
-  permission: "🔒 Permission requirement:",
-  permissionsFalse: emojis.redx + "That value is already `false`!",
-  permissionsSetFalse: emojis.green_check_mark + "Permissions requirement now set to: `false`",
-  permissionsSetTrue: emojis.green_check_mark + "Permissions requirement now set to: `true`",
-  permissionsTrue: emojis.redx + "That value is already `true`!",
-  pinging: emojis.loading + "Pinging...",
-  playlistAdded: emojis.green_check_mark +
-    "Playlist: **%TITLE%** has been added to the queue!",
-  positiveBass: emojis.redx + "The bass needs to be a positive number!",
-  positiveVolume: emojis.redx + "The volume needs to be a positive number!",
-  prefixHere: "My prefix here is: ",
-  prefixMaxLength: "The prefix must be shorter or equal to 5 letters!",
-  prefixSet: emojis.green_check_mark + "New prefix set to:",
-  premiumState: "Premium status: ",
-  previousSong: emojis.previous + "Previous",
-  provideANumber: "Please provide a number ranging from 1-10 to select one of the search results.",
-  provideASong: emojis.redx + "Please provide a song position in queue for me to remove!",
-  queueDeleted: "Queue deleted!",
-  queueDesc: "**Now playing:** %SONG%<a:aNotes:674602408105476106>\n:arrow_down: Next in queue :arrow_down:",
-  queueFooter: "songs in the queue!",
-  queueLength: emojis.redx + "There are only %SONGS% song(s) in the queue!",
-  queueTitle: "__Song queue__",
-  quotaReached: emojis.redx +
-    "Quota reached please try again after midnight Pacific Time (PT)!",
-  reloaded: "All files reloaded!",
-  removed: emojis.garbage + "removed `%SONG%` from the queue!",
-  reset: emojis.green_check_mark + "Reset __all__ guild settings!",
-  restart: "restarting all shards...",
-  resumed: emojis.resume + "Resumed the music!",
-  searchSimilarUsage: emojis.redx + "Correct usage: %USAGE%",
-  seekingPointPositive: emojis.redx + "The seeking point needs to be a positive number!",
-  seekMax: emojis.redx +
-    "The lenght of this song is %LENGTH% seconds! You can't seek further than that!",
-  settingsAnnounceSongs: "announcesongs",
-  settingsAnnounceSongsDesc: "Whether to announce songs that start playing or not.",
-  settingsAutoPlay: "autoplay",
-  settingsAutoPlayDesc: "When the queue ends similar songs will be played.",
-  settingsBass: "bass",
-  settingsBassDesc: "Change the default bass level.",
-  settingsBlacklist: "blacklist",
-  settingsBlacklistDesc: "Blacklist channels that you wan't to block music commands to be executed on or block the bot from joining certain voiceChannels.",
-  settingsFooter: "how to use: %PREFIX%settings <Setting name> <value>",
-  settingsPermissions: "permissions",
-  settingsPermissionsDesc: "Change whether to require permissions to use eg `skip, stop, pause, loop, etc...`",
-  settingsPrefix: "prefix",
-  settingsPrefixDesc: "Change the guild specific prefix. (string)",
-  settingsSetDj: "setdj",
-  settingsSetDjDesc: "Set a DJ role. This will allow chosen users to freely use all Musix commands. This will automatically set the `permissions` settings to true in order for the `DJ` role to have effect!",
-  settingsTitle: "Guild settings for Musix",
-  settingsVolume: "volume",
-  settingsVolumeDesc: "Change the default volume that the bot will start playing at. (number)",
-  setVolume: emojis.volumeHigh + "I set the volume to: ",
-  shuffled: emojis.shuffle + "Queue suffled!",
-  skipped: emojis.skip + "Skipped the song!",
-  songAdded: emojis.green_check_mark + "**%TITLE%** has been added to the queue!",
-  songBlockedWMG: emojis.redx +
-    "This song had been blocked by WMG (Warner Music Groud).\n<:skip:674685614221688832> Skipped to next song.",
-  songsAdded: emojis.green_check_mark + "%AMOUNT% songs added to the queue!",
-  songSelection: "__Song Selection__",
-  startPlaying: emojis.notes + "Start playing: ",
-  statusField1: emojis.signal + "Ping",
-  statusField2: "Latency",
-  statusField3: emojis.stopWatch + "Uptime",
-  statusField4: "Shard: ",
-  statusTitle: "Status for Musix",
-  stop: emojis.stop + "Stopped the music!",
-  tookTooLong: emojis.redx + "Something took too long! Please try again!",
-  validNumber: emojis.redx + "I'm sorry, But you need to enter a valid __number__.",
-  videoUnavailable: emojis.redx + "That video is unavaiable! Please try again.",
-  wrongVoiceChannel: emojis.redx +
-    "I'm sorry but you need to be in the same voice channel as Musix to use this command!",
-};

src/events/clientEvents/guildCreate.js

@@ -1,29 +0,0 @@
-module.exports = {
-  name: "guildcreate",
-  async execute(client, guild) {
-    client.db.collection("guilds").doc(guild.id).set({
-      prefix: client.config.prefix,
-      defaultVolume: client.config.defaultVolume,
-      permissions: client.config.permissions,
-      dj: client.config.dj,
-      djrole: client.config.djrole,
-      startPlaying: client.config.startPlaying,
-      bass: client.config.bass,
-      blacklist: [],
-      premium: false,
-      autoPlay: client.config.autoPlay,
-    });
-    client.global.db.guilds[guild.id] = {
-      prefix: client.config.prefix,
-      defaultVolume: client.config.defaultVolume,
-      permissions: client.config.permissions,
-      dj: client.config.dj,
-      djrole: client.config.djrole,
-      startPlaying: client.config.startPlaying,
-      bass: client.config.bass,
-      blacklist: [],
-      premium: false,
-      autoPlay: client.config.autoPlay,
-    };
-  },
-};

src/events/clientEvents/guildDelete.js

@@ -1,6 +0,0 @@
-module.exports = {
-    name: "guildcreate",
-    async execute(client, guild) {
-        delete client.global.db.guilds[guild.id];
-    },
-};

src/events/clientEvents/handler.js

@@ -1,36 +0,0 @@
-module.exports = function (client) {
-    client.on('ready', () => {
-            require(`./ready.js`).execute(client);
-        }).on('message', (msg) => {
-            require(`./msg.js`).execute(client, msg);
-        }).on('guildCreate', (guild) => {
-            require(`./guildCreate.js`).execute(client, guild);
-        })
-        .on('guildDelete', (guild) => {
-            require(`./guildDelete.js`).execute(client, guild);
-        }).on('voiceStateUpdate', (oldState, newState) => {
-            require(`./voiceStateUpdate.js`).execute(client, oldState, newState);
-        }).on('error', (error) => {
-            console.log(error);
-        }).on('debug', (info) => {
-            if (client.config.devMode) console.log(info);
-        }).on('invalidated', () => {
-            console.log("Client session invalidated! Exiting the process!")
-            process.exit(1);
-        }).on('rateLimit', (rateLimitInfo) => {
-
-        }).on('shardDisconnect', (event, id) => {
-            client.logs.push(`Shard ${id} disconnected event ${event}`);
-        }).on('shardError', (error, shardId) => {
-            client.logs.push(`Shard ${shardId} error ${error}`);
-        }).on('shardReady', (id, unavailableGuilds) => {
-            client.logs.push(`Shard ${id} ready. Unavailable guilds: ${unavailableGuilds || 0}`);
-        }).on('shardReconnecting', (id) => {
-            client.logs.push(`shard ${id} reconnecting.`);
-        }).on('shardResume', (id, replayedEvents) => {
-            client.logs.push(`shard ${id} resume events ${replayedEvents}`);
-        }).on("warn", (info) => {
-            client.logs.push(`Warn! info: ${info}`);
-            console.log(`Warn! info: ${info}`);
-        });
-}

src/events/clientEvents/msg.js

@@ -1,41 +0,0 @@
-module.exports = {
-  name: "message",
-  async execute(client, msg, Discord) {
-    if (msg.author.bot || !msg.guild) return;
-    if (!client.global.db.guilds[msg.guild.id]) client.funcs.checkDB(client);
-    let prefix = client.global.db.guilds[msg.guild.id].prefix || client.config.prefix;
-    const args = msg.content.slice(prefix.length).split(" ");
-    if (client.config.devMode) prefix = client.config.devPrefix;
-    const permission = msg.channel.permissionsFor(client.user);
-    if (!permission.has("SEND_MESSAGES")) return;
-    if (msg.mentions.users.first()) {
-      if (msg.mentions.users.first().id === client.user.id) {
-        if (!args[1] || args[0] !== `@!${client.user.id}>`) return;
-        if (args[1] === "prefix") {
-          if (!args[2])
-            return msg.channel.send(
-              `${client.messages.prefixHere}\`${prefix}\`.`
-            );
-          if (args[2] === "=" && args[3]) return (prefix = args[3]);
-        }
-        args.shift();
-        getCommand(client, args, msg, Discord);
-      }
-    }
-    if (!msg.content.startsWith(prefix)) return;
-    getCommand(client, args, msg, Discord);
-  },
-};
-
-function getCommand(client, args, msg) {
-  if (!args[0]) return;
-  const commandName = args[0].toLowerCase();
-  if (commandName === "none") return;
-  const command =
-    client.commands.get(commandName) ||
-    client.commands.find(
-      (cmd) => cmd.alias && cmd.alias.includes(commandName)
-    );
-  if (!command) return;
-  client.funcs.exe(msg, args, client, command);
-}

src/events/clientEvents/ready.js

@@ -1,45 +0,0 @@
-module.exports = {
-  name: "ready",
-  async execute(client, Discord) {
-    const remoteMusixGuildsData = await client.funcs.dbget(
-      "guilds",
-      null,
-      client
-    );
-    remoteMusixGuildsData.forEach((guildData) => {
-      client.global.db.guilds[guildData.id] = guildData.d;
-    });
-    if (client.config.devMode) {
-      client.guilds.cache.forEach((guild) => {
-        client.global.db.guilds[guild.id] = {
-          prefix: client.config.devPrefix,
-          defaultVolume: client.config.defaultVolume,
-          permissions: client.config.permissions,
-          dj: client.config.dj,
-          djrole: client.config.djrole,
-          startPlaying: client.config.startPlaying,
-          bass: client.config.bass,
-          blacklist: [],
-          premium: true,
-          autoPlay: client.config.autoPlay,
-        };
-      });
-    }
-    console.log(`- DB Set - Shard: ${client.shard.ids} -`);
-    client.user.setActivity(`@${client.user.username} help | 🎶`, {
-      type: "LISTENING",
-    });
-    client.user.setStatus("online");
-    client.funcs.getSpotifyKey(client);
-    console.log(`- Activated - Shard: ${client.shard.ids} -`);
-    setInterval(() => {
-      if (!client.config.devMode) client.funcs.checkDB(client);
-    }, 60000);
-    setInterval(async () => {
-      client.funcs.saveDB(client);
-    }, 1800000);
-    setInterval(() => {
-      client.funcs.getSpotifyKey(client);
-    }, 3600000);
-  },
-};

src/events/clientEvents/voiceStateUpdate.js

@@ -1,34 +0,0 @@
-module.exports = {
-    name: 'voiceStateUpdate',
-    async execute(client, oldState, newState) {
-        if (oldState.channel === null) return newState.setSelfDeaf(true);
-        let change = false;
-        const queue = client.queue.get(newState.guild.id);
-        if (!queue) return;
-        if (newState.member.id === client.user.id && oldState.member.id === client.user.id) {
-            if (newState.member.voice.channel === null) {
-                queue.songs = [];
-                queue.looping = false;
-                queue.endReason = "manual disconnect";
-                return client.queue.delete(newState.guild.id);
-            }
-            if (newState.member.voice.channel !== queue.voiceChannel) {
-                change = true;
-                queue.voiceChannel = newState.member.voice.channel;
-                queue.connection = newState.connection;
-            }
-        }
-        if (oldState.channel.members.size === 1 && oldState.channel === queue.voiceChannel || change) {
-            setTimeout(() => {
-                if (!queue || !queue.connection.dispatcher || queue.connection.dispatcher === null) return;
-                if (queue.voiceChannel.members.size === 1) {
-                    queue.textChannel.send(client.messages.leftAlone);
-                    queue.songs = [];
-                    queue.looping = false;
-                    queue.endReason = "Timeout";
-                    queue.connection.dispatcher.end();
-                }
-            }, 120000);
-        }
-    }
-}

src/events/connectionEvents/handler.js

@@ -1,21 +0,0 @@
-module.exports = function (client, connection) {
-    connection.on("authenticated", () => {
-        if (client.config.devMode) console.log("Voice connection initiated.");
-    }).on("debug", (message) => {
-        if (client.config.devMode) console.log(message);
-    }).on("disconnect", () => {
-        if (client.config.devMode) console.log("Voice connection disconnected.");
-    }).on("error", (error) => {
-        console.log(error);
-    }).on("failed", (error) => {
-        if (client.config.devMode) console.log(error);
-    }).on("newSession", () => {
-        if (client.config.devMode) console.log("New voice session id received!");
-    }).on("ready", () => {
-        if (client.config.devMode) console.log("Voice connection ready.");
-    }).on("reconnecting", () => {
-        if (client.config.devMode) console.log("Voice connection reconnecting.");
-    }).on("warn", (warning) => {
-        console.log(`Voice connection warning: ${warning}`);
-    })
-}

src/events/dispatcherEvents/error.js

@@ -1,14 +0,0 @@
-module.exports = {
-    async execute(client, error, guild) {
-        const queue = client.queue.get(guild.id);
-        console.log(error);
-        /*if (error = "Error: input stream: This video contains content from WMG, who has blocked it on copyright grounds.") {
-            queue.endReason = "skip";
-            queue.connection.dispatcher.end();
-            return queue.textChannel.send(client.messages.songBlockedWMG);
-        }*/
-        queue.voiceChannel.leave();
-        client.queue.delete(guild.id);
-        return queue.textChannel.send(client.messages.errorDispatcher + `\`${error}\``);
-    },
-};

src/events/dispatcherEvents/finish.js

@@ -1,95 +0,0 @@
-const similarSongs = require("similar-songs");
-const ytdl = require("ytdl-core");
-
-module.exports = {
-  async execute(client, guild) {
-    const queue = client.queue.get(guild.id);
-    queue.playing = false;
-    if (queue.endReason === "seek") {
-      return (queue.playing = true);
-    }
-
-    if (!queue.songLooping) {
-      if (queue.looping) {
-        queue.songs.push(queue.songs[0]);
-      }
-
-      queue.time = 0;
-      queue.votes = 0;
-      queue.voters = [];
-      if (queue.endReason !== "replay") {
-        if (queue.endReason === "previous")
-          queue.songs.unshift(queue.prevSongs.pop());
-        if (queue.endReason !== "previous")
-          queue.prevSongs.push(queue.songs.shift());
-        if (
-          client.global.db.guilds[guild.id].autoPlay &&
-          !queue.songs[0] &&
-          queue.endReason !== "stop"
-        ) {
-          if (queue.prevSongs.length > 0)
-            return findSimilar(client, queue, queue.prevSongs, guild);
-        }
-      }
-    }
-    client.funcs.play(guild, queue.songs[0], client, 0, true);
-  },
-};
-
-function findSimilar(client, queue, prevSongs, guild) {
-  let retries = 0;
-  const query =
-    prevSongs[Math.floor(Math.random() * Math.floor(prevSongs.length))];
-  if (!query || !query.track) return findSimilar(client, queue, prevSongs, guild);
-  similarSongs.find({
-      title: query.track.name,
-      artist: query.track.artists[0].name,
-      limit: 10,
-      lastfmAPIKey: client.config.lastfm_api_key,
-      lastfmAPISecret: client.config.lastfm_secret,
-      youtubeAPIKey: client.config.youtube_api_key,
-    },
-    async function (err, songs) {
-      if (err) {
-        if (
-          err.message ==
-          'The request cannot be completed because you have exceeded your <a href="/youtube/v3/getting-started#quota">quota</a>.'
-        ) {
-          queue.voiceChannel.leave();
-          queue.exists = false;
-          client.queue.delete(guild.id);
-          queue.textChannel.send(client.messages.quotaReached);
-          return;
-        }
-        console.log(err.message);
-        queue.voiceChannel.leave();
-        queue.exists = false;
-        client.queue.delete(guild.id);
-        return queue.textChannel.send(client.messages.error);
-      }
-      if (songs[0]) {
-        const random = Math.floor(Math.random() * Math.floor(songs.length));
-        const songInfo = await ytdl.getInfo(
-          `https://www.youtube.com/watch?v=${songs[random].youtubeId}`
-        );
-        queue.songs.push({
-          title: songInfo.videoDetails.title,
-          url: `https://www.youtube.com/watch?v=${songs[random].youtubeId}`,
-          author: client.user,
-          type: "ytdl",
-          info: songInfo.videoDetails,
-          track: query.track,
-        });
-        client.funcs.play(guild, queue.songs[0], client, 0, true);
-      } else {
-        if (prevSongs.length > 4 && retries < 6) {
-          findSimilar(client, queue, prevSongs, guild);
-          retries++;
-          return;
-        }
-        queue.textChannel.send(client.messages.noSimilarResults);
-        client.funcs.play(guild, queue.songs[0], client, 0, true);
-      }
-    }
-  );
-}

src/events/dispatcherEvents/handler.js

@@ -1,16 +0,0 @@
-module.exports = function (client, dispatcher, queue, guild) {
-    dispatcher.on("finish", () => {
-            if (client.config.devMode) console.log("Dispatcher finish.");
-            require("./finish").execute(client, guild);
-        })
-        .on("start", () => {
-            if (client.config.devMode) console.log("Dispatcher start.");
-            queue.endReason = null;
-            dispatcher.player.streamingData.pausedTime = 0;
-        })
-        .on("error", (error) => {
-            require("./error").execute(client, error, guild);
-        }).on("debug", (info) => {
-            if (client.config.devMode) console.log(info);
-        })
-}

src/funcs/check.js

@@ -1,34 +0,0 @@
-module.exports = function (client, msg, command) {
-  const queue = client.queue.get(msg.guild.id);
-  const permissions = msg.channel.permissionsFor(msg.author);
-  if (!queue || !queue.playing && command.name !== "stop") {
-    msg.channel.send(client.messages.noServerQueue);
-    return false;
-  }
-  if (msg.author.id !== client.config.devId) {
-    if (msg.member.voice.channel !== queue.voiceChannel) {
-      msg.channel.send(client.messages.wrongVoiceChannel);
-      return false;
-    }
-    if (client.global.db.guilds[msg.guild.id].permissions === true) {
-      if (client.global.db.guilds[msg.guild.id].dj) {
-        if (
-          !msg.member.roles.cache.has(
-            client.global.db.guilds[msg.guild.id].djrole
-          )
-        ) {
-          msg.channel.send(client.messages.noDj);
-          return false;
-        } else return true;
-      } else if (!permissions.has(command.permission)) {
-        let message;
-        message = client.messages.noPerms.replace(
-          "%PERMS%",
-          command.permissions
-        );
-        msg.channel.send(message);
-        return false;
-      } else return true;
-    } else return true;
-  } else return true;
-};

src/funcs/checkDB.js

@@ -1,52 +0,0 @@
-module.exports = async function (client) {
-  client.guilds.cache.forEach((guild) => {
-    if (!client.global.db.guilds[guild.id]) {
-      client.db.collection("guilds").doc(guild.id).set({
-        prefix: client.config.prefix,
-        defaultVolume: client.config.defaultVolume,
-        permissions: client.config.permissions,
-        dj: client.config.dj,
-        djrole: client.config.djrole,
-        startPlaying: client.config.startPlaying,
-        bass: client.config.bass,
-        blacklist: [],
-        premium: false,
-        autoPlay: client.config.autoPlay,
-      });
-      client.global.db.guilds[guild.id] = {
-        prefix: client.config.prefix,
-        defaultVolume: client.config.defaultVolume,
-        permissions: client.config.permissions,
-        dj: client.config.dj,
-        djrole: client.config.djrole,
-        startPlaying: client.config.startPlaying,
-        bass: client.config.bass,
-        blacklist: [],
-        premium: false,
-        autoPlay: client.config.autoPlay,
-      };
-      return;
-    }
-    if (!client.global.db.guilds[guild.id].prefix)
-      client.global.db.guilds[guild.id].prefix = client.config.prefix;
-    if (!client.global.db.guilds[guild.id].defaultVolume)
-      client.global.db.guilds[guild.id].defaultVolume =
-      client.config.defaultVolume;
-    if (!client.global.db.guilds[guild.id].permissions)
-      client.global.db.guilds[guild.id].permissions = client.config.permissions;
-    if (!client.global.db.guilds[guild.id].dj)
-      client.global.db.guilds[guild.id].dj = client.config.dj;
-    if (!client.global.db.guilds[guild.id].djrole)
-      client.global.db.guilds[guild.id].djrole = client.config.djrole;
-    if (!client.global.db.guilds[guild.id].startPlaying)
-      client.global.db.guilds[guild.id].startPlaying =
-      client.config.startPlaying;
-    if (!client.global.db.guilds[guild.id].bass)
-      client.global.db.guilds[guild.id].bass = client.config.bass;
-    if (!client.global.db.guilds[guild.id].blacklist)
-      client.global.db.guilds[guild.id].blacklist = [];
-    if (!client.global.db.guilds[guild.id].premium)
-      client.global.db.guilds[guild.id].premium = false;
-    if (!client.global.db.guilds[guild.id].autoPlay) client.global.db.guilds[guild.id].autoPlay = client.config.autoPlay
-  });
-};

src/funcs/dbget.js

@@ -1,22 +0,0 @@
-module.exports = async function (collection, doc, client) {
-    if (doc) {
-        let d = await client.db.collection(collection).doc(doc).get().catch(err => {
-            console.log('Error getting document', err);
-            return 'error';
-        });
-        return d.data();
-    } else {
-        let d = await client.db.collection(collection).get().catch(err => {
-            console.log('Error getting document', err);
-            return 'error';
-        });
-        let finalD = [];
-        d.forEach(doc => {
-            finalD.push({
-                id: doc.id,
-                d: doc.data(),
-            });
-        });
-        return finalD;
-    }
-};

src/funcs/end.js

@@ -1,12 +0,0 @@
-module.exports = async function (client, msg, pos, command) {
-  const seek = parseInt(pos);
-  const queue = client.queue.get(msg.guild.id);
-  if (command.name === "seek") {
-    queue.time = seek * 1000;
-  } else {
-    queue.time = queue.connection.dispatcher.streamTime + queue.time;
-  }
-  queue.connection.dispatcher.end();
-  queue.endReason = "seek";
-  client.funcs.play(msg.guild, queue.songs[0], client, seek, false);
-};