@elara-services/tickets 1.6.0 → 2.0.2

package/README.md

@@ -6,52 +6,73 @@ This is a customizable ticket system that uses interactions and discord.js
 # Getting Started
 ```js
 const { Client } = require("discord.js"),
-        Tickets = require(`@elara-services/tickets`),
-        client = new Client({ intents: [ "GUILDS" ] }),
-        tickets = new Tickets({
-            client,
-            prefix: "support", // This is what is used for interactions (buttons) and the start of the channel name
-            ticketCategory: "", // When tickets get created they get created in this category, (OPTIONAL) - Default is the category ID for the starter message's channel.
-            webhookId: "WEBHOOK ID HERE",
-            webhookToken: "WEBHOOK TOKEN HERE",
-            encryptToken: "ASB!@#$%^&*(B", // This is to encrypt/decrypt the user IDs in the channel topic, to avoid non-staff from seeing who's ticket it is
-            supportRoleIds: [
-                "12345678", // Add the support role ids here
-            ],
-            supportUserIds: [
-                `12345678`, // Add the support user ids here
-            ],
-            webhookUsername: "WEBHOOK USERNAME HERE",
-            webhookAvatar: "WEBHOOK AVATAR URL HERE",
-            ticketOpen: {
-                content: "", // The content of the ticket message once it gets created, use "%user%" or "%server%" for the user mention or server name
-                embeds: [], // View https://discord.com/developers/docs/resources/channel#embed-object 
+    Tickets = require(`@elara-services/tickets`),
+    client = new Client({ intents: ["GUILDS"] }),
+    tickets = new Tickets({
+        client,
+        prefix: "support", // This is what is used for interactions (buttons) and the start of the channel name
+        ticketCategory: "", // When tickets get created they get created in this category, (OPTIONAL) - Default is the category ID for the starter message's channel.
+        encryptToken: "ASB!@#$%^&*(B", // This is to encrypt/decrypt the user IDs in the channel topic, to avoid non-staff from seeing who's ticket it is
+        debug: true, // Only use if you want errors logged.
+        ticketOpen: {
+            content: "", // The content of the ticket message once it gets created, use "%user%" or "%server%" for the user mention or server name
+            embeds: [], // View https://discord.com/developers/docs/resources/channel#embed-object 
+        },
+        appeals: { // OPTIONAL
+            enabled: true, // If the appeals server checks should be enabled.
+            mainserver: {
+                id: "", // The main server's id 
+                checkIfBanned: true // Check if the user is banned in the main server, if not they can't open a ticket.
             },
-            appeals: { // OPTIONAL
-                enabled: true, // If the appeals server checks should be enabled.
-                mainserver: {
-                    id: "", // The main server's id 
-                    checkIfBanned: true // Check if the user is banned in the main server, if not they can't open a ticket.
-                },
-                embeds: {
-                    not_banned: {} // The embeds, content and components for the not banned message. 
-                }
+            embeds: {
+                not_banned: {} // The embeds, content and components for the not banned message. 
             }
-        })
+        },
 
-    client.on("interactionCreate", (int) => tickets.run(int))
+        modal: {
+            enabled: true, // If this form should be enabled  / shown 
+            title: "", // The top title of the modal / form 
+            questions: [
+                {
+                    label: "[NAME]", // The name of this question
+                    style: 2, // 1 (SHORT ANSWER) | 2 (LONG ANSWER)
+                    placeholder: "", // The placeholder of the question
+                    value: "", // The default value for the question
+                    required: true, // If the question should be required
+                    min_length: 20, // The min length for the question response
+                    max_length: 4000, // The max length for the question response
+                }
+            ]
+        },
+        webhook: {
+            id: "", // 'webhookId' support will be removed in the next major version
+            token: "", // 'webhookToken' support will be removed in the next major version
+            username: "Webhook Username Here", // 'webhookUsername' support will be removed in the next major version
+            avatar: "", // 'webhookAvatar' support will be removed in the next major version
+        },
+        support: {
+            roles: [ // 'supportRoleIds' support will be removed in the next major version
+                "123456789"
+            ],
+            users: [ // 'supportUserIds' support will be removed in the next major version
+                "123456789"
+            ]
+        },
+    })
 
-    client.on("ready", () => {
-        console.log(`Client is ready`);
-        // Use it as "node bot.js --starter" or just create a command in your bot to manage the starter message
-        if (process.argv.find(c => c === "--starter")) {
-            return tickets.starterMessage(`HELP OR SUPPORT CHANNEL ID HERE`, {
-                embeds: [
-                    { title: "Support Tickets", description: `Click the button below to create a support ticket!`, color: 0xFF000 }
-                ]
-            })
-        }
-    });
+client.on("interactionCreate", (int) => tickets.run(int))
+
+client.on("ready", () => {
+    console.log(`Client is ready`);
+    // Use it as "node bot.js --starter" or just create a command in your bot to manage the starter message
+    if (process.argv.find(c => c === "--starter")) {
+        return tickets.starterMessage(`HELP OR SUPPORT CHANNEL ID HERE`, {
+            embeds: [
+                { title: "Support Tickets", description: `Click the button below to create a support ticket!`, color: 0xFF000 }
+            ]
+        })
+    }
+});
 
-    client.login("BOT TOKEN HERE")
+client.login("BOT TOKEN HERE")
 ```

package/index.d.ts

