Update

.env.example

@@ -0,0 +1,5 @@
+DISCORD_TOKEN=
+MONGO_TOKEN=
+GIPHY_TOKEN=
+TOPGG_TOKEN=
+RADIO=

package.json

@@ -0,0 +1,76 @@
+{
+  "name": "discordbot",
+  "version": "9.0.4",
+  "description": "DiscordBot is a bot with which you can run your entire server! With no less than 400+ commands",
+  "main": "./src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node . --trace-warnings"
+  },
+  "keywords": [
+    "Music",
+    "Moderation",
+    "Tickets",
+    "Radio",
+    "Games",
+    "Giveaways",
+    "Customisation",
+    "Economy",
+    "Leveling",
+    "Invites",
+    "Messages",
+    "Utilities",
+    "Suggestions",
+    "Server Stats"
+  ],
+  "author": "CorwinDev",
+  "license": "ISC",
+  "dependencies": {
+    "@discordjs/builders": "^0.11.0",
+    "@discordjs/rest": "^0.1.0-canary.0",
+    "@discordjs/voice": "^0.7.5",
+    "@haileybot/captcha-generator": "^1.7.0",
+    "@iamtraction/google-translate": "^1.1.2",
+    "@top-gg/sdk": "^3.1.3",
+    "axios": "^0.24.0",
+    "canvacord": "^5.2.3",
+    "chalk": "^4.1.2",
+    "discord-api-types": "^0.26.0",
+    "discord-giveaways": "^5.1.1",
+    "discord-image-generation": "^1.4.9",
+    "discord.js": "^13.5.1",
+    "dompurify": "^2.3.5",
+    "dotenv": "^10.0.0",
+    "erela.js": "^2.3.3",
+    "erela.js-apple": "^1.2.6",
+    "erela.js-deezer": "^1.0.7",
+    "erela.js-facebook": "^1.0.4",
+    "erela.js-spotify": "^1.2.0",
+    "figlet": "^1.5.2",
+    "fs": "^0.0.1-security",
+    "generate-password": "^1.6.1",
+    "giphy-api": "^2.0.2",
+    "hdqwalls-wrapper": "^1.0.4",
+    "he": "^1.2.0",
+    "html-entities": "^2.3.2",
+    "i": "^0.3.7",
+    "is-hexcolor": "^1.0.0",
+    "isgd": "^1.1.3",
+    "jsdom": "^18.1.0",
+    "libsodium-wrappers": "^0.7.9",
+    "lyrics-finder": "^21.7.0",
+    "mathjs": "^10.0.2",
+    "moment": "^2.29.1",
+    "moment-duration-format": "^2.3.2",
+    "moment-timezone": "^0.5.33",
+    "mongoose": "^6.0.13",
+    "ms": "^2.1.3",
+    "npm": "^8.3.0",
+    "popcat-wrapper": "^1.5.0",
+    "sourcebin": "^4.2.5",
+    "topgg-autoposter": "^2.0.1",
+    "util": "^0.12.4",
+    "weather-js": "^2.0.0",
+    "ytdl-core": "^4.9.2"
+  }
+}

src/Collection/index.js

@@ -0,0 +1,5 @@
+const { Collection } = require("discord.js");
+
+const blacklistedWords = new Collection();
+
+module.exports = { blacklistedWords };

src/assets/utils/TriviaPlayer.js

@@ -0,0 +1,289 @@
+const {
+    AudioPlayerStatus,
+    createAudioPlayer,
+    entersState,
+    VoiceConnectionDisconnectReason,
+    VoiceConnectionStatus,
+    createAudioResource,
+    StreamType
+} = require('@discordjs/voice');
+const { setTimeout } = require('timers');
+const { promisify } = require('util');
+const ytdl = require('ytdl-core');
+const { MessageEmbed } = require('discord.js');
+const wait = promisify(setTimeout);
+
+class TriviaPlayer {
+    constructor() {
+        this.connection = null;
+        this.audioPlayer = createAudioPlayer();
+        this.score = new Map();
+        this.queue = [];
+        this.textChannel;
+        this.wasTriviaEndCalled = false;
+    }
+
+    passConnection(connection) {
+        this.connection = connection;
+        this.connection.on('stateChange', async (_, newState) => {
+            if (newState.status === VoiceConnectionStatus.Disconnected) {
+                if (
+                    newState.reason === VoiceConnectionDisconnectReason.WebSocketClose &&
+                    newState.closeCode === 4014
+                ) {
+                    try {
+                        await entersState(
+                            this.connection,
+                            VoiceConnectionStatus.Connecting,
+                            5000
+                        );
+                    } catch {
+                        this.connection.destroy();
+                    }
+                } else if (this.connection.rejoinAttemps < 5) {
+                    await wait((this.connection.rejoinAttemps + 1) * 5000);
+                    this.connection.rejoin();
+                } else {
+                    this.connection.destroy();
+                }
+            } else if (newState.status === VoiceConnectionStatus.Destroyed) {
+                // when destroying connection (stop-trivia)
+                this.stop();
+            } else if (
+                newState.status === VoiceConnectionStatus.Connecting ||
+                newState.status === VoiceConnectionStatus.Signalling
+            ) {
+                try {
+                    await entersState(
+                        this.connection,
+                        VoiceConnectionStatus.Ready,
+                        20000
+                    );
+                } catch {
+                    if (this.connection.state.status !== VoiceConnectionStatus.Destroyed)
+                        this.connection.destroy();
+                }
+            }
+        });
+
+        this.audioPlayer.on('stateChange', (oldState, newState) => {
+            if (
+                newState.status === AudioPlayerStatus.Idle &&
+                oldState.status !== AudioPlayerStatus.Idle
+            ) {
+                this.queue.shift();
+                // Finished playing audio
+                if (this.queue.length) {
+                    // play next song
+                    this.process(this.queue);
+                } else {
+                    const sortedScoreMap = new Map(
+                        [...this.score.entries()].sort(function (a, b) {
+                            return b[1] - a[1];
+                        })
+                    );
+
+                    if (this.wasTriviaEndCalled) return;
+
+                    this.textChannel.client.embed({
+                        title: `🎶・Music Quiz - Results`,
+                        desc: getLeaderBoard(Array.from(sortedScoreMap.entries())),
+                        edit: true
+                    }, this.textChannel)
+
+                    // leave channel close connection and subscription
+                    if (this.connection._state.status !== 'destroyed') {
+                        this.connection.destroy();
+                        this.textChannel.client.triviaManager.delete(
+                            this.textChannel.guildId
+                        );
+                    }
+                }
+            } else if (newState.status === AudioPlayerStatus.Playing) {
+                // trivia logic
+                let songNameFound = false;
+                let songSingerFound = false;
+
+                let skipCounter = 0;
+                const skippedArray = [];
+
+                const collector = this.textChannel.channel.createMessageCollector({
+                    time: 30000
+                });
+
+                collector.on('collect', msg => {
+                    if (!this.score.has(msg.author.username)) return;
+                    let guess = normalizeValue(msg.content);
+                    let title = normalizeValue(this.queue[0].title);
+                    let singer = normalizeValue(this.queue[0].singer);
+
+                    if (guess === 'skip') {
+                        if (skippedArray.includes(msg.author.username)) {
+                            return;
+                        }
+                        skippedArray.push(msg.author.username);
+                        skipCounter++;
+                        if (skipCounter > this.score.size * 0.6) {
+                            return collector.stop();
+                        }
+                        return;
+                    }
+
+                    // if user guessed both singer and song name
+                    if (guess.includes(singer) && guess.includes(title)) {
+                        if (
+                            (songSingerFound && !songNameFound) ||
+                            (songNameFound && !songSingerFound)
+                        ) {
+                            this.score.set(
+                                msg.author.username,
+                                this.score.get(msg.author.username) + 1
+                            );
+                            msg.react('☑');
+                            return collector.stop();
+                        }
+                        this.score.set(
+                            msg.author.username,
+                            this.score.get(msg.author.username) + 2
+                        );
+                        msg.react('☑');
+                        return collector.stop();
+                    }
+                    // if user guessed only the singer
+                    else if (guess.includes(singer)) {
+                        if (songSingerFound) return; // already been found
+                        songSingerFound = true;
+                        if (songNameFound && songSingerFound) {
+                            this.score.set(
+                                msg.author.username,
+                                this.score.get(msg.author.username) + 1
+                            );
+                            msg.react('☑');
+                            return collector.stop();
+                        }
+
+                        this.score.set(
+                            msg.author.username,
+                            this.score.get(msg.author.username) + 1
+                        );
+                        msg.react('☑');
+                    }
+                    // if user guessed song name
+                    else if (guess.includes(title)) {
+                        if (songNameFound) return; // if song name has already been found
+                        songNameFound = true;
+
+                        if (songNameFound && songSingerFound) {
+                            this.score.set(
+                                msg.author.username,
+                                this.score.get(msg.author.username) + 1
+                            );
+                            msg.react('☑');
+                            return collector.stop();
+                        }
+                        this.score.set(
+                            msg.author.username,
+                            this.score.get(msg.author.username) + 1
+                        );
+                        msg.react('☑');
+                    } else {
+                        // wrong answer
+                        return msg.react('❌');
+                    }
+                });
+
+                collector.on('end', () => {
+                    /*
+                      The reason for this if statement is that we don't want to get an
+                      empty embed returned via chat by the bot if end-trivia command was called
+                      */
+                    if (this.wasTriviaEndCalled) {
+                        this.wasTriviaEndCalled = false;
+                        return;
+                    }
+
+                    this.audioPlayer.stop();
+
+                    const sortedScoreMap = new Map(
+                        [...this.score.entries()].sort(function (a, b) {
+                            return b[1] - a[1];
+                        })
+                    );
+
+                    const song = `${capitalize_Words(
+                        this.queue[0].singer
+                    )}: ${capitalize_Words(this.queue[0].title)}`;
+
+                    this.textChannel.client.embed({
+                        title: `🎶・Music Quiz`,
+                        desc: `The song was:  ${song} \n\n${getLeaderBoard(Array.from(sortedScoreMap.entries()))}`,
+                        edit: true
+                    }, this.textChannel)
+                    return;
+                });
+            }
+        });
+
+        this.audioPlayer.on('error', error => {
+            console.error(error);
+        });
+
+        this.connection.subscribe(this.audioPlayer);
+    }
+
+    stop() {
+        this.queue.length = 0;
+        this.audioPlayer.stop(true);
+    }
+
+    async process(queue) {
+        const song = this.queue[0];
+        try {
+            const stream = ytdl(song.url, {
+                filter: 'audio',
+                quality: 'highestaudio',
+                highWaterMark: 1 << 25
+            });
+            const resource = createAudioResource(stream, {
+                inputType: StreamType.Arbitrary
+            });
+            this.audioPlayer.play(resource);
+        } catch (err) {
+            console.error(err);
+            return this.process(queue);
+        }
+    }
+}
+
+var getLeaderBoard = arr => {
+    if (!arr) return;
+    if (!arr[0]) return;
+    let leaderBoard = '';
+
+    leaderBoard = `👑   **${arr[0][0]}:** ${arr[0][1]}  points`;
+
+    if (arr.length > 1) {
+        for (let i = 1; i < arr.length; i++) {
+            leaderBoard =
+                leaderBoard + `\n\n   ${i + 1}: ${arr[i][0]}: ${arr[i][1]}  points`;
+        }
+    }
+    return leaderBoard;
+};
+
+var capitalize_Words = str => {
+    return str.replace(/\w\S*/g, function (txt) {
+        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+    });
+};
+
+var normalizeValue = value =>
+    value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '') // remove diacritics
+        .replace(/[^0-9a-zA-Z\s]/g, '') // remove non-alphanumeric characters
+        .trim()
+        .replace(/\s+/g, ' ')
+        .toLowerCase(); // remove duplicate spaces
+
+module.exports = TriviaPlayer;

src/assets/utils/forhumans.js

@@ -0,0 +1,26 @@
+function forHumans(o) {
+  for (
+    var r = [
+      [Math.floor(o / 31536e3), "years"],
+      [Math.floor((o % 31536e3) / 86400), "days"],
+      [Math.floor(((o % 31536e3) % 86400) / 3600), "hours"],
+      [Math.floor((((o % 31536e3) % 86400) % 3600) / 60), "minutes"],
+      [(((o % 31536e3) % 86400) % 3600) % 60, "seconds"],
+    ],
+    e = "",
+    t = 0,
+    s = r.length;
+    t < s;
+    t++
+  )
+    0 !== r[t][0] &&
+      (e +=
+        " " +
+        r[t][0] +
+        " " +
+        (1 === r[t][0] ? r[t][1].substr(0, r[t][1].length - 1) : r[t][1]));
+  return e.trim();
+}
+
+module.exports = forHumans;
+

src/assets/utils/static.js

@@ -0,0 +1,11 @@
+module.exports.defaultPFP = 'https://cdn.discordapp.com/embed/avatars/0.png';
+
+module.exports.DummyUser = {
+    bot: false,
+    id: '00000000000',
+    tag: "Unknown User#0000",
+    name: "Unknown User",
+    username: "Unknown User",
+    hexAccentColor: "#FFFFFF",
+    avatarURL: () => 'https://cdn.discordapp.com/embed/avatars/0.png'
+}

src/bot.js

@@ -0,0 +1,160 @@
+const Discord = require('discord.js');
+const fs = require('fs');
+
+const { Manager } = require("erela.js");
+const Spotify = require("erela.js-spotify");
+const Facebook = require("erela.js-facebook");
+const Deezer = require("erela.js-deezer");
+const AppleMusic = require("erela.js-apple");
+
+// Discord client
+const client = new Discord.Client({
+    allowedMentions: {
+        parse: [
+            'users',
+            'roles'
+        ],
+        repliedUser: true
+    },
+    autoReconnect: true,
+    disabledEvents: [
+        "TYPING_START"
+    ],
+    partials: [
+        'USER',
+        'CHANNEL',
+        'GUILD_MEMBER',
+        'MESSAGE',
+        'REACTION',
+        'GUILD_SCHEDULED_EVENT'
+    ],
+    intents: [
+        Discord.Intents.FLAGS.GUILDS,
+        Discord.Intents.FLAGS.GUILD_MEMBERS,
+        Discord.Intents.FLAGS.GUILD_BANS,
+        Discord.Intents.FLAGS.GUILD_EMOJIS_AND_STICKERS,
+        Discord.Intents.FLAGS.GUILD_INTEGRATIONS,
+        Discord.Intents.FLAGS.GUILD_WEBHOOKS,
+        Discord.Intents.FLAGS.GUILD_INVITES,
+        Discord.Intents.FLAGS.GUILD_VOICE_STATES,
+        Discord.Intents.FLAGS.GUILD_MESSAGES,
+        Discord.Intents.FLAGS.GUILD_MESSAGE_REACTIONS,
+        Discord.Intents.FLAGS.GUILD_MESSAGE_TYPING,
+        Discord.Intents.FLAGS.DIRECT_MESSAGES,
+        Discord.Intents.FLAGS.DIRECT_MESSAGE_REACTIONS,
+        Discord.Intents.FLAGS.DIRECT_MESSAGE_TYPING,
+        Discord.Intents.FLAGS.GUILD_SCHEDULED_EVENTS,
+    ],
+    restTimeOffset: 0
+});
+
+
+const clientID = "";
+const clientSecret = "";
+
+// Lavalink client
+client.player = new Manager({
+    plugins: [
+        new AppleMusic(),
+        new Deezer(),
+        new Facebook(),
+        new Spotify({
+            clientID,
+            clientSecret,
+            playlistLimit: 100,
+            albumLimit: 100
+        })
+    ],
+    nodes: [
+        {
+            host: "",
+            port: 2333,
+            password: "",
+        },
+    ],
+    send(id, payload) {
+        const guild = client.guilds.cache.get(id);
+        if (guild) guild.shard.send(payload);
+    },
+})
+
+const events = fs.readdirSync(`./src/events/music`).filter(files => files.endsWith('.js'));
+
+for (const file of events) {
+    const event = require(`./events/music/${file}`);
+    client.player.on(file.split(".")[0], event.bind(null, client)).setMaxListeners(0);
+};
+
+// Connect to database
+require("./database/connect")();
+
+// Client settings
+client.config = require('./config/bot');
+client.changelogs = require('./config/changelogs');
+client.emotes = require("./config/emojis.json");
+client.webhooks = require("./config/webhooks.json");
+client.commands = new Discord.Collection();
+client.playerManager = new Map();
+client.triviaManager = new Map();
+client.queue = new Map();
+
+// Webhooks
+const consoleLogs = new Discord.WebhookClient({
+    id: client.webhooks.consoleLogs.id,
+    token: client.webhooks.consoleLogs.token,
+});
+
+const warnLogs = new Discord.WebhookClient({
+    id: client.webhooks.warnLogs.id,
+    token: client.webhooks.warnLogs.token,
+});
+
+// Load handlers
+fs.readdirSync('./src/handlers').forEach((dir) => {
+    fs.readdirSync(`./src/handlers/${dir}`).forEach((handler) => {
+        require(`./handlers/${dir}/${handler}`)(client);
+    });
+});
+
+client.login(process.env.DISCORD_TOKEN);
+
+process.on('unhandledRejection', error => {
+    const embed = new Discord.MessageEmbed()
+        .setTitle(`🚨・Unhandled promise rejection`)
+        .addField(`Error`, `\`\`\`${error}\`\`\``)
+        .addField(`Stack error`, `\`\`\`${error.stack}\`\`\``)
+        .setColor(client.config.colors.normal)
+    consoleLogs.send({
+        username: 'Bot Logs',
+        embeds: [embed],
+    }).catch(() => {
+        console.log(error)
+    })
+});
+
+process.on('warning', warn => {
+    const embed = new Discord.MessageEmbed()
+        .setTitle(`🚨・New warning found`)
+        .addField(`Warn`, `\`\`\`${warn}\`\`\``)
+        .setColor(client.config.colors.normal)
+    warnLogs.send({
+        username: 'Bot Logs',
+        embeds: [embed],
+    }).catch(() => {
+
+    })
+});
+
+client.on('shardError', error => {
+    const embed = new Discord.MessageEmbed()
+        .setTitle(`🚨・A websocket connection encountered an error`)
+        .addField(`Error`, `\`\`\`${error}\`\`\``)
+        .addField(`Stack error`, `\`\`\`${error.stack}\`\`\``)
+        .setColor(client.config.colors.normal)
+    consoleLogs.send({
+        username: 'Bot Logs',
+        embeds: [embed],
+    });
+});
+
+ 

src/commands/afk/list.js

@@ -0,0 +1,18 @@
+const Discord = require('discord.js');
+
+const Schema = require('../../database/models/afk');
+
+module.exports = async (client, interaction, args) => {
+    const rawboard = await Schema.find({ Guild: interaction.guild.id })
+
+    if (rawboard.length < 1) return client.errNormal({ 
+        error: "No data found!",
+        type: 'editreply'
+    }, interaction);
+
+    const lb = rawboard.map(e => `<@!${e.User}> - **Reason** ${e.Message}`);
+
+    await client.createLeaderboard(`🚫・AFK users - ${interaction.guild.name}`, lb, interaction);
+}
+
+ 

src/commands/afk/set.js

@@ -0,0 +1,38 @@
+const Discord = require('discord.js');
+
+const Schema = require('../../database/models/afk');
+
+module.exports = async (client, interaction, args) => {
+    const reason = interaction.options.getString('reason') || `Not specified`;
+
+    Schema.findOne({ Guild: interaction.guild.id, User: interaction.user.id }, async (err, data) => {
+        if (data) {
+            return client.errNormal({ 
+                error: `You're already afk!`,
+                type: 'editreply' 
+            }, interaction);
+        }
+        else {
+            new Schema({
+                Guild: interaction.guild.id,
+                User: interaction.user.id,
+                Message: reason
+            }).save();
+
+            if (!interaction.member.displayName.includes(`[AFK] `)) {
+                interaction.member.setNickname(`[AFK] ` + interaction.member.displayName).catch(e => { });
+            }
+
+            client.succNormal({ 
+                text: `Your AFK has been set up succesfully`,
+                type: 'ephemeral'
+            }, interaction);
+
+            client.embed({ 
+                desc: `${interaction.user} is now afk! **Reason:** ${reason}` 
+            }, interaction.channel)
+        }
+    })
+}
+
+ 

src/commands/announcement/create.js

@@ -0,0 +1,24 @@
+const Discord = require('discord.js');
+
+module.exports = async (client, interaction, args) => {
+    const message = interaction.options.getString('message');
+    const channel = interaction.options.getChannel('channel');
+
+    client.embed({ 
+        title: `📢・Announcement!`, 
+        desc: message 
+    }, channel);
+
+    client.succNormal({
+        text: `Announcement has been sent successfully!`,
+        fields: [
+            {
+                name: `📘┆Channel`,
+                value: `${channel} (${channel.name})`
+            }
+        ],
+        type: 'editreply'
+    }, interaction);
+}
+
+ 

src/commands/announcement/edit.js

@@ -0,0 +1,21 @@
+const Discord = require('discord.js');
+
+module.exports = async (client, interaction, args) => {
+    const message = interaction.options.getString('message');
+    const messageId = interaction.options.getString('id');
+
+    const editMessage = await interaction.channel.messages.fetch(messageId);
+
+    client.embed({ 
+        title: `📢・Announcement!`, 
+        desc: message,
+        type: 'edit'
+    }, editMessage);
+
+    client.succNormal({
+        text: `Announcement has been edit successfully!`,
+        type: 'ephemeraledit'
+    }, interaction);
+}
+
+ 

src/commands/automod/add.js

@@ -0,0 +1,43 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/blacklist");
+const { blacklistedWords } = require("../../Collection");
+
+module.exports = async (client, interaction, args) => {
+    const word = interaction.options.getString('word');
+
+    Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+        if (data) {
+            if (data.Words.includes(word)) {
+                return client.errNormal({ 
+                    error: `That word is already exists in the database!`,
+                    type: 'editreply' 
+                }, interaction);
+            }
+            data.Words.push(word);
+            data.save();
+            blacklistedWords.get(interaction.guild.id).push(word);
+        }
+        else {
+            new Schema({
+                Guild: interaction.guild.id,
+                Words: word
+            }).save();
+
+            blacklistedWords.set(interaction.guild.id, [word]);
+        }
+    })
+
+    client.succNormal({
+        text: `Word is now blacklisted!`,
+        fields: [
+            {
+                name: `💬┆Word`,
+                value: `${word}`
+            }
+        ],
+        type: 'editreply'
+    }, interaction);
+}
+
+ 

