From eb6b9ba0c54cf12bd323edeaf4ce7d8b1c4fcc80 Mon Sep 17 00:00:00 2001
From: husky-rotmg <70654625+husky-rotmg@users.noreply.github.com>
Date: Fri, 16 Feb 2024 11:17:56 -0500
Subject: [PATCH 1/9] Full mutes rework

:smile: I'll fill out info later, need a couple small touches
---
 .eslintignore           |   2 -
 commands/mute.js        | 315 ++++++++++++++++++++++++++++----------
 commands/mutes.js       | 157 +++++++++++++------
 commands/punishments.js | 329 +++++++++++++++++++++++++++++-----------
 commands/test.js        |  52 ++++++-
 commands/unmute.js      | 157 ++++++++++++-------
 dbSetup.js              |   2 +-
 jobs/mute.js            |  35 +++--
 lib/extensions.js       |   2 +
 memberHandler.js        |   4 +-
 messageManager.js       |  26 +---
 utils.js                |  56 ++++++-
 12 files changed, 811 insertions(+), 326 deletions(-)

diff --git a/.eslintignore b/.eslintignore
index 488401c8..5f7c9d1a 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -31,7 +31,6 @@ commands/manualVerify.js
 commands/manualVetVerify.js
 commands/memes.js
 commands/modmailBlacklist.js
-commands/mute.js
 commands/mutes.js
 commands/noNicknames.js
 commands/parsemembers.js
@@ -59,7 +58,6 @@ commands/tempKeyRemove.js
 commands/test.js
 commands/unlock.js
 commands/unlockdown.js
-commands/unmute.js
 commands/unsuspend.js
 commands/unverify.js
 commands/unvetverify.js
diff --git a/commands/mute.js b/commands/mute.js
index 23084439..6b43559c 100644
--- a/commands/mute.js
+++ b/commands/mute.js
@@ -1,96 +1,249 @@
-const Discord = require('discord.js')
-const ErrorLogger = require('../lib/logError')
-const fs = require('fs')
+const { EmbedBuilder, Colors } = require('discord.js');
+const moment = require('moment');
 const SlashArgType = require('discord-api-types/v10').ApplicationCommandOptionType;
