commands/automation/ButtonRoleCreateCommand.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 { ButtonInteraction, CacheType, CommandInteraction, GuildChannel, Interaction, Message, MessageActionRow, MessageButton, MessageCollector, Permissions, TextChannel, Util } from 'discord.js';
import BaseCommand from '../../utils/structures/BaseCommand';
import DiscordClient from '../../client/Client';
import CommandOptions from '../../types/CommandOptions';
import MessageEmbed from '../../client/MessageEmbed';
import InteractionOptions from '../../types/InteractionOptions';
import { fetchEmoji } from '../../utils/Emoji';
import InteractionRole from '../../models/InteractionRole';
import InteractionRoleMessage from '../../models/InteractionRoleMessage';

export default class ButtonRoleCreateCommand extends BaseCommand {
    permissions = [Permissions.FLAGS.MANAGE_MESSAGES];

    constructor() {
        super('buttonrole__create', 'automation', []);
    }

    async action(client: DiscordClient, message: Message<boolean>, interactionBtn: ButtonInteraction) {
        await interactionBtn.reply("**Step 1**\nDo you want to have a custom text with your interaction role or the bot should generate it? Reply with '...' to generate message.");
        const collector = new MessageCollector(message.channel!, {
            filter(i) {
                console.log(i.author.id, interactionBtn.user.id);
                return i.author.id === interactionBtn.user.id;
            },
            time: 180_000,
        });

        let step = 1;
        let content = '', messageContent = '', autoGenerate = false, channel: TextChannel = message.channel! as TextChannel;
        const row = new MessageActionRow<MessageButton>();
        const insertedIDs: string[] = [];

        collector.on("collect", async collectedMessage => {
            console.log("Collected!");
            step++;

            if (collectedMessage.content === '--cancel') {
                await InteractionRole.deleteMany({ _id: { $in: insertedIDs } });
                collector.stop();
                await collectedMessage.react(fetchEmoji('check')!);
                return;
            }

            if (step === 2) {
                messageContent = collectedMessage.content;
                autoGenerate = messageContent.trim() === '...';

                await collectedMessage.reply("**Step 2**\nAwesome! Tell me which roles should I take care of, with name.\nThe format should be: `<roleID|roleMention> - <role title>` and each role should be in new lines and must not exceed 5 lines; Example:\n```\n@Test - Test Role\n363456217832361253 - Announcements\n```.\n\n*Waiting for your response...*");
            }
            else if (step === 3) {
                const tempMessage = await collectedMessage.reply("Please wait...");
                content = collectedMessage.content;
                
                const lines = content.split('\n');

                if (lines.length > 5) {
                    await collectedMessage.reply("I cannot create 5 role buttons at once!");
                    collector.stop();
                    tempMessage.delete().catch(console.error);
                    return;
                }

                if (messageContent.trim() === '...') {
                    messageContent = '';
                }

                let i = 0;
                
                for (const line of lines) {
                    i++;

                    const trimmed = line.trim();
                    const pos = trimmed.indexOf('-');

                    if (pos === -1) {
                        await collectedMessage.reply("You probably gave malformed entries. The role list must follow the structure/format given above.");
                        collector.stop();
                        tempMessage.delete().catch(console.error);
                        return;
                    }

                    const roleOrID = trimmed.substring(0, pos).trim();
                    const name = trimmed.substring(pos + 1).trim();

                    console.log(roleOrID, name);

                    try {
                        const role = roleOrID.startsWith('<@&') && roleOrID.endsWith('>') ? await message.guild!.roles.fetch(roleOrID.substring(3, roleOrID.length - 1)) : (await message.guild!.roles.fetch(roleOrID));

                        if (!role) {
                            throw new Error();
                        }

                        const interactionRole = await InteractionRole.create({
                            guild_id: message.guildId!,
                            role_id: role.id,
                            type: 'button',
                            createdAt: new Date()
                        });

                        insertedIDs.push(interactionRole.id);

                        if (autoGenerate) {
                            messageContent += `${role} • ${Util.escapeMarkdown(name)}\n`;
                        }

                        row.addComponents(
                            new MessageButton()
                                .setCustomId(`role__${interactionRole.id}__${role.id}`)
                                .setLabel(name)
                                .setStyle('SECONDARY')
                        );
                    }
                    catch (e) {
                        console.log(e);
                        
                        await collectedMessage.reply(`The role with ID ${roleOrID.startsWith('<@&') && roleOrID.endsWith('>') ? roleOrID.substring(3, roleOrID.length - 1) : roleOrID} (at position ${i}) is invalid or unable to fetch the role.`);
                        collector.stop();
                        tempMessage.delete().catch(console.error);
                        return;
                    }
                }
                
                tempMessage.delete().catch(console.error);
                await collectedMessage.reply("**Step 3**\nIn which channel you want the button role message to be? Tag it here or send the ID or send '...' to use the current channel.");
            }
            else if (step === 4) {
                if (collectedMessage.content.trim() !== '...') {
                    if (collectedMessage.mentions.channels.first()) {
                        channel = collectedMessage.mentions.channels.first() as TextChannel;
                    }
                    else {
                        try {
                            channel = <TextChannel> await message.guild?.channels.fetch(collectedMessage.content.trim());
                        }
                        catch (e) {
                            await collectedMessage.reply("Channel not found! Make sure the ID is correct.");
                            collector.stop();
                            return;
                        }
                    }

                    if (!['GUILD_TEXT', 'GUILD_NEWS', 'GUILD_NEWS_THREAD', 'GUILD_PUBLIC_THREAD', 'GUILD_PRIVATE_THREAD'].includes(channel.type)) {
                        await collectedMessage.reply("The given channel must be a text/announcement/thread channel!");
                        collector.stop();
                        return;
                    }
                }

                await collectedMessage.reply("**Step 4**\nAlright, I got it. Please confirm that everything is OK by typing `ok` in this channel.");
            }
            else if (step === 5) {
                if (collectedMessage.content.trim().toLowerCase() === 'ok') {
                    channel.send({
                        content: messageContent,
                        components: [
                            row
                        ],
                        allowedMentions: {
                            roles: []
                        }
                    }).then(async({ id, guildId }) => {
                        await InteractionRoleMessage.create({
                            dbIDs: insertedIDs,
                            createdAt: new Date(),
                            guild_id: guildId!,
                            message_id: id
                        });
                    }).catch(console.error);
                }
                else {
                    await InteractionRole.deleteMany({ _id: { $in: insertedIDs } });
                    collector.stop();
                    message.reply("Operation canceled.");
                }
            }
        });
    }