src/commands/automod/antiinvite.js

@@ -0,0 +1,26 @@
+const Discord = require('discord.js');
+
+const Schema = require('../../database/models/functions');
+
+module.exports = async (client, interaction, args) => {
+    const boolean = interaction.options.getBoolean('active');
+
+    const data = await Schema.findOne({ Guild: interaction.guild.id });
+    if (data) {
+        data.AntiInvite = boolean;
+        data.save();
+    }
+    else {
+        new Schema({
+            Guild: interaction.guild.id,
+            AntiInvite: boolean,
+        }).save();
+    }
+
+    client.succNormal({
+        text: `Anti invite is now **${boolean ? 'enabled' : 'disabled'}** in this guild`,
+        type: 'editreply'
+    }, interaction);
+}
+
+ 

src/commands/automod/antilinks.js

@@ -0,0 +1,26 @@
+const Discord = require('discord.js');
+
+const Schema = require('../../database/models/functions');
+
+module.exports = async (client, interaction, args) => {
+    const boolean = interaction.options.getBoolean('active');
+
+    const data = await Schema.findOne({ Guild: interaction.guild.id });
+    if (data) {
+        data.AntiLinks = boolean;
+        data.save();
+    }
+    else {
+        new Schema({
+            Guild: interaction.guild.id,
+            AntiLinks: boolean,
+        }).save();
+    }
+
+    client.succNormal({
+        text: `Anti links is now **${boolean ? 'enabled' : 'disabled'}** in this guild`,
+        type: 'editreply'
+    }, interaction);
+}
+
+ 

src/commands/automod/antispam.js

@@ -0,0 +1,26 @@
+const Discord = require('discord.js');
+
+const Schema = require('../../database/models/functions');
+
+module.exports = async (client, interaction, args) => {
+    const boolean = interaction.options.getBoolean('active');
+
+    const data = await Schema.findOne({ Guild: interaction.guild.id });
+    if (data) {
+        data.AntiSpam = boolean;
+        data.save();
+    }
+    else {
+        new Schema({
+            Guild: interaction.guild.id,
+            AntiSpam: boolean,
+        }).save();
+    }
+
+    client.succNormal({
+        text: `Anti spam is now **${boolean ? 'enabled' : 'disabled'}** in this guild`,
+        type: 'editreply'
+    }, interaction);
+}
+
+ 

src/commands/automod/display.js

@@ -0,0 +1,24 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/blacklist");
+const { blacklistedWords } = require("../../Collection");
+
+module.exports = async (client, interaction, args) => {
+    Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+        if (data && data.Words.length > 0) {
+            client.embed({
+                title: "🤬・Blacklisted words",
+                desc: data.Words.join(", "),
+                type: 'editreply'
+            }, interaction)
+        }
+        else {
+            client.errNormal({
+                error: `This guild has not data!`,
+                type: 'editreply'
+            }, interaction);
+        }
+    })
+}
+
+ 

src/commands/automod/linkschannel.js

@@ -0,0 +1,80 @@
+const Discord = require('discord.js');
+
+const Schema = require('../../database/models/channelList');
+
+module.exports = async (client, interaction, args) => {
+    const type = interaction.options.getString('type');
+    const channel = interaction.options.getChannel('channel');
+
+    if (type == "add") {
+        Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+            if (data) {
+                if (data.Channels.includes(channel.id)) {
+                    return client.errNormal({
+                        error: `The channel ${channel} is already in the database!`,
+                        type: 'editreply'
+                    }, interaction);
+                }
+
+                data.Channels.push(channel.id);
+                data.save();
+            }
+            else {
+                new Schema({
+                    Guild: interaction.guild.id,
+                    Channels: channel.id
+                }).save();
+            }
+        })
+
+        client.succNormal({
+            text: `Channel has been added to the whitelist!`,
+            fields: [
+                {
+                    name: `📘┆Channel`,
+                    value: `${channel} (${channel.name})`
+                }
+            ],
+            type: 'editreply'
+        }, interaction);
+    }
+    else if (type == "remove") {
+        Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+            if (data) {
+                if (!data.Channels.includes(channel.id)) {
+                    return client.errNormal({
+                        error: `The channel ${channel} doesn't exist in the database!`,
+                        type: 'editreply'
+                    }, interaction);
+                }
+
+                const filtered = data.Channels.filter((target) => target !== channel.id);
+
+                await Schema.findOneAndUpdate({ Guild: interaction.guild.id }, {
+                    Guild: interaction.guild.id,
+                    Channels: filtered
+                });
+
+
+                client.succNormal({
+                    text: `Channel has been removed from the whitelist!`,
+                    fields: [
+                        {
+                            name: `📘┆Channel`,
+                            value: `${channel} (${channel.name})`
+                        }
+                    ],
+                    type: 'editreply'
+                }, interaction);
+            }
+            else {
+                return client.errNormal({
+                    error: `This guild has not data!`,
+                    type: 'editreply'
+                }, interaction);
+            }
+        })
+    }
+}
+
+ 

src/commands/automod/remove.js

@@ -0,0 +1,47 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/blacklist");
+const { blacklistedWords } = require("../../Collection");
+
+module.exports = async (client, interaction, args) => {
+    const word = interaction.options.getString('word');
+
+    Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+        if (data) {
+            if (!data.Words.includes(word)) {
+                return client.errNormal({
+                    error: `That word doesn't exist in the database!`,
+                    type: 'editreply'
+                }, interaction);
+            }
+
+            const filtered = data.Words.filter((target) => target !== word);
+
+            await Schema.findOneAndUpdate({ Guild: interaction.guild.id }, {
+                Guild: interaction.guild.id,
+                Words: filtered
+            });
+
+            blacklistedWords.set(interaction.guild.id, filtered)
+
+            client.succNormal({
+                text: `Word is removed from the blacklist!`,
+                fields: [
+                    {
+                        name: `💬┆Word`,
+                        value: `${word}`
+                    }
+                ],
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+            client.errNormal({
+                error: `This guild has not data!`,
+                type: 'editreply'
+            }, interaction);
+        }
+    })
+}
+
+ 

src/commands/autosetup/customvoice.js

@@ -0,0 +1,50 @@
+const Discord = require('discord.js');
+
+const voiceSchema = require("../../database/models/voice");
+
+module.exports = async (client, interaction, args) => {
+    interaction.guild.channels.create("Custom voice", {
+        type: "GUILD_CATEGORY"
+    }).then((cat) => {
+        interaction.guild.channels.create("➕ Create Voice", {
+            type: "GUILD_VOICE",
+            parent: cat.id,
+            permissionOverwrites: [
+                {
+                    deny: 'SPEAK',
+                    id: interaction.guild.id
+                },
+            ],
+        }).then((ch) => {
+            voiceSchema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+                if (data) {
+                    data.Category = cat.id;
+                    data.Channel = ch.id
+                    data.ChannelName = "{emoji} {channel name}"
+                    data.save();
+                }
+                else {
+                    new voiceSchema({
+                        Guild: interaction.guild.id,
+                        Channel: ch.id,
+                        ChannelName: "{emoji} {channel name}",
+                        Category: cat.id
+                    }).save();
+                }
+            });
+
+            client.succNormal({
+                text: `Custom voice has been set up successfully!`,
+                fields: [
+                    {
+                        name: `📘┆Channel`,
+                        value: `${ch} (${ch.name})`
+                    }
+                ],
+                type: 'editreply'
+            }, interaction);
+        })
+    })
+}
+
+ 

src/commands/autosetup/fun.js

@@ -0,0 +1,53 @@
+const Discord = require('discord.js');
+
+const Birthdays = require("../../database/models/birthdaychannels");
+const Chatbot = require("../../database/models/chatbot-channel");
+const Review = require("../../database/models/reviewChannels");
+const Suggestion = require("../../database/models/suggestionChannels");
+const StarBoard = require("../../database/models/starboardChannels");
+
+module.exports = async (client, interaction, args) => {
+    const choice = interaction.options.getString('setup');
+
+    if (choice == "birthdays") {
+        interaction.guild.channels.create("birthdays", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(Birthdays, ch, interaction)
+        })
+    }
+
+    if (choice == "chatbot") {
+        interaction.guild.channels.create("chatbot", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(Chatbot, ch, interaction)
+        })
+    }
+
+    if (choice == "reviews") {
+        interaction.guild.channels.create("reviews", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(Review, ch, interaction)
+        })
+    }
+
+    if (choice == "suggestions") {
+        interaction.guild.channels.create("suggestions", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(Suggestion, ch, interaction)
+        })
+    }
+
+    if (choice == "starboard") {
+        interaction.guild.channels.create("starboard", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(StarBoard, ch, interaction)
+        })
+    }
+}
+
+ 

src/commands/autosetup/games.js

@@ -0,0 +1,68 @@
+const Discord = require('discord.js');
+
+const Counting = require("../../database/models/countChannel");
+const GTN = require("../../database/models/guessNumber");
+const GTW = require("../../database/models/guessWord");
+const WordSnake = require("../../database/models/wordsnake");
+
+module.exports = async (client, interaction, args) => {
+    const choice = interaction.options.getString('setup');
+
+    if (choice == "counting") {
+        interaction.guild.channels.create("counting", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.embed({
+                title: `🔢・Counting`,
+                desc: `This is the start of counting! The first number is **1**`
+            }, ch)
+
+            client.createChannelSetup(Counting, ch, interaction)
+        })
+    }
+
+    if (choice == "gtn") {
+        interaction.guild.channels.create("guess-the-number", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.embed({ 
+                title: `🔢・Guess the number`,
+                desc: `Guess the number between **1** and **10.000**!`
+            }, ch)
+
+            client.createChannelSetup(GTN, ch, interaction)
+        })
+    }
+
+    if (choice == "gtw") {
+        interaction.guild.channels.create("guess-the-word", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            var word = "start";
+            var shuffled = word.split('').sort(function () { return 0.5 - Math.random() }).join('');
+
+            client.embed({ 
+                title: `💬・Guess the word`,
+                desc: `Put the letters in the right position!`,
+                fields: [
+                    {
+                        name: `🔀┆Word`,
+                        value: `${shuffled.toLowerCase()}`
+                    }
+                ],
+            }, ch)
+            
+            client.createChannelSetup(GTW, ch, interaction)
+        })
+    }
+
+    if (choice == "wordsnake") {
+        interaction.guild.channels.create("word-snake", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(WordSnake, ch, interaction)
+        })
+    }
+}
+
+ 

src/commands/autosetup/logs.js

@@ -0,0 +1,41 @@
+const Discord = require('discord.js');
+
+const logs = require("../../database/models/logChannels");
+const boostLogs = require("../../database/models/boostChannels");
+const levelLogs = require("../../database/models/levelChannels");
+
+module.exports = async (client, interaction, args) => {
+    const choice = interaction.options.getString('setup');
+
+    if (choice == "serverLogs") {
+        interaction.guild.channels.create("server-logs", {
+            permissionOverwrites: [
+                {
+                    deny: 'VIEW_CHANNEL',
+                    id: interaction.guild.id
+                },
+            ],
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(logs, ch, interaction)
+        })
+    }
+
+    if (choice == "levelLogs") {
+        interaction.guild.channels.create("level-logs", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(levelLogs, ch, interaction)
+        })
+    }
+
+    if (choice == "boostLogs") {
+        interaction.guild.channels.create("boosts", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(boostLogs, ch, interaction)
+        })
+    }
+}
+
+ 

src/commands/autosetup/ticketpanel.js

