src/services/AFKService.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 { AfkEntry } from "@prisma/client";
import { formatDistanceToNowStrict } from "date-fns";
import { ChannelType, GuildMember, Message, Snowflake, escapeMarkdown, time } from "discord.js";
import Service from "../core/Service";
import { GatewayEventListener } from "../decorators/GatewayEventListener";
import { HasEventListeners } from "../types/HasEventListeners";
import { log, logError } from "../utils/logger";

export const name = "afkService";

export default class AFKService extends Service implements HasEventListeners {
    protected readonly entries = new Map<Snowflake, AfkEntry>();
    protected readonly syncTimeoutDelay = 15_000;
    protected syncTimeout: NodeJS.Timeout | null = null;
    protected readonly modifiedIds = new Set<string>();

    @GatewayEventListener("ready")
    async onReady() {
        const entries = await this.client.prisma.afkEntry.findMany();

        for (const entry of entries) {
            this.entries.set(`${entry.guildId}_${entry.userId}`, entry);
        }
    }

    isAFK(guildId: string, userId: string) {
        return this.entries.has(`${guildId}_${userId}`);
    }

    toggle(guildId: string, userId: string, reason?: string) {
        if (this.isAFK(guildId, userId)) {
            return this.removeAFK(guildId, userId);
        }

        return this.startAFK(guildId, userId, reason);
    }

    async removeAFK(guildId: string, userId: string, shouldAwait: boolean = true) {
        const entry = this.entries.get(`${guildId}_${userId}`)!;

        if (!entry) {
            return null;
        }

        const promise = this.client.prisma.afkEntry.deleteMany({
            where: {
                id: entry.id
            }
        });

        shouldAwait ? await promise : promise.then(log);

        this.entries.delete(`${guildId}_${userId}`);
        return entry;
    }

    async startAFK(guildId: string, userId: string, reason?: string) {
        const entry = await this.client.prisma.afkEntry.create({
            data: {
                guildId,
                userId,
                reason
            }
        });

        this.entries.set(`${guildId}_${userId}`, entry);
        return entry;
    }

    addMentions(guildId: string, userId: string, mentions: { userId: Snowflake; messageLink: string }[]) {
        if (!this.isAFK(guildId, userId)) {
            return false;
        }

        const entry = this.entries.get(`${guildId}_${userId}`)!;

        if (entry.mentions.length >= 10) {
            return false;
        }

        entry.mentions.push(...mentions.map(m => `${m.userId}__${m.messageLink}__${new Date().toISOString()}`));
        this.modifiedIds.add(`${guildId}_${userId}`);
        this.queueSync();

        return true;
    }

    queueSync() {
        this.syncTimeout ??= setTimeout(() => {
            for (const guildId_UserId of this.modifiedIds) {
                const entry = this.entries.get(guildId_UserId);

                if (!entry) {
                    continue;
                }

                this.client.prisma.afkEntry.updateMany({
                    where: {
                        id: entry.id
                    },
                    data: entry
                });
            }
        }, this.syncTimeoutDelay);
    }

    @GatewayEventListener("messageCreate")
    async onMessageCreate(message: Message<boolean>) {
        if (message.author.bot || !message.guild || message.channel.type === ChannelType.DM) {
            return;
        }

        if (this.isAFK(message.guildId!, message.author.id)) {
            const entry = await this.removeAFK(message.guildId!, message.author.id, false);

            await message.reply({
                embeds: [
                    {
                        color: 0x007bff,
                        description: this.client.afkService.generateAFKEndMessage(entry)
                    }
                ],
                allowedMentions: {
                    users: []
                }
            });
        }

        if (message.mentions.users.size === 0) {
            return;
        }

        let description = "";
        const users = message.mentions.users.filter(user => this.isAFK(message.guildId!, user.id));

        if (users.size === 0) {
            return;
        }

        for (const [id] of users) {
            this.addMentions(message.guildId!, id, [
                {
                    messageLink: message.url,
                    userId: message.author.id
                }
            ]);
        }

        if (users.size === 1) {
            const entry = this.entries.get(`${message.guildId!}_${users.at(0)!.id}`);
            description = `<@${users.at(0)!.id}> is AFK right now${
                entry?.reason ? `, for reason: **${escapeMarkdown(entry?.reason)}**` : ""
            }.`;
        } else {
            description = "The following users are AFK right now: \n\n";

            for (const [id] of users) {
                if (this.isAFK(message.guildId!, id)) {
                    const entry = this.entries.get(`${message.guildId!}_${id}`);
                    description += `* <@${id}>: ${entry?.reason ?? "*No reason provided*"} ${
                        entry?.createdAt ? `(${time(entry?.createdAt!)})` : ""
                    }\n`;
                }
            }
        }

        if (description.trim() === "") {
            return;
        }

        message
            .reply({
                embeds: [
                    {
                        color: 0x007bff,
                        description
                    }
                ],
                allowedMentions: {
                    users: []
                }
            })
            .catch(logError);
    }

