Merge pull request #246 from musix-org/dependabot/npm_and_yarn/v2/firebase-12.3.0

Bump firebase from 12.2.1 to 12.3.0

.env_example

@@ -1,3 +0,0 @@
-DISCORD_API_TOKEN=
-BOT_PREFIX=
-YOUTUBE_API_KEY=

.gitignore

@@ -1 +1,4 @@
+.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;
+        }
+    }
+};

Procfile

@@ -1 +0,0 @@
-worker: node index.js

README.md

@@ -1 +1,21 @@
-# Musix OSS - V1
+# 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,400 +1,50 @@
-const { AudioPlayerStatus, createAudioPlayer, createAudioResource, getVoiceConnection, joinVoiceChannel, NoSubscriberBehavior } = require('@discordjs/voice');
-const { Client, ActivityType, PermissionFlagsBits } = require('discord.js');
 const Discord = require('discord.js');
-const YouTube = require('simple-youtube-api')
-const ytdl = require('ytdl-core');
-const PREFIX = (process.env.BOT_PREFIX ?? "mx>");
-const client = new Client({
-	intents: [
-		"Guilds",
-		"GuildMessages",
-		"GuildVoiceStates",
-		"MessageContent"
-	],
-	disableMentions: 'everyone'
-});
-const youtube = new YouTube(process.env.YOUTUBE_API_KEY);
-const queue = new Map();
-client.login(process.env.DISCORD_API_TOKEN);
-client.on('ready', () => {
-	client.user.setActivity(`${PREFIX}help`, { type: ActivityType.Listening })
-	client.user.setStatus('online');
-});
-client.on('messageCreate', async msg => {
-	if (!msg.guild || msg.author.bot) return;
-	if (msg.content.startsWith(`${PREFIX}`)) {
-		if (msg.content === `${PREFIX}ping`) {
-			msg.channel.send(`My current Ping: **${Math.floor(client.ws.ping * 10) / 10} ms**.`);
-			return;
-		}
-		if (msg.content === `${PREFIX}help`) {
-			const embed = new Discord.EmbedBuilder()
-				.setTitle('Commands for ' + client.user.username + '!')
-				.addFields(
-					{ name: '```' + `${PREFIX}` + 'play | ' + `${PREFIX}` + 'p```', value: 'Play a song.', inline: true },
-					{ name: '```' + `${PREFIX}` + 'queue | ' + `${PREFIX}` + 'q```', value: 'Display the queue.', inline: true },
-					{ name: '```' + `${PREFIX}` + 'nowplaying | ' + `${PREFIX}` + 'np```', value: 'Display whats currently playing.', 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}` + 'stop```', value: 'Stop the music, Clear the queue and leave the current voice channel.', inline: true },
-					{ name: '```' + `${PREFIX}` + 'skip | ' + `${PREFIX}` + 's```', value: 'Skip a song.', inline: true },
-					{ name: '```' + `${PREFIX}` + 'invite```', value: 'Invite ' + client.user.username + '.', inline: true },
-					{ name: '```' + `${PREFIX}` + 'ping```', value: 'See the current ping for ' + client.user.username, inline: true },
-					{ name: '```' + `${PREFIX}` + 'info```', value: 'Display info and instructions.', inline: true },
-					{ name: '```' + `${PREFIX}` + 'help```', value: 'Display the help.', inline: true }
-				)
-				.setAuthor({ name: client.user.username, iconURL: client.user.avatarURL() })
-				.setColor('#b50002');
-			msg.channel.send({ embeds: [embed] });
-			return undefined;
-		}
-		if (msg.content === `${PREFIX}info`) {
-			var line = '**>-----------------------------------------------------------------------<**';
-			var dj = msg.guild.roles.cache.find(x => x.name === 'DJ') ? true : false;
-			const embed = new Discord.EmbedBuilder()
-				.setTitle('**' + client.user.username + ' instructions and info**:')
-				.addFields(
-					{ name: 'If your current guild has a role called \'DJ\' you will need it to use music commands! If your current guild doesn\'t have a role called \'DJ\' everyone can use music commands!', value:'DJ role existance: ' + dj, inline: true },
-					{ name: 'If you encounter any errors with ' + client.user.username + ' please report about them on the offical ' + client.user.username + ' support server!', value: 'https://discord.gg/rvHuJtB', inline: true },
-					{ name: `On errors you can do ${PREFIX}stop to reset the queue and try again!`, value: line, inline: true },
-					{ name: 'Current Ping in milliseconds', value: `${Math.floor(client.ws.ping * 10) / 10} ms`, inline: true },
-					{ name: 'Be careful with the Volume command! Volume is not recommended to be put over 3 with user volume at 100%!', value: 'Volume will reset to 1 always when a new song begins!', inline: true }
-				)
-				.setAuthor({ name: client.user.username, iconURL: client.user.avatarURL() })
-				.setColor('#b50002');
-			msg.channel.send({ embeds: [embed] });
-			return undefined;
-		}
-		if (msg.content === `${PREFIX}invite`) {
-			msg.channel.send('Invite me with:' + '\n' + 'https://discord.com/oauth2/authorize?client_id=' + client.user.id + '&permissions=2184465408&scope=applications.commands+bot');
-			return undefined;
-		}
-		if (msg.member.guild.roles.cache.find(x => x.name === 'DJ')) {
-			if (msg.member.roles.cache.find(x => x.name === 'DJ')) {
-				const args = msg.content.split(' ');
-				const searchString = args.slice(1).join(' ');
-				const url = args[1] ? args[1].replace(/<(.+)>/g, '$1') : '';
-				const serverQueue = queue.get(msg.guild.id);
+const MusicClient = require('./Client');
+const client = new MusicClient({});
+const fs = require('fs');
 
-				let command = msg.content.toLowerCase().split(' ')[0];
-				command = command.slice(PREFIX.length);
-
-				if (command === 'play' || command === 'p') {
-					if (!args[1]) return msg.channel.send(':x: I\'m sorry but you didn\'t specify a song');
-					const voiceChannel = msg.member.voice.channel;
-					if (!voiceChannel) return msg.channel.send(':x: I\'m sorry but you need to be in a voice channel to play music!');
-					const permissions = voiceChannel.permissionsFor(msg.client.user);
-					if (!permissions.has(PermissionFlagsBits.Connect)) {
-						return msg.channel.send(':x: I cannot connect to your voice channel, make sure I have the proper permissions!');
-					}
-					if (!permissions.has(PermissionFlagsBits.Speak)) {
-						return msg.channel.send(':x: I cannot speak in this 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 handleVideo(video2, msg, voiceChannel, true);
-						}
-						return msg.channel.send(`:white_check_mark: Playlist: **${playlist.title}** has been added to the queue!`);
-					} else {
-						try {
-							var video = await youtube.getVideo(url);
-						} catch (error) {
-							try {
-								var videos = await youtube.searchVideos(searchString, 10);
-								let index = 0;
-								msg.channel.send(`
-	__**Song selection:**__
-${videos.map(video2 => `**${++index} -** ${video2.title}`).join('\n')}
-Please provide a value to select one of the search results ranging from 1-10.
-						`);
-
-								try {
-									var response = await msg.channel.awaitMessages({
-										filter: msg2 => msg2.content > 0 && msg2.content < 11,
-										max: 1,
-										time: 10000,
-										errors: ['time']
-									});
-								} catch (err) {
-									return msg.channel.send(':x: Cancelling song selection.');
-								}
-								const videoIndex = parseInt(response.first().content);
-
-								var video = await youtube.getVideoByID(videos[videoIndex - 1].id);
-							} catch (err) {
-								return msg.channel.send(':x: I could not obtain any search results.');
-							}
-						}
-						return handleVideo(video, msg, voiceChannel);
-					}
-				} else if (command === 'skip' || command === 's') {
-					if (!msg.member.voice.channel) return msg.channel.send(':x: You are not in a voice channel!');
-					if (!serverQueue) return msg.channel.send(':x: There is nothing playing that I could skip for you.');
-					if (!serverQueue.songs[1]) return msg.channel.send(':x: Theres nothing to skip to!')
-					serverQueue.audioPlayer.stop();
-					return;
-				} else if (command === 'stop') {
-					if (!msg.member.voice.channel) return msg.channel.send(':x: You are not in a voice channel!');
-					if (!serverQueue) return msg.channel.send(':x: There is nothing playing that I could stop for you.');
-					serverQueue.songs = [];
-					serverQueue.audioPlayer.stop();
-					return;
-				} else if (command === 'volume') {
-					if (!msg.member.voice.channel) return msg.channel.send(':x: You are not in a voice channel!');
-					if (!serverQueue) return msg.channel.send(':x: There is nothing playing.');
-					if (!args[1]) return msg.channel.send(`The current volume is: **${serverQueue.volume}** :speaker:`);
-					if (isNaN(args[1])) {
-						return msg.channel.send(':x: I\'m sorry, But you need to enter a valid __number__.')
-					}
-					serverQueue.volume = args[1];
-					serverQueue.audioResource.volume.setVolume(args[1] / 100);
-					return msg.channel.send(`I set the volume to: **${args[1]}** 🔊`);
-				} else if (command === 'np' || command === 'nowplaying') {
-					if (!serverQueue) return msg.channel.send(':x: There is nothing playing.');
-					return msg.channel.send(`:musical_note: Now playing: **${serverQueue.songs[0].title}**`);
-				} else if (command === "queue" || command === 'q') {
-					if (!serverQueue)
-						return msg.channel.send(":x: There is nothing in the queue.");
-					var queuemessage = `__**Song queue:**__
-${serverQueue.songs.map(song => `**-** ${song.title}`).join("\n")}
-**Now playing:** ${serverQueue.songs[0].title} :musical_note: `;
-					if (queuemessage.length > 2000) {
-						return msg.channel.send(":x: The queue has too many songs in it to show all in this channel. Try again after a few songs.");
-					}
-					return msg.channel.send(queuemessage);
-				} else if (command === 'pause') {
-					if (serverQueue && serverQueue.playing) {
-						serverQueue.playing = false;
-						serverQueue.audioPlayer.pause();
-						return msg.channel.send(':pause_button: Paused the music for you!');
-					}
-					return msg.channel.send(':x: There is nothing playing.');
-				} else if (command === 'resume') {
-					if (serverQueue && !serverQueue.playing) {
-						serverQueue.playing = true;
-						serverQueue.audioPlayer.unpause();
-						return msg.channel.send(':play_pause: Resumed the music for you!');
-					}
-					return msg.channel.send(':x: There is nothing playing.');
-				}
-				if (msg.content === `${PREFIX}`) return;
-				msg.channel.send(`:x: Unknown command! Type ${PREFIX}help for the list of commands!`)
-				return;
-			}
-			if (msg.content === `${PREFIX}`) return;
-			var coms = [`${PREFIX}play`, `${PREFIX}queue`, `${PREFIX}np`, `${PREFIX}volume`, `${PREFIX}pause`, `${PREFIX}resume`, `${PREFIX}stop`, `${PREFIX}skip`, `${PREFIX}ping`, `${PREFIX}q`, `${PREFIX}nowplaying`, `${PREFIX}p`, `${PREFIX}s`];
-			for (var i = 0; i < coms.length; i++) {
-				if (msg.content.includes(coms[i])) {
-					if (!msg.member.roles.cache.find(x => x.name === 'DJ')) {
-						msg.channel.send(':x: i\'m sorry but you need to have the \'DJ\' role to use music commands!')
-						return;
-					}
-				}
-			}
-			msg.channel.send(`:x: Unknown command! Type ${PREFIX}help for the list of commands!`)
-			return;
-		} else {
-			const args = msg.content.split(' ');
-			const searchString = args.slice(1).join(' ');
-			const url = args[1] ? args[1].replace(/<(.+)>/g, '$1') : '';
-			const serverQueue = queue.get(msg.guild.id);
-
-			let command = msg.content.toLowerCase().split(' ')[0];
-			command = command.slice(PREFIX.length)
-
-			if (command === 'play' || command === 'p') {
-				if (!args[1]) return msg.channel.send(':x: I think you forgot what you wanted to play!');
-				const voiceChannel = msg.member.voice.channel;
-				if (!voiceChannel) return msg.channel.send(':x: I\'m sorry but you need to be in a voice channel to play music!');
-				const permissions = voiceChannel.permissionsFor(msg.client.user);
-				if (!permissions.has(PermissionFlagsBits.Connect)) {
-					return msg.channel.send(':x: I cannot connect to your voice channel, make sure I have the proper permissions!');
-				}
-				if (!permissions.has(PermissionFlagsBits.Speak)) {
-					return msg.channel.send(':x: I cannot speak in this 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); // eslint-disable-line no-await-in-loop
-						await handleVideo(video2, msg, voiceChannel, true); // eslint-disable-line no-await-in-loop
-					}
-					return msg.channel.send(`:white_check_mark: Playlist: **${playlist.title}** has been added to the queue!`);
-				} else {
-					try {
-						var video = await youtube.getVideo(url);
-					} catch (error) {
-						try {
-							var videos = await youtube.searchVideos(searchString, 10);
-							let index = 0;
-							msg.channel.send(`
-	__**Song selection:**__
-${videos.map(video2 => `**${++index} -** ${video2.title}`).join('\n')}
-Please provide a value to select one of the search results ranging from 1-10.
-						`);
-							// eslint-disable-next-line max-depth
-							try {
-								var response = await msg.channel.awaitMessages(msg2 => msg2.content > 0 && msg2.content < 11, {
-									maxMatches: 1,
-									time: 10000,
-									errors: ['time']
-								});
-							} catch (err) {
-								return msg.channel.send(':x: No or invalid value entered, cancelling video selection.');
-							}
-							const videoIndex = parseInt(response.first().content);
-							var video = await youtube.getVideoByID(videos[videoIndex - 1].id);
-						} catch (err) {
-							console.error(err);
-							return msg.channel.send(':x: I could not obtain any search results.');
-						}
-					}
-					return handleVideo(video, msg, voiceChannel);
-				}
-			} else if (command === 'skip' || command === 's') {
-				if (!msg.member.voice.channel) return msg.channel.send(':x: You are not in a voice channel!');
-				if (!serverQueue) return msg.channel.send(':x: There is nothing playing that I could skip for you.');
-				msg.channel.send('Skipped :thumbsup:')
-				serverQueue.audioPlayer.stop();
-				return undefined;
-			} else if (command === 'stop') {
-				if (!msg.member.voice.channel) return msg.channel.send(':x: You are not in a voice channel!');
-				if (!serverQueue) return msg.channel.send(':x: There is nothing playing that I could stop for you.');
-				msg.channel.send('Stopped the music! :stop_button:')
-				serverQueue.songs = [];
-				serverQueue.audioPlayer.stop();
-				return undefined;
-			} else if (command === 'volume') {
-				if (!msg.member.voice.channel) return msg.channel.send(':x: You are not in a voice channel!');
-				if (!serverQueue) return msg.channel.send(':x: There is nothing playing.');
-				if (!args[1]) return msg.channel.send(`The current volume is: **${serverQueue.volume}** :speaker:`);
-				if (isNaN(args[1])) {
-					return msg.channel.send(':x: I\'m sorry, But you need to enter a valid __number__.')
-				}
-				serverQueue.volume = args[1];
-				serverQueue.audioResource.volume.setVolume(args[1] / 100);
-				return msg.channel.send(`I set the volume to: **${args[1]}** 🔊`);
-			} else if (command === 'np' || command === 'nowplaying') {
-				if (!serverQueue) return msg.channel.send(':x: There is nothing playing.');
-				return msg.channel.send(`:musical_note: Now playing: **${serverQueue.songs[0].title}**`);
-			} else if (command === "queue" || command === 'q') {
-				if (!serverQueue)
-					return msg.channel.send(":x: There is nothing in the queue.");
-				var queuemessage = `__**Song queue:**__
-${serverQueue.songs.map(song => `**-** ${song.title}`).join("\n")}
-**Now playing:** ${serverQueue.songs[0].title} :musical_note: `;
-				if (queuemessage.length < 2000) {
-					return msg.channel.send(":x: The queue has too many songs in it to show all in this channel. Try again after a few songs");
-				}
-				return msg.channel.send(queuemessage);
-			} else if (command === 'pause') {
-				if (serverQueue && serverQueue.playing) {
-					serverQueue.playing = false;
-					serverQueue.audioPlayer.pause();
-					return msg.channel.send(':pause_button: Paused the music for you!');
-				}
-				return msg.channel.send(':x: There is nothing playing.');
-			} else if (command === 'resume') {
-				if (serverQueue && !serverQueue.playing) {
-					serverQueue.playing = true;
-					serverQueue.audioPlayer.unpause();
-					return msg.channel.send(':play_pause: Resumed the music for you!');
-				}
-				return msg.channel.send(':x: There is nothing playing.');
-			}
-		}
-		if (msg.content === `${PREFIX}`) {
-			return;
-		}
-		msg.channel.send(`:x: Unknown command! Type ${PREFIX}help for the list of commands!`)
-		return;
-	}
-});
-
-async function handleVideo(video, msg, voiceChannel, playlist = false) {
-	const serverQueue = queue.get(msg.guild.id);
-	const song = {
-		id: video.id,
-		title: video.title,
-		url: `https://www.youtube.com/watch?v=${video.id}`
-	};
-	if (!serverQueue) {
-		const queueConstruct = {
-			textChannel: msg.channel,
-			voiceChannel: voiceChannel,
-			connection: null,
-			audioPlayer: createAudioPlayer({
-				behaviors: {
-					noSubscriber: NoSubscriberBehavior.Play,
-				}
-			}),
-			audioResource: null,
-			songs: [],
-			volume: 50,
-			playing: true
-		};
-
-		queue.set(msg.guild.id, queueConstruct);
-
-		queueConstruct.songs.push(song);
-
-		try {
-			const connection =
-				getVoiceConnection(voiceChannel.guild.id) ??
-				joinVoiceChannel({
-					channelId: voiceChannel.id,
-					guildId: voiceChannel.guild.id,
-					adapterCreator: voiceChannel.guild.voiceAdapterCreator
-				});
-			queueConstruct.connection = connection;
-			play(msg.guild, queueConstruct.songs[0]);
-		} catch (error) {
-			console.error(`I could not join the voice channel: ${error}`);
-			queue.delete(msg.guild.id);
-			return msg.channel.send(`:x: I could not join the voice channel: ${error}`);
-		}
-	} else {
-		serverQueue.songs.push(song);
-		if (playlist) return undefined;
-		else return msg.channel.send(`:white_check_mark: **${song.title}** has been added to the queue!`);
-	}
-	return undefined;
+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);
 }
 