@@ -0,0 +1,38 @@
+const Discord = require('discord.js');
+
+const ticketSchema = require("../../database/models/tickets");
+
+module.exports = async (client, interaction, args) => {
+    ticketSchema.findOne({ Guild: interaction.guild.id }, async (err, ticketData) => {
+        if (ticketData) {
+            const channel = interaction.guild.channels.cache.get(ticketData.Channel);
+            const button = new Discord.MessageButton()
+                .setCustomId('Bot_openticket')
+                .setLabel("Tickets")
+                .setStyle('PRIMARY')
+                .setEmoji('🎫')
+
+            const row = new Discord.MessageActionRow()
+                .addComponents(button)
+
+            client.embed({
+                title: "Tickets",
+                desc: "Click on 🎫 to open a ticket",
+                components: [row]
+            }, channel)
+
+            client.succNormal({
+                text: `Ticket panel has been set up successfully!`,
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+            client.errNormal({
+                error: `Run the ticket setup first!`,
+                type: 'editreply'
+            }, interaction);
+        }
+    })
+}
+
+ 

src/commands/autosetup/welcome.js

@@ -0,0 +1,36 @@
+const Discord = require('discord.js');
+
+const welcomeChannel = require("../../database/models/welcomeChannels");
+const welcomeRole = require("../../database/models/joinRole");
+const leaveChannel = require("../../database/models/leaveChannels");
+
+module.exports = async (client, interaction, args) => {
+    const choice = interaction.options.getString('setup');
+
+    if (choice == "welcomechannel") {
+        interaction.guild.channels.create("Welcome", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(welcomeChannel, ch, interaction)
+        })
+    }
+
+    if (choice == "welcomerole") {
+        interaction.guild.roles.create({
+            name: 'Member',
+            color: client.config.colors.normal
+        }).then((rl) => {
+            client.createRoleSetup(welcomeRole, rl, interaction)
+        })
+    }
+
+    if (choice == "leavechannel") {
+        interaction.guild.channels.create("Bye", {
+            type: "GUILD_TEXT"
+        }).then((ch) => {
+            client.createChannelSetup(leaveChannel, ch, interaction)
+        })
+    }
+}
+
+ 

src/commands/birthdays/check.js

@@ -0,0 +1,20 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/birthday");
+
+module.exports = async (client, interaction, args) => {
+    Schema.findOne({ Guild: interaction.guild.id, User: interaction.user.id }, async (err, data) => {
+        if (!data) return client.errNormal({ 
+            error: "No birthday found!",
+            type: 'editreply' 
+        }, interaction);
+
+        client.embed({ 
+            title: `${client.emotes.normal.birthday}・Birthday check`, 
+            desc: `${interaction.user.username} birthday is on ${data.Birthday}`,
+            type: 'editreply'
+        }, interaction)
+    })
+}
+
+ 

src/commands/birthdays/delete.js

@@ -0,0 +1,21 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/birthday");
+
+module.exports = async (client, interaction, args) => {
+    Schema.findOne({ Guild: interaction.guild.id, User: interaction.user.id }, async (err, data) => {
+        if (!data) return client.errNormal({ 
+            error: "No birthday found!",
+            type: 'editreply' 
+        }, interaction);
+
+        Schema.findOneAndDelete({ Guild: interaction.guild.id, User: interaction.user.id }).then(() => {
+            client.succNormal({ 
+                text: "Deleted your birthday", 
+                type: 'editreply' 
+            }, interaction)
+        })
+    })
+}
+
+ 

src/commands/birthdays/list.js

@@ -0,0 +1,18 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/birthday");
+
+module.exports = async (client, interaction, args) => {
+    const rawBirthdayboard = await Schema.find({ Guild: interaction.guild.id })
+
+    if (rawBirthdayboard.length < 1) return client.errNormal({ 
+        error: "No birthdays found!",
+        type: 'editreply' 
+    }, interaction);
+
+    const lb = rawBirthdayboard.map(e => `${client.emotes.normal.birthday} | **<@!${e.User}>** - ${e.Birthday} `);
+
+    await client.createLeaderboard(`🎂・Birthdays - ${interaction.guild.name}`, lb, interaction);
+}
+
+ 

src/commands/birthdays/set.js

@@ -0,0 +1,75 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/birthday");
+
+module.exports = async (client, interaction, args) => {
+    const months = {
+        1: "January",
+        2: "February",
+        3: "March",
+        4: "April",
+        5: "May",
+        6: "June",
+        7: "July",
+        8: "August",
+        9: "September",
+        10: "October",
+        11: "November",
+        12: "December"
+    };
+
+    const day = interaction.options.getNumber('day');
+    const month = interaction.options.getNumber('month');
+
+    if (!day || day > 31) return client.errNormal({ 
+        error: "Wrong day format!",
+        type: 'editreply'
+    }, interaction);
+
+    if (!month || month > 12) return client.errNormal({
+        error: "Wrong month format!",
+        type: 'editreply'
+    }, interaction);
+
+    const convertedDay = suffixes(day);
+    const convertedMonth = months[month];
+    const birthdayString = `${convertedDay} of ${convertedMonth}`;
+
+    Schema.findOne({ Guild: interaction.guild.id, User: interaction.user.id }, async (err, data) => {
+        if (data) {
+            data.Birthday = birthdayString;
+            data.save();
+        }
+        else {
+            new Schema({
+                Guild: interaction.guild.id,
+                User: interaction.user.id,
+                Birthday: birthdayString
+            }).save();
+        }
+    })
+
+    client.succNormal({ 
+        text: `Birthday has been set successfully`,
+        fields: [
+            {
+                name: `${client.emotes.normal.birthday}┆Birthday`,
+                value: `${birthdayString}`
+            }
+        ],
+        type: 'editreply'
+    }, interaction);
+}
+
+function suffixes(number) {
+    const converted = number.toString();
+
+    const lastChar = converted.charAt(converted.length - 1);
+
+    return lastChar == "1" ?
+        `${converted}st` : lastChar == "2" ?
+            `${converted}nd` : lastChar == '3'
+                ? `${converted}rd` : `${converted}th`
+}
+
+ 

src/commands/bot/changelogs.js

@@ -0,0 +1,18 @@
+const Discord = require('discord.js');
+
+module.exports = async (client, interaction, args) => {
+    client.embed({
+        title: "📃・Changelogs",
+        desc: `_____`,
+        thumbnail: client.user.avatarURL({ size: 1024 }),
+        fields: [{
+                name: "📢┆Alert!",
+                value: 'After more than 1 year we decided to stop Bot on April 15th, for more information go to [this server](https://discord.gg/techpoint)',
+                inline: false,
+            },
+        ],
+        type: 'editreply'
+    }, interaction)
+}
+
+ 

src/commands/bot/donate.js

@@ -0,0 +1,22 @@
+const Discord = require('discord.js');
+
+module.exports = async (client, interaction, args) => {
+    let row = new Discord.MessageActionRow()
+        .addComponents(
+            new Discord.MessageButton()
+                .setLabel("Donatebot")
+                .setURL("https://donatebot.io/checkout/735868402194710530")
+                .setStyle("LINK"),
+        );
+
+    client.embed({
+        title: `${client.user.username}・Donate`,
+        desc: '_____ \n\nClick the button below for the donation page \n**Pay attention! Donating is not required**',
+        thumbnail: client.user.avatarURL({ dynamic: true }),
+        url: "https://donatebot.io/checkout/735868402194710530",
+        components: [row],
+        type: 'editreply'
+    }, interaction)
+}
+
+ 

src/commands/bot/feedback.js

@@ -0,0 +1,27 @@
+const Discord = require('discord.js');
+
+const webhookClient = new Discord.WebhookClient({
+    id: "831574783324848188",
+    token: "UMFd7fPeeV7sHewjglLuAyM1819qA6AG8_-8VcIcA-bveVODYXy9Hko3pe0sWWgz9oDa",
+});
+
+module.exports = async (client, interaction, args) => {
+    const feedback = interaction.options.getString('feedback');
+
+    const embed = new Discord.MessageEmbed()
+        .setTitle(`📝・New feedback!`)
+        .addField("User", `${interaction.user} (${interaction.user.tag})`)
+        .setDescription(`${feedback}`)
+        .setColor(client.config.colors.normal)
+    webhookClient.send({
+        username: 'Bot Feedback',
+        embeds: [embed],
+    });
+
+    client.succNormal({ 
+        text: `Feedback successfully sent to the developers`,
+        type: 'editreply'
+    }, interaction);
+}
+
+ 

src/commands/bot/info.js

@@ -0,0 +1,146 @@
+const Discord = require('discord.js');
+const moment = require("moment");
+require("moment-duration-format");
+
+module.exports = async (client, interaction, args) => {
+    const promises = [
+        client.shard.broadcastEval(client => client.guilds.cache.size),
+        client.shard.broadcastEval(client => client.guilds.cache.reduce((acc, guild) => acc + guild.memberCount, 0)),
+        client.shard.broadcastEval(client => client.channels.cache.size),
+        client.shard.broadcastEval(client => client.voice.adapters.size)
+    ];
+    return Promise.all(promises)
+        .then(async results => {
+            const totalGuilds = results[0].reduce((acc, guildCount) => acc + guildCount, 0);
+            const totalMembers = results[1].reduce((acc, memberCount) => acc + memberCount, 0);
+            const totalChannels = results[2].reduce((acc, channelCount) => acc + channelCount, 0);
+            const totalVoice = results[3].reduce((acc, voiceCount) => acc + voiceCount, 0);
+
+            const duration = moment.duration(client.uptime).format("\`D\` [days], \`H\` [hrs], \`m\` [mins], \`s\` [secs]");
+
+            client.embed({
+                title: `ℹ・Bot information`,
+                desc: `____________________________`,
+                thumbnail: client.user.avatarURL({ size: 1024 }),
+                fields: [{
+                name: "📢┆Alert!",
+                value: 'After more than 1 year we decided to stop Bot on April 15th, for more information go to [this server](https://discord.gg/techpoint)',
+                inline: false,
+               },
+               {
+                    name: "ℹ️┆Information",
+                    value: `Bot is a bot with which you can run your entire server! With no less than 350+ commands, we have a large bot with many options to improve your server!`,
+                    inline: false,
+                },
+                {
+                    name: "_____ \n\n│General",
+                    value: `_____`,
+                    inline: false,
+                },
+                {
+                    name: "🤖┆Bot name",
+                    value: `${client.user.username}`,
+                    inline: true,
+                },
+                {
+                    name: "🆔┆Bot id",
+                    value: `${client.user.id}`,
+                    inline: true,
+                },
+                {
+                    name: "💻┆Shards",
+                    value: `\`${client.options.shardCount}\` shards`,
+                    inline: true,
+                },
+                {
+                    name: "🔧┆Bot owner",
+                    value: `<@!534398298002292739> `,
+                    inline: true,
+                },
+                {
+                    name: "🔧┆Bot developer",
+                    value: `<@!402893517749354516>`,
+                    inline: true,
+                },
+                {
+                    name: "💻┆Commands",
+                    value: `\`${client.commands.size}\` commands`,
+                    inline: true,
+                },
+                {
+                    name: "🌐┆Servers",
+                    value: `\`${totalGuilds}\` servers`,
+                    inline: true,
+                },
+                {
+                    name: "🌐┆Servers this shard",
+                    value: `\`${client.guilds.cache.size}\` servers`,
+                    inline: true,
+                },
+                {
+                    name: "👥┆Members",
+                    value: `\`${totalMembers}\` members`,
+                    inline: true,
+                },
+                {
+                    name: "🔊┆Connected channels",
+                    value: `\`${totalVoice}\` channels`,
+                    inline: true,
+                },
+                {
+                    name: "📺┆Channels",
+                    value: `\`${totalChannels}\` channels`,
+                    inline: true,
+                },
+                {
+                    name: "📅┆Created",
+                    value: `<t:${Math.round(client.user.createdTimestamp / 1000)}>`,
+                    inline: true,
+                },
+
+                {
+                    name: "_____ \n\n│System",
+                    value: `_____`,
+                    inline: false,
+                },
+                {
+                    name: "🆙┆Uptime",
+                    value: `${duration}`,
+                    inline: true,
+                },
+                {
+                    name: "⌛┆API speed:",
+                    value: `\`${client.ws.ping}\`ms`,
+                    inline: true,
+                },
+                {
+                    name: "🏷┆Bot Version",
+                    value: `\`${require(`${process.cwd()}/package.json`).version}\``,
+                    inline: true,
+                },
+                {
+                    name: "🏷┆Node.js Version",
+                    value: `\`${process.version}\``,
+                    inline: true,
+                },
+                {
+                    name: "📂┆Discord.js Version",
+                    value: `\`${Discord.version}\``,
+                    inline: true,
+                },
+                {
+                    name: "💾┆Bot memory",
+                    value: `\`${(process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2)}\` MB`,
+                    inline: true,
+                },
+                {
+                    name: "🔗┆Links",
+                    value: `Add me: [[HERE]](${client.config.discord.botInvite}) \nSupport server: [[HERE]](${client.config.discord.serverInvite})`,
+                    inline: false,
+                }],
+                type: 'editreply'
+            }, interaction)
+        })
+}
+
+ 

src/commands/bot/links.js

@@ -0,0 +1,52 @@
+const Discord = require('discord.js');
+
+module.exports = async (client, interaction, args) => {
+    const row = new Discord.MessageActionRow()
+        .addComponents(
+            new Discord.MessageSelectMenu()
+                .setCustomId('Bot-linkspanel')
+                .setPlaceholder('❌┆Nothing selected')
+                .addOptions([
+                    {
+                        label: `Support server`,
+                        description: `Join the suppport server`,
+                        emoji: "❓",
+                        value: "support-linkspanel",
+                    },
+                    {
+                        label: `Invite Bot`,
+                        description: `Invite Bot to your server`,
+                        emoji: "📨",
+                        value: "invite-linkspanel",
+                    },
+                    {
+                        label: `Invite Bot 2`,
+                        description: `Invite Bot 2 to your server`,
+                        emoji: "📕",
+                        value: "invite2-linkspanel",
+                    },
+                    {
+                        label: `Community Server`,
+                        description: `Join the community server!`,
+                        emoji: "🌍",
+                        value: "community-linkspanel",
+                    },
+                    {
+                        label: `Top.gg`,
+                        description: `Show the top.gg link`,
+                        emoji: "📃",
+                        value: "top.gg-linkspanel",
+                    },
+                ]),
+        );
+
+    client.embed({
+        title: `🔗・Links`,
+        desc: `Get access to all Bot links! Choose the link you need in the menu below`,
+        image: "https://cdn.discordapp.com/attachments/843487478881976381/874694194474668052/Bot_banner_invite.jpg",
+        components: [row],
+        type: 'editreply'
+    }, interaction)
+}
+
+ 

src/commands/bot/owner.js

@@ -0,0 +1,32 @@
+const Discord = require('discord.js');
+
+module.exports = async (client, interaction, args) => {
+    client.embed({
+        title: `📘・Owner information`,
+        desc: `____________________________`,
+        thumbnail: client.user.avatarURL({ dynamic: true, size: 1024 }),
+        fields: [{
+            name: "👑┆Owner name",
+            value: `Corwinl`,
+            inline: true,
+        },
+        {
+            name: "🏷┆Discord tag",
+            value: `</Corwin>#0001`,
+            inline: true,
+        },
+        {
+            name: "🏢┆Organization",
+            value: `CorwinDev`,
+            inline: true,
+        },
+        {
+            name: "🌐┆Website",
+            value: `[https://corwindev.nl](https://corwindev.nl)`,
+            inline: true,
+        }],
+        type: 'editreply'
+    }, interaction)
+}
+
+ 

src/commands/bot/ping.js

@@ -0,0 +1,43 @@
+const Discord = require('discord.js');
+const mongoose = require('mongoose');
+
+module.exports = async (client, interaction, args) => {
+    client.simpleEmbed({
+        desc: `${client.emotes.animated.loading} Calculating ping...`,
+        type: 'editreply'
+    }, interaction).then((resultMessage) => {
+        const ping = Math.floor(resultMessage.createdTimestamp - interaction.createdTimestamp);
+
+        mongoose.connection.db.admin().ping(function (err, result) {
+
+            var mongooseSeconds = ((result.ok % 60000) / 1000);
+            var pingSeconds = ((ping % 60000) / 1000);
+            var apiSeconds = ((client.ws.ping % 60000) / 1000);
+
+            client.embed({
+                title: `${client.emotes.normal.pong}・Pong`,
+                desc: `Check out how fast our bot is`,
+                fields: [
+                    {
+                        name: "🤖┆Bot latency",
+                        value: `${ping}ms (${pingSeconds}s)`,
+                        inline: true,
+                    },
+                    {
+                        name: "💻┆API Latency",
+                        value: `${client.ws.ping}ms (${apiSeconds}s)`,
+                        inline: true,
+                    },
+                    {
+                        name: "📂┆Database Latency",
+                        value: `${result.ok}ms (${mongooseSeconds}s)`,
+                        inline: true,
+                    }
+                ],
+                type: 'editreply'
+            }, interaction)
+        })
+    })
+}
+
+ 

src/commands/bot/support.js

@@ -0,0 +1,22 @@
+const Discord = require('discord.js');
+
+module.exports = async (client, interaction, args) => {
+    let row = new Discord.MessageActionRow()
+        .addComponents(
+            new Discord.MessageButton()
+                .setLabel("Support server")
+                .setURL(client.config.discord.serverInvite)
+                .setStyle("LINK"),
+        );
+
+    client.embed({
+        title: `❓・Support`,
+        desc: `Make your server even better with Bot!`,
+        image: "https://cdn.discordapp.com/attachments/843487478881976381/874694194474668052/Bot_banner_invite.jpg",
+        url: client.config.discord.serverInvite,
+        components: [row],
+        type: 'editreply'
+    }, interaction)
+}
+
+ 

src/commands/bot/uptime.js

@@ -0,0 +1,28 @@
+const Discord = require('discord.js');
+const moment = require("moment");
+require("moment-duration-format");
+
+module.exports = async (client, interaction, args) => {
+    const duration = moment.duration(client.uptime).format("\`D\` [days], \`H\` [hrs], \`m\` [mins], \`s\` [secs]");
+    const upvalue = (Date.now() / 1000 - client.uptime / 1000).toFixed(0);
+
+    client.embed({
+        title: `${client.emotes.normal.arrowUp}・Uptime`,
+        desc: `See the uptime of Bot`,
+        fields: [
+            {
+                name: "⌛┇Uptime",
+                value: `${duration}`,
+                inline: true
+            },
+            {
+                name: "⏰┇Up Since",
+                value: `<t:${upvalue}>`,
+                inline: true
+            }
+        ],
+        type: 'editreply'
+    }, interaction)
+}
+
+ 

src/commands/bot/vote.js

@@ -0,0 +1,41 @@
+const Discord = require('discord.js');
+const Topgg = require(`@top-gg/sdk`);
+const moment = require("moment");
+require("moment-duration-format");
+
+module.exports = async (client, interaction, args) => {
+    let dbl = new Topgg.Api(process.env.TOPGG_TOKEN)
+
+    let row = new Discord.MessageActionRow()
+        .addComponents(
+            new Discord.MessageButton()
+                .setLabel("Vote for me")
+                .setURL("https://top.gg/bot/798144456528363550/vote")
+                .setStyle("LINK"),
+        );
+
+    dbl.hasVoted(interaction.user.id).then(voted => {
+        if (voted) {
+            client.embed({
+                title: `📨・Vote`,
+                desc: `You have voted!`,
+                image: `https://cdn.discordapp.com/attachments/843487478881976381/874694192755007509/Bot_banner_vote.jpg`,
+                color: client.config.colors.succes,
+                components: [row],
+                type: 'editreply'
+            }, interaction)
+        }
+        if (!voted) {
+            client.embed({
+                title: `📨・Vote`,
+                desc: `You have not voted!`,
+                image: `https://cdn.discordapp.com/attachments/843487478881976381/874694192755007509/Bot_banner_vote.jpg`,
+                color: client.config.colors.error,
+                components: [row],
+                type: 'editreply'
+            }, interaction)
+        }
+    }).catch(error => { client.errNormal({ text: `There was an error by checking this vote!`, editreply: true }, interaction) });
+}
+
+ 

src/commands/casino/blackjack.js

@@ -0,0 +1,327 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+    let user = interaction.user;
+
+    Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+        if (data) {
+            let money = parseInt(args[0]);
+
+            if (!money) return client.errUsage({ usage: "blackjack [amount]", type: 'editreply' }, interaction);
+            if (money > data.Money) return client.errNormal({ error: `You are betting more than you have!`, type: 'editreply' }, interaction);
+
+            var numCardsPulled = 0;
+            var gameOver = false;
+            var player = {
+                cards: [],
+                score: 0,
+            };
+            var dealer = {
+                cards: [],
+                score: 0,
+            };
+            function getCardsValue(a) {
+                var cardArray = [],
+                    sum = 0,
+                    i = 0,
+                    dk = 10.5,
+                    doubleking = "QQ",
+                    aceCount = 0;
+                cardArray = a;
+                for (i; i < cardArray.length; i += 1) {
+                    if (
+                        cardArray[i].rank === "J" ||
+                        cardArray[i].rank === "Q" ||
+                        cardArray[i].rank === "K"
+                    ) {
+                        sum += 10;
+                    } else if (cardArray[i].rank === "A") {
+                        sum += 11;
+                        aceCount += 1;
+                    } else if (cardArray[i].rank === doubleking) {
+                        sum += dk;
+                    } else {
+                        sum += cardArray[i].rank;
+                    }
+                }
+                while (aceCount > 0 && sum > 21) {
+                    sum -= 10;
+                    aceCount -= 1;
+                }
+                return sum;
+            }
+
+            var deck = {
+                deckArray: [],
+                initialize: function () {
+                    var suitArray, rankArray, s, r, n;
+                    suitArray = ["b", "d", "g", "s"];
+                    rankArray = [2, 3, 4, 5, 6, 7, 8, 9, 10, "J", "Q", "K", "A"];
+                    n = 13;
+
+                    for (s = 0; s < suitArray.length; s += 1) {
+                        for (r = 0; r < rankArray.length; r += 1) {
+                            this.deckArray[s * n + r] = {
+                                rank: rankArray[r],
+                                suit: suitArray[s],
+                            };
+                        }
+                    }
+                },
+                shuffle: function () {
+                    var temp, i, rnd;
+                    for (i = 0; i < this.deckArray.length; i += 1) {
+                        rnd = Math.floor(Math.random() * this.deckArray.length);
+                        temp = this.deckArray[i];
+                        this.deckArray[i] = this.deckArray[rnd];
+                        this.deckArray[rnd] = temp;
+                    }
+                },
+            };
+            deck.initialize();
+            deck.shuffle();
+            async function bet(outcome) {
+                if (outcome === "win") {
+                    data.Money += money;
+                    data.save();
+                }
+                if (outcome === "lose") {
+                    data.Money -= money;
+                    data.save();
+                }
+            }
+
+            function endMsg(f, msg, cl, dealerC) {
+                let cardsMsg = "";
+                player.cards.forEach(function (card) {
+                    var emAR = ["♥", "♦", "♠", "♣"];
+                    var t = emAR[Math.floor(Math.random() * emAR.length)];
+                    cardsMsg += t + card.rank.toString();
+                    if (card.suit == "d1") cardsMsg += "♥";
+                    if (card.suit == "d2") cardsMsg += "♦";
+                    if (card.suit == "d3") cardsMsg += "♠";
+                    if (card.suit == "d4") cardsMsg += "♣";
+                    cardsMsg;
+                });
+                cardsMsg += " > " + player.score.toString();
+
+                var dealerMsg = "";
+                if (!dealerC) {
+                    var emAR = ["♥", "♦", "♠", "♣"];
+                    var t = emAR[Math.floor(Math.random() * emAR.length)];
+                    dealerMsg = t + dealer.cards[0].rank.toString();
+                    if (dealer.cards[0].suit == "d1") dealerMsg += "♥";
+                    if (dealer.cards[0].suit == "d2") dealerMsg += "♦";
+                    if (dealer.cards[0].suit == "d3") dealerMsg += "♠";
+                    if (dealer.cards[0].suit == "d4") dealerMsg += "♣";
+                    dealerMsg;
+                } else {
+                    dealerMsg = "";
+                    dealer.cards.forEach(function (card) {
+                        var emAR = ["♥", "♦", "♠", "♣"];
+                        var t = emAR[Math.floor(Math.random() * emAR.length)];
+                        dealerMsg += t + card.rank.toString();
+                        if (card.suit == "d1") dealerMsg += "♥";
+                        if (card.suit == "d2") dealerMsg += "♦";
+                        if (card.suit == "d3") dealerMsg += "♠";
+                        if (card.suit == "d4") dealerMsg += "♣";
+                        dealerMsg;
+                    });
+                    dealerMsg += " > " + dealer.score.toString();
+                }
+
+                const row = new Discord.MessageActionRow()
+                    .addComponents(
+                        new Discord.MessageButton()
+                            .setCustomId('blackjack_hit')
+                            .setLabel(`Hit`)
+                            .setStyle('PRIMARY'),
+
+                        new Discord.MessageButton()
+                            .setCustomId('blackjack_stand')
+                            .setLabel(`Stand`)
+                            .setStyle('PRIMARY'),
+                    )
+
+                if (cl) {
+
+                    client.embed({
+                        title: `♦️・Blackjack`,
+                        desc: `${f} \n${msg}`,
+                        fields: [
+                            {
+                                name: `You`,
+                                value: cardsMsg,
+                                inline: true,
+                            },
+                            {
+                                name: `Bot`,
+                                value: dealerMsg,
+                                inline: true,
+                            }
+                        ],
+                        type: 'editreply'
+                    }, interaction)
+                }
+                else {
+                    client.embed({
+                        title: `♦️・Blackjack`,
+                        desc: `${f} \n${msg}`,
+                        fields: [
+                            {
+                                name: `You`,
+                                value: cardsMsg,
+                                inline: true,
+                            },
+                            {
+                                name: `Bot`,
+                                value: dealerMsg,
+                                inline: true,
+                            }
+                        ],
+                        components: [row],
+                        type: 'editreply'
+                    }, interaction)
+                }
+            }
+
+            async function endGame() {
+                if (player.score === 21) {
+                    bet("win");
+                    gameOver = true;
+                    await endMsg(
+                        `Win! You got 21!`,
+                        `Bot had ${dealer.score.toString()}`,
+                        `GREEN`
+                    );
+                }
+                if (player.score > 21) {
+                    bet("lose");
+                    gameOver = true;
+                    await endMsg(
+                        `Lost! You reached over 21!`,
+                        `Bot had ${dealer.score.toString()}`,
+                        `RED`
+                    );
+                }
+                if (dealer.score === 21) {
+                    bet("lose");
+                    gameOver = true;
+                    await endMsg(
+                        `Lost! The dealer got 21!`,
+                        `Bot had ${dealer.score.toString()}`,
+                        `RED`
+                    );
+                }
+                if (dealer.score > 21) {
+                    bet("win");
+                    gameOver = true;
+                    await endMsg(
+                        `Win! Bot reached over 21!`,
+                        `Bot had ${dealer.score.toString()}`,
+                        `GREEN`
+                    );
+                }
+                if (
+                    dealer.score >= 17 &&
+                    player.score > dealer.score &&
+                    player.score < 21
+                ) {
+                    bet("win");
+                    gameOver = true;
+                    await endMsg(
+                        `Win! You defeated Bot!`,
+                        `Bot had ${dealer.score.toString()}`,
+                        `GREEN`
+                    );
+                }
+                if (
+                    dealer.score >= 17 &&
+                    player.score < dealer.score &&
+                    dealer.score < 21
+                ) {
+                    bet("lose");
+                    gameOver = true;
+                    await endMsg(
+                        `Lost! Bot won!`,
+                        `Bot had ${dealer.score.toString()}`,
+                        `RED`
+                    );
+                }
+                if (
+                    dealer.score >= 17 &&
+                    player.score === dealer.score &&
+                    dealer.score < 21
+                ) {
+                    gameOver = true;
+                    await endMsg(`Tie!`, `Bot had ${dealer.score.toString()}`, `RED`);
+                }
+            }
+
+            function dealerDraw() {
+                dealer.cards.push(deck.deckArray[numCardsPulled]);
+                dealer.score = getCardsValue(dealer.cards);
+                numCardsPulled += 1;
+            }
+
+            function newGame() {
+                hit();
+                hit();
+                dealerDraw();
+                endGame();
+            }
+
+            function hit() {
+                player.cards.push(deck.deckArray[numCardsPulled]);
+                player.score = getCardsValue(player.cards);
+
+                numCardsPulled += 1;
+                if (numCardsPulled > 2) {
+                    endGame();
+                }
+            }
+
+            function stand() {
+                while (dealer.score < 17) {
+                    dealerDraw();
+                }
+                endGame();
+            }
+            newGame();
+            async function loop() {
+                if (gameOver) return;
+
+                endMsg(
+                    "To hit type `h`, for stand type `s`",
+                    `GoodLuck ;)`,
+                    client.color
+                );
+
+                const filter = i => i.user.id === interaction.user.id;
+                interaction.channel.awaitMessageComponent({ filter, max: 1, time: 1200000, errors: ["time"] })
+                    .then(async i => {
+                        if (i.customId == "blackjack_hit") {
+                            hit();
+                            loop();
+                            return i.deferUpdate();;
+                        } else if (i.customId == "blackjack_stand") {
+                            stand();
+                            loop();
+                            return i.deferUpdate();;
+                        }
+                    })
+                    .catch(_ => {
+                        interaction.channel.send("Lost!!");
+                        bet("lose");
+                        return;
+                    });
+            }
+            await loop();
+        }
+        else {
+            client.errNormal({ error: `You don't have any ${client.emotes.economy.coins}!`, type: 'editreply' }, interaction);
+        }
+    })
+}

src/commands/casino/crash.js

@@ -0,0 +1,145 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+    let user = interaction.user;
+        var result = Math.ceil(Math.random() * 12);
+
+        Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+            if (data) {
+                let money = parseInt(args[0]);
+                if (!money) return client.errUsage({ usage: "crash [amount]", type: 'editreply' }, interaction);
+
+                if (money > data.Money) return client.errNormal({ error: `You are betting more than you have!`, type: 'editreply' }, interaction);
+
+                const row = new Discord.MessageActionRow()
+                    .addComponents(
+                        new Discord.MessageButton()
+                            .setCustomId('crash_stop')
+                            .setEmoji("🛑")
+                            .setStyle('DANGER'),
+                    )
+
+                const disableRow = new Discord.MessageActionRow()
+                    .addComponents(
+                        new Discord.MessageButton()
+                            .setCustomId('crash_stop')
+                            .setEmoji("🛑")
+                            .setStyle('DANGER')
+                            .setDisabled(true),
+                    )
+
+                client.embed({
+                    desc: `Crash started by ${user}・React 🛑 to stop`,
+                    fields: [
+                        {
+                            name: `Multiplier`,
+                            value: `1x`,
+                            inline: true,
+                        },
+                        {
+                            name: `Profit`,
+                            value: `**0**`,
+                            inline: true,
+                        }
+                    ],
+                    components: [row],
+                    type: 'editreply'
+                }, interaction).then(msg => {
+                    let multiplier = 1;
+                    let index = 0;
+
+                    let times = result + 1;
+                    let timer = 2000 * times;
+
+                    setInterval(() => {
+                        if (index === result + 1) { return }
+                        else if (index === result) {
+
+                            Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+                                if (data) {
+                                    data.Money -= money;
+                                    data.save();
+                                }
+                            })
+
+                            return client.embed({
+                                title: `Crash Results of ${user}`,
+                                desc: `${f} \n${msg}`,
+                                edit: true,
+                                fields: [
+                                    {
+                                        name: `Loss`,
+                                        value: `**${money}**`,
+                                        inline: false,
+                                    }
+                                ]
+                            }, msg)
+
+                        }
+                        else {
+                            index += 1;
+                            multiplier += 0.20;
+
+                            let calc = money * multiplier;
+                            let profit = calc - money;
+
+                            client.embed({
+                                desc: `Crash started by ${user}・React 🛑 to stop`,
+                                edit: true,
+                                fields: [
+                                    {
+                                        name: `Multiplier`,
+                                        value: `${multiplier.toFixed(1)}x`,
+                                        inline: true,
+                                    },
+                                    {
+                                        name: `Profit`,
+                                        value: `**$${profit.toFixed(2)}**`,
+                                        inline: true,
+                                    }
+                                ],
+                                components: [row]
+                            }, msg)
+
+                            const filter = i => i.user.id === interaction.user.id;
+                            interaction.channel.awaitMessageComponent({ filter, max: 1, time: timer })
+                                .then(async i => {
+                                    if (i.customId == "crash_stop") {
+                                        i.deferUpdate();
+
+                                        index = result + 1;
+
+                                        Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+                                            if (data) {
+                                                data.Money += parseInt(profit);
+                                                data.save();
+                                            }
+                                        })
+
+                                        return client.embed({
+                                            desc: `Crash Results of ${user}`,
+                                            edit: true,
+                                            fields: [
+                                                {
+                                                    name: `Profit`,
+                                                    value: `**$${profit.toFixed(2)}**`,
+                                                    inline: false,
+                                                }
+                                            ],
+                                            components: [disableRow]
+                                        }, msg)
+
+                                    }
+                                })
+                        }
+                    }, 2000)
+                })
+
+            }
+            else {
+                client.errNormal({ error: `You has no ${client.emotes.economy.coins}!`, type: 'editreply' }, interaction);
+            }
+        })
+}