-const { slashArg, slashChoices, slashCommandJSON } = require('../utils.js')
+const { slashArg, slashCommandJSON } = require('../utils.js');
+
+/**
+ * @typedef MuteRow
+ * @property {string} id
+ * @property {string} modid
+ * @property {string} guildid
+ * @property {string} reason
+ * @property {number} appliedOn
+ * @property {number} duration
+ * @property {number?} removedOn
+ * @property {string?} removedBy
+ * @property {string?} removeReason
+ */
+
+/**
+ *
+ * @param {number} duration
+ * @returns {string}
+ */
+function durationString(duration, when = Date.unix()) {
+    if (!duration) return 'Permanent';
+    duration = parseInt(duration);
+    when = parseInt(when);
+    const mmt = moment.duration(duration * 1000).humanize();
+    return `${mmt[0].toUpperCase()}${mmt.substring(1)} ending <t:${when + duration}:R> at <t:${when + duration}:f>`;
+}
+
+/**
+ * @param {MuteRow} row
+ * @param {import('discord.js').GuildMember} member
+ * @param {number?} duration
+ */
+async function attemptOverwrite(db, row, member, duration) {
+    const removeReason = `Overwritten by ${member} on <t:${Date.unix()}:f> ${durationString(duration)}`;
+    await db.promise().query('UPDATE mutes SET removedOn = unix_timestamp(), removedBy = ?, removeReason = ? WHERE id = ? AND guildid = ? AND removedOn IS NULL',
+        [member.id, removeReason, row.id, row.guildid]);
+}
+
+/**
+ *
+ * @param {string} duration
+ * @param {number} time
+ */
+function processDuration(duration, time) {
+    duration = duration.toLowerCase();
+    if (duration.startsWith('mo')) return time * 2_592_000;
+    switch (duration[0]) {
+        case 's': return time;
+        case 'm': return time * 60;
+        case 'h': return time * 3_600;
+        case 'd': return time * 86_400;
+        case 'w': return time * 604_800;
+        case 'y': return time * 31_536_000;
+        default:
+    }
+}
+
+/**
+ * @param {import('../utils.js').BotCommandInteraction} interaction
+ * @param {MuteRow} row
+ * @returns {{
+ *  overwrite: boolean;
+ *  mute: boolean
+ * }}
+*/
+async function confirmOverwrite(interaction, member, row, duration, reason) {
+    const mod = interaction.guild.members.cache.get(row.modid);
+    const embed = new EmbedBuilder()
+        .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+        .setTitle('Confirm Mute Override')
+        .setDescription(`<@${row.id}> currently has an active mute. Do you want to override this mute?`)
+        .setColor(Colors.Blue)
+        .setTimestamp()
+        .addFields({ name: 'Old Moderator', value: mod ? `${mod} \`${mod.displayName}\`` : `<@${row.modid}>`, inline: true },
+            { name: 'Applied On', value: `<t:${row.appliedOn}:f>`, inline: true },
+            { name: 'Old Expires', value: durationString(row.duration, row.appliedOn), inline: true },
+            { name: 'Old Reason', value: row.reason },
+            { name: 'New Moderator', value: `${interaction.member} \`${interaction.member.displayName}\``, inline: true },
+            { name: 'New Expires', value: durationString(duration), inline: true },
+            { name: 'New Reason', value: reason });
+
+    const message = await interaction.editReply({ embeds: [embed], fetchReply: true });
+    return await message.confirmButton(interaction.member.id);
+}
+
+/**
+ * @param {import('../utils.js').BotCommandInteraction} interaction
+ * @param {import('discord.js').GuildMember} member
+ */
+async function confirmUnmanagedMute(interaction, member, duration, reason) {
+    const embed = new EmbedBuilder()
+        .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+        .setTitle('Unmanaged Mute')
+        .setDescription(`${member} has a mute currently not managed by ${interaction.client.user}. Would you like to have it managed with the following information?`)
+        .setColor(Colors.Blue)
+        .addFields({ name: 'Member', value: `${member} \`${member.displayName}\``, inline: true },
+            { name: 'Moderator', value: `${interaction.member} \`${interaction.member.displayName}\``, inline: true },
+            { name: 'Expires', value: durationString(duration), inline: true },
+            { name: 'Reason', value: reason });
+
+    const message = await interaction.editReply({ embeds: [embed], fetchReply: true });
+    return await message.confirmButton(interaction.member.id);
+}
 
 module.exports = {
     name: 'mute',
     description: 'Gives user the muted role',
-    args: '<member> <time> <time type s/m/h/d/w/y> <Reason>',
     role: 'security',
-    varargs: true,
-    requiredArgs: 4,
     args: [
-        slashArg(SlashArgType.User, 'member', {
-            description: "Member in the Server"
+        slashArg(SlashArgType.Subcommand, 'temporary', {
+            description: 'Temporarily mute member',
+            options: [
+                slashArg(SlashArgType.User, 'member', {
+                    description: 'Server member to mute'
+                }),
+                slashArg(SlashArgType.Integer, 'time', {
+                    description: 'The amount of time for the mute'
+                }),
+                slashArg(SlashArgType.String, 'duration', {
+                    description: 'The type of duration for the mute'
+                }),
+                slashArg(SlashArgType.String, 'reason', {
+                    description: 'The reason for the permanent mute',
+                    varargs: true
+                })
+            ]
         }),
-        slashArg(SlashArgType.Integer, 'time', {
-            required: false,
-            description: "Quantity of Time"
-        }),
-        slashArg(SlashArgType.String, 'timetype', {
-            required: false,
-            description: "Time Type[s/m/h/d/w/y]"
-        }),
-        slashArg(SlashArgType.String, 'reason', {
-            required: false,
-            description: "Reason for mute"
+        slashArg(SlashArgType.Subcommand, 'permanent', {
+            description: 'Permanently mute member',
+            options: [
+                slashArg(SlashArgType.User, 'member', {
+                    description: 'Server member to mute'
+                }),
+                slashArg(SlashArgType.String, 'reason', {
+                    description: 'The reason for the permanent mute',
+                    varargs: true
+                })
+            ]
         }),
     ],
     getSlashCommandData(guild) {
-        return slashCommandJSON(this, guild)
+        return slashCommandJSON(this, guild);
+    },
+
+    /**
+     * @param {import('../utils.js').BotCommandInteraction?} interaction
+     * @param {import('discord.js').GuildMember} member
+     * @param {number?} duration
+     * @param {string} reason
+     * @param {MuteRow?} row - Row to overwrite
+     */
+    async mute(settings, db, interaction, member, duration, reason, row) {
+        const moderator = interaction?.member || member.client.user;
+        const endTime = Date.now() + duration;
+
+        const embed = new EmbedBuilder()
+            .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+            .setTitle('Mute Information')
+            .setDescription(`The mute is ${duration ? 'for ' + moment.duration(duration * 1000).humanize(false) : 'permanent'}`)
+            .setFooter({ text: duration ? 'Unmuting at' : 'Permanent' })
+            .setColor(Colors.Green)
+            .setTimestamp(endTime)
+            .addFields({ name: 'Member', value: `${member} \`${member.displayName}\``, inline: true },
+                { name: 'Moderator', value: `${moderator} \`${moderator.displayName}\``, inline: true },
+                { name: 'Expires', value: durationString(duration), inline: true },
+                { name: 'Reason', value: reason });
+
+        if (row) {
+            await attemptOverwrite(db, row, moderator, duration);
+            const mod = member.guild.members.cache.get(row.modid);
+            embed.addFields({ name: 'Overwrote Mute', value: '\u000B' },
+                { name: 'Old Moderator', value: mod ? `${mod} \`${mod.displayName}\`` : `<@${row.modid}>`, inline: true },
+                { name: 'Applied On', value: `<t:${row.appliedOn}:f>`, inline: true },
+                { name: 'Old Expires', value: durationString(row.duration, row.appliedOn), inline: true },
+                { name: 'Old Reason', value: row.reason });
+        }
+        if (reason.length > 1024) reason = reason.substring(0, 1021) + '...';
+        await db.promise().query('INSERT INTO mutes (id, modid, guildid, reason, duration) VALUES (?, ?, ?, ?, ?)', [member.id, moderator.id, member.guild.id, reason, duration || 0])
+            .catch(console.log);
+        member.roles.add(settings.roles.muted);
+
+        if (interaction) {
+            const message = await interaction.fetchReply();
+            if (!message) await interaction.reply({ embeds: [embed] });
+            else await interaction.editReply({ embeds: [embed], components: [] });
+        }
+        await member.guild.channels.cache.get(settings.channels.modlogs)?.send({ embeds: [embed] });
+
+        embed.setColor(Colors.Red).setDescription(`You have been muted in the ${member.guild.name} discord. The mute is ${duration ? 'for ' + moment.duration(duration * 1000).humanize(false) : 'permanent'}`);
+        const dm = await member.createDM().catch(() => {});
+        await dm?.send({ embeds: [embed] }).catch(() => {});
     },
-    async execute(message, args, bot, db) {
-        let settings = bot.settings[message.guild.id]
-        const memberSearch = args.shift();
-        let member = message.guild.members.cache.get(memberSearch);
-        if (!member) member = message.guild.members.cache.filter(user => user.nickname != null).find(nick => nick.nickname.replace(/[^a-z|]/gi, '').toLowerCase().split('|').includes(memberSearch.toLowerCase()));
-        if (!member) member = message.guild.members.cache.get(memberSearch.replace(/\D/gi, ''))
-        if (!member) { message.reply('User not found. Please try again'); return; }
-        if (member.roles.highest.position >= message.member.roles.highest.position) return message.reply(`${member} has a role greater than or equal to you and cannot be muted`);
-        let muted = settings.roles.muted
-        if (member.roles.cache.has(muted)) return message.reply(`${member} is already muted`)
-        if (args.length == 1) {
-            await member.roles.add(muted).catch(er => ErrorLogger.log(er, bot, message.guild))
-            await message.reply(`${member} has been muted indefinitely`)
-            return;
+
+    /**
+     * @param {import('../utils.js').BotCommandInteraction} interaction
+     * @param {string[]} args ignored
+     * @param {import('discord.js').Client} bot
+     * @param {import('mysql2').Pool} db
+     */
+    async execute(interaction, args, bot, db) {
+        const settings = bot.settings[interaction.guild.id];
+        const member = interaction.options.getMember('member');
+        const reason = interaction.options.getString('reason');
+        const type = interaction.options.getSubcommand();
+        const duration = type == 'permanent' ? 0 : processDuration(interaction.options.getString('duration'), interaction.options.getInteger('time'));
+        const embed = new EmbedBuilder()
+            .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+            .setColor(Colors.Blue)
+            .setTimestamp()
+            .setFooter({ text: `Ran by ${interaction.member.displayName}` })
+            .setTitle('Processing Mute')
+            .setDescription('Please wait...');
+
+        await interaction.reply({ embeds: [embed] });
+
+        if (type != 'permanent' && !duration) {
+            embed.setColor(Colors.Red)
+                .setDescription(`\`${interaction.options.getInteger('time')} ${interaction.options.getString('duration')}\` is not a valid duration.`);
+            return await interaction.editReply({ embeds: [embed] });
         }
-        let time = parseInt(args.shift())
-        let timeType = args.shift()
-        if (!timeType) return message.channel.send("Please enter a valid time type __**d**__ay, __**m**__inute, __**h**__our, __**s**__econd, __**w**__eek, __**y**__ear");
-        let reason = args.join(' ');
-        switch (timeType.charAt(0).toLowerCase()) {
-            case 's': millisecondTime = time * 1000; timeDuration = 'second(s)'; break;
-            case 'm': millisecondTime = time * 60000; timeDuration = 'minute(s)'; break;
-            case 'h': millisecondTime = time * 3600000; timeDuration = 'hour(s)'; break;
-            case 'd': millisecondTime = time * 86400000; timeDuration = 'day(s)'; break;
-            case 'w': millisecondTime = time * 604800000; timeDuration = 'week(s)'; break;
-            case 'y': millisecondTime = time * 31536000000; timeDuration = 'year(s)'; break;
-            default: return message.channel.send("Please enter a valid time type __**s**__econd, __**m**__inute, __**h**__our, __**d**__ay, __**w**__eek, __**y**__ear");
+
+        if (member.roles.highest.position >= interaction.member.roles.highest.position) {
+            embed.setColor(Colors.Red)
+                .setDescription(`${member} has a role greater than or equal to your own and you cannot mute them.`);
+            return await interaction.editReply({ embeds: [embed] });
         }
-        async function muteProcess(overwrite) {
-            const modlogs = message.guild.channels.cache.get(settings.channels.modlogs);
-            let embed = new Discord.EmbedBuilder()
-                .setColor('#ff0000')
-                .setTitle('Mute Information')
-                .setDescription(`You have been muted in the ${message.guild.name} discord. The mute is for ${time} ${timeDuration} until <t:${(((Date.now() + millisecondTime) / 1000)).toFixed(0)}:f>`)
-                .addFields([{name: `User Information \`${member.nickname}\``, value: `<@!${member.id}> `, inline: true}])
-                .addFields([{name: `Mod Information \`${message.guild.members.cache.get(message.author.id).nickname}\``, value: `<@!${message.author.id}> `, inline: true}])
-                .addFields([{name: `Reason:`, value: reason}])
-                .setFooter({ text: `Unmuting at ` })
-                .setTimestamp(Date.now() + millisecondTime);
-                (member.user.send({ embeds: [embed] }).catch(() => {}));
-            } 
-        async function muteProcesslog(overwrite) {
-            const modlogs = message.guild.channels.cache.get(settings.channels.modlogs);
-            let embed = new Discord.EmbedBuilder()
-                .setColor('#ff0000')
-                .setTitle('Mute Information')
-                .setDescription(`The mute is for ${time} ${timeDuration} until <t:${(((Date.now() + millisecondTime) / 1000)).toFixed(0)}:f>`)
-                .addFields([{name: `User Information \`${member.nickname}\``, value: `<@!${member.id}> `, inline: true}])
-                .addFields([{name: `Mod Information \`${message.guild.members.cache.get(message.author.id).nickname}\``, value: `<@!${message.author.id}> `, inline: true}])
-                .addFields([{name: `Reason:`, value: reason}])
-                .setFooter({ text: `Unmuting at ` })
-                .setTimestamp(Date.now() + millisecondTime);
-            modlogs.send({ embeds: [embed] });
-            }           
-        db.query(`INSERT INTO mutes (id, guildid, muted, reason, modid, uTime) VALUES ('${member.id}', '${message.guild.id}', true, '${reason || 'None Provided'}','${message.author.id}', '${Date.now() + millisecondTime}')`, err => {
-            member.roles.add(muted).catch(er => ErrorLogger.log(er, bot, message.guild))
-            message.reply(`${member} has been muted`);
-            muteProcess();
-            muteProcesslog();
-            
-        })
+
+        const [rows] = await db.promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [member.id, member.guild.id]);
+
+        if (rows.length && !await confirmOverwrite(interaction, member, rows[0], duration, reason)) {
+            embed.setColor(Colors.Red)
+                .setDescription('Cancelled mute override');
+            return await interaction.editReply({ embeds: [embed], components: [] });
+        }
+
+        if (!rows.length && member.roles.cache.has(settings.roles.muted) && !await confirmUnmanagedMute(interaction, member, duration, reason)) {
+            embed.setColor(Colors.Red)
+                .setDescription('Cancelled converting mute');
+            return await interaction.editReply({ embeds: [embed], components: [] });
+        }
+
+        await this.mute(settings, db, interaction, member, duration, reason, rows[0]);
     }
-}
+};
+
diff --git a/commands/mutes.js b/commands/mutes.js
index 1eaae6b0..b3b0471e 100644
--- a/commands/mutes.js
+++ b/commands/mutes.js
@@ -1,8 +1,110 @@
-const Discord = require('discord.js')
 const moment = require('moment');
-const ErrorLogger = require('../lib/logError')
+const ErrorLogger = require('../lib/logError');
+const { ApplicationCommandOptionType, EmbedBuilder, Colors } = require('discord.js');
+const { slashArg, slashCommandJSON } = require('../utils');
+
+/**
+ * @typedef MuteRow
+ * @property {string} id
+ * @property {string} guildid
+ * @property {boolean} muted
+ * @property {string} reason
+ * @property {string} modid
+ * @property {string} uTime
+ * @property {boolean} perma
+ */
+/**
+ * 
+ * @param {MuteRow} row 
+ * @param {number?} idx 
+ */
+function muteRowToString(row, idx) {
+
+}
+
+/**
+ * @param {import('discord.js').Message | import('discord.js').CommandInteraction} message
+ * @param {import('discord.js').Client} bot
+ * @param {import('mysql2').Pool} db
+ * @param {import('discord.js').GuildMember} member
+ * @param {import('discord.js').Role} mutedRole
+ * @param {EmbedBuilder} embed
+ */
+async function displayAllMutes(message, bot, db, mutedRole, embed) {
+    embed.setTitle(`${bot.user.displayName} Managed Mutes`);
+    const members = mutedRole.members.clone();
+
+    const [rows] = await db.promise().query('SELECT * FROM mutes WHERE muted = true AND guildid = ?', [message.guild.id]);
+
+    const mutedTexts = [''];
+    for (const row of rows) {
+        const duration = row.perma ? '**permanently**' : `ending <t:${(parseInt(row.uTime) / 1000).toFixed(0)}:R>`;
+        const userRow = `<@${row.id}> by <@${row.modid}> ${duration}`;
+        if (mutedTexts[mutedTexts.length - 1].length + userRow.length + 1 >= 3800) mutedTexts.push('');
+        mutedTexts[mutedTexts.length - 1] += `${userRow}\n`;
+        members.delete(row.id);
+    }
+
+    if (!rows.length) mutedTexts[0] = 'None!';
+    for (const text of mutedTexts) {
+        embed.setDescription(text);
+        await message.channel.send({ embeds: [embed] });
+        embed.setTitle(`${bot.user.displayName} Managed Mutes (cont.)`);
+    }
+
+    embed.setTitle(`Unmanaged Mutes`);
+    mutedTexts.splice(0);
+    mutedTexts.push('');
+
+    members.forEach(member => {
+        if (mutedTexts[mutedTexts.length - 1].length + `${member}`.length + 1 >= 3800) mutedTexts.push('');
+        mutedTexts[mutedTexts.length -1] += `${member}\n`
+    })
+
+    if (!members.size) mutedTexts[0] = 'None!';
+    for (const text of mutedTexts) {
+        embed.setDescription(text);
+        await message.channel.send({ embeds: [embed] });
+        embed.setTitle(`Unmanaged Mutes (cont.)`);
+    }
+}
 
 module.exports = {
+    name: 'mutes',
+    description: 'Shows mutes for the server',
+    role: 'security',
+    args: [slashArg(ApplicationCommandOptionType.User, 'member', { description: 'member to check mutes of', required: false })],
+    getSlashCommandData(guild) { return slashCommandJSON(this, guild); },
+
+    /**
+     * @param {import('discord.js').Message | import('discord.js').CommandInteraction} message
+     * @param {string[]} args
+     * @param {import('discord.js').Client} bot
+     * @param {import('mysql2').Pool} db
+     */
+    async execute(message, args, bot, db) {
+        /** @type {import('discord.js').GuildMember?} */
+        const member = message.options.getMember('member');
+        /** @type {import('discord.js').Role} */          
+        const mutedRole = message.guild.roles.cache.get(bot.settings[message.guild.id].roles.muted);
+
+        const embed = new EmbedBuilder()
+            .setAuthor({ name: message.guild.name, iconURL: message.guild.iconURL() })
+            .setColor(Colors.DarkButNotBlack)
+            .setTimestamp()
+            .setFooter({ text: `Ran by ${message.member.displayName}`, iconURL: message.member.displayAvatarURL() });
+
+        if (!member) return await displayAllMutes(message, bot, db, mutedRole);
+        
+        embed.setTitle(`Mutes for ${member.displayName}`);
+        const [rows] = await db.promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? ORDER BY muted DESC, uTime DESC', [member.id, member.guild.id]);
+        for (const row of rows) {
+            const userText = ``
+        }
+    }
+}
+
+module.exports1 = {
     name: 'mutes',
     description: 'prints all muted members of the server',
     role: 'security',
@@ -19,24 +121,7 @@ module.exports = {
         let embed = new Discord.EmbedBuilder()
             .setAuthor({ name: member ? `Mutes for ${member.nickname || member.user.tag} in ${message.guild.name}` : `Muted members in ${message.guild.name}` })
             .setDescription(`None!`)
-        if (!member) {
-            db.query(`SELECT * FROM mutes WHERE muted = true AND guildid = ${message.guild.id}`, async (err, rows) => {
-                if (err) ErrorLogger.log(err, bot, message.guild);
-                const members = message.guild.roles.cache.get(require('../guildSettings.json')[message.guild.id].roles.muted).members.clone();
-                if (rows && rows.length) {
-                    for (const row of rows) {
-                        members.delete(row.id);
-                        fitStringIntoEmbed(embed, `<@!${row.id}> by <@!${row.modid}> ending <t:${(parseInt(row.uTime)/1000).toFixed(0)}:R> at <t:${(parseInt(row.uTime)/1000).toFixed(0)}:f>`, message.channel);
-                    }
-                }
-                message.channel.send({ embeds: [embed] })
-                embed.data.fields = [];
-                embed.setDescription('None!');
-                embed.setAuthor({ name: `Mutes in ${message.guild.name} not set by ${message.guild.members.cache.get(bot.user.id).nickname || bot.user.tag}` });
-                members.forEach(m => fitStringIntoEmbed(embed, `${m}`, message.channel));
-                message.channel.send({ embeds: [embed] });
-            })
-        } else {
+
             db.query(`SELECT * FROM mutes WHERE id = ${member.id} AND guildid = ${message.guild.id} ORDER BY muted DESC`, async (err, rows) => {
                 if (err) ErrorLogger.log(err, bot, message.guild);
                 if (!rows || !rows.length)
@@ -48,36 +133,8 @@ module.exports = {
                         fitStringIntoEmbed(embed, `Ended <t:${(parseInt(row.uTime)/1000).toFixed(0)}:R> at <t:${(parseInt(row.uTime)/1000).toFixed(0)}:f> by <@!${row.modid}>: ${row.reason}`);
                 }
                 message.channel.send({ embeds: [embed] });
-            });
-        }
+    });
+        
 
     }
-}
-
-function fitStringIntoEmbed(embed, string, channel) {
-    if (embed.data.description == 'None!') {
-        embed.setDescription(string)
-    } else if (embed.data.description.length + `\n${string}`.length >= 2048) {
-        if (!embed.data.fields) {
-            embed.addFields({ name: '-', value: string })
-        } else if (embed.data.fields && embed.data.fields[embed.data.fields.length - 1].value.length + `\n${string}`.length >= 1024) {
-            if (JSON.stringify(embed.toJSON()).length + `\n${string}`.length >= 6000) {
-                channel.send({ embeds: [embed] })
-                embed.setDescription(string)
-                embed.data.fields = []
-            } else {
-                embed.addFields({ name: '-', value: string })
-            }
-        } else {
-            if (JSON.stringify(embed.toJSON()).length + `\n${string}`.length >= 6000) {
-                channel.send({ embeds: [embed] })
-                embed.setDescription(string)
-                embed.data.fields = []
-            } else {
-                embed.data.fields[embed.data.fields.length - 1].value = embed.data.fields[embed.data.fields.length - 1].value.concat(`\n${string}`)
-            }
-        }
-    } else {
-        embed.setDescription(embed.data.description.concat(`\n${string}`))
-    }
 }
\ No newline at end of file
diff --git a/commands/punishments.js b/commands/punishments.js
index 746823b6..099a870e 100644
--- a/commands/punishments.js
+++ b/commands/punishments.js
@@ -1,45 +1,8 @@
-const Discord = require('discord.js');
+const { EmbedBuilder, Colors, ActionRowBuilder, ButtonBuilder, ButtonStyle, StringSelectMenuBuilder,
+    StringSelectMenuOptionBuilder, InteractionCollector, ComponentType } = require('discord.js');
 const SlashArgType = require('discord-api-types/v10').ApplicationCommandOptionType;
 const { slashArg, slashCommandJSON } = require('../utils.js');
 
-function buildPunishmentEmbed(rows, member, title) {
-    const embed = new Discord.EmbedBuilder()
-        .setColor('#F04747')
-        .setDescription(`${title} for ${member}`);
-    if (rows.length > 0) {
-        let embedFieldStrings = [];
-        let embedFieldLength = 1;
-        for (let i = 0; i < rows.length; i++) {
-            const punishment = rows[i];
-            const stringText = `\`${(i + 1).toString().padStart(3, ' ')}\`${punishment.silent ? ' Silently' : ''} By <@!${punishment.modid}> <t:${(parseInt(punishment.uTime) / 1000).toFixed(0)}:R> at <t:${(parseInt(punishment.uTime) / 1000).toFixed(0)}:f>\`\`\`${punishment.reason}\`\`\`\n`;
-            if (embedFieldStrings == 0) embedFieldStrings.push(stringText);
-            else {
-                if (embedFieldStrings.join('').length + stringText.length >= 800) {
-                    embed.addFields({
-                        name: `${title} (${embedFieldLength})`,
-                        value: embedFieldStrings.join(''),
-                        inline: true
-                    });
-                    embedFieldLength++;
-                    embedFieldStrings = [];
-                    embedFieldStrings.push(stringText);
-                } else {
-                    embedFieldStrings.push(stringText);
-                }
-            }
-        }
-        if (embedFieldStrings.length > 0) {
-            embed.addFields({
-                name: `${title} (${embedFieldLength})`,
-                value: embedFieldStrings.join(''),
-                inline: true
-            });
-        }
-        embed.setTitle(`${title} for ${member.displayName}`);
-        return embed;
-    }
-}
-
 function flattenOnId(rows) {
     return rows.reduce((obj, row) => {
         if (!obj[row.id]) obj[row.id] = [];
@@ -48,12 +11,239 @@ function flattenOnId(rows) {
     }, {});
 }
 
+function timeString(permanent, ending, ended) {
+    if (!ended && permanent) return 'Permanently';
+    return `<t:${ended || ending}:R> at <t:${ended || ending}:f>`;
+}
+
+class PunishmentsUI {
+    #members = [];
+    #index = 0;
+    #page = 'Warns';
+
+    #warns = {};
+    #suspensions = {};
+    #mutes = {};
+
+    #interaction;
+    #message;
+    #guild;
+    #settings;
+    #moderator;
+    #bot;
+
+    /** @type {NodeJS.Timeout} */
+    #timer;
+    #collector;
+    constructor(interaction, guild, settings, members) {
+        this.#guild = guild;
+        this.#moderator = interaction.member;
+        this.#settings = settings;
+        this.#members = members;
+        this.#interaction = interaction;
+        this.#bot = guild.client;
+    }
+
+    async initialize(db) {
+        const { punishmentsMutes, punishmentsSuspensions, punishmentsWarnings } = this.#settings.backend;
+        const { roles, rolePermissions } = this.#settings;
+        const { position } = this.#moderator.roles.highest;
+        const { cache } = this.#guild.roles;
+        const ids = this.#members;
+
+        if (position >= cache.get(roles[rolePermissions.punishmentsWarnings]).position && punishmentsWarnings) {
+            const [warns] = await db.promise().query('SELECT * FROM warns WHERE id in (?) AND guildid = ? ORDER BY time DESC', [ids, this.#guild.id]);
+            this.#warns = flattenOnId(warns);
+        }
+        if (position >= cache.get(roles[rolePermissions.punishmentsSuspensions]).position && punishmentsSuspensions) {
+            const [suspensions] = await db.promise().query('SELECT * FROM suspensions WHERE id in (?) AND guildid = ? ORDER BY suspended DESC, perma DESC, uTime DESC', [ids, this.#guild.id]);
+            this.#suspensions = flattenOnId(suspensions);
+        }
+        if (position >= cache.get(roles[rolePermissions.punishmentsMutes]).position && punishmentsMutes) {
+            const [mutes] = await db.promise().query('SELECT *  FROM mutes WHERE id in (?) AND guildid = ? ORDER BY removedOn DESC', [ids, this.#guild.id]);
+            this.#mutes = flattenOnId(mutes);
+        }
+        this.#page = this.#availablePages[0];
+        this.#message = await this.#interaction.reply(this.#content);
+        this.#timer = setTimeout(() => this.#stop(), 300_000);
+        this.#timer.unref();
+        this.#collector = new InteractionCollector(this.#bot, {
+            message: this.#message,
+            filter: i => i.member.id == this.#moderator.id && (i.componentType == ComponentType.Button || i.componentType == ComponentType.StringSelect)
+        });
+        this.#collector.on('collect', interaction => this.#process(interaction));
+    }
+
+    /**
+    * @param {ButtonInteraction | StringSelectMenuInteraction} interaction
+    */
+    async #process(interaction) {
+        this.#timer.refresh();
+        switch (interaction.customId) {
+            case 'Warns':
+            case 'Suspensions':
+            case 'Mutes':
+                this.#page = interaction.customId;
+                break;
+            case 'member-select':
+                this.#index = interaction.values[0];
+                this.#page = this.#availablePages[0];
+                break;
+            default:
+        }
+        await interaction.update(this.#content);
+    }
+
+    async #stop() {
+        await this.#message.edit({ embeds: [this.#embed], components: [] });
+    }
+
+    get #memberId() { return this.#members[this.#index]; }
+
+    get #member() { return this.#guild.members.cache.get(this.#memberId); }
+
+    get #memberSelect() {
+        const menu = new StringSelectMenuBuilder()
+            .setCustomId('member-select')
+            .setMaxValues(1)
+            .setMinValues(1)
+            .setPlaceholder('Select a member...');
+
+        let index = 0;
+        for (const id of this.#members) {
+            const member = this.#guild.members.cache.get(id);
+            const option = new StringSelectMenuOptionBuilder()
+                .setValue(`${index++}`)
+                .setLabel(member.displayName);
+
+            if (id == this.#memberId) option.setDefault(true);
+            menu.addOptions(option);
+        }
+        return menu;
+    }
+
+    get #components() {
+        const components = [];
+        if (this.#members.length > 1) components.push(new ActionRowBuilder().addComponents(this.#memberSelect));
+
+        const buttons = this.#availablePages.map(page => {
+            const button = new ButtonBuilder()
+                .setCustomId(page)
+                .setLabel(page)
+                .setStyle(ButtonStyle.Primary);
+            if (this.#page == page) button.setDisabled(true);
+            return button;
+        });
+
+        if (buttons.length) components.push(new ActionRowBuilder().addComponents(...buttons));
+        return components;
+    }
+
+    get #availablePages() {
+        return [
+            this.#warns[this.#memberId] && 'Warns',
+            this.#suspensions[this.#memberId] && 'Suspensions',
+            this.#mutes[this.#memberId] && 'Mutes'
+        ].filter(page => page);
+    }
+
+    get #noPunishmentsPage() {
+        const member = this.#member;
+        return new EmbedBuilder()
+            .setColor(Colors.Green)
+            .setTitle('No Punishments')
+            .setDescription(`${member} has no punishments in ${this.#guild.name}.`);
+    }
+
+    get #warnsPage() {
+        const member = this.#member;
+        const embed = new EmbedBuilder()
+            .setColor(Colors.Yellow)
+            .setTitle('Warns')
+            .setDescription(`Warns for ${member}`);
+        const rows = this.#warns[this.#memberId];
+        const fields = [''];
+        let i = 1;
+        for (; i <= rows.length; i++) {
+            const row = rows[i - 1];
+            const time = timeString(false, (row.time / 1000).toFixed(0));
+            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.silent ? ' *Silently*' : ''} By <@!${row.modid}> ${time}\`\`\`${row.reason}\`\`\`\n`;
+            if (embed.length + fields.map(f => f.length).reduce((a, c) => a + c, 0) + text.length >= 5600) break;
+            if (fields[fields.length - 1].length + text.length >= 800) fields.push('');
+            fields[fields.length - 1] += text;
+        }
+        embed.addFields(fields.map((text) => ({ name: '\u000B', value: text, inline: true })));
+        if (i - 1 != rows.length) embed.addFields({ name: 'Too Many Warns', value: `${member} has ${rows.length} warns but only ${i - 1} could fit in the UI.` });
+        return embed;
+    }
+
+    get #suspensionsPage() {
+        const member = this.#member;
+        const embed = new EmbedBuilder()
+            .setColor(Colors.Red)
+            .setTitle('Suspensions')
+            .setDescription(`Suspensions for ${member}`);
+
+        const rows = this.#suspensions[this.#memberId];
+        const fields = [''];
+        let i = 1;
+        for (; i <= rows.length; i++) {
+            const row = rows[i - 1];
+            const time = timeString(row.perma, (row.uTime / 1000).toFixed(0));
+            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.suspended ? ' **Active**' : ''} By <@!${row.modid}> ${time}\`\`\`${row.reason}\`\`\`\n`;
+            if (embed.length + fields.map(f => f.length).reduce((a, c) => a + c, 0) + text.length >= 5600) break;
+            if (fields[fields.length - 1].length + text.length >= 800) fields.push('');
+            fields[fields.length - 1] += text;
+        }
+        embed.addFields(fields.map((text) => ({ name: '\u000B', value: text, inline: true })));
+        if (i - 1 != rows.length) embed.addFields({ name: 'Too Many Suspensions', value: `${member} has ${rows.length} suspensions but only ${i - 1} could fit in the UI.` });
+        return embed;
+    }
+
+    get #mutesPage() {
+        const member = this.#member;
+        const embed = new EmbedBuilder()
+            .setColor(Colors.LightGrey)
+            .setTitle('Mutes')
+            .setDescription(`Mutes for ${member}`);
+
+        const fields = [''];
+        const rows = [...this.#mutes[this.#memberId].filter(row => !row.removedOn), ...this.#mutes[this.#memberId].filter(row => row.removedOn)];
+        let i = 1;
+        for (;i <= rows.length; i++) {
+            const row = rows[i - 1];
+            const time = (row.duration ? '' : 'ending ') + timeString(!row.duration, row.appliedOn + row.duration, row.removedOn);
+            const text = `\`${(i).toString().padStart(3, ' ')}\`${!row.removedOn ? ' **Active**' : ''} By <@!${row.modid}> ${time} \`\`\`${row.reason}\`\`\`\n`;
+            if (embed.length + fields.map(f => f.length).reduce((a, c) => a + c, 0) + text.length >= 5600) break;
+            if (fields[fields.length - 1].length + text.length >= 800) fields.push('');
+            fields[fields.length - 1] += text;
+        }
+        embed.addFields(fields.map((text) => ({ name: '\u000B', value: text, inline: true })));
+        if (i - 1 != rows.length) embed.addFields({ name: 'Too Many Mutes', value: `${member} has ${rows.length} mutes but only ${i - 1} could fit in the UI.` });
+        return embed;
+    }
+
+    get #embed() {
+        const member = this.#member;
+        const pages = this.#availablePages;
+        let page = this.#noPunishmentsPage;
+        if (pages.includes('Warns') && this.#page == 'Warns') page = this.#warnsPage;
+        else if (pages.includes('Suspensions') && this.#page == 'Suspensions') page = this.#suspensionsPage;
+        else if (pages.includes('Mutes') && this.#page == 'Mutes') page = this.#mutesPage;
+        page.setAuthor({ name: member.displayName, value: member.displayAvatarURL() })
+            .setFooter({ text: `Search by ${this.#moderator.displayName}`, iconURL: this.#moderator.displayAvatarURL() })
+            .setTimestamp();
+        return page;
+    }
+
+    get #content() { return { embeds: [this.#embed], components: this.#components }; }
+}
+
 module.exports = {
     role: 'security',
     name: 'punishments',
     slashCommandName: 'pu',
     alias: ['backgroundcheck', 'pu', 'ui', 'userinfo'],
-    requiredArgs: 1,
     description: 'Displays all mutes, warnings or suspensions any user has',
     varargs: true,
     args: [
@@ -62,60 +252,27 @@ module.exports = {
         }),
     ],
     getSlashCommandData(guild) { return slashCommandJSON(this, guild); },
-    async execute(message, args, bot, db) {
-        const settings = bot.settings[message.guild.id];
-        const { roles, rolePermissions } = settings;
-        const roleCache = message.guild.roles.cache;
+    async execute(interaction, args, bot, db) {
+        const settings = bot.settings[interaction.guild.id];
 
-        const usersNotFound = [];
+        const unfound = [];
         const members = [];
-        for (const user of args) {
-            const member = message.guild.findMember(user);
+        for (const search of args) {
+            const member = interaction.guild.findMember(search);
             if (member) members.push(member);
-            else usersNotFound.push(user);
+            else unfound.push(member);
         }
 
         if (members.length > 0) {
-            const punishmentsByType = {};
-            const memberPosition = message.member.roles.highest.position;
-            if (memberPosition >= roleCache.get(roles[rolePermissions.punishmentsWarnings]).position && settings.backend.punishmentsWarnings) {
-                const [warnRows] = await db.promise().query('SELECT *, time as uTime FROM ?? WHERE id IN (?) AND guildid = ?', ['warns', members.map(member => member.id), message.guild.id]);
-                punishmentsByType['Warnings'] = flattenOnId(warnRows);
-            }
-            if (memberPosition >= roleCache.get(roles[rolePermissions.punishmentsSuspensions]).position && settings.backend.punishmentsSuspensions) {
-                const [suspendRows] = await db.promise().query('SELECT *, false silent FROM ?? WHERE id IN (?) AND guildid = ?', ['suspensions', members.map(member => member.id), message.guild.id]);
-                punishmentsByType['Suspensions'] = flattenOnId(suspendRows);
-            }
-            if (memberPosition >= roleCache.get(roles[rolePermissions.punishmentsMutes]).position && settings.backend.punishmentsMutes) {
-                const [muteRows] = await db.promise().query('SELECT *, false silent FROM ?? WHERE id IN (?) AND guildid = ?', ['mutes', members.map(member => member.id), message.guild.id]);
-                punishmentsByType['Mutes'] = flattenOnId(muteRows);
-            }
-
-            for (const member of members) {
-                const embeds = Object.entries(punishmentsByType).map(([title, punishmentsByUserId]) => punishmentsByUserId[member.id] && buildPunishmentEmbed(punishmentsByUserId[member.id], member, title)).filter(i => i);
-
-                // Disabling eslint await in loop error because we need the
-                // messages to send in order, so the await is required
-                if (embeds.length > 0) {
-                    // eslint-disable-next-line no-await-in-loop
-                    await message.reply({ embeds });
-                } else {
-                    const embed = new Discord.EmbedBuilder()
-                        .setTitle('No punishments')
-                        .setDescription(`${member} has no punishments in this server.`)
-                        .setColor('#F04747');
-                    // eslint-disable-next-line no-await-in-loop
-                    await message.reply({ embeds: [embed] });
-                }
-            }
+            const pui = new PunishmentsUI(interaction, interaction.guild, settings, members.map(m => m.id));
+            await pui.initialize(db);
         }
-
-        if (usersNotFound.length > 0) {
-            const embedNotFound = new Discord.EmbedBuilder()
+        if (unfound.length > 0) {
+            const embed = new EmbedBuilder()
                 .setTitle('Users not found')
-                .setColor('#fAA61A')
-                .setDescription(usersNotFound.join(', '));
-            await message.reply({ embeds: [embedNotFound] });
+                .setColor(Colors.Gold)
+                .setDescription(unfound.join(', '));
+            await interaction.followUp({ embeds: [embed] });
         }
     }
 };
diff --git a/commands/test.js b/commands/test.js
index db3535a9..18e0a415 100644
--- a/commands/test.js
+++ b/commands/test.js
@@ -10,7 +10,55 @@ module.exports = {
     guildspecific: true,
     role: 'developer',
     async execute(message, args, bot, db) {
-        const repliedMessage = "Toast!!!!!"
-        await message.reply(repliedMessage)
+        if (args[0] != 'CONVERT_DB_ONLY_RUN_ONCE') return;
+        const [rows] = await db.promise().query('SELECT * FROM mutes');
+        const now = Date.now();
+        const newRows = rows.map(({ id, guildid, reason, modid, uTime, muted, perma })=> {
+            // duration is 0 if perma in new system
+            // if old uTime is NaN, default to perma if muted = 1
+            perma = perma || (isNaN(uTime) && muted);
+            // Normally, duration will be 0 if a mute is labeled 'Permanent'
+            // Unfortunately, there's no way of knowing when the mute was applied so we can't infer duration from uTime
+            const duration = perma || !muted ? 0 : Math.max(0, (parseInt(uTime) / 1000)^0 - Date.unix());
+            // If a mute has not been resolved, removedOn will be null
+            // If permanent mute or there's a duration, then it should not yet be resolved
+            const removedOn = perma || duration ? null : Date.unix();
+            const removedBy = removedOn && bot.user.id;
+            const removeReason = removedOn && `Automatic or unknown, occurred before ${new Date()}`;
+            return [ id, modid, guildid, reason, duration, removedOn, removedBy, removeReason ];
+        });
+        await db.promise().query('DROP TABLE IF EXISTS `temp_mutes`');
+        await db.promise().query('CREATE TABLE `temp_mutes` ( \
+            `id` varchar(32) NOT NULL, \
+            `modid` varchar(32) NOT NULL, \
+            `guildid` varchar(32) NOT NULL, \
+            `reason` varchar(1024) NOT NULL, \
+            `appliedOn` int NOT NULL DEFAULT (unix_timestamp()), \
+            `duration` int NOT NULL, \
+            `removedOn` int DEFAULT NULL, \
+            `removedBy` varchar(32) DEFAULT NULL, \
+            `removeReason` varchar(1024) DEFAULT NULL \
+          )');
+
+        await db.promise().query('INSERT INTO temp_mutes (id, modid, guildid, reason, duration, removedOn, removedBy, removeReason) VALUES ?', [newRows]);
+        await db.promise().query('RENAME TABLE mutes TO mutes_backup');
+        await db.promise().query('RENAME TABLE temp_mutes TO mutes');
+
+        const [final] = await db.promise().query('SELECT * FROM mutes');
+        const embed = new Discord.EmbedBuilder()
+            .setTitle('Mute Table Conversion')
+            .setDescription('Converted mutes table to new schema.\nIf issues arise, the \`mutes\` table has been backed up as \`mutes_backup\`')
+            .setColor(Discord.Colors.Green)
+            .setTimestamp()
+            .setFooter({ text: message.member.displayName, iconURL: message.member.displayAvatarURL() });
+
+        embed.addFields({ 
+            name: 'Mutes', 
+            value: final.filter(r => !r.removedOn)
+                .map(r => { r.guild = bot.guilds.cache.get(r.guildid); return r })
+                .map(r => `<@${r.id}> by <@${r.modid}> in ${r.guild?.name || `Unknown Guild ${r.guildid}`} ` + (r.duration ? `ending <t:${r.appliedOn + r.duration}:R>` : 'Permanently'))
+                .join('\n')
+        })
+        message.reply({ embeds: [embed] });
     }
 }
diff --git a/commands/unmute.js b/commands/unmute.js
index 4952feda..f8eb5c6f 100644
--- a/commands/unmute.js
+++ b/commands/unmute.js
@@ -1,71 +1,112 @@
-const Discord = require('discord.js')
-const ErrorLogger = require('../lib/logError')
-const fs = require('fs')
-const SlashArgType = require('discord-api-types/v10').ApplicationCommandOptionType;
-const { slashArg, slashChoices, slashCommandJSON } = require('../utils.js')
+const { EmbedBuilder, Colors } = require('discord.js');
+const ErrorLogger = require('../lib/logError');
+const { ApplicationCommandOptionType } = require('discord-api-types/v10');
+const { slashArg, slashCommandJSON } = require('../utils.js');
+const moment = require('moment');
+
+/**
+ *
+ * @param {number} duration
+ * @returns {string}
+ */
+function durationString(duration, when = Date.unix()) {
+    if (!duration) return 'Permanent';
+    duration = parseInt(duration);
+    when = parseInt(when);
+    return `${moment.duration(duration * 1000).humanize()} ending <t:${when + duration}:R> at <t:${when + duration}:f>`;
+}
 
 module.exports = {
     name: 'unmute',
     description: 'Removes muted role from user',
-    args: '<ign/mention/id>',
-    requiredArgs: 1,
     role: 'security',
     args: [
-        slashArg(SlashArgType.User, 'member', {
-            description: "Member in the Server"
+        slashArg(ApplicationCommandOptionType.User, 'member', {
+            description: 'Member in the Server'
         }),
+        slashArg(ApplicationCommandOptionType.String, 'reason', {
+            description: 'Reason for the unmute',
+            required: false,
+            varargs: true
+        })
     ],
     getSlashCommandData(guild) {
-        return slashCommandJSON(this, guild)
+        return slashCommandJSON(this, guild);
+    },
+
+    /**
+     *
+     * @param {import('../utils.js').BotCommandInteraction} interaction
+     * @param {string[]} args unused
+     * @param {import('discord.js').Client} bot
+     * @param {import('mysql2').Pool} db
+     */
+    async execute(interaction, args, bot, db) {
+        const settings = bot.settings[interaction.guild.id];
+        const member = interaction.options.getMember('member');
+        const reason = interaction.options.getString('reason') || 'No reason provided';
+
+        const [[row]] = await db.promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [member.id, member.guild.id]);
+
+        if (!row && !member.roles.cache.has(settings.roles.muted)) {
+            const embed = new EmbedBuilder()
+                .setFooter({ text: `Ran by ${interaction.member.displayName}`, iconURL: interaction.member.displayAvatarURL() })
+                .setDescription(`${member} does not have the muted role and doesn't have any active mutes with ${interaction.client.user}.`)
+                .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+                .setTitle('Unmute')
+                .setTimestamp()
+                .setColor(Colors.Red);
+            return await interaction.reply({ embeds: [embed] });
+        }
+
+        await this.unmute(interaction, interaction.guild, interaction.member, member, settings, db, row, reason);
     },
-    async execute(message, args, bot, db) {
-        let settings = bot.settings[message.guild.id]
-        var member = message.mentions.members.first()
-        if (!member) member = message.guild.members.cache.get(args[0]);
-        if (!member) member = message.guild.members.cache.filter(user => user.nickname != null).find(nick => nick.nickname.replace(/[^a-z|]/gi, '').toLowerCase().split('|').includes(args[0].toLowerCase()));
-        if (!member) { message.reply('User not found. Please try again'); return; }
-        if (member.roles.highest.position >= message.member.roles.highest.position) return message.reply(`${member} has a role greater than or equal to you and cannot be unmuted by you`);
-        let muted = settings.roles.muted
-        if (!member.roles.cache.has(muted)) {
-            message.reply(`${member} is not muted`)
-            return;
+
+    /**
+     *
+     * @param {import('../utils.js').BotCommandInteraction?} interaction
+     * @param {import('discord.js').GuildMember} moderator
+     * @param {import('discord.js').GuildMember?} member
+     * @param {*} settings
+     * @param {import('mysql2').Pool} db
+     * @param {import('./mute.js').MuteRow} row
+     * @param {string} reason
+     */
+    async unmute(interaction, guild, moderator, member, settings, db, row, reason) {
+        const embed = new EmbedBuilder()
+            .setColor(Colors.Green)
+            .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+            .setTitle('Unmute')
+            .setTimestamp()
+            .setFooter({ text: `Ran by ${moderator.displayName}`, iconURL: moderator.displayAvatarURL() })
+            .addFields({ name: 'Member', value: member ? `${member} \`${member.displayName}\`` : `<@!${row.id}> (not in server)`, inline: true },
+                { name: 'Moderator', value: `${moderator} \`${moderator.displayName}\``, inline: true },
+                { name: 'Unmute Time', value: `<t:${Date.unix()}:f>`, inline: true },
+                { name: 'Unmute Reason', value: reason });
+
+        if (row) {
+            await db.promise().query('UPDATE mutes SET removedOn = unix_timestamp(), removedBy = ?, removeReason = ? WHERE id = ? AND guildid = ? AND removedOn IS NULL',
+                [moderator.id, reason, row.id, guild.id]);
+
+            const mod = guild.members.cache.get(row.modid);
+            embed.addFields({ name: 'Muted By', value: mod ? `${mod} \`${mod.displayName}\`` : `<@!${row.modid}>`, inline: true },
+                { name: 'Muted On', value: `<t:${row.appliedOn}:R> at <t:${row.appliedOn}:f>`, inline: true },
+                { name: 'Mute Duration', value: durationString(row.duration, row.appliedOn), inline: true },
+                { name: 'Mute Reason', value: row.reason });
+        } else {
+            embed.addFields({ name: 'Unmanaged', value: `<@!${member.id}> had the <@&${settings.roles.muted}> role but it was not managed by ${guild.client.user}.` });
         }
-        db.query(`SELECT * FROM mutes WHERE id = '${member.id}' AND muted = true`, async (err, rows) => {
-            if (err) ErrorLogger.log(err, bot, message.guild)
-            if (!rows || rows.length == 0) {
-                let embed = new Discord.EmbedBuilder()
-                    .setTitle('Confirm Action')
-                    .setColor('#ff0000')
-                    .setDescription(`I don't have any log of ${member} being muted. Are you sure you want to unmute them?`)
-                let confirmMessage = await message.channel.send({ embeds: [embed] })
-                let reactionCollector = new Discord.ReactionCollector(confirmMessage, { filter: (r, u) => !u.bot && u.id == message.author.id && (r.emoji.name === '✅' || r.emoji.name === '❌') })
-                reactionCollector.on('collect', async (r, u) => {
-                    confirmMessage.delete()
-                    if (r.emoji.name !== '✅') return;
-                    member.roles.remove(muted).catch(er => ErrorLogger.log(er, bot, message.guild))
-                    message.channel.send(`${member} has been unmuted`)
-                })
-                await confirmMessage.react('✅')
-                await confirmMessage.react('❌')
-            } else {
-                const reason = rows[0].reason
-                const unmuteUTime = parseInt(rows[0].uTime)
-                let embed = new Discord.EmbedBuilder()
-                    .setTitle('Confirm Action')
-                    .setColor('#ff0000')
-                    .setDescription(`Are you sure you want to unmute ${member}\nReason: ${reason}\nMuted by <@!${rows[0].modid}>\nUnmute: <t:${(unmuteUTime/1000).toFixed(0)}:R> at <t:${(unmuteUTime/1000).toFixed(0)}:f>`)
-                let confirmMessage = await message.channel.send({ embeds: [embed] })
-                let reactionCollector = new Discord.ReactionCollector(confirmMessage, { filter: (r, u) => !u.bot && u.id == message.author.id && (r.emoji.name === '✅' || r.emoji.name === '❌') })
-                await confirmMessage.react('✅')
-                await confirmMessage.react('❌')
-                reactionCollector.on('collect', async (r, u) => {
-                    confirmMessage.delete()
-                    if (r.emoji.name !== '✅') return;
-                    await member.roles.remove(muted).catch(er => ErrorLogger.log(er, bot, message.guild))
-                    message.reply(`${member} has been unmuted`)
-                    db.query(`UPDATE mutes SET muted = false WHERE id = '${member.id}'`)
-                })
+
+        try {
+            if (member) {
+                await member.roles.remove(settings.roles.muted);
+                const dm = await member.createDM().catch(() => {});
+                await dm?.send({ embeds: [embed] }).catch(() => {});
             }
-        })
+            if (interaction) await interaction.reply({ embeds: [embed] });
+            await guild.channels.cache.get(settings.channels.modlogs).send({ embeds: [embed] });
+        } catch (e) {
+            ErrorLogger.log(e, guild.client, guild);
+        }
     }
-}
\ No newline at end of file
+};
diff --git a/dbSetup.js b/dbSetup.js
index 2095710f..2d440646 100644
--- a/dbSetup.js
+++ b/dbSetup.js
@@ -52,7 +52,7 @@ class DbWrap {
                 let error = null;
                 let rv = null;
                 try {
-                    rv = await dbPromise.query(query, params, cb).catch(() => {});
+                    rv = await dbPromise.query(query, params, cb);
                 } catch (e) {
                     error = e;
                 }
diff --git a/jobs/mute.js b/jobs/mute.js
index 66717eef..b13e56de 100644
--- a/jobs/mute.js
+++ b/jobs/mute.js
@@ -1,26 +1,25 @@
 const { RepeatedJob } = require('./RepeatedJob.js');
-const ErrorLogger = require('../lib/logError');
-const { iterServersWithQuery } = require('./util.js');
+const { iterServers } = require('./util.js');
 const { getDB } = require('../dbSetup.js');
-
+const { unmute } = require('../commands/unmute.js');
 class Mute extends RepeatedJob {
     async run(bot) {
-        await iterServersWithQuery(bot, 'SELECT * FROM mutes WHERE muted = true', async (bot, row, g) => {
-            if (Date.now() > parseInt(row.uTime)) {
-                const guildId = row.guildid;
-                const settings = bot.settings[guildId];
-                const guild = bot.guilds.cache.get(guildId);
-                if (guild) {
-                    const db = getDB(g.id);
-                    const member = guild.members.cache.get(row.id);
-                    if (!member) return await db.promise().query('UPDATE mutes SET muted = false WHERE id = ?', [row.id]);
-                    try {
-                        await member.roles.remove(settings.roles.muted);
-                        await db.promise().query('UPDATE mutes SET muted = false WHERE id = ?', [row.id]);
-                    } catch (er) {
-                        ErrorLogger.log(er, bot, g);
-                    }
+        await iterServers(bot, async (bot, guild) => {
+            const ids = [];
+            const settings = bot.settings[guild.id];
+            const db = getDB(guild.id);
+            const botMember = guild.members.cache.get(bot.user.id);
+            const [rows] = await db.promise().query('SELECT * FROM mutes WHERE guildid = ? AND removedOn IS NULL', [guild.id]);
+            for (const row of rows) {
+                const member = guild.members.cache.get(row.id);
+                if (ids.includes(row.id)) continue;
+                if (parseInt(row.appliedOn) + parseInt(row.duration) > Date.unix() || !row.duration) {
+                    if (!member?.roles.cache.has(settings.roles.muted)) member?.roles.add(settings.roles.muted);
+                    continue;
                 }
+                ids.push(row.id); // In case db ends up with multiple rows with removedOn = null
+                // eslint-disable-next-line no-await-in-loop
+                await unmute(null, guild, botMember, member, settings, db, row, 'Mute expired');
             }
         });
     }
diff --git a/lib/extensions.js b/lib/extensions.js
index af72a4aa..af7d310a 100644
--- a/lib/extensions.js
+++ b/lib/extensions.js
@@ -32,6 +32,8 @@ module.exports = {
     createEmbed
 };
 
+Date.unix = function() { return (Date.now() / 1000)^0 };
+
 /* Promise.wait = Promise.wait || function(time) {
     let waiter, rej;
     return { finished: new Promise((resolve, reject) => { rej = reject; waiter = setTimeout(resolve, time) }), cancel: () => { clearTimeout(waiter); rej(new Error('Wait cancelled.')); } };
diff --git a/memberHandler.js b/memberHandler.js
index 8fb4efa6..4d8a3f08 100644
--- a/memberHandler.js
+++ b/memberHandler.js
@@ -50,7 +50,7 @@ module.exports = {
     async checkWasMuted(bot, member) {
         const db = getDB(member.guild.id);
 
-        const [[{ muteCount }]] = await db.promise().query('SELECT COUNT(*) as muteCount FROM mutes WHERE id = ? AND muted = true', [member.id]);
+        const [[{ muteCount }]] = await db.promise().query('SELECT COUNT(*) as muteCount FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [member.id, member.guild.id]);
         if (muteCount !== 0) {
             await member.roles.add(bot.settings[member.guild.id].roles.muted);
             const logChannel = modlogChannel(bot, member.guild);
@@ -69,7 +69,7 @@ module.exports = {
         await Promise.all(bot.partneredServers.filter((server) => server.guildId == member.guild.id).map(async (partneredServer) => {
             const partneredSettings = bot.settings[partneredServer.id];
             const otherServer = bot.guilds.cache.find(g => g.id == partneredServer.id);
-            const partneredMember = otherServer.members.cache.get(member.id);
+            const partneredMember = otherServer?.members.cache.get(member.id);
 
             if (!partneredMember) { return; }
 
diff --git a/messageManager.js b/messageManager.js
index 9104d943..2facd2c3 100644
--- a/messageManager.js
+++ b/messageManager.js
@@ -12,7 +12,7 @@ const modmail = require('./lib/modmail.js')
 const { argString } = require('./commands/commands.js');
 const { getDB } = require('./dbSetup.js')
 const { LegacyCommandOptions, LegacyParserError } = require('./utils.js')
-
+const { mute } = require('./commands/mute.js');
 class MessageManager {
     #bot;
     #botSettings;
@@ -302,27 +302,9 @@ class MessageManager {
         const settings = this.#bot.settings[message.guild.id]
         if (!settings || !settings.backend.automod) return;
         if (!message.member.roles.highest || message.member.roles.highest.position >= message.guild.roles.cache.get(settings.roles.eventrl).position) return
-        if (message.mentions.roles.size != 0) mute('Pinging Roles', 2);
-
-        function mute(reason, time) {
-            // Time: 1=1 hour, 2=1 day
-            let timeString; let timeValue;
-            if (time == 1) {
-                timeString = '1 Hour';
-                timeValue = 3600000
-            } else if (time == 2) {
-                timeString = '1 Day';
-                timeValue = 86400000
-            }
-
-            message.member.roles.add(settings.roles.muted)
-                .then(() => this.#bot.dbs[message.guild.id].query(`INSERT INTO mutes (id, guildid, muted, reason, modid, uTime) VALUES ('${message.author.id}', '${message.guild.id}', true, '${reason}','${this.#bot.user.id}', '${Date.now() + timeValue}')`))
-                .then(() => message.author.send(`You have been muted in \`${message.guild.name}\` for \`${reason}\`. This will last for \`${timeString}\``))
-                .then(() => {
-                    const modlog = message.guild.channels.cache.get(settings.channels.modlog)
-                    if (!modlog) return ErrorLogger.log(new Error('Mod log not found for automod'), this.#bot, message.guild)
-                    modlog.send(`${message.member} was muted for \`${timeString}\` for \`${reason}\``)
-                })
+        if (message.mentions.roles.size != 0) {
+            const [rows] = await this.#bot.dbs[message.guild.id].promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [message.member.id, message.guild.id]);
+            await mute(settings, this.#bot.dbs[message.guild.id], null, message.member, 86400000, 'Pinging roles', rows[0]);
         }
     }
 
diff --git a/utils.js b/utils.js
index 9bd59407..b30ecd60 100644
--- a/utils.js
+++ b/utils.js
@@ -23,10 +23,11 @@ class LegacyCommandOptions {
     #opts;
     #users = [];
     #attachments;
-
+    #settings;
     constructor(opts, message, varargs) {
         this.#opts = opts;
         this.#message = message;
+        this.#settings = message.client.settings[message.guild.id];
         this.#attachments = message.attachments.map((v) => v);
         const s = message.content;
         const [, ...args] = s.slice(1).split(/ +/gi);
@@ -35,7 +36,7 @@ class LegacyCommandOptions {
             const currentOpt = optsToParse.shift();
             if (currentOpt.required && (currentOpt.type == SlashArgType.Attachment ? this.#attachments.length == 0 : args.length == 0)) throw new LegacyParserError(`Not enough arguments. Expected: ${argString(opts)}`);
             if (args.length == 0) break;
-            const currentArg = args.shift();
+            const currentArg = currentOpt.varargs ? args.splice(0).join(' ') : args.shift();
             if (currentOpt.type == SlashArgType.Subcommand) {
                 // Grab all the subcommand options
                 const possibleSubcommands = [currentOpt];
@@ -47,7 +48,12 @@ class LegacyCommandOptions {
                 this.subcommand = subcommand.name;
                 subcommand.options.forEach((opt) => {
                     if (args.length == 0 && opt.required) throw new LegacyParserError(`Not enough arguments for subcommand \`${subcommand.name}\`. Expected: ${argString(opts)}`);
-                    if (args.length != 0) {
+                    if (opt.varargs) {
+                        const v = this.#processType(opt.type, args.splice(0).join(' '));
+                        if (!v) throw new LegacyParserError(`Error parsing argument \`${opt.name}\``);
+                        this.args[opt.name] = v;
+                    }
+                    if (args.length) {
                         const v = this.#processType(opt.type, args.shift());
                         if (!v) throw new LegacyParserError(`Error parsing argument \`${opt.name}\``);
                         this.args[opt.name] = v;
@@ -76,26 +82,56 @@ class LegacyCommandOptions {
         };
     }
 
+    /**
+     * @returns {string[]}
+     */
     getVarargs() {
         return this.args.varargs || [];
     }
 
+    /**
+     * @param {string} k
+     * @returns {string}
+     */
     getString(k) {
         if (this.#optTypeMatch(SlashArgType.String, k)) return this.args[k];
     }
 
+    /**
+     * @param {string} k
+     * @returns {import('discord.js').GuildMember}
+     */
     getMember(k) {
         if (this.#optTypeMatch(SlashArgType.User, k)) return this.args[k];
     }
 
+    /**
+     * @param {string} k
+     * @returns {number}
+     */
     getInteger(k) {
         if (this.#optTypeMatch(SlashArgType.Integer, k)) return this.args[k];
     }
 
+    /**
+     * @param {string} k
+     * @returns {import('discord.js').Attachment}
+     */
     getAttachment(k) {
         if (this.#optTypeMatch(SlashArgType.Attachment, k)) return this.args[k];
     }
 
+    /**
+     * @param {string} k
+     * @returns {import('discord.js').Role | import('discord.js').BaseChannel | import('discord.js').GuildMember}
+     */
+    getMentionable(k) {
+        if (this.#optTypeMatch(SlashArgType.Mentionable, k)) return this.args[k];
+    }
+
+    /**
+     * @returns {string}
+     */
     getSubcommand() {
         return this.subcommand;
     }
@@ -113,14 +149,26 @@ class LegacyCommandOptions {
                 this.#users.push(member);
                 return member;
             }
+            case SlashArgType.Boolean: {
+                value = value.toLowerCase();
+                if (['f', 'false', 'no', 'n', '0'].includes(value)) return false;
+                if (['t', 'true', '1', 'yes', 'y'].includes(value)) return true;
+                throw new LegacyParserError(`\`${value}\` is not a valid value, try either \`true\` or \`false\`.`);
+            }
             case SlashArgType.String: return value;
             case SlashArgType.Integer: return parseInt(value);
             case SlashArgType.Attachment: return this.#attachments.shift();
+            case SlashArgType.Number: return parseFloat(value);
+            case SlashArgType.Role: return Object.keys(this.#settings.roles).includes(value) ? this.#message.guild.roles.cache.get(this.#settings.roles[value]) : this.#message.guild.roles.cache.get(value.replace(/\D/g, ''));
+            case SlashArgType.Channel: return Object.keys(this.#settings.channels).includes(value) ? this.#message.guild.channels.cache.get(this.#settings.channels[value]) : this.#message.guild.channels.cache.get(value.replace(/\D/g, ''));
+            case SlashArgType.Mentionable: return this.#processType(SlashArgType.Role, value) ?? this.#processType(SlashArgType.Channel, value) ?? this.#message.guild.findMember(value);
             default: throw new Error('Unhandled type');
         }
     }
 }
-
+/**
+ * @typedef {import('discord.js').Message & { options: LegacyCommandOptions } | import('discord.js').CommandInteraction} BotCommandInteraction
+ */
 module.exports = {
     slashArg(type, name, opts) {
         const obj = {

From bfdffebc5dc8fcb8e5603eb36fb946c18ba82417 Mon Sep 17 00:00:00 2001
From: husky-rotmg <70654625+husky-rotmg@users.noreply.github.com>
Date: Sun, 18 Feb 2024 10:59:18 -0500
Subject: [PATCH 2/9] Update punishments.js

---
 commands/punishments.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/commands/punishments.js b/commands/punishments.js
index 3a2f0617..db08d72b 100644
--- a/commands/punishments.js
+++ b/commands/punishments.js
@@ -145,7 +145,7 @@ class PunishmentsUI {
             const [mutes] = await db.promise().query('SELECT * FROM mutes WHERE id in (?) AND guildid = ? ORDER BY appliedOn + duration DESC', [ids, this.#guild.id]);
             const permas = mutes.filter(mute => !mute.removedOn && !mute.duration);
             const actives = mutes.filter(mute => !permas.includes(mute) && !mute.removedOn);
-            const remaining = mutes.filter(mute => !permas.includes(mute) && !actives.include(mute));
+            const remaining = mutes.filter(mute => !permas.includes(mute) && !actives.includes(mute));
             this.#mutes = flattenOnId([...permas, ...actives, ...remaining]); // sort by perma > active > inactive, flattenOnId respects local order
         }
 

From 984e2a3ddfb992385bd175c4dc7d158be6084816 Mon Sep 17 00:00:00 2001
From: husky-rotmg <70654625+husky-rotmg@users.noreply.github.com>
Date: Sun, 18 Feb 2024 11:07:48 -0500
Subject: [PATCH 3/9] Delete mutes.js

---
 commands/mutes.js | 140 ----------------------------------------------
 1 file changed, 140 deletions(-)
 delete mode 100644 commands/mutes.js

diff --git a/commands/mutes.js b/commands/mutes.js
deleted file mode 100644
index b3b0471e..00000000
--- a/commands/mutes.js
+++ /dev/null
@@ -1,140 +0,0 @@
-const moment = require('moment');
-const ErrorLogger = require('../lib/logError');
-const { ApplicationCommandOptionType, EmbedBuilder, Colors } = require('discord.js');
-const { slashArg, slashCommandJSON } = require('../utils');
-
-/**
- * @typedef MuteRow
- * @property {string} id
- * @property {string} guildid
- * @property {boolean} muted
- * @property {string} reason
- * @property {string} modid
- * @property {string} uTime
- * @property {boolean} perma
- */
-/**
- * 
- * @param {MuteRow} row 
- * @param {number?} idx 
- */
-function muteRowToString(row, idx) {
-
-}
-
-/**
- * @param {import('discord.js').Message | import('discord.js').CommandInteraction} message
- * @param {import('discord.js').Client} bot
- * @param {import('mysql2').Pool} db
- * @param {import('discord.js').GuildMember} member
- * @param {import('discord.js').Role} mutedRole
- * @param {EmbedBuilder} embed
- */
-async function displayAllMutes(message, bot, db, mutedRole, embed) {
-    embed.setTitle(`${bot.user.displayName} Managed Mutes`);
-    const members = mutedRole.members.clone();
-
-    const [rows] = await db.promise().query('SELECT * FROM mutes WHERE muted = true AND guildid = ?', [message.guild.id]);
-
-    const mutedTexts = [''];
-    for (const row of rows) {
-        const duration = row.perma ? '**permanently**' : `ending <t:${(parseInt(row.uTime) / 1000).toFixed(0)}:R>`;
-        const userRow = `<@${row.id}> by <@${row.modid}> ${duration}`;
-        if (mutedTexts[mutedTexts.length - 1].length + userRow.length + 1 >= 3800) mutedTexts.push('');
-        mutedTexts[mutedTexts.length - 1] += `${userRow}\n`;
-        members.delete(row.id);
-    }
-
-    if (!rows.length) mutedTexts[0] = 'None!';
-    for (const text of mutedTexts) {
-        embed.setDescription(text);
-        await message.channel.send({ embeds: [embed] });
-        embed.setTitle(`${bot.user.displayName} Managed Mutes (cont.)`);
-    }
-
-    embed.setTitle(`Unmanaged Mutes`);
-    mutedTexts.splice(0);
-    mutedTexts.push('');
-
-    members.forEach(member => {
-        if (mutedTexts[mutedTexts.length - 1].length + `${member}`.length + 1 >= 3800) mutedTexts.push('');
-        mutedTexts[mutedTexts.length -1] += `${member}\n`
-    })
-
-    if (!members.size) mutedTexts[0] = 'None!';
-    for (const text of mutedTexts) {
-        embed.setDescription(text);
-        await message.channel.send({ embeds: [embed] });
-        embed.setTitle(`Unmanaged Mutes (cont.)`);
-    }
-}
-
-module.exports = {
-    name: 'mutes',
-    description: 'Shows mutes for the server',
-    role: 'security',
-    args: [slashArg(ApplicationCommandOptionType.User, 'member', { description: 'member to check mutes of', required: false })],
-    getSlashCommandData(guild) { return slashCommandJSON(this, guild); },
-
-    /**
-     * @param {import('discord.js').Message | import('discord.js').CommandInteraction} message
-     * @param {string[]} args
-     * @param {import('discord.js').Client} bot
-     * @param {import('mysql2').Pool} db
-     */
-    async execute(message, args, bot, db) {
-        /** @type {import('discord.js').GuildMember?} */
-        const member = message.options.getMember('member');
-        /** @type {import('discord.js').Role} */          
-        const mutedRole = message.guild.roles.cache.get(bot.settings[message.guild.id].roles.muted);
-
-        const embed = new EmbedBuilder()
-            .setAuthor({ name: message.guild.name, iconURL: message.guild.iconURL() })
-            .setColor(Colors.DarkButNotBlack)
-            .setTimestamp()
-            .setFooter({ text: `Ran by ${message.member.displayName}`, iconURL: message.member.displayAvatarURL() });
-
-        if (!member) return await displayAllMutes(message, bot, db, mutedRole);
-        
-        embed.setTitle(`Mutes for ${member.displayName}`);
-        const [rows] = await db.promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? ORDER BY muted DESC, uTime DESC', [member.id, member.guild.id]);
-        for (const row of rows) {
-            const userText = ``
-        }
-    }
-}
-
-module.exports1 = {
-    name: 'mutes',
-    description: 'prints all muted members of the server',
-    role: 'security',
-    args: '[IGN | mention | id]',
-    async execute(message, args, bot, db) {
-        const memberSearch = args.shift();
-        let member;
-        if (memberSearch) {
-            member = message.guild.members.cache.get(memberSearch);
-            if (!member) member = message.guild.members.cache.filter(user => user.nickname != null).find(nick => nick.nickname.replace(/[^a-z|]/gi, '').toLowerCase().split('|').includes(memberSearch.toLowerCase()));
-            if (!member) member = message.guild.members.cache.get(memberSearch.replace(/\D/gi, ''))
-        }
-
-        let embed = new Discord.EmbedBuilder()
-            .setAuthor({ name: member ? `Mutes for ${member.nickname || member.user.tag} in ${message.guild.name}` : `Muted members in ${message.guild.name}` })
-            .setDescription(`None!`)
-
-            db.query(`SELECT * FROM mutes WHERE id = ${member.id} AND guildid = ${message.guild.id} ORDER BY muted DESC`, async (err, rows) => {
-                if (err) ErrorLogger.log(err, bot, message.guild);
-                if (!rows || !rows.length)
-                    return message.channel.send({ embeds: [embed] });
-                for (const row of rows) {
-                    if (row.muted)
-                        fitStringIntoEmbed(embed, `**Ends <t:${(parseInt(row.uTime)/1000).toFixed(0)}:R> at <t:${(parseInt(row.uTime)/1000).toFixed(0)}:f> by <@!${row.modid}>: ${row.reason}**`);
-                    else
-                        fitStringIntoEmbed(embed, `Ended <t:${(parseInt(row.uTime)/1000).toFixed(0)}:R> at <t:${(parseInt(row.uTime)/1000).toFixed(0)}:f> by <@!${row.modid}>: ${row.reason}`);
-                }
-                message.channel.send({ embeds: [embed] });
-    });
-        
-
-    }
-}
\ No newline at end of file

From af88f175fc149e0802948f85877460ab75ee3da1 Mon Sep 17 00:00:00 2001
From: husky-rotmg <70654625+husky-rotmg@users.noreply.github.com>
Date: Sun, 18 Feb 2024 13:10:24 -0500
Subject: [PATCH 4/9] decouple execute & slashCommandExecute, eslintignore

Split up slashCommandExecute and execute to keep normal command (mostly) the same, no reason to have `permanent | temporary` as an arg when we can guess based on value of 2nd argument
---
 .eslintignore    |  1 -
 commands/mute.js | 67 +++++++++++++++++++++++++++++++++---------------
 2 files changed, 47 insertions(+), 21 deletions(-)

diff --git a/.eslintignore b/.eslintignore
index a89b6fda..cf476eab 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -30,7 +30,6 @@ commands/manualVerify.js
 commands/manualVetVerify.js
 commands/memes.js
 commands/modmailBlacklist.js
-commands/mute.js
 commands/noNicknames.js
 commands/parsemembers.js
 commands/permaSuspend.js
diff --git a/commands/mute.js b/commands/mute.js
index 6b43559c..f456d3d0 100644
--- a/commands/mute.js
+++ b/commands/mute.js
@@ -110,6 +110,7 @@ module.exports = {
     name: 'mute',
     description: 'Gives user the muted role',
     role: 'security',
+    slashOnlyArgsProcessing: true,
     args: [
         slashArg(SlashArgType.Subcommand, 'temporary', {
             description: 'Temporarily mute member',
@@ -145,7 +146,9 @@ module.exports = {
     getSlashCommandData(guild) {
         return slashCommandJSON(this, guild);
     },
-
+    getNotes() {
+        return { title: 'Chat Command Args', value: '<user> <\'permanent\' | <time> <duration>> <reason>\n\nDuration should be either s(econds), m(inutes), h(ours), d(ays), w(eeks), mo(nths), y(ears)' };
+    },
     /**
      * @param {import('../utils.js').BotCommandInteraction?} interaction
      * @param {import('discord.js').GuildMember} member
@@ -194,19 +197,7 @@ module.exports = {
         const dm = await member.createDM().catch(() => {});
         await dm?.send({ embeds: [embed] }).catch(() => {});
     },
-
-    /**
-     * @param {import('../utils.js').BotCommandInteraction} interaction
-     * @param {string[]} args ignored
-     * @param {import('discord.js').Client} bot
-     * @param {import('mysql2').Pool} db
-     */
-    async execute(interaction, args, bot, db) {
-        const settings = bot.settings[interaction.guild.id];
-        const member = interaction.options.getMember('member');
-        const reason = interaction.options.getString('reason');
-        const type = interaction.options.getSubcommand();
-        const duration = type == 'permanent' ? 0 : processDuration(interaction.options.getString('duration'), interaction.options.getInteger('time'));
+    async processExecute(interaction, settings, db, member, reason, duration) {
         const embed = new EmbedBuilder()
             .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
             .setColor(Colors.Blue)
@@ -217,12 +208,6 @@ module.exports = {
 
         await interaction.reply({ embeds: [embed] });
 
-        if (type != 'permanent' && !duration) {
-            embed.setColor(Colors.Red)
-                .setDescription(`\`${interaction.options.getInteger('time')} ${interaction.options.getString('duration')}\` is not a valid duration.`);
-            return await interaction.editReply({ embeds: [embed] });
-        }
-
         if (member.roles.highest.position >= interaction.member.roles.highest.position) {
             embed.setColor(Colors.Red)
                 .setDescription(`${member} has a role greater than or equal to your own and you cannot mute them.`);
@@ -244,6 +229,48 @@ module.exports = {
         }
 
         await this.mute(settings, db, interaction, member, duration, reason, rows[0]);
+    },
+    /**
+     * @param {import('discord.js').ChatInputCommandInteraction} interaction
+     * @param {import('discord.js').Client} bot
+     * @param {import('mysql2').Pool} db
+     */
+    async slashCommandExecute(interaction, bot, db) {
+        const settings = bot.settings[interaction.guild.id];
+        const member = interaction.options.getMember('member');
+        const reason = interaction.options.getString('reason');
+        const type = interaction.options.getSubcommand();
+        const duration = type == 'permanent' ? 0 : processDuration(interaction.options.getString('duration'), interaction.options.getInteger('time'));
+        await this.processExecute(interaction, settings, db, member, reason, duration);
+    },
+
+    /**
+     * @param {import('discord.js').Message} interaction
+     * @param {string[]} args ignored
+     * @param {import('discord.js').Client} bot
+     * @param {import('mysql2').Pool} db
+     */
+    async execute(message, args, bot, db) {
+        const settings = bot.settings[message.guild.id];
+
+        const embed = new EmbedBuilder()
+            .setColor(Colors.Red)
+            .setTimestamp()
+            .setFooter({ text: `Ran by ${message.member.displayName}` })
+            .setTitle('Invalid Arguments');
+        const search = args.shift();
+        const member = message.guild.findMember(search);
+        if (!member) return message.reply({ embeds: [embed.setDescription(`Could not find member matching \`${search}\``)] });
+
+        const timeValue = args.shift();
+        if (isNaN(timeValue) && !timeValue.toLowerCase().startsWith('perm')) {
+            return await message.reply({ embeds: [embed.setDescription(`\`${timeValue}\` is not a valid argument for \`time\``)] });
+        }
+
+        const duration = isNaN(timeValue) ? 0 : processDuration(args.shift(), parseInt(timeValue));
+        const reason = args.join(' ');
+
+        await this.processExecute(message, settings, db, member, reason, duration);
     }
 };
 

From 73185ee28abe57625ee5065e17ccd1ffbf5096c0 Mon Sep 17 00:00:00 2001
From: husky-rotmg <70654625+husky-rotmg@users.noreply.github.com>
Date: Sun, 18 Feb 2024 22:49:41 -0500
Subject: [PATCH 5/9] Clean out ;test, mute row format

- Remove dangerous code from `;test`, will be done in an `;eval` instead.
- Fixed up formatting for overwrites & old mutes
- initial old mutes have duration -1 since it's unknown so `;punushments` can clarify we aren't certain when or how long (uTime is a terrible field design)
---
 commands/mute.js        | 28 +++++++++-------------
 commands/punishments.js | 38 +++++++++++++++---------------
 commands/test.js        | 51 +----------------------------------------
 3 files changed, 30 insertions(+), 87 deletions(-)

diff --git a/commands/mute.js b/commands/mute.js
index f456d3d0..3a80f19d 100644
--- a/commands/mute.js
+++ b/commands/mute.js
@@ -14,30 +14,24 @@ const { slashArg, slashCommandJSON } = require('../utils.js');
  * @property {number?} removedOn
  * @property {string?} removedBy
  * @property {string?} removeReason
+ * @property {boolean} overwritten
  */
 
 /**
- *
- * @param {number} duration
- * @returns {string}
+ * @param {MuteRow} row
+ * @param {import('discord.js').GuildMember} member
+ * @param {number?} duration
  */
+async function attemptOverwrite(db, row, member, reason) {
+    await db.promise().query('UPDATE mutes SET removedOn = unix_timestamp(), removedBy = ?, removeReason = ?, overwritten = true WHERE id = ? AND guildid = ? AND removedOn IS NULL',
+        [member.id, reason, row.id, row.guildid]);
+}
+
 function durationString(duration, when = Date.unix()) {
     if (!duration) return 'Permanent';
     duration = parseInt(duration);
     when = parseInt(when);
-    const mmt = moment.duration(duration * 1000).humanize();
-    return `${mmt[0].toUpperCase()}${mmt.substring(1)} ending <t:${when + duration}:R> at <t:${when + duration}:f>`;
-}
-
-/**
- * @param {MuteRow} row
- * @param {import('discord.js').GuildMember} member
- * @param {number?} duration
- */
-async function attemptOverwrite(db, row, member, duration) {
-    const removeReason = `Overwritten by ${member} on <t:${Date.unix()}:f> ${durationString(duration)}`;
-    await db.promise().query('UPDATE mutes SET removedOn = unix_timestamp(), removedBy = ?, removeReason = ? WHERE id = ? AND guildid = ? AND removedOn IS NULL',
-        [member.id, removeReason, row.id, row.guildid]);
+    return `Ending <t:${when + duration}:R>\nAt <t:${when + duration}:f>`;
 }
 
 /**
@@ -173,7 +167,7 @@ module.exports = {
                 { name: 'Reason', value: reason });
 
         if (row) {
-            await attemptOverwrite(db, row, moderator, duration);
+            await attemptOverwrite(db, row, moderator, reason);
             const mod = member.guild.members.cache.get(row.modid);
             embed.addFields({ name: 'Overwrote Mute', value: '\u000B' },
                 { name: 'Old Moderator', value: mod ? `${mod} \`${mod.displayName}\`` : `<@${row.modid}>`, inline: true },
diff --git a/commands/punishments.js b/commands/punishments.js
index ec29796d..47bc620c 100644
--- a/commands/punishments.js
+++ b/commands/punishments.js
@@ -1,8 +1,10 @@
+/* eslint-disable no-bitwise */
 /* eslint-disable no-await-in-loop */
 const { EmbedBuilder, Colors, ActionRowBuilder, ButtonBuilder, ButtonStyle, StringSelectMenuBuilder,
     StringSelectMenuOptionBuilder, InteractionCollector, ComponentType } = require('discord.js');
 const SlashArgType = require('discord-api-types/v10').ApplicationCommandOptionType;
 const { slashArg, slashCommandJSON } = require('../utils.js');
+const moment = require('moment');
 
 /** @typedef {{ id: string }} HasID */
 /**
@@ -35,11 +37,13 @@ const { slashArg, slashCommandJSON } = require('../utils.js');
  * @typedef MuteRow
  * @property {string} id
  * @property {string} guildid
- * @property {boolean} muted
- * @property {string} reason
  * @property {string} modid
- * @property {string} uTime
- * @property {boolean} perma
+ * @property {string} reason
+ * @property {number} appliedOn
+ * @property {number} duration
+ * @property {number?} removedOn
+ * @property {string?} removedBy
+ * @property {string?} removeReason
  */
 /**
  * @param {WarnRow[]} rows
@@ -53,16 +57,7 @@ function flattenOnId(rows) {
     }, {});
 }
 
-/**
- * @param {boolean} permanent
- * @param {number} ending unix time
- * @param {number?} ended unix time
- * @returns {string}
- */
-function timeString(permanent, ending, ended) {
-    if (!ended && permanent) return 'Permanently';
-    return `<t:${ended || ending}:R> at <t:${ended || ending}:f>`;
-}
+const timestamp = (time) => `<t:${time}:R> at <t:${time}:f>`;
 
 class PunishmentsUI {
     /** @type {string[]} */
@@ -309,8 +304,7 @@ class PunishmentsUI {
         let i = 1;
         for (; i <= rows.length; i++) {
             const row = rows[i - 1];
-            const time = timeString(false, (row.time / 1000).toFixed(0));
-            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.silent ? ' *Silently*' : ''} By <@!${row.modid}> ${time}\`\`\`${row.reason}\`\`\`\n`;
+            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.silent ? ' *Silently*' : ''} By <@!${row.modid}> ${timestamp((row.time / 1000) ^ 0)}\`\`\`${row.reason}\`\`\`\n`;
             if (embed.length + fields.map(f => f.length).reduce((a, c) => a + c, 0) + text.length >= 5600) break;
             if (fields[fields.length - 1].length + text.length >= 800) fields.push('');
             fields[fields.length - 1] += text;
@@ -335,8 +329,7 @@ class PunishmentsUI {
         let i = 1;
         for (; i <= rows.length; i++) {
             const row = rows[i - 1];
-            const time = timeString(row.perma, (parseInt(row.uTime) / 1000).toFixed(0));
-            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.suspended ? ' **Active**' : ''} By <@!${row.modid}> ${time}\`\`\`${row.reason}\`\`\`\n`;
+            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.suspended ? ' **Active**' : ''} By <@!${row.modid}> ${row.perma ? 'Permanently' : timestamp((parseInt(row.uTime) / 1000) ^ 0)}\`\`\`${row.reason}\`\`\`\n`;
             if (embed.length + fields.map(f => f.length).reduce((a, c) => a + c, 0) + text.length >= 5600) break;
             if (fields[fields.length - 1].length + text.length >= 800) fields.push('');
             fields[fields.length - 1] += text;
@@ -361,8 +354,13 @@ class PunishmentsUI {
         let i = 1;
         for (; i <= rows.length; i++) {
             const row = rows[i - 1];
-            const time = (row.duration ? '' : 'ending ') + timeString(!row.duration, row.appliedOn + row.duration, row.removedOn);
-            const text = `\`${(i).toString().padStart(3, ' ')}\`${!row.removedOn ? ' **Active**' : ''} By <@!${row.modid}> ${time} \`\`\`${row.reason}\`\`\`\n`;
+            let timestr = '';
+            if (!row.duration && !row.removedOn) timestr = 'Permanently';
+            else if (!row.duration) timestr = 'was Permanent';
+            else if (row.duration == -1) timestr = `Unknown duration\nEnded before <t:${row.appliedOn}:f>`;
+            else timestr = `for ${moment.duration(row.duration * 1000).humanize()}\nApplied on <t:${row.appliedOn}:f>`;
+            const reason = row.duration != -1 && row.removedOn ? `\`\`\`\n${row.reason}\`\`\`${row.overwritten ? 'Overwritten' : 'Removed'} <t:${row.removedOn}:R> by <@!${row.removedBy}> \`\`\`\n${row.removeReason}\`\`\`` : `\`\`\`${row.reason}\`\`\``;
+            const text = `\`${(i).toString().padStart(3, ' ')}\`${!row.removedOn ? ' **Active**' : ''} By <@!${row.modid}> ${timestr} ${reason}\n`;
             if (embed.length + fields.map(f => f.length).reduce((a, c) => a + c, 0) + text.length >= 5600) break;
             if (fields[fields.length - 1].length + text.length >= 800) fields.push('');
             fields[fields.length - 1] += text;
diff --git a/commands/test.js b/commands/test.js
index 18e0a415..d36575a2 100644
--- a/commands/test.js
+++ b/commands/test.js
@@ -10,55 +10,6 @@ module.exports = {
     guildspecific: true,
     role: 'developer',
     async execute(message, args, bot, db) {
-        if (args[0] != 'CONVERT_DB_ONLY_RUN_ONCE') return;
-        const [rows] = await db.promise().query('SELECT * FROM mutes');
-        const now = Date.now();
-        const newRows = rows.map(({ id, guildid, reason, modid, uTime, muted, perma })=> {
-            // duration is 0 if perma in new system
-            // if old uTime is NaN, default to perma if muted = 1
-            perma = perma || (isNaN(uTime) && muted);
-            // Normally, duration will be 0 if a mute is labeled 'Permanent'
-            // Unfortunately, there's no way of knowing when the mute was applied so we can't infer duration from uTime
-            const duration = perma || !muted ? 0 : Math.max(0, (parseInt(uTime) / 1000)^0 - Date.unix());
-            // If a mute has not been resolved, removedOn will be null
-            // If permanent mute or there's a duration, then it should not yet be resolved
-            const removedOn = perma || duration ? null : Date.unix();
-            const removedBy = removedOn && bot.user.id;
-            const removeReason = removedOn && `Automatic or unknown, occurred before ${new Date()}`;
-            return [ id, modid, guildid, reason, duration, removedOn, removedBy, removeReason ];
-        });
-        await db.promise().query('DROP TABLE IF EXISTS `temp_mutes`');
-        await db.promise().query('CREATE TABLE `temp_mutes` ( \
-            `id` varchar(32) NOT NULL, \
-            `modid` varchar(32) NOT NULL, \
-            `guildid` varchar(32) NOT NULL, \
-            `reason` varchar(1024) NOT NULL, \
-            `appliedOn` int NOT NULL DEFAULT (unix_timestamp()), \
-            `duration` int NOT NULL, \
-            `removedOn` int DEFAULT NULL, \
-            `removedBy` varchar(32) DEFAULT NULL, \
-            `removeReason` varchar(1024) DEFAULT NULL \
-          )');
-
-        await db.promise().query('INSERT INTO temp_mutes (id, modid, guildid, reason, duration, removedOn, removedBy, removeReason) VALUES ?', [newRows]);
-        await db.promise().query('RENAME TABLE mutes TO mutes_backup');
-        await db.promise().query('RENAME TABLE temp_mutes TO mutes');
-
-        const [final] = await db.promise().query('SELECT * FROM mutes');
-        const embed = new Discord.EmbedBuilder()
-            .setTitle('Mute Table Conversion')
-            .setDescription('Converted mutes table to new schema.\nIf issues arise, the \`mutes\` table has been backed up as \`mutes_backup\`')
-            .setColor(Discord.Colors.Green)
-            .setTimestamp()
-            .setFooter({ text: message.member.displayName, iconURL: message.member.displayAvatarURL() });
-
-        embed.addFields({ 
-            name: 'Mutes', 
-            value: final.filter(r => !r.removedOn)
-                .map(r => { r.guild = bot.guilds.cache.get(r.guildid); return r })
-                .map(r => `<@${r.id}> by <@${r.modid}> in ${r.guild?.name || `Unknown Guild ${r.guildid}`} ` + (r.duration ? `ending <t:${r.appliedOn + r.duration}:R>` : 'Permanently'))
-                .join('\n')
-        })
-        message.reply({ embeds: [embed] });
+        message.reply('This is a test 1 2 3 one two three I II III')
     }
 }

From 2e663f981c959b132bfa971c03d7c5b194280726 Mon Sep 17 00:00:00 2001
From: husky-rotmg <70654625+husky-rotmg@users.noreply.github.com>
Date: Sun, 18 Feb 2024 23:21:54 -0500
Subject: [PATCH 6/9] Remove legacy options extensions

Not doing legacy options extending in this PR.
---
 commands/mute.js |  6 ++----
 utils.js         | 56 ++++--------------------------------------------
 2 files changed, 6 insertions(+), 56 deletions(-)

diff --git a/commands/mute.js b/commands/mute.js
index 3a80f19d..5ac0994e 100644
--- a/commands/mute.js
+++ b/commands/mute.js
@@ -119,8 +119,7 @@ module.exports = {
                     description: 'The type of duration for the mute'
                 }),
                 slashArg(SlashArgType.String, 'reason', {
-                    description: 'The reason for the permanent mute',
-                    varargs: true
+                    description: 'The reason for the permanent mute'
                 })
             ]
         }),
@@ -131,8 +130,7 @@ module.exports = {
                     description: 'Server member to mute'
                 }),
                 slashArg(SlashArgType.String, 'reason', {
-                    description: 'The reason for the permanent mute',
-                    varargs: true
+                    description: 'The reason for the permanent mute'
                 })
             ]
         }),
diff --git a/utils.js b/utils.js
index b30ecd60..9bd59407 100644
--- a/utils.js
+++ b/utils.js
@@ -23,11 +23,10 @@ class LegacyCommandOptions {
     #opts;
     #users = [];
     #attachments;
-    #settings;
+
     constructor(opts, message, varargs) {
         this.#opts = opts;
         this.#message = message;
-        this.#settings = message.client.settings[message.guild.id];
         this.#attachments = message.attachments.map((v) => v);
         const s = message.content;
         const [, ...args] = s.slice(1).split(/ +/gi);
@@ -36,7 +35,7 @@ class LegacyCommandOptions {
             const currentOpt = optsToParse.shift();
             if (currentOpt.required && (currentOpt.type == SlashArgType.Attachment ? this.#attachments.length == 0 : args.length == 0)) throw new LegacyParserError(`Not enough arguments. Expected: ${argString(opts)}`);
             if (args.length == 0) break;
-            const currentArg = currentOpt.varargs ? args.splice(0).join(' ') : args.shift();
+            const currentArg = args.shift();
             if (currentOpt.type == SlashArgType.Subcommand) {
                 // Grab all the subcommand options
                 const possibleSubcommands = [currentOpt];
@@ -48,12 +47,7 @@ class LegacyCommandOptions {
                 this.subcommand = subcommand.name;
                 subcommand.options.forEach((opt) => {
                     if (args.length == 0 && opt.required) throw new LegacyParserError(`Not enough arguments for subcommand \`${subcommand.name}\`. Expected: ${argString(opts)}`);
-                    if (opt.varargs) {
-                        const v = this.#processType(opt.type, args.splice(0).join(' '));
-                        if (!v) throw new LegacyParserError(`Error parsing argument \`${opt.name}\``);
-                        this.args[opt.name] = v;
-                    }
-                    if (args.length) {
+                    if (args.length != 0) {
                         const v = this.#processType(opt.type, args.shift());
                         if (!v) throw new LegacyParserError(`Error parsing argument \`${opt.name}\``);
                         this.args[opt.name] = v;
@@ -82,56 +76,26 @@ class LegacyCommandOptions {
         };
     }
 
-    /**
-     * @returns {string[]}
-     */
     getVarargs() {
         return this.args.varargs || [];
     }
 
-    /**
-     * @param {string} k
-     * @returns {string}
-     */
     getString(k) {
         if (this.#optTypeMatch(SlashArgType.String, k)) return this.args[k];
     }
 
-    /**
-     * @param {string} k
-     * @returns {import('discord.js').GuildMember}
-     */
     getMember(k) {
         if (this.#optTypeMatch(SlashArgType.User, k)) return this.args[k];
     }
 
-    /**
-     * @param {string} k
-     * @returns {number}
-     */
     getInteger(k) {
         if (this.#optTypeMatch(SlashArgType.Integer, k)) return this.args[k];
     }
 
-    /**
-     * @param {string} k
-     * @returns {import('discord.js').Attachment}
-     */
     getAttachment(k) {
         if (this.#optTypeMatch(SlashArgType.Attachment, k)) return this.args[k];
     }
 
-    /**
-     * @param {string} k
-     * @returns {import('discord.js').Role | import('discord.js').BaseChannel | import('discord.js').GuildMember}
-     */
-    getMentionable(k) {
-        if (this.#optTypeMatch(SlashArgType.Mentionable, k)) return this.args[k];
-    }
-
-    /**
-     * @returns {string}
-     */
     getSubcommand() {
         return this.subcommand;
     }
@@ -149,26 +113,14 @@ class LegacyCommandOptions {
                 this.#users.push(member);
                 return member;
             }
-            case SlashArgType.Boolean: {
-                value = value.toLowerCase();
-                if (['f', 'false', 'no', 'n', '0'].includes(value)) return false;
-                if (['t', 'true', '1', 'yes', 'y'].includes(value)) return true;
-                throw new LegacyParserError(`\`${value}\` is not a valid value, try either \`true\` or \`false\`.`);
-            }
             case SlashArgType.String: return value;
             case SlashArgType.Integer: return parseInt(value);
             case SlashArgType.Attachment: return this.#attachments.shift();
-            case SlashArgType.Number: return parseFloat(value);
-            case SlashArgType.Role: return Object.keys(this.#settings.roles).includes(value) ? this.#message.guild.roles.cache.get(this.#settings.roles[value]) : this.#message.guild.roles.cache.get(value.replace(/\D/g, ''));
-            case SlashArgType.Channel: return Object.keys(this.#settings.channels).includes(value) ? this.#message.guild.channels.cache.get(this.#settings.channels[value]) : this.#message.guild.channels.cache.get(value.replace(/\D/g, ''));
-            case SlashArgType.Mentionable: return this.#processType(SlashArgType.Role, value) ?? this.#processType(SlashArgType.Channel, value) ?? this.#message.guild.findMember(value);
             default: throw new Error('Unhandled type');
         }
     }
 }
-/**
- * @typedef {import('discord.js').Message & { options: LegacyCommandOptions } | import('discord.js').CommandInteraction} BotCommandInteraction
- */
+
 module.exports = {
     slashArg(type, name, opts) {
         const obj = {

From d21c656ebc5c3bf079b3e5390dcb81073987aee5 Mon Sep 17 00:00:00 2001
From: husky-rotmg <70654625+husky-rotmg@users.noreply.github.com>
Date: Sun, 18 Feb 2024 23:28:42 -0500
Subject: [PATCH 7/9] Update unmute.js

---
 commands/unmute.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/commands/unmute.js b/commands/unmute.js
index f8eb5c6f..f2c1cb77 100644
--- a/commands/unmute.js
+++ b/commands/unmute.js
@@ -20,14 +20,14 @@ module.exports = {
     name: 'unmute',
     description: 'Removes muted role from user',
     role: 'security',
+    varargs: true,
     args: [
         slashArg(ApplicationCommandOptionType.User, 'member', {
             description: 'Member in the Server'
         }),
         slashArg(ApplicationCommandOptionType.String, 'reason', {
             description: 'Reason for the unmute',
-            required: false,
-            varargs: true
+            required: false
         })
     ],
     getSlashCommandData(guild) {
@@ -44,7 +44,7 @@ module.exports = {
     async execute(interaction, args, bot, db) {
         const settings = bot.settings[interaction.guild.id];
         const member = interaction.options.getMember('member');
-        const reason = interaction.options.getString('reason') || 'No reason provided';
+        const reason = [interaction.options.getString('reason'), ...interaction.options.getVarargs()].join(' ') || 'No reason provided';
 
         const [[row]] = await db.promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [member.id, member.guild.id]);
 

From 094094eeae919eddef6882fb562550b4aaf27b4a Mon Sep 17 00:00:00 2001
From: husky-rotmg <70654625+husky-rotmg@users.noreply.github.com>
Date: Mon, 19 Feb 2024 03:14:19 -0500
Subject: [PATCH 8/9] rolePemissions, pretty embed

- If settings.rolePermissions.removePermanentMute is defined, deny if lower role
- Slight unmute embed formatting
- mute reason default to `No reason provided` instead of empty string
---
 commands/mute.js   |  2 +-
 commands/unmute.js | 29 ++++++++++++++++-------------
 2 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/commands/mute.js b/commands/mute.js
index 5ac0994e..1cfd6bdd 100644
--- a/commands/mute.js
+++ b/commands/mute.js
@@ -260,7 +260,7 @@ module.exports = {
         }
 
         const duration = isNaN(timeValue) ? 0 : processDuration(args.shift(), parseInt(timeValue));
-        const reason = args.join(' ');
+        const reason = args.join(' ') || 'No reason provided';
 
         await this.processExecute(message, settings, db, member, reason, duration);
     }
diff --git a/commands/unmute.js b/commands/unmute.js
index f2c1cb77..7515beca 100644
--- a/commands/unmute.js
+++ b/commands/unmute.js
@@ -47,18 +47,21 @@ module.exports = {
         const reason = [interaction.options.getString('reason'), ...interaction.options.getVarargs()].join(' ') || 'No reason provided';
 
         const [[row]] = await db.promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [member.id, member.guild.id]);
-
+        const embed = new EmbedBuilder()
+            .setFooter({ text: `Ran by ${interaction.member.displayName}`, iconURL: interaction.member.displayAvatarURL() })
+            .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+            .setTitle('Unmute')
+            .setTimestamp()
+            .setColor(Colors.Red);
         if (!row && !member.roles.cache.has(settings.roles.muted)) {
-            const embed = new EmbedBuilder()
-                .setFooter({ text: `Ran by ${interaction.member.displayName}`, iconURL: interaction.member.displayAvatarURL() })
-                .setDescription(`${member} does not have the muted role and doesn't have any active mutes with ${interaction.client.user}.`)
-                .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
-                .setTitle('Unmute')
-                .setTimestamp()
-                .setColor(Colors.Red);
+            embed.setDescription(`${member} does not have the muted role and doesn't have any active mutes with ${interaction.client.user}.`);
+            return await interaction.reply({ embeds: [embed] });
+        }
+        const rpmrole = member.guild.roles.cache.get(settings.roles[settings.rolePermissions.removePermanentMute]);
+        if (rpmrole && member.roles.highest.position < rpmrole.position) {
+            embed.setDescription(`You must have ${rpmrole} or higher to remove a permanent mute.`);
             return await interaction.reply({ embeds: [embed] });
         }
-
         await this.unmute(interaction, interaction.guild, interaction.member, member, settings, db, row, reason);
     },
 
@@ -79,8 +82,8 @@ module.exports = {
             .setTitle('Unmute')
             .setTimestamp()
             .setFooter({ text: `Ran by ${moderator.displayName}`, iconURL: moderator.displayAvatarURL() })
-            .addFields({ name: 'Member', value: member ? `${member} \`${member.displayName}\`` : `<@!${row.id}> (not in server)`, inline: true },
-                { name: 'Moderator', value: `${moderator} \`${moderator.displayName}\``, inline: true },
+            .addFields({ name: 'Member', value: member ? `${member}\n\`${member.displayName}\`` : `<@!${row.id}> (not in server)`, inline: true },
+                { name: 'Moderator', value: `${moderator}\n\`${moderator.displayName}\``, inline: true },
                 { name: 'Unmute Time', value: `<t:${Date.unix()}:f>`, inline: true },
                 { name: 'Unmute Reason', value: reason });
 
@@ -89,8 +92,8 @@ module.exports = {
                 [moderator.id, reason, row.id, guild.id]);
 
             const mod = guild.members.cache.get(row.modid);
-            embed.addFields({ name: 'Muted By', value: mod ? `${mod} \`${mod.displayName}\`` : `<@!${row.modid}>`, inline: true },
-                { name: 'Muted On', value: `<t:${row.appliedOn}:R> at <t:${row.appliedOn}:f>`, inline: true },
+            embed.addFields({ name: 'Muted By', value: mod ? `${mod}\n\`${mod.displayName}\`` : `<@!${row.modid}>`, inline: true },
+                { name: 'Muted On', value: `<t:${row.appliedOn}:R>\n<t:${row.appliedOn}:f>`, inline: true },
                 { name: 'Mute Duration', value: durationString(row.duration, row.appliedOn), inline: true },
                 { name: 'Mute Reason', value: row.reason });
         } else {

From 573d29ae04cd9f26cc1c272ead3a005ec33f4518 Mon Sep 17 00:00:00 2001
From: husky-rotmg <70654625+husky-rotmg@users.noreply.github.com>
Date: Mon, 19 Feb 2024 11:51:36 -0500
Subject: [PATCH 9/9] Fix footer

set to moderator name + icon to help clarity (images are always nice)
---
 commands/mute.js   | 6 +++---
 commands/unmute.js | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/commands/mute.js b/commands/mute.js
index 1cfd6bdd..18e0008c 100644
--- a/commands/mute.js
+++ b/commands/mute.js
@@ -156,7 +156,7 @@ module.exports = {
             .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
             .setTitle('Mute Information')
             .setDescription(`The mute is ${duration ? 'for ' + moment.duration(duration * 1000).humanize(false) : 'permanent'}`)
-            .setFooter({ text: duration ? 'Unmuting at' : 'Permanent' })
+            .setFooter({ text: moderator.displayName, iconURL: moderator.displayAvatarURL() })
             .setColor(Colors.Green)
             .setTimestamp(endTime)
             .addFields({ name: 'Member', value: `${member} \`${member.displayName}\``, inline: true },
@@ -194,7 +194,7 @@ module.exports = {
             .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
             .setColor(Colors.Blue)
             .setTimestamp()
-            .setFooter({ text: `Ran by ${interaction.member.displayName}` })
+            .setFooter({ text: `${interaction.member.displayName}`, iconURL: interaction.member.displayAvatarURL() })
             .setTitle('Processing Mute')
             .setDescription('Please wait...');
 
@@ -248,7 +248,7 @@ module.exports = {
         const embed = new EmbedBuilder()
             .setColor(Colors.Red)
             .setTimestamp()
-            .setFooter({ text: `Ran by ${message.member.displayName}` })
+            .setFooter({ text: `${message.member.displayName}`, iconURL: message.member.displayAvatarURL() })
             .setTitle('Invalid Arguments');
         const search = args.shift();
         const member = message.guild.findMember(search);
diff --git a/commands/unmute.js b/commands/unmute.js
index 7515beca..a2d2c4a1 100644
--- a/commands/unmute.js
+++ b/commands/unmute.js
@@ -48,7 +48,7 @@ module.exports = {
 
         const [[row]] = await db.promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [member.id, member.guild.id]);
         const embed = new EmbedBuilder()
-            .setFooter({ text: `Ran by ${interaction.member.displayName}`, iconURL: interaction.member.displayAvatarURL() })
+            .setFooter({ text: `${interaction.member.displayName}`, iconURL: interaction.member.displayAvatarURL() })
             .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
             .setTitle('Unmute')
             .setTimestamp()
@@ -81,7 +81,7 @@ module.exports = {
             .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
             .setTitle('Unmute')
             .setTimestamp()
-            .setFooter({ text: `Ran by ${moderator.displayName}`, iconURL: moderator.displayAvatarURL() })
+            .setFooter({ text: `${moderator.displayName}`, iconURL: moderator.displayAvatarURL() })
             .addFields({ name: 'Member', value: member ? `${member}\n\`${member.displayName}\`` : `<@!${row.id}> (not in server)`, inline: true },
                 { name: 'Moderator', value: `${moderator}\n\`${moderator.displayName}\``, inline: true },
                 { name: 'Unmute Time', value: `<t:${Date.unix()}:f>`, inline: true },