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	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			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			}