src/commands/casino/roulette.js

@@ -0,0 +1,66 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+    let user = interaction.user;
+
+    Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+        if (data) {
+            function isOdd(num) {
+                if ((num % 2) == 0) return false;
+                else if ((num % 2) == 1) return true;
+            }
+
+            let colour = interaction.options.getString('color');
+            let money = parseInt(interaction.options.getNumber('amount'));
+
+            let random = Math.floor(Math.random() * 37);
+
+            if (!colour || !money) return client.errUsage({ usage: "roulette [color] [amount]", type: 'editreply' }, interaction);
+            colour = colour.toLowerCase()
+            if (money > data.Money) return client.errNormal({ error: `You are betting more than you have!`, type: 'editreply' }, interaction);
+
+            if (colour == "b" || colour.includes("black")) colour = 0;
+            else if (colour == "r" || colour.includes("red")) colour = 1;
+            else if (colour == "g" || colour.includes("green")) colour = 2;
+            else return client.errNormal({ error: `No correct color specified!`, type: 'editreply' }, interaction);
+
+            if (random == 0 && colour == 2) { // Green
+                money *= 15
+
+                data.Money += money;
+                data.save();
+
+                client.embed({ title: `🎰・Multiplier: 15x`, desc: `You won **${client.emotes.economy.coins} $${money}**`, type: 'editreply' }, interaction);
+            }
+
+            else if (isOdd(random) && colour == 1) { // Red
+                money = parseInt(money * 1.5)
+                data.Money += money;
+                data.save();
+
+                client.embed({ title: `🎰・Multiplier: 1.5x`, desc: `You won **${client.emotes.economy.coins} $${money}**`, type: 'editreply' }, interaction);
+            }
+
+            else if (!isOdd(random) && colour == 0) { // Black
+                money = parseInt(money * 2)
+                data.Money += money;
+                data.save();
+
+                client.embed({ title: `🎰・Multiplier: 2x`, desc: `You won **${client.emotes.economy.coins} $${money}**`, type: 'editreply' }, interaction);
+            }
+
+            else { // Wrong
+                data.Money -= money;
+                data.save();
+
+                client.embed({ title: `🎰・Multiplier: 0x`, desc: `You lost **${client.emotes.economy.coins} $${money}**`, type: 'editreply' }, interaction);
+            }
+
+        }
+        else {
+            client.errNormal({ error: `You has no ${client.emotes.economy.coins}!`, type: 'editreply' }, interaction);
+        }
+    })
+}

src/commands/casino/slots.js

@@ -0,0 +1,76 @@
+const slotItems = ["🍇", "🍉", "🍊", "🍎", "🍓", "🍒"];
+const Discord = require('discord.js');
+const ms = require("parse-ms");
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+    let user = interaction.user;
+
+    Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+        if (data) {
+            let money = parseInt(args[0]);
+            let win = false;
+
+            if (!money) return client.errUsage({ usage: "slots [amount]", type: 'editreply' }, interaction);
+            if (money > data.Money) return client.errNormal({ error: `You are betting more than you have!`, type: 'editreply' }, interaction);
+
+            let number = []
+            for (i = 0; i < 3; i++) { number[i] = Math.floor(Math.random() * slotItems.length); }
+
+            if (number[0] == number[1] && number[1] == number[2]) {
+                money *= 9
+                win = true;
+            } else if (number[0] == number[1] || number[0] == number[2] || number[1] == number[2]) {
+                money *= 2
+                win = true;
+            }
+
+            const row = new Discord.MessageActionRow()
+                .addComponents(
+                    new Discord.MessageButton()
+                        .setCustomId('slots_1')
+                        .setLabel(`${slotItems[number[0]]}`)
+                        .setStyle('PRIMARY'),
+
+                    new Discord.MessageButton()
+                        .setCustomId('slots_2')
+                        .setLabel(`${slotItems[number[1]]}`)
+                        .setStyle('PRIMARY'),
+
+                    new Discord.MessageButton()
+                        .setCustomId('slots_3')
+                        .setLabel(`${slotItems[number[2]]}`)
+                        .setStyle('PRIMARY'),
+                );
+            if (win) {
+
+                client.embed({
+                    title: `🎰・Slots`,
+                    desc: `You won **${client.emotes.economy.coins} $${money}**`,
+                    color: client.config.colors.succes, 
+                    components: [row], 
+                    type: 'editreply'
+                }, interaction)
+
+                data.Money += money;
+                data.save();
+            } else {
+
+                client.embed({
+                    title: `🎰・Slots`,
+                    desc: `You lost **${client.emotes.economy.coins} $${money}**`,
+                    components: [row], 
+                    color: client.config.colors.error, 
+                    type: 'editreply'
+                }, interaction)
+
+                data.Money -= money;
+                data.save();
+            }
+        }
+        else {
+            client.errNormal({ error: `You has no ${client.emotes.economy.coins}!`, type: 'editreply' }, interaction);
+        }
+    })
+}

src/commands/config/leavemessage.js

@@ -0,0 +1,78 @@
+const Discord = require('discord.js');
+
+const inviteMessages = require("../../database/models/inviteMessages");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.MANAGE_MESSAGES],
+        perms: ["MANAGE_MESSAGES"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const message = interaction.options.getString('message');
+
+    if (message.toUpperCase() == "HELP") {
+        return client.embed({
+            title: `ℹ️・Welcome message options`,
+            desc: `Leave message options: \n
+            \`{user:username}\` - User's username
+            \`{user:discriminator}\` - User's discriminator
+            \`{user:tag}\` - User's tag
+            \`{user:mention}\` - Mention a user
+
+            \`{inviter:username}\` - inviter's username
+            \`{inviter:discriminator}\` - inviter's discriminator
+            \`{inviter:tag}\` - inviter's tag
+            \`{inviter:mention}\` - inviter's mention
+            \`{inviter:invites}\` - inviter's invites
+            \`{inviter:invites:left}\` - inviter's left invites
+            
+            \`{guild:name}\` - Server name
+            \`{guild:members}\` - Server members count`,
+            type: 'editreply'
+        }, interaction)
+    }
+
+    if (message.toUpperCase() == "DEFAULT") {
+        inviteMessages.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+            if (data) {
+                data.inviteLeave = null;
+                data.save();
+
+                client.succNormal({
+                    text: `Leave message deleted!`,
+                    type: 'editreply'
+                }, interaction);
+            }
+        })
+    }
+    else {
+        inviteMessages.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+            if (data) {
+                data.inviteLeave = message;
+                data.save();
+            }
+            else {
+                new inviteMessages({
+                    Guild: interaction.guild.id,
+                    inviteLeave: message
+                }).save();
+            }
+
+            client.succNormal({
+                text: `The leave message has been set successfully`,
+                fields: [
+                    {
+                        name: `💬┆Message`,
+                        value: `${message}`,
+                        inline: true
+                    },
+                ],
+                type: 'editreply'
+            }, interaction)
+        })
+    }
+}
+
+ 

src/commands/config/levelmessage.js

@@ -0,0 +1,70 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/levelMessages");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.MANAGE_MESSAGES],
+        perms: ["MANAGE_MESSAGES"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const message = interaction.options.getString('message');
+
+    if (message.toUpperCase() == "HELP") {
+        return client.embed({
+            title: `ℹ️・Level message options`,
+            desc: `These are the level message name options: \n
+            \`{user:username}\` - User's username
+            \`{user:discriminator}\` - User's discriminator
+            \`{user:tag}\` - User's tag
+            \`{user:mention}\` - Mention a user
+
+            \`{user:level}\` - Users's level
+            \`{user:xp}\` - Users's xp`,
+            type: 'editreply'
+        }, interaction)
+    }
+
+    if (message.toUpperCase() == "DEFAULT") {
+        Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+            if (data) {
+                Schema.findOneAndDelete({ Guild: interaction.guild.id }).then(() => {
+                    client.succNormal({ 
+                        text: `Level message deleted!`,
+                        type: 'editreply'
+                    }, interaction);
+                })
+            }
+        })
+    }
+    else {
+        Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+            if (data) {
+                data.Message = message;
+                data.save();
+            }
+            else {
+                new Schema({
+                    Guild: interaction.guild.id,
+                    Message: message
+                }).save();
+            }
+
+            client.succNormal({
+                text: `The level message has been set successfully`,
+                fields: [
+                    {
+                        name: `💬┆Message`,
+                        value: `${message}`,
+                        inline: true
+                    },
+                ],
+                type: 'editreply'
+            }, interaction)
+        })
+    }
+}
+
+ 

src/commands/config/levels.js

@@ -0,0 +1,33 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/functions");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.MANAGE_MESSAGES],
+        perms: ["MANAGE_MESSAGES"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const boolean = interaction.options.getBoolean('boolean');
+
+    const data = await Schema.findOne({ Guild: interaction.guild.id });
+    if (data) {
+        data.Levels = boolean;
+        data.save();
+    }
+    else {
+        new Schema({
+            Guild: interaction.guild.id,
+            Levels: boolean,
+        }).save();
+    }
+
+    client.succNormal({
+        text: `Levels is now **${boolean ? 'enabled' : 'disabled'}** in this guild`,
+        type: 'editreply'
+    }, interaction);
+}
+
+ 

src/commands/config/setchannelname.js

@@ -0,0 +1,51 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/stats");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.MANAGE_CHANNELS],
+        perms: ["MANAGE_CHANNELS"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const name = interaction.options.getString('name');
+
+    if (name.toUpperCase() == "HELP") {
+        return client.embed({
+            title: `ℹ️・Channel name options`,
+            desc: `These are the channel name options: \n
+            \`{emoji}\` - Channel emoji
+            \`{name}\` - Channel name`,
+            type: 'editreply'
+        }, interaction)
+    }
+
+    Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+        if (data) {
+            data.ChannelTemplate = name
+            data.save();
+        }
+        else {
+            new Schema({
+                Guild: interaction.guild.id,
+                ChannelTemplate: name
+            }).save();
+        }
+
+        client.succNormal({
+            text: `The channel name has been set successfully`,
+            fields: [
+                {
+                    name: `💬┆Name`,
+                    value: `${name}`,
+                    inline: true
+                },
+            ],
+            type: 'editreply'
+        }, interaction)
+    })
+}
+
+ 

src/commands/config/setcolor.js

@@ -0,0 +1,60 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/functions");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.ADMINISTRATOR],
+        perms: ["ADMINISTRATOR"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const rawColor = interaction.options.getString('color');
+    let color = "";
+
+    if (rawColor.toUpperCase() == "DEFAULT") {
+        color = client.config.colors.normal.replace("#", "");
+    }
+    else {
+        color = rawColor
+    }
+
+    if (!isHexColor(color)) return client.errNormal({
+        error: "You did not specify an hex color! Example: ff0000",
+        type: 'editreply'
+    }, interaction)
+
+    Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+        if (data) {
+            data.Color = `#${color}`;
+            data.save();
+        }
+        else {
+            new Schema({
+                Guild: interaction.guild.id,
+                Color: `#${color}`
+            }).save();
+        }
+    })
+
+    client.succNormal({
+        text: `The embed color has been adjusted successfully`,
+        fields: [
+            {
+                name: `🎨┆New color`,
+                value: `#${color}`,
+                inline: true
+            },
+        ],
+        type: 'editreply'
+    }, interaction)
+}
+
+function isHexColor(hex) {
+    return typeof hex === 'string'
+        && hex.length === 6
+        && !isNaN(Number('0x' + hex))
+}
+
+ 

src/commands/config/setverify.js

@@ -0,0 +1,65 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/verify");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.MANAGE_MESSAGES],
+        perms: ["MANAGE_MESSAGES"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const boolean = interaction.options.getBoolean('enable');
+    const channel = interaction.options.getChannel('channel');
+    const role = interaction.options.getRole('role');
+
+    if (boolean == true) {
+        const data = await Schema.findOne({ Guild: interaction.guild.id });
+        if (data) {
+            data.Channel = channel.id;
+            data.Role = role.id
+            data.save();
+        }
+        else {
+            new Schema({
+                Guild: interaction.guild.id,
+                Channel: channel.id,
+                Role: role.id
+            }).save();
+        }
+
+        client.succNormal({
+            text: `Verify panel has been successfully created`,
+            fields: [
+                {
+                    name: `📘┆Channel`,
+                    value: `${channel} (${channel.name})`,
+                    inline: true
+                },
+                {
+                    name: `📛┆Role`,
+                    value: `${role} (${role.name})`,
+                    inline: true
+                }
+            ],
+            type: 'editreply'
+        }, interaction);
+
+        const row = new Discord.MessageActionRow()
+            .addComponents(
+                new Discord.MessageButton()
+                    .setCustomId('Bot_verify')
+                    .setEmoji('✅')
+                    .setStyle('SUCCESS'),
+            );
+
+        client.embed({
+            title: `${interaction.guild.name}・verify`,
+            desc: `Click on the button to verify yourself`,
+            components: [row]
+        }, channel)
+    }
+}
+
+ 

src/commands/config/ticketmessage.js

@@ -0,0 +1,148 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/ticketMessage");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.MANAGE_MESSAGES],
+        perms: ["MANAGE_MESSAGES"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const type = interaction.options.getString('type');
+    const message = interaction.options.getString('message');
+
+    if (type == "open") {
+        if (message.toUpperCase() == "DEFAULT") {
+            const data = await Schema.findOne({ Guild: interaction.guild.id })
+
+            if (data) {
+                data.openTicket = "Thanks for creating a ticket! \nSupport will be with you shortly \n\n🔒 - Close ticket \n✋ - Claim ticket \n📝 - Save transcript \n🔔 - Send a notification";
+                data.save();
+
+                client.succNormal({
+                    text: `The ticket message has been set successfully`,
+                    fields: [
+                        {
+                            name: `📘┆Message type`,
+                            value: `${type}`,
+                            inline: true
+                        },
+                        {
+                            name: `💬┆Message`,
+                            value: `${data.openTicket}`,
+                            inline: true
+                        },
+                    ],
+                    type: 'editreply'
+                }, interaction)
+            }
+            else {
+                client.errNormal({
+                    error: `No ticket message data found!`,
+                    type: 'editreply'
+                }, interaction)
+            }
+
+            return;
+        }
+
+        Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+            if (data) {
+                data.openTicket = message;
+                data.save();
+            }
+            else {
+                new Schema({
+                    Guild: interaction.guild.id,
+                    openTicket: message
+                }).save();
+            }
+        })
+
+        client.succNormal({
+            text: `The ticket message has been set successfully`,
+            fields: [
+                {
+                    name: `📘┆Message type`,
+                    value: `${type}`,
+                    inline: true
+                },
+                {
+                    name: `💬┆Message`,
+                    value: `${message}`,
+                    inline: true
+                },
+            ],
+            type: 'editreply'
+        }, interaction)
+    }
+    else if (type == "close") {
+        if (message.toUpperCase() == "DEFAULT") {
+            const data = await Schema.findOne({ Guild: interaction.guild.id })
+
+            if (data) {
+                data.dmMessage = "Here is the transcript for your ticket, please keep this if you ever want to refer to it!";
+                data.save();
+
+                client.succNormal({
+                    text: `The ticket message has been set successfully`,
+                    fields: [
+                        {
+                            name: `📘┆Message type`,
+                            value: `${type}`,
+                            inline: true
+                        },
+                        {
+                            name: `💬┆Message`,
+                            value: `${data.dmMessage}`,
+                            inline: true
+                        },
+                    ],
+                    type: 'editreply'
+                }, interaction)
+            }
+            else {
+                client.errNormal({
+                    error: `No ticket message data found!`,
+                    type: 'editreply'
+                }, interaction)
+            }
+
+            return;
+        }
+
+        Schema.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+            if (data) {
+                data.dmMessage = message;
+                data.save();
+            }
+            else {
+                new Schema({
+                    Guild: interaction.guild.id,
+                    dmMessage: message
+                }).save();
+            }
+        })
+
+        client.succNormal({
+            text: `The ticket message has been set successfully`,
+            fields: [
+                {
+                    name: `📘┆Message type`,
+                    value: `${type}`,
+                    inline: true
+                },
+                {
+                    name: `💬┆Message`,
+                    value: `${message}`,
+                    inline: true
+                },
+            ],
+            type: 'editreply'
+        }, interaction)
+    }
+}
+
+ 

src/commands/config/welcomemessage.js

@@ -0,0 +1,78 @@
+const Discord = require('discord.js');
+
+const inviteMessages = require("../../database/models/inviteMessages");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.MANAGE_MESSAGES],
+        perms: ["MANAGE_MESSAGES"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const message = interaction.options.getString('message');
+
+    if (message.toUpperCase() == "HELP") {
+        return client.embed({
+            title: `ℹ️・Welcome message options`,
+            desc: `Join message options: \n
+            \`{user:username}\` - User's username
+            \`{user:discriminator}\` - User's discriminator
+            \`{user:tag}\` - User's tag
+            \`{user:mention}\` - Mention a user
+
+            \`{inviter:username}\` - inviter's username
+            \`{inviter:discriminator}\` - inviter's discriminator
+            \`{inviter:tag}\` - inviter's tag
+            \`{inviter:mention}\` - inviter's mention
+            \`{inviter:invites}\` - inviter's invites
+            \`{inviter:invites:left}\` - inviter's left invites
+                    
+            \`{guild:name}\` - Server name
+            \`{guild:members}\` - Server members count`,
+            type: 'editreply'
+        }, interaction)
+    }
+
+    if (message.toUpperCase() == "DEFAULT") {
+        inviteMessages.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+            if (data) {
+                data.inviteJoin = null;
+                data.save();
+
+                client.succNormal({
+                    text: `Welcome message deleted!`,
+                    type: 'editreply'
+                }, interaction);
+            }
+        })
+    }
+    else {
+        inviteMessages.findOne({ Guild: interaction.guild.id }, async (err, data) => {
+            if (data) {
+                data.inviteJoin = message;
+                data.save();
+            }
+            else {
+                new inviteMessages({
+                    Guild: interaction.guild.id,
+                    inviteJoin: message
+                }).save();
+            }
+
+            client.succNormal({
+                text: `The welcome message has been set successfully`,
+                fields: [
+                    {
+                        name: `💬┆Message`,
+                        value: `${message}`,
+                        inline: true
+                    },
+                ],
+                type: 'editreply'
+            }, interaction)
+        })
+    }
+}
+
+ 

src/commands/custom-commands/add.js

@@ -0,0 +1,113 @@
+const Discord = require('discord.js');
+const Schema = require("../../database/models/customCommandAdvanced");
+
+module.exports = async (client, interaction, args) => {
+    const cmdname = interaction.options.getString('command');
+    const cmdresponce = interaction.options.getString('text');
+
+    Schema.findOne({ Guild: interaction.guild.id, Name: cmdname.toLowerCase() }, async (err, data) => {
+        if (data) {
+            client.errNormal({ error: "This command name is already added in guild custom commands!", type: 'editreply' }, interaction);
+        }
+        else {
+            const row = new Discord.MessageActionRow()
+                .addComponents(
+                    new Discord.MessageSelectMenu()
+                        .setCustomId('customSelect')
+                        .setPlaceholder('❌┆Nothing selected')
+                        .addOptions(
+                            [
+                                {
+                                    label: `Embed`,
+                                    description: `Send a message in an embed`,
+                                    value: "command-embed",
+                                },
+                                {
+                                    label: `Normal`,
+                                    description: `Send a message as normal`,
+                                    value: "command-normal",
+                                },
+                                {
+                                    label: `Private`,
+                                    description: `Send the message in DM`,
+                                    value: "command-dm",
+                                },
+                            ]
+                        )
+                );
+
+            client.embed({ desc: `What action should be attached to this command?`, components: [row], type: 'editreply' }, interaction)
+
+            const filter = i => i.user.id === interaction.user.id;
+
+            interaction.channel.awaitMessageComponent({ filter, max: 1 }).then(async i => {
+                if (i.customId == 'customSelect') {
+                    if (i.values[0] === "command-embed") {
+                        new Schema({
+                            Guild: interaction.guild.id,
+                            Name: cmdname.toLowerCase(),
+                            Responce: cmdresponce,
+                            Action: "Embed"
+                        }).save();
+
+                        client.succNormal({
+                            text: `The command has been added successfully`,
+                            fields: [{
+                                name: "🔧┆Command",
+                                value: `\`\`\`${cmdname.toLowerCase()}\`\`\``,
+                                inline: true,
+                            }],
+                            type: 'editreply'
+                        }, i);
+                    }
+
+                    if (i.values[0] === "command-normal") {
+                        new Schema({
+                            Guild: interaction.guild.id,
+                            Name: cmdname.toLowerCase(),
+                            Responce: cmdresponce,
+                            Action: "Normal"
+                        }).save();
+
+                        client.succNormal({
+                            text: `The command has been added successfully`,
+                            fields: [{
+                                name: "🔧┆Command",
+                                value: `\`\`\`${cmdname.toLowerCase()}\`\`\``,
+                                inline: true,
+                            }],
+                            type: 'editreply'
+                        }, i);
+                    }
+
+                    if (i.values[0] === "command-dm") {
+                        new Schema({
+                            Guild: interaction.guild.id,
+                            Name: cmdname.toLowerCase(),
+                            Responce: cmdresponce,
+                            Action: "DM"
+                        }).save();
+
+                        client.succNormal({
+                            text: `The command has been added successfully`,
+                            fields: [{
+                                name: "🔧┆Command",
+                                value: `\`\`\`${cmdname.toLowerCase()}\`\`\``,
+                                inline: true,
+                            }],
+                            type: 'editreply'
+                        }, i);
+                    }
+
+                    await interaction.guild.commands.create({
+                        name: cmdname,
+                        description: 'Custom server command'
+                    });
+                }
+            })
+        }
+    })
+
+}
+
+ 

