@spatulox/simplediscordbot 1.0.24 → 1.0.26

package/dist/manager/guild/GuildUserManager.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildUserManager = void 0;
+const Bot_1 = require("../../bot/Bot");
+const Log_1 = require("../../utils/Log");
+const BasicUserManager_1 = require("../direct/BasicUserManager");
+const discord_js_1 = require("discord.js");
+const promises_1 = require("timers/promises");
+const EmbedManager_1 = require("../messages/EmbedManager");
+const GuildManager_1 = require("./GuildManager");
+const MAX_NICKNAME_LENGTH = 32;
+class GuildUserManager extends BasicUserManager_1.BasicUserManager {
+    static async find(userId, guild) {
+        try {
+            if (guild instanceof discord_js_1.Guild) {
+                return await guild.members.fetch(userId);
+            }
+            else {
+                return await (await GuildManager_1.GuildManager.find(guild)).members.fetch(userId);
+            }
+        }
+        catch (error) {
+            Log_1.Log.error(`UserManager: Member ${userId} not found`);
+            return null;
+        }
+    }
+    static async rename(member, nickname, maxAttempts = 3) {
+        if (nickname.length > MAX_NICKNAME_LENGTH) {
+            nickname = nickname.slice(0, MAX_NICKNAME_LENGTH);
+        }
+        for (let attempts = 0; attempts < maxAttempts; attempts++) {
+            try {
+                const oldName = member.displayName;
+                await member.setNickname(nickname.trim());
+                Log_1.Log.info(`Renaming user: ${oldName} → ${nickname.trim()}`);
+                await (0, promises_1.setTimeout)(1500);
+                return true;
+            }
+            catch (error) {
+                console.error(`Attempt ${attempts + 1} failed when renaming ${member.displayName} into ${nickname.trim()}:`, error);
+                await (0, promises_1.setTimeout)(1000);
+            }
+        }
+        Bot_1.Bot.log.info(EmbedManager_1.EmbedManager.error(`Failed to rename ${member.displayName} to ${nickname.trim()} after ${maxAttempts} attempts.`));
+        return false;
+    }
+    /**
+     * Check if user is banned from guild
+     */
+    static async isBanned(guildId, userId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild) {
+                Log_1.Log.warn(`Guild ${guildId} not found`);
+                return false;
+            }
+            const ban = await guild.bans.fetch(userId);
+            return !!ban;
+        }
+        catch (error) {
+            Log_1.Log.debug(`User ${userId} is not banned from guild ${guildId}`);
+            return false;
+        }
+    }
+    /**
+     * Deconnect a member from a voice
+     */
+    static async deconnectFromVoice(guildId, memberId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild) {
+                throw new Error(`Guild ${guildId} not found`);
+            }
+            const member = await guild.members.fetch(memberId);
+            if (!member.voice.channel) {
+                throw new Error(`Member ${memberId} is not in a voice channel`);
+            }
+            await member.voice.disconnect();
+            Log_1.Log.info(`Disconnected member ${memberId} from voice in guild ${guildId}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to disconnect member ${memberId} from voice in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Check if a member is in voice
+     */
+    static async isInVoice(memberId, guildId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                return false;
+            const member = await guild.members.fetch(memberId);
+            return member.voice.channelId !== null;
+        }
+        catch (error) {
+            Log_1.Log.debug(`Member ${memberId} not found or not in voice in guild ${guildId}`);
+            return false;
+        }
+    }
+    /**
+     * Mute a member
+     */
+    static async mute(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.voice.setMute(true, reason);
+            Log_1.Log.info(`Server muted ${memberId} in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to server mute ${memberId} in ${guildId}:, error`);
+            throw error;
+        }
+    }
+    /**
+     * Unmute a member
+     */
+    static async unmute(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.voice.setMute(false, reason);
+            Log_1.Log.info(`Server unmuted ${memberId} in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to server unmute ${memberId} in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Deafen a member
+     */
+    static async deafen(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.voice.setDeaf(true, reason);
+            Log_1.Log.info(`Server deafened ${memberId} in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to server deafen ${memberId} in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Undeafen member voice
+     */
+    static async undeafen(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.voice.setDeaf(false, reason);
+            Log_1.Log.info(`Server undeafened ${memberId} in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to server undeafen ${memberId} in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Timeout a member
+     */
+    static async timeout(guildId, memberId, duration, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            const expires = Date.now() + duration;
+            await member.timeout(expires, reason);
+            Log_1.Log.info(`Timed out ${memberId} for ${duration}ms in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to timeout ${memberId} in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Remove the timeout of a member
+     */
+    static async untimeout(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.timeout(null, reason);
+            Log_1.Log.info(`Untimed out ${memberId} in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to untimeout ${memberId} in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Kick a member
+     */
+    static async kick(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.kick(reason);
+            Log_1.Log.info(`Kicked ${memberId} from guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to kick ${memberId} from ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    static async ban(guildId, userId, banOption) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            throw new Error(`Guild ${guildId} not found`);
+        }
+        try {
+            await guild.members.ban(userId, banOption);
+            Log_1.Log.info(`Banned user ${userId} from guild ${guildId}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to ban user ${userId} from guild ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    static async unban(guildId, userId, reason) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            throw new Error(`Guild ${guildId} not found`);
+        }
+        try {
+            await guild.members.unban(userId, reason);
+            Log_1.Log.info(`Unbanned user ${userId} from guild ${guildId}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to unban user ${userId} from guild ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.GuildUserManager = GuildUserManager;

package/dist/manager/guild/InviteManager.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InviteManager = void 0;
+const Log_1 = require("../../utils/Log");
+const Bot_1 = require("../../bot/Bot");
+const GuildChannelManager_1 = require("./ChannelManager/GuildChannelManager");
+class InviteManager {
+    /**
+     * Create an invite for a channel
+     */
+    static async create(channelId, options = {}) {
+        try {
+            const channel = await GuildChannelManager_1.GuildChannelManager.find(channelId);
+            if (!channel) {
+                throw new Error(`Channel ${channelId} not found`);
+            }
+            const guild = channel.guild;
+            const inviteOptions = {
+                maxAge: options.maxAge ?? 86400,
+                maxUses: options.maxUses ?? 0,
+                temporary: options.temporary ?? false,
+                reason: options.reason
+            };
+            // ✅ guild.invites.create(channelId, options)
+            const invite = await guild.invites.create(channelId, inviteOptions);
+            Log_1.Log.info(`Created invite ${invite.code} for channel ${channelId}`);
+            return invite;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to create invite for channel ${channelId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Delete an invitation
+     */
+    static async delete(invite) {
+        try {
+            await invite.delete();
+            Log_1.Log.info(`Deleted invite ${invite.code} from guild ${invite.guild?.id}`);
+            return true;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to delete invite ${invite.code}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * List every invitation from a guild
+     */
+    static async list(guildId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild) {
+                throw new Error(`Guild ${guildId} not found`);
+            }
+            const invites = await guild.invites.fetch();
+            const inviteList = Array.from(invites.values());
+            Log_1.Log.info(`Fetched ${inviteList.length} invites for guild ${guildId}`);
+            return inviteList;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch invites for guild ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.InviteManager = InviteManager;

package/dist/manager/guild/InviteManager_old.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InviteManager = void 0;
+const discord_js_1 = require("discord.js");
+const Bot_1 = require("../../bot/Bot");
+const Log_1 = require("../../utils/Log");
+class InviteManager {
+    /**
+     * Check if invite is old (more than 1 hour)
+     */
+    static isOld(invite, excludedInvite = []) {
+        const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000); // 1h
+        if (!invite.createdAt) {
+            return false;
+        }
+        return (invite.maxAge !== 0 &&
+            !excludedInvite.includes(invite.code) &&
+            invite.createdAt < oneHourAgo);
+    }
+    /**
+     * Delete single invite
+     */
+    static async delete(invite) {
+        try {
+            await invite.delete();
+            if (invite.createdAt) {
+                Log_1.Log.info(`🗑️ Deleted invite \`${invite.code}\` created ${invite.createdAt.toDateString()}`);
+                return true;
+            }
+            Log_1.Log.warn(`Invite ${invite.code} deleted but no createdAt`);
+            return true;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to delete invite ${invite.code}: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Delete all old invites from guild
+     */
+    static async cleanupGuild(guildId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild) {
+                Log_1.Log.error(`Guild ${guildId} not found for invite cleanup`);
+                return 0;
+            }
+            const invites = await guild.invites.fetch();
+            let deletedCount = 0;
+            for (const [_code, invite] of invites) {
+                if (this.isOld(invite)) {
+                    const success = await this.delete(invite);
+                    if (success)
+                        deletedCount++;
+                    // Rate limit protection
+                    await new Promise(r => setTimeout(r, 100));
+                }
+            }
+            Log_1.Log.info(`Invite cleanup ${guild.name}: ${deletedCount} old invites deleted`);
+            return deletedCount;
+        }
+        catch (error) {
+            Log_1.Log.error(`Invite cleanup failed for ${guildId}: ${error}`);
+            return 0;
+        }
+    }
+    /**
+     * Get all invites from guild
+     */
+    static async fetchGuildInvites(guildId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            return await guild.invites.fetch();
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch invites for ${guildId}: ${error}`);
+            return new discord_js_1.Collection();
+        }
+    }
+    /**
+     * Get old invites only
+     */
+    static getOldInvites(invites) {
+        return invites.filter(invite => this.isOld(invite)).map(invite => invite);
+    }
+}
+exports.InviteManager = InviteManager;

package/dist/manager/guild/RoleManager.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleManager = void 0;
+const Log_1 = require("../../utils/Log");
+class RoleManager {
+    /**
+     * Add role - CACHE ONLY
+     * @param member - GuildMember ALREADY FETCHED
+     * @param roleId - Role ID (string)
+     */
+    static async add(member, roleId) {
+        try {
+            const role = member.roles.cache.get(roleId);
+            if (!role) {
+                Log_1.Log.warn(`Role ${roleId} not found in cache`);
+                return false;
+            }
+            await member.roles.add(role);
+            Log_1.Log.info(`✅ Added ${role.name} to ${member.displayName}`);
+            return true;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to add role ${roleId}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Remove role - CACHE ONLY
+     * @param member - GuildMember ALREADY FETCHED
+     * @param roleIdOrName - Role ID or name
+     */
+    static async remove(member, roleIdOrName) {
+        try {
+            let role;
+            if (typeof roleIdOrName === 'string' && roleIdOrName.length === 18) {
+                role = member.roles.cache.get(roleIdOrName);
+            }
+            else {
+                role = member.roles.cache.find(r => r.id === roleIdOrName || r.name.toLowerCase() === roleIdOrName.toString().toLowerCase());
+            }
+            if (!role) {
+                Log_1.Log.warn(`Role ${roleIdOrName} not found for ${member.displayName}`);
+                return false;
+            }
+            await member.roles.remove(role);
+            Log_1.Log.info(`✅ Removed ${role.name} from ${member.displayName}`);
+            return true;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to remove role ${roleIdOrName}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Toggle role (add/remove)
+     */
+    static async toggle(member, roleIdOrName) {
+        const role = member.roles.cache.get(roleIdOrName) ||
+            member.roles.cache.find(r => r.name.toLowerCase() === roleIdOrName.toString().toLowerCase());
+        if (!role) {
+            Log_1.Log.warn(`Role ${roleIdOrName} not found`);
+            throw new Error(`Role not found`);
+        }
+        if (member.roles.cache.has(role.id)) {
+            await this.remove(member, role.id);
+            return 'removed';
+        }
+        else {
+            await this.add(member, role.id);
+            return 'added';
+        }
+    }
+    /**
+     * Check if member has role
+     */
+    static hasRole(member, roleIdOrName) {
+        if (typeof roleIdOrName === 'string' && roleIdOrName.length === 18) {
+            return member.roles.cache.has(roleIdOrName);
+        }
+        return member.roles.cache.some(r => r.id === roleIdOrName || r.name.toLowerCase() === roleIdOrName.toString().toLowerCase());
+    }
+}
+exports.RoleManager = RoleManager;

package/dist/manager/interactions/ModalManager.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalManager = void 0;
+const discord_js_1 = require("discord.js");
+const FolderName_1 = require("../../type/FolderName");
+const FileManager_1 = require("../FileManager");
+class ModalManager {
+    /**
+     * Load modal from JSON file and return ModalBuilder
+     */
+    static async load(filename) {
+        try {
+            const file = await FileManager_1.FileManager.readJsonFile(`./handlers/${FolderName_1.FolderName.MODAL}/${filename}`);
+            if (!file)
+                return false;
+            return ModalManager.jsonToBuilder(file);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * List all modal files
+     */
+    static async list() {
+        try {
+            const files = await FileManager_1.FileManager.listJsonFiles(`./handlers/${FolderName_1.FolderName.MODAL}`);
+            return files || [];
+        }
+        catch {
+            return false;
+        }
+    }
+    static jsonToBuilder(json) {
+        const modal = new discord_js_1.ModalBuilder()
+            .setCustomId(json.customId)
+            .setTitle(json.title.slice(0, 45));
+        const actionRows = [];
+        for (const fieldJson of json.fields) {
+            const input = this.fieldJsonToInput(fieldJson);
+            const row = new discord_js_1.ActionRowBuilder()
+                .addComponents(input);
+            actionRows.push(row);
+        }
+        return modal.addComponents(...actionRows);
+    }
+    static fieldJsonToInput(fieldJson) {
+        const input = new discord_js_1.TextInputBuilder()
+            .setCustomId(fieldJson.customId)
+            .setLabel(fieldJson.title.slice(0, 45))
+            .setPlaceholder(fieldJson.placeholder || 'Enter value...')
+            .setRequired(fieldJson.required !== false)
+            .setMinLength(fieldJson.minLength || 0)
+            .setMaxLength(fieldJson.maxLength || 400);
+        // Convertir style JSON (1, 2, "Number") → TextInputStyle
+        const style = fieldJson.style;
+        if (typeof style === 'number') {
+            // 1=Short, 2=Paragraph
+            input.setStyle(style);
+        }
+        else {
+            // "Number", "Phone", "Date"
+            switch (style) {
+                case 'Number':
+                case 'Phone':
+                case 'Date':
+                    input.setStyle(discord_js_1.TextInputStyle.Short);
+                    input.setPlaceholder(style === 'Number' ? '123' :
+                        style === 'Phone' ? '+33 6 12 34 56 78' :
+                            '2024-02-05');
+                    break;
+                default:
+                    input.setStyle(discord_js_1.TextInputStyle.Short);
+            }
+        }
+        return input;
+    }
+    static parseNumber(value) {
+        if (!/^\d+$/.test(value))
+            return null;
+        const num = parseInt(value);
+        return isNaN(num) ? null : num;
+    }
+    static parsePhone(value) {
+        // 0604050359, +33604050359, 06 40 50 35 59, (06) 40-50-35-59
+        const clean = value.replace(/[\s\-\(\)]/g, '');
+        // Français : 06/07/09 + 8 chiffres OU +33 + 9 chiffres
+        if (/^(06|07|09)\d{8}$/.test(clean) || /^(\+33|0033)?[6-9]\d{8}$/.test(clean)) {
+            // Normalise au format international
+            if (clean.startsWith('06') || clean.startsWith('07') || clean.startsWith('09')) {
+                return '+33' + clean.slice(2);
+            }
+            return clean.startsWith('0033') ? '+33' + clean.slice(4) : clean;
+        }
+        return null;
+    }
+    static parseDate(value) {
+        // yyyy-mm-dd → Date
+        if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+            const [year, month, day] = value.split('-').map(Number);
+            const date = new Date(year, month - 1, day);
+            return isNaN(date.getTime()) ? null : date;
+        }
+        // dd/mm/yyyy → Date
+        if (/^\d{2}\/\d{2}\/\d{4}$/.test(value)) {
+            const [day, month, year] = value.split('/').map(Number);
+            const date = new Date(year, month - 1, day);
+            return isNaN(date.getTime()) ? null : date;
+        }
+        return null;
+    }
+}
+exports.ModalManager = ModalManager;