    @GatewayEventListener("guildMemberRemove")
    onGuildMemberRemove(member: GuildMember) {
        if (this.isAFK(member.guild.id, member.user.id)) {
            this.removeAFK(member.guild.id, member.user.id).catch(logError);
        }
    }

    generateAFKEndMessage(entry: AfkEntry | null | undefined) {
        return (
            `You're no longer AFK. You had **${entry?.mentions.length ?? 0}** mentions in this server.` +
            (entry?.mentions?.length
                ? "\n\n" +
                  entry.mentions
                      .map(data => {
                          const [userId, messageLink, dateISO] = data.split("__");
                          return `From <@${userId}>, ${formatDistanceToNowStrict(new Date(dateISO), {
                              addSuffix: true
                          })} [Navigate](${messageLink})`;
                      })
                      .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 { AfkEntry } from "@prisma/client";
21			import { formatDistanceToNowStrict } from "date-fns";
22			import { ChannelType, GuildMember, Message, Snowflake, escapeMarkdown, time } from "discord.js";
23			import Service from "../core/Service";
24			import { GatewayEventListener } from "../decorators/GatewayEventListener";
25			import { HasEventListeners } from "../types/HasEventListeners";
26			import { log, logError } from "../utils/logger";
27
28			export const name = "afkService";
29
30			export default class AFKService extends Service implements HasEventListeners {
31			protected readonly entries = new Map<Snowflake, AfkEntry>();
32			protected readonly syncTimeoutDelay = 15_000;
33			protected syncTimeout: NodeJS.Timeout \| null = null;
34			protected readonly modifiedIds = new Set<string>();
35
36			@GatewayEventListener("ready")
37			async onReady() {
38			const entries = await this.client.prisma.afkEntry.findMany();
39
40			for (const entry of entries) {
41			this.entries.set(`${entry.guildId}_${entry.userId}`, entry);
42			}
43			}
44
45			isAFK(guildId: string, userId: string) {
46			return this.entries.has(`${guildId}_${userId}`);
47			}
48
49			toggle(guildId: string, userId: string, reason?: string) {
50			if (this.isAFK(guildId, userId)) {
51			return this.removeAFK(guildId, userId);
52			}
53
54			return this.startAFK(guildId, userId, reason);
55			}
56
57			async removeAFK(guildId: string, userId: string, shouldAwait: boolean = true) {
58			const entry = this.entries.get(`${guildId}_${userId}`)!;
59
60			if (!entry) {
61			return null;
62			}
63
64			const promise = this.client.prisma.afkEntry.deleteMany({
65			where: {
66			id: entry.id
67			}
68			});
69
70			shouldAwait ? await promise : promise.then(log);
71
72			this.entries.delete(`${guildId}_${userId}`);
73			return entry;
74			}
75
76			async startAFK(guildId: string, userId: string, reason?: string) {
77			const entry = await this.client.prisma.afkEntry.create({
78			data: {
79			guildId,
80			userId,
81			reason
82			}
83			});
84
85			this.entries.set(`${guildId}_${userId}`, entry);
86			return entry;
87			}
88
89			addMentions(guildId: string, userId: string, mentions: { userId: Snowflake; messageLink: string }[]) {
90			if (!this.isAFK(guildId, userId)) {
91			return false;
92			}
93
94			const entry = this.entries.get(`${guildId}_${userId}`)!;
95
96			if (entry.mentions.length >= 10) {
97			return false;
98			}
99
100			entry.mentions.push(...mentions.map(m => `${m.userId}__${m.messageLink}__${new Date().toISOString()}`));
101			this.modifiedIds.add(`${guildId}_${userId}`);
102			this.queueSync();
103
104			return true;
105			}
106
107			queueSync() {
108			this.syncTimeout ??= setTimeout(() => {
109			for (const guildId_UserId of this.modifiedIds) {
110			const entry = this.entries.get(guildId_UserId);
111
112			if (!entry) {
113			continue;
114			}
115
116			this.client.prisma.afkEntry.updateMany({
117			where: {
118			id: entry.id
119			},
120			data: entry
121			});
122			}
123			}, this.syncTimeoutDelay);
124			}
125
126			@GatewayEventListener("messageCreate")
127			async onMessageCreate(message: Message<boolean>) {
128			if (message.author.bot \|\| !message.guild \|\| message.channel.type === ChannelType.DM) {
129			return;
130			}
131
132			if (this.isAFK(message.guildId!, message.author.id)) {
133			const entry = await this.removeAFK(message.guildId!, message.author.id, false);
134
135			await message.reply({
136			embeds: [
137			{
138			color: 0x007bff,
139			description: this.client.afkService.generateAFKEndMessage(entry)
140			}
141			],
142			allowedMentions: {
143			users: []
144			}
145			});
146			}
147
148			if (message.mentions.users.size === 0) {
149			return;
150			}
151
152			let description = "";
153			const users = message.mentions.users.filter(user => this.isAFK(message.guildId!, user.id));
154
155			if (users.size === 0) {
156			return;
157			}
158
159			for (const [id] of users) {
160			this.addMentions(message.guildId!, id, [
161			{
162			messageLink: message.url,
163			userId: message.author.id
164			}
165			]);
166			}
167
168			if (users.size === 1) {
169			const entry = this.entries.get(`${message.guildId!}_${users.at(0)!.id}`);
170			description = `<@${users.at(0)!.id}> is AFK right now${
171			entry?.reason ? `, for reason: ${escapeMarkdown(entry?.reason)}` : ""
172			}.`;
173			} else {
174			description = "The following users are AFK right now: \n\n";
175
176			for (const [id] of users) {
177			if (this.isAFK(message.guildId!, id)) {
178			const entry = this.entries.get(`${message.guildId!}_${id}`);
179			description += `* <@${id}>: ${entry?.reason ?? "No reason provided"} ${
180			entry?.createdAt ? `(${time(entry?.createdAt!)})` : ""
181			}\n`;
182			}
183			}
184			}
185
186			if (description.trim() === "") {
187			return;
188			}
189
190			message
191			.reply({
192			embeds: [
193			{
194			color: 0x007bff,
195			description
196			}
197			],
198			allowedMentions: {
199			users: []
200			}
201			})
202			.catch(logError);
203			}
204
205			@GatewayEventListener("guildMemberRemove")
206			onGuildMemberRemove(member: GuildMember) {
207			if (this.isAFK(member.guild.id, member.user.id)) {
208			this.removeAFK(member.guild.id, member.user.id).catch(logError);
209			}
210			}
211
212			generateAFKEndMessage(entry: AfkEntry \| null \| undefined) {
213			return (
214			`You're no longer AFK. You had ${entry?.mentions.length ?? 0} mentions in this server.` +
215			(entry?.mentions?.length
216			? "\n\n" +
217			entry.mentions
218			.map(data => {
219			const [userId, messageLink, dateISO] = data.split("__");
220			return `From <@${userId}>, ${formatDistanceToNowStrict(new Date(dateISO), {
221			addSuffix: true
222			})} [Navigate](${messageLink})`;
223			})
224			.join("\n")
225			: "")
226			);
227			}
228			}