src/commands/custom-commands/delete.js

@@ -0,0 +1,31 @@
+const Discord = require('discord.js');
+const Schema = require("../../database/models/customCommandAdvanced");
+
+module.exports = async (client, interaction, args) => {
+    const cmdname = interaction.options.getString('command');
+
+    Schema.findOne({ Guild: interaction.guild.id, Name: cmdname.toLowerCase() }, async (err, data) => {
+        if (data) {
+            Schema.findOneAndDelete({ Guild: interaction.guild.id, Name: cmdname }).then(async () => {
+                const command = await interaction.guild.commands.cache.find((cmd => cmd.name == cmdname));
+                await interaction.guild.commands.delete(command.id);
+
+                client.succNormal({
+                    text: `The command has been deleted successfully`,
+                    fields: [{
+                        name: "🔧┆Command",
+                        value: `\`\`\`${cmdname}\`\`\``,
+                        inline: true,
+                    }],
+                    type: 'editreply'
+                }, interaction);
+            })
+        }
+        else {
+            client.errNormal({ error: "Unable to find this command!", type: 'editreply' }, interaction);
+        }
+    })
+
+}
+
+ 

src/commands/developers/args.js

@@ -0,0 +1,270 @@
+const Discord = require('discord.js');
+
+module.exports = async (client, interaction, args) => {
+    const message = interaction.options.getString('message');
+
+    client.succNormal({
+        text: `Message has been sent successfully!`,
+        type: 'ephemeraledit'
+    }, interaction);
+
+    if (message == "information") {
+        client.simpleEmbed({
+            image: `https://cdn.discordapp.com/attachments/843487478881976381/874742689017520128/Bot_banner_information.jpg`
+        }, interaction.channel).then(() => {
+            client.embed({
+                title: `ℹ️・Information`,
+                thumbnail: client.user.avatarURL({ size: 1024 }),
+                desc: `_____`,
+                fields: [
+                    {
+                        name: `👋┆Welcome to ${interaction.guild.name}!`,
+                        value: `Welcome to our hangout place! Meet new people here, play some games and participate in seasonal events! We are a server where we bring everyone together and we try to make it comfortable for everyone! Please be welcome and have some fun!`,
+                    },
+                    {
+                        name: `❓┆What can I do here?`,
+                        value: `- Meet new people! \n- Play many fun games! \n- Discover the seasons! \n- Participate in events! \nAnd…. Last but not least, choose your own roles at <#847867992044994561>!`,
+                    },
+                    {
+                        name: `🎫┆How do I get help when needed?`,
+                        value: `You can make a ticket in <#820308164322656327>! We are happy to help you with your questions here and offer support in your server!`,
+                    },
+                    {
+                        name: `⚙️┆I want to help Bot Hangout to improve!`,
+                        value: `- Go to applications and see what kind of jobs are available! \n- Or make a ticket and ask if you can help with certain things! \n\n**We wish you a very nice and happy time here!**`,
+                    }
+                ]
+            }, interaction.channel)
+        })
+    }
+
+    if (message == "rules") {
+        client.simpleEmbed({
+            image: `https://cdn.discordapp.com/attachments/843487478881976381/874742702393131038/Bot_banner_rules.jpg`
+        }, interaction.channel).then(async () => {
+            await client.embed({
+                title: `📃・Rules`,
+                thumbnail: client.user.avatarURL({ size: 1024 }),
+                desc: `_____ \n\nThese are our server rules. Please stick to this to keep it fun for everyone. The Admins and Mods will Timeout/Kick/Ban per discretion`,
+            }, interaction.channel)
+
+            await client.embed({
+                title: `1. Be respectful`,
+                desc: `You must respect all users, regardless of your liking towards them. Treat others the way you want to be treated.`,
+            }, interaction.channel)
+
+            await client.embed({
+                title: `2. No Inappropriate Language`,
+                desc: `The use of profanity should be kept to a minimum. However, any derogatory language towards any user is prohibited.`,
+            }, interaction.channel)
+
+            await client.embed({
+                title: `3. No spamming`,
+                desc: `Don't send a lot of small messages right after each other. Do not disrupt chat by spamming.`,
+            }, interaction.channel)
+
+            await client.embed({
+                title: `4. No pornographic/adult/other NSFW material`,
+                desc: `This is a community server and not meant to share this kind of material.`,
+            }, interaction.channel)
+
+            await client.embed({
+                title: `5. No advertisements`,
+                desc: `We do not tolerate any kind of advertisements, whether it be for other communities or streams. You can post your content in the media channel if it is relevant and provides actual value (Video/Art)`,
+            }, interaction.channel)
+
+            await client.embed({
+                title: `6. No offensive names and profile pictures`,
+                desc: `You will be asked to change your name or picture if the staff deems them inappropriate.`,
+            }, interaction.channel)
+
+            await client.embed({
+                title: `7. Server Raiding`,
+                desc: `Raiding or mentions of raiding are not allowed.`,
+            }, interaction.channel)
+
+            await client.embed({
+                title: `8. Direct & Indirect Threats`,
+                desc: `Threats to other users of DDoS, Death, DoX, abuse, and other malicious threats are absolutely prohibited and disallowed.`,
+            }, interaction.channel)
+
+            await client.embed({
+                title: `9. Follow the Discord Community Guidelines`,
+                desc: `You can find them here: https://discordapp.com/guidelines`,
+            }, interaction.channel)
+
+            await client.embed({
+                title: `10. Do not join voice chat channels without permissions of the people already in there`,
+                desc: `If you see that they have a free spot it is alright to join and ask whether they have an open spot, but leave if your presence is not wanted by whoever was there first`,
+            }, interaction.channel)
+        })
+    }
+
+    if (message == "applications") {
+        client.simpleEmbed({
+            image: `https://cdn.discordapp.com/attachments/843487478881976381/874742737415581786/Bot_banner_applications.jpg`
+        }, interaction.channel).then(() => {
+            client.embed({
+                title: `💼・Applications`,
+                thumbnail: client.user.avatarURL({ size: 1024 }),
+                desc: `_____ \n\nWhat could be more fun than working at the best bot/server? We regularly have spots for new positions that you can apply for \n\nBut... what can you expect?`,
+                fields: [
+                    {
+                        name: `👥┆A very nice team`,
+                        value: `In the Bot team there is always a pleasant atmosphere and everyone is treated equally!`,
+                    },
+                    {
+                        name: `🥳┆Access to the beta program`,
+                        value: `Get access to unreleased Bot features with your own server! You are a real Bot tester!`,
+                    },
+                    {
+                        name: `📛┆A nice rank and badge`,
+                        value: `You will get a nice rank in the server and a team badge in our userinfo command. Everyone can see that you contribute to the team`,
+                    },
+                    {
+                        name: `📖┆Learn and grow`,
+                        value: `We understand that you don't always understand everything right away! At Bot, we give you the opportunity to learn new things and get better at the position. You can also grow into the management team in the future!`,
+                    },
+                    {
+                        name: `📘┆What does everything mean?`,
+                        value: `**Moderator** \nYou keep yourself busy with the server that everything is and remains fun for everyone! Chat with us and keep the overview \n\n**Marketing** \nWe also want to grow and we do that with a great marketing team! You know better than anyone how to make a server grow well \n\n**Organization** \nYou will ensure an even nicer atmosphere in the server! Together with a team you work on new and fun events to make the server even more fun!`,
+                    },
+                    {
+                        name: `📃┆Apply?`,
+                        value: `Create a ticket to receive your application!`,
+                    }
+                ]
+            }, interaction.channel)
+        })
+    }
+
+    if (message == "boosterperks") {
+        client.simpleEmbed({
+            image: `https://media.discordapp.net/attachments/843487478881976381/881396544195149874/Bot_banner_boosters.jpg`
+        }, interaction.channel).then(() => {
+            client.embed({
+                title: `💎・Booster Perks`,
+                thumbnail: client.user.avatarURL({ size: 1024 }),
+                desc: `_____ \n\nMore options in the server? Become a real Bot Booster and get nice benefits for a nice experience. But what do you actually get?`,
+                fields: [
+                    {
+                        name: `😛┆Use external stickers`,
+                        value: `Use stickers from other servers in our server`,
+                    },
+                    {
+                        name: `🔊┆Send TTS messages`,
+                        value: `Send messages that have a sound attached`,
+                    },
+                    {
+                        name: `🤔┆Access to the hidden lounge`,
+                        value: `Get access to a private lounge and chat with other boosters!`,
+                    },
+                    {
+                        name: `📛┆Change your nickname`,
+                        value: `Change your name in the server. This is how you stand out in the server`,
+                    },
+                    {
+                        name: `💭┆Create public/private threads`,
+                        value: `Create a thread in our text channels`,
+                    },
+                    {
+                        name: `🎉┆Private giveaways`,
+                        value: `Get access to fun exclusive giveaways`,
+                    },
+                    {
+                        name: `📂┆Send files in any channel`,
+                        value: `Send files in all channels where you can talk`,
+                    },
+                    {
+                        name: `📊┆Get access to a special promotional channel`,
+                        value: `Get the opportunity to promote your own server in a special channel`,
+                    },
+                    {
+                        name: `😜┆Custom role of your choice`,
+                        value: `Create your own role that you can set yourself`,
+                    },
+                    {
+                        name: `💎┆Get the booster role + badge`,
+                        value: `Stand out with a nice booster role and a booster badge!`,
+                    },
+                    {
+                        name: `💻┆Access to new bèta updates in Bot`,
+                        value: `We'll give your server access to updates that aren't out yet! How nice is that?`,
+                    }
+                ]
+            }, interaction.channel)
+        })
+    }
+
+    if (message == "links") {
+        client.simpleEmbed({
+            image: `https://media.discordapp.net/attachments/843487478881976381/881396544195149874/Bot_banner_boosters.jpg`
+        }, interaction.channel).then(() => {
+            client.embed({
+                title: `🔗・Links`,
+                thumbnail: client.user.avatarURL({ size: 1024 }),
+                desc: `_____ \n\nSee all the links from Bot Network!`,
+                fields: [
+                    {
+                        name: `▬▬│Servers│▬▬`,
+                        value: ``,
+                    }
+                ]
+            }, interaction.channel)
+        })
+    }
+
+    if (message == "rewards") {
+        client.embed({
+            title: `😜・Role Rewards`,
+            thumbnail: client.user.avatarURL({ size: 1024 }),
+            desc: `_____ \n\nDo you want some extras in the server? Or do you want to stand out more in the server? Look below for the rewards`,
+            fields: [
+                {
+                    name: `🏆┆Levels`,
+                    value: `- Level 5   | <@&833307296699908097>\n- Level 10  | <@&833307450437664838>\n- Level 15  | <@&833307452279226379>\n- Level 30 | <@&915290300757458964>\n- Level 40 | <@&915290324480430080>`,
+                },
+                {
+                    name: `🥳┆Special`,
+                    value: `- 1 server vote | <@&833959913742794772>\n- 1 boost | <@&744208324022501447>\n- 1 donate | <@&849554599371210793>`,
+                },
+                {
+                    name: `💰┆Economy`,
+                    value: `- $10.000 | <@&890720270086733854>\n- $15.000 | <@&833936202725720084>\n- $20.000 | <@&833936185167839232> \n- $25.000 | <@&928236333309255711> \n- $30.000 | <@&928235747100733450>`,
+                }
+            ]
+        }, interaction.channel)
+    }
+
+    if (message == "ourbots") {
+        client.simpleEmbed({
+            image: `https://cdn.discordapp.com/attachments/843487478881976381/874742741224022016/Bot_banner_bot_info.jpg`
+        }, interaction.channel).then(() => {
+            client.embed({
+                title: `🤖・Our bots`,
+                thumbnail: client.user.avatarURL({ size: 1024 }),
+                desc: `_____ \n\nOutside of a community we also maintain 2 public bots. These bots are all made to make your server better!`,
+                fields: [
+                    {
+                        name: `📘┆What is Bot?`,
+                        value: `Bot is a bot with which you can run your entire server! With no less than 400+ commands, we have a large bot with many options to improve your server! You know what else is beautiful? All of this is **FREE** to use!`,
+                    },
+                    {
+                        name: `🎶┆What is Bot 2?`,
+                        value: `Bot 2 was created for additional music. This way you never get in each other's way when someone is already listening to music. Furthermore, this bot contains a soundboard and a radio system`,
+                    },
+                    {
+                        name: `📨┆How do I invite the bots?`,
+                        value: `You can invite the bots by doing \`/invite\` or by clicking on the links below \n\n**Bot** - [Invite here](https://discord.com/oauth2/authorize?&client_id=798144456528363550&scope=applications.commands+bot&permissions=8) \n**Bot 2** - [Invite here](https://discord.com/oauth2/authorize?&client_id=896842236002713673&scope=applications.commands+bot&permissions=8)`,
+                    },
+                    {
+                        name: `🎫┆How do I get help when needed?`,
+                        value: `You can make a ticket in <#820308164322656327>! We are happy to help you with your questions here and offer support in your server!`,
+                    }
+                ]
+            }, interaction.channel)
+        })
+    }
+}
+
+ 

src/commands/developers/badge.js

@@ -0,0 +1,141 @@
+const Discord = require('discord.js');
+
+const model = require('../../database/models/badge');
+
+const webhookClientLogs = new Discord.WebhookClient({
+    id: "",
+    token: "",
+});
+
+module.exports = async (client, interaction, args) => {
+    const badgeFlags = {
+        DEVELOPER: client.emotes.badges.developer,
+        EVENT: client.emotes.badges.event,
+        BOOSTER: client.emotes.badges.booster,
+        BUGS: client.emotes.badges.bug,
+        MANAGEMENT: client.emotes.badges.management,
+        PREMIUM: client.emotes.badges.premium,
+        SUPPORTER: client.emotes.badges.supporter,
+        TEAM: client.emotes.badges.team,
+        BOOSTER: client.emotes.badges.booster,
+        PARTNER: client.emotes.badges.partner,
+        VOTER: client.emotes.badges.voter,
+        SUPPORT: client.emotes.badges.support,
+        MODERATOR: client.emotes.badges.moderator,
+        DESIGNER: client.emotes.badges.designer,
+        MARKETING: client.emotes.badges.marketing,
+        ACTIVE: client.emotes.badges.active,
+        VIP: client.emotes.badges.vip
+    }
+
+    const boolean = interaction.options.getBoolean('new');
+    const member = interaction.options.getUser('user');
+    const badge = interaction.options.getString('badge');
+
+    let Badges = await model.findOne({ User: member.id });
+
+    if (!badgeFlags[badge.toUpperCase()]) return client.errNormal({
+        error: `I can't find that badge`,
+        type: `editreply`
+    }, interaction);
+
+    if (boolean == true) {
+        if (Badges) {
+            if (Badges.FLAGS.includes(badge.toUpperCase())) return client.errNormal({
+                error: `This users already has that badge!`,
+                type: `editreply`
+            }, interaction);
+
+            let FLAG = badge.toUpperCase();
+            let array = Badges.FLAGS;
+
+            array.push(FLAG);
+
+            model.findOne({ User: member.id }, async (err, data) => {
+                if (err) throw err;
+                data.FLAGS = array
+                data.save();
+            });
+
+            client.succNormal({
+                text: `Added the ${badgeFlags[badge.toUpperCase()]} (${badge.toUpperCase()}) badge!`,
+                type: `editreply`
+            }, interaction);
+        } else {
+            const newSettings = new model({ User: member.id, FLAGS: [badge.toUpperCase()] });
+            await newSettings.save().catch(() => { });
+
+            client.succNormal({
+                text: `Added the ${badgeFlags[badge.toUpperCase()]} (${badge.toUpperCase()}) badge!`,
+                type: `editreply`
+            }, interaction)
+        }
+
+        let embedLogs = new Discord.MessageEmbed()
+            .setTitle(`📛・Badge added`)
+            .setDescription(`Added a new badge to ${member} (${member.id})`)
+            .addField('👤┆Added By', `${interaction.user} (${interaction.user.tag})`, true)
+            .addField(`📛┆Badge`, `${badgeFlags[badge.toUpperCase()]} (${badge.toUpperCase()})`, true)
+            .setColor(client.config.colors.normal)
+            .setFooter(client.config.discord.footer)
+            .setTimestamp();
+        webhookClientLogs.send({
+            username: 'Bot Badges',
+            embeds: [embedLogs],
+        });
+    }
+    else if (boolean == false) {
+        if (!Badges.FLAGS.includes(badge.toUpperCase())) return client.errNormal({
+            error: `The user does not have this badge`,
+            type: `editreply`
+        }, interaction);
+
+        let FLAG = badge.toUpperCase();
+        let array = Badges.FLAGS;
+
+        for (var i = 0; i < array.length; i++) {
+
+            if (array[i] === FLAG) {
+                array.splice(i, 1);
+                i--;
+            }
+        }
+
+        if (!array[0]) {
+            let deleted = await model.deleteMany({ User: member.id });
+            client.succNormal({
+                text: `Removed the ${badgeFlags[badge.toUpperCase()]} (${badge.toUpperCase()}) badge, the user is now removed of the badge system, it has no badges left!`,
+                type: 'editreply'
+            }, interaction);
+
+        } else {
+            model.findOne(
+                { User: member.id },
+                async (err, data) => {
+                    if (err) throw err;
+                    data.FLAGS = array
+                    data.save();
+                }
+            );
+            client.succNormal({
+                text: `Removed the ${badgeFlags[badge.toUpperCase()]} (${badge.toUpperCase()}) badge!`,
+                type: 'editreply'
+            }, interaction);
+        }
+
+        let embedLogs = new Discord.MessageEmbed()
+            .setTitle(`📛・Badge removed`)
+            .setDescription(`Removed a badge from ${member} (${member.id})`)
+            .addField('👤┆Removed By', `${interaction.user} (${interaction.user.tag})`, true)
+            .addField(`📛┆Badge`, `${badgeFlags[badge.toUpperCase()]} (${badge.toUpperCase()})`, true)
+            .setColor(client.config.colors.normal)
+            .setFooter(client.config.discord.footer)
+            .setTimestamp();
+        webhookClientLogs.send({
+            username: 'Bot Badges',
+            embeds: [embedLogs],
+        });
+    }
+}
+
+ 

src/commands/developers/ban.js

@@ -0,0 +1,78 @@
+const Discord = require('discord.js');
+
+const Schema = require('../../database/models/userBans');
+
+const webhookClientLogs = new Discord.WebhookClient({
+    id: "",
+    token: "",
+});
+
+module.exports = async (client, interaction, args) => {
+    const boolean = interaction.options.getBoolean('new');
+    const member = interaction.options.getUser('user');
+
+    if (boolean == true) {
+        Schema.findOne({ User: member.id }, async (err, data) => {
+            if (data) {
+                return client.errNormal({
+                    error: `<@!${member.id}> (${member.id}) has already been banned from the bot`,
+                    type: `editreply`
+                }, interaction);
+            }
+            else {
+                new Schema({
+                    User: member.id
+                }).save();
+
+                client.succNormal({
+                    text: `<@!${member.id}> (${member.id}) banned from the bot`,
+                    type: 'editreply'
+                }, interaction)
+
+                let embedLogs = new Discord.MessageEmbed()
+                    .setTitle(`🔨・Ban added`)
+                    .setDescription(`<@!${member.id}> (${member.id}) banned from the bot`)
+                    .addField('👤┆Banned By', `${interaction.user} (${interaction.user.tag})`, true)
+                    .setColor(client.config.colors.normal)
+                    .setFooter(client.config.discord.footer)
+                    .setTimestamp();
+                webhookClientLogs.send({
+                    username: 'Bot Bans',
+                    embeds: [embedLogs],
+                });
+            }
+        })
+    }
+    else if (boolean == false) {
+        Schema.findOne({ User: member.id }, async (err, data) => {
+            if (data) {
+                Schema.findOneAndDelete({ User: member.id }).then(() => {
+                    client.succNormal({
+                        text: `<@!${member.id}> (${member.id}) unbanned from the bot`,
+                        type: 'editreply'
+                    }, interaction)
+
+                    let embedLogs = new Discord.MessageEmbed()
+                        .setTitle(`🔨・Ban removed`)
+                        .setDescription(`<@!${member.id}> (${member.id}) unbanned from the bot`)
+                        .addField('👤┆Unbanned By', `${interaction.user} (${interaction.user.tag})`, true)
+                        .setColor(client.config.colors.normal)
+                        .setFooter(client.config.discord.footer)
+                        .setTimestamp();
+                    webhookClientLogs.send({
+                        username: 'Bot Bans',
+                        embeds: [embedLogs],
+                    });
+                })
+            }
+            else {
+                return client.errNormal({
+                    error: `<@!${member.id}> (${member.id}) has not been banned from the bot`,
+                    type: `editreply`
+                }, interaction);
+            }
+        })
+    }
+}
+
+ 

src/commands/developers/credits.js

