commands/settings/SetupCommand.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* SudoBot is free software; you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by 
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* 
* SudoBot is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License 
* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
*/

import { CommandInteraction, Guild, Message, MessageActionRow, MessageSelectMenu, SelectMenuInteraction, TextChannel } from 'discord.js';
import BaseCommand from '../../utils/structures/BaseCommand';
import DiscordClient from '../../client/Client';
import CommandOptions from '../../types/CommandOptions';
import InteractionOptions from '../../types/InteractionOptions';
import MessageEmbed from '../../client/MessageEmbed';
import { fetchEmoji } from '../../utils/Emoji';

export default class AboutCommand extends BaseCommand {
    supportsInteractions: boolean = true;
    ownerOnly: boolean = true;

    constructor() {
        super('setup', 'settings', []);
    }

    async createMutedRole(client: DiscordClient, interaction: SelectMenuInteraction) {
        await interaction.reply({
            content: `${await fetchEmoji('loading')} Creating muted role...`
        });

        const { guild } = interaction;

        if (!guild) {
            return;
        }

        try {
            const role = await guild.roles.create({
                color: 'DARK_GREY',
                mentionable: false,
                name: 'Muted',
                permissions: undefined,
                reason: 'User commanded to create a muted role',
            });

            await new Promise(r => setTimeout(r, 1500));

            await interaction.editReply({
                content: `${await fetchEmoji('check')} Muted role created.\n${await fetchEmoji('loading')} Adding permission override to the channels...`
            });    

            let success = 0, failed = 0;

            for (const channel of guild.channels.cache.values()) {
                try {
                    if (channel.type === 'GUILD_STAGE_VOICE' || channel.type === 'GUILD_VOICE') {
                        await channel.permissionOverwrites.create(role, {
                            ADD_REACTIONS: false,
                            SEND_MESSAGES: false,
                            SEND_MESSAGES_IN_THREADS: false,
                            SPEAK: false,
                            REQUEST_TO_SPEAK: false
                        });
                    }
                    else if (!channel.type.endsWith('_THREAD')) {
                        await (channel as TextChannel).permissionOverwrites.create(role, {
                            ADD_REACTIONS: false,
                            SEND_MESSAGES: false,
                            SEND_MESSAGES_IN_THREADS: false,
                        });
                    }

                    success++;
                }
                catch (e) {
                    console.log(e);
                    failed++;
                }
            }

            await interaction.editReply({ content: `${await fetchEmoji('check')} A new muted role ${role} was created, with ${success} successful and ${failed} failed channel overrides.` });
        }
        catch (e) {
            console.log(e);
            await interaction.editReply({ content: `${await fetchEmoji('error')} An error occured while trying to create the role and applying overrides.` });
        }
    }

