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