@@ -0,0 +1,73 @@
+const Discord = require('discord.js');
+
+const Schema = require('../../database/models/votecredits');
+
+const webhookClientLogs = new Discord.WebhookClient({
+    id: "",
+    token: "",
+});
+
+module.exports = async (client, interaction, args) => {
+    const type = interaction.options.getString('type');
+    const user = interaction.options.getUser('user');
+    const amount = interaction.options.getNumber('amount');
+
+    if (type == "add") {
+        Schema.findOne({ User: user.id }, async (err, data) => {
+            if (data) {
+                data.Credits += amount;
+                data.save();
+            }
+            else {
+                new Schema({
+                    User: user.id,
+                    Credits: amount
+                }).save();
+            }
+        })
+
+        client.succNormal({
+            text: `Added **${amount} credits** to ${user}`,
+            type: 'editreply'
+        }, interaction);
+
+        let embedLogs = new Discord.MessageEmbed()
+            .setTitle(`🪙・Credits added`)
+            .setDescription(`Added credits to ${user} (${user.id})`)
+            .addField('👤┆Added By', `${interaction.user} (${interaction.user.tag})`, true)
+            .addField(`🔢┆Amount`, `${amount}`, true)
+            .setColor(client.config.colors.normal)
+            .setTimestamp();
+        webhookClientLogs.send({
+            username: 'Bot Credits',
+            embeds: [embedLogs],
+        });
+    }
+    else if (type == "remove") {
+        Schema.findOne({ User: user.id }, async (err, data) => {
+            if (data) {
+                data.Credits -= amount;
+                data.save();
+            }
+        })
+
+        client.succNormal({
+            text: `Removed **${amount} credits** from ${user}`,
+            type: 'editreply'
+        }, interaction);
+
+        let embedLogs = new Discord.MessageEmbed()
+            .setTitle(`🪙・Credits removed`)
+            .setDescription(`Removed credits from ${user} (${user.id})`)
+            .addField('👤┆Removed By', `${interaction.user} (${interaction.user.tag})`, true)
+            .addField(`🔢┆Amount`, `${amount}`, true)
+            .setColor(client.config.colors.normal)
+            .setTimestamp();
+        webhookClientLogs.send({
+            username: 'Bot Credits',
+            embeds: [embedLogs],
+        });
+    }
+}
+
+ 

src/commands/developers/eval.js

@@ -0,0 +1,97 @@
+const Discord = require('discord.js');
+
+const { inspect } = require('util');
+
+module.exports = async (client, interaction, args) => {
+    const webhookClientLogs = new Discord.WebhookClient({
+        id: client.webhooks.evalLogs.id,
+        token: client.webhooks.evalLogs.token,
+    });
+
+    let code = interaction.options.getString('code');
+    if (code.includes('token') == true) return client.errNormal({ error: "I'm not going to send my token!", type: 'editreply' }, interaction);
+
+    code = code.replace(/[""]/g, '"').replace(/['']/g, "'");
+    let evaled;
+
+    try {
+        const start = process.hrtime();
+        evaled = eval(code);
+
+        if (evaled instanceof Promise) {
+            evaled = await evaled;
+        }
+
+        const stop = process.hrtime(start);
+        const outputResponse = `\`\`\`${inspect(evaled, { depth: 0 })}\n\`\`\``;
+
+        if (outputResponse.length <= 1024) {
+            await client.embed({
+                title: `💻・Eval`,
+                fields: [
+                    {
+                        name: "📥┇Input",
+                        value: `\`\`\`${code}\`\`\``,
+                        inline: false,
+                    },
+                    {
+                        name: "📥┇Output",
+                        value: outputResponse.substr(0, 1024),
+                        inline: false,
+                    },
+                ],
+                type: 'editreply'
+            }, interaction)
+
+            const embed2 = new Discord.MessageEmbed()
+                .setTitle(`${interaction.user.tag} used eval command`)
+                .addField("📥┇Input", `\`\`\`${code}\`\`\``)
+                .addField("📤┇Output", outputResponse.substr(0, 1024))
+                .setColor(client.config.colors.normal)
+                .setTimestamp();
+            webhookClientLogs.send({
+                username: 'Bot Logs',
+                embeds: [embed2],
+            });
+        }
+        else {
+            const output = new Discord.MessageAttachment(Buffer.from(outputResponse), 'output.txt');
+            var embed2 = new Discord.MessageEmbed()
+                .setAuthor(client.user.username, client.user.avatarURL())
+                .addField("📥┇Input", `\`\`\`${code}\`\`\``)
+                .setColor(client.config.colors.succes)
+                .setFooter(client.config.discord.footer)
+                .setTimestamp();
+            interaction.editreply({ embeds: [embed2] });
+            await interaction.channel.send({ files: [output] });
+        }
+    }
+    catch (err) {
+
+        return client.embed({
+            title: `💻・Eval`,
+            fields: [
+                {
+                    name: "📥┇Input",
+                    value: `\`\`\`${code}\`\`\``,
+                    inline: false,
+                },
+                {
+                    name: "📥┇Error!",
+                    value: `\`\`\`${clean(err)}\`\`\``,
+                    inline: false,
+                },
+            ],
+            type: 'editreply'
+        }, interaction)
+    }
+}
+
+const clean = text => {
+    if (typeof (text) === "string")
+        return text.replace(/`/g, "`" + String.fromCharCode(8203)).replace(/@/g, "@" + String.fromCharCode(8203));
+    else
+        return text;
+}
+
+ 

src/commands/developers/servers.js

@@ -0,0 +1,13 @@
+const Discord = require('discord.js');
+
+module.exports = async (client, interaction, args) => {
+    var list = "";
+    client.guilds.cache.forEach(guild => {
+        list += `${guild.name} (${guild.id}) | ${guild.memberCount} members | Owner: ${guild.ownerId}\n`
+    })
+
+    const output = new Discord.MessageAttachment(Buffer.from(list), 'servers.txt');
+    interaction.editreply({ files: [output] });
+}
+
+ 

src/commands/developers/whitelist.js

@@ -0,0 +1,49 @@
+const Discord = require('discord.js');
+
+const Schema = require('../../database/models/whitelist');
+
+module.exports = async (client, interaction, args) => {
+    const type = interaction.options.getString('type');
+    const guild = interaction.options.getString('guild');
+
+    if (interaction.author.id === "534398298002292739") {
+        if (type == "add") {
+            Schema.findOne({ Guild: guild }, async (err, data) => {
+                if (data) {
+                    data.Guild = guild;
+                    data.save();
+                }
+                else {
+                    new Schema({
+                        Guild: guild
+                    }).save();
+                }
+            })
+
+            client.succNormal({
+                text: `${guild} added to the bot whitelist`,
+                type: 'editreply'
+            }, interaction);
+        }
+        else if (type == "remove") {
+            Schema.findOne({ Guild: guild }, async (err, data) => {
+                if (data) {
+                    Schema.findOneAndDelete({ Guild: guild }).then(() => {
+                        client.succNormal({
+                            text: `${guild} removed from the bot whitelist`,
+                            type: 'editreply'
+                        }, interaction);
+                    })
+                }
+            })
+        }
+    }
+    else {
+        client.errNormal({
+            error: "Only the Bot CEO are allowed to do this",
+            type: 'editreply'
+        }, interaction);
+    }
+}
+
+ 

src/commands/economy/additem.js

@@ -0,0 +1,52 @@
+const Discord = require('discord.js');
+
+const store = require("../../database/models/economyStore");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.MANAGE_MESSAGES],
+        perms: ["MANAGE_MESSAGES"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const role = interaction.options.getRole('role');
+    let amount = interaction.options.getNumber('amount');
+
+    if (!role || !amount) return client.errUsage({ usage: "additem [role] [amount]", type: 'editreply' }, interaction);
+
+    if (isNaN(amount)) return client.errNormal({ error: "Enter a valid number!", type: 'editreply' }, interaction);
+
+    store.findOne({ Guild: interaction.guild.id, Role: role.id }, async (err, storeData) => {
+        if (storeData) {
+            client.errNormal({ error: `This role is already in the store!`, type: 'editreply' }, interaction);
+        }
+        else {
+
+            new store({
+                Guild: interaction.guild.id,
+                Role: role.id,
+                Amount: amount
+            }).save();
+
+            client.succNormal({
+                text: `The role was added to the store!`,
+                fields: [
+                    {
+                        name: `🛒┆Role`,
+                        value: `<@&${role.id}>`,
+                        inline: true
+                    },
+                    {
+                        name: `${client.emotes.economy.coins}┆Amount`,
+                        value: `$${amount}`,
+                        inline: true
+                    }
+                ],
+                type: 'editreply'
+            }, interaction);
+        }
+    })
+}
+
+ 

src/commands/economy/addmoney.js

@@ -0,0 +1,54 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.ADMINISTRATOR],
+        perms: ["ADMINISTRATOR"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const user = interaction.options.getUser('user');
+    let amount = interaction.options.getNumber('amount');
+
+    if (!user || !amount) return client.errUsage({ usage: "addmoney [user] [amount]", type: 'editreply' }, interaction);
+
+    if (isNaN(amount)) return client.errNormal({ error: "Enter a valid number!", type: 'editreply' }, interaction);
+
+    if (user.bot) return client.errNormal({
+        error: "You cannot add money to a bot!",
+        type: 'editreply'
+    }, interaction);
+
+    client.addMoney(interaction, user, parseInt(amount));
+
+    setTimeout(() => {
+        Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+            if (data) {
+
+                client.succNormal({
+                    text: `Added money to a user!`,
+                    fields: [
+                        {
+                            name: `👤┆User`,
+                            value: `<@!${user.id}>`,
+                            inline: true
+                        },
+                        {
+                            name: `${client.emotes.economy.coins}┆Amount`,
+                            value: `$${amount}`,
+                            inline: true
+                        }
+                    ],
+                    type: 'editreply'
+                }, interaction);
+            }
+            else {
+                client.errNormal({ error: `This user doesn't have any money!`, type: 'editreply' }, interaction);
+            }
+        }, 500)
+    })
+}
+ 

src/commands/economy/balance.js

@@ -0,0 +1,50 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+
+    const user = interaction.options.getUser('user') || interaction.user;
+
+    if (user.bot) return client.errNormal({
+        error: "You cannot see the balance of a bot!",
+        type: 'editreply'
+    }, interaction);
+
+    Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+        if (data) {
+
+            let total = data.Money + data.Bank;
+
+            client.embed({
+                title: `${client.emotes.economy.coins}・Balance`,
+                fields: [
+                    {
+                        name: `${client.emotes.economy.pocket}┆Wallet`,
+                        value: `$${data.Money}`,
+                        inline: true
+                    },
+                    {
+                        name: `${client.emotes.economy.bank}┆Bank`,
+                        value: `$${data.Bank}`,
+                        inline: true
+                    },
+                    {
+                        name: `💰┆Total`,
+                        value: `$${total}`,
+                        inline: true
+                    }
+                ],
+                desc: `The current balance of \`${user.tag}\``,
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+            client.errNormal({
+                error: `The user doesn't have any money!`, type: 'editreply'
+            }, interaction);
+        }
+    })
+}
+
+ 

src/commands/economy/beg.js

@@ -0,0 +1,50 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economyTimeout");
+
+module.exports = async (client, interaction, args) => {
+    let user = interaction.user;
+
+    let timeout = 180000;
+    let amount = 5;
+
+    Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+        if (dataTime && dataTime.Beg !== null && timeout - (Date.now() - dataTime.Beg) > 0) {
+            let time = (dataTime.Beg / 1000 + timeout / 1000).toFixed(0);
+            return client.errWait({
+                time: time,
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+
+            client.succNormal({
+                text: `You've begged for some money!`,
+                fields: [
+                    {
+                        name: `${client.emotes.economy.coins}┆Amount`,
+                        value: `$${amount}`,
+                        inline: true
+                    }
+                ],
+                type: 'editreply'
+            }, interaction);
+
+            if (dataTime) {
+                dataTime.Beg = Date.now();
+                dataTime.save();
+            }
+            else {
+                new Schema({
+                    Guild: interaction.guild.id,
+                    User: user.id,
+                    Beg: Date.now()
+                }).save();
+            }
+
+            client.addMoney(interaction, user, amount);
+        }
+    })
+}
+
+ 

src/commands/economy/buy.js

@@ -0,0 +1,69 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+const store = require("../../database/models/economyStore");
+
+module.exports = async (client, interaction, args) => {
+    const storeData = await store.find({ Guild: interaction.guild.id });
+    if (storeData.length == 0) return client.errNormal({
+        error: `No shop found in this server`,
+        type: 'editreply'
+    }, interaction);
+
+    let labels = [];
+
+    storeData.forEach(d => {
+        const role = interaction.guild.roles.cache.get(d.Role);
+
+        const generated = {
+            label: `${role.name.substr(0, 24)}.`,
+            value: role.id,
+        }
+
+        return labels.push(generated);
+    });
+
+    const select = await client.generateSelect(`economyBuy`, labels);
+
+    client.embed({
+        title: `🛒・${interaction.guild.name}'s Store`,
+        desc: `Choose a item from the menu to buy`,
+        components: [select],
+        type: 'editreply'
+    }, interaction)
+
+    const filter = i => {
+        i.deferUpdate();
+        return i.user.id === interaction.user.id;
+    };
+
+    interaction.channel.awaitMessageComponent({ filter, componentType: 'SELECT_MENU', time: 60000 }).then(async i => {
+        const role = i.values[0];
+        const buyPerson = i.guild.members.cache.get(i.user.id);
+
+        const data = await Schema.findOne({ Guild: i.guild.id, User: i.user.id });
+        const checkStore = await store.findOne({ Guild: i.guild.id, Role: role });
+
+        if (parseInt(checkStore.Amount) > parseInt(data.Money)) return client.errNormal({
+            error: `You don't have enough money to buy this!`,
+            type: 'editreply'
+        }, i);
+
+        client.removeMoney(i, i.user, parseInt(checkStore.Amount));
+
+        buyPerson.roles.add(role);
+
+        client.succNormal({
+            text: `The purchase has been successfully completed`,
+            fields: [
+                {
+                    name: `📘┆Item`,
+                    value: `<@&${role}>`
+                }
+            ],
+            type: 'editreply'
+        }, i);
+    })
+}
+
+ 

src/commands/economy/clear.js

@@ -0,0 +1,66 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+const store = require("../../database/models/economyStore");
+
+module.exports = async (client, interaction, args) => {
+
+    client.checkPerms({
+        flags: [Discord.Permissions.FLAGS.ADMINISTRATOR],
+        perms: ["ADMINISTRATOR"]
+    }, interaction)
+
+
+    const row = new Discord.MessageActionRow() 
+        .addComponents(
+            new Discord.MessageButton()
+                .setCustomId('eco_go')
+                .setEmoji('✅')
+                .setStyle('SUCCESS'),
+
+            new Discord.MessageButton()
+                .setCustomId('eco_stop')
+                .setEmoji('❌')
+                .setStyle('DANGER'),
+        );
+
+    client.embed({
+        title: `⏰・Reset economy`,
+        desc: `Are you sure you want to reset the economy?`,
+        components: [row],
+        type: 'editreply',
+    }, interaction)
+
+    const filter = i => i.user.id === interaction.user.id;
+
+    interaction.channel.awaitMessageComponent({ filter, componentType: 'BUTTON', time: 60000 }).then(async i => {
+        if (i.customId == "eco_go") {
+            var remove = await Schema.deleteMany({ Guild: interaction.guild.id });
+            var remove2 = await Schema2.deleteMany({ Guild: interaction.guild.id });
+            var remove3 = await store.deleteMany({ Guild: interaction.guild.id });
+
+            client.succNormal({
+                text: `The economy has been successfully reset in this guild!`,
+                components: [],
+                type: 'editreply'
+            }, interaction);
+        }
+
+        if (i.customId == "eco_stop") {
+            client.errNormal({
+                error: `The economy reset has been cancelled!`,
+                components: [],
+                type: 'editreply'
+            }, interaction);
+        }
+    })
+        .catch(() => {
+            client.errNormal({
+                error: "Time's up! Cancelled the economy reset!",
+                type: 'editreply'
+            }, interaction);
+        });
+}
+
+ 

src/commands/economy/crime.js

@@ -0,0 +1,80 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+
+module.exports = async (client, interaction, args) => {
+
+    let user = interaction.user;
+    let timeout = 600000;
+
+    Schema2.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+        if (dataTime && dataTime.Crime !== null && timeout - (Date.now() - dataTime.Crime) > 0) {
+            let time = (dataTime.Crime / 1000 + timeout / 1000).toFixed(0);
+            return client.errWait({
+                time: time,
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+
+            let replies = ['Hacking', 'Burglary', 'Roberry', 'Murder', 'Dealing drugs', 'Child abuse', 'Arms trade', 'Street robbery'];
+
+            let result = Math.floor((Math.random() * replies.length));
+            let result2 = Math.floor((Math.random() * 10));
+            let amount = Math.floor(Math.random() * 80) + 1;
+
+            if (result2 > 7) {
+
+                client.succNormal({
+                    text: `Your crime went successfully!`,
+                    fields: [
+                        {
+                            name: `🦹‍♂️┆Crime`,
+                            value: `${replies[result]}`,
+                            inline: true
+                        },
+                        {
+                            name: `${client.emotes.economy.coins}┆Earned`,
+                            value: `$${amount}`,
+                            inline: true
+                        }
+                    ],
+                    type: 'editreply'
+                }, interaction);
+
+                client.addMoney(interaction, user, amount);
+
+                if (dataTime) {
+                    dataTime.Crime = Date.now();
+                    dataTime.save();
+                }
+
+                else {
+                    new Schema2({
+                        Guild: interaction.guild.id,
+                        User: user.id,
+                        Crime: Date.now()
+                    }).save();
+                }
+            }
+            else {
+                client.errNormal({ error: `You were caught carrying out the crime ${replies[result]}`, type: 'editreply' }, interaction);
+
+                if (dataTime) {
+                    dataTime.Crime = Date.now();
+                    dataTime.save();
+                }
+                else {
+                    new Schema2({
+                        Guild: interaction.guild.id,
+                        User: user.id,
+                        Crime: Date.now()
+                    }).save();
+                }
+            }
+        }
+    })
+}
+
+ 

src/commands/economy/daily.js

@@ -0,0 +1,50 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+
+module.exports = async (client, interaction, args) => {
+  let user = interaction.user;
+  let timeout = 86400000;
+  let amount = 200;
+
+  Schema2.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+    if (dataTime && dataTime.Daily !== null && timeout - (Date.now() - dataTime.Daily) > 0) {
+      let time = (dataTime.Daily / 1000 + timeout / 1000).toFixed(0);
+      return client.errWait({
+        time: time,
+        type: 'editreply'
+      }, interaction);
+    }
+    else {
+
+      client.succNormal({
+        text: `You've collected your daily reward!`,
+        fields: [
+          {
+            name: `${client.emotes.economy.coins}┆Amount`,
+            value: `$${amount}`,
+            inline: true
+          }
+        ],
+        type: 'editreply'
+      }, interaction);
+
+      if (dataTime) {
+        dataTime.Daily = Date.now();
+        dataTime.save();
+      }
+      else {
+        new Schema2({
+          Guild: interaction.guild.id,
+          User: user.id,
+          Daily: Date.now()
+        }).save();
+      }
+
+      client.addMoney(interaction, user, amount);
+    }
+  })
+}
+
+ 

src/commands/economy/deleteitem.js

@@ -0,0 +1,43 @@
+const Discord = require('discord.js');
+
+const store = require("../../database/models/economyStore");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.MANAGE_MESSAGES],
+        perms: ["MANAGE_MESSAGES"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const role = interaction.options.getRole('role');
+
+    if (!role) return client.errUsage({ usage: "deleteitem [role]", type: 'editreply' }, interaction);
+
+    store.findOne({ Guild: interaction.guild.id, Role: role.id }, async (err, storeData) => {
+        if (storeData) {
+
+            var remove = await store.deleteOne({ Guild: interaction.guild.id, Role: role.id });
+
+            client.succNormal({
+                text: `The role was deleted from the store`,
+                fields: [
+                    {
+                        name: `🛒┆Role`,
+                        value: `${role}`
+                    }
+                ],
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+
+            client.errNormal({
+                error: `This role is not in the store!`,
+                type: 'editreply'
+            }, interaction);
+        }
+    })
+}
+
+ 

src/commands/economy/deposit.js

@@ -0,0 +1,43 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+
+    let amount = interaction.options.getNumber('amount');
+    let user = interaction.user;
+
+    if (!amount) return client.errUsage({ usage: "deposit [amount]", type: 'editreply' }, interaction);
+
+    if (isNaN(amount)) return client.errNormal({ error: "Enter a valid number!", type: 'editreply' }, interaction);
+
+    if (amount < 0) return client.errNormal({ error: `You can't deposit negative money!`, type: 'editreply' }, interaction);
+
+    Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+        if (data) {
+            if (data.Money < parseInt(amount)) return client.errNormal({ error: `You don't have that much money!`, type: 'editreply' }, interaction);
+
+            let money = parseInt(amount);
+
+            data.Money -= money;
+            data.Bank += money;
+            data.save();
+
+            client.succNormal({
+                text: `You've have deposited some money into your bank!`,
+                fields: [
+                    {
+                        name: `${client.emotes.economy.coins}┆Amount`,
+                        value: `$${amount}`,
+                        inline: true
+                    }
+                ],
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+            client.errNormal({ text: `You don't have any money to deposit!`, type: 'editreply' }, interaction);
+        }
+    })
+}
+ 

src/commands/economy/fish.js

@@ -0,0 +1,80 @@
+const Discord = require('discord.js');
+const ms = require("ms");
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+const itemSchema = require("../../database/models/economyItems");
+
+module.exports = async (client, interaction, args) => {
+
+    const rand = (min, max) => {
+        return Math.floor(Math.random() * (max - min)) + min;
+    };
+
+    let user = interaction.user;
+
+    let timeout = 60000;
+    let fish =
+        ["Yellow Fish :tropical_fish:",
+            "Fat Fish :blowfish:",
+            "Blue Fish :fish:",
+            "Coconut :coconut:",
+            "Dolphin :dolphin:",
+            "Lobster :lobster:",
+            "Shark :shark:",
+            "Crab :crab:",
+            "Squid :squid:",
+            "Whale :whale2:",
+            "Shrimp :shrimp:",
+            "Octopus :octopus:",
+            "Diamond :gem:"];
+
+    let randn = rand(0, parseInt(fish.length));
+    let randrod = rand(15, 30);
+
+    let fishToWin = fish[randn];
+
+    const userItems = await itemSchema.findOne({ Guild: interaction.guild.id, User: user.id });
+
+    if (!userItems || userItems.FishingRod == false) return client.errNormal({ error: "You have to buy a fishing rod!", type: 'editreply' }, interaction);
+
+    if (userItems) {
+        if (userItems.FishingRodUsage >= randrod) {
+            userItems.FishingRod = false;
+            userItems.save();
+
+            return client.errNormal({ error: "Your fishing rod has broken! Go buy a new one!", type: 'editreply' }, interaction);
+        }
+    }
+
+    Schema2.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+        if (dataTime && dataTime.Fish !== null && timeout - (Date.now() - dataTime.Fish) > 0) {
+            let time = (dataTime.Fish / 1000 + timeout / 1000).toFixed(0);
+
+            return client.errWait({ time: time, type: 'editreply' }, interaction);
+        }
+        else {
+            client.succNormal({ text: `You've fished and gotten a ${fishToWin}`, type: 'editreply' }, interaction);
+
+            if (userItems) {
+                userItems.FishingRodUsage += 1;
+                userItems.save();
+            }
+
+            if (dataTime) {
+                dataTime.Fish = Date.now();
+                dataTime.save();
+            }
+            else {
+                new Schema2({
+                    Guild: message.guild.id,
+                    User: user.id,
+                    Fish: Date.now()
+                }).save();
+            }
+        }
+    })
+
+}
+
+ 