    async run(client: DiscordClient, message: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        const selectMenuRow = new MessageActionRow<MessageSelectMenu>()
            .addComponents(
                new MessageSelectMenu()
                    .setCustomId('setup_selectmenu')
                    .setMaxValues(1)
                    .setMinValues(1)
                    .addOptions(
                        {
                            label: 'Create Mute Role',
                            value: 'muterole_create',
                            description: 'Creates a muted role with proper permission overrides'
                        }
                    )
            );

        let reply = <Message> await message.reply({
            embeds: [
                new MessageEmbed({
                    title: 'Setup Options',
                    description: 'Choose a option to start.',
                })
            ],
            components: [selectMenuRow]
        });

        if (message instanceof CommandInteraction) {
            reply = <Message> await message.fetchReply();
        }

        message.channel?.awaitMessageComponent({
            componentType: 'SELECT_MENU',
            time: 120_000,
            dispose: true,
            filter(interaction) {
                return interaction.customId === 'setup_selectmenu' && interaction.user.id === message.member!.user.id;
            },
        })
        .then(interaction => {
            if (interaction.values.includes('muterole_create')) {
                this.createMutedRole(client, interaction);
            }
        })
        .catch(error => {
            console.log(error);
            selectMenuRow.components[0].setDisabled(true);

            reply!.edit({
                components: [selectMenuRow]
            });
        })
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2022 OSN Inc.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import { CommandInteraction, Guild, Message, MessageActionRow, MessageSelectMenu, SelectMenuInteraction, TextChannel } from 'discord.js';
21			import BaseCommand from '../../utils/structures/BaseCommand';
22			import DiscordClient from '../../client/Client';
23			import CommandOptions from '../../types/CommandOptions';
24			import InteractionOptions from '../../types/InteractionOptions';
25			import MessageEmbed from '../../client/MessageEmbed';
26			import { fetchEmoji } from '../../utils/Emoji';
27
28			export default class AboutCommand extends BaseCommand {
29			supportsInteractions: boolean = true;
30			ownerOnly: boolean = true;
31
32			constructor() {
33			super('setup', 'settings', []);
34			}
35
36			async createMutedRole(client: DiscordClient, interaction: SelectMenuInteraction) {
37			await interaction.reply({
38			content: `${await fetchEmoji('loading')} Creating muted role...`
39			});
40
41			const { guild } = interaction;
42
43			if (!guild) {
44			return;
45			}
46
47			try {
48			const role = await guild.roles.create({
49			color: 'DARK_GREY',
50			mentionable: false,
51			name: 'Muted',
52			permissions: undefined,
53			reason: 'User commanded to create a muted role',
54			});
55
56			await new Promise(r => setTimeout(r, 1500));
57
58			await interaction.editReply({
59			content: `${await fetchEmoji('check')} Muted role created.\n${await fetchEmoji('loading')} Adding permission override to the channels...`
60			});
61
62			let success = 0, failed = 0;
63
64			for (const channel of guild.channels.cache.values()) {
65			try {
66			if (channel.type === 'GUILD_STAGE_VOICE' \|\| channel.type === 'GUILD_VOICE') {
67			await channel.permissionOverwrites.create(role, {
68			ADD_REACTIONS: false,
69			SEND_MESSAGES: false,
70			SEND_MESSAGES_IN_THREADS: false,
71			SPEAK: false,
72			REQUEST_TO_SPEAK: false
73			});
74			}
75			else if (!channel.type.endsWith('_THREAD')) {
76			await (channel as TextChannel).permissionOverwrites.create(role, {
77			ADD_REACTIONS: false,
78			SEND_MESSAGES: false,
79			SEND_MESSAGES_IN_THREADS: false,
80			});
81			}
82
83			success++;
84			}
85			catch (e) {
86			console.log(e);
87			failed++;
88			}
89			}
90
91			await interaction.editReply({ content: `${await fetchEmoji('check')} A new muted role ${role} was created, with ${success} successful and ${failed} failed channel overrides.` });
92			}
93			catch (e) {
94			console.log(e);
95			await interaction.editReply({ content: `${await fetchEmoji('error')} An error occured while trying to create the role and applying overrides.` });
96			}
97			}
98
99			async run(client: DiscordClient, message: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
100			const selectMenuRow = new MessageActionRow<MessageSelectMenu>()
101			.addComponents(
102			new MessageSelectMenu()
103			.setCustomId('setup_selectmenu')
104			.setMaxValues(1)
105			.setMinValues(1)
106			.addOptions(
107			{
108			label: 'Create Mute Role',
109			value: 'muterole_create',
110			description: 'Creates a muted role with proper permission overrides'
111			}
112			)
113			);
114
115			let reply = <Message> await message.reply({
116			embeds: [
117			new MessageEmbed({
118			title: 'Setup Options',
119			description: 'Choose a option to start.',
120			})
121			],
122			components: [selectMenuRow]
123			});
124
125			if (message instanceof CommandInteraction) {
126			reply = <Message> await message.fetchReply();
127			}
128
129			message.channel?.awaitMessageComponent({
130			componentType: 'SELECT_MENU',
131			time: 120_000,
132			dispose: true,
133			filter(interaction) {
134			return interaction.customId === 'setup_selectmenu' && interaction.user.id === message.member!.user.id;
135			},
136			})
137			.then(interaction => {
138			if (interaction.values.includes('muterole_create')) {
139			this.createMutedRole(client, interaction);
140			}
141			})
142			.catch(error => {
143			console.log(error);
144			selectMenuRow.components[0].setDisabled(true);
145
146			reply!.edit({
147			components: [selectMenuRow]
148			});
149			})
150			}
151			}