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	/**
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	}