src/services/AFKEngine.ts

import { formatDistanceToNowStrict } from "date-fns";
import { CommandInteraction, GuildMember, Message, User, Util } from "discord.js";
import DiscordClient from "../client/Client";
import MessageEmbed from "../client/MessageEmbed";
import AFKCommand from "../commands/utils/AFKCommand";
import AFK from "../models/AFK";
import Service from "../utils/structures/Service";

export interface MentionSchema {
    date: number;
    user: string; 
}

export default class AFKEngine extends Service {
    list: AFK[] = [];

    constructor(client: DiscordClient) {
        super(client);
        AFK.findAll().then(models => this.list = models).catch(console.error);
    }

    findUsers(ids: string[], guild: string) {
        return this.list.filter(afk => ids.includes(afk.get("user") as string) && afk.get("guild_id") as string === guild);
    }
 
    async removeUser(id: string, guild: string) {
        let index = 0;

        for await (const afk of this.list) {
            if (afk.get('user') === id && afk.get("guild_id") === guild) {
                await afk.destroy();
                this.list.splice(index, 1);
            }

            index++;
        }
    }
    
    async toggle(message: Message | CommandInteraction, enable: boolean = false, status?: string) {
        const afk = this.findUsers([message.member!.user.id], message.guild!.id);

        if (afk.length > 0) {
            const mentions = afk[0].get("mentions")! as Array<MentionSchema>;
            let count = 0, text = '';

            for await (const m of mentions) {
                if (count >= 3) {
                    break;
                }

                let member: GuildMember | undefined;

                try {
                    member = await message.guild!.members.fetch(m.user);

                    if (!member) {
                        throw new Error("user not found");
                    }
                }
                catch (e) {
                    console.log(e);
                    continue;                    
                }
                
                text += `\nFrom ${member.toString()}, ${formatDistanceToNowStrict(m.date, { addSuffix: true })}`;
                count++;
            }

            await this.client.afkEngine.removeUser(message.member!.user.id, message.guild!.id);

            await message.reply({
                embeds: [
                    new MessageEmbed({
                        description: `You're no longer AFK. You had ${mentions.length ?? 0} mentions in the server(s) where SudoBot is in.${mentions.length > 0 ? `\n\n**Mentions**:${text}` : ''}`,
                    })
                ]
            });
        }
        else if (enable) {
            this.client.afkEngine.list.push(await AFK.create({
                user: message.member!.user.id,
                guild_id: message.guild!.id,
                mentions: [],
                reason: status ?? undefined
            }));

            await message.reply({
                embeds: [
                    new MessageEmbed({
                        description: `You're AFK now${status ? `, for reason: **${Util.escapeMarkdown(status)}**` : ''}.`
                    })
                ]
            });
        }
    }

