src/services/InviteTrackerService.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 { Collection, Guild, GuildMember, GuildPremiumTier, Invite, Snowflake, Vanity } 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 { wait } from "../utils/utils";

export const name = "inviteTracker";

export default class InviteTrackerService extends Service implements HasEventListeners {
    public readonly invites = new Collection<`${Snowflake}_${string}`, number>();

    @GatewayEventListener("ready")
    async onReady() {
        log("Syncing the invites...", this.client.guilds.cache.size);

        for (const [, guild] of this.client.guilds.cache) {
            if (!this.client.configManager.config[guild.id]?.invite_tracking?.enabled) {
                continue;
            }

            try {
                const invites = await guild.invites.fetch();

                for (const [, invite] of invites) {
                    log("Adding invite", invite.code);
                    this.invites.set(`${guild.id}_${invite.code}`, invite.uses ?? 0);
                }

                if (guild.premiumTier === GuildPremiumTier.Tier3) {
                    log("Fetching vanity info for guild ", guild.id);

                    try {
                        const vanity = guild.vanityURLUses !== null ? guild.vanityURLUses : (await guild.fetchVanityData()).uses;
                        this.invites.set(`${guild.id}_VANITY`, vanity);
                    } catch (e) {
                        logError(e);
                    }
                }

                await wait(1000);
            } catch (e) {
                logError(e);
            }
        }

        log("Successfully synced the invites");
    }

    @GatewayEventListener("inviteCreate")
    async onInviteCreate(invite: Invite) {
        log("Added new invite", invite.code);
        if (!invite.guild?.id || !this.client.configManager.config[invite.guild?.id ?? ""]?.invite_tracking?.enabled) {
            log("Invalid guild");
            return;
        }

        this.invites.set(`${invite.guild?.id}_${invite.code}`, invite.uses ?? 0);
    }

    @GatewayEventListener("inviteDelete")
    async onInviteDelete(invite: Invite) {
        log("Deleted invite", invite.code);
        if (!invite.guild?.id || !this.client.configManager.config[invite.guild?.id ?? ""]?.invite_tracking?.enabled) {
            log("Invalid guild");
            return;
        }

        this.invites.delete(`${invite.guild?.id}_${invite.code}`);
    }

    @GatewayEventListener("guildUpdate")
    async onGuildUpdate(oldGuild: Guild, newGuild: Guild) {
        if (!this.client.configManager.config[newGuild.id]?.invite_tracking?.enabled) {
            return;
        }

        if (newGuild.vanityURLCode === oldGuild.vanityURLCode && newGuild.vanityURLUses === oldGuild.vanityURLUses) {
            return;
        }

        if (oldGuild.vanityURLCode && !newGuild.vanityURLCode) {
            this.invites.delete(`${newGuild.id}_VANITY`);
        } else if (!oldGuild.vanityURLCode && newGuild.vanityURLCode) {
            this.invites.set(`${newGuild.id}_VANITY`, newGuild.vanityURLUses ?? 0);
        }
    }

