commands/automation/CreateReactionRoleCommand.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * 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 { PermissionFlagsBits, SlashCommandBuilder, Snowflake, TextBasedChannel, parseEmoji } from "discord.js";
import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { safeChannelFetch, safeMessageFetch, safeRoleFetch } from "../../utils/fetch";
import { logError } from "../../utils/logger";
import { isSnowflake } from "../../utils/utils";

export default class CreateReactionRoleCommand extends Command {
    public readonly name = "createreactionrole";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.String],
            name: "link",
            requiredErrorMessage: "Please provide a target message link!",
            typeErrorMessage: "Please provide a __valid__ message link!"
        },
        {
            types: [ArgumentType.String],
            name: "emoji",
            requiredErrorMessage: "Please provide a trigger emoji!",
            typeErrorMessage: "Please provide a __valid__ emoji!"
        },
        {
            types: [ArgumentType.StringRest],
            name: "roles",
            requiredErrorMessage: "Please provide at least one role!",
            typeErrorMessage: "Please provide __valid__ roles!"
        }
    ];
    public readonly permissions = [PermissionFlagsBits.ManageRoles];
    public readonly aliases = ["createreactrole", "makereactrole", "makerr", "createrr"];
    public readonly description = "Adds a reaction role listener to the given message.";
    public readonly detailedDescription =
        "Adds a reaction listener to the message, and when a user reacts with the given emoji, it will assign the given role(s).";
    public readonly slashCommandBuilder = new SlashCommandBuilder()
        .addStringOption(option => option.setName("message_link").setDescription("The target message link").setRequired(true))
        .addStringOption(option => option.setName("emoji").setDescription("The trigger emoji").setRequired(true))
        .addStringOption(option =>
            option
                .setName("roles")
                .setDescription("The role(s) to assign, when a user reacts with the given emoji")
                .setRequired(true)
        )
        .addStringOption(option =>
            option.setName("mode").setDescription("The behaviour of the reaction role trigger").setChoices(
                {
                    name: "Single and unique role",
                    value: "SINGLE"
                },
                {
                    name: "Multiple (Default)",
                    value: "MULTIPLE"
                }
            )
        );

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        await this.deferIfInteraction(message);

        const link: string = context.isLegacy ? context.parsedNamedArgs.link : context.options.getString("message_link", true);
        const mode = (context.isLegacy ? null : (context.options.getString("mode") as "SINGLE" | "MULTIPLE")) ?? "MULTIPLE";

        if (!/^https?:\/\/(canary\.|ptb\.|beta\.|www\.|)discord\.com\/channels\/\d+\/\d+\/\d+$/i.test(link.trim())) {
            await this.error(message, this.validationRules[0].typeErrorMessage);
            return;
        }

        const [messageId, channelId, guildId] = link
            .substring(0, link[link.length - 1] === "/" ? link.length - 1 : link.length)
            .split("/")
            .reverse();

        if (guildId !== message.guildId!) {
            await this.error(message, "That's a message link from another server!");
            return;
        }

        const rolesUnprocessed: string = (
            context.isLegacy ? context.parsedNamedArgs.roles : context.options.getString("roles", true)
        ).split(/\s+/);

        if (rolesUnprocessed.length > 7) {
            await this.error(message, "Cannot add more than 7 roles to a single emoji trigger!");
            return;
        }

        const roles: Snowflake[] = [];
        const roleNames: string[] = [];

        for (const roleUnprocessed of rolesUnprocessed) {
            const isId = isSnowflake(roleUnprocessed);
            const isMention = roleUnprocessed.startsWith("<@&") && roleUnprocessed.endsWith(">");

            if (!isId && !isMention) {
                await this.deferredReply(message, {
                    content: `${this.emoji("error")} Invalid role: ${roleUnprocessed}`,
                    allowedMentions: {
                        roles: []
                    }
                });

                return;
            }

            const role = await safeRoleFetch(
                message.guild!,
                isId ? roleUnprocessed : roleUnprocessed.substring(3, roleUnprocessed.length - 1)
            );

            if (!role) {
                await this.deferredReply(message, {
                    content: `${this.emoji("error")} Could not find role: ${roleUnprocessed}`,
                    allowedMentions: {
                        roles: []
                    }
                });

                return;
            }

            roles.push(role.id);
            roleNames.push(role.name);
        }

        const emoji: string = context.isLegacy ? context.parsedNamedArgs.emoji : context.options.getString("emoji", true);
        const parsed = parseEmoji(emoji);
        const emojiIdOrName = parsed?.id ?? parsed?.name ?? emoji;

        const channel = await safeChannelFetch(message.guild!, channelId);

        if (!channel) {
            await this.error(message, "Could not find the channel of the message!");
            return;
        }

        const targetMessage = await safeMessageFetch(channel as TextBasedChannel, messageId);

        if (!targetMessage) {
            await this.error(message, "Could not find the target message!");
            return;
        }

        try {
            await targetMessage.react(emoji);
        } catch (e) {
            logError(e);
            await this.error(message, "Invalid emoji given!");
            return;
        }

        await this.client.reactionRoleService.createReactionRole({
            channelId,
            emoji: emojiIdOrName,
            guildId,
            messageId,
            roles,
            mode
        });

        await this.success(
            message,
            `Successfully added reaction role. Reacting with the given emoji will give the user these roles:\n\n\`${roleNames.join(
                "`\n* `"
            )}\``
        );
    }
}
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2023 OSN Developers.
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 { PermissionFlagsBits, SlashCommandBuilder, Snowflake, TextBasedChannel, parseEmoji } from "discord.js";
21	import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
22	import { safeChannelFetch, safeMessageFetch, safeRoleFetch } from "../../utils/fetch";
23	import { logError } from "../../utils/logger";
24	import { isSnowflake } from "../../utils/utils";
25
26	export default class CreateReactionRoleCommand extends Command {
27	public readonly name = "createreactionrole";
28	public readonly validationRules: ValidationRule[] = [
29	{
30	types: [ArgumentType.String],
31	name: "link",
32	requiredErrorMessage: "Please provide a target message link!",
33	typeErrorMessage: "Please provide a __valid__ message link!"
34	},
35	{
36	types: [ArgumentType.String],
37	name: "emoji",
38	requiredErrorMessage: "Please provide a trigger emoji!",
39	typeErrorMessage: "Please provide a __valid__ emoji!"
40	},
41	{
42	types: [ArgumentType.StringRest],
43	name: "roles",
44	requiredErrorMessage: "Please provide at least one role!",
45	typeErrorMessage: "Please provide __valid__ roles!"
46	}
47	];
48	public readonly permissions = [PermissionFlagsBits.ManageRoles];
49	public readonly aliases = ["createreactrole", "makereactrole", "makerr", "createrr"];
50	public readonly description = "Adds a reaction role listener to the given message.";
51	public readonly detailedDescription =
52	"Adds a reaction listener to the message, and when a user reacts with the given emoji, it will assign the given role(s).";
53	public readonly slashCommandBuilder = new SlashCommandBuilder()
54	.addStringOption(option => option.setName("message_link").setDescription("The target message link").setRequired(true))
55	.addStringOption(option => option.setName("emoji").setDescription("The trigger emoji").setRequired(true))
56	.addStringOption(option =>
57	option
58	.setName("roles")
59	.setDescription("The role(s) to assign, when a user reacts with the given emoji")
60	.setRequired(true)
61	)
62	.addStringOption(option =>
63	option.setName("mode").setDescription("The behaviour of the reaction role trigger").setChoices(
64	{
65	name: "Single and unique role",
66	value: "SINGLE"
67	},
68	{
69	name: "Multiple (Default)",
70	value: "MULTIPLE"
71	}
72	)
73	);
74
75	async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
76	await this.deferIfInteraction(message);
77
78	const link: string = context.isLegacy ? context.parsedNamedArgs.link : context.options.getString("message_link", true);
79	const mode = (context.isLegacy ? null : (context.options.getString("mode") as "SINGLE" \| "MULTIPLE")) ?? "MULTIPLE";
80
81	if (!/^https?:\/\/(canary\.\|ptb\.\|beta\.\|www\.\|)discord\.com\/channels\/\d+\/\d+\/\d+$/i.test(link.trim())) {
82	await this.error(message, this.validationRules[0].typeErrorMessage);
83	return;
84	}
85
86	const [messageId, channelId, guildId] = link
87	.substring(0, link[link.length - 1] === "/" ? link.length - 1 : link.length)
88	.split("/")
89	.reverse();
90
91	if (guildId !== message.guildId!) {
92	await this.error(message, "That's a message link from another server!");
93	return;
94	}
95
96	const rolesUnprocessed: string = (
97	context.isLegacy ? context.parsedNamedArgs.roles : context.options.getString("roles", true)
98	).split(/\s+/);
99
100	if (rolesUnprocessed.length > 7) {
101	await this.error(message, "Cannot add more than 7 roles to a single emoji trigger!");
102	return;
103	}
104
105	const roles: Snowflake[] = [];
106	const roleNames: string[] = [];
107
108	for (const roleUnprocessed of rolesUnprocessed) {
109	const isId = isSnowflake(roleUnprocessed);
110	const isMention = roleUnprocessed.startsWith("<@&") && roleUnprocessed.endsWith(">");
111
112	if (!isId && !isMention) {
113	await this.deferredReply(message, {
114	content: `${this.emoji("error")} Invalid role: ${roleUnprocessed}`,
115	allowedMentions: {
116	roles: []
117	}
118	});
119
120	return;
121	}
122
123	const role = await safeRoleFetch(
124	message.guild!,
125	isId ? roleUnprocessed : roleUnprocessed.substring(3, roleUnprocessed.length - 1)
126	);
127
128	if (!role) {
129	await this.deferredReply(message, {
130	content: `${this.emoji("error")} Could not find role: ${roleUnprocessed}`,
131	allowedMentions: {
132	roles: []
133	}
134	});
135
136	return;
137	}
138
139	roles.push(role.id);
140	roleNames.push(role.name);
141	}
142
143	const emoji: string = context.isLegacy ? context.parsedNamedArgs.emoji : context.options.getString("emoji", true);
144	const parsed = parseEmoji(emoji);
145	const emojiIdOrName = parsed?.id ?? parsed?.name ?? emoji;
146
147	const channel = await safeChannelFetch(message.guild!, channelId);
148
149	if (!channel) {
150	await this.error(message, "Could not find the channel of the message!");
151	return;
152	}
153
154	const targetMessage = await safeMessageFetch(channel as TextBasedChannel, messageId);
155
156	if (!targetMessage) {
157	await this.error(message, "Could not find the target message!");
158	return;
159	}
160
161	try {
162	await targetMessage.react(emoji);
163	} catch (e) {
164	logError(e);
165	await this.error(message, "Invalid emoji given!");
166	return;
167	}
168
169	await this.client.reactionRoleService.createReactionRole({
170	channelId,
171	emoji: emojiIdOrName,
172	guildId,
173	messageId,
174	roles,
175	mode
176	});
177
178	await this.success(
179	message,
180	`Successfully added reaction role. Reacting with the given emoji will give the user these roles:\n\n\`${roleNames.join(
181	"`\n* `"
182	)}\``
183	);
184	}
185	}