discordjs-automod/src/automods/AntiInvite.js

A package to easily add some extra auto-moderation protection to bots

const Client = require("../client/Client");
const { DefaultAntiinviteOptions } = require("../util/Defaults");
const Discord = require("discord.js");
const antiinvites = require("../../models/antiinvites.js");
const members = require("../../models/users.js");
const { MongoError } = require("mongodb");

class AntiInvite {
    /**
     *
     * @param {Discord.Client} client The Discord Client
     * @param {Discord.Guild} guild The guild that the anti-invite options are for
     * @param {Object} options The options for the AntiInvite class
     */
    constructor(client, guild, options) {
        options == {} ? (options = DefaultAntiinviteOptions) : (options = options);

        this.options = options;

        this.client = client;

        this.guild = guild;
    }

    /**
     * Check whether a message contains an invite link or not
     * @param {Discord.Message} message The discord message to check for a server invite
     * @returns {?String} Whether the message contained an invite link or not
     */
    check(message) {
        if (!message instanceof Discord.Message)
            throw new TypeError("Parameter `message` is not a Message");
        if (message.guild != this.guild)
            throw new Error("Provided message object is not in the AntiInvite guild");
        var invite = false;
        if (
            message.content.includes("discord.gg/") ||
            message.content.includes("invite.gg/") ||
            message.content.includes("discordapp.com/invite/")
        )
            invite = true;

        if (invite) {
            members.findOne(
                {
                    server: message.guild.id,
                    user: message.author.id,
                    client: this.client._client.user.id
                },
                (err, member) => {
                    if (err) throw new MongoError(err.message);
                    antiinvites.findOne(
                        { server: message.guild.id, client: this.client._client.user.id },
                        async (err, Invite) => {
                            if (err) throw new MongoError(err.message);
                            var userDoc = member;
                            var invDoc = Invite;
                            if (!member) {
                                userDoc = await new members({
                                    client: this.client._client.user.id,
                                    server: message.guild.id,
                                    user: message.author.id,
                                    warnings: 0
                                }).save();
                            }
                            if (!Invite) {
                                invDoc = await new antiinvites({
                                    client: this.client._client.user.id,
                                    server: message.guild.id,
                                    DefaultAntiinviteOptions
                                }).save();
                            }
                            userDoc.warnings++;
                            await userDoc.save();
                            let user = message.guild.member(userDoc.user);
                            if (userDoc.warnings == this.options.warnThreshold) {
                                this.client.emit("inviteWarn", (user, userDoc.warnings));
                                return this.options.warnMessage.replace(
                                    "{user}",
                                    message.author
                                );
                            } else if (userDoc.warnings == this.options.kickThreshold) {
                                this.client.emit("inviteKick", (user, userDoc.warnings));
                                return this.options.kickMessage.replace(
                                    "{guild_name}",
                                    message.guild.name
                                );
                            } else if (userDoc.warnings == this.options.banThreshold) {
                                this.client.emit("inviteBan", (user, userDoc.warnings));
                                return this.options.banMessage.replace(
                                    "{guild_name}",
                                    message.guild.name
                                );
                            } else {
                                return null;
                            }
                        }
                    );
                }
            );
        }
    }
}

module.exports = AntiInvite;