src/services/QuickMuteService.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 { ChannelType, GuildMember, MessageReaction, PartialMessageReaction, PartialUser, TextChannel, User } from "discord.js";
import Service from "../core/Service";
import { GatewayEventListener } from "../decorators/GatewayEventListener";
import { HasEventListeners } from "../types/HasEventListeners";
import { log, logError, logInfo, logWarn } from "../utils/logger";

export const name = "quickmute";

export default class QuickMuteService extends Service implements HasEventListeners {
    @GatewayEventListener("messageReactionAdd")
    async onMessageReactionAdd(reaction: MessageReaction | PartialMessageReaction, user: User | PartialUser) {
        if (!reaction || !reaction.message.guild || reaction.message.channel.type === ChannelType.DM) {
            return;
        }

        const result = await this.handle(reaction, user);

        if (result === false) {
            await reaction.remove().catch(logError);
        }
    }

    async handle(reaction: MessageReaction | PartialMessageReaction, user: User | PartialUser) {
        log("Reaction");

        const config = this.client.configManager.config[reaction.message.guildId!]?.quickmute;

        log(config);

        if (!config?.enabled || !config?.clear_emoji || !config?.noclear_emoji) {
            return;
        }

        log("Reaction 2");

        if (
            reaction.emoji.id !== config.clear_emoji &&
            reaction.emoji.identifier !== config.clear_emoji &&
            reaction.emoji.id !== config.noclear_emoji &&
            reaction.emoji.identifier !== config.noclear_emoji
        ) {
            return;
        }

        logInfo("Quickmute trigger reaction receieved.");

        const clearMessages = reaction.emoji.id === config.clear_emoji || reaction.emoji.identifier === config.clear_emoji;
        const guild = this.client.guilds.cache.get(reaction.message.guildId!);

        if (!guild) {
            logWarn("Could not resolve guild");
            return;
        }

        if (reaction.message.author!.id === this.client.user!.id) {
            log("Cannot mute the bot itself");
            return false;
        }

        let moderator: GuildMember | undefined = undefined;

        try {
            moderator = guild.members.cache.get(user.id) ?? (await guild.members.fetch(user.id));
        } catch (e) {
            logError(e);
            return;
        }

        if (!moderator) {
            return;
        }

        const { permissions } = await this.client.permissionManager.getMemberPermissions(moderator, true);

        if (!permissions.has("Administrator") && !permissions.has("ManageMessages") && !permissions.has("ModerateMembers")) {
            logInfo("This moderator does not have permission to use quickmute!");
            return false;
        }

        const member = reaction.message.member!;

        if (!(await this.client.permissionManager.shouldModerate(member, moderator))) {
            logInfo("This moderator does not have permission to mute this user!");
            return false;
        }

        await this.client.infractionManager.createMemberMute(member, {
            guild,
            moderator: user as User,
            autoRemoveQueue: true,
            bulkDeleteReason: clearMessages
                ? "Clearing recent messages from user, because the quickmute trigger was used."
                : undefined,
            duration: config.duration ?? 1000 * 60 * 60 * 2,
            messageChannel: clearMessages ? (reaction.message.channel! as TextChannel) : undefined,
            notifyUser: true,
            sendLog: true,
            reason:
                config.reason ??
                "You have violated the rules or guidelines of the server. Please take a break, and come back later."
        });

        if (!clearMessages) {
            await reaction.remove().catch(logError);
        }

        return true;
    }
}
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 { ChannelType, GuildMember, MessageReaction, PartialMessageReaction, PartialUser, TextChannel, User } from "discord.js";
21			import Service from "../core/Service";
22			import { GatewayEventListener } from "../decorators/GatewayEventListener";
23			import { HasEventListeners } from "../types/HasEventListeners";
24			import { log, logError, logInfo, logWarn } from "../utils/logger";
25
26			export const name = "quickmute";
27
28			export default class QuickMuteService extends Service implements HasEventListeners {
29			@GatewayEventListener("messageReactionAdd")
30			async onMessageReactionAdd(reaction: MessageReaction \| PartialMessageReaction, user: User \| PartialUser) {
31			if (!reaction \|\| !reaction.message.guild \|\| reaction.message.channel.type === ChannelType.DM) {
32			return;
33			}
34
35			const result = await this.handle(reaction, user);
36
37			if (result === false) {
38			await reaction.remove().catch(logError);
39			}
40			}
41
42			async handle(reaction: MessageReaction \| PartialMessageReaction, user: User \| PartialUser) {
43			log("Reaction");
44
45			const config = this.client.configManager.config[reaction.message.guildId!]?.quickmute;
46
47			log(config);
48
49			if (!config?.enabled \|\| !config?.clear_emoji \|\| !config?.noclear_emoji) {
50			return;
51			}
52
53			log("Reaction 2");
54
55			if (
56			reaction.emoji.id !== config.clear_emoji &&
57			reaction.emoji.identifier !== config.clear_emoji &&
58			reaction.emoji.id !== config.noclear_emoji &&
59			reaction.emoji.identifier !== config.noclear_emoji
60			) {
61			return;
62			}
63
64			logInfo("Quickmute trigger reaction receieved.");
65
66			const clearMessages = reaction.emoji.id === config.clear_emoji \|\| reaction.emoji.identifier === config.clear_emoji;
67			const guild = this.client.guilds.cache.get(reaction.message.guildId!);
68
69			if (!guild) {
70			logWarn("Could not resolve guild");
71			return;
72			}
73
74			if (reaction.message.author!.id === this.client.user!.id) {
75			log("Cannot mute the bot itself");
76			return false;
77			}
78
79			let moderator: GuildMember \| undefined = undefined;
80
81			try {
82			moderator = guild.members.cache.get(user.id) ?? (await guild.members.fetch(user.id));
83			} catch (e) {
84			logError(e);
85			return;
86			}
87
88			if (!moderator) {
89			return;
90			}
91
92			const { permissions } = await this.client.permissionManager.getMemberPermissions(moderator, true);
93
94			if (!permissions.has("Administrator") && !permissions.has("ManageMessages") && !permissions.has("ModerateMembers")) {
95			logInfo("This moderator does not have permission to use quickmute!");
96			return false;
97			}
98
99			const member = reaction.message.member!;
100
101			if (!(await this.client.permissionManager.shouldModerate(member, moderator))) {
102			logInfo("This moderator does not have permission to mute this user!");
103			return false;
104			}
105
106			await this.client.infractionManager.createMemberMute(member, {
107			guild,
108			moderator: user as User,
109			autoRemoveQueue: true,
110			bulkDeleteReason: clearMessages
111			? "Clearing recent messages from user, because the quickmute trigger was used."
112			: undefined,
113			duration: config.duration ?? 1000 * 60 * 60 * 2,
114			messageChannel: clearMessages ? (reaction.message.channel! as TextChannel) : undefined,
115			notifyUser: true,
116			sendLog: true,
117			reason:
118			config.reason ??
119			"You have violated the rules or guidelines of the server. Please take a break, and come back later."
120			});
121
122			if (!clearMessages) {
123			await reaction.remove().catch(logError);
124			}
125
126			return true;
127			}
128			}