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 { log, logError } from "../utils/Logger";
import { safeMemberFetch } from "../utils/fetch";

export const name = "reactionRoleService";

interface UserRequestInfo {
    timestamps: number[];
    timeout?: Timer;
}

type RawMessageReactionData = {
    t: "MESSAGE_REACTION_ADD" | "MESSAGE_REACTION_REMOVE";
    d: {
        user_id: string;
        message_id: string;
        channel_id: string;
        guild_id: string;
        emoji: {
            name: string;
            id?: string;
        };
        member?: {
            user: {
                bot: boolean;
            };
        };
    };
};

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: RawMessageReactionData) {
        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: RawMessageReactionData,
        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
                              }) as RawMessageReactionData["d"]["emoji"]
                    }
                }).catch(logError);
            }
        }

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

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