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	rakinar2	577	/**
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			}