gestion/events/antiraid.js/GuildMemberAdd.js

const sqlite3 = require('sqlite3').verbose();
const db = new sqlite3.Database('myDatabase.db');
const { Events, AuditLogEvent, PermissionsBitField, EmbedBuilder } = require('discord.js');
const { getPermissionLevel } = require('../../fonction/getPermissionLevel');

module.exports = {
    name: Events.GuildMemberAdd,
    async execute(member, client) {
        if (member.user.bot) {
        const botId = client.user.id;
        const guildId = member.guild.id;
        const guild = member.guild;
        const fetchedLogs = await guild.fetchAuditLogs({
            type: AuditLogEvent.BotAdd,
            limit: 1,
        });

        const firstEntry = fetchedLogs.entries.first();
        const user = guild.members.cache.get(`${firstEntry.executor.id}`);
        let data = await new Promise((resolve, reject) => {
            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                if (err) {
                    console.error(err.message);
                    reject(err);
                }
                resolve(row ? JSON.parse(row.value) : {});
            });
        });

        const antibotConfig = data[guildId]?.antibot;
        if (!antibotConfig || antibotConfig.type === 'off') {
            return;
        }
        data.whitelist = data.whitelist || {};
        data.whitelist[guildId] = data.whitelist[guildId] || {};
        const whitelist = data.whitelist[guildId];
        const type = antibotConfig.type;
        const permlevel = await getPermissionLevel(user, client);
        try {
            if (type === "whitelist") {
                if (permlevel >= 10) return;
                if (whitelist[user.id]) return;
                punish(user, antibotConfig.action, guild);
                await member.kick('Anti-bot protection');
                sendlog(user, antibotConfig.action, guild, data);
            } else if (type === "owner") {
                if (permlevel >= 10) return;
                punish(user, antibotConfig.action, guild);
                await member.kick('Anti-bot protection');
                sendlog(user, antibotConfig.action, guild, data);
            } else if (type === "buyer") {
                if (permlevel === 11) return;
                punish(user, antibotConfig.action, guild);
                await member.kick('Anti-bot protection');
                sendlog(user, antibotConfig.action, guild, data);
            }
        } catch (err) {
        }
    }else {
        const botId = client.user.id;
        const guildId = member.guild.id;
        const guild = member.guild;
        let data = await new Promise((resolve, reject) => {
            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                if (err) {
                    console.error(err.message);
                    reject(err);
                }
                resolve(row ? JSON.parse(row.value) : {});
            });
        });
        const antijoinConfig = data[guildId]?.antijoin
        if(antijoinConfig && antijoinConfig?.type === 'on') {
        try{
        member.kick({ reason: 'Anti-join protection' });
        }catch(err) {
        }
        } else {
            const creationlimitConfig = data[guildId]?.creationLimit
            if (creationlimitConfig) {
                let limitInMilliseconds;
                const lastChar = creationlimitConfig.slice(-1);
                const number = parseInt(creationlimitConfig.slice(0, -1), 10);
                switch (lastChar) {
                    case 'm':
                        limitInMilliseconds = number * 60 * 1000;
                        break;
                    case 'h':
                        limitInMilliseconds = number * 60 * 60 * 1000; 
                        break;
                    case 'd':
                        limitInMilliseconds = number * 24 * 60 * 60 * 1000; 
                        break;
                    default:
                        return; 
                }    
                const memberCreationDate = member.user.createdAt;
                const currentDate = new Date();     
                const timeDifference = currentDate - memberCreationDate;
                if (timeDifference < limitInMilliseconds) {
                    return member.kick('Votre compte est trop récent.').catch(console.error);
                }else {
                    const invites = await member.guild.invites.fetch();
                    const invite = invites.find(i => i.uses > 1);
                    if (invite && invite.inviter) {
                        await updateInviteCount(member.guild.id, invite.inviter.id);
                        return;

                    }
                }   
            }else {

            const invites = await member.guild.invites.fetch();
            const invite = invites.find(i => i.uses > 1);
            if (invite && invite.inviter) {
                await updateInviteCount(member.guild.id, invite.inviter.id);
                return;
            }


        }
        }
    }
    }
};

async function punish(user, action, guild) {
    switch (action) {
        case 'ban':
            await guild.members.ban(user, { reason: 'Anti-bot protection' });
            break;
        case 'kick':
            await guild.members.kick(user, 'Anti-bot protection');
            break;
        case 'derank':
            const dangerousPermissions = [
                PermissionsBitField.Flags.Administrator,
                PermissionsBitField.Flags.ManageGuild,
                PermissionsBitField.Flags.ManageRoles,
                PermissionsBitField.Flags.ManageChannels,
                PermissionsBitField.Flags.KickMembers,
                PermissionsBitField.Flags.BanMembers,
                PermissionsBitField.Flags.ManageWebhooks,
                PermissionsBitField.Flags.MuteMembers,
                PermissionsBitField.Flags.MentionEveryone,
                PermissionsBitField.Flags.ManageEvents,
                PermissionsBitField.Flags.ManageThreads,
            ];
            const member = guild.members.cache.get(user.id);
            if (member) {
                const rolesToRemove = member.roles.cache.filter(role => dangerousPermissions.includes(role.permissions.bitfield));
                await member.roles.remove(rolesToRemove, 'Anti-bot protection');
            }
            break;
        case 'nothing':
            break;
    }
}
function updateInviteCount(guildId, memberId) {
    const db = new sqlite3.Database('myDatabase.db');
    db.run(`INSERT INTO invitations (guild_id, member_id, invite_count)
            VALUES (?, ?, 1)
            ON CONFLICT(guild_id, member_id) DO UPDATE SET invite_count = invite_count + 1`,
            [guildId, memberId], function(err) {
                if (err) {
                    return console.error(err.message);
                }
            });
}
async function sendlog(user, action, guild, data) {
    if (!data[guild.id]) {
        data[guild.id] = {};
    }
    const channelid = data[guild.id]?.raidlog;
    if(channelid) {
        const logChannel = guild.channels.cache.get(channelid);
        if (!logChannel) return ;

        const embed = new EmbedBuilder()
        .setDescription(`L'utilisateur <@${user.id}> a ajoutée un bot et a été \`${action}\`.`)
        .setColor('#ADD8E6')
        .setTimestamp();

        logChannel.send({ embeds: [embed] });
    }
}