    async run(client: DiscordClient, message: CommandInteraction<CacheType> | Message<boolean>, options: CommandOptions | InteractionOptions): Promise<void> {
        let msg = <Message | CommandInteraction> await message.reply({
            embeds: [
                new MessageEmbed({
                    title: "Button Role Creation Wizard",
                    description: "This interactive wizard will help you to set up new button roles. Make sure that you respond in 3 minutes or otherwise the operation will be canceled. You can also manually cancel the operation by typing `--cancel` at any time, in this channel."
                })
            ],
            components: [
                new MessageActionRow()
                    .addComponents(
                        new MessageButton()
                            .setCustomId('rolecreate__start')
                            .setEmoji(fetchEmoji('ArrowRight')!)
                            .setLabel("Start Role Creation")
                            .setStyle('SECONDARY'),
                        new MessageButton()
                            .setCustomId('rolecreate__cancel')
                            .setEmoji(fetchEmoji('error')!)
                            .setLabel("Cancel")
                            .setStyle('SECONDARY')
                    )
            ]
        });

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

        message.channel!.awaitMessageComponent({
            componentType: 'BUTTON',
            dispose: true,
            time: 120_000,
            filter: i => i.guild.id === message.guildId! && i.member.user.id === message.member!.user.id
        })
        .then(async interaction => {
            if (interaction.customId !== 'rolecreate__start') {
                await interaction.reply("Operation canceled.");
                return Promise.reject();
            }

            let msg = message;

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

            this.action(client, msg as Message, interaction);
        })
        .catch(console.error)
        .finally(() => {
            const row = new MessageActionRow()
                .addComponents(
                    new MessageButton()
                        .setCustomId('rolecreate__start')
                        .setEmoji(fetchEmoji('ArrowRight')!)
                        .setLabel("Start Role Creation")
                        .setStyle('SECONDARY')
                        .setDisabled(true),
                    new MessageButton()
                        .setCustomId('rolecreate__cancel')
                        .setEmoji(fetchEmoji('error')!)
                        .setLabel("Cancel")
                        .setStyle('SECONDARY')
                        .setDisabled(true)
                );

            if (msg instanceof Message) {
                msg.edit({ components: [row] }).catch(console.error);
            }
            else if (msg instanceof CommandInteraction) {
                msg.editReply({ components: [row] }).catch(console.error);
            }
        });
    }
}
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 { ButtonInteraction, CacheType, CommandInteraction, GuildChannel, Interaction, Message, MessageActionRow, MessageButton, MessageCollector, Permissions, TextChannel, Util } from 'discord.js';
21			import BaseCommand from '../../utils/structures/BaseCommand';
22			import DiscordClient from '../../client/Client';
23			import CommandOptions from '../../types/CommandOptions';
24			import MessageEmbed from '../../client/MessageEmbed';
25			import InteractionOptions from '../../types/InteractionOptions';
26			import { fetchEmoji } from '../../utils/Emoji';
27			import InteractionRole from '../../models/InteractionRole';
28			import InteractionRoleMessage from '../../models/InteractionRoleMessage';
29
30			export default class ButtonRoleCreateCommand extends BaseCommand {
31			permissions = [Permissions.FLAGS.MANAGE_MESSAGES];
32
33			constructor() {
34			super('buttonrole__create', 'automation', []);
35			}
36
37			async action(client: DiscordClient, message: Message<boolean>, interactionBtn: ButtonInteraction) {
38			await interactionBtn.reply("Step 1\nDo you want to have a custom text with your interaction role or the bot should generate it? Reply with '...' to generate message.");
39			const collector = new MessageCollector(message.channel!, {
40			filter(i) {
41			console.log(i.author.id, interactionBtn.user.id);
42			return i.author.id === interactionBtn.user.id;
43			},
44			time: 180_000,
45			});
46
47			let step = 1;
48			let content = '', messageContent = '', autoGenerate = false, channel: TextChannel = message.channel! as TextChannel;
49			const row = new MessageActionRow<MessageButton>();
50			const insertedIDs: string[] = [];
51
52			collector.on("collect", async collectedMessage => {
53			console.log("Collected!");
54			step++;
55
56			if (collectedMessage.content === '--cancel') {
57			await InteractionRole.deleteMany({ _id: { $in: insertedIDs } });
58			collector.stop();
59			await collectedMessage.react(fetchEmoji('check')!);
60			return;
61			}
62
63			if (step === 2) {
64			messageContent = collectedMessage.content;
65			autoGenerate = messageContent.trim() === '...';
66
67			await collectedMessage.reply("Step 2\nAwesome! Tell me which roles should I take care of, with name.\nThe format should be: `<roleID\|roleMention> - <role title>` and each role should be in new lines and must not exceed 5 lines; Example:\n```\n@Test - Test Role\n363456217832361253 - Announcements\n```.\n\nWaiting for your response...");
68			}
69			else if (step === 3) {
70			const tempMessage = await collectedMessage.reply("Please wait...");
71			content = collectedMessage.content;
72
73			const lines = content.split('\n');
74
75			if (lines.length > 5) {
76			await collectedMessage.reply("I cannot create 5 role buttons at once!");
77			collector.stop();
78			tempMessage.delete().catch(console.error);
79			return;
80			}
81
82			if (messageContent.trim() === '...') {
83			messageContent = '';
84			}
85
86			let i = 0;
87
88			for (const line of lines) {
89			i++;
90
91			const trimmed = line.trim();
92			const pos = trimmed.indexOf('-');
93
94			if (pos === -1) {
95			await collectedMessage.reply("You probably gave malformed entries. The role list must follow the structure/format given above.");
96			collector.stop();
97			tempMessage.delete().catch(console.error);
98			return;
99			}
100
101			const roleOrID = trimmed.substring(0, pos).trim();
102			const name = trimmed.substring(pos + 1).trim();
103
104			console.log(roleOrID, name);
105
106			try {
107			const role = roleOrID.startsWith('<@&') && roleOrID.endsWith('>') ? await message.guild!.roles.fetch(roleOrID.substring(3, roleOrID.length - 1)) : (await message.guild!.roles.fetch(roleOrID));
108
109			if (!role) {
110			throw new Error();
111			}
112
113			const interactionRole = await InteractionRole.create({
114			guild_id: message.guildId!,
115			role_id: role.id,
116			type: 'button',
117			createdAt: new Date()
118			});
119
120			insertedIDs.push(interactionRole.id);
121
122			if (autoGenerate) {
123			messageContent += `${role} • ${Util.escapeMarkdown(name)}\n`;
124			}
125
126			row.addComponents(
127			new MessageButton()
128			.setCustomId(`role__${interactionRole.id}__${role.id}`)
129			.setLabel(name)
130			.setStyle('SECONDARY')
131			);
132			}
133			catch (e) {
134			console.log(e);
135
136			await collectedMessage.reply(`The role with ID ${roleOrID.startsWith('<@&') && roleOrID.endsWith('>') ? roleOrID.substring(3, roleOrID.length - 1) : roleOrID} (at position ${i}) is invalid or unable to fetch the role.`);
137			collector.stop();
138			tempMessage.delete().catch(console.error);
139			return;
140			}
141			}
142
143			tempMessage.delete().catch(console.error);
144			await collectedMessage.reply("Step 3\nIn which channel you want the button role message to be? Tag it here or send the ID or send '...' to use the current channel.");
145			}
146			else if (step === 4) {
147			if (collectedMessage.content.trim() !== '...') {
148			if (collectedMessage.mentions.channels.first()) {
149			channel = collectedMessage.mentions.channels.first() as TextChannel;
150			}
151			else {
152			try {
153			channel = <TextChannel> await message.guild?.channels.fetch(collectedMessage.content.trim());
154			}
155			catch (e) {
156			await collectedMessage.reply("Channel not found! Make sure the ID is correct.");
157			collector.stop();
158			return;
159			}
160			}
161
162			if (!['GUILD_TEXT', 'GUILD_NEWS', 'GUILD_NEWS_THREAD', 'GUILD_PUBLIC_THREAD', 'GUILD_PRIVATE_THREAD'].includes(channel.type)) {
163			await collectedMessage.reply("The given channel must be a text/announcement/thread channel!");
164			collector.stop();
165			return;
166			}
167			}
168
169			await collectedMessage.reply("Step 4\nAlright, I got it. Please confirm that everything is OK by typing `ok` in this channel.");
170			}
171			else if (step === 5) {
172			if (collectedMessage.content.trim().toLowerCase() === 'ok') {
173			channel.send({
174			content: messageContent,
175			components: [
176			row
177			],
178			allowedMentions: {
179			roles: []
180			}
181			}).then(async({ id, guildId }) => {
182			await InteractionRoleMessage.create({
183			dbIDs: insertedIDs,
184			createdAt: new Date(),
185			guild_id: guildId!,
186			message_id: id
187			});
188			}).catch(console.error);
189			}
190			else {
191			await InteractionRole.deleteMany({ _id: { $in: insertedIDs } });
192			collector.stop();
193			message.reply("Operation canceled.");
194			}
195			}
196			});
197			}
198
199			async run(client: DiscordClient, message: CommandInteraction<CacheType> \| Message<boolean>, options: CommandOptions \| InteractionOptions): Promise<void> {
200			let msg = <Message \| CommandInteraction> await message.reply({
201			embeds: [
202			new MessageEmbed({
203			title: "Button Role Creation Wizard",
204			description: "This interactive wizard will help you to set up new button roles. Make sure that you respond in 3 minutes or otherwise the operation will be canceled. You can also manually cancel the operation by typing `--cancel` at any time, in this channel."
205			})
206			],
207			components: [
208			new MessageActionRow()
209			.addComponents(
210			new MessageButton()
211			.setCustomId('rolecreate__start')
212			.setEmoji(fetchEmoji('ArrowRight')!)
213			.setLabel("Start Role Creation")
214			.setStyle('SECONDARY'),
215			new MessageButton()
216			.setCustomId('rolecreate__cancel')
217			.setEmoji(fetchEmoji('error')!)
218			.setLabel("Cancel")
219			.setStyle('SECONDARY')
220			)
221			]
222			});
223
224			if (message instanceof CommandInteraction) {
225			msg = <Message> await message.fetchReply();
226			}
227
228			message.channel!.awaitMessageComponent({
229			componentType: 'BUTTON',
230			dispose: true,
231			time: 120_000,
232			filter: i => i.guild.id === message.guildId! && i.member.user.id === message.member!.user.id
233			})
234			.then(async interaction => {
235			if (interaction.customId !== 'rolecreate__start') {
236			await interaction.reply("Operation canceled.");
237			return Promise.reject();
238			}
239
240			let msg = message;
241
242			if (message instanceof CommandInteraction) {
243			msg = <Message> await message.fetchReply();
244			}
245
246			this.action(client, msg as Message, interaction);
247			})
248			.catch(console.error)
249			.finally(() => {
250			const row = new MessageActionRow()
251			.addComponents(
252			new MessageButton()
253			.setCustomId('rolecreate__start')
254			.setEmoji(fetchEmoji('ArrowRight')!)
255			.setLabel("Start Role Creation")
256			.setStyle('SECONDARY')
257			.setDisabled(true),
258			new MessageButton()
259			.setCustomId('rolecreate__cancel')
260			.setEmoji(fetchEmoji('error')!)
261			.setLabel("Cancel")
262			.setStyle('SECONDARY')
263			.setDisabled(true)
264			);
265
266			if (msg instanceof Message) {
267			msg.edit({ components: [row] }).catch(console.error);
268			}
269			else if (msg instanceof CommandInteraction) {
270			msg.editReply({ components: [row] }).catch(console.error);
271			}
272			});
273			}
274			}