src/services/ReactionRoleService.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 { ReactionRole } from "@prisma/client";
import { Client, GuildMember, PermissionsString, Routes, Snowflake } from "discord.js";
import Service from "../core/Service";
import { GatewayEventListener } from "../decorators/GatewayEventListener";
import { HasEventListeners } from "../types/HasEventListeners";
import { safeMemberFetch } from "../utils/fetch";
import { log, logError } from "../utils/logger";

export const name = "reactionRoleService";

interface UserRequestInfo {
    timestamps: number[];
    timeout?: NodeJS.Timeout;
}

export default class ReactionRoleService extends Service implements HasEventListeners {
    readonly reactionRoleEntries = new Map<string, ReactionRole | undefined>();
    readonly users: Record<string, UserRequestInfo> = {};
    readonly rateLimited = new Map<string, number>();

    @GatewayEventListener("ready")
    async onReady(client: Client<true>) {
        log("Syncing reaction roles...");

        const reactionRoles = await this.client.prisma.reactionRole.findMany({
            where: {
                guildId: {
                    in: [...client.guilds.cache.keys()]
                }
            }
        });

        for (const reactionRole of reactionRoles) {
            this.reactionRoleEntries.set(
                `${reactionRole.guildId}_${reactionRole.channelId}_${reactionRole.messageId}_${reactionRole.emoji}`,
                reactionRole
            );
        }

        log("Successfully synced reaction roles");
    }

    @GatewayEventListener("raw")
    async onRaw(data: any) {
        if (data.t !== "MESSAGE_REACTION_ADD" && data.t !== "MESSAGE_REACTION_REMOVE") {
            return;
        }

        if (!this.client.configManager.config[data.d.guild_id]?.reaction_roles?.enabled) {
            return;
        }

        log(JSON.stringify(data, null, 2));

        const config = this.client.configManager.config[data.d.guild_id]?.reaction_roles?.ratelimiting;

        if (config?.enabled) {
            const rateLimitedAt = this.rateLimited.get(data.d.user_id) ?? 0;

            if (Date.now() - rateLimitedAt < config.block_duration) {
                log("The user has hit a ratelimit.");
                return;
            }

            this.rateLimited.delete(data.d.user_id);

            if (!this.users[data.d.user_id]) {
                this.users[data.d.user_id] = {
                    timestamps: []
                };
            }

            const info = this.users[data.d.user_id];

            info.timestamps.push(Date.now());
        }

        const { aborted, member, reactionRole } = await this.processRequest(data, data.t === "MESSAGE_REACTION_ADD");

        if (aborted) {
            log("Request aborted");
            this.setTimeout(data.d.user_id, data.d.guild_id);
            return;
        }

        try {
            if (data.t === "MESSAGE_REACTION_ADD") {
                await member?.roles.add(reactionRole!.roles, "Adding reaction roles");
            } else {
                await member?.roles.remove(reactionRole!.roles, "Removing reaction roles");
            }
        } catch (e) {
            logError(e);
        }

        this.setTimeout(data.d.user_id, data.d.guild_id);
    }

    setTimeout(userId: string, guildId: string) {
        if (!this.users[userId]) {
            return;
        }

        this.users[userId].timeout ??= setTimeout(() => {
            const config = this.client.configManager.config[guildId]?.reaction_roles?.ratelimiting;

            if (config?.enabled) {
                const delayedInfo = this.users[userId];
                const timestamps = delayedInfo.timestamps.filter(timestamp => config.timeframe + timestamp >= Date.now());

                if (timestamps.length >= config.max_attempts) {
                    this.rateLimited.set(userId, Date.now());
                }
            }

            delete this.users[userId];
        }, 9000);
    }