src/commands/economy/hourly.js

@@ -0,0 +1,50 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+
+module.exports = async (client, interaction, args) => {
+    let user = interaction.user;
+    let timeout = 3600000;
+    let amount = 10;
+
+    Schema2.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+        if (dataTime && dataTime.Hourly !== null && timeout - (Date.now() - dataTime.Hourly) > 0) {
+            let time = (dataTime.Hourly / 1000 + timeout / 1000).toFixed(0);
+            return client.errWait({
+                time: time,
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+
+            client.succNormal({
+                text: `You've collected your hourly reward!`,
+                fields: [
+                    {
+                        name: `${client.emotes.economy.coins}┆Amount`,
+                        value: `$${amount}`,
+                        inline: true
+                    }
+                ],
+                type: 'editreply'
+            }, interaction);
+
+            if (dataTime) {
+                dataTime.Hourly = Date.now();
+                dataTime.save();
+            }
+            else {
+                new Schema2({
+                    Guild: interaction.guild.id,
+                    User: user.id,
+                    Hourly: Date.now()
+                }).save();
+            }
+
+            client.addMoney(interaction, user, amount);
+        }
+    })
+}
+
+ 

src/commands/economy/hunt.js

@@ -0,0 +1,62 @@
+const Discord = require('discord.js');
+const ms = require("ms");
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+const itemSchema = require("../../database/models/economyItems");
+
+module.exports = async (client, interaction, args) => {
+
+    const rand = (min, max) => {
+        return Math.floor(Math.random() * (max - min)) + min;
+    };
+
+    let user = interaction.user;
+
+    let timeout = 60000;
+    let hunt =
+        ["Rabbit :rabbit:",
+            "Frog :frog:",
+            "Monkey :monkey:",
+            "Chicken :chicken:",
+            "Wolf :wolf:",
+            "Rooster :rooster:",
+            "Turkey :turkey:",
+            "Chipmunk :chipmunk:",
+            "Water Buffalo :water_buffalo:",
+            "Race Horse :racehorse:",
+            "Pig :pig:",
+            "Snake :snake:",
+            "Cow :cow:"];
+
+    let randn = rand(0, parseInt(hunt.length));
+    let randrod = rand(15, 30);
+
+    let huntToWin = hunt[randn];
+
+    Schema2.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+        if (dataTime && dataTime.Hunt !== null && timeout - (Date.now() - dataTime.Hunt) > 0) {
+            let time = (dataTime.Hunt / 1000 + timeout / 1000).toFixed(0);
+
+            return client.errWait({ time: time, type: 'editreply' }, interaction);
+        }
+        else {
+            client.succNormal({ text: `You've hunted and gotten a ${huntToWin}`, type: 'editreply' }, interaction);
+
+            if (dataTime) {
+                dataTime.Hunt = Date.now();
+                dataTime.save();
+            }
+            else {
+                new Schema2({
+                    Guild: interaction.guild.id,
+                    User: user.id,
+                    Hunt: Date.now()
+                }).save();
+            }
+        }
+    })
+
+}
+
+ 

src/commands/economy/leaderboard.js

@@ -0,0 +1,34 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+    const type = interaction.options.getString("type");
+
+    if (type == "money") {
+        const rawLeaderboard = await Schema.find({ Guild: interaction.guild.id }).sort(([['Money', 'descending']]));
+
+        if (!rawLeaderboard) return client.errNormal({ 
+            error: "No data found!",
+            type: 'editreply'
+        }, interaction);
+
+        const lb = rawLeaderboard.map(e => `**${rawLeaderboard.findIndex(i => i.Guild === interaction.guild.id && i.User === e.User) + 1}** | <@!${e.User}> - ${client.emotes.economy.coins} \`$${e.Money}\``);
+
+        await client.createLeaderboard(`🪙・Money - ${interaction.guild.name}`, lb, interaction);
+    }
+    else if (type == "bank") {
+        const rawLeaderboard = await Schema.find({ Guild: interaction.guild.id }).sort(([['Bank', 'descending']]));
+
+        if (!rawLeaderboard) return client.errNormal({ 
+            error: "No data found!",
+            type: 'editreply'
+        }, interaction);
+
+        const lb = rawLeaderboard.map(e => `**${rawLeaderboard.findIndex(i => i.Guild === interaction.guild.id && i.User === e.User) + 1}** | <@!${e.User}> - ${client.emotes.economy.bank} \`$${e.Bank}\``);
+
+        await client.createLeaderboard(`🏦・Bank - ${interaction.guild.name}`, lb, interaction);
+    }
+}
+
+ 

src/commands/economy/monthly.js

@@ -0,0 +1,50 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+
+module.exports = async (client, interaction, args) => {
+  let user = interaction.user;
+  let timeout = 2419200000;
+  let amount = 1000;
+
+  Schema2.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+    if (dataTime && dataTime.Monthly !== null && timeout - (Date.now() - dataTime.Monthly) > 0) {
+      let time = (dataTime.Monthly / 1000 + timeout / 1000).toFixed(0);
+      return client.errWait({
+        time: time,
+        type: 'editreply'
+      }, interaction);
+    }
+    else {
+
+      client.succNormal({
+        text: `You've collected your monthly reward!`,
+        fields: [
+          {
+            name: `${client.emotes.economy.coins}┆Amount`,
+            value: `$${amount}`,
+            inline: true
+          }
+        ],
+        type: 'editreply'
+      }, interaction);
+
+      if (dataTime) {
+        dataTime.Monthly = Date.now();
+        dataTime.save();
+      }
+      else {
+        new Schema2({
+          Guild: interaction.guild.id,
+          User: user.id,
+          Monthly: Date.now()
+        }).save();
+      }
+
+      client.addMoney(interaction, user, amount);
+    }
+  })
+}
+
+ 

src/commands/economy/pay.js

@@ -0,0 +1,53 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+
+    const user = await interaction.guild.members.fetch(interaction.options.getUser('user'));
+    let amount = interaction.options.getNumber('amount');
+    
+    if (amount < 0) return client.errNormal({ error: `You can't pay negative money!`, type: 'editreply' }, interaction);
+
+    if (user.id == interaction.user.id) {
+        return client.errNormal({
+            error: "You cannot pay money to yourself!",
+            type: 'editreply'
+        }, interaction)
+    }
+
+    Schema.findOne({ Guild: interaction.guild.id, User: interaction.user.id }, async (err, data) => {
+        if (data) {
+            if (data.Money < parseInt(amount)) return client.errNormal({ error: `You don't have that much money!`, type: 'editreply' }, interaction);
+
+            let money = parseInt(amount);
+
+            data.Money -= money;
+            data.save();
+
+            client.addMoney(interaction, user, money);
+
+            client.succNormal({
+                text: `You have payed some money to a user!`,
+                fields: [
+                    {
+                        name: `👤┆User`,
+                        value: `$${user}`,
+                        inline: true
+                    },
+                    {
+                        name: `${client.emotes.economy.coins}┆Amount`,
+                        value: `$${amount}`,
+                        inline: true
+                    }
+                ],
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+            client.errNormal({ text: `You don't have any money!`, type: 'editreply' }, interaction);
+        }
+    })
+}
+
+ 

src/commands/economy/present.js

@@ -0,0 +1,51 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+
+module.exports = async (client, interaction, args) => {
+    let user = interaction.user;
+    let timeout = 604800000;
+
+
+    Schema2.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+        if (dataTime && dataTime.Present !== null && timeout - (Date.now() - dataTime.Present) > 0) {
+            let time = (dataTime.Present / 1000 + timeout / 1000).toFixed(0);
+            return client.errWait({
+                time: time,
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+            let amount = Math.floor(Math.random() * 1000) + 1;
+
+            client.succNormal({
+                text: `You've collected your present reward!`,
+                fields: [
+                    {
+                        name: `${client.emotes.economy.coins}┆Amount`,
+                        value: `$${amount}`,
+                        inline: true
+                    }
+                ],
+                type: 'editreply'
+            }, interaction);
+
+            if (dataTime) {
+                dataTime.Present = Date.now();
+                dataTime.save();
+            }
+            else {
+                new Schema2({
+                    Guild: interaction.guild.id,
+                    User: user.id,
+                    Present: Date.now()
+                }).save();
+            }
+
+            client.addMoney(interaction, user, amount);
+        }
+    })
+}
+
+ 

src/commands/economy/removemoney.js

@@ -0,0 +1,54 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+    const perms = await client.checkUserPerms({
+        flags: [Discord.Permissions.FLAGS.ADMINISTRATOR],
+        perms: ["ADMINISTRATOR"]
+    }, interaction)
+
+    if (perms == false) return;
+
+    const user = interaction.options.getUser('user');
+    let amount = interaction.options.getNumber('amount');
+
+    if (!user || !amount) return client.errUsage({ usage: "addmoney [user] [amount]", type: 'editreply' }, interaction);
+
+    if (isNaN(amount)) return client.errNormal({ error: "Enter a valid number!", type: 'editreply' }, interaction);
+
+    if (user.bot) return client.errNormal({
+        error: "You cannot remove money from a bot!",
+        type: 'editreply'
+    }, interaction);
+
+    client.removeMoney(interaction, user, parseInt(amount));
+
+    setTimeout(() => {
+        Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+            if (data) {
+
+                client.succNormal({
+                    text: `Removed money from a user!`,
+                    fields: [
+                        {
+                            name: `👤┆User`,
+                            value: `<@!${user.id}>`,
+                            inline: true
+                        },
+                        {
+                            name: `${client.emotes.economy.coins}┆Amount`,
+                            value: `$${amount}`,
+                            inline: true
+                        }
+                    ],
+                    type: 'editreply'
+                }, interaction);
+            }
+            else {
+                client.errNormal({ error: `This user doesn't have any money!`, type: 'editreply' }, interaction);
+            }
+        }, 500)
+    })
+}
+ 

src/commands/economy/rob.js

@@ -0,0 +1,95 @@
+const Discord = require('discord.js');
+const ms = require("ms");
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+
+module.exports = async (client, interaction, args) => {
+
+    const user = interaction.options.getUser('user');
+    if (!user) return client.errUsage({ usage: "rob [mention user]", type: 'editreply' }, interaction);
+
+    if (user.bot) return client.errNormal({
+        error: "You rob a bot!",
+        type: 'editreply'
+    }, interaction);
+
+    try {
+        let timeout = 600000;
+
+        Schema2.findOne({ Guild: interaction.guild.id, User: interaction.user.id }, async (err, dataTime) => {
+            if (dataTime && dataTime.Rob !== null && timeout - (Date.now() - dataTime.Rob) > 0) {
+                let time = (dataTime.Rob / 1000 + timeout / 1000).toFixed(0);
+                return client.errWait({ time: time, type: 'editreply' }, interaction);
+            }
+            else {
+                Schema.findOne({ Guild: interaction.guild.id, User: interaction.user.id }, async (err, authorData) => {
+                    if (authorData) {
+                        if (authorData.Money < 200) return client.errNormal({ error: `You need atleast 200 coins in your wallet to rob someone!`, type: 'editreply' }, interaction);
+
+                        Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, targetData) => {
+                            if (targetData) {
+                                console.log(targetData.Money)
+                                if (targetData = undefined || !targetData || targetData.Money == 0 || targetData.Money < 0) {
+                                    return client.errNormal({ error: `${user.user.username} does not have anything you can rob!`, type: 'editreply' }, interaction);
+                                }
+
+                                if (dataTime) {
+                                    dataTime.Rob = Date.now();
+                                    dataTime.save();
+                                }
+                                else {
+                                    new Schema2({
+                                        Guild: interaction.guild.id,
+                                        User: interaction.user.id,
+                                        Rob: Date.now()
+                                    }).save();
+                                }
+
+                                random = Math.floor(Math.random() * 100) + 1;
+
+                                if (targetData.Money < random) {
+                                    random = targetData.Money;
+
+                                    authorData.Money += targetData.Money;
+                                    authorData.save();
+
+                                    client.removeMoney(interaction, user, targetData.Money);
+                                }
+                                else {
+                                    authorData.Money += random;
+                                    authorData.save();
+
+                                    client.removeMoney(interaction, user, random);
+                                }
+
+                                client.succNormal({
+                                    text: `Your robbed a user and got away!`,
+                                    fields: [
+                                        {
+                                            name: `👤┆User`,
+                                            value: `${user}`,
+                                            inline: true
+                                        },
+                                        {
+                                            name: `${client.emotes.economy.coins}┆Robbed`,
+                                            value: `$${random}`,
+                                            inline: true
+                                        }
+                                    ],
+                                    type: 'editreply'
+                                }, interaction);
+                            }
+                            else {
+                                return client.errNormal({ error: `${user.user.username} does not have anything you can rob!`, type: 'editreply' }, interaction);
+                            }
+                        })
+                    }
+                })
+            }
+        })
+    }
+    catch { }
+}
+
+ 

src/commands/economy/store.js

@@ -0,0 +1,26 @@
+const Discord = require('discord.js');
+
+const store = require("../../database/models/economyStore");
+
+module.exports = async (client, interaction, args, message) => {
+    store.find({ Guild: interaction.guild.id }, async (err, storeData) => {
+        if (storeData && storeData.length > 0) {
+            const lb = storeData.map(e => `**<@&${e.Role}>** - ${client.emotes.economy.coins} $${e.Amount} \n**To buy:** \`buy ${e.Role}\``);
+
+            await client.createLeaderboard(`🛒・${interaction.guild.name}'s Store`, lb, interaction);
+            client.embed({ 
+                title: `🛒・Bot's Store`, 
+                desc: `**Fishingrod** - ${client.emotes.economy.coins} $100 \n**To buy:** \`buy fishingrod\``, 
+            }, interaction.channel);
+        }
+        else {
+            client.errNormal({ 
+                error: `No store found in this guild!`, 
+                type: 'editreply' 
+            }, interaction);
+        }
+    })
+
+}
+
+ 

src/commands/economy/weekly.js

@@ -0,0 +1,50 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+
+module.exports = async (client, interaction, args) => {
+  let user = interaction.user;
+  let timeout = 604800000;
+  let amount = 500;
+
+  Schema2.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+    if (dataTime && dataTime.Weekly !== null && timeout - (Date.now() - dataTime.Weekly) > 0) {
+      let time = (dataTime.Weekly / 1000 + timeout / 1000).toFixed(0);
+      return client.errWait({
+        time: time,
+        type: 'editreply'
+      }, interaction);
+    }
+    else {
+
+      client.succNormal({
+        text: `You've collected your weekly reward!`,
+        fields: [
+          {
+            name: `${client.emotes.economy.coins}┆Amount`,
+            value: `$${amount}`,
+            inline: true
+          }
+        ],
+        type: 'editreply'
+      }, interaction);
+
+      if (dataTime) {
+        dataTime.Weekly = Date.now();
+        dataTime.save();
+      }
+      else {
+        new Schema2({
+          Guild: interaction.guild.id,
+          User: user.id,
+          Weekly: Date.now()
+        }).save();
+      }
+
+      client.addMoney(interaction, user, amount);
+    }
+  })
+}
+
+ 

src/commands/economy/withdraw.js

@@ -0,0 +1,43 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+
+module.exports = async (client, interaction, args) => {
+
+    let amount = interaction.options.getNumber('amount');
+    let user = interaction.user;
+
+    if (!amount) return client.errUsage({ usage: "withdraw [amount]", type: 'editreply' }, interaction);
+
+    if (isNaN(amount)) return client.errNormal({ error: "Enter a valid number!", type: 'editreply' }, interaction);
+
+    if (amount < 0) return client.errNormal({ error: `You can't withdraw negative money!`, type: 'editreply' }, interaction);
+
+    Schema.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, data) => {
+        if (data) {
+            if (data.Bank === 0) return client.errNormal({ error: `You have nothing left in the bank!`, type: 'editreply' }, interaction);
+
+            let money = parseInt(amount);
+
+            data.Money += money;
+            data.Bank -= money;
+            data.save();
+
+            client.succNormal({
+                text: `You've have withdrawn some money from your bank!`,
+                fields: [
+                    {
+                        name: `${client.emotes.economy.coins}┆Amount`,
+                        value: `$${amount}`,
+                        inline: true
+                    }
+                ],
+                type: 'editreply'
+            }, interaction);
+        }
+        else {
+            client.errNormal({ text: `You don't have any money to withdraw!`, type: 'editreply' }, interaction);
+        }
+    })
+}
+ 

src/commands/economy/work.js

@@ -0,0 +1,60 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+
+module.exports = async (client, interaction, args) => {
+  let user = interaction.user;
+  let timeout = 600000;
+
+  Schema2.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+    if (dataTime && dataTime.Work !== null && timeout - (Date.now() - dataTime.Work) > 0) {
+      let time = (dataTime.Work / 1000 + timeout / 1000).toFixed(0);
+      return client.errWait({
+        time: time,
+        type: 'editreply'
+      }, interaction);
+    }
+    else {
+      let replies = ['Programmer', 'Hacker', 'Waiter', 'Busboy', 'Chief', 'Mechanic']
+
+      let result = Math.floor((Math.random() * replies.length));
+      let amount = Math.floor(Math.random() * 100) + 1;
+
+      client.succNormal({ text: `You worked as a ${replies[result]} and earned: **${client.emotes.economy.coins} $${amount}**`, type: 'editreply' }, interaction);
+
+      client.succNormal({
+        text: `You've wokred and earned some money!`,
+        fields: [
+          {
+            name: `🦹‍♂️┆Crime`,
+            value: `${replies[result]}`,
+            inline: true
+          },
+          {
+            name: `${client.emotes.economy.coins}┆Earned`,
+            value: `$${amount}`,
+            inline: true
+          }
+        ],
+        type: 'editreply'
+      }, interaction);
+
+      if (dataTime) {
+        dataTime.Work = Date.now();
+        dataTime.save();
+      }
+      else {
+        new Schema2({
+          Guild: interaction.guild.id,
+          User: user.id,
+          Work: Date.now()
+        }).save();
+      }
+
+      client.addMoney(interaction, user, amount);
+    }
+  })
+}
+
+ 

src/commands/economy/yearly.js

@@ -0,0 +1,54 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/economy");
+const Schema2 = require("../../database/models/economyTimeout");
+
+module.exports = async (client, interaction, args) => {
+  let user = interaction.user;
+  let timeout = 31557600000;
+  let amount = 5000;
+
+  Schema2.findOne({ Guild: interaction.guild.id, User: user.id }, async (err, dataTime) => {
+    if (dataTime && dataTime.Yearly !== null && timeout - (Date.now() - dataTime.Yearly) > 0) {
+      let time = (dataTime.Yearly / 1000 + timeout / 1000).toFixed(0);
+      return client.errWait({
+        time: time,
+        type: 'editreply'
+      }, interaction);
+    }
+    else {
+      client.succNormal({
+        text: `You've collected your yearly reward of **${client.emotes.economy.coins} $${amount}**`,
+        type: 'editreply'
+      }, interaction);
+
+      client.succNormal({
+        text: `You've collected your yearly reward!`,
+        fields: [
+          {
+            name: `${client.emotes.economy.coins}┆Earned`,
+            value: `$${amount}`,
+            inline: true
+          }
+        ],
+        type: 'editreply'
+      }, interaction);
+
+      if (dataTime) {
+        dataTime.Yearly = Date.now();
+        dataTime.save();
+      }
+      else {
+        new Schema2({
+          Guild: interaction.guild.id,
+          User: user.id,
+          Yearly: Date.now()
+        }).save();
+      }
+
+      client.addMoney(interaction, user, amount);
+    }
+  })
+}
+
+ 

src/commands/family/adopt.js