@@ -1,20 +1,14 @@
 declare module "@elara-services/tickets" {
     
-    import { Client, MessageOptions, GuildMember, Guild, User, TextBasedChannel, Message, Interaction } from "discord.js";
+    import { Client, MessageOptions, GuildMember, Guild, User, TextBasedChannel, Message, Interaction, ModalOptions } from "discord.js";
     import Webhook from "discord-hook";
 
     export interface TicketOptions {
         client: Client;
         prefix: string;
+        debug?: boolean;
         encryptToken: string;
         ticketCategory?: string;
-
-        webhookId?: string;
-        webhookToken?: string;
-        webhookUsername?: string;
-        webhookAvatar?: string;
-        supportRoleIds?: string[];
-        supportUserIds?: string[];
         ticketOpen?: Pick<MessageOptions, "content" | "embeds">
         appeals?: {
             enabled: boolean;
@@ -25,7 +19,43 @@ declare module "@elara-services/tickets" {
             embeds?: {
                 not_banned: Pick<MessageOptions, "content" | "embeds" | "components">
             }
-        }
+        };
+        modal?: {
+            enabled: boolean;
+            title?: string;
+            questions?: {
+                label: string;
+                style: 1 | 2;
+                placeholder?: string;
+                value?: string;
+                required?: boolean;
+                min_length?: number;
+                max_length?: number;
+            }[]
+        };
+        webhook?: {
+            id?: string;
+            token?: string;
+            username?: string;
+            avatar?: string
+        };
+        support?: {
+            roles?: string[];
+            users?: string[];
+        };
+
+        /** @deprecated Use 'webhook.id' */
+        webhookId?: string;
+        /** @deprecated Use 'webhook.token' */
+        webhookToken?: string;
+        /** @deprecated Use 'webhook.username' */
+        webhookUsername?: string;
+        /** @deprecated Use 'webhook.avatar' */
+        webhookAvatar?: string;
+        /** @deprecated Use 'support.roles' */
+        supportRoleIds?: string[];
+        /** @deprecated Use 'support.users' */
+        supportUserIds?: string[];
     }
 
     class Tickets {

package/index.js

@@ -1,25 +1,263 @@
-const { Collection, WebhookClient } = require("discord.js"),
-      { encrypt, decrypt } = require("aes256"),
-      { generate } = require("shortid"),
-        Webhook = require("discord-hook");
+const { Collection, WebhookClient, MessageEmbed } = require("discord.js"),
+    { encrypt, decrypt } = require("aes256"),
+    { generate } = require("shortid"),
+    { Interactions: { button, modal } } = require("@elara-services/packages"),
+      Webhook = require("discord-hook"),
+      de = {
+        user: "<:Members:860931214232125450>",
+        channel: "<:Channel:841654412509839390>",
+        transcript: "<:Log:792290922749624320>"
+      }
 
 module.exports = class Tickets {
     constructor(options) {
         this.options = options;
     };
     get prefix() { return `system:ticket:${this.options.prefix}`; };
+
+    /** @private */
+    get webhookOptions() {
+        return {
+            id: this.options.webhook?.id || this.options.webhookId,
+            token: this.options.webhook?.token || this.options.webhookToken,
+            username: this.options.webhook?.username || this.options.webhookUsername || "Tickets",
+            avatar: this.options.webhook?.avatar || this.options.webhookAvatar || "https://cdn.discordapp.com/emojis/818757771310792704.png?v=1"
+        }
+    }
     webhook() {
-        return new Webhook(`https://discord.com/api/webhooks/${this.options.webhookId}/${this.options.webhookToken}`, {
-            username: this.options.webhookUsername || "Tickets", 
-            avatar_url: this.options.webhookAvatar || "https://cdn.discordapp.com/emojis/818757771310792704.png?v=1", 
-        }); 
+        const { id, token, username, avatar } = this.webhookOptions;
+        return new Webhook(`https://discord.com/api/webhooks/${id}/${token}`, { username, avatar_url: avatar });
+    };
+
+    /**
+     * @param {import("discord.js").Interaction} int 
+     */
+    async run(int) {
+        if (int?.isButton?.() || int?.isModalSubmit()) {
+            let { guild, channel, member, customId } = int,
+                category = guild?.channels?.resolve?.(this.options.ticketCategory || channel?.parentId);
+
+            if (!guild || !guild.available || !channel || !member || !category) return;
+
+            /**
+             * @param {import("discord.js").InteractionDeferReplyOptions|import("discord.js").InteractionReplyOptions} options 
+             * @param {boolean} edit 
+             * @param {boolean} defer 
+             */
+            const send = async (options = {}, defer = false) => {
+                if (defer) return int.deferReply(options).catch(this._debug);
+                if (int.replied || int.deferred) return int.editReply(options).catch(this._debug);
+                return int.reply(options).catch(this._debug);
+            };
+            switch (customId) {
+                case this.prefix: {
+                    if (this.options.modal?.enabled) {
+                        return int.showModal(this.modal({
+                            title: this.options.modal.title,
+                            components: this.options.modal.questions?.length >= 1 ?
+                                this.options.modal.questions.slice(0, 5).map(c => ({ type: 1, components: [{ min_length: c.min_length || 10, max_length: c.max_length || 4000, type: 4, style: c.style || 2, label: c.label, value: c.value, placeholder: c.placeholder, required: c.required, custom_id: c.label || `random_${Math.floor(Math.random() * 10000)}` }] })) :
+                                []
+                        })).catch(this._debug);
+                    }
+                    return this.handleCreate({ guild, member, category, send })
+                };
+
+                case `${this.prefix}:close`: return send({ ephemeral: true, content: `🤔 Are you sure you want to close this ticket?`, components: [{ type: 1, components: [{ type: 2, custom_id: `${this.prefix}:close:confirm:${this.code(channel.topic?.split?.("ID: ")?.[1])}`, label: "Yes close the ticket", style: 4, emoji: { id: "807031399563264030" } }] }] })
+
+                case `${this.prefix}:modal_submit`: {
+                    let [embed, fields, split] = [new MessageEmbed().setColor("ORANGE"), [], false];
+                    for (const c of int.fields.components) {
+                        for (const cc of c.components) {
+                            if (cc.value && cc.customId) {
+                                fields.push({ name: cc.customId, value: cc.value });
+                                if (cc.value.length <= 1024) embed.addField(cc.customId, cc.value);
+                                else split = true
+                            }
+                        }
+                    }
+                    if (embed.length >= 6000 || split) {
+                        return this.handleCreate({ guild, member, category, send, embeds: fields.map((v, i) => ({
+                            title: `Form Response: ${v.name}`,
+                            color: embed.color,
+                            description: v.value,
+                            author: i === 0 ? { name: member.user.username, iconURL: member.user.displayAvatarURL({ dynamic: true }) } : undefined,
+                            timestamp: fields.length - 1 === i ? new Date() : undefined,
+                            footer: fields.length - 1 === i ? { text: `ID: ${member.id}` } : undefined
+                        })) })
+                    };
+                    
+                    return this.handleCreate({ guild, member, category, send, embeds: [
+                        embed
+                            .setTitle(`Form Responses`)
+                            .setTimestamp()
+                            .setAuthor({ name: member.user.username, iconURL: member.user.displayAvatarURL({ dynamic: true }) })
+                            .setFooter({ text: `ID: ${member.id}` })
+                    ]})
+                }
+            };
+            if (customId.startsWith(`${this.prefix}:close:confirm`)) {
+                let user = this.options.client.users.resolve(customId.split("close:confirm:")[1]) ?? await this.options.client.users.fetch(customId.split("close:confirm:")[1]).catch(() => null);
+                if (!user) return send({ content: `❌ I was unable to fetch the user that opened the ticket.`, ephemeral: true })
+                let messages = await this.fetchMessages(channel, 5000);
+                if (!messages || !messages.length) return send({ ephemeral: true, content: `❌ I was unable to close the ticket, I couldn't fetch the messages in this channel.` })
+                let closed = await channel.delete(`${member.user.tag} (${member.id}) closed the ticket.`).catch(this._debug);
+                if (!closed) return send({ ephemeral: true, content: `${emojis.x} I was unable to delete the channel & close the ticket.` })
+                return this.closeTicket({ channel, guild, user, member, messages });
+            }
+        };
+    };
+
+    /** @private */
+    async handleCreate({ guild, member, category, send, embeds = [] } = {}) {
+        let [support, supportUsers, supportIds] = [[], [], this.getSupportIds()];
+        if (supportIds.roles.length) for (const sup of supportIds.roles) {
+            let role = guild.roles.resolve(sup);
+            if (role) support.push(sup);
+        };
+
+        if (supportIds.users.length) for (const uId of supportIds.users) {
+            let member = guild.members.resolve(uId) || await guild.members.fetch(uId).catch((e) => {
+                if (e?.stack?.includes?.("Unknown Member")) this.options.support.users = this.options.support.users.filter(c => c !== uId);
+                return this._debug(e);
+            });
+            if (member) supportUsers.push(uId);
+        }
+        await send({ ephemeral: true }, true);
+        if (this.options.appeals?.enabled) {
+            let appeals = this.options.appeals;
+            if (appeals.mainserver?.id && appeals.mainserver.checkIfBanned) {
+                let server = this.options.client.guilds.resolve(appeals.mainserver.id);
+                if (server?.available) {
+                    let isBanned = await server.bans.fetch({ user: member.id, force: true }).catch(() => null);
+                    if (!isBanned) return send(
+                        typeof appeals.embeds?.not_banned === "object" ?
+                            appeals.embeds.not_banned :
+                            {
+                                embeds: [
+                                    {
+                                        author: { name: guild.name, icon_url: guild.iconURL({ dynamic: true }) },
+                                        title: "INFO",
+                                        description: `❌ You can't open this ticket due to you not being banned in the main server!`,
+                                        color: 0xFF0000,
+                                        timestamp: new Date()
+                                    }
+                                ]
+                            }
+                    )
+                }
+            }
+        }
+        let [permissions, allow] = [
+            [],
+            ["ADD_REACTIONS", "ATTACH_FILES", "CREATE_INSTANT_INVITE", "EMBED_LINKS", "READ_MESSAGE_HISTORY", "VIEW_CHANNEL", "USE_EXTERNAL_EMOJIS", "SEND_MESSAGES"]
+        ];
+        if (support.length) for (const sup of support) permissions.push({ type: "role", id: sup, allow });
+        if (supportUsers.length) for (const user of supportUsers) permissions.push({ type: "member", id: user, allow });
+
+        /** @type {import("discord.js").TextChannel} */
+        let channel = await guild.channels.create(`${this.options.prefix}-${generate().slice(0, 5).replace(/-|_/g, "")}`, {
+            type: "GUILD_TEXT", parent: category, reason: `Ticket created by: @${member.user.tag} (${member.id})`,
+            topic: `ID: ${this.code(member.id, "e")}`,
+            permissionOverwrites: [
+                { type: "member", id: this.options.client.user.id, allow: ["ADD_REACTIONS", "ATTACH_FILES", "SEND_MESSAGES", "READ_MESSAGE_HISTORY", "EMBED_LINKS", "USE_EXTERNAL_EMOJIS", "VIEW_CHANNEL", "MENTION_EVERYONE"] },
+                { type: "member", id: member.id, allow: ["ADD_REACTIONS", "ATTACH_FILES", "SEND_MESSAGES", "READ_MESSAGE_HISTORY", "EMBED_LINKS", "USE_EXTERNAL_EMOJIS", "VIEW_CHANNEL"], deny: ["MENTION_EVERYONE"] },
+                { type: "role", id: guild.id, deny: ["VIEW_CHANNEL"] },
+                ...permissions
+            ]
+        }).catch(this._debug);
+        if (!channel) return send({ content: `${emojis.x} I was unable to create the ticket channel, if this keeps happening contact one of the staff members via their DMs!` });
+        let msg = await channel.send({
+            content: this.options.ticketOpen?.content?.replace?.(/%user%/gi, member.user.toString())?.replace?.(/%server%/gi, guild.name) || `${member.user.toString()} 👋 Hello, please explain what you need help with.`,
+            embeds: this.options.ticketOpen?.embeds || [{
+                author: { name: guild.name, icon_url: guild.iconURL({ dynamic: true }) },
+                title: `Support will be with you shortly`,
+                color: 0xF50DE3,
+                timestamp: new Date(),
+                footer: { text: `To close this ticket press the button below.` }
+            }],
+            components: [{ type: 1, components: [{ type: 2, custom_id: `${this.prefix}:close`, label: "Close Ticket", style: 4, emoji: { name: "🔒" } }] }]
+        }).catch(this._debug);
+        if (!msg) return null;
+        if (embeds?.length <= 10) for await (const embed of embeds) await channel.send({ embeds: [ embed ] }).catch(this._debug);
+        if (this.webhookOptions.id && this.webhookOptions.token) this.webhook()
+            .embed({
+                author: { name: guild.name, icon_url: guild.iconURL({ dynamic: true }) },
+                title: "Ticket: Opened",
+                description: `${de.user} User: ${member.user.toString()} \`@${member.user.tag}\` (${member.id})\n${de.channel} Channel: \`#${channel.name}\` (${channel.id})`,
+                color: 0xFF000,
+                timestamp: new Date(),
+                footer: { text: `Ticket ID: ${channel.name.split("-")[1]}` },
+            }).send().catch(this._debug);
+        return send({
+            embeds: [
+                {
+                    author: { name: `Ticket Created!`, icon_url: `https://cdn.discordapp.com/emojis/476629550797684736.gif` },
+                    description: channel.toString(),
+                    color: 0xFF000
+                }
+            ],
+            components: [ { type: 1, components: [ button({ title: "Go to ticket", url: msg.url }) ] } ]
+        })
+    }
+
+    button(options = { style: 3, label: "Create Ticket", emoji: { name: "📩" } }) {
+        return button({
+            id: options?.id || this.prefix,
+            style: options.style || 3,
+            title: options.label,
+            emoji: options.emoji
+        });
+    };
+
+    /**
+     * @param {object} options 
+     * @param {string} [options.title] The title of the modal submit form 
+     * @param {import("@elara-services/packages").Modal['components']} [options.components]
+     */
+    modal(options = { title: "", components: [] }) {
+        return modal({
+            id: `${this.prefix}:modal_submit`,
+            title: options?.title || "Create Ticket",
+            components: options?.components?.length >= 1 ? options.components : [
+                {
+                    type: 1, components: [
+                        { type: 4, min_length: 10, max_length: 4000, custom_id: "message", label: "Content", style: 2, placeholder: "What's the ticket about?", required: true }
+                    ]
+                }
+            ]
+        })
+    }
+
+    async starterMessage(channelId, options) {
+        let channel = this.options.client.channels.resolve(channelId);
+        if (!channel) return Promise.reject(`No channel found for: ${channelId}`);
+        if (!channel.isText()) return Promise.reject(`The channel ID provided isn't a text-based-channel`);
+        if (!channel.permissionsFor?.(this.options.client.user.id)?.has?.(["VIEW_CHANNEL", "SEND_MESSAGES", "EMBED_LINKS", "ATTACH_FILES", "READ_MESSAGE_HISTORY"])) return Promise.reject(`I'm missing permissions in ${channel.name} (${channelId})`);
+        return channel.send({
+            content: options?.content,
+            files: options?.attachments,
+            embeds: options?.embeds,
+            components: options?.components || [{ type: 1, components: [this.button()] }]
+        })
+            .then(() => console.log(`Sent the starter message in ${channel.name} (${channel.id})`))
+    };
+
+    code(id, type = "d") {
+        try {
+            switch (type) {
+                case "e": return encrypt(this.options.encryptToken, id);
+                case "d": return decrypt(this.options.encryptToken, id);
+            }
+        } catch {
+            return id;
+        }
     };
 
     async fetchMessages(channel, limit = 50, before, after, around) {
         if (limit && limit > 100) {
             let logs = [];
             const get = async (_before, _after) => {
-                const messages = [ ...(await channel.messages.fetch({ limit: 100, before: _before || undefined, after: _after || undefined }).catch(() => new Collection())).values() ];
+                const messages = [...(await channel.messages.fetch({ limit: 100, before: _before || undefined, after: _after || undefined }).catch(() => new Collection())).values()];
                 if (limit <= messages.length) {
                     return (_after ? messages.slice(messages.length - limit, messages.length).map((message) => message).concat(logs) : logs.concat(messages.slice(0, limit).map((message) => message)));
                 }
@@ -30,19 +268,26 @@ module.exports = class Tickets {
             };
             return get(before, after);
         }
-        return [ ...(await channel.messages.fetch({ limit, before, after, around }).catch(() => new Collection())).values() ];
+        return [...(await channel.messages.fetch({ limit, before, after, around }).catch(() => new Collection())).values()];
     };
 
+    /**
+     * @param {import("discord.js").TextBasedChannel} channel 
+     * @param {import("discord.js").Message[]} messages 
+     * @param {string} ticketID 
+     * @param {string} type 
+     * @returns {string}
+     */
     displayMessages(channel, messages = [], ticketID, type) {
         let users = [];
         for (const i of messages.values()) {
             let f = users.find(c => c.user.id === i.author.id);
             if (f) f.count++; else users.push({ user: i.author, count: 1 });
         };
-        return [`<discord-messages>`, `<discord-message author="${type} Ticket: ${ticketID}" bot="true" verified avatar="https://cdn.discordapp.com/emojis/847397714677334066.png?v=1" role-color="#1da1f2">Total Messages: ${users.map(c => c.count).reduce((a, b) => a + b, 0).toLocaleString()}<br>${users.map(c => `<discord-mention type="role" color="${channel.guild?.members?.cache?.get(c.user.id)?.displayColor ? channel.guild?.members?.cache?.get(c.user.id)?.displayHexColor : `#ffffff`}">${c.user.tag}</discord-mention> (${c.user.id})`).join("<br>")}</discord-message></discord-messages><discord-messages>`,
+        return [`<discord-messages>`, `<discord-message author="${type} Ticket: ${ticketID}" bot="true" verified avatar="https://cdn.discordapp.com/emojis/847397714677334066.png?v=1" role-color="#1da1f2">Total Messages: ${users.map(c => c.count).reduce((a, b) => a + b, 0).toLocaleString()}<br>${users.map(c => `<discord-mention type="role" color="${channel.guild?.members?.resolve?.(c.user.id)?.displayColor ? channel.guild?.members?.resolve?.(c.user.id)?.displayHexColor : `#ffffff`}">${c.user.tag}</discord-mention> (${c.user.id})`).join("<br>")}</discord-message></discord-messages><discord-messages>`,
             ...messages.map(message => {
                 let str = [
-                    `<discord-message${message.author.bot ? ` bot="true"` : ""} timestamp="${message.createdAt.toLocaleString("en-US", { timeZone: "America/Los_Angeles" })} (PST/PDT) | ${message.createdAt.toLocaleString("en-GB", { timeZone: "Europe/London" })} (BST/British Time)" author="${message.author.username}" avatar=${message.author.displayAvatarURL({ dynamic: true, format: "png" })} role-color="${channel.guild?.members?.cache?.get(message.author.id)?.displayColor ? channel.guild?.members?.cache?.get(message.author.id)?.displayHexColor : `#ffffff`}">`
+                    `<discord-message${message.author.bot ? ` bot="true" ${message.author.flags?.has?.("VERIFIED_BOT") ? `verified="true"` : ""}` : ""} new_timestamp="${message.createdAt.toISOString()}" author="${message.author.username}" avatar=${message.author.displayAvatarURL({ dynamic: true, format: "png" })} role-color="${channel.guild?.members?.cache?.get(message.author.id)?.displayColor ? channel.guild?.members?.cache?.get(message.author.id)?.displayHexColor : `#ffffff`}">`
                 ];
                 if (message.content) {
                     let content = message.content;
@@ -51,40 +296,76 @@ module.exports = class Tickets {
                     if (message.mentions.roles.size) for (const role of message.mentions.roles.values()) content = content.replace(new RegExp(role.toString(), "g"), `<discord-mention type="role" color="${role.hexColor}">${role.name}</discord-mention>`)
                     str.push(content)
                 };
+                if (message.embeds?.length) {
+                    let arr = [ `<discord-embeds slot="embeds">` ];
+                    for (const embed of message.embeds) {
+                        let emb = [
+                            `<discord-embed slot="embed" ${embed.thumbnail?.url ? `thumbnail="${embed.thumbnail.url}"` : ""} ${embed.image?.url ? `image="${embed.image.url}"` : ""} ${embed.author ? `${embed.author.name ? `author-name="${embed.author.name}"` : ""} ${embed.author.iconURL ? `author-image="${embed.author.iconURL}"` : ""} ${embed.author.url ? `author-url="${embed.author.url}"` : ""}` : ""} ${embed.title ? `embed-title="${embed.title}"` : ""}${embed.color ? `color="${embed.hexColor}"` : ""}>`
+                        ];
+                        if (embed.description) emb.push(`<discord-embed-description slot="description">${embed.description}</discord-embed-description>`);
+                        if (embed.fields?.length) {
+                            emb.push(`<discord-embed-fields slot="fields">`)
+                            for (const field of embed.fields) emb.push(`<discord-embed-field field-title="${field.name}" ${field.inline ? `inline` : ""}>${field.value}</discord-embed-field>`)
+                        }
+                        arr.push(...emb, `</discord-embed>`)
+                    }
+                    str.push(...arr, "</discord-embeds>")
+                }
+                if (message.interaction?.user) str.push(`<discord-command slot="reply" command="${message.interaction.type === "APPLICATION_COMMAND" ? "/" : ""}${message.interaction.commandName}" profile="${message.interaction.user.id}" role-color="${channel.guild?.members?.resolve?.(message.interaction.user?.id)?.displayHexColor || "#fffff"}" author="${message.interaction.user.tag}" avatar="${message.interaction.user.displayAvatarURL({ dynamic: true })}"></discord-command>`)
+                if (message.components?.length) {
+                    let row = [
+                        `<discord-attachments slot="components">`
+                    ],
+                        styles = {
+                            "PRIMARY": "primary",
+                            "SECONDARY": "secondary",
+                            "SUCCESS": "success",
+                            "DANGER": "destructive",
+                            "LINK": "secondary"
+                        }
+                    for (const components of message.components) {
+                        row.push(`<discord-action-row>`)
+                        for (const c of components.components) {
+                            if (c.type === "BUTTON") row.push(`<discord-button ${c.disabled ? `disabled=true` : ""} type="${styles[c.style]}" ${c.emoji?.name ? `emoji-name="${c.emoji.name}"` : ""} ${c.emoji?.id ? `emoji="https://cdn.discordapp.com/emojis/${c.emoji.id}.${c.emoji.animated ? "gif" : "png"}"` : ""} ${c.url ? `url="${c.url}"` : ""}>${c.label || ""}</discord-button>`)
+                        }
+                        row.push(`</discord-action-row>`)
+                    }
+                    if (row.length >= 2) str.push(...row, `</discord-attachments>`)
+                }
                 if (message.attachments.size) str.push(message.attachments.map((c) => `<a href="${c.proxyURL}">${c.name}</a>`).join("<br>"))
-                str.push(`<br><br><code style="background-color: #36393e; color: white;">ID: ${message.id}</code>`)
+                str.push(`${message.content?.length ? `<br><br>` : "" }<code style="background-color: #36393e; color: white;">ID: ${message.id}</code>`)
                 return [...str, `</discord-message>`].join(" ");
             }),
             "</discord-messages>"].join(" ");
     };
 
     async closeTicket({ member, messages, channel, guild, user } = {}) {
-        if (!this.options.webhookId || !this.options.webhookToken) return; 
+        const { id, token, username, avatar: avatarURL } = this.webhookOptions;
+        if (!id || !token) return;
         let embeds = [
             {
                 author: { name: guild.name, icon_url: guild.iconURL({ dynamic: true }) },
                 title: "Ticket: Closed",
-                description: `▫️User: ${user.toString()} \`@${user.tag}\` (${user.id})\n▫️Closed By: ${member.toString()} (${member.id})\n▫️Channel: \`#${channel.name}\` (${channel.id})`,
+                description: `${de.user}User: ${user.toString()} \`@${user.tag}\` (${user.id})\n${de.user}Closed By: ${member.toString()} (${member.id})\n${de.channel}Channel: \`#${channel.name}\` (${channel.id})`,
                 color: 0xFF0000,
                 timestamp: new Date(),
                 footer: { text: `Ticket ID: ${channel.name.split("-")[1]}` },
             }
         ];
-        new WebhookClient({ id: this.options.webhookId, token: this.options.webhookToken })
-            .send({ 
-                username: this.options.webhookUsername || "Tickets", 
-                avatarURL: this.options.webhookAvatar || "https://cdn.discordapp.com/emojis/818757771310792704.png?v=1", 
-                embeds, 
-                files: [ { name: "transcript.txt", attachment: Buffer.from(this.displayMessages(channel, messages.reverse(), channel.name.split("-")[1], this.options.prefix)) } ] 
+        new WebhookClient({ id, token })
+            .send({
+                username, avatarURL,
+                embeds,
+                files: [{ name: "transcript.txt", attachment: Buffer.from(this.displayMessages(channel, messages.reverse(), channel.name.split("-")[1], this.options.prefix)) }]
             })
             .then(m => {
-                let components = [{ type: 2, style: 5, label: "Transcript", emoji: { name: "📝" }, url: `https://my.elara.services/tickets?url=${Array.isArray(m.attachments) ? m.attachments?.[0]?.url : m.attachments instanceof Collection ? m.attachments?.first?.()?.url : "URL_NOT_FOUND" ?? "URL_NOT_FOUND"}` }];
-                
+                let components = [{ type: 2, style: 5, label: "Transcript", emoji: { id: "792290922749624320" }, url: `https://my.elara.services/tickets?url=${Array.isArray(m.attachments) ? m.attachments?.[0]?.url : m.attachments instanceof Collection ? m.attachments?.first?.()?.url : "URL_NOT_FOUND" ?? "URL_NOT_FOUND"}` }];
+                embeds[0].description += `\n${de.transcript} Transcript: [View here](${components[0].url})`
                 this.webhook()
-                .embeds(embeds)
-                .button({ type: 1, components })
-                .edit(m.id)
-                .catch(() => null);
+                    .embeds(embeds)
+                    .button({ type: 1, components })
+                    .edit(m.id)
+                    .catch(this._debug);
                 if (user) user.send({
                     embeds: [{
                         author: { name: guild.name, icon_url: guild.iconURL({ dynamic: true }) },
@@ -94,151 +375,30 @@ module.exports = class Tickets {
                         footer: { text: `Ticket ID: ${channel.name.split("-")[1]}` }
                     }],
                     components: [{ type: 1, components }]
-                }).catch(() => null)
-            })
-            .catch((e) => console.log(e));
-    };
-
-    async run(int) {
-        if (int?.isButton?.()) {
-            let { guild, channel, member, customId } = int,
-                  category = guild?.channels?.resolve?.(this.options.ticketCategory || channel?.parentId),
-                [ support, supportUsers ] = [ [], [] ];
-            if (!guild || !guild.available || !channel || !member || !category) return;
-            if (this.options?.supportRoleIds?.length) for (const sup of this.options.supportRoleIds) {
-                let role = guild.roles.resolve(sup);
-                if (role) support.push(sup);
-            };
-
-            if (this.options?.supportUserIds?.length) for (const uId of this.options.supportUserIds) {
-                let member = guild.members.resolve(uId) || await guild.members.fetch(uId).catch((e) => {
-                    if (e?.stack?.includes?.("Unknown Member")) this.options.supportUserIds = this.options.supportUserIds.filter(c => c !== uId);
-                    return null;
-                });
-                if (member) supportUsers.push(uId);
-            }
-            /**
-             * @param {import("discord.js").InteractionDeferReplyOptions|import("discord.js").InteractionReplyOptions} options 
-             * @param {boolean} edit 
-             * @param {boolean} defer 
-             */
-            const send = async (options = {}, defer = false) => {
-                if (defer) return int.deferReply(options).catch(() => null);
-                if (int.replied || int.deferred) return int.editReply(options).catch(() => null);
-                return int.reply(options).catch(() => null);
-            };
-            switch (customId) {
-                case this.prefix: {
-                    await send({ ephemeral: true }, true);
-                    if (this.options.appeals?.enabled) {
-                        let appeals = this.options.appeals;
-                        if (appeals.mainserver?.id && appeals.mainserver.checkIfBanned) {
-                            let server = this.options.client.guilds.resolve(appeals.mainserver.id);
-                            if (server?.available) {
-                                let isBanned = await server.bans.fetch({ user: member.id, force: true }).catch(() => null);
-                                if (!isBanned) return send(
-                                    typeof appeals.embeds?.not_banned === "object" ? 
-                                    appeals.embeds.not_banned : 
-                                    { embeds: [
-                                        { 
-                                            author: { name: guild.name, icon_url: guild.iconURL({ dynamic: true }) },
-                                            title: "INFO", 
-                                            description: `❌ You can't open this ticket due to you not being banned in the main server!`, 
-                                            color: 0xFF0000, 
-                                            timestamp: new Date() 
-                                        }
-                                    ]}
-                                )
-                            }
-                        }
-                    }
-                    let [ permissions, allow ] = [
-                        [],
-                        [ "ADD_REACTIONS", "ATTACH_FILES", "CREATE_INSTANT_INVITE", "EMBED_LINKS", "READ_MESSAGE_HISTORY", "VIEW_CHANNEL", "USE_EXTERNAL_EMOJIS", "SEND_MESSAGES" ]
-                    ];
-                    if (support.length) for (const sup of support) permissions.push({ type: "role", id: sup, allow });
-                    if (supportUsers.length) for (const user of supportUsers) permissions.push({ type: "member", id: user, allow });
-                    
-                    /** @type {import("discord.js").TextChannel} */
-                    let channel = await guild.channels.create(`${this.options.prefix}-${generate().slice(0, 5).replace(/-|_/g, "")}`, {
-                        type: "GUILD_TEXT", parent: category, reason: `Ticket created by: @${member.user.tag} (${member.id})`,
-                        topic: `ID: ${this.code(member.id, "e")}`,
-                        permissionOverwrites: [
-                            { type: "member", id: this.options.client.user.id, allow: ["ADD_REACTIONS", "ATTACH_FILES", "SEND_MESSAGES", "READ_MESSAGE_HISTORY", "EMBED_LINKS", "USE_EXTERNAL_EMOJIS", "VIEW_CHANNEL", "MENTION_EVERYONE"] },
-                            { type: "member", id: member.id, allow: ["ADD_REACTIONS", "ATTACH_FILES", "SEND_MESSAGES", "READ_MESSAGE_HISTORY", "EMBED_LINKS", "USE_EXTERNAL_EMOJIS", "VIEW_CHANNEL"], deny: ["MENTION_EVERYONE"] },
-                            { type: "role", id: guild.id, deny: ["VIEW_CHANNEL"] },
-                            ...permissions
-                        ]
-                    }).catch((err) => { console.log(err); return null; });
-                    if (!channel) return send({ content: `${emojis.x} I was unable to create the ticket channel, if this keeps happening contact one of the staff members via their DMs!` });
-                    let msg = await channel.send({
-                        content: this.options.ticketOpen?.content?.replace?.(/%user%/gi, member.user.toString())?.replace?.(/%server%/gi, guild.name) || `${member.user.toString()} 👋 Hello, please explain what you need help with.`,
-                        embeds: this.options.ticketOpen?.embeds || [{
-                            author: { name: guild.name, icon_url: guild.iconURL({ dynamic: true }) },
-                            title: `Support will be with you shortly`,
-                            color: 0xF50DE3,
-                            timestamp: new Date(),
-                            footer: { text: `To close this ticket press the button below.` }
-                        }],
-                        components: [{ type: 1, components: [{ type: 2, custom_id: `${this.prefix}:close`, label: "Close Ticket", style: 4, emoji: { name: "🔒" } }] }]
-                    }).catch(() => null);
-                    if (!msg) return null
-                    if (this.options.webhookId && this.options.webhookToken) this.webhook()
-                    .embed({
-                        author: { name: guild.name, icon_url: guild.iconURL({ dynamic: true }) },
-                        title: "Ticket: Opened",
-                        description: `▫️User: ${member.user.toString()} \`@${member.user.tag}\` (${member.id})\n▫️Channel: \`#${channel.name}\` (${channel.id})`,
-                        color: 0xFF000,
-                        timestamp: new Date(),
-                        footer: { text: `Ticket ID: ${channel.name.split("-")[1]}` },
-                    }).send().catch((e) => console.log(e));
-                    return send({ content: `✅ Ticket created: ${channel.toString()}`, components: [
-                        { type: 1, components: [
-                            { type: 2, style: 5, url: msg.url, label: "Go to ticket" }
-                        ] }
-                    ] })
-                };
-    
-                case `${this.prefix}:close`: return send({ ephemeral: true, content: `🤔 Are you sure you want to close this ticket?`, components: [{ type: 1, components: [{ type: 2, custom_id: `${this.prefix}:close:confirm:${this.code(channel.topic?.split?.("ID: ")?.[1])}`, label: "Yes close the ticket", style: 4, emoji: { id: "807031399563264030" } }] }] })
-            };
-            if (customId.startsWith(`${this.prefix}:close:confirm`)) {
-                let user = this.options.client.users.resolve(customId.split("close:confirm:")[1]) ?? await this.options.client.users.fetch(customId.split("close:confirm:")[1]).catch(() => null);
-                if (!user) return send({ content: `❌ I was unable to fetch the user that opened the ticket.`, ephemeral: true })
-                let messages = await this.fetchMessages(channel, 5000);
-                if (!messages || !messages.length) return send({ ephemeral: true, content: `❌ I was unable to close the ticket, I couldn't fetch the messages in this channel.` })
-                let closed = await channel.delete(`${member.user.tag} (${member.id}) closed the ticket.`).catch(() => null);
-                if (!closed) return send({ ephemeral: true, content: `${emojis.x} I was unable to delete the channel & close the ticket.` })
-                return this.closeTicket({ channel, guild, user, member, messages });
-            }
-        };
-    };
-
-    async starterMessage(channelId, options) {
-        let channel = this.options.client.channels.resolve(channelId);
-        if (!channel) return Promise.reject(`No channel found for: ${channelId}`);
-        if (!channel.isText()) return Promise.reject(`The channel ID provided isn't a text-based-channel`);
-        if (!channel.permissionsFor?.(this.options.client.user.id)?.has?.([ "VIEW_CHANNEL", "SEND_MESSAGES", "EMBED_LINKS", "ATTACH_FILES", "READ_MESSAGE_HISTORY" ])) return Promise.reject(`I'm missing permissions in ${channel.name} (${channelId})`);
-        return channel.send({
-            content: options?.content,
-            files: options?.attachments,
-            embeds: options?.embeds,
-            components: options?.components || [ { type: 1, components: [ this.button() ] } ]
-        })
-        .then(() => console.log(`Sent the starter message in ${channel.name} (${channel.id})`))
+                }).catch(this._debug);
+            }).catch(this._debug);
     };
+    /**
+     * @typedef {Object} getSupportResponse
+     * @property {string[]} [roles]
+     * @property {string[]} [users]
+     * 
+     * 
+     * @private
+     * @returns {getSupportResponse}
+     */
+    getSupportIds() {
+        return {
+            roles: this.options.support?.roles || this.options.supportRoleIds || [],
+            users: this.options.support?.users || this.options.supportUserIds || []
+        }
+    }
 
-    button(options = { style: 3, label: "Create Ticket", emoji: { name: "📩" } }) {
-        return { type: 2, custom_id: options?.id || this.prefix, style: options.style || 3, label: options.label, emoji: options.emoji };
-    };
+    /** @private */
+    _debug(...args) {
+        if (!this.options?.debug) return null;
+        console.log(...args);
+        return null;
+    }
 
-    code(id, type = "d") {
-        try {
-            switch (type) {
-                case "e": return encrypt(this.options.encryptToken, id);
-                case "d": return decrypt(this.options.encryptToken, id);
-            }
-        } catch { 
-            return id; 
-        }
-    };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elara-services/tickets",
-  "version": "1.6.0",
+  "version": "2.0.2",
   "description": "Helper for tickets",
   "main": "index.js",
   "types": "index.d.ts",
@@ -11,6 +11,7 @@
     "discord.js": "13.8.0"
   },
   "dependencies": {
+    "@elara-services/packages": "5.0.0",
     "aes256": "1.1.0",
     "discord-hook": "2.0.0",
     "shortid": "2.2.16"