    async findNewMemberInviteLink(member: GuildMember): Promise<
        | {
              isVanity: true;
              vanity: Vanity;
              invite: undefined;
          }
        | {
              isVanity: false;
              vanity: undefined;
              invite: Invite;
          }
        | undefined
    > {
        if (!this.client.configManager.config[member.guild.id]?.invite_tracking?.enabled) {
            return;
        }

        await wait(3500);
        const invites = await member.guild.invites.fetch();

        for (const [, invite] of invites) {
            const oldInviteCount = this.invites.get(`${member.guild.id}_${invite.code}`);

            if (oldInviteCount === undefined) {
                continue;
            }

            log("Compare", invite.code, oldInviteCount, invite.uses);

            if ((invite.uses ?? 0) > oldInviteCount) {
                this.invites.set(`${member.guild.id}_${invite.code}`, invite.uses ?? 0);
                return {
                    isVanity: false,
                    invite,
                    vanity: undefined
                };
            }
        }

        if (member.guild.premiumTier === GuildPremiumTier.Tier3) {
            try {
                const vanity = await member.guild.fetchVanityData();
                const oldVanityUses = this.invites.get(`${member.guild.id}_VANITY`);

                if (oldVanityUses === undefined) {
                    log("No vanity");
                    return;
                }

                log("Vanity", oldVanityUses, vanity.uses);

                if (vanity.uses > oldVanityUses) {
                    this.invites.set(`${member.guild.id}_VANITY`, vanity.uses);
                    return {
                        isVanity: true,
                        vanity,
                        invite: undefined
                    };
                }
            } catch (e) {
                logError(e);
            }
        }
    }
}
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 { Collection, Guild, GuildMember, GuildPremiumTier, Invite, Snowflake, Vanity } 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 } from "../utils/logger";
25			import { wait } from "../utils/utils";
26
27			export const name = "inviteTracker";
28
29			export default class InviteTrackerService extends Service implements HasEventListeners {
30			public readonly invites = new Collection<`${Snowflake}_${string}`, number>();
31
32			@GatewayEventListener("ready")
33			async onReady() {
34			log("Syncing the invites...", this.client.guilds.cache.size);
35
36			for (const [, guild] of this.client.guilds.cache) {
37			if (!this.client.configManager.config[guild.id]?.invite_tracking?.enabled) {
38			continue;
39			}
40
41			try {
42			const invites = await guild.invites.fetch();
43
44			for (const [, invite] of invites) {
45			log("Adding invite", invite.code);
46			this.invites.set(`${guild.id}_${invite.code}`, invite.uses ?? 0);
47			}
48
49			if (guild.premiumTier === GuildPremiumTier.Tier3) {
50			log("Fetching vanity info for guild ", guild.id);
51
52			try {
53			const vanity = guild.vanityURLUses !== null ? guild.vanityURLUses : (await guild.fetchVanityData()).uses;
54			this.invites.set(`${guild.id}_VANITY`, vanity);
55			} catch (e) {
56			logError(e);
57			}
58			}
59
60			await wait(1000);
61			} catch (e) {
62			logError(e);
63			}
64			}
65
66			log("Successfully synced the invites");
67			}
68
69			@GatewayEventListener("inviteCreate")
70			async onInviteCreate(invite: Invite) {
71			log("Added new invite", invite.code);
72			if (!invite.guild?.id \|\| !this.client.configManager.config[invite.guild?.id ?? ""]?.invite_tracking?.enabled) {
73			log("Invalid guild");
74			return;
75			}
76
77			this.invites.set(`${invite.guild?.id}_${invite.code}`, invite.uses ?? 0);
78			}
79
80			@GatewayEventListener("inviteDelete")
81			async onInviteDelete(invite: Invite) {
82			log("Deleted invite", invite.code);
83			if (!invite.guild?.id \|\| !this.client.configManager.config[invite.guild?.id ?? ""]?.invite_tracking?.enabled) {
84			log("Invalid guild");
85			return;
86			}
87
88			this.invites.delete(`${invite.guild?.id}_${invite.code}`);
89			}
90
91			@GatewayEventListener("guildUpdate")
92			async onGuildUpdate(oldGuild: Guild, newGuild: Guild) {
93			if (!this.client.configManager.config[newGuild.id]?.invite_tracking?.enabled) {
94			return;
95			}
96
97			if (newGuild.vanityURLCode === oldGuild.vanityURLCode && newGuild.vanityURLUses === oldGuild.vanityURLUses) {
98			return;
99			}
100
101			if (oldGuild.vanityURLCode && !newGuild.vanityURLCode) {
102			this.invites.delete(`${newGuild.id}_VANITY`);
103			} else if (!oldGuild.vanityURLCode && newGuild.vanityURLCode) {
104			this.invites.set(`${newGuild.id}_VANITY`, newGuild.vanityURLUses ?? 0);
105			}
106			}
107
108			async findNewMemberInviteLink(member: GuildMember): Promise<
109			\| {
110			isVanity: true;
111			vanity: Vanity;
112			invite: undefined;
113			}
114			\| {
115			isVanity: false;
116			vanity: undefined;
117			invite: Invite;
118			}
119			\| undefined
120			> {
121			if (!this.client.configManager.config[member.guild.id]?.invite_tracking?.enabled) {
122			return;
123			}
124
125			await wait(3500);
126			const invites = await member.guild.invites.fetch();
127
128			for (const [, invite] of invites) {
129			const oldInviteCount = this.invites.get(`${member.guild.id}_${invite.code}`);
130
131			if (oldInviteCount === undefined) {
132			continue;
133			}
134
135			log("Compare", invite.code, oldInviteCount, invite.uses);
136
137			if ((invite.uses ?? 0) > oldInviteCount) {
138			this.invites.set(`${member.guild.id}_${invite.code}`, invite.uses ?? 0);
139			return {
140			isVanity: false,
141			invite,
142			vanity: undefined
143			};
144			}
145			}
146
147			if (member.guild.premiumTier === GuildPremiumTier.Tier3) {
148			try {
149			const vanity = await member.guild.fetchVanityData();
150			const oldVanityUses = this.invites.get(`${member.guild.id}_VANITY`);
151
152			if (oldVanityUses === undefined) {
153			log("No vanity");
154			return;
155			}
156
157			log("Vanity", oldVanityUses, vanity.uses);
158
159			if (vanity.uses > oldVanityUses) {
160			this.invites.set(`${member.guild.id}_VANITY`, vanity.uses);
161			return {
162			isVanity: true,
163			vanity,
164			invite: undefined
165			};
166			}
167			} catch (e) {
168			logError(e);
169			}
170			}
171			}
172			}