-function play(guild, song) {
-	const serverQueue = queue.get(guild.id);
-
-	if (!song) {
-		serverQueue.connection.destroy();
-		queue.delete(guild.id);
-		return;
-	}
-
-	serverQueue.audioPlayer
-		.on(AudioPlayerStatus.Idle, () => {
-			serverQueue.songs.shift();
-			serverQueue.audioPlayer.removeAllListeners();
-			play(guild, serverQueue.songs[0]);
-		})
-		.on('error', (error) => {
-			console.error(error)
-		});
-
-	const audioResource = createAudioResource(ytdl(song.url, { quality: `highestaudio`, filter: 'audioonly' }),{
-		inlineVolume: true
-	});
-
-	audioResource.volume.setVolume(serverQueue.volume / 100);
-
-	serverQueue.audioPlayer.play(audioResource);
-	serverQueue.audioResource = audioResource;
-	serverQueue.connection.subscribe(serverQueue.audioPlayer);
-
-	serverQueue.textChannel.send(`:musical_note: Start playing: **${song.title}**`);
+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);
+});
+
+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);
+});
+
+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);
+});
+
+client.login(client.config.discord_api_token).catch(err => { console.log('- Failed To Login -> ' + err); });

package.json

@@ -1,26 +1,34 @@
 {
   "name": "musix-oss",
-  "version": "1.3.0",
+  "version": "2.22.0",
   "description": "",
   "main": "index.js",
   "scripts": {
     "start": "node index.js",
-    "start:dev": "nodemon",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "start:dev": "nodemon"
   },
   "keywords": [],
-  "author": "",
+  "author": "Musix Org",
   "license": "MIT",
+  "homepage": "https://https://github.com/musix-oss/musix",
+  "repository": {
+    "type": "git",
+    "url": "https://https://github.com/musix-oss/musix"
+  },
   "dependencies": {
-    "discord.js": "^14.26.3",
-    "@discordjs/voice": "^0.19.2",
+    "discord.js": "^14.22.1",
+    "@discordjs/voice": "^0.19.0",
     "@discordjs/opus": "^0.10.0",
+    "dotenv": "^17.2.2",
+    "firebase": "^12.3.0",
+    "firebase-admin": "^13.5.0",
+    "he": "^1.2.0",
     "ms": "^2.1.3",
     "request": "^2.88.2",
     "simple-youtube-api": "^5.2.1",
     "ytdl-core": "^4.11.5"
   },
   "devDependencies": {
-    "nodemon": "^3.1.14"
+    "nodemon": "^3.1.10"
   }
 }