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();

                log("List", invites);

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