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";

export default class ReactionRoleService extends Service implements HasEventListeners {
    readonly reactionRoleEntries = new Map<string, ReactionRole | undefined>();
    readonly usersInProgress = new Set<Snowflake>();

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

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

        if (this.usersInProgress.has(data.d.user_id)) {
            log("The user has hit a ratelimit.");
            return;
        }

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

        if (aborted) {
            log("Request aborted");
            setTimeout(() => this.usersInProgress.delete(data.d.user_id), 1500);
            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);
        }

        setTimeout(() => this.usersInProgress.delete(data.d.user_id), 1500);
    }

    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;
        const usesLevels = this.client.configManager.config[guildId]?.permissions.mode === "levels";

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