    async processRequest(
        data: any,
        permissionChecks = true
    ): Promise<{
        aborted: boolean;
        reactionRole?: ReactionRole;
        member?: GuildMember;
        removedPreviousRoles?: boolean;
    }> {
        const emoji = data.d.emoji;
        const userId = data.d.user_id;
        const messageId = data.d.message_id;
        const channelId = data.d.channel_id;
        const guildId = data.d.guild_id;
        const isReactionAddEvent = data.t === "MESSAGE_REACTION_ADD";

        if (userId === this.client.user?.id) {
            return { aborted: true };
        }

        if (!guildId) {
            return { aborted: true };
        }

        const config = this.client.configManager.config[guildId]?.reaction_roles;

        if (!config?.enabled || (config.ignore_bots && data.d.member?.user?.bot)) {
            return { aborted: true };
        }

        const entry = this.reactionRoleEntries.get(`${guildId}_${channelId}_${messageId!}_${emoji.id ?? emoji.name}`);

        if (!entry) {
            log("Reaction role entry not found, ignoring");
            return { aborted: true };
        }

        if (entry.roles.length === 0) {
            log("No role to add/remove");
            return { aborted: true };
        }

        const guild = this.client.guilds.cache.get(guildId);

        if (!guild) {
            return { aborted: true };
        }

        const member = await safeMemberFetch(guild, userId);

        if (!member) {
            return { aborted: true };
        }

        if (config.ignore_bots && member.user.bot) {
            return { aborted: true };
        }

        if (permissionChecks) {
            if (!member.roles.cache.hasAll(...entry.requiredRoles)) {
                log("Member does not have the required roles");
                return await this.removeReactionAndAbort(data);
            }

            if (!member.permissions.has("Administrator") && entry.blacklistedUsers.includes(member.user.id)) {
                log("User is blacklisted");
                return await this.removeReactionAndAbort(data);
            }

            if (!member.permissions.has(entry.requiredPermissions as PermissionsString[], true)) {
                log("Member does not have the required permissions");
                return await this.removeReactionAndAbort(data);
            }

            if (this.client.permissionManager.usesLevelBasedMode(member.guild.id) && entry.level) {
                const level = (await this.client.permissionManager.getManager(member.guild.id)).getPermissionLevel(member);

                if (level < entry.level) {
                    log("Member does not have the required permission level");
                    return await this.removeReactionAndAbort(data);
                }
            }
        }

        let removedPreviousRoles = false;
        const reactionsToRemove = [];

        if (entry?.single && isReactionAddEvent) {
            for (const value of this.reactionRoleEntries.values()) {
                if (
                    value?.guildId === guildId &&
                    value?.channelId === channelId &&
                    value?.messageId === messageId &&
                    member.roles.cache.hasAny(...value!.roles)
                ) {
                    await member.roles.remove(value!.roles, "Taking out the previous roles").catch(logError);
                    removedPreviousRoles = !removedPreviousRoles ? true : removedPreviousRoles;

                    if (reactionsToRemove.length <= 4) {
                        reactionsToRemove.push(`${value?.emoji}`);
                    }
                }
            }
        }

        if (removedPreviousRoles && reactionsToRemove.length > 0 && reactionsToRemove.length <= 4) {
            log(reactionsToRemove);

            for (const reaction of reactionsToRemove) {
                const isBuiltIn = !/^\d+$/.test(reaction);
                const emoji = !isBuiltIn
                    ? this.client.emojis.cache.find(e => e.id === reaction || e.identifier === reaction)
                    : null;

                if (!isBuiltIn && !emoji) {
                    continue;
                }

                this.removeReactionAndAbort({
                    ...data,
                    d: {
                        ...data.d,
                        emoji: isBuiltIn
                            ? reaction
                            : {
                                  id: emoji!.id,
                                  name: emoji!.name
                              }
                    }
                }).catch(logError);
            }
        }

        return { aborted: false, member, reactionRole: entry, removedPreviousRoles };
    }

    async removeReactionAndAbort(data: any) {
        await this.client.rest
            .delete(
                Routes.channelMessageUserReaction(
                    data.d.channel_id,
                    data.d.message_id,
                    data.d.emoji.id && data.d.emoji.name
                        ? `${data.d.emoji.name}:${data.d.emoji.id}`
                        : encodeURIComponent(data.d.emoji.name),
                    data.d.user_id
                )
            )
            .catch(logError);

        return { aborted: true };
    }