    async start(msg: Message) {
        if (msg.author.bot)
            return;

        const selfAFK = this.findUsers([msg.author.id], msg.guild!.id);

        if (selfAFK.length > 0) {
            this.toggle(msg, false);
        }
        
        const mention = msg.mentions.members?.first();

        if (mention) {
            const afkRecords: AFK[] = this.findUsers([...msg.mentions.members!.keys()].slice(0, 3), msg.guild!.id);

            if (!afkRecords || afkRecords.length < 1) {
                return;
            }

            for (const record of afkRecords) {
                const mentions = record.get("mentions") as MentionSchema[];

                mentions.push({
                    date: Date.now(),
                    user: msg.author.id
                });

                record.set("mentions", mentions).save();
            }

            let text = `The following users are AFK right now:`;

            if (afkRecords.length > 1) {
                for await (const afkRecord of afkRecords) {
                    text += `\n**${msg.mentions.members!.get(afkRecord.get("user") as string)!.user.tag}**${afkRecord.get("reason") as (null | string) ? `\n**Reason**: ${Util.escapeMarkdown(afkRecord.get("reason") as string)}` : ""}`;
                }
            }
            else {
                text = `${msg.mentions.members!.get(afkRecords[0].get("user") as string)!.user.tag} is AFK right now${afkRecords[0].get("reason") as (null | string) ? `, for reason **${Util.escapeMarkdown(afkRecords[0].get("reason") as string)}**` : ""}.`;
            }

            await msg.reply({
                embeds: [
                    new MessageEmbed({
                        description: text
                    })
                ]
            });
        }
    }
};
1	rakin	304	import { formatDistanceToNowStrict } from "date-fns";
2			import { CommandInteraction, GuildMember, Message, User, Util } from "discord.js";
3	rakin	51	import DiscordClient from "../client/Client";
4			import MessageEmbed from "../client/MessageEmbed";
5	rakin	304	import AFKCommand from "../commands/utils/AFKCommand";
6			import AFK from "../models/AFK";
7	rakin	226	import Service from "../utils/structures/Service";
8	rakin	51
9	rakin	304	export interface MentionSchema {
10			date: number;
11			user: string;
12			}
13
14	rakin	226	export default class AFKEngine extends Service {
15	rakin	304	list: AFK[] = [];
16
17			constructor(client: DiscordClient) {
18			super(client);
19			AFK.findAll().then(models => this.list = models).catch(console.error);
20			}
21
22			findUsers(ids: string[], guild: string) {
23			return this.list.filter(afk => ids.includes(afk.get("user") as string) && afk.get("guild_id") as string === guild);
24			}
25
26			async removeUser(id: string, guild: string) {
27			let index = 0;
28
29			for await (const afk of this.list) {
30			if (afk.get('user') === id && afk.get("guild_id") === guild) {
31			await afk.destroy();
32			this.list.splice(index, 1);
33			}
34
35			index++;
36			}
37			}
38
39			async toggle(message: Message \| CommandInteraction, enable: boolean = false, status?: string) {
40			const afk = this.findUsers([message.member!.user.id], message.guild!.id);
41
42			if (afk.length > 0) {
43			const mentions = afk[0].get("mentions")! as Array<MentionSchema>;
44			let count = 0, text = '';
45
46			for await (const m of mentions) {
47			if (count >= 3) {
48			break;
49	rakin	51	}
50
51	rakin	304	let member: GuildMember \| undefined;
52	rakin	51
53	rakin	304	try {
54			member = await message.guild!.members.fetch(m.user);
55
56			if (!member) {
57			throw new Error("user not found");
58			}
59			}
60			catch (e) {
61			console.log(e);
62			continue;
63			}
64
65			text += `\nFrom ${member.toString()}, ${formatDistanceToNowStrict(m.date, { addSuffix: true })}`;
66			count++;
67	rakin	51	}
68
69	rakin	304	await this.client.afkEngine.removeUser(message.member!.user.id, message.guild!.id);
70
71			await message.reply({
72			embeds: [
73			new MessageEmbed({
74			description: `You're no longer AFK. You had ${mentions.length ?? 0} mentions in the server(s) where SudoBot is in.${mentions.length > 0 ? `\n\nMentions:${text}` : ''}`,
75			})
76			]
77			});
78			}
79			else if (enable) {
80			this.client.afkEngine.list.push(await AFK.create({
81			user: message.member!.user.id,
82			guild_id: message.guild!.id,
83			mentions: [],
84			reason: status ?? undefined
85			}));
86
87			await message.reply({
88			embeds: [
89			new MessageEmbed({
90			description: `You're AFK now${status ? `, for reason: ${Util.escapeMarkdown(status)}` : ''}.`
91			})
92			]
93			});
94			}
95	rakin	51	}
96
97	rakin	304	async start(msg: Message) {
98	rakin	69	if (msg.author.bot)
99			return;
100	rakin	304
101			const selfAFK = this.findUsers([msg.author.id], msg.guild!.id);
102
103			if (selfAFK.length > 0) {
104			this.toggle(msg, false);
105			}
106	rakin	69
107	rakin	304	const mention = msg.mentions.members?.first();
108	rakin	51
109			if (mention) {
110	rakin	304	const afkRecords: AFK[] = this.findUsers([...msg.mentions.members!.keys()].slice(0, 3), msg.guild!.id);
111
112			if (!afkRecords \|\| afkRecords.length < 1) {
113			return;
114			}
115
116			for (const record of afkRecords) {
117			const mentions = record.get("mentions") as MentionSchema[];
118
119			mentions.push({
120			date: Date.now(),
121			user: msg.author.id
122	rakin	51	});
123	rakin	304
124			record.set("mentions", mentions).save();
125			}
126
127			let text = `The following users are AFK right now:`;
128
129			if (afkRecords.length > 1) {
130			for await (const afkRecord of afkRecords) {
131			text += `\n${msg.mentions.members!.get(afkRecord.get("user") as string)!.user.tag}${afkRecord.get("reason") as (null \| string) ? `\nReason: ${Util.escapeMarkdown(afkRecord.get("reason") as string)}` : ""}`;
132	rakin	51	}
133	rakin	304	}
134			else {
135			text = `${msg.mentions.members!.get(afkRecords[0].get("user") as string)!.user.tag} is AFK right now${afkRecords[0].get("reason") as (null \| string) ? `, for reason ${Util.escapeMarkdown(afkRecords[0].get("reason") as string)}` : ""}.`;
136			}
137
138			await msg.reply({
139			embeds: [
140			new MessageEmbed({
141			description: text
142			})
143			]
144	rakin	51	});
145			}
146			}
147			};