diff options
Diffstat (limited to 'src')
38 files changed, 1772 insertions, 111 deletions
diff --git a/src/commands/config/autoPublishChannel.ts b/src/commands/config/autoPublishChannel.ts new file mode 100644 index 0000000..421e030 --- /dev/null +++ b/src/commands/config/autoPublishChannel.ts @@ -0,0 +1,53 @@ +import { BushCommand, BushMessage } from '@lib'; +import { Channel } from 'discord.js'; + +export default class AutoPublishChannelCommand extends BushCommand { + public constructor() { + super('autopublishchannel', { + aliases: ['autopublishchannel', 'apc', 'publishchannel', 'autopublishchannels', 'publishchannels', 'autopublish'], + category: 'config', + description: { + content: 'A command to add/remove channels from being automatically published.', + usage: 'autopublishchannel <channel>', + examples: ['autopublishchannel #github'] + }, + args: [ + { + id: 'channel', + type: 'channel', + match: 'content', + prompt: { + start: 'What channel would you like to toggle auto publishing in?', + retry: '{error} Choose a valid channel.', + optional: false + } + } + ], + slash: true, + slashOptions: [ + { + name: 'channel', + description: 'What channel would you like me to send welcome messages in?', + type: 'CHANNEL', + required: false + } + ], + channel: 'guild', + clientPermissions: ['SEND_MESSAGES'], + userPermissions: ['MANAGE_GUILD', 'SEND_MESSAGES'] + }); + } + + public async exec(message: BushMessage, { channel }: { channel: Channel }): Promise<unknown> { + const autoPublishChannels = await message.guild.getSetting('autoPublishChannels'); + autoPublishChannels.includes(channel.id) + ? autoPublishChannels.splice(autoPublishChannels.indexOf(channel.id), 1) + : autoPublishChannels.push(channel.id); + await message.guild.setSetting('autoPublishChannels', autoPublishChannels); + return await message.util.reply( + `${this.client.util.emojis.success} Successfully ${ + autoPublishChannels.includes(channel.id) ? 'disabled' : 'enabled' + } auto publishing in <#${channel.id}>.` + ); + } +} diff --git a/src/commands/config/muteRole.ts b/src/commands/config/muteRole.ts index 1bec4a9..9074a1d 100644 --- a/src/commands/config/muteRole.ts +++ b/src/commands/config/muteRole.ts @@ -11,8 +11,6 @@ export default class MuteRoleCommand extends BushCommand { usage: 'muterole <role>', examples: ['muterole 748912426581229690'] }, - clientPermissions: ['SEND_MESSAGES'], - userPermissions: ['SEND_MESSAGES', 'MANAGE_GUILD'], args: [ { id: 'role', @@ -32,7 +30,10 @@ export default class MuteRoleCommand extends BushCommand { type: 'ROLE', required: true } - ] + ], + channel: 'guild', + clientPermissions: ['SEND_MESSAGES'], + userPermissions: ['SEND_MESSAGES', 'MANAGE_GUILD'] }); } diff --git a/src/commands/config/prefix.ts b/src/commands/config/prefix.ts index 4624e99..79956be 100644 --- a/src/commands/config/prefix.ts +++ b/src/commands/config/prefix.ts @@ -10,8 +10,6 @@ export default class PrefixCommand extends BushCommand { usage: 'prefix [prefix]', examples: ['prefix', 'prefix -'] }, - clientPermissions: ['SEND_MESSAGES'], - userPermissions: ['SEND_MESSAGES', 'MANAGE_GUILD'], args: [ { id: 'prefix', @@ -31,7 +29,10 @@ export default class PrefixCommand extends BushCommand { type: 'STRING', required: false } - ] + ], + channel: 'guild', + clientPermissions: ['SEND_MESSAGES'], + userPermissions: ['SEND_MESSAGES', 'MANAGE_GUILD'] }); } diff --git a/src/commands/config/punishmentFooter.ts b/src/commands/config/punishmentFooter.ts index 3a246df..6b2759a 100644 --- a/src/commands/config/punishmentFooter.ts +++ b/src/commands/config/punishmentFooter.ts @@ -11,8 +11,6 @@ export default class PunishmentFooterCommand extends BushCommand { usage: 'punishmentfooter [message]', examples: ['punishmentfooter', 'prefix you can appeal at https://example.com.'] }, - clientPermissions: ['SEND_MESSAGES'], - userPermissions: ['SEND_MESSAGES', 'MANAGE_GUILD'], args: [ { id: 'ending', @@ -33,7 +31,10 @@ export default class PunishmentFooterCommand extends BushCommand { type: 'STRING', required: false } - ] + ], + channel: 'guild', + clientPermissions: ['SEND_MESSAGES'], + userPermissions: ['SEND_MESSAGES', 'MANAGE_GUILD'] }); } diff --git a/src/commands/config/welcomeChannel.ts b/src/commands/config/welcomeChannel.ts index 71d59f8..488a0a9 100644 --- a/src/commands/config/welcomeChannel.ts +++ b/src/commands/config/welcomeChannel.ts @@ -11,8 +11,6 @@ export default class WelcomeChannelCommand extends BushCommand { usage: 'welcomechannel [channel]', examples: ['welcomechannel #welcome'] }, - clientPermissions: ['SEND_MESSAGES'], - userPermissions: ['SEND_MESSAGES', 'MANAGE_GUILD'], args: [ { id: 'channel', @@ -32,7 +30,10 @@ export default class WelcomeChannelCommand extends BushCommand { type: 'CHANNEL', required: false } - ] + ], + channel: 'guild', + clientPermissions: ['SEND_MESSAGES'], + userPermissions: ['SEND_MESSAGES', 'MANAGE_GUILD'] }); } public async exec(message: BushMessage | BushSlashMessage, args: { channel: Channel }): Promise<unknown> { diff --git a/src/commands/dev/_testDuration.ts b/src/commands/dev/_testDuration.ts new file mode 100644 index 0000000..3ad9aff --- /dev/null +++ b/src/commands/dev/_testDuration.ts @@ -0,0 +1,53 @@ +// import { BushCommand, BushSlashMessage } from '@lib'; +// import { stripIndents } from 'common-tags'; +// import { Message } from 'discord.js'; + +// export default class TestDurationCommand extends BushCommand { +// public constructor() { +// super('testduration', { +// aliases: ['testduration'], +// category: 'dev', +// description: { +// content: 'Tests duration parsing.', +// usage: 'testduration [reason]', +// examples: ['testduration'] +// }, +// args: [ +// { +// id: 'reason', +// type: 'contentWithDuration', +// match: 'rest', +// prompt: { +// start: 'Enter text and a duration here.', +// retry: '{error} Error parsing duration and text.', +// optional: true +// } +// } +// ], +// slash: true, +// slashOptions: [ +// { +// name: 'reason', +// description: 'Enter text and a duration here.', +// type: 'STRING', +// required: false +// } +// ], +// hidden: true, +// ownerOnly: true +// }); +// } + +// async exec( +// message: Message | BushSlashMessage, +// { reason }: { reason?: { duration: number; contentWithoutTime: string } } +// ): Promise<unknown> { +// const rawDuration = reason.duration; +// const text = reason.contentWithoutTime; +// const humanizedDuration = this.client.util.humanizeDuration(rawDuration); +// return await message.util.reply(stripIndents` +// **rawDuration:** ${rawDuration} +// **text:** ${text} +// **humanizedDuration:** ${humanizedDuration}`); +// } +// } diff --git a/src/commands/dev/say.ts b/src/commands/dev/say.ts new file mode 100644 index 0000000..9dc2632 --- /dev/null +++ b/src/commands/dev/say.ts @@ -0,0 +1,58 @@ +import { AllowedMentions, BushCommand, BushMessage } from '@lib'; +import { AkairoMessage } from 'discord-akairo'; + +export default class SayCommand extends BushCommand { + public constructor() { + super('say', { + aliases: ['say'], + category: 'dev', + description: { + content: 'A command make the bot say something.', + usage: 'say <message>', + examples: ['say hello'] + }, + args: [ + { + id: 'say', + type: 'string', + match: 'rest', + prompt: { + start: 'What would you like the bot to say?', + retry: '{error} Choose something valid to say.' + } + } + ], + slashOptions: [ + { + name: 'content', + description: 'What would you like the bot to say?', + type: 'STRING' + } + ], + ownerOnly: true, + clientPermissions: ['SEND_MESSAGES'], + slash: true + }); + } + + public async exec(message: BushMessage, { say }: { say: string }): Promise<unknown> { + if (!message.author.isOwner()) + return await message.util.reply(`${this.client.util.emojis.error} Only my developers can run this command.`); + + if (message.deletable) { + await message.delete(); + } + await message.util.send({ content: say, allowedMentions: AllowedMentions.none() }); + } + + public async execSlash(message: AkairoMessage, { content }: { content: string }): Promise<unknown> { + if (!this.client.config.owners.includes(message.author.id)) { + return await message.interaction.reply({ + content: `${this.client.util.emojis.error} Only my developers can run this command.`, + ephemeral: true + }); + } + await message.interaction.reply({ content: 'Attempting to send message.', ephemeral: true }); + return message.channel.send({ content, allowedMentions: AllowedMentions.none() }); + } +} diff --git a/src/commands/dev/setLevel.ts b/src/commands/dev/setLevel.ts index db0cfab..f2ae6c7 100644 --- a/src/commands/dev/setLevel.ts +++ b/src/commands/dev/setLevel.ts @@ -29,21 +29,21 @@ export default class SetLevelCommand extends BushCommand { } } ], - ownerOnly: true, slashOptions: [ { name: 'user', - description: 'The user to change the level of', + description: 'What user would you like to change the level of?', type: 'USER', required: true }, { name: 'level', - description: 'The level to set the user to', + description: 'What level would you like to set the user to?', type: 'INTEGER', required: true } ], + ownerOnly: true, slash: true }); } diff --git a/src/commands/dev/testDuration.ts b/src/commands/dev/testDuration.ts deleted file mode 100644 index 2d636d2..0000000 --- a/src/commands/dev/testDuration.ts +++ /dev/null @@ -1,53 +0,0 @@ -import { BushCommand, BushSlashMessage } from '@lib'; -import { stripIndents } from 'common-tags'; -import { Message } from 'discord.js'; - -export default class TestDurationCommand extends BushCommand { - public constructor() { - super('testduration', { - aliases: ['testduration'], - category: 'dev', - description: { - content: 'Tests duration parsing.', - usage: 'testduration [reason]', - examples: ['testduration'] - }, - args: [ - { - id: 'reason', - type: 'contentWithDuration', - match: 'rest', - prompt: { - start: 'Enter text and a duration here.', - retry: '{error} Error parsing duration and text.', - optional: true - } - } - ], - slash: true, - slashOptions: [ - { - name: 'reason', - description: 'Enter text and a duration here.', - type: 'STRING', - required: false - } - ], - hidden: true, - ownerOnly: true - }); - } - - async exec( - message: Message | BushSlashMessage, - { reason }: { reason?: { duration: number; contentWithoutTime: string } } - ): Promise<unknown> { - const rawDuration = reason.duration; - const text = reason.contentWithoutTime; - const humanizedDuration = this.client.util.humanizeDuration(rawDuration); - return await message.util.reply(stripIndents` - **rawDuration:** ${rawDuration} - **text:** ${text} - **humanizedDuration:** ${humanizedDuration}`); - } -} diff --git a/src/commands/fun/coinflip.ts b/src/commands/fun/coinflip.ts new file mode 100644 index 0000000..68484bb --- /dev/null +++ b/src/commands/fun/coinflip.ts @@ -0,0 +1,26 @@ +import { BushCommand, BushMessage, BushSlashMessage } from '@lib'; + +export default class CoinFlipCommand extends BushCommand { + public constructor() { + super('coinflip', { + aliases: ['coinflip', 'cf'], + category: 'fun', + description: { + content: 'Flip a virtual coin.', + usage: 'coinflip', + examples: ['coinflip'] + }, + clientPermissions: ['SEND_MESSAGES'] + }); + } + + public async exec(message: BushMessage | BushSlashMessage): Promise<void> { + const random = Math.random(); + let result: string; + const fall = message.author.id === '322862723090219008' ? 0.1 : 0.001; + if (random < fall) result = 'The coin fell off the table :('; + else if (random <= 0.5 + fall / 2) result = 'Heads'; + else result = 'Tails'; + await message.util.reply(result); + } +} diff --git a/src/commands/fun/dice.ts b/src/commands/fun/dice.ts new file mode 100644 index 0000000..46b159b --- /dev/null +++ b/src/commands/fun/dice.ts @@ -0,0 +1,23 @@ +import { BushCommand, BushMessage, BushSlashMessage } from '@lib'; + +export default class EightBallCommand extends BushCommand { + public constructor() { + super('dice', { + aliases: ['dice', 'die'], + category: 'fun', + description: { + content: 'Roll virtual dice.', + usage: 'dice', + examples: ['dice'] + }, + clientPermissions: ['SEND_MESSAGES'], + slash: true + }); + } + + public async exec(message: BushMessage | BushSlashMessage): Promise<unknown> { + const responses = ['1', '2', '3', '4', '5', '6']; + const answer = responses[Math.floor(Math.random() * responses.length)]; + return await message.util.reply(`You rolled a **${answer}**.`); + } +} diff --git a/src/commands/fun/eightBall.ts b/src/commands/fun/eightBall.ts new file mode 100644 index 0000000..7b7d39c --- /dev/null +++ b/src/commands/fun/eightBall.ts @@ -0,0 +1,64 @@ +import { BushCommand, BushMessage, BushSlashMessage } from '../../lib'; + +export default class EightBallCommand extends BushCommand { + public constructor() { + super('eightBall', { + aliases: ['8ball', 'eightball'], + category: 'fun', + description: { + content: 'Ask questions for a randomly generated response.', + usage: '8Ball <question>', + examples: ['8Ball does anyone love me?'] + }, + args: [ + { + id: 'question', + type: 'string', + match: 'rest', + prompt: { + start: 'What question would you like answered?', + retry: '{error} Invalid question.' + } + } + ], + slash: true, + slashOptions: [ + { + name: 'question', + description: 'What question would you like answered?', + type: 'STRING', + required: true + } + ], + clientPermissions: ['SEND_MESSAGES'], + userPermissions: ['SEND_MESSAGES'] + }); + } + + public async exec(message: BushMessage | BushSlashMessage): Promise<void> { + const responses = [ + 'It is certain', + 'Without a doubt', + 'You may rely on it', + 'Yes definitely', + 'It is decidedly so', + 'As I see it, yes', + 'Most likely', + 'Yes', + 'Outlook good', + 'Signs point to yes', + 'Reply hazy try again', + 'Better not tell you now', + 'Ask again later', + 'Cannot predict now', + 'Concentrate and ask again', + "Don't count on it", + 'Outlook not so good', + 'My sources say no', + 'Very doubtful', + 'My reply is no' + ]; + const answer = responses[Math.floor(Math.random() * responses.length)]; + await message.util.reply(answer); + } +} diff --git a/src/commands/fun/minesweeper.ts b/src/commands/fun/minesweeper.ts new file mode 100644 index 0000000..2b46e34 --- /dev/null +++ b/src/commands/fun/minesweeper.ts @@ -0,0 +1,123 @@ +import { BushCommand, BushMessage, BushSlashMessage } from '@lib'; +import Minesweeper from 'discord.js-minesweeper'; + +export default class MinesweeperCommand extends BushCommand { + public constructor() { + super('minesweeper', { + aliases: ['minesweeper'], + category: 'fun', + description: { + content: 'minesweeper command.', + usage: 'minesweeper <rows> <columns> <mines> [--spaces] [--revealFirstCell]', + examples: ['minesweeper 10 10 2'] + }, + args: [ + { + id: 'rows', + type: 'integer', + prompt: { + start: 'How many rows would you like?', + retry: '{error} Choose a valid number of rows', + optional: true + }, + default: 9 + }, + { + id: 'columns', + type: 'integer', + prompt: { + start: 'How many columns would you like?', + retry: '{error} Choose a valid number of columns', + optional: true + }, + default: 9 + }, + { + id: 'mines', + type: 'integer', + prompt: { + start: 'How many mines would you like?', + retry: '{error} Choose a valid number of mines', + optional: true + }, + default: 10 + }, + { + id: 'spaces', + match: 'flag', + flag: '--spaces' + }, + { + id: 'reveal_first_cell', + match: 'flag', + flag: '--revealFirstCell' + } + ], + slash: true, + slashOptions: [ + { + name: 'rows', + description: 'How many rows would you like?', + type: 'INTEGER', + required: false + }, + { + name: 'columns', + description: 'How many rows would you like?', + type: 'INTEGER', + required: false + }, + { + name: 'mines', + description: 'How many rows would you like?', + type: 'INTEGER', + required: false + }, + { + name: 'spaces', + description: 'Would you like there to be spaces?', + type: 'BOOLEAN', + required: false + }, + { + name: 'reveal_first_cell', + description: 'Would you like to automatically reveal the first cell?', + type: 'BOOLEAN', + required: false + } + ], + clientPermissions: ['SEND_MESSAGES'], + userPermissions: ['SEND_MESSAGES'] + }); + } + + public async exec( + message: BushMessage | BushSlashMessage, + { + rows, + columns, + mines, + spaces, + reveal_first_cell + }: { + rows: number; + columns: number; + mines: number; + spaces: boolean; + reveal_first_cell: boolean; + } + ): Promise<unknown> { + const minesweeper = new Minesweeper({ + rows: rows ?? 9, + columns: columns ?? 9, + mines: mines ?? 10, + emote: 'boom', + revealFirstCell: reveal_first_cell ?? false, + zeroFirstCell: true, + spaces: spaces ?? false, + returnType: 'emoji' + }); + const matrix = minesweeper.start(); + return await message.util.reply(matrix.toString()); + } +} diff --git a/src/commands/info/avatar.ts b/src/commands/info/avatar.ts new file mode 100644 index 0000000..3d1776f --- /dev/null +++ b/src/commands/info/avatar.ts @@ -0,0 +1,51 @@ +import { Constants } from 'discord-akairo'; +import { MessageEmbed, User } from 'discord.js'; +import { BushCommand, BushMessage, BushSlashMessage } from '../../lib'; + +export default class AvatarCommand extends BushCommand { + constructor() { + super('avatar', { + aliases: ['avatar', 'av'], + category: 'info', + description: { + content: "A command to get a user's avatar", + usage: 'avatar [user]', + examples: 'avatar' + }, + args: [ + { + id: 'user', + type: Constants.ArgumentTypes.USER, + match: Constants.ArgumentMatches.PHRASE, + prompt: { + start: 'Who would you like to see the avatar of?', + retry: '{error} Choose a valid user.', + optional: true + } + } + ], + clientPermissions: ['SEND_MESSAGES', 'EMBED_LINKS'], + slash: true, + slashOptions: [ + { + name: 'user', + description: 'The user you would like to find the avatar of.', + type: 'USER', + required: false + } + ] + }); + } + + async exec(message: BushMessage | BushSlashMessage, { user }: { user: User }): Promise<void> { + user = user ?? message.author; + + const embed = new MessageEmbed() + .setTimestamp() + .setColor(this.client.util.colors.default) + .setTitle(user.tag) + .setImage(user.avatarURL({ size: 2048, format: 'png', dynamic: true })); + + await message.util.reply({ embeds: [embed] }); + } +} diff --git a/src/commands/info/botInfo.ts b/src/commands/info/botInfo.ts index d5941b2..986bd01 100644 --- a/src/commands/info/botInfo.ts +++ b/src/commands/info/botInfo.ts @@ -4,7 +4,7 @@ import { MessageEmbed, version as discordJSVersion } from 'discord.js'; export default class BotInfoCommand extends BushCommand { public constructor() { super('botinfo', { - aliases: ['botinfo'], + aliases: ['botinfo', 'stats'], category: 'info', description: { content: 'Shows information about the bot', diff --git a/src/commands/info/color.ts b/src/commands/info/color.ts new file mode 100644 index 0000000..4db20e7 --- /dev/null +++ b/src/commands/info/color.ts @@ -0,0 +1,42 @@ +import { BushCommand, BushMessage, BushSlashMessage } from '@lib'; +import { Constants } from 'discord-akairo'; +import { ColorResolvable, MessageEmbed } from 'discord.js'; + +export default class ColorCommand extends BushCommand { + public constructor() { + super('color', { + aliases: ['color'], + category: 'info', + description: { + content: 'See what color a hex code is.', + usage: 'color <color>', + examples: ['color #0000FF'] + }, + args: [ + { + id: 'color', + type: /^#?(?<code>[0-9A-F]{6})$/i, + match: Constants.ArgumentMatches.PHRASE, + prompt: { + start: 'What color value would you like to see the color of', + retry: '{error} Choose a valid hex color code.' + } + } + ], + channel: 'guild', + clientPermissions: ['EMBED_LINKS', 'SEND_MESSAGES'] + }); + } + + public async exec( + message: BushMessage | BushSlashMessage, + { color: { match } }: { color: { match: RegExpMatchArray; matches: RegExpMatchArray[] } } + ): Promise<unknown> { + const embed = new MessageEmbed() + .addField('Hex', match.groups.code, false) + .addField('RGB', this.client.util.hexToRgb(match.groups.code), false) + .setColor(match.groups.code as ColorResolvable); + + return await message.util.reply({ embeds: [embed] }); + } +} diff --git a/src/commands/info/guildInfo.ts b/src/commands/info/guildInfo.ts new file mode 100644 index 0000000..a3e7405 --- /dev/null +++ b/src/commands/info/guildInfo.ts @@ -0,0 +1,171 @@ +import { Argument, Constants } from 'discord-akairo'; +import { Guild, GuildPreview, MessageEmbed, Snowflake, Vanity } from 'discord.js'; +import { BushCommand, BushMessage, BushSlashMessage } from '../../lib'; + +// TODO: Implement regions and security +export default class GuildInfoCommand extends BushCommand { + public constructor() { + super('guildInfo', { + aliases: ['guildinfo', 'serverinfo', 'guild', 'server', 'g'], + category: 'info', + description: { + content: 'Get info about a server.', + usage: 'guildinfo [guild]', + examples: ['guildinfo 516977525906341928'] + }, + args: [ + { + id: 'guild', + type: Argument.union(Constants.ArgumentTypes.GUILD, Constants.ArgumentTypes.BIGINT), + match: Constants.ArgumentMatches.PHRASE, + prompt: { + start: 'What server would you like to find information about?', + retry: '{error} Choose a valid server to find information about.', + optional: true + } + } + ], + slash: true, + slashOptions: [ + { + name: 'guild', + description: 'The id of the guild you would like to find information about.', + type: 'STRING', + required: false + } + ], + clientPermissions: ['EMBED_LINKS', 'SEND_MESSAGES'], + userPermissions: ['SEND_MESSAGES'] + }); + } + + public async exec(message: BushMessage | BushSlashMessage, args: { guild: Guild | bigint | GuildPreview }): Promise<unknown> { + if (!args?.guild && !message.guild) { + return await message.util.reply( + `${this.client.util.emojis.error} You must either provide an server to provide info about or run this command in a server.` + ); + } + let isPreview = false; + if (['bigint', 'number', 'string'].includes(typeof args?.guild)) { + const preview = await this.client.fetchGuildPreview(`${args.guild}` as Snowflake).catch(() => {}); + if (preview) { + args.guild = preview; + isPreview = true; + } else { + return await message.util.reply(`${this.client.util.emojis.error} That guild is not discoverable or does not exist.`); + } + } + const guild: Guild | GuildPreview = (args?.guild as Guild | GuildPreview) || (message.guild as Guild); + const emojis: string[] = []; + const guildAbout: string[] = []; + // const guildSecurity = []; + if (['516977525906341928', '784597260465995796', '717176538717749358', '767448775450820639'].includes(guild.id)) + emojis.push(this.client.consts.mappings.otherEmojis.BUSH_VERIFIED); + + if (!isPreview && guild instanceof Guild) { + if (guild.premiumTier) emojis.push(this.client.consts.mappings.otherEmojis['BOOST_' + guild.premiumTier]); + await guild.fetch(); + const channelTypes = [ + `${this.client.consts.mappings.otherEmojis.TEXT} ${guild.channels.cache + .filter((channel) => channel.type === 'GUILD_TEXT') + .size.toLocaleString()}`, + `${this.client.consts.mappings.otherEmojis.NEWS} ${guild.channels.cache + .filter((channel) => channel.type === 'GUILD_NEWS') + .size.toLocaleString()}`, + `${this.client.consts.mappings.otherEmojis.VOICE} ${guild.channels.cache + .filter((channel) => channel.type === 'GUILD_VOICE') + .size.toLocaleString()}`, + `${this.client.consts.mappings.otherEmojis.STAGE} ${guild.channels.cache + .filter((channel) => channel.type === 'GUILD_STAGE_VOICE') + .size.toLocaleString()}`, + `${this.client.consts.mappings.otherEmojis.STORE} ${guild.channels.cache + .filter((channel) => channel.type === 'GUILD_STORE') + .size.toLocaleString()}`, + `${this.client.consts.mappings.otherEmojis.CATEGORY} ${guild.channels.cache + .filter((channel) => channel.type === 'GUILD_CATEGORY') + .size.toLocaleString()}`, + `${this.client.consts.mappings.otherEmojis.THREAD} ${guild.channels.cache + .filter((channel) => + ['GUILD_NEWS_THREAD', 'GUILD_PUBLIC_THREAD', 'GUILD_PRIVATE_THREAD', 'GUILD_STAGE_VOICE'].includes(channel.type) + ) + .size.toLocaleString()}` + ]; + + // TODO add guild regions + // const guildRegions = []; + + guildAbout.push( + `**Owner:** ${guild.members.cache.get(guild.ownerId)?.user.tag}`, + `**Created** ${guild.createdAt.toLocaleString()}`, + `**Members:** ${guild.memberCount.toLocaleString()}`, + `**Online:** ${guild.approximatePresenceCount?.toLocaleString()}`, + `**Channels:** ${guild.channels.cache.size} (${channelTypes.join(', ')})`, + `**Emojis:** ${guild.emojis.cache.size.toLocaleString()}` + // `**Region:** ${guildRegions.join()}` + ); + if (guild.premiumSubscriptionCount) + guildAbout.push( + `**Boosts:** Level ${guild.premiumTier.slice(0, 4)} with ${guild.premiumSubscriptionCount ?? 0} boosts` + ); + if (guild.me?.permissions.has('MANAGE_GUILD') && guild.vanityURLCode) { + const vanityInfo: Vanity = await guild.fetchVanityData(); + guildAbout.push( + `**Vanity URL:** discord.gg/${vanityInfo.code}`, + `**Vanity Uses:** ${vanityInfo.uses?.toLocaleString()}` + ); + } + + // guildSecurity.push; + } else { + guildAbout.push( + `**Members:** ${guild.approximateMemberCount?.toLocaleString()}`, + `**Online:** ${guild.approximatePresenceCount?.toLocaleString()}`, + `**Emojis:** ${(guild as GuildPreview).emojis.size}` + ); + } + + const guildFeatures = guild.features.sort((a, b) => { + const aWeight = this.client.consts.mappings.features[a]?.weight; + const bWeight = this.client.consts.mappings.features[b]?.weight; + + if (aWeight != undefined && bWeight != undefined) { + return aWeight - bWeight; + } else if (aWeight == undefined) { + return 1; + } else if (bWeight == undefined) { + return -1; + } + }); + if (guildFeatures.length) { + guildFeatures.forEach((feature) => { + if (this.client.consts.mappings.features[feature]?.emoji) { + emojis.push(`${this.client.consts.mappings.features[feature].emoji}`); + } else if (this.client.consts.mappings.features[feature]?.name) { + emojis.push(`\`${this.client.consts.mappings.features[feature].name}\``); + } else { + emojis.push(`\`${feature}\``); + } + }); + } + + if (guild.description) { + emojis.push(`\n\n${guild.description}`); + } + + const guildInfoEmbed = new MessageEmbed() + .setTitle(guild.name) + .setColor(this.client.util.colors.default) + .addField('» About', guildAbout.join('\n')); + const guildIcon = guild.iconURL({ size: 2048, format: 'png', dynamic: true }); + if (guildIcon) { + guildInfoEmbed.setThumbnail(guildIcon); + } + // if (!isPreview) { + // guildInfoEmbed.addField('» Security', guildSecurity.join('\n')); + // } + if (emojis) { + guildInfoEmbed.setDescription(emojis.join(' ')); + } + return await message.util.reply({ embeds: [guildInfoEmbed] }); + } +} diff --git a/src/commands/info/help.ts b/src/commands/info/help.ts index e061453..0977c36 100644 --- a/src/commands/info/help.ts +++ b/src/commands/info/help.ts @@ -11,8 +11,6 @@ export default class HelpCommand extends BushCommand { usage: 'help [command]', examples: ['help prefix'] }, - clientPermissions: ['EMBED_LINKS'], - args: [ { id: 'command', @@ -38,7 +36,9 @@ export default class HelpCommand extends BushCommand { type: 'STRING', required: false } - ] + ], + clientPermissions: ['EMBED_LINKS', 'SEND_MESSAGES'], + userPermissions: ['SEND_MESSAGES'] }); } diff --git a/src/commands/info/icon.ts b/src/commands/info/icon.ts new file mode 100644 index 0000000..bd1cdf4 --- /dev/null +++ b/src/commands/info/icon.ts @@ -0,0 +1,34 @@ +import { MessageEmbed } from 'discord.js'; +import { BushCommand, BushMessage, BushSlashMessage } from '../../lib'; + +export default class IconCommand extends BushCommand { + constructor() { + super('icon', { + aliases: ['icon', 'guildavatar', 'severicon', 'guildicon'], + category: 'info', + description: { + content: "A command to get the server's icon", + usage: 'icon', + examples: 'icon' + }, + clientPermissions: ['SEND_MESSAGES', 'EMBED_LINKS'], + channel: 'guild', + slash: true + }); + } + + async exec(message: BushMessage | BushSlashMessage): Promise<void> { + const embed = new MessageEmbed() + .setTimestamp() + .setColor(this.client.util.colors.default) + .setImage( + message.guild?.iconURL({ + size: 2048, + dynamic: true, + format: 'png' + }) + ) + .setTitle(message.guild.name); + await message.util.reply({ embeds: [embed] }); + } +} diff --git a/src/commands/info/invite.ts b/src/commands/info/invite.ts new file mode 100644 index 0000000..f53e930 --- /dev/null +++ b/src/commands/info/invite.ts @@ -0,0 +1,33 @@ +import { BushCommand, BushMessage, BushSlashMessage } from '@lib'; +import { MessageActionRow, MessageButton } from 'discord.js'; + +export default class InviteCommand extends BushCommand { + public constructor() { + super('invite', { + aliases: ['invite'], + category: 'info', + description: { + content: 'Sends the bot invite link.', + usage: 'invite', + examples: ['invite'] + }, + ratelimit: 4, + cooldown: 4000, + clientPermissions: ['SEND_MESSAGES'], + slash: true + }); + } + + public async exec(message: BushMessage | BushSlashMessage): Promise<unknown> { + if (this.client.config.dev) + return await message.util.reply(`${this.client.util.emojis.error} The dev bot cannot be invited.`); + const ButtonRow = new MessageActionRow().addComponents( + new MessageButton({ + style: 'LINK', + label: 'Invite Me', + url: `https://discord.com/api/oauth2/authorize?client_id=${this.client.user.id}&permissions=2147483647&scope=bot%20applications.commands` + }) + ); + return await message.util.reply({ components: [ButtonRow] }); + } +} diff --git a/src/commands/info/ping.ts b/src/commands/info/ping.ts index 59f475f..d1f406d 100644 --- a/src/commands/info/ping.ts +++ b/src/commands/info/ping.ts @@ -11,9 +11,9 @@ export default class PingCommand extends BushCommand { usage: 'ping', examples: ['ping'] }, + slash: true, clientPermissions: ['SEND_MESSAGES', 'EMBED_LINKS'], - userPermissions: ['SEND_MESSAGES'], - slash: true + userPermissions: ['SEND_MESSAGES'] }); } diff --git a/src/commands/info/snowflakeInfo.ts b/src/commands/info/snowflakeInfo.ts new file mode 100644 index 0000000..e234cc2 --- /dev/null +++ b/src/commands/info/snowflakeInfo.ts @@ -0,0 +1,151 @@ +import { + CategoryChannel, + Channel, + DeconstructedSnowflake, + DMChannel, + Emoji, + Guild, + MessageEmbed, + NewsChannel, + Role, + Snowflake, + SnowflakeUtil, + StageChannel, + TextChannel, + User, + VoiceChannel +} from 'discord.js'; +import { BushCommand, BushMessage, BushSlashMessage } from '../../lib'; + +export default class SnowflakeInfoCommand extends BushCommand { + public constructor() { + super('snowflake', { + aliases: ['snowflake', 'info', 'sf'], + category: 'info', + ratelimit: 4, + cooldown: 4000, + description: { + content: 'Provides information about the specified Snowflake.', + usage: 'snowflake <snowflake>', + examples: ['snowflake 322862723090219008'] + }, + args: [ + { + id: 'snowflake', + type: 'bigint', + prompt: { + start: 'Enter the snowflake you would like to get information about.', + retry: '{error} Choose a valid snowflake.', + optional: false + } + } + ], + clientPermissions: ['EMBED_LINKS', 'SEND_MESSAGES'], + slash: true, + slashOptions: [ + { + name: 'snowflake', + description: 'The snowflake you would like to get information about.', + type: 'STRING', + required: true + } + ] + }); + } + public async exec(message: BushMessage | BushSlashMessage, args: { snowflake: bigint }): Promise<unknown> { + const snowflake = `${args.snowflake}` as Snowflake; + const snowflakeEmbed = new MessageEmbed().setTitle('Unknown :snowflake:').setColor(this.client.util.colors.default); + + // Channel + if (this.client.channels.cache.has(snowflake)) { + const channel: Channel = this.client.channels.cache.get(snowflake); + const channelInfo = [`**Type:** ${channel.type}`]; + if (['dm', 'group'].includes(channel.type)) { + const _channel = channel as DMChannel; + channelInfo.push(`**Recipient:** ${_channel.recipient.tag} (${_channel.recipient.id})`); + snowflakeEmbed.setTitle(`:snowflake: DM with ${(channel as DMChannel).recipient.tag} \`[Channel]\``); + } else if ( + [ + 'GUILD_CATEGORY', + 'GUILD_NEWS', + 'GUILD_TEXT', + 'GUILD_VOICE', + 'GUILD_STORE', + 'GUILD_STAGE_VOICE', + 'GUILD_NEWS_THREAD', + 'GUILD_PUBLIC_THREAD', + 'GUILD_PRIVATE_THREAD' + ].includes(channel.type) + ) { + const _channel = channel as TextChannel | VoiceChannel | NewsChannel | StageChannel | CategoryChannel | StageChannel; + channelInfo.push( + `**Channel Name:** <#${_channel.id}> (${_channel.name})`, + `**Channel's Server:** ${_channel.guild.name} (${_channel.guild.id})` + ); + snowflakeEmbed.setTitle(`:snowflake: ${_channel.name} \`[Channel]\``); + } + snowflakeEmbed.addField('» Channel Info', channelInfo.join('\n')); + } + + // Guild + else if (this.client.guilds.cache.has(snowflake)) { + const guild: Guild = this.client.guilds.cache.get(snowflake); + const guildInfo = [ + `**Name:** ${guild.name}`, + `**Owner:** ${this.client.users.cache.get(guild.ownerId)?.tag || '¯\\_(ツ)_/¯'} (${guild.ownerId})`, + `**Members:** ${guild.memberCount?.toLocaleString()}` + ]; + snowflakeEmbed.setThumbnail(guild.iconURL({ size: 2048, dynamic: true })); + snowflakeEmbed.addField('» Server Info', guildInfo.join('\n')); + snowflakeEmbed.setTitle(`:snowflake: ${guild.name} \`[Server]\``); + } + + // User + else if (this.client.users.cache.has(snowflake)) { + const user: User = this.client.users.cache.get(snowflake); + const userInfo = [`**Name:** <@${user.id}> (${user.tag})`]; + snowflakeEmbed.setThumbnail(user.avatarURL({ size: 2048, dynamic: true })); + snowflakeEmbed.addField('» User Info', userInfo.join('\n')); + snowflakeEmbed.setTitle(`:snowflake: ${user.tag} \`[User]\``); + } + + // Emoji + else if (this.client.emojis.cache.has(snowflake)) { + const emoji: Emoji = this.client.emojis.cache.get(snowflake); + const emojiInfo = [`**Name:** ${emoji.name}`, `**Animated:** ${emoji.animated}`]; + snowflakeEmbed.setThumbnail(emoji.url); + snowflakeEmbed.addField('» Emoji Info', emojiInfo.join('\n')); + snowflakeEmbed.setTitle(`:snowflake: ${emoji.name} \`[Emoji]\``); + } + + // Role + else if (message.guild.roles.cache.has(snowflake)) { + const role: Role = message.guild.roles.cache.get(snowflake); + const roleInfo = [ + `**Name:** <@&${role.id}> (${role.name})`, + `**Members:** ${role.members.size}`, + `**Hoisted:** ${role.hoist}`, + `**Managed:** ${role.managed}`, + `**Position:** ${role.position}`, + `**Hex Color:** ${role.hexColor}` + ]; + if (role.color) snowflakeEmbed.setColor(role.color); + snowflakeEmbed.addField('» Role Info', roleInfo.join('\n')); + snowflakeEmbed.setTitle(`:snowflake: ${role.name} \`[Role]\``); + } + + // SnowflakeInfo + const deconstructedSnowflake: DeconstructedSnowflake = SnowflakeUtil.deconstruct(snowflake); + const snowflakeInfo = [ + `**Timestamp:** ${deconstructedSnowflake.timestamp}`, + `**Created:** ${deconstructedSnowflake.date.toLocaleString()}`, + `**Worker ID:** ${deconstructedSnowflake.workerId}`, + `**Process ID:** ${deconstructedSnowflake.processId}`, + `**Increment:** ${deconstructedSnowflake.increment}` + // `**Binary:** ${deconstructedSnowflake.binary}` + ]; + snowflakeEmbed.addField('» Snowflake Info', snowflakeInfo.join('\n')); + + return await message.util.reply({ embeds: [snowflakeEmbed] }); + } +} diff --git a/src/commands/info/userInfo.ts b/src/commands/info/userInfo.ts new file mode 100644 index 0000000..50756a6 --- /dev/null +++ b/src/commands/info/userInfo.ts @@ -0,0 +1,160 @@ +import { BushCommand, BushMessage, BushSlashMessage } from '@lib'; +import { GuildMember, MessageEmbed } from 'discord.js'; +import moment from 'moment'; + +// TODO: Allow looking up a user not in the guild and not cached +// TODO: Re-Implement Status Emojis +// TODO: Add bot information +export default class UserInfoCommand extends BushCommand { + public constructor() { + super('userinfo', { + aliases: ['userinfo', 'user', 'u'], + category: 'info', + description: { + usage: 'userinfo [user]', + examples: ['userinfo 322862723090219008'], + content: 'Gives information about a specified user.' + }, + args: [ + { + id: 'user', + type: 'member', + prompt: { + start: 'What user would you like to find information about?', + retry: '{error} Choose a valid user to find information about.', + optional: true + }, + default: null + } + ], + slash: true, + slashOptions: [ + { + name: 'user', + description: 'The user you would like to find information about.', + type: 'USER', + required: false + } + ], + clientPermissions: ['EMBED_LINKS', 'SEND_MESSAGES'], + userPermissions: ['SEND_MESSAGES'] + }); + } + + public async exec(message: BushMessage | BushSlashMessage, args: { user: GuildMember }): Promise<unknown> { + const user = args?.user || message.member; + const emojis = []; + const superUsers = this.client.cache.global.superUsers; + + const userEmbed: MessageEmbed = new MessageEmbed() + .setTitle(user.user.tag) + .setThumbnail(user.user.avatarURL({ size: 2048, format: 'png', dynamic: true })) + .setTimestamp(); + + // Flags + if (this.client.config.owners.includes(user.id)) emojis.push(this.client.consts.mappings.otherEmojis.DEVELOPER); + if (superUsers.includes(user.id)) emojis.push(this.client.consts.mappings.otherEmojis.SUPERUSER); + const flags = user.user.flags?.toArray(); + if (flags) { + flags.forEach((f) => { + if (this.client.consts.mappings.userFlags[f]) { + emojis.push(this.client.consts.mappings.userFlags[f]); + } else emojis.push(f); + }); + } + + // Since discord bald I just guess if someone has nitro + if ( + Number(user.user.discriminator) < 10 || + this.client.consts.mappings.maybeNitroDiscrims.includes(user.user.discriminator) || + user.user.displayAvatarURL({ dynamic: true })?.endsWith('.gif') || + user.user.flags?.toArray().includes('PARTNERED_SERVER_OWNER') + ) { + emojis.push(this.client.consts.mappings.otherEmojis.NITRO); + } + + if (message.guild.ownerId == user.id) emojis.push(this.client.consts.mappings.otherEmojis.OWNER); + else if (user.permissions.has('ADMINISTRATOR')) emojis.push(this.client.consts.mappings.otherEmojis.ADMIN); + if (user.premiumSinceTimestamp) emojis.push(this.client.consts.mappings.otherEmojis.BOOSTER); + + const createdAt = user.user.createdAt.toLocaleString(), + createdAtDelta = moment(user.user.createdAt).diff(moment()).toLocaleString(), + joinedAt = user.joinedAt?.toLocaleString(), + joinedAtDelta = moment(user.joinedAt)?.diff(moment()).toLocaleString(), + premiumSince = user.premiumSince?.toLocaleString(), + premiumSinceDelta = moment(user.premiumSince)?.diff(moment()).toLocaleString(); + + // General Info + const generalInfo = [ + `**Mention:** <@${user.id}>`, + `**ID:** ${user.id}`, + `**Created: **${createdAt} (${createdAtDelta} ago)` + ]; + userEmbed.addField('» General Info', generalInfo.join('\n')); + + // Server User Info + const serverUserInfo = []; + if (joinedAt) + serverUserInfo.push( + `**${message.guild.ownerId == user.id ? 'Created Server' : 'Joined'}: ** ${joinedAt} (${joinedAtDelta} ago)` + ); + if (premiumSince) serverUserInfo.push(`**Boosting Since:** ${premiumSince} (${premiumSinceDelta} ago)`); + if (user.displayHexColor) serverUserInfo.push(`**Display Color:** ${user.displayHexColor}`); + if (user.id == '322862723090219008' && message.guild.id == this.client.consts.mappings.guilds.bush) + serverUserInfo.push(`**General Deletions:** 2`); + if ( + ['384620942577369088', '496409778822709251'].includes(user.id) && + message.guild.id == this.client.consts.mappings.guilds.bush + ) + serverUserInfo.push(`**General Deletions:** 1`); + if (user.nickname) serverUserInfo.push(`**Nickname** ${user.nickname}`); + if (serverUserInfo.length) + userEmbed + .addField('» Server Info', serverUserInfo.join('\n')) + .setColor(user.displayColor || this.client.util.colors.default); + + // User Presence Info + if (user.presence?.status || user.presence?.clientStatus || user.presence?.activities) { + let customStatus = ''; + const activitiesNames = []; + if (user.presence.activities) { + user.presence.activities.forEach((a) => { + if (a.type == 'CUSTOM' && a.state) { + const emoji = `${a.emoji ? `${a.emoji.toString()} ` : ''}`; + customStatus = `${emoji}${a.state}`; + } + activitiesNames.push(`\`${a.name}\``); + }); + } + let devices; + if (user.presence.clientStatus) devices = Object.keys(user.presence.clientStatus); + const presenceInfo = []; + if (user.presence.status) presenceInfo.push(`**Status:** ${user.presence.status}`); + if (devices) + presenceInfo.push(`**${devices.length - 1 ? 'Devices' : 'Device'}:** ${this.client.util.oxford(devices, 'and', '')}`); + if (activitiesNames.length) + presenceInfo.push( + `**Activit${activitiesNames.length - 1 ? 'ies' : 'y'}:** ${this.client.util.oxford(activitiesNames, 'and', '')}` + ); + if (customStatus) presenceInfo.push(`**Custom Status:** ${customStatus}`); + userEmbed.addField('» Presence', presenceInfo.join('\n')); + } + + // Important Perms + const perms = []; + if (user.permissions.has('ADMINISTRATOR') || message.guild.ownerId == user.id) { + perms.push('`Administrator`'); + } else { + user.permissions.toArray(true).forEach((permission) => { + if (this.client.consts.mappings.permissions[permission]?.important) { + perms.push(`\`${this.client.consts.mappings.permissions[permission].name}\``); + } + }); + } + + if (perms.length) userEmbed.addField('» Important Perms', perms.join(' ')); + if (emojis) userEmbed.setDescription(emojis.join(' ')); + + return await message.util.reply({ embeds: [userEmbed] }); + } +} diff --git a/src/commands/moderation/modlog.ts b/src/commands/moderation/modlog.ts index af5f563..4b57a4f 100644 --- a/src/commands/moderation/modlog.ts +++ b/src/commands/moderation/modlog.ts @@ -1,6 +1,6 @@ -import { BushCommand, BushMessage, BushSlashMessage, ModLog } from '@lib'; +import { BushCommand, BushMessage, BushSlashMessage, BushUser, ModLog } from '@lib'; import { Argument } from 'discord-akairo'; -import { MessageEmbed } from 'discord.js'; +import { MessageEmbed, User } from 'discord.js'; export default class ModlogCommand extends BushCommand { public constructor() { @@ -47,8 +47,8 @@ export default class ModlogCommand extends BushCommand { return modLog.join(`\n`); } - async exec(message: BushMessage | BushSlashMessage, { search }: { search: string }): Promise<unknown> { - const foundUser = await this.client.util.resolveUserAsync(search); + async exec(message: BushMessage | BushSlashMessage, { search }: { search: BushUser | string }): Promise<unknown> { + const foundUser = search instanceof User ? search : await this.client.util.resolveUserAsync(search); if (foundUser) { const logs = await ModLog.findAll({ where: { @@ -57,6 +57,8 @@ export default class ModlogCommand extends BushCommand { }, order: [['createdAt', 'ASC']] }); + if (!logs.length) + return message.util.reply(`${this.client.util.emojis.error} **${foundUser.tag}** does not have any modlogs.`); const niceLogs: string[] = []; for (const log of logs) { niceLogs.push(this.generateModlogInfo(log)); @@ -72,7 +74,7 @@ export default class ModlogCommand extends BushCommand { ); this.client.util.buttonPaginate(message, embedPages, '', true); } else if (search) { - const entry = await ModLog.findByPk(search); + const entry = await ModLog.findByPk(search as string); if (!entry) return message.util.send(`${this.client.util.emojis.error} That modlog does not exist.`); const embed = new MessageEmbed({ title: `Case ${entry.id}`, diff --git a/src/commands/moderation/removeReactionEmoji.ts b/src/commands/moderation/removeReactionEmoji.ts new file mode 100644 index 0000000..3d274e1 --- /dev/null +++ b/src/commands/moderation/removeReactionEmoji.ts @@ -0,0 +1,64 @@ +import { BushCommand, BushMessage } from '@lib'; +import { Argument } from 'discord-akairo'; +import { Emoji } from 'discord.js'; + +export default class RemoveReactionEmojiCommand extends BushCommand { + public constructor() { + super('removereactionemoji', { + aliases: ['removereactionemoji', 'rre'], + category: 'moderation', + description: { + content: 'Deleted all the reactions of a certain emoji from a message.', + usage: 'removereactionemoji <message> <emoji>', + examples: ['removereactionemoji 791413052347252786 <:omegaclown:782630946435366942>'] + }, + clientPermissions: ['MANAGE_MESSAGES', 'SEND_MESSAGES', 'EMBED_LINKS'], + userPermissions: ['MANAGE_MESSAGES', 'MANAGE_EMOJIS'], // Can't undo the removal of 1000s of reactions + args: [ + { + id: 'messageToRemoveFrom', + type: 'guildMessage', + prompt: { + start: 'What message would you like to remove a reaction from?', + retry: '{error} Please pick a valid message.' + } + }, + { + id: 'emoji', + type: Argument.union('emoji', 'bigint'), + match: 'restContent', + prompt: { + start: 'What emoji would you like to remove?', + retry: '{error} Please pick a valid emoji.' + } + } + ], + channel: 'guild' + }); + } + + public async exec( + message: BushMessage, + { messageToRemoveFrom, emoji }: { messageToRemoveFrom: BushMessage; emoji: Emoji | BigInt } + ): Promise<unknown> { + const id = !['bigint', 'string'].includes(typeof emoji); + const emojiID = !id ? `${emoji}` : (emoji as Emoji).id; + const success = await messageToRemoveFrom.reactions.cache + .get(emojiID) + .remove() + .catch(() => {}); + if (success) { + return await message.util.reply( + `${this.client.util.emojis.success} Removed all reactions of \`${ + id ? emojiID : emoji + }\` from the message with the id of \`${messageToRemoveFrom.id}\`.` + ); + } else { + return await message.util.reply( + `${this.client.util.emojis.error} There was an error removing all reactions of \`${ + id ? emojiID : emoji + }\` from the message with the id of \`${messageToRemoveFrom.id}\`.` + ); + } + } +} diff --git a/src/commands/moderation/slowmode.ts b/src/commands/moderation/slowmode.ts new file mode 100644 index 0000000..8384562 --- /dev/null +++ b/src/commands/moderation/slowmode.ts @@ -0,0 +1,87 @@ +import { BushCommand, BushMessage, BushSlashMessage } from '@lib'; +import { Argument, Constants } from 'discord-akairo'; +import { TextChannel, ThreadChannel } from 'discord.js'; + +export default class SlowModeCommand extends BushCommand { + public constructor() { + super('slowmode', { + aliases: ['slowmode', 'slow'], + category: 'moderation', + description: { + content: 'A command to set the slowmode of a channel.', + usage: 'slowmode <length>', + examples: ['slowmode 3'] + }, + args: [ + { + id: 'length', + type: Argument.union('duration', 'off', 'none', 'disable'), + default: 0, + prompt: { + start: 'What would you like to set the slowmode to?', + retry: '{error} Please set the slowmode to a valid length.', + optional: true + } + }, + { + id: 'channel', + type: Constants.ArgumentTypes.CHANNEL, + match: Constants.ArgumentMatches.PHRASE, + prompt: { + start: 'What channel would you like to change?', + retry: '{error} Choose a valid channel.', + optional: true + } + } + ], + slash: true, + slashOptions: [ + { + name: 'channel', + description: 'What channel would you like to change the slowmode of?', + type: 'CHANNEL', + required: false + } + ], + channel: 'guild', + clientPermissions: ['MANAGE_CHANNELS', 'SEND_MESSAGES', 'EMBED_LINKS'], + userPermissions: ['MANAGE_MESSAGES', 'SEND_MESSAGES'] + }); + } + + public async exec( + message: BushMessage | BushSlashMessage, + { length, channel }: { length: number | 'off' | 'none' | 'disable'; channel: TextChannel | ThreadChannel } + ): Promise<unknown> { + if (message.channel.type === 'DM') + return await message.util.reply(`${this.client.util.emojis.error} This command cannot be run in dms.`); + if (!channel) channel = message.channel as ThreadChannel | TextChannel; + if (!(channel instanceof TextChannel) || !(channel instanceof ThreadChannel)) + return await message.util.reply(`${this.client.util.emojis.error} <#${channel.id}> is not a text or thread channel.`); + if (length) { + length = + typeof length === 'string' && !['off', 'none', 'disable'].includes(length) + ? await Argument.cast('duration', this.client.commandHandler.resolver, message as BushMessage, length) + : length; + } + + // @ts-expect-error: stop being dumb smh + const length2: number = ['off', 'none', 'disable'].includes(length) ? 0 : length; + + const setSlowmode = await (channel as ThreadChannel | TextChannel) + .setRateLimitPerUser(length2 / 1000, `Changed by ${message.author.tag} (${message.author.id}).`) + .catch(() => {}); + if (!setSlowmode) + return await message.util.reply( + `${this.client.util.emojis.error} There was an error changing the slowmode of <#${ + (channel as ThreadChannel | TextChannel).id + }>.` + ); + else + return await message.util.reply( + `${this.client.util.emojis.success} Successfully changed the slowmode of ${channel} ${ + length2 ? `to \`${this.client.util.humanizeDuration(length2)}` : '`off' + }\`.` + ); + } +} diff --git a/src/commands/skyblockReborn/chooseColorCommand.ts b/src/commands/skyblockReborn/chooseColorCommand.ts new file mode 100644 index 0000000..ce70419 --- /dev/null +++ b/src/commands/skyblockReborn/chooseColorCommand.ts @@ -0,0 +1,179 @@ +import { AllowedMentions, BushCommand, BushGuildMember, BushMessage, BushSlashMessage } from '@lib'; +import { Constants } from 'discord-akairo'; +import { CommandInteraction, Role, RoleResolvable, Snowflake } from 'discord.js'; + +const roleColorMap = [ + { + name: 'Brown', + value: '840952499883737108' + }, + { + name: 'Dark Red', + value: '840952434574229546' + }, + { + name: 'Red', + value: '840952208552230913' + }, + { + name: 'Pink', + value: '840952722681364531' + }, + { + name: 'Hot Pink', + value: '840952638309007412' + }, + { + name: 'Yellow', + value: '840952282598473778' + }, + { + name: 'Gold', + value: '840952256764313610' + }, + { + name: 'Light Green', + value: '846394838744170517' + }, + { + name: 'Green', + value: '840952308702642206' + }, + { + name: 'Sea Green', + value: '840952901853511690' + }, + { + name: 'Forest Green', + value: '840952382510858260' + }, + { + name: 'Dark Green', + value: '840952336339042315' + }, + { + name: 'Blue', + value: '840952833200750682' + }, + { + name: 'Dark Blue', + value: '840952875734532137' + }, + { + name: 'Blurple', + value: '853037502188617778' + }, + { + name: 'Wizard Purple', + value: '840952750816755723' + }, + { + name: 'White', + value: '840953158276743208' + }, + { + name: 'Dark Mode', + value: '840953434785710110' + }, + { + name: 'Black', + value: '840953275326660629' + } +]; +export default class ChooseColorCommand extends BushCommand { + public constructor() { + super('chooseColor', { + aliases: ['choosecolor'], + category: 'Skyblock: Reborn', + description: { + content: 'Choose a color.', + usage: 'color <color>', + examples: ['report IRONM00N'] + }, + args: [ + { + id: 'color', + type: Constants.ArgumentTypes.ROLE, + match: Constants.ArgumentMatches.REST, + prompt: { + start: 'Please choose a valid color.', + retry: `{error} Provide what did they do wrong.`, + optional: true + } + } + ], + clientPermissions: ['EMBED_LINKS', 'SEND_MESSAGES'], + channel: 'guild', + restrictedGuilds: ['839287012409999391'], + slash: true, + slashGuilds: ['839287012409999391'], + slashOptions: [ + { + name: 'color', + description: 'The color you would like to have.', + type: 'STRING', + choices: roleColorMap, + required: true + } + ] + }); + } + + public async exec(message: BushMessage | BushSlashMessage, args: { color: Role | RoleResolvable }): Promise<unknown> { + if (message.guild.id != this.client.consts.mappings.guilds.sbr) { + return await message.util.reply(`${this.client.util.emojis.error} This command can only be run in Skyblock: Reborn.`); + } + const allowedRoles: Snowflake[] = [ + '839317526395879449', //Server Booster + '840949387534008360' //Mega Donator + ]; + + if ( + !( + allowedRoles.some((role) => (message.member as BushGuildMember).roles.cache.has(role)) || + (message.member as BushGuildMember).permissions.has('ADMINISTRATOR') || + message.guild.ownerId === message.author.id + ) + ) { + const allowed = this.client.util.oxford( + allowedRoles.map((id) => `<@&${id}>s`), + 'and', + '' + ); + return await message.util.reply({ + content: `${this.client.util.emojis.error} Only ${allowed} can use this command.`, + allowedMentions: AllowedMentions.none(), + ephemeral: true + }); + } + if (message.util.isSlash) await (message.interaction as CommandInteraction).defer(); + // new Array( + // roleColorMap.map(obj => obj.name.toLowerCase()), + // roleColorMap.map(obj => obj.value) + // ); + const colorID = message.util.isSlash ? (args.color as string) : (args.color as Role).id; + if (!roleColorMap.map((obj) => obj.value).includes(colorID)) { + return await message.util.reply({ + content: `${this.client.util.emojis.error} ${args.color} is not a whitelisted color role.`, + allowedMentions: AllowedMentions.none() + }); + } + const memberColorRoles = (message.member as BushGuildMember).roles.cache.filter((role) => + roleColorMap.map((obj) => obj.value).includes(role.id) + ); + + await (message.member as BushGuildMember).roles.add(args.color, 'Choose Color Command.'); + + if (memberColorRoles.size) { + memberColorRoles.forEach( + (role) => (message.member as BushGuildMember).roles.remove(role), + 'Removing Duplicate Color Roles.' + ); + } + + message.util.reply({ + content: `${this.client.util.emojis.success} Assigned you the <@&${colorID}> role.`, + allowedMentions: AllowedMentions.none() + }); + } +} diff --git a/src/commands/utilities/whoHasRole.ts b/src/commands/utilities/_whoHasRole.ts index e69de29..e69de29 100644 --- a/src/commands/utilities/whoHasRole.ts +++ b/src/commands/utilities/_whoHasRole.ts diff --git a/src/commands/utilities/decode.ts b/src/commands/utilities/decode.ts new file mode 100644 index 0000000..97ff444 --- /dev/null +++ b/src/commands/utilities/decode.ts @@ -0,0 +1,131 @@ +import { AllowedMentions, BushCommand, BushMessage } from '@lib'; +import { AkairoMessage } from 'discord-akairo'; +import { MessageEmbed } from 'discord.js'; + +const encodingTypesArray = ['ascii', 'utf8', 'utf-8', 'utf16le', 'ucs2', 'ucs-2', 'base64', 'latin1', 'binary', 'hex']; +const encodingTypesString = '`ascii`, `utf8`, `utf-8`, `utf16le`, `ucs2`, `ucs-2`, `base64`, `latin1`, `binary`, `hex`'; + +export default class DecodeCommand extends BushCommand { + public constructor() { + super('decode', { + aliases: ['decode', 'encode'], + category: 'utilities', + description: { + content: 'Decode / encode.', + usage: 'decode <from> <to> <data>', + examples: ['decode base64 ascii TmVyZApJbWFnaW5lIGRlY29kaW5nIHRoaXMgbG1hbw=='] + }, + args: [ + { + id: 'from', + type: encodingTypesArray, + prompt: { + start: 'What is the encoding of the original data?', + retry: `{error} Choose one of the following ${encodingTypesString} for the encoding of the original data.` + } + }, + { + id: 'to', + type: encodingTypesArray, + prompt: { + start: 'What would you like the encoding of the resulting data to be?', + retry: `{error} Choose one of the following ${encodingTypesString} for the encoding of the resulting data.` + } + }, + { + id: 'data', + type: 'string', + match: 'restContent', + prompt: { + start: 'What would you to decode.', + retry: '{error} Choose a valid string to decode.' + } + } + ], + clientPermissions: ['SEND_MESSAGES'], + slash: true, + slashOptions: [ + { + name: 'from', + description: 'The type of data you are inputting.', + type: 'STRING', + choices: [ + { name: 'ascii', value: 'ascii' }, + { name: 'utf8', value: 'utf8' }, + { name: 'utf-8', value: 'utf-8' }, + { name: 'utf16le', value: 'utf16le' }, + { name: 'ucs2', value: 'ucs2' }, + { name: 'ucs-2', value: 'ucs-2' }, + { name: 'base64', value: 'base64' }, + { name: 'latin1', value: 'latin1' }, + { name: 'binary', value: 'binary' }, + { name: 'hex', value: 'hex' } + ] + }, + { + name: 'to', + description: 'The type of data you want the output to be.', + type: 'STRING', + choices: [ + { name: 'ascii', value: 'ascii' }, + { name: 'utf8', value: 'utf8' }, + { name: 'utf-8', value: 'utf-8' }, + { name: 'utf16le', value: 'utf16le' }, + { name: 'ucs2', value: 'ucs2' }, + { name: 'ucs-2', value: 'ucs-2' }, + { name: 'base64', value: 'base64' }, + { name: 'latin1', value: 'latin1' }, + { name: 'binary', value: 'binary' }, + { name: 'hex', value: 'hex' } + ] + }, + { + name: 'data', + description: 'What you would like to decode.', + type: 'STRING' + } + ] + }); + } + + public async exec( + message: BushMessage, + { from, to, data }: { from: BufferEncoding; to: BufferEncoding; data: string } + ): Promise<unknown> { + const encodeOrDecode = message?.util?.parsed?.alias?.charAt(0).toUpperCase() + message?.util?.parsed?.alias?.slice(1); + const decodedEmbed = new MessageEmbed() + .setTitle(`${encodeOrDecode} Information`) + .addField('📥 Input', await this.client.util.codeblock(data, 1024)); + try { + const decoded = Buffer.from(data, from).toString(to); + decodedEmbed + .setColor(this.client.util.colors.success) + .addField('📤 Output', await this.client.util.codeblock(decoded, 1024)); + } catch (error) { + decodedEmbed + .setColor(this.client.util.colors.error) + .addField(`📤 Error ${encodeOrDecode.slice(1)}ing`, await this.client.util.codeblock(error.stack, 1024)); + } + return await message.util.send({ embeds: [decodedEmbed], allowedMentions: AllowedMentions.none() }); + } + + public async execSlash( + message: AkairoMessage, + { from, to, data }: { from: BufferEncoding; to: BufferEncoding; data: string } + ): Promise<unknown> { + const decodedEmbed = new MessageEmbed() + .setTitle(`Decoded Information`) + .addField('📥 Input', await this.client.util.codeblock(data, 1024)); + try { + const decoded = Buffer.from(data, from).toString(to); + decodedEmbed + .setColor(this.client.util.colors.success) + .addField('📤 Output', await this.client.util.codeblock(decoded, 1024)); + } catch (error) { + decodedEmbed + .setColor(this.client.util.colors.error) + .addField(`📤 Error decoding`, await this.client.util.codeblock(error.stack, 1024)); + } + return await message.interaction.reply({ embeds: [decodedEmbed], allowedMentions: AllowedMentions.none() }); + } +} diff --git a/src/commands/utilities/serverStatus.ts b/src/commands/utilities/serverStatus.ts new file mode 100644 index 0000000..a20f0b2 --- /dev/null +++ b/src/commands/utilities/serverStatus.ts @@ -0,0 +1,58 @@ +import { MessageEmbed } from 'discord.js'; +import got from 'got'; +import { BushCommand, BushMessage } from '../../lib'; + +export default class ServerStatusCommand extends BushCommand { + public constructor() { + super('serverstatus', { + aliases: ['serverstatus', 'ss'], + category: 'utilities', + description: { + usage: 'serverstatus', + examples: ['serverstatus', 'ss'], + content: "Gives the status of moulberry's server" + }, + ratelimit: 4, + cooldown: 4000, + clientPermissions: ['EMBED_LINKS', 'SEND_MESSAGES'], + slash: true + }); + } + + public async exec(message: BushMessage): Promise<void> { + const msgEmbed: MessageEmbed = new MessageEmbed() + .setTitle('Server status') + .setDescription(`Checking server:\n${this.client.util.emojis.loading}`) + .setColor(this.client.util.colors.default) + .setFooter('Checking https://moulberry.codes/lowestbin.json'); + await message.util.reply({ embeds: [msgEmbed] }); + let main; + try { + await got.get('https://moulberry.codes/lowestbin.json').json(); + main = this.client.util.emojis.success; + } catch (e) { + main = this.client.util.emojis.error; + } + await message.util.edit({ embeds: [msgEmbed.setDescription(`Checking server:\n${main}`)] }); + if (main == this.client.util.emojis.success) { + await message.util.edit({ + embeds: [ + msgEmbed + .addField('Status', 'The server is online, all features related to prices will likely work.') + .setColor(this.client.util.colors.success) + ] + }); + } else { + await message.util.edit({ + embeds: [ + msgEmbed + .addField( + 'Status', + "It appears Moulberry's server is offline, this means that everything related to prices will likely not work." + ) + .setColor(this.client.util.colors.error) + ] + }); + } + } +} diff --git a/src/commands/utilities/uuid.ts b/src/commands/utilities/uuid.ts new file mode 100644 index 0000000..0b96ce1 --- /dev/null +++ b/src/commands/utilities/uuid.ts @@ -0,0 +1,43 @@ +import { Constants } from 'discord-akairo'; +import { BushCommand, BushMessage } from '../../lib'; + +export default class UuidCommand extends BushCommand { + public constructor() { + super('uuid', { + aliases: ['uuid'], + category: 'utilities', + description: { + content: "Find someone's minecraft uuid", + usage: 'uuid <ign>', + examples: ['uuid ironm00n'] + }, + args: [ + { + id: 'ign', + type: /\w{1,16}/im, + match: Constants.ArgumentMatches.PHRASE, + prompt: { + start: 'What ign would you like to find the uuid of?', + retry: '{error} Choose a valid ign.', + optional: false + } + } + ], + cooldown: 4000, + ratelimit: 1, + clientPermissions: ['SEND_MESSAGES'] + }); + } + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + public async exec(message: BushMessage, { ign }: { ign: { match: any[]; matches: any[] } }): Promise<unknown> { + if (!ign) return await message.util.reply(`${this.client.util.emojis.error} Please enter a valid ign.`); + const readableIGN = ign.match[0]; + try { + const uuid = await this.client.util.findUUID(readableIGN); + return await message.util.reply(`The uuid for \`${readableIGN}\` is \`${uuid}\``); + } catch (e) { + return await message.util.reply(`${this.client.util.emojis.error} Could not find an uuid for \`${readableIGN}\`.`); + } + } +} diff --git a/src/commands/utilities/viewraw.ts b/src/commands/utilities/viewraw.ts new file mode 100644 index 0000000..7642b2a --- /dev/null +++ b/src/commands/utilities/viewraw.ts @@ -0,0 +1,75 @@ +import { Argument, Constants } from 'discord-akairo'; +import { DMChannel, Message, MessageEmbed, NewsChannel, Snowflake, TextChannel } from 'discord.js'; +import { inspect } from 'util'; +import { BushCommand, BushMessage, BushSlashMessage } from '../../lib'; + +export default class ViewRawCommand extends BushCommand { + public constructor() { + super('viewraw', { + aliases: ['viewraw'], + category: 'info', + clientPermissions: ['EMBED_LINKS'], + description: { + usage: 'viewraw <message id> <channel>', + examples: ['viewraw 322862723090219008'], + content: 'Gives information about a specified user.' + }, + args: [ + { + id: 'message', + type: Argument.union(Constants.ArgumentTypes.MESSAGE, Constants.ArgumentTypes.BIGINT), + match: Constants.ArgumentMatches.PHRASE, + prompt: { + start: 'What message would you like to view?', + retry: '{error} Choose a valid message.', + optional: false + } + }, + { + id: 'channel', + type: Constants.ArgumentTypes.CHANNEL, + match: Constants.ArgumentMatches.PHRASE, + prompt: { + start: 'What channel is the message in?', + retry: '{error} Choose a valid channel.', + optional: true + }, + default: (m) => m.channel + }, + { + id: 'json', + match: Constants.ArgumentMatches.FLAG, + flag: '--json' + } + ] + }); + } + + public async exec( + message: BushMessage | BushSlashMessage, + args: { message: Message | BigInt; channel: TextChannel | NewsChannel | DMChannel; json?: boolean } + ): Promise<unknown> { + let newMessage: Message | 0; + if (!(typeof args.message === 'object')) { + newMessage = await args.channel.messages.fetch(`${args.message}` as Snowflake).catch(() => { + return 0; + }); + if (!newMessage) { + return await message.util.reply( + `${this.client.util.emojis.error} There was an error fetching that message, try supplying a channel.` + ); + } + } else { + newMessage = args.message as Message; + } + const content = args.json ? inspect(newMessage.toJSON()) || '[No Content]' : newMessage.content || '[No Content]'; + const messageEmbed = new MessageEmbed() + .setFooter(newMessage.author.tag, newMessage.author.avatarURL({ dynamic: true })) + .setTimestamp(newMessage.createdTimestamp) + .setColor(newMessage.member?.roles?.color?.color || this.client.util.colors.default) + .setTitle('Raw Message Information') + .setDescription(await this.client.util.codeblock(content, 2048, 'js')); + + return await message.util.reply({ embeds: [messageEmbed] }); + } +} diff --git a/src/lib/extensions/discord-akairo/BushClient.ts b/src/lib/extensions/discord-akairo/BushClient.ts index cb6a1de..3b14200 100644 --- a/src/lib/extensions/discord-akairo/BushClient.ts +++ b/src/lib/extensions/discord-akairo/BushClient.ts @@ -25,6 +25,7 @@ import { Guild as GuildModel } from '../../models/Guild'; import { Level } from '../../models/Level'; import { ModLog } from '../../models/ModLog'; import { Mute } from '../../models/Mute'; +import { PunishmentRole } from '../../models/PunishmentRole'; import { StickyRole } from '../../models/StickyRole'; import { AllowedMentions } from '../../utils/AllowedMentions'; import { BushCache } from '../../utils/BushCache'; @@ -260,6 +261,7 @@ export class BushClient extends AkairoClient { Mute.initModel(this.db); Level.initModel(this.db); StickyRole.initModel(this.db); + PunishmentRole.initModel(this.db); await this.db.sync({ alter: true }); // Sync all tables to fix everything if updated await this.console.success('Startup', `Successfully connected to <<database>>.`, false); } catch (e) { diff --git a/src/lib/extensions/discord-akairo/BushClientUtil.ts b/src/lib/extensions/discord-akairo/BushClientUtil.ts index b3c9953..6538ebf 100644 --- a/src/lib/extensions/discord-akairo/BushClientUtil.ts +++ b/src/lib/extensions/discord-akairo/BushClientUtil.ts @@ -43,7 +43,7 @@ import { } from 'discord.js'; import got from 'got'; import humanizeDuration from 'humanize-duration'; -import Op from 'sequelize/types/lib/operators'; +import { Op } from 'sequelize'; import { promisify } from 'util'; interface hastebinRes { @@ -99,6 +99,11 @@ interface punishmentModels { role: PunishmentRole; } +interface MojangProfile { + username: string; + uuid: string; +} + export class BushClientUtil extends ClientUtil { /** The client of this ClientUtil */ public declare readonly client: BushClient; @@ -302,6 +307,7 @@ export class BushClientUtil extends ClientUtil { text: string | null = null, deleteOnExit?: boolean ): Promise<void> { + const paginateEmojis = this.paginateEmojis; if (deleteOnExit === undefined) deleteOnExit = true; if (embeds.length === 1) { @@ -374,7 +380,6 @@ export class BushClientUtil extends ClientUtil { ?.update({ content: text, embeds: [embeds[curPage]], components: [getPaginationRow()] }) .catch(() => undefined); } - const paginateEmojis = this.paginateEmojis; function getPaginationRow(disableAll = false): MessageActionRow { return new MessageActionRow().addComponents( new MessageButton({ @@ -408,6 +413,7 @@ export class BushClientUtil extends ClientUtil { /** Sends a message with a button for the user to delete it. */ public async sendWithDeleteButton(message: BushMessage | BushSlashMessage, options: MessageOptions): Promise<void> { + const paginateEmojis = this.paginateEmojis; updateOptions(); const msg = await message.util.reply(options as MessageOptions & { split?: false }); const filter = (interaction: ButtonInteraction) => interaction.customId == 'paginate__stop' && interaction.message == msg; @@ -429,7 +435,6 @@ export class BushClientUtil extends ClientUtil { await msg.edit(options as MessageEditOptions).catch(() => undefined); }); - const paginateEmojis = this.paginateEmojis; function updateOptions(edit?: boolean, disable?: boolean) { if (edit == undefined) edit = false; if (disable == undefined) disable = false; @@ -644,7 +649,7 @@ export class BushClientUtil extends ClientUtil { if (!getCaseNumber) return { log: saveResult, caseNum: null }; - const caseNum = (await ModLog.findAll({ where: { type: options.type, user: options.user, guild: options.guild } }))?.length; + const caseNum = (await ModLog.findAll({ where: { type: options.type, user: user, guild: guild } }))?.length; return { log: saveResult, caseNum }; } @@ -703,6 +708,7 @@ export class BushClientUtil extends ClientUtil { public async findExpiredEntries<K extends keyof punishmentModels>(type: K): Promise<punishmentModels[K][]> { const dbModel = this.findPunishmentModel(type); + console.log(dbModel); //@ts-ignore: stfu idc return await dbModel.findAll({ where: { @@ -733,4 +739,33 @@ export class BushClientUtil extends ClientUtil { public humanizeDuration(duration: number): string { return humanizeDuration(duration, { language: 'en', maxDecimalPoints: 2 }); } + + public async findUUID(player: string): Promise<string> { + try { + const raw = await got.get(`https://api.ashcon.app/mojang/v2/user/${player}`); + let profile: MojangProfile; + if (raw.statusCode == 200) { + profile = JSON.parse(raw.body); + } else { + throw 'invalid player'; + } + + if (raw.statusCode == 200 && profile && profile.uuid) { + return profile.uuid.replace(/-/g, ''); + } else { + throw `Could not fetch the uuid for ${player}.`; + } + } catch (e) { + throw 'An error has occurred.'; + } + } + + public hexToRgb(hex: string): string { + const arrBuff = new ArrayBuffer(4); + const vw = new DataView(arrBuff); + vw.setUint32(0, parseInt(hex, 16), false); + const arrByte = new Uint8Array(arrBuff); + + return arrByte[1] + ', ' + arrByte[2] + ', ' + arrByte[3]; + } } diff --git a/src/lib/extensions/discord.js/BushGuildMember.ts b/src/lib/extensions/discord.js/BushGuildMember.ts index 4bb1c2c..fb85d7f 100644 --- a/src/lib/extensions/discord.js/BushGuildMember.ts +++ b/src/lib/extensions/discord.js/BushGuildMember.ts @@ -80,32 +80,36 @@ export class BushGuildMember extends GuildMember { } public async warn(options: BushPunishmentOptions): Promise<{ result: WarnResponse; caseNum: number }> { + const moderator = this.client.users.cache.get(this.client.users.resolveId(options.moderator || this.client.user)); // add modlog entry - const { log, caseNum } = await this.client.util + const result = await this.client.util .createModLogEntry( { type: ModLogType.WARN, user: this, - moderator: options.moderator || this.client.user.id, + moderator: moderator.id, reason: options.reason, guild: this.guild }, true ) - .catch(() => null); - if (!log) return { result: 'error creating modlog entry', caseNum: null }; + .catch((e) => { + this.client.console.error('warn', e, true, 1); + return { log: null, caseNum: null }; + }); + if (!result || !result.log) return { result: 'error creating modlog entry', caseNum: null }; // dm user - const ending = this.guild.getSetting('punishmentEnding'); + const ending = await this.guild.getSetting('punishmentEnding'); const dmSuccess = await this.send({ content: `You have been warned in **${this.guild}** for **${options.reason || 'No reason provided'}**.${ ending ? `\n\n${ending}` : '' }` }).catch(() => null); - if (!dmSuccess) return { result: 'failed to dm', caseNum }; + if (!dmSuccess) return { result: 'failed to dm', caseNum: result.caseNum }; - return { result: 'success', caseNum }; + return { result: 'success', caseNum: result.caseNum }; } public async addRole(options: AddRoleOptions): Promise<AddRoleResponse> { @@ -232,7 +236,7 @@ export class BushGuildMember extends GuildMember { if (!punishmentEntrySuccess) return 'error creating mute entry'; // dm user - const ending = this.guild.getSetting('punishmentEnding'); + const ending = await this.guild.getSetting('punishmentEnding'); const dmSuccess = await this.send({ content: `You have been muted ${ options.duration ? 'for ' + this.client.util.humanizeDuration(options.duration) : 'permanently' @@ -300,7 +304,7 @@ export class BushGuildMember extends GuildMember { const moderator = this.client.users.cache.get(this.client.users.resolveId(options.moderator || this.client.user)); // dm user - const ending = this.guild.getSetting('punishmentEnding'); + const ending = await this.guild.getSetting('punishmentEnding'); const dmSuccess = await this.send({ content: `You have been kicked from **${this.guild}** for **${options.reason || 'No reason provided'}**.${ ending ? `\n\n${ending}` : '' @@ -333,7 +337,7 @@ export class BushGuildMember extends GuildMember { const moderator = this.client.users.cache.get(this.client.users.resolveId(options.moderator || this.client.user)); // dm user - const ending = this.guild.getSetting('punishmentEnding'); + const ending = await this.guild.getSetting('punishmentEnding'); const dmSuccess = await this.send({ content: `You have been banned ${ options.duration ? 'for ' + this.client.util.humanizeDuration(options.duration) : 'permanently' diff --git a/src/lib/models/Guild.ts b/src/lib/models/Guild.ts index f6aa1a4..43fcd64 100644 --- a/src/lib/models/Guild.ts +++ b/src/lib/models/Guild.ts @@ -6,17 +6,13 @@ import { BaseModel } from './BaseModel'; export interface GuildModel { id: string; prefix: string; - autoPublishChannels: string[]; + autoPublishChannels: Snowflake[]; blacklistedChannels: Snowflake[]; welcomeChannel: Snowflake; muteRole: Snowflake; punishmentEnding: string; } -// export type GuildModelCreationAttributes = Optional< -// GuildModel, -// 'prefix' | 'autoPublishChannels' | 'blacklistedChannels' | 'welcomeChannel' | 'muteRole' | 'punishmentEnding' -// >; export interface GuildModelCreationAttributes { id: string; prefix?: string; @@ -30,7 +26,7 @@ export interface GuildModelCreationAttributes { export class Guild extends BaseModel<GuildModel, GuildModelCreationAttributes> implements GuildModel { id!: string; prefix!: string; - autoPublishChannels: string[]; + autoPublishChannels: Snowflake[]; blacklistedChannels: Snowflake[]; welcomeChannel: Snowflake; muteRole: Snowflake; diff --git a/src/lib/utils/BushConstants.ts b/src/lib/utils/BushConstants.ts index 7e6013d..747c6d6 100644 --- a/src/lib/utils/BushConstants.ts +++ b/src/lib/utils/BushConstants.ts @@ -152,7 +152,8 @@ export class BushConstants { VOICE: '<:voice:853375566735212584>', STAGE: '<:stage:853375583521210468>', STORE: '<:store:853375601175691266>', - CATEGORY: '<:category:853375615260819476>' + CATEGORY: '<:category:853375615260819476>', + THREAD: '<:thread:865033845753249813>' }, userFlags: { diff --git a/src/listeners/commands/commandMissingPermissions.ts b/src/listeners/commands/commandMissingPermissions.ts index ffcc408..f3d2218 100644 --- a/src/listeners/commands/commandMissingPermissions.ts +++ b/src/listeners/commands/commandMissingPermissions.ts @@ -16,15 +16,6 @@ export default class CommandMissingPermissionsListener extends BushListener { type: 'client' | 'user', missing: Array<PermissionString> ): Promise<void> { - this.client.console.debug(message.guild.me.permissions.toArray()); - missing.forEach((permission) => { - this.client.console.debug(message.guild.me.permissions.has(permission)); - }); - message.guild.me.permissions; - this.client.console.debug(type); - this.client.console.debug(command.clientPermissions); - this.client.console.debug(command.userPermissions); - this.client.console.debug(missing); const niceMissing = []; missing.forEach((missing) => { if (this.client.consts.mappings.permissions[missing]) { @@ -34,7 +25,7 @@ export default class CommandMissingPermissionsListener extends BushListener { } }); - const discordFormat = this.client.util.oxford(this.client.util.surroundArray(niceMissing, '`'), 'and', ''); + const discordFormat = this.client.util.oxford(this.client.util.surroundArray(niceMissing, '**'), 'and', ''); const consoleFormat = this.client.util.oxford(this.client.util.surroundArray(niceMissing, '<<', '>>'), 'and', ''); this.client.console.info( 'CommandMissingPermissions', @@ -55,7 +46,7 @@ export default class CommandMissingPermissionsListener extends BushListener { .reply( `${this.client.util.emojis.error} You are missing the ${discordFormat} permission${ missing.length ? 's' : '' - } required for the \`${command?.id}\` command.` + } required for the **${command?.id}** command.` ) .catch(() => {}); } |