@@ -0,0 +1,119 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/family");
+
+module.exports = async (client, interaction, args) => {
+
+    const target = interaction.options.getUser('user');
+    const author = interaction.user;
+
+    if (author.id == target.id) return client.errNormal({
+        error: "You cannot adopt yourself",
+        type: 'editreply'
+    }, interaction);
+
+    if (target.bot) return client.errNormal({
+        error: "You cannot adopt a bot",
+        type: 'editreply'
+    }, interaction);
+
+    const familyMember = await Schema.findOne({ Guild: interaction.guild.id, User: target.id, Parent: author.id });
+    const familyMember2 = await Schema.findOne({ Guild: interaction.guild.id, User: author.id, Parent: target.id });
+    const familyMember3 = await Schema.findOne({ Guild: interaction.guild.id, User: author.id, Partner: target.id });
+
+    if (familyMember || familyMember2 || familyMember3) {
+        return client.errNormal({
+            error: `You cannot adopt a family member!`,
+            type: 'editreply'
+        }, interaction);
+    }
+
+    const checkAdopt = await Schema.findOne({ Guild: interaction.guild.id, Children: target.username });
+    if (checkAdopt) {
+        return client.errNormal({
+            error: `This user has already been adopted`,
+            type: 'editreply'
+        }, interaction);
+    }
+
+    const row = new Discord.MessageActionRow()
+        .addComponents(
+            new Discord.MessageButton()
+                .setCustomId('adopt_yes')
+                .setEmoji('✅')
+                .setStyle('SUCCESS'),
+
+            new Discord.MessageButton()
+                .setCustomId('adopt_deny')
+                .setEmoji('❌')
+                .setStyle('DANGER'),
+        );
+
+    client.embed({
+        title: `👪・Adoption`,
+        desc: `${author} has ${target} asked to adopt him! \n${target} click on one of the buttons`,
+        components: [row],
+        content: `${target}`,
+        type: 'editreply',
+    }, interaction)
+
+    const filter = i => i.user.id === target.id;
+
+    interaction.channel.awaitMessageComponent({ filter, componentType: 'BUTTON', time: 60000 }).then(async i => {
+        if (i.customId == "adopt_yes") {
+
+            Schema.findOne({ Guild: interaction.guild.id, User: author.id }, async (err, data) => {
+                if (data) {
+                    data.Children.push(target.username);
+                    data.save();
+                }
+                else {
+                    new Schema({
+                        Guild: interaction.guild.id,
+                        User: author.id,
+                        Children: target.username
+                    }).save();
+                }
+            })
+
+            Schema.findOne({ Guild: interaction.guild.id, User: target.id }, async (err, data) => {
+                if (data) {
+                    data.Parent.push(author.username);
+                    data.save();
+                }
+                else {
+                    new Schema({
+                        Guild: interaction.guild.id,
+                        User: target.id,
+                        Parent: author.username
+                    }).save();
+                }
+            })
+
+            client.embed({
+                title: `👪・Adoption - Approved`,
+                desc: `${author} is now the proud parent of ${target}! 🎉`,
+                components: [],
+                type: 'editreply'
+            }, interaction);
+        }
+
+        if (i.customId == "adopt_deny") {
+            client.embed({
+                title: `👪・Adoption - Denied`,
+                desc: `${target} don't want to be adopted by ${author}`,
+                components: [],
+                type: 'editreply'
+            }, interaction);
+        }
+    }).catch(() => {
+        client.embed({
+            title: `👪・Adoption - Denied`,
+            desc: `${target} has not answered anything! The adoption is canceled`,
+            components: [],
+            type: 'editreply'
+        }, interaction);
+    });
+}
+
+ 

src/commands/family/delete.js

@@ -0,0 +1,61 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/family");
+
+module.exports = async (client, interaction, args) => {
+
+    const row = new Discord.MessageActionRow()
+        .addComponents(
+            new Discord.MessageButton()
+                .setCustomId('family_delete')
+                .setEmoji('✅')
+                .setStyle('SUCCESS'),
+
+            new Discord.MessageButton()
+                .setCustomId('family_stop')
+                .setEmoji('❌')
+                .setStyle('DANGER'),
+        );
+
+    client.embed({
+        title: `${client.emotes.normal.error}・Reset family`,
+        desc: `Are you sure you want to reset your family?`,
+        components: [row],
+        type: 'editreply'
+    }, interaction);
+
+    const filter = i => i.user.id === interaction.user.id;
+
+    interaction.channel.awaitMessageComponent({ filter, time: 60000 })
+        .then(async i => {
+            if (i.customId == "family_delete") {
+                i.message.delete();
+
+                var remove = await Schema.findOneAndDelete({ Guild: interaction.guild.id, User: interaction.author.id });
+                const parent = await Schema.findOne({ Guild: interaction.guild.id, Parent: interaction.author.id });
+                const partner = await Schema.findOne({ Guild: interaction.guild.id, Partner: interaction.author.id });
+
+                if (parent) {
+                    parent.Parent = " ";
+                    parent.save();
+                }
+
+                if (partner) {
+                    partner.Partner = " ";
+                    partner.save();
+                }
+
+                client.succNormal({ text: `Your family has been deleted!`, type: 'editreply' }, interaction);
+            }
+
+            if (i.customId == "family_stop") {
+                i.message.delete();
+            }
+        })
+        .catch((err) => {
+            console.log(err)
+            client.errNormal({ error: "Time's up! Cancelled backup loading!", type: 'editreply' }, interaction);
+        });
+}
+
+ 

src/commands/family/disown.js

@@ -0,0 +1,65 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/family");
+
+module.exports = async (client, interaction, args) => {
+
+    const target = interaction.options.getUser('user');
+    const author = interaction.user;
+    const guild = { Guild: interaction.guild.id };
+
+    if (author.id == target.id) return client.errNormal({
+        error: "You cannot disown yourself",
+        type: 'editreply'
+    }, interaction);
+
+    if (target.bot) return client.errNormal({
+        error: "You cannot disown a bot",
+        type: 'editreply'
+    }, interaction);
+
+    Schema.findOne({ Guild: interaction.guild.id, Parent: target.id }, async (err, data) => {
+        if (data) {
+            Schema.findOne({ Guild: interaction.guild.id, User: data.Parent }, async (err, data2) => {
+                if (data2) {
+                    client.embed({ title: `👪・Disowned`, desc: `${author} has disowned <@!${data.Parent}>`, type: 'editreply' }, interaction);
+
+                    data.Parent = null;
+                    data.save();
+                }
+            })
+        }
+        else {
+            Schema.findOne({ Guild: interaction.guild.id, User: author.id }, async (err, data) => {
+                if (data) {
+                    if (data.Children.includes(target.username)) {
+                        const filtered = data.Children.filter((user) => user !== target.username);
+
+                        await Schema.findOneAndUpdate(guild, {
+                            Guild: interaction.guild.id,
+                            User: author.id,
+                            Children: filtered
+                        });
+
+                        Schema.findOne({ Guild: interaction.guild.id, Parent: author.id }, async (err, data) => {
+                            if (data) {
+                                data.Parent = null;
+                                data.save();
+                            }
+                        })
+
+                        client.embed({ title: `👪・Disowned`, desc: `${author} has disowned <@!${target.id}>`, type: 'editreply' }, interaction);
+                    }
+                    else {
+                        client.errNormal({ error: "You have no children/parents at the moment", type: 'editreply' }, interaction);
+                    }
+                }
+                else {
+                    client.errNormal({ error: "You have no children/parents at the moment", type: 'editreply' }, interaction);
+                }
+            })
+        }
+    })
+}
+
+ 

src/commands/family/divorce.js

@@ -0,0 +1,46 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/family");
+
+module.exports = async (client, interaction, args) => {
+
+    const target = interaction.options.getUser('user');
+    const author = interaction.user;
+
+    if (author.id == target.id) return client.errNormal({
+        error: "You cannot divorce yourself",
+        type: 'editreply'
+    }, interaction);
+
+    if (target.bot) return client.errNormal({
+        error: "You cannot divorce a bot",
+        type: 'editreply'
+    }, interaction);
+
+    const data = await Schema.findOne({ Guild: interaction.guild.id, User: author.id, Partner: target.id });
+    if (data) {
+        const data2 = await Schema.findOne({ Guild: interaction.guild.id, User: target.id });
+        if (data2) {
+            data2.Partner = null;
+            data2.save();
+        }
+
+        data.Partner = null;
+        data.save();
+
+        client.embed({ 
+            title: `👰・Divorced`, 
+            desc: `${author} and ${target} have been divorced`, 
+            type: 'editreply' 
+        }, interaction);
+
+    }
+    else {
+        client.errNormal({ 
+            error: "You are not married at the moment", 
+            type: 'editreply' 
+        }, interaction);
+    }
+}
+
+ 

src/commands/family/family.js

@@ -0,0 +1,32 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/family");
+
+module.exports = async (client, interaction, args) => {
+
+    const target = interaction.options.getUser('user') || interaction.user;
+
+    const data = await Schema.findOne({ Guild: interaction.guild.id, User: target.id });
+
+    client.embed({
+        title: `👪・${target.username}'s Family`,
+        thumbnail: target.avatarURL({ size: 1024 }),
+        fields: [
+            {
+                name: `Partner`,
+                value: `${data && data.Partner ? `<@!${data.Partner}>` : `This user is not married`}`
+            },
+            {
+                name: `Parent`,
+                value: `${data && data.Parent.length > 0 ? `${data.Parent.join(", ")}` : `This user has no parents`}`
+            },
+            {
+                name: `Children`,
+                value: `${data && data.Children.length > 0 ? `${data.Children.join(", ")}` : `This user has no children`}`
+            }
+        ],
+        type: 'editreply'
+    }, interaction)
+}
+
+ 

src/commands/family/propose.js

@@ -0,0 +1,140 @@
+const Discord = require('discord.js');
+
+const Schema = require("../../database/models/family");
+
+module.exports = async (client, interaction, args) => {
+
+    const target = interaction.options.getUser('user');
+    const author = interaction.user;
+    const guild = { Guild: interaction.guild.id };
+
+    if (author.id == target.id) return client.errNormal({ error: "You cannot marry yourself!", type: 'editreply' }, interaction);
+
+    Schema.findOne({ Guild: interaction.guild.id, Partner: author.id }, async (err, data) => {
+        if (data) {
+            client.errNormal({ error: "Someone in the couple is already married!", type: 'editreply' }, interaction);
+        }
+        else {
+            Schema.findOne({ Guild: interaction.guild.id, Partner: target.id }, async (err, data) => {
+                if (data) {
+                    client.errNormal({ error: "Someone in the couple is already married!", type: 'editreply' }, interaction);
+                }
+                else {
+                    Schema.findOne({ Guild: interaction.guild.id, User: target.id, Parent: author.id }, async (err, data) => {
+                        if (data) {
+                            client.errNormal({ error: "You cannot marry a family member!", type: 'editreply' }, interaction);
+                        }
+                        else {
+                            Schema.findOne({ Guild: interaction.guild.id, User: author.id, Parent: target.id }, async (err, data) => {
+                                if (data) {
+                                    client.errNormal({ error: "You cannot marry a family member!", type: 'editreply' }, interaction);
+                                }
+                                else {
+                                    Schema.findOne({ Guild: interaction.guild.id, User: author.id }, async (err, data) => {
+                                        if (data) {
+                                            if (data.Children.includes(target.id)) {
+                                                client.errNormal({ error: "You cannot marry a family member!", type: 'editreply' }, interaction);
+                                            }
+                                            else {
+                                                propose();
+                                            }
+                                        }
+                                        else {
+                                            propose();
+                                        }
+                                    })
+                                }
+                            })
+                        }
+                    })
+                }
+            })
+        }
+    })
+
+    function propose() {
+        const row = new Discord.MessageActionRow()
+            .addComponents(
+                new Discord.MessageButton()
+                    .setCustomId('propose_accept')
+                    .setEmoji('✅')
+                    .setStyle('SUCCESS'),
+
+                new Discord.MessageButton()
+                    .setCustomId('propose_deny')
+                    .setEmoji('❌')
+                    .setStyle('DANGER'),
+            );
+
+        client.embed({
+            title: `👰・Marriage proposal`,
+            desc: `${author} has ${target} asked to propose him! \n${target} click on one of the buttons`,
+            components: [row],
+            content: `${target}`,
+            type: 'editreply'
+        }, interaction);
+
+        const filter = i => i.user.id === target.id;
+
+        interaction.channel.awaitMessageComponent({ filter, componentType: 'BUTTON', time: 60000 }).then(async i => {
+            if (i.customId == "propose_accept") {
+
+                Schema.findOne({ Guild: interaction.guild.id, User: author.id }, async (err, data) => {
+                    if (data) {
+                        data.Partner = target.id
+                        data.save();
+                    }
+                    else {
+                        new Schema({
+                            Guild: interaction.guild.id,
+                            User: author.id,
+                            Partner: target.id
+                        }).save();
+                    }
+                })
+
+                Schema.findOne({ Guild: interaction.guild.id, User: target.id }, async (err, data) => {
+                    if (data) {
+                        data.Partner = author.id
+                        data.save();
+                    }
+                    else {
+                        new Schema({
+                            Guild: interaction.guild.id,
+                            User: target.id,
+                            Partner: author.id
+                        }).save();
+                    }
+                })
+
+                client.embed({
+                    title: `👰・Marriage proposal - Approved`,
+                    desc: `${author} and ${target} are now married! 👰🎉`,
+                    components: [],
+                    content: `${target}`,
+                    type: 'editreply'
+                }, interaction);
+            }
+
+            if (i.customId == "propose_deny") {
+                client.embed({
+                    title: `👰・Marriage proposal - Denied`,
+                    desc: `${target} loves someone else and chose not to marry ${author}`,
+                    components: [],
+                    content: `${target}`,
+                    type: 'editreply'
+                }, interaction);
+            }
+        }).catch(() => {
+            client.embed({
+                title: `👰・Marriage proposal - Denied`,
+                desc: `${target} has not answered anything! The wedding is canceled`,
+                components: [],
+                content: `${target}`,
+                type: 'editreply'
+            }, interaction);
+        });
+    }
+}
+
+ 

src/commands/fun/ascii.js

@@ -0,0 +1,23 @@
+const Discord = require('discord.js');
+const figlet = require('figlet');
+
+module.exports = async (client, interaction, args) => {
+    const msg = interaction.options.getString('text');
+
+    if (msg.length > 2000) return client.errNormal({ error: "Please provide text shorter than 2000 character!", type: 'editreply' }, interaction);
+
+    figlet.text(msg, function (err, data) {
+
+        if (err) {
+            return client.errNormal({ error: "Something went wrong!", type: 'editreply' }, interaction);
+        }
+
+        client.embed({
+            title: '💬・Ascii',
+            desc: `\`\`\` ${data} \`\`\``,
+            type: 'editreply',
+        }, interaction);
+    })
+}
+
+ 

src/commands/fun/birdfact.js

@@ -0,0 +1,19 @@
+const Discord = require('discord.js');
+const fetch = require("node-fetch");
+
+module.exports = async (client, interaction, args) => {
+
+    fetch(
+        `https://some-random-api.ml/facts/bird`
+    )
+        .then((res) => res.json()).catch({})
+        .then(async (json) => {
+            client.embed({
+                title: `💡・Random bird fact`,
+                desc: json.fact,
+                type: 'editreply',
+            }, interaction);
+        }).catch({})
+}
+
+ 

src/commands/fun/catfact.js

@@ -0,0 +1,19 @@
+const Discord = require('discord.js');
+const fetch = require("node-fetch");
+
+module.exports = async (client, interaction, args) => {
+
+    fetch(
+        `https://some-random-api.ml/facts/cat`
+    )
+        .then((res) => res.json()).catch({})
+        .then(async (json) => {
+            client.embed({
+                title: `💡・Random cat fact`,
+                desc: json.fact,
+                type: 'editreply',
+            }, interaction);
+        }).catch({})
+}
+
+ 

src/commands/fun/cleverrate.js

@@ -0,0 +1,13 @@
+
+module.exports = async (client, interaction, args) => {
+
+    var result = Math.ceil(Math.random() * 100);
+
+    client.embed({
+        title: `💡・Clever Rate`,
+        desc: `You are ${result}% clever!`,
+        type: 'editreply'
+    }, interaction)
+}
+
+ 

src/commands/fun/confused.js

@@ -0,0 +1,11 @@
+
+module.exports = async (client, interaction, args) => {
+
+    client.embed({
+        title: '😲・Confused Nick',
+        image: "https://cdn.discordapp.com/attachments/825305196355780628/836154426481704980/nick-young-confused-face-300x256-nqlyaa.png",
+        type: 'editreply'
+    }, interaction)
+}
+
+ 

src/commands/fun/dinochrome.js

@@ -0,0 +1,96 @@
+
+module.exports = async (client, interaction, args) => {
+
+    let msg = await interaction.editReply({ content: `---------------🦖`, fetchReply: true });
+    let time = 1 * 1000;
+    setTimeout(function () {
+        interaction.editReply(`-----------🦖----`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`----------🦖------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`--------🦖--------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`------🦖-----------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`-------🦖-----------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`---🌵-----🦖---------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`---🌵-🦖-------------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`🦖\n ---🌵--------------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`------🦖---🌵--------------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`----🦖-----🌵----------------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`-🌵🌵-----🦖-------🌵--------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`----🌵🌵-🦖----------🌵------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`🦖\n ---🌵🌵-------------🌵---`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`-----🦖---🌵🌵-------------🌵--`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`-------🦖-----🌵🌵-------------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`🎂----🦖--------🌵🌵-----------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`---🎂--🦖----------🌵🌵---------`);
+    }, time);
+    time += 1.5 * 1000;
+
+    setTimeout(function () {
+        interaction.editReply(`**Ⓜⓘⓢⓢⓘⓞⓝ Ⓒⓞⓜⓟⓛⓔⓣⓔⓓ !**\n ---🎂🦖----------🌵🌵-------------`);
+    }, time);
+}
+
+ 

src/commands/fun/dogfact.js

@@ -0,0 +1,19 @@
+const Discord = require('discord.js');
+const fetch = require("node-fetch");
+
+module.exports = async (client, interaction, args) => {
+
+    fetch(
+        `https://some-random-api.ml/facts/dog`
+    )
+        .then((res) => res.json()).catch({})
+        .then(async (json) => {
+            client.embed({
+                title: `💡・Random dog fact`,
+                desc: json.fact,
+                type: 'editreply',
+            }, interaction);
+        }).catch({})
+}
+
+ 

src/commands/fun/epicgamerrate.js

@@ -0,0 +1,12 @@
+
+module.exports = async (client, interaction, args) => {
+    var result = Math.ceil(Math.random() * 100);
+
+    client.embed({
+        title: `🎮・Epic gamer rate`,
+        desc: `You are ${result}% epic gamer!`,
+        type: 'editreply'
+    }, interaction)
+}
+
+ 

src/commands/fun/fact.js

@@ -0,0 +1,20 @@
+const Discord = require('discord.js');
+const request = require('request');
+
+module.exports = async (client, interaction, args) => {
+
+    var url = 'https://uselessfacts.jsph.pl/random.json?language=en'
+
+
+    request(url, function (err, response, body) {
+        fact = JSON.parse(body).text;
+
+        client.embed({
+            title: `😂・Fact`,
+            desc: fact,
+            type: 'editreply',
+        }, interaction);
+    })
+}
+
+ 

src/commands/fun/gif.js

@@ -0,0 +1,19 @@
+const Discord = require('discord.js');
+
+module.exports = async (client, interaction, args) => {
+    const msg = interaction.options.getString('text');
+
+    if (!msg) return client.errUsage({ usage: "gif [text]", type: 'editreply' }, interaction);
+
+    var giphy = require('giphy-api')(process.env.GIPHY_TOKEN);
+
+    giphy.random(msg, function (err, res) {
+        client.embed({
+            title: `📺・${msg} Gif`,
+            image: `https://media1.giphy.com/media/${res.data.id}/giphy.gif`,
+            type: 'editreply'
+        }, interaction);
+    });
+}
+
+ 

src/commands/fun/hack.js

@@ -0,0 +1,130 @@
+const fetch = require("node-fetch");
+const generator = require('generate-password');
+
+module.exports = async (client, interaction, args) => {
+
+    const password = generator.generate({
+        length: 10,
+        symbols: true,
+        numbers: true
+    });
+
+    const user = interaction.options.getUser('user');
+
+    if (!user) return client.errUsage({ usage: "hack [mention user]", type: 'editreply' }, interaction)
+
+    function wait(ms) {
+        let start = new Date().getTime();
+        let end = start;
+        while (end < start + ms) {
+            end = new Date().getTime();
+        }
+    }
+
+    client.embed({
+        title: '💻・Hacking',
+        desc: `The hack on ${user} started...`,
+        type: 'editreply'
+    }, interaction).then(msg => {
+
+        wait(140);
+        client.embed({
+            title: '💻・Hacking',
+            desc: `Searching for user information..`,
+            type: 'edit',
+        }, msg).then(i => {
+
+            wait(133);
+            client.embed({
+                title: '💻・Hacking',
+                desc: `Searching for IP address...`,
+                type: 'edit',
+            }, msg).then(i => {
+
+                wait(140);
+                client.embed({
+                    title: '💻・Hacking',
+                    desc: `The users ip address was found!`,
+                    fields: [
+                        {
+                            name: '🔗┆IP Adress',
+                            value: `\`\`\`127.0.0.1\`\`\``,
+                            inline: true,
+                        }
+                    ],
+                    type: 'edit',
+                }, msg).then(i => {
+
+                    wait(60);
+                    client.embed({
+                        title: '💻・Hacking',
+                        desc: `Searching for Discord login...`,
+                        type: 'edit',
+                    }, msg).then(i => {
+
+                        wait(230);
+                        client.embed({
+                            title: '💻・Hacking',
+                            desc: `The users discord login was found!`,
+                            fields: [
+                                {
+                                    name: '📨┆Email',
+                                    value: `\`\`\`${user.username}isCoolXD@gmail.com\`\`\``
+                                },
+                                {
+                                    name: '🔑┆Password',
+                                    value: `\`\`\`${password}\`\`\``
+                                }
+                            ],
+                            type: 'edit',
+                        }, msg).then(i => {
+
+                            wait(200);
+                            client.embed({
+                                title: '💻・Hacking',
+                                desc: `Search for Discord token...`,
+                                type: 'edit'
+                            }, msg).then(i => {
+
+                                wait(200);
+                                fetch(`https://some-random-api.ml/bottoken`).then((res) => res.json()).catch({}).then(async (json) => {
+                                    client.embed({
+                                        title: '💻・Hacking',
+                                        desc: `The users discord account token was found!`,
+                                        fields: [
+                                            {
+                                                name: '🔧┆Token',
+                                                value: `\`\`\`${json.token}\`\`\``,
+                                                inline: true
+                                            }
+                                        ],
+                                        type: 'edit',
+                                    }, msg).then(i => {
+
+                                        wait(140);
+                                        client.embed({
+                                            title: '💻・Hacking',
+                                            desc: `Reporting account to Discord for breaking TOS...`,
+                                            type: 'edit',
+                                        }, msg).then(i => {
+
+                                            wait(180);
+                                            client.succNormal({ text: `${user} is succesfully hacked.All the user's information was send to your dm`, type: 'edit' }, msg);
+                                            client.embed({
+                                                title: '😂・Pranked',
+                                                image: "https://media1.tenor.com/images/05006ed09075a0d6965383797c3cea00/tenor.gif?itemid=17987788",
+                                            }, interaction.user)
+                                        })
+                                    })
+                                }).catch({})
+                            })
+                        })
+                    })
+                })
+            })
+        })
+    })
+
+}
+
+