    async createReactionRole({
        channelId,
        messageId,
        guildId,
        emoji,
        roles,
        mode = "MULTIPLE"
    }: {
        channelId: Snowflake;
        messageId: Snowflake;
        guildId: Snowflake;
        emoji: string;
        roles: Snowflake[];
        mode?: "SINGLE" | "MULTIPLE";
    }) {
        const reactionRole = await this.client.prisma.reactionRole.create({
            data: {
                channelId,
                guildId,
                messageId,
                isBuiltInEmoji: !/^\d+$/.test(emoji),
                emoji,
                roles,
                single: mode === "SINGLE"
            }
        });

        this.reactionRoleEntries.set(
            `${reactionRole.guildId}_${reactionRole.channelId}_${reactionRole.messageId}_${reactionRole.emoji}`,
            reactionRole
        );

        return reactionRole;
    }
}
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 { ReactionRole } from "@prisma/client";
21	import { Client, GuildMember, PermissionsString, Routes, Snowflake } from "discord.js";
22	import Service from "../core/Service";
23	import { GatewayEventListener } from "../decorators/GatewayEventListener";
24	import { HasEventListeners } from "../types/HasEventListeners";
25	import { safeMemberFetch } from "../utils/fetch";
26	import { log, logError } from "../utils/logger";
27
28	export const name = "reactionRoleService";
29
30	interface UserRequestInfo {
31	timestamps: number[];
32	timeout?: NodeJS.Timeout;
33	}
34
35	export default class ReactionRoleService extends Service implements HasEventListeners {
36	readonly reactionRoleEntries = new Map<string, ReactionRole \| undefined>();
37	readonly users: Record<string, UserRequestInfo> = {};
38	readonly rateLimited = new Map<string, number>();
39
40	@GatewayEventListener("ready")
41	async onReady(client: Client<true>) {
42	log("Syncing reaction roles...");
43
44	const reactionRoles = await this.client.prisma.reactionRole.findMany({
45	where: {
46	guildId: {
47	in: [...client.guilds.cache.keys()]
48	}
49	}
50	});
51
52	for (const reactionRole of reactionRoles) {
53	this.reactionRoleEntries.set(
54	`${reactionRole.guildId}_${reactionRole.channelId}_${reactionRole.messageId}_${reactionRole.emoji}`,
55	reactionRole
56	);
57	}
58
59	log("Successfully synced reaction roles");
60	}
61
62	@GatewayEventListener("raw")
63	async onRaw(data: any) {
64	if (data.t !== "MESSAGE_REACTION_ADD" && data.t !== "MESSAGE_REACTION_REMOVE") {
65	return;
66	}
67
68	if (!this.client.configManager.config[data.d.guild_id]?.reaction_roles?.enabled) {
69	return;
70	}
71
72	log(JSON.stringify(data, null, 2));
73
74	const config = this.client.configManager.config[data.d.guild_id]?.reaction_roles?.ratelimiting;
75
76	if (config?.enabled) {
77	const rateLimitedAt = this.rateLimited.get(data.d.user_id) ?? 0;
78
79	if (Date.now() - rateLimitedAt < config.block_duration) {
80	log("The user has hit a ratelimit.");
81	return;
82	}
83
84	this.rateLimited.delete(data.d.user_id);
85
86	if (!this.users[data.d.user_id]) {
87	this.users[data.d.user_id] = {
88	timestamps: []
89	};
90	}
91
92	const info = this.users[data.d.user_id];
93
94	info.timestamps.push(Date.now());
95	}
96
97	const { aborted, member, reactionRole } = await this.processRequest(data, data.t === "MESSAGE_REACTION_ADD");
98
99	if (aborted) {
100	log("Request aborted");
101	this.setTimeout(data.d.user_id, data.d.guild_id);
102	return;
103	}
104
105	try {
106	if (data.t === "MESSAGE_REACTION_ADD") {
107	await member?.roles.add(reactionRole!.roles, "Adding reaction roles");
108	} else {
109	await member?.roles.remove(reactionRole!.roles, "Removing reaction roles");
110	}
111	} catch (e) {
112	logError(e);
113	}
114
115	this.setTimeout(data.d.user_id, data.d.guild_id);
116	}
117
118	setTimeout(userId: string, guildId: string) {
119	if (!this.users[userId]) {
120	return;
121	}
122
123	this.users[userId].timeout ??= setTimeout(() => {
124	const config = this.client.configManager.config[guildId]?.reaction_roles?.ratelimiting;
125
126	if (config?.enabled) {
127	const delayedInfo = this.users[userId];
128	const timestamps = delayedInfo.timestamps.filter(timestamp => config.timeframe + timestamp >= Date.now());
129
130	if (timestamps.length >= config.max_attempts) {
131	this.rateLimited.set(userId, Date.now());
132	}
133	}
134
135	delete this.users[userId];
136	}, 9000);
137	}
138
139	async processRequest(
140	data: any,
141	permissionChecks = true
142	): Promise<{
143	aborted: boolean;
144	reactionRole?: ReactionRole;
145	member?: GuildMember;
146	removedPreviousRoles?: boolean;
147	}> {
148	const emoji = data.d.emoji;
149	const userId = data.d.user_id;
150	const messageId = data.d.message_id;
151	const channelId = data.d.channel_id;
152	const guildId = data.d.guild_id;
153	const isReactionAddEvent = data.t === "MESSAGE_REACTION_ADD";
154
155	if (userId === this.client.user?.id) {
156	return { aborted: true };
157	}
158
159	if (!guildId) {
160	return { aborted: true };
161	}
162
163	const config = this.client.configManager.config[guildId]?.reaction_roles;
164
165	if (!config?.enabled \|\| (config.ignore_bots && data.d.member?.user?.bot)) {
166	return { aborted: true };
167	}
168
169	const entry = this.reactionRoleEntries.get(`${guildId}_${channelId}_${messageId!}_${emoji.id ?? emoji.name}`);
170
171	if (!entry) {
172	log("Reaction role entry not found, ignoring");
173	return { aborted: true };
174	}
175
176	if (entry.roles.length === 0) {
177	log("No role to add/remove");
178	return { aborted: true };
179	}
180
181	const guild = this.client.guilds.cache.get(guildId);
182
183	if (!guild) {
184	return { aborted: true };
185	}
186
187	const member = await safeMemberFetch(guild, userId);
188
189	if (!member) {
190	return { aborted: true };
191	}
192
193	if (config.ignore_bots && member.user.bot) {
194	return { aborted: true };
195	}
196
197	if (permissionChecks) {
198	if (!member.roles.cache.hasAll(...entry.requiredRoles)) {
199	log("Member does not have the required roles");
200	return await this.removeReactionAndAbort(data);
201	}
202
203	if (!member.permissions.has("Administrator") && entry.blacklistedUsers.includes(member.user.id)) {
204	log("User is blacklisted");
205	return await this.removeReactionAndAbort(data);
206	}
207
208	if (!member.permissions.has(entry.requiredPermissions as PermissionsString[], true)) {
209	log("Member does not have the required permissions");
210	return await this.removeReactionAndAbort(data);
211	}
212
213	if (this.client.permissionManager.usesLevelBasedMode(member.guild.id) && entry.level) {
214	const level = (await this.client.permissionManager.getManager(member.guild.id)).getPermissionLevel(member);
215
216	if (level < entry.level) {
217	log("Member does not have the required permission level");
218	return await this.removeReactionAndAbort(data);
219	}
220	}
221	}
222
223	let removedPreviousRoles = false;
224	const reactionsToRemove = [];
225
226	if (entry?.single && isReactionAddEvent) {
227	for (const value of this.reactionRoleEntries.values()) {
228	if (
229	value?.guildId === guildId &&
230	value?.channelId === channelId &&
231	value?.messageId === messageId &&
232	member.roles.cache.hasAny(...value!.roles)
233	) {
234	await member.roles.remove(value!.roles, "Taking out the previous roles").catch(logError);
235	removedPreviousRoles = !removedPreviousRoles ? true : removedPreviousRoles;
236
237	if (reactionsToRemove.length <= 4) {
238	reactionsToRemove.push(`${value?.emoji}`);
239	}
240	}
241	}
242	}
243
244	if (removedPreviousRoles && reactionsToRemove.length > 0 && reactionsToRemove.length <= 4) {
245	log(reactionsToRemove);
246
247	for (const reaction of reactionsToRemove) {
248	const isBuiltIn = !/^\d+$/.test(reaction);
249	const emoji = !isBuiltIn
250	? this.client.emojis.cache.find(e => e.id === reaction \|\| e.identifier === reaction)
251	: null;
252
253	if (!isBuiltIn && !emoji) {
254	continue;
255	}
256
257	this.removeReactionAndAbort({
258	...data,
259	d: {
260	...data.d,
261	emoji: isBuiltIn
262	? reaction
263	: {
264	id: emoji!.id,
265	name: emoji!.name
266	}
267	}
268	}).catch(logError);
269	}
270	}
271
272	return { aborted: false, member, reactionRole: entry, removedPreviousRoles };
273	}
274
275	async removeReactionAndAbort(data: any) {
276	await this.client.rest
277	.delete(
278	Routes.channelMessageUserReaction(
279	data.d.channel_id,
280	data.d.message_id,
281	data.d.emoji.id && data.d.emoji.name
282	? `${data.d.emoji.name}:${data.d.emoji.id}`
283	: encodeURIComponent(data.d.emoji.name),
284	data.d.user_id
285	)
286	)
287	.catch(logError);
288
289	return { aborted: true };
290	}
291
292	async createReactionRole({
293	channelId,
294	messageId,
295	guildId,
296	emoji,
297	roles,
298	mode = "MULTIPLE"
299	}: {
300	channelId: Snowflake;
301	messageId: Snowflake;
302	guildId: Snowflake;
303	emoji: string;
304	roles: Snowflake[];
305	mode?: "SINGLE" \| "MULTIPLE";
306	}) {
307	const reactionRole = await this.client.prisma.reactionRole.create({
308	data: {
309	channelId,
310	guildId,
311	messageId,
312	isBuiltInEmoji: !/^\d+$/.test(emoji),
313	emoji,
314	roles,
315	single: mode === "SINGLE"
316	}
317	});
318
319	this.reactionRoleEntries.set(
320	`${reactionRole.guildId}_${reactionRole.channelId}_${reactionRole.messageId}_${reactionRole.emoji}`,
321	reactionRole
322	);
323
324	return reactionRole;
325	}
326	}