Version update

V7.7.2 Final release

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+.DS_Store

Addons/addon.js

@@ -1,26 +0,0 @@
-const Discord = require("discord.js");
-const fs = require("fs");
-const yaml = require("js-yaml");
-const { Command } = require('../Structures/Addon.js'); // Adjust the path as needed
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-
-module.exports = new Command({
-    name: "addon",
-    description: "This is a sample addon!",
-    options: [],
-    permissions: ["Administrator"],
-  
-    async run(interaction) {
-      let disableCommand = true;
-  
-      const PingEmbed = new Discord.EmbedBuilder()
-        .setDescription(
-          `This is a sample addon.\n\nPong! \`${interaction.client.ws.ping} ms\``
-        )
-        .setColor(supportbot.Embed.Colours.General);
-  
-      interaction.reply({
-        embeds: [PingEmbed],
-      });
-    },
-  });

Addons/hello.js

@@ -0,0 +1,45 @@
+// SupportBot | Emerald Services
+// Example (default) Addon
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+// Your Addon Config file! Saved in /Addons/Configs/YourAddonConfig.yml
+// const config = yaml.load(fs.readFileSync('./Addons/Configs/YourAddonConfig.yml', 'utf8'));
+
+const { Command, Event } = require("../Structures/Addon");
+
+module.exports.commands = [
+  /*
+  // EXAMPLE COMMAND
+  new Command({
+    name: "hello",
+    description: "hello",
+    options: [],
+    permissions: ["SEND_MESSAGES"],
+    async run(interaction) {
+      const Embed = new Discord.MessageEmbed()
+        .setDescription("Hello World!")
+        .setColor(supportbot.InfoColour);
+
+      interaction.reply({
+        embeds: [Embed],
+      });
+    },
+  }),
+  */
+];
+module.exports.events = [
+  /*
+  // EXAMPLE EVENT
+  new Event("ready", async (client) => {
+    console.log("Bot started!");
+  }), 
+  */
+];

Commands/add.js

@@ -0,0 +1,92 @@
+// SupportBot | Emerald Services
+// Ticket Add Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.TicketAdd,
+  description: cmdconfig.TicketAddDesc,
+  options: [
+    {
+      name: "user",
+      description: "User to add",
+      type: "USER",
+      required: true,
+    },
+  ],
+  permissions: ["SEND_MESSAGES"],
+
+  async run(interaction) {
+    const { getRole } = interaction.client;
+    let SupportStaff = await getRole(supportbot.Staff, interaction.guild);
+    let Admin = await getRole(supportbot.Admin, interaction.guild);
+    if (!SupportStaff || !Admin)
+      return interaction.reply(
+        "Some roles seem to be missing!\nPlease check for errors when starting the bot."
+      );
+
+    const NoPerms = new Discord.MessageEmbed()
+      .setTitle("Invalid Permissions!")
+      .setDescription(
+        `${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``
+      )
+      .setColor(supportbot.WarningColour);
+
+    if (
+      !interaction.member.roles.cache.has(SupportStaff.id) &&
+      !interaction.member.roles.cache.has(Admin.id)
+    )
+      return interaction.reply({ ephemeral: true, embeds: [NoPerms] });
+
+    let TicketData = await JSON.parse(
+      fs.readFileSync("./Data/TicketData.json", "utf8")
+    );
+    let ticket = await TicketData.tickets.findIndex(
+      (t) => t.id === interaction.channel.id
+    );
+    if (ticket === -1) {
+      const Exists = new Discord.MessageEmbed()
+        .setTitle("No Ticket Found!")
+        .setDescription(supportbot.NoValidTicket)
+        .setColor(supportbot.WarningColour);
+      return interaction.reply({ ephemeral: true, embeds: [Exists] });
+    }
+
+    let uMember = interaction.options.getUser("user");
+    const UserNotExist = new Discord.MessageEmbed()
+      .setTitle("User Not Found!")
+      .setDescription(
+        `${supportbot.UserNotFound}\n\nTry Again:\`/${cmdconfig.TicketAdd} <user#0000>\``
+      )
+      .setColor(supportbot.ErrorColour);
+
+    if (!uMember) return interaction.reply({ embeds: [UserNotExist] });
+
+    await interaction.channel.permissionOverwrites.edit(uMember.id, {
+      VIEW_CHANNEL: true,
+    });
+    const Complete = new Discord.MessageEmbed()
+      .setTitle("User Added!")
+      .setDescription(supportbot.AddedUser.replace(/%user%/g, uMember.id))
+      .setTimestamp()
+      .setColor(supportbot.EmbedColour);
+    interaction.reply({ embeds: [Complete] });
+    TicketData.tickets[ticket].subUsers.push(uMember.id);
+    fs.writeFileSync(
+      "./Data/TicketData.json",
+      JSON.stringify(TicketData, null, 4),
+      (err) => {
+        if (err) console.error(err);
+      }
+    );
+  },
+});

Commands/addUser.js

@@ -1,217 +0,0 @@
-const fs = require("fs");
-const {
-  EmbedBuilder,
-  ApplicationCommandOptionType,
-  ApplicationCommandType,
-  ActionRowBuilder,
-  ButtonBuilder,
-  ButtonStyle,
-  ChannelType,
-} = require("discord.js");
-const yaml = require("js-yaml");
-
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
-const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-
-const Command = require("../Structures/Command.js");
-
-module.exports = new Command({
-  name: cmdconfig.AddUser.Command,
-  description: cmdconfig.AddUser.Description,
-  type: ApplicationCommandType.ChatInput,
-  options: [
-    {
-      name: "user",
-      description: "The user to add",
-      type: ApplicationCommandOptionType.User,
-      required: true,
-    },
-  ],
-  permissions: cmdconfig.AddUser.Permission,
-
-  async run(interaction) {
-    const userToAdd = interaction.options.getUser("user");
-    const ticketChannel = interaction.channel;
-    const ticketDataPath = "./Data/TicketData.json";
-
-    if (
-      (supportbot.Ticket.TicketType === "threads" && !ticketChannel.isThread()) ||
-      (supportbot.Ticket.TicketType === "channels" && ticketChannel.type !== ChannelType.GuildText)
-    ) {
-      const onlyInTicket = new EmbedBuilder()
-        .setTitle(msgconfig.AddUser.NotInTicket_Title)
-        .setDescription(msgconfig.AddUser.NotInTicket_Description)
-        .setColor(supportbot.Embed.Colours.Error);
-
-      return interaction.reply({
-        embeds: [onlyInTicket],
-        ephemeral: true,
-      });
-    }
-
-    const ticketInviteEmbed = new EmbedBuilder()
-      .setTitle(msgconfig.AddUser.Invite_Title)
-      .setDescription(msgconfig.AddUser.Invite_Description.replace("%username%", userToAdd.username))
-      .setColor(supportbot.Embed.Colours.General);
-
-    await interaction.reply({
-      embeds: [ticketInviteEmbed],
-      ephemeral: true,
-    });
-
-    try {
-      const dmEmbed = new EmbedBuilder()
-        .setTitle(msgconfig.AddUser.DM_Title)
-        .setDescription(msgconfig.AddUser.DM_Description.replace("%channelname%", ticketChannel.name))
-        .setColor(supportbot.Embed.Colours.General);
-
-      const acceptButton = new ButtonBuilder()
-        .setCustomId("accept_invite")
-        .setLabel(msgconfig.AddUser.Accept_Label)
-        .setEmoji("✅")
-        .setStyle(ButtonStyle.Primary);
-
-      const rejectButton = new ButtonBuilder()
-        .setCustomId("reject_invite")
-        .setLabel(msgconfig.AddUser.Reject_Label)
-        .setEmoji("❌")
-        .setStyle(ButtonStyle.Secondary);
-
-      const row = new ActionRowBuilder().addComponents(acceptButton, rejectButton);
-
-      const dmMessage = await userToAdd.send({
-        embeds: [dmEmbed],
-        components: [row],
-      });
-
-      const filter = (i) => i.user.id === userToAdd.id;
-      const collector = dmMessage.createMessageComponentCollector({
-        filter,
-        time: 60000,
-      });
-
-      collector.on("collect", async (i) => {
-        if (i.customId === "accept_invite") {
-          try {
-            // Add user to thread or channel based on TicketType
-            if (supportbot.Ticket.TicketType === "threads") {
-              await ticketChannel.members.add(userToAdd.id); // For threads
-            } else if (supportbot.Ticket.TicketType === "channels") {
-              await ticketChannel.permissionOverwrites.create(userToAdd.id, {
-                ViewChannel: true,
-                SendMessages: true,
-                ReadMessageHistory: true,
-              }); // For channels
-            }
-
-            const ticketData = JSON.parse(fs.readFileSync(ticketDataPath, "utf8"));
-            const ticketIndex = ticketData.tickets.findIndex((t) => t.id === ticketChannel.id);
-            if (ticketIndex !== -1) {
-              ticketData.tickets[ticketIndex].subUsers.push(userToAdd.id);
-              fs.writeFileSync(ticketDataPath, JSON.stringify(ticketData, null, 4));
-            }
-
-            const acceptedEmbed = new EmbedBuilder()
-              .setTitle(msgconfig.AddUser.Accepted_Title)
-              .setDescription(msgconfig.AddUser.Accepted_Message)
-              .setColor(supportbot.Embed.Colours.Success);
-
-            await i.update({
-              embeds: [acceptedEmbed],
-              components: [],
-            });
-
-            // Send the added user ticket message in the ticket channel
-
-              const addeduserTicket = new EmbedBuilder()
-                .setTitle(msgconfig.AddUser.Added_Title)
-                .setDescription(msgconfig.AddUser.Added_Description.replace('%username%', userToAdd.username))
-                .setColor(supportbot.Embed.Colours.General);
-
-              await ticketChannel.send({
-                embeds: [addeduserTicket],
-              });
-
-
-            const addedToTicketEmbed = new EmbedBuilder()
-              .setTitle(msgconfig.AddUser.AddedToTicket_Title)
-              .setDescription(msgconfig.AddUser.AddedToTicket_Description.replace(
-                "%channel_link%",
-                `[${ticketChannel.name}](https://discord.com/channels/${ticketChannel.guild.id}/${ticketChannel.id})`
-              ))
-              .setColor(supportbot.Embed.Colours.General);
-
-            const ticketLinkButton = new ButtonBuilder()
-              .setLabel(msgconfig.AddUser.ViewTicket_Label)
-              .setURL(`https://discord.com/channels/${ticketChannel.guild.id}/${ticketChannel.id}`)
-              .setStyle(ButtonStyle.Link);
-
-            await userToAdd.send({
-              embeds: [addedToTicketEmbed],
-              components: [new ActionRowBuilder().addComponents(ticketLinkButton)],
-            });
-
-          } catch (err) {
-            console.error("Error adding user to the ticket:", err);
-
-            const errorEmbed = new EmbedBuilder()
-              .setTitle(msgconfig.AddUser.Error_Title)
-              .setDescription(msgconfig.AddUser.Error_Adding)
-              .setColor(supportbot.Embed.Colours.Error);
-
-            await i.update({
-              embeds: [errorEmbed],
-              components: [],
-            });
-          }
-        } else {
-          const declinedEmbed = new EmbedBuilder()
-            .setTitle(msgconfig.AddUser.Declined_Title)
-            .setDescription(msgconfig.AddUser.Declined_Message)
-            .setColor(supportbot.Embed.Colours.Error);
-
-          await i.update({
-            embeds: [declinedEmbed],
-            components: [],
-          });
-        }
-      });
-
-      collector.on("end", (collected) => {
-        if (collected.size === 0) {
-          userToAdd.send({
-            embeds: [
-              new EmbedBuilder()
-                .setTitle(msgconfig.AddUser.NoResponse_Title)
-                .setDescription(msgconfig.AddUser.NoResponse_Message)
-                .setColor(supportbot.Embed.Colours.Warning),
-            ],
-          });
-        }
-      });
-    } catch (error) {
-      if (error.code === 50007) {
-        const errorEmbed = new EmbedBuilder()
-          .setTitle(msgconfig.AddUser.DM_Error_Title)
-          .setDescription(msgconfig.AddUser.DM_Error_Description.replace("%username%", userToAdd.username))
-          .setColor(supportbot.Embed.Colours.Error);
-
-        await ticketChannel.send({
-          embeds: [errorEmbed],
-        });
-      } else {
-        console.error("Error sending DM:", error);
-
-        const unexpectedErrorEmbed = new EmbedBuilder()
-          .setTitle(msgconfig.AddUser.Unexpected_Error_Title)
-          .setDescription(msgconfig.AddUser.Unexpected_Error_Description.replace("%error%", error.message))
-          .setColor(supportbot.Embed.Colours.Error);
-
-        await ticketChannel.send({
-          embeds: [unexpectedErrorEmbed],
-        });
-      }
-    }
-  },
-});

Commands/close.js

@@ -1,426 +1,199 @@
+// SupportBot | Emerald Services
+// Close Ticket Command
+
 const fs = require("fs");
+
 const Discord = require("discord.js");
 const yaml = require("js-yaml");
-
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
 const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
 
 const Command = require("../Structures/Command.js");
 
 module.exports = new Command({
-  name: cmdconfig.CloseTicket.Command,
-  description: cmdconfig.CloseTicket.Description,
-  type: Discord.ApplicationCommandType.ChatInput,
+  name: cmdconfig.CloseTicket,
+  description: cmdconfig.CloseTicketDesc,
   options: [
     {
       name: "reason",
       description: "Ticket Close Reason",
-      type: Discord.ApplicationCommandOptionType.String,
-    }
+      type: "STRING",
+    },
   ],
-  permissions: cmdconfig.CloseTicket.Permission,
+  permissions: ["SEND_MESSAGES"],
 
   async run(interaction) {
     const { getRole, getChannel } = interaction.client;
-
-    if (supportbot.Ticket.Close.StaffOnly) {
-      let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
-      let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
-
-      if (!SupportStaff || !Admin) {
-        return interaction.reply("Some roles seem to be missing! Please check for errors when starting the bot.");
-      }
-
-      const NoPerms = new Discord.EmbedBuilder()
+    if (supportbot.StaffOnly) {
+      let SupportStaff = await getRole(supportbot.Staff, interaction.guild);
+      let Admin = await getRole(supportbot.Admin, interaction.guild);
+      if (!SupportStaff || !Admin)
+        return interaction.reply(
+          "Some roles seem to be missing!\nPlease check for errors when starting the bot."
+        );
+      const NoPerms = new Discord.MessageEmbed()
         .setTitle("Invalid Permissions!")
-        .setDescription(`${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``)
-        .setColor(supportbot.Embed.Colours.Warn);
+        .setDescription(
+          `${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``
+        )
+        .setColor(supportbot.WarningColour);
 
-      if (!interaction.member.roles.cache.has(SupportStaff.id) && !interaction.member.roles.cache.has(Admin.id)) {
+      if (
+        !interaction.member.roles.cache.has(SupportStaff.id) &&
+        !interaction.member.roles.cache.has(Admin.id)
+      )
         return interaction.reply({ embeds: [NoPerms] });
-      }
     }
-
-    const isThread = interaction.channel.type === Discord.ChannelType.PrivateThread;
-    if (
-      (supportbot.Ticket.TicketType === "threads" && !isThread) ||
-      (supportbot.Ticket.TicketType === "channels" && interaction.channel.type !== Discord.ChannelType.GuildText)
-    ) {
-      const NotTicketChannel = new Discord.EmbedBuilder()
-        .setTitle("Invalid Channel!")
-        .setDescription(`This command can only be used in a ${supportbot.Ticket.TicketType === "threads" ? "ticket thread" : "ticket channel"}.`)
-        .setColor(supportbot.Embed.Colours.Warn);
-
-      return interaction.reply({ embeds: [NotTicketChannel], ephemeral: true });
-    }
-
     await interaction.deferReply();
-
-    let tickets;
-    try {
-      tickets = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-    } catch (err) {
-      console.error("Error reading ticket data file:", err);
-      return interaction.followUp({ content: "There was an error loading ticket data." });
-    }
-
-    let TicketData = tickets.tickets.findIndex((t) => t.id === interaction.channel.id);
+    let tickets = await JSON.parse(
+      fs.readFileSync("./Data/TicketData.json", "utf8")
+    );
+    let TicketData = await tickets.tickets.findIndex(
+      (t) => t.id === interaction.channel.id
+    );
     let ticket = tickets.tickets[TicketData];
-
     if (TicketData === -1) {
-      const Exists = new Discord.EmbedBuilder()
+      const Exists = new Discord.MessageEmbed()
         .setTitle("No Ticket Found!")
-        .setDescription(msgconfig.Error.NoValidTicket)
-        .setColor(supportbot.Embed.Colours.Warn);
+        .setDescription(supportbot.NoValidTicket)
+        .setColor(supportbot.WarningColour);
       return interaction.followUp({ embeds: [Exists] });
     }
+    let tUser = interaction.client.users.cache.get(ticket.user);
+    let transcriptChannel = await getChannel(
+      supportbot.TranscriptLog,
+      interaction.guild
+    );
+    let logChannel = await getChannel(supportbot.TicketLog, interaction.guild);
+    let reason =
+      (await interaction.options?.getString("reason")) || "No Reason Provided.";
 
-    let reason = interaction.options?.getString("reason") || "No Reason Provided.";
-    const ticketUserId = ticket.user;
-
-    if (supportbot.Ticket.ReviewSystem.Enabled) {
-      const rating = await collectReviewRating(interaction, ticketUserId);
-      const comment = await collectReviewComment(interaction, ticketUserId);
-
-      const reviewChannel = await getChannel(supportbot.Ticket.ReviewSystem.Channel, interaction.guild);
-      const reviewer = supportbot.Ticket.ClaimTickets ? `<@${ticket.claimedBy}>` : null;
-
-      const reviewEmbed = new Discord.EmbedBuilder()
-        .setTitle(msgconfig.ReviewSystem.ReviewEmbed.Title)
-        .addFields(
-          {
-            name: msgconfig.ReviewSystem.ReviewEmbed.RatingTitle,
-            value: `${msgconfig.ReviewSystem.ReviewEmbed.ReviewEmoji.repeat(rating)}`,
-            inline: false
-          },
-          {
-            name: msgconfig.ReviewSystem.ReviewEmbed.CommentTitle,
-            value: `\`\`\`${comment}\`\`\``,
-            inline: false
-          }
+    if (!transcriptChannel || !logChannel)
+      return interaction.followUp("Some Channels seem to be missing!");
+    if (supportbot.CloseConfirmation) {
+      const CloseTicketRequest = new Discord.MessageEmbed()
+        .setTitle(`**${supportbot.ClosingTicket}**`)
+        .setDescription(
+          `Please confirm by repeating the following word.. \`${supportbot.ClosingConfirmation_Word}\` `
         )
-        .setColor(msgconfig.ReviewSystem.ReviewEmbed.Color);
+        .setColor(supportbot.EmbedColour);
+      await interaction.followUp({ embeds: [CloseTicketRequest] });
+      let filter = (m) =>
+        m.content.toLowerCase() === supportbot.ClosingConfirmation_Word &&
+        m.author.id === interaction.user.id;
+      await interaction.channel.awaitMessages({
+        filter,
+        max: 1,
+        time: 20000,
+        errors: ["time"],
+      });
+    }
+    try {
+      tickets.tickets[TicketData].open = false;
+      fs.writeFileSync(
+        "./Data/TicketData.json",
+        JSON.stringify(tickets, null, 4),
+        (err) => {
+          if (err) console.error(err);
+        }
+      );
+      await interaction.followUp(`**${supportbot.ClosingTicket}**`);
+      const transcriptEmbed = new Discord.MessageEmbed()
+        .setTitle(supportbot.TranscriptTitle)
+        .setColor(supportbot.EmbedColour)
+        .setFooter({
+          text: supportbot.EmbedFooter,
+          iconURL: interaction.user.displayAvatarURL(),
+        })
+        .addField(
+          "Ticket",
+          `${interaction.channel.name} (${interaction.channel.id})`
+        )
+        .addField(
+          "User",
+          `${tUser?.username || "N/A"}#${tUser?.discriminator || "N/A"} (${
+            tUser?.id || ticket.user
+          })`
+        )
+        .addField("Closed By", interaction.user.tag)
+        .addField("Reason", reason);
+      const logEmbed = new Discord.MessageEmbed()
+        .setTitle(supportbot.TicketLog_Title)
+        .setColor(supportbot.EmbedColour)
+        .setFooter({
+          text: supportbot.EmbedFooter,
+          iconURL: interaction.user.displayAvatarURL(),
+        })
+        .addField(
+          "Ticket",
+          `${interaction.channel.name} (${interaction.channel.id})`
+        )
+        .addField(
+          "User",
+          `${tUser?.username || "N/A"}#${tUser?.discriminator || "N/A"} (${
+            tUser?.id || ticket.user
+          })`
+        )
+        .addField("Closed By", interaction.user.tag)
+        .addField("Reason", reason);
+      let msgs = await interaction.channel.messages.fetch({ limit: 100 });
+      let html = "";
 
-      if (supportbot.Ticket.ClaimTickets.Enabled) {
-        reviewEmbed.setDescription(
-          `**${msgconfig.ReviewSystem.ReviewEmbed.ReviewedStaffTitle}** ${reviewer}\n**${msgconfig.ReviewSystem.ReviewEmbed.ReviewedByTitle}** <@${ticketUserId}>` || `N/A`
-        );
-      } else {
-        reviewEmbed.setDescription(
-          `**${msgconfig.ReviewSystem.ReviewEmbed.ReviewedByTitle}** <@${ticketUserId}>`
-        );
+      msgs = msgs.sort((a, b) => a.createdTimestamp - b.createdTimestamp);
+      html += `<style>* {background-color: #2c2f33;color: #fff;font-family: Arial, Helvetica, sans-serif;}</style>`;
+      html += `<strong>Server Name:</strong> ${interaction.guild.name}<br>`;
+      html += `<strong>Ticket:</strong> ${interaction.channel.name}<br>`;
+      html += `<strong>Message:</strong> ${msgs.size} Messages<br><br><br>`;
+
+      await msgs.forEach((msg) => {
+        if (msg.content) {
+          html += `<strong>User:</strong> ${msg.author.tag}<br>`;
+          html += `<strong>Message:</strong> ${msg.content}<br>`;
+          html += `-----<br><br>`;
+        }
+      });
+      if (!(supportbot.DisableTicketLogChannel)) {
+        await logChannel.send({ embeds: [logEmbed] }).catch((err) => {
+          console.error(err);
+        });
+      }
+      let file = new Discord.MessageAttachment(
+        Buffer.from(html),
+        `${interaction.channel.name}.html`
+      );
+      await transcriptChannel
+        .send({ embeds: [transcriptEmbed], files: [file] })
+        .catch(async (err) => {
+          console.error(err);
+        });
+
+      if (supportbot.DMTranscripts) {
+
+        await tUser
+        ?.send({ embeds: [transcriptEmbed], files: [file] })
+        .catch(async (err) => {
+          console.error(err);
+        });
+      if (ticket.subUsers) {
+        ticket.subUsers.forEach(async (subUser) => {
+          await interaction.client.users.cache
+            .get(subUser)
+            ?.send({ embeds: [transcriptEmbed], files: [file] });
+        });
       }
 
-      if (reviewChannel) {
-        await reviewChannel.send({ embeds: [reviewEmbed] });
       }
 
-      if (!interaction.replied && !interaction.deferred) {
-        await interaction.followUp({ embeds: [reviewEmbed] });
-      }
-
-      await handleCloseTicket(interaction, reason, ticket, TicketData);
-    } else {
-      await handleCloseTicket(interaction, reason, ticket, TicketData);
+      await interaction.channel.delete().catch(async (error) => {
+        console.error(error);
+        if (error.code !== Discord.Constants.APIErrors.UNKNOWN_CHANNEL) {
+          console.error("Failed to delete the interaction:", error);
+        }
+      });
+    } catch (error) {
+      console.error(error);
     }
   },
 });
-
-async function collectReviewRating(interaction, ticketUserId) {
-  const reviewPrompt = new Discord.EmbedBuilder()
-    .setTitle(msgconfig.ReviewSystem.Rate.Title)
-    .setDescription(`${msgconfig.ReviewSystem.Rate.Description}`)
-    .setColor(supportbot.Embed.Colours.General);
-
-  const stars = new Discord.ActionRowBuilder().addComponents(
-    new Discord.StringSelectMenuBuilder()
-      .setCustomId("starRating")
-      .setPlaceholder("Select a rating")
-      .addOptions([
-        { label: msgconfig.ReviewSystem.Stars.One, value: "1" },
-        { label: msgconfig.ReviewSystem.Stars.Two, value: "2" },
-        { label: msgconfig.ReviewSystem.Stars.Three, value: "3" },
-        { label: msgconfig.ReviewSystem.Stars.Four, value: "4" },
-        { label: msgconfig.ReviewSystem.Stars.Five, value: "5" },
-      ])
-  );
-
-  await interaction.followUp({
-    content: `<@${ticketUserId}>`,
-    embeds: [reviewPrompt],
-    components: [stars],
-    ephemeral: true,
-  });
-
-  const starRating = await interaction.channel.awaitMessageComponent({
-    componentType: Discord.ComponentType.StringSelect,
-    filter: (i) => i.customId === "starRating" && i.user.id === ticketUserId,
-  });
-  await starRating.deferUpdate();
-  return starRating.values[0];
-}
-
-async function collectReviewComment(interaction, ticketUserId) {
-  const commentPrompt = new Discord.EmbedBuilder()
-    .setTitle(msgconfig.ReviewSystem.Comment.Title)
-    .setDescription(`${msgconfig.ReviewSystem.Comment.Description}`)
-    .setColor(supportbot.Embed.Colours.General);
-
-  await interaction.followUp({
-    content: `<@${ticketUserId}>`,
-    embeds: [commentPrompt],
-    ephemeral: true,
-  });
-
-  const filter = (response) => response.author.id === ticketUserId;
-
-  const commentCollection = await interaction.channel.awaitMessages({ filter, max: 1 });
-  const comment = commentCollection.first()?.content;
-  return comment && comment.toLowerCase() !== "no" ? comment : "No Comment Provided";
-}
-async function handleCloseTicket(interaction, reason, ticket, TicketData) {
-  const { getChannel } = interaction.client;
-
-  let tickets;
-  try {
-    tickets = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-  } catch (err) {
-    console.error("Error reading ticket data:", err);
-    return interaction.followUp("Failed to load ticket data.");
-  }
-
-  let tUser = interaction.client.users.cache.get(ticket.user);
-  let transcriptChannel = await getChannel(supportbot.Ticket.Log.TicketDataLog, interaction.guild);
-
-  if (!transcriptChannel) {
-    console.log("Transcript channel missing or inaccessible");
-    return interaction.followUp("Error: Transcript log channel is missing or bot lacks permission.");
-  }
-
-  try {
-    // Fetch all messages from the channel
-    let allMessages = [];
-    let lastId = null;
-    
-    while (true) {
-      const options = { limit: 100 };
-      if (lastId) {
-        options.before = lastId;
-      }
-      
-      const messages = await interaction.channel.messages.fetch(options);
-      if (messages.size === 0) break;
-      
-      allMessages = [...allMessages, ...messages.values()];
-      lastId = messages.last().id;
-      
-      if (messages.size < 100) break;
-    }
-
-    // Sort messages by timestamp
-    allMessages.sort((a, b) => a.createdTimestamp - b.createdTimestamp);
-
-    // Create transcript data
-    const transcriptData = allMessages.map(msg => ({
-      content: msg.content || "No content",
-      username: msg.author.username,
-      userId: msg.author.id,
-      avatar: msg.author.displayAvatarURL(),
-      timestamp: msg.createdAt.toISOString(),
-      attachments: Array.from(msg.attachments.values()).map(att => ({
-        url: att.url,
-        name: att.name
-      })),
-      embeds: msg.embeds.map(embed => ({
-        title: embed.title,
-        description: embed.description,
-        fields: embed.fields
-      }))
-    }));
-
-    // Update ticket status
-    tickets.tickets[TicketData].open = false;
-    tickets.tickets[TicketData].messages = transcriptData;
-    fs.writeFileSync("./Data/TicketData.json", JSON.stringify(tickets, null, 4));
-
-    const transcriptEmbed = new Discord.EmbedBuilder()
-      .setTitle(msgconfig.TicketLog.Title)
-      .setColor(msgconfig.TicketLog.Colour)
-      .setFooter({ text: supportbot.Embed.Footer, iconURL: interaction.user.displayAvatarURL() })
-      .setDescription(
-        `> **Ticket:** ${interaction.channel.name} (\`${interaction.channel.id}\`)\n` +
-        `> **User:** ${tUser?.tag || "Unknown User"} (\`${tUser?.id || ticket.user}\`)\n` +
-        `> **Closed by:** <@${interaction.user.id}>\n` +
-        `> **Message Count:** ${transcriptData.length}`
-      )
-      .addFields({ name: "Reason", value: `\`\`\`${reason}\`\`\``, inline: true });
-
-    const html = createTranscriptHTML(
-      {
-        id: interaction.channel.id,
-        messages: transcriptData,
-        name: interaction.channel.name
-      },
-      reason
-    );
-
-    const fileName = `${interaction.channel.id}-transcript.html`;
-    fs.writeFileSync(`./Data/Transcripts/${fileName}`, html);
-
-    await transcriptChannel.send({
-      embeds: [transcriptEmbed],
-      files: [{
-        attachment: `./Data/Transcripts/${fileName}`,
-        name: `SPOILER_${fileName}`,
-        spoiler: true
-      }]
-    });
-
-    if (interaction.channel.type === Discord.ChannelType.GuildText ||
-        interaction.channel.type === Discord.ChannelType.PrivateThread) {
-      await interaction.channel.delete();
-    }
-  } catch (err) {
-    console.error("Error handling ticket close:", err);
-    interaction.followUp("An error occurred while closing the ticket.");
-  }
-}
-
-function parseMarkdown(content) {
-  // Convert **bold** text to <strong> tags
-  content = content.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
-  
-  // Convert _italic_ text to <em> tags
-  content = content.replace(/_(.*?)_/g, '<em>$1</em>');
-  
-  // Convert inline `code` to <code> tags
-  content = content.replace(/`(.*?)`/g, '<code>$1</code>');
-  
-  // Convert [text](link) to <a> tags
-  content = content.replace(/\[(.*?)\]\((.*?)\)/g, '<a href="$2" target="_blank">$1</a>');
-  
-  // Convert multiline code blocks ```code``` to <pre><code> tags
-  content = content.replace(/```(.*?)```/gs, '<pre><code>$1</code></pre>');
-  
-  return content;
-}
-
-function createTranscriptHTML(ticket, reason) {
-  return `
-    <!DOCTYPE html>
-    <html>
-      <head>
-        <meta charset="UTF-8">
-        <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <link href="https://cdnjs.cloudflare.com/ajax/libs/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
-        <style>
-          body {
-            background-color: #1a1a1a;
-            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-            color: white;
-            margin: 0;
-            padding: 20px;
-          }
-          .container {
-            max-width: 1000px;
-            margin: 0 auto;
-            background-color: rgba(0, 0, 0, 0.3);
-            border-radius: 15px;
-            padding: 20px;
-          }
-          .message {
-            background-color: rgba(255, 255, 255, 0.1);
-            border-radius: 10px;
-            padding: 15px;
-            margin-bottom: 15px;
-          }
-          .message-header {
-            display: flex;
-            align-items: center;
-            margin-bottom: 10px;
-          }
-          .avatar {
-            width: 40px;
-            height: 40px;
-            border-radius: 50%;
-            margin-right: 15px;
-          }
-          .username {
-            font-weight: bold;
-            color: #4CAF50;
-          }
-          .timestamp {
-            margin-left: auto;
-            color: #888;
-            font-size: 0.9em;
-          }
-          .content {
-            word-break: break-word;
-          }
-          .embed {
-            border-left: 4px solid #4CAF50;
-            padding-left: 10px;
-            margin: 10px 0;
-            background-color: rgba(0, 0, 0, 0.2);
-          }
-          .attachment {
-            display: inline-block;
-            background-color: rgba(76, 175, 80, 0.1);
-            border: 1px solid #4CAF50;
-            border-radius: 5px;
-            padding: 5px 10px;
-            margin: 5px 0;
-            color: #4CAF50;
-            text-decoration: none;
-          }
-        </style>
-      </head>
-      <body>
-        <div class="container">
-          <div class="mb-6">
-            <h1 class="text-3xl font-bold mb-4">Ticket Transcript</h1>
-            <p><strong>Channel:</strong> ${ticket.name}</p>
-            <p><strong>Ticket ID:</strong> ${ticket.id}</p>
-            <p><strong>Message Count:</strong> ${ticket.messages.length}</p>
-            <p><strong>Close Reason:</strong> ${reason}</p>
-          </div>
-          
-          <div class="messages">
-            ${ticket.messages.map(msg => `
-              <div class="message">
-                <div class="message-header">
-                  <img src="${msg.avatar}" alt="Avatar" class="avatar">
-                  <span class="username">${msg.username}</span>
-                  <span class="timestamp">${new Date(msg.timestamp).toLocaleString()}</span>
-                </div>
-                <div class="content">
-                  ${parseMarkdown(msg.content)}
-                  
-                  ${msg.embeds.map(embed => `
-                    <div class="embed">
-                      ${embed.title ? `<div class="font-bold">${embed.title}</div>` : ''}
-                      ${embed.description ? `<div>${embed.description}</div>` : ''}
-                      ${embed.fields.map(field => `
-                        <div class="mt-2">
-                          <strong>${field.name}:</strong>
-                          <div>${field.value}</div>
-                        </div>
-                      `).join('')}
-                    </div>
-                  `).join('')}
-                  
-                  ${msg.attachments.map(att => `
-                    <a href="${att.url}" class="attachment" target="_blank">
-                      📎 ${att.name}
-                    </a>
-                  `).join('')}
-                </div>
-              </div>
-            `).join('')}
-          </div>
-        </div>
-      </body>
-    </html>
-  `;
-}

Commands/embed.js

@@ -1,479 +1,107 @@
-const { 
-  ApplicationCommandType, 
-  ApplicationCommandOptionType,
-  ActionRowBuilder, 
-  ButtonBuilder, 
-  EmbedBuilder,
-  StringSelectMenuBuilder,
-  ModalBuilder,
-  TextInputBuilder,
-  TextInputStyle,
-  ButtonStyle,
-  ComponentType
-} = require('discord.js');
-const Command = require('../Structures/Command.js');
-const fs = require('fs');
-const yaml = require('js-yaml');
+// SupportBot | Emerald Services
+// Embed Command
 
-const supportbot = yaml.load(fs.readFileSync('./Configs/supportbot.yml', 'utf8'));
-const cmdconfig = yaml.load(fs.readFileSync('./Configs/commands.yml', 'utf8'));
-const msgconfig = yaml.load(fs.readFileSync('./Configs/messages.yml', 'utf8'));
+const fs = require("fs");
 
-// Helper function to validate and convert hex color
-function parseColor(color) {
-  if (!color) return 0x5865F2;
-  if (typeof color === 'number') return color;
-  if (typeof color !== 'string') return 0x5865F2;
-  color = color.replace('#', '');
-  if (/^[0-9A-F]{6}$/i.test(color)) {
-    return parseInt(color, 16);
-  }
-  return 0x5865F2;
-}
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
 
 module.exports = new Command({
-  name: cmdconfig.Embed.Command,
-  description: cmdconfig.Embed.Description,
-  type: ApplicationCommandType.ChatInput,
+  name: cmdconfig.EmbedCommand,
+  description: cmdconfig.EmbedCommandDesc,
   options: [
     {
-      name: 'channel',
-      description: 'Select channel to send the message',
-      type: ApplicationCommandOptionType.Channel,
-      required: true
-    }
+      name: "title",
+      description: "Embed Title",
+      type: "STRING",
+      required: true,
+    },
+    {
+      name: "message",
+      description: "Embed Message",
+      type: "STRING",
+      required: true,
+    },
+    {
+      name: "color",
+      description: "Embed HEX Color",
+      type: "STRING",
+      required: false,
+    },
+    {
+      name: "fieldtitle",
+      description: "Add an additional Embed Field",
+      type: "STRING",
+      required: false,
+    },
+    {
+      name: "fieldcontent",
+      description: "Add an additional Embed Field",
+      type: "STRING",
+      required: false,
+    },
+    {
+      name: "thumbnail",
+      description: "Embed Thumbnail URL",
+      type: "STRING",
+      required: false,
+    },
+    {
+      name: "image",
+      description: "Embed Image URL",
+      type: "STRING",
+      required: false,
+    },
   ],
-  permissions: cmdconfig.Embed.Permission,
+  permissions: ["SEND_MESSAGES"],
 
   async run(interaction) {
-    // Permission check
     const { getRole } = interaction.client;
-    let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
-    let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+    let SupportStaff = await getRole(supportbot.Staff, interaction.guild);
+    let Admin = await getRole(supportbot.Admin, interaction.guild);
 
-    if (!SupportStaff || !Admin) {
-      return interaction.reply('Some roles seem to be missing!\nPlease check for errors when starting the bot.');
-    }
-
-    if (!interaction.member.roles.cache.has(SupportStaff.id) && 
-        !interaction.member.roles.cache.has(Admin.id)) {
-      const NoPerms = new EmbedBuilder()
-        .setTitle('Invalid Permissions!')
-        .setDescription(`${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``)
-        .setColor(0xFF0000);
-      return interaction.reply({ embeds: [NoPerms], ephemeral: true });
-    }
-
-    const channel = interaction.options.getChannel('channel');
-    
-    // Initial message state
-    const messageData = {
-      type: 'embed',
-      title: 'New Embed',
-      description: 'Click the buttons below to edit this embed',
-      color: 0x5865F2,
-      fields: [],
-      footer: null,
-      thumbnail: null,
-      image: null,
-      timestamp: false
-    };
-
-    // Create initial embed
-    function createEmbed() {
-      const embed = new EmbedBuilder()
-        .setTitle(messageData.title)
-        .setDescription(messageData.description)
-        .setColor(messageData.color);
-
-      if (messageData.fields.length > 0) {
-        embed.addFields(messageData.fields);
-      }
-      if (messageData.footer) {
-        embed.setFooter({ text: messageData.footer });
-      }
-      if (messageData.thumbnail) {
-        embed.setThumbnail(messageData.thumbnail);
-      }
-      if (messageData.image) {
-        embed.setImage(messageData.image);
-      }
-      if (messageData.timestamp) {
-        embed.setTimestamp();
-      }
-
-      return embed;
-    }
-
-    // Create type selector
-    const typeRow = new ActionRowBuilder()
-      .addComponents(
-        new StringSelectMenuBuilder()
-          .setCustomId('message_type')
-          .setPlaceholder('Select message type')
-          .addOptions([
-            {
-              label: 'Embed Message',
-              description: 'Send as an embedded message',
-              value: 'embed'
-            },
-            {
-              label: 'Text Message',
-              description: 'Send as a plain text message',
-              value: 'text'
-            }
-          ])
+    if (!SupportStaff || !Admin)
+      return interaction.reply(
+        "Some roles seem to be missing!\nPlease check for errors when starting the bot."
       );
+    const NoPerms = new Discord.MessageEmbed()
+      .setTitle("Invalid Permissions!")
+      .setDescription(
+        `${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``
+      )
+      .setColor(supportbot.WarningColour);
 
-    // Create button rows function
-    function createButtons(messageType) {
-      const buttons = [];
-      
-      if (messageType === 'embed') {
-        // Only show these buttons for embed mode
-        const row1 = new ActionRowBuilder()
-          .addComponents(
-            new ButtonBuilder()
-              .setCustomId('edit_title')
-              .setLabel('Edit Title')
-              .setStyle(ButtonStyle.Secondary),
-            new ButtonBuilder()
-              .setCustomId('edit_description')
-              .setLabel('Edit Description')
-              .setStyle(ButtonStyle.Secondary),
-            new ButtonBuilder()
-              .setCustomId('edit_color')
-              .setLabel('Edit Color')
-              .setStyle(ButtonStyle.Secondary),
-            new ButtonBuilder()
-              .setCustomId('add_field')
-              .setLabel('Add Field')
-              .setStyle(ButtonStyle.Secondary)
-          );
+    if (
+      interaction.member.roles.cache.has(SupportStaff.id) ||
+      interaction.member.roles.cache.has(Admin.id)
+    ) {
+      const EmbedTitle = interaction.options.getString("title");
+      const EmbedSubject = interaction.options.getString("message");
+      const EmbedColour = interaction.options.getString("color");
+      const EmbedThumbnail = interaction.options.getString("thumbnail");
+      const EmbedImage = interaction.options.getString("image");
+      const EmbedFieldContent = interaction.options.getString("fieldcontent");
+      const EmbedFieldTitle = interaction.options.getString("fieldtitle");
 
-        const row2 = new ActionRowBuilder()
-          .addComponents(
-            new ButtonBuilder()
-              .setCustomId('edit_footer')
-              .setLabel('Edit Footer')
-              .setStyle(ButtonStyle.Secondary),
-            new ButtonBuilder()
-              .setCustomId('edit_image')
-              .setLabel('Add Image')
-              .setStyle(ButtonStyle.Secondary),
-            new ButtonBuilder()
-              .setCustomId('edit_thumbnail')
-              .setLabel('Add Thumbnail')
-              .setStyle(ButtonStyle.Secondary),
-            new ButtonBuilder()
-              .setCustomId('toggle_timestamp')
-              .setLabel('Toggle Timestamp')
-              .setStyle(ButtonStyle.Secondary)
-          );
-        
-        buttons.push(row1, row2);
-      } else {
-        // Text mode only shows edit text button
-        const textRow = new ActionRowBuilder()
-          .addComponents(
-            new ButtonBuilder()
-              .setCustomId('edit_description')
-              .setLabel('Edit Text')
-              .setStyle(ButtonStyle.Secondary)
-          );
-        
-        buttons.push(textRow);
-      }
+      const EmbedMsg = new Discord.MessageEmbed()
+        .setTitle(EmbedTitle)
+        .setDescription(EmbedSubject)
+        .setColor(EmbedColour)
+        .setThumbnail(EmbedThumbnail)
+        .setImage(EmbedImage)
+        if (EmbedFieldTitle && EmbedFieldContent) { EmbedMsg.addField(EmbedFieldTitle, EmbedFieldContent) };
 
-      // Send button always shows
-      const sendRow = new ActionRowBuilder()
-        .addComponents(
-          new ButtonBuilder()
-            .setCustomId('send_message')
-            .setLabel('Send')
-            .setStyle(ButtonStyle.Success)
-        );
-      
-      buttons.push(sendRow);
-      return buttons;
+      interaction.reply({
+        embeds: [EmbedMsg],
+      });
+    } else {
+      return interaction.reply({ embeds: [NoPerms] });
     }
-
-    // Function to update the message preview
-    async function updatePreview(i) {
-      if (messageData.type === 'embed') {
-        await i.update({
-          content: 'Customize your message:',
-          embeds: [createEmbed()],
-          components: [typeRow, ...createButtons('embed')]
-        });
-      } else {
-        // For text mode, just show the text directly
-        await i.update({
-          content: messageData.description,
-          embeds: [],
-          components: [typeRow, ...createButtons('text')]
-        });
-      }
-    }
-
-    // Send initial message
-    const message = await interaction.reply({
-      content: messageData.type === 'text' ? messageData.description : 'Customize your message:',
-      components: [typeRow, ...createButtons(messageData.type)],
-      embeds: messageData.type === 'embed' ? [createEmbed()] : [],
-      ephemeral: true
-    });
-
-    // Create collector for interactions
-    const collector = message.createMessageComponentCollector({
-      time: 900000
-    });
-
-    collector.on('collect', async (i) => {
-      if (i.user.id !== interaction.user.id) {
-        return i.reply({ 
-          content: 'You cannot edit this message.', 
-          ephemeral: true 
-        });
-      }
-
-      switch (i.customId) {
-        case 'message_type':
-          messageData.type = i.values[0];
-          await updatePreview(i);
-          break;
-
-        case 'edit_description':
-          const descModal = new ModalBuilder()
-            .setCustomId('desc_modal')
-            .setTitle(messageData.type === 'embed' ? 'Edit Description' : 'Edit Text');
-
-          descModal.addComponents(
-            new ActionRowBuilder()
-              .addComponents(
-                new TextInputBuilder()
-                  .setCustomId('desc_input')
-                  .setLabel(messageData.type === 'embed' ? 'Description' : 'Message Text')
-                  .setStyle(TextInputStyle.Paragraph)
-                  .setValue(messageData.description)
-                  .setMaxLength(4000)
-              )
-          );
-
-          await i.showModal(descModal);
-          break;
-
-        case 'edit_title':
-          const titleModal = new ModalBuilder()
-            .setCustomId('title_modal')
-            .setTitle('Edit Title');
-
-          titleModal.addComponents(
-            new ActionRowBuilder()
-              .addComponents(
-                new TextInputBuilder()
-                  .setCustomId('title_input')
-                  .setLabel('Title')
-                  .setStyle(TextInputStyle.Short)
-                  .setValue(messageData.title)
-                  .setMaxLength(256)
-              )
-          );
-
-          await i.showModal(titleModal);
-          break;
-
-        case 'edit_color':
-          const colorModal = new ModalBuilder()
-            .setCustomId('color_modal')
-            .setTitle('Edit Color');
-
-          colorModal.addComponents(
-            new ActionRowBuilder()
-              .addComponents(
-                new TextInputBuilder()
-                  .setCustomId('color_input')
-                  .setLabel('Color (HEX)')
-                  .setStyle(TextInputStyle.Short)
-                  .setPlaceholder('#FF0000')
-                  .setMinLength(6)
-                  .setMaxLength(7)
-                  .setValue(messageData.color.toString(16).padStart(6, '0'))
-              )
-          );
-
-          await i.showModal(colorModal);
-          break;
-
-        case 'add_field':
-          const fieldModal = new ModalBuilder()
-            .setCustomId('field_modal')
-            .setTitle('Add Field');
-
-          fieldModal.addComponents(
-            new ActionRowBuilder()
-              .addComponents(
-                new TextInputBuilder()
-                  .setCustomId('field_name')
-                  .setLabel('Field Name')
-                  .setStyle(TextInputStyle.Short)
-                  .setMaxLength(256)
-              ),
-            new ActionRowBuilder()
-              .addComponents(
-                new TextInputBuilder()
-                  .setCustomId('field_value')
-                  .setLabel('Field Value')
-                  .setStyle(TextInputStyle.Paragraph)
-                  .setMaxLength(1024)
-              ),
-            new ActionRowBuilder()
-              .addComponents(
-                new TextInputBuilder()
-                  .setCustomId('field_inline')
-                  .setLabel('Inline? (true/false)')
-                  .setStyle(TextInputStyle.Short)
-                  .setValue('false')
-                  .setPlaceholder('true or false')
-              )
-          );
-
-          await i.showModal(fieldModal);
-          break;
-
-        case 'edit_footer':
-          const footerModal = new ModalBuilder()
-            .setCustomId('footer_modal')
-            .setTitle('Edit Footer');
-
-          footerModal.addComponents(
-            new ActionRowBuilder()
-              .addComponents(
-                new TextInputBuilder()
-                  .setCustomId('footer_input')
-                  .setLabel('Footer Text')
-                  .setStyle(TextInputStyle.Short)
-                  .setValue(messageData.footer || '')
-                  .setMaxLength(2048)
-              )
-          );
-
-          await i.showModal(footerModal);
-          break;
-
-        case 'edit_image':
-          const imageModal = new ModalBuilder()
-            .setCustomId('image_modal')
-            .setTitle('Add Image');
-
-          imageModal.addComponents(
-            new ActionRowBuilder()
-              .addComponents(
-                new TextInputBuilder()
-                  .setCustomId('image_input')
-                  .setLabel('Image URL')
-                  .setStyle(TextInputStyle.Short)
-                  .setValue(messageData.image || '')
-                  .setPlaceholder('https://example.com/image.png')
-              )
-          );
-
-          await i.showModal(imageModal);
-          break;
-
-        case 'edit_thumbnail':
-          const thumbnailModal = new ModalBuilder()
-            .setCustomId('thumbnail_modal')
-            .setTitle('Add Thumbnail');
-
-          thumbnailModal.addComponents(
-            new ActionRowBuilder()
-              .addComponents(
-                new TextInputBuilder()
-                  .setCustomId('thumbnail_input')
-                  .setLabel('Thumbnail URL')
-                  .setStyle(TextInputStyle.Short)
-                  .setValue(messageData.thumbnail || '')
-                  .setPlaceholder('https://example.com/thumbnail.png')
-              )
-          );
-
-          await i.showModal(thumbnailModal);
-          break;
-
-        case 'toggle_timestamp':
-          messageData.timestamp = !messageData.timestamp;
-          await updatePreview(i);
-          break;
-
-        case 'send_message':
-          try {
-            if (messageData.type === 'embed') {
-              await channel.send({ embeds: [createEmbed()] });
-            } else {
-              await channel.send(messageData.description);
-            }
-            await i.update({ 
-              content: 'Message sent successfully!', 
-              components: [], 
-              embeds: [] 
-            });
-            collector.stop();
-          } catch (error) {
-            await i.reply({ 
-              content: 'Failed to send message. Please check channel permissions.', 
-              ephemeral: true 
-            });
-          }
-          break;
-      }
-    });
-
-    // Handle modal submissions
-    interaction.client.on('interactionCreate', async (modal) => {
-      if (!modal.isModalSubmit()) return;
-      if (modal.user.id !== interaction.user.id) return;
-
-      switch (modal.customId) {
-        case 'title_modal':
-          messageData.title = modal.fields.getTextInputValue('title_input');
-          break;
-        case 'desc_modal':
-          messageData.description = modal.fields.getTextInputValue('desc_input');
-          break;
-        case 'color_modal':
-          messageData.color = parseColor(modal.fields.getTextInputValue('color_input'));
-          break;
-        case 'field_modal':
-          const inlineValue = modal.fields.getTextInputValue('field_inline').toLowerCase();
-          messageData.fields.push({
-            name: modal.fields.getTextInputValue('field_name'),
-            value: modal.fields.getTextInputValue('field_value'),
-            inline: inlineValue === 'true'
-          });
-          break;
-        case 'footer_modal':
-          messageData.footer = modal.fields.getTextInputValue('footer_input');
-          break;
-        case 'image_modal':
-          messageData.image = modal.fields.getTextInputValue('image_input');
-          break;
-        case 'thumbnail_modal':
-          messageData.thumbnail = modal.fields.getTextInputValue('thumbnail_input');
-          break;
-        default:
-          return;
-      }
-
-      await updatePreview(modal);
-    });
-
-    collector.on('end', () => {
-      interaction.editReply({
-        content: 'Message editor timed out.',
-        components: [],
-        embeds: []
-      }).catch(() => {});
-    });
-  }
-});
+  },
+});

Commands/forceaddUser.js

@@ -1,134 +0,0 @@
-const fs = require("fs");
-const {
-  EmbedBuilder,
-  ApplicationCommandOptionType,
-  ApplicationCommandType,
-  ChannelType,
-} = require("discord.js");
-const yaml = require("js-yaml");
-
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
-const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-
-const Command = require("../Structures/Command.js");
-
-module.exports = new Command({
-  name: cmdconfig.ForceAddUser.Command,
-  description: cmdconfig.ForceAddUser.Description,
-  type: ApplicationCommandType.ChatInput,
-  options: [
-    {
-      name: "user",
-      description: "The user to forcefully add",
-      type: ApplicationCommandOptionType.User,
-      required: true,
-    },
-  ],
-  permissions: cmdconfig.ForceAddUser.Permission,
-
-  async run(interaction) {
-    const userToAdd = interaction.options.getUser("user");
-    const ticketChannel = interaction.channel;
-    const ticketDataPath = "./Data/TicketData.json";
-
-    if (
-      (supportbot.Ticket.TicketType === "threads" && !ticketChannel.isThread()) ||
-      (supportbot.Ticket.TicketType === "channels" && ticketChannel.type !== ChannelType.GuildText)
-    ) {
-      const onlyInTicket = new EmbedBuilder()
-        .setTitle(msgconfig.ForceAddUser.NotInTicket_Title)
-        .setDescription(msgconfig.ForceAddUser.NotInTicket_Description)
-        .setColor(supportbot.Embed.Colours.Error);
-
-      return interaction.reply({
-        embeds: [onlyInTicket],
-        ephemeral: true,
-      });
-    }
-
-    try {
-
-      if (supportbot.Ticket.TicketType === "threads") {
-        try {
-            // Explicitly ensure the bot is in the thread
-            const botMember = await ticketChannel.members.fetch(interaction.client.user.id).catch(() => null);
-            if (!botMember) {
-                await ticketChannel.join();
-            }
-    
-            // Delay to ensure API has processed the bot's membership
-            await new Promise(res => setTimeout(res, 1000));
-    
-            // Attempt to add the user to the thread
-            await ticketChannel.members.add(userToAdd.id);
-    
-            console.log("User successfully added to the thread.");
-        } catch (err) {
-            console.error("Error adding user to the thread:", err.message);
-            const errorEmbed = new EmbedBuilder()
-                .setTitle(msgconfig.ForceAddUser.Error_Title)
-                .setDescription(`An error occurred: ${err.message}`)
-                .setColor(supportbot.Embed.Colours.Error);
-    
-            return interaction.reply({
-                embeds: [errorEmbed],
-                ephemeral: true,
-            });
-        }
-
-      } else if (supportbot.Ticket.TicketType === "channels") {
-        await ticketChannel.permissionOverwrites.create(userToAdd.id, {
-          ViewChannel: true,
-          SendMessages: true,
-          ReadMessageHistory: true,
-        }); 
-      }
-
-      const ticketData = JSON.parse(fs.readFileSync(ticketDataPath, "utf8"));
-      const ticketIndex = ticketData.tickets.findIndex((t) => t.id === ticketChannel.id);
-      if (ticketIndex !== -1) {
-        ticketData.tickets[ticketIndex].subUsers.push(userToAdd.id);
-        fs.writeFileSync(ticketDataPath, JSON.stringify(ticketData, null, 4));
-      }
-
-      const addedEmbed = new EmbedBuilder()
-        .setTitle(msgconfig.ForceAddUser.Added_Title)
-        .setDescription(
-          msgconfig.ForceAddUser.Added_Description.replace("%username%", userToAdd.username)
-        )
-        .setColor(supportbot.Embed.Colours.Success);
-
-      await interaction.reply({
-        embeds: [addedEmbed],
-        ephemeral: true,
-      });
-
-      const addedToTicketEmbed = new EmbedBuilder()
-        .setTitle(msgconfig.ForceAddUser.AddedToTicket_Title)
-        .setDescription(
-          msgconfig.ForceAddUser.AddedToTicket_Description.replace(
-            "%channel_link%",
-            `[${ticketChannel.name}](https://discord.com/channels/${ticketChannel.guild.id}/${ticketChannel.id})`
-          )
-        )
-        .setColor(supportbot.Embed.Colours.General);
-
-      await userToAdd.send({
-        embeds: [addedToTicketEmbed],
-      });
-    } catch (err) {
-      console.error("Error adding user to the ticket:", err);
-
-      const errorEmbed = new EmbedBuilder()
-        .setTitle(msgconfig.ForceAddUser.Error_Title)
-        .setDescription(msgconfig.ForceAddUser.Error_Adding)
-        .setColor(supportbot.Embed.Colours.Error);
-
-      await interaction.reply({
-        embeds: [errorEmbed],
-        ephemeral: true,
-      });
-    }
-  },
-});

Commands/help.js

@@ -1,62 +1,89 @@
+// SupportBot | Emerald Services
+// Help Command
+
 const fs = require("fs");
+
 const Discord = require("discord.js");
 const yaml = require("js-yaml");
-
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
 const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
 
 const Command = require("../Structures/Command.js");
 
 module.exports = new Command({
-  name: cmdconfig.Help.Command,
-  description: cmdconfig.Help.Description,
-  type: Discord.ApplicationCommandType.ChatInput,
+  name: cmdconfig.HelpCommand,
+  description: cmdconfig.HelpCommandDesc,
   options: [],
-  permissions: cmdconfig.Help.Permission,
+  permissions: ["SEND_MESSAGES"],
 
   async run(interaction) {
     const { getRole } = interaction.client;
-    let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
-    let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
-    if (!SupportStaff || !Admin) {
+    let SupportStaff = await getRole(supportbot.Staff, interaction.guild);
+    let Admin = await getRole(supportbot.Admin, interaction.guild);
+    if (!SupportStaff || !Admin)
       return interaction.reply(
         "Some roles seem to be missing!\nPlease check for errors when starting the bot."
       );
+
+    let botCommands = "";
+    botCommands += `**/${cmdconfig.HelpCommand}** ${cmdconfig.HelpCommandDesc}\n`;
+    botCommands += `**/${cmdconfig.InfoCommand}** ${cmdconfig.InfoCommandDesc}\n`;
+    botCommands += `**/${cmdconfig.PingCommand}** ${cmdconfig.PingCommandDesc}\n`;
+    botCommands += `**/${cmdconfig.UserInfoCommand}** ${cmdconfig.UserInfoCommandDesc}\n`;
+
+    if (supportbot.DisableSuggestions === false) {
+      botCommands += `**/${cmdconfig.SuggestCommand}** ${cmdconfig.SuggestCommandDesc}\n`;
     }
 
-    // Separate regular commands and addon commands
-    let botCommands = "";
-    let addonCommands = "";
+    let ticketCommands = "";
+    ticketCommands += `**/${cmdconfig.OpenTicket}** ${cmdconfig.OpenTicketDesc}\n`;
+    ticketCommands += `**/${cmdconfig.CloseTicket}** ${cmdconfig.CloseTicketDesc}\n`;
 
-    interaction.client.commands.forEach((command) => {
-      if (command.permissions) {
-        if (command.addon) {
-          addonCommands += `\`${command.name}\` `;
-        } else {
-          botCommands += `\`${command.name}\` `;
-        }
-      }
-    });
+    let staffCommands = "";
+    staffCommands += `**/${cmdconfig.TicketAdd}** ${cmdconfig.TicketAddDesc}\n`;
+    staffCommands += `**/${cmdconfig.TicketRemove}** ${cmdconfig.TicketRemoveDesc}\n`;
+    staffCommands += `**/${cmdconfig.UserInfoCommand}** ${cmdconfig.UserInfoCommandDesc}\n`;
+    staffCommands += `**/${cmdconfig.TranslateCommand}** ${cmdconfig.TranslateCommandDesc}\n`;
 
-    // Create embed
-    const HelpEmbed1 = new Discord.EmbedBuilder()
-      .setTitle(supportbot.General.Name + " Commands")
+    const HelpEmbed1 = new Discord.MessageEmbed()
+      .setTitle(supportbot.Name + " Commands")
       .setThumbnail(interaction.user.displayAvatarURL())
-      .setColor(supportbot.Embed.Colours.General)
-      .addFields({
-        name: "🖥️ Commands\n",
-        value: botCommands || "No commands available.",
-        inline: false,
+
+      .addFields(
+        {
+          name: "🖥️ General Commands\n",
+          value: `${botCommands}\n`,
+          inline: false,
+        },
+        {
+          name: "🎫 Support Commands\n",
+          value: `${ticketCommands}\n`,
+          inline: false,
+        }
+      )
+
+      .setColor(supportbot.EmbedColour)
+      .setFooter({
+        text: supportbot.EmbedFooter,
+        iconURL: interaction.user.displayAvatarURL(),
       });
 
-    HelpEmbed1.setFooter({
-      text: supportbot.Embed.Footer,
-      iconURL: interaction.user.displayAvatarURL(),
-    });
+    if (
+      interaction.member.roles.cache.has(SupportStaff.id) ||
+      interaction.member.roles.cache.has(Admin.id)
+    ) {
+      HelpEmbed1.addFields({
+        name: "🔐 Staff Commands\n",
+        value: `${staffCommands}\n`,
+        inline: false,
+      });
+    }
 
-    interaction.reply({
-      ephemeral: true,
-      embeds: [HelpEmbed1],
-    });
+      interaction.reply({
+        ephemeral: true,
+        embeds: [HelpEmbed1],
+      });
   },
 });

Commands/info.js

@@ -5,47 +5,36 @@ const fs = require("fs");
 
 const Discord = require("discord.js");
 const yaml = require("js-yaml");
-
 const supportbot = yaml.load(
   fs.readFileSync("./Configs/supportbot.yml", "utf8")
 );
-
-const cmdconfig = yaml.load(
-  fs.readFileSync("./Configs/commands.yml", "utf8")
-);
-
-const msgconfig = yaml.load(
-  fs.readFileSync("./Configs/messages.yml", "utf8")
-);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
 
 const Command = require("../Structures/Command.js");
 
 module.exports = new Command({
-  name: cmdconfig.Info.Command,
-  description: cmdconfig.Info.Description,
+  name: cmdconfig.InfoCommand,
+  description: cmdconfig.InfoCommandDesc,
   options: [],
-  permissions: cmdconfig.Info.Permission,
+  permissions: ["SEND_MESSAGES"],
 
   async run(interaction) {
-    let disableCommand = true;
+    const InfoButton = new Discord.MessageButton()
+      .setLabel(supportbot.InfoButtonText)
+      .setURL(supportbot.InfoURL)
+      .setStyle("LINK");
 
-  const InfoButton = new Discord.ButtonBuilder()
-    .setLabel(msgconfig.Info.Button)
-    .setURL(msgconfig.Info.URL)
-    .setStyle("Link");
+    const inforow = new Discord.MessageActionRow().addComponents(InfoButton);
 
-  const inforow = new Discord.ActionRowBuilder().addComponents(InfoButton);
-
-  const InfoEmbed = new Discord.EmbedBuilder()
-    .setURL(msgconfig.Info.URL)
-    .setTitle(msgconfig.Info.Title)
-    .setDescription(msgconfig.Info.Description)
-    .setColor(msgconfig.Info.Colour)
-
-  interaction.reply({
-    embeds: [InfoEmbed],
-    components: [inforow],
-  });
+    const InfoEmbed = new Discord.MessageEmbed()
+      .setURL(supportbot.InfoURL)
+      .setTitle(supportbot.InfoTitle)
+      .setDescription(supportbot.AboutMe)
+      .setColor(supportbot.InfoColour);
 
+    interaction.reply({
+      embeds: [InfoEmbed],
+      components: [inforow],
+    });
   },
-});
+});

Commands/mod.js

@@ -1,261 +0,0 @@
-const fs = require("fs");
-const { ApplicationCommandOptionType, ApplicationCommandType, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, ComponentType } = require("discord.js");
-const yaml = require("js-yaml");
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
-
-const Command = require("../Structures/Command.js");
-
-// Function to chunk array into smaller arrays
-function chunkArray(arr, size) {
-  const chunks = [];
-  for (let i = 0; i < arr.length; i += size) {
-    chunks.push(arr.slice(i, i + size));
-  }
-  return chunks;
-}
-
-module.exports = new Command({
-  name: cmdconfig.Mod.Command,
-  description: cmdconfig.Mod.Command,
-  type: ApplicationCommandType.ChatInput,
-  options: [
-    {
-      name: cmdconfig.Mod.TicketBlacklist.Command,
-      description: cmdconfig.Mod.TicketBlacklist.Description,
-      type: ApplicationCommandOptionType.SubcommandGroup,
-      options: [
-        {
-          name: cmdconfig.Mod.TicketBlacklist.Add.Command,
-          description: msgconfig.Mod.TicketBlacklist.Add.Description || "Add a user to the ticket blacklist",
-          type: ApplicationCommandOptionType.Subcommand,
-          options: [
-            {
-              name: 'user',
-              description: msgconfig.Mod.TicketBlacklist.Add.UserDescription || "User to blacklist",
-              type: ApplicationCommandOptionType.User,
-              required: true
-            },
-            {
-              name: 'reason', 
-              description: msgconfig.Mod.TicketBlacklist.Add.ReasonDescription || "Reason for blacklisting",
-              type: ApplicationCommandOptionType.String,
-              required: false
-            }
-          ]
-        },
-        {
-          name: cmdconfig.Mod.TicketBlacklist.Remove.Command,
-          description: msgconfig.Mod.TicketBlacklist.Remove.Description || "Remove a user from the ticket blacklist",
-          type: ApplicationCommandOptionType.Subcommand,
-          options: [
-            {
-              name: 'user',
-              description: msgconfig.Mod.TicketBlacklist.Remove.UserDescription || "User to remove from blacklist",
-              type: ApplicationCommandOptionType.User,
-              required: true
-            },
-            {
-              name: 'reason',
-              description: msgconfig.Mod.TicketBlacklist.Remove.ReasonDescription || "Reason for removing from blacklist",
-              type: ApplicationCommandOptionType.String,
-              required: false
-            }
-          ]
-        },
-        {
-          name: "view",
-          description: msgconfig.Mod.TicketBlacklist.View.Description || "View all blacklisted users",
-          type: ApplicationCommandOptionType.Subcommand,
-        }
-      ]
-    }
-  ],
-  permissions: cmdconfig.Mod.Permission,
-
-  async run(interaction) {
-    const { getRole } = interaction.client;
-
-    let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
-    let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
-    let Moderator = await getRole(supportbot.Roles.StaffMember.Moderator, interaction.guild);
-
-    if (!SupportStaff || !Admin || !Moderator) {
-      const missingRolesEmbed = new EmbedBuilder()
-        .setDescription(msgconfig.Error.InvalidChannel || "Required roles are missing!")
-        .setColor(supportbot.Embed.Colours.Warn);
-      return interaction.reply({ embeds: [missingRolesEmbed] });
-    }
-
-    const NoPerms = new EmbedBuilder()
-      .setDescription(msgconfig.Error.IncorrectPerms || "You do not have the correct permissions!")
-      .setColor(supportbot.Embed.Colours.Warn);
-
-    if (!interaction.member.roles.cache.has(Admin.id) && !interaction.member.roles.cache.has(Moderator.id) && (!supportbot.Mod.AllowSupportStaff || !interaction.member.roles.cache.has(SupportStaff.id))) {
-      return interaction.reply({ embeds: [NoPerms] });
-    }
-
-    const subcommand = interaction.options.getSubcommand(false);
-    const user = interaction.options.getUser('user');
-    const reason = interaction.options.getString('reason') || "No reason provided"; 
-
-    try {
-      let blacklistedUsers;
-      try {
-        blacklistedUsers = JSON.parse(fs.readFileSync("./Data/BlacklistedUsers.json", "utf8")).blacklistedUsers;
-        if (!Array.isArray(blacklistedUsers)) {
-          blacklistedUsers = [];
-        }
-      } catch (error) {
-        blacklistedUsers = [];
-      }
-
-      if (subcommand === cmdconfig.Mod.TicketBlacklist.Add.Command) {
-        if (blacklistedUsers.includes(user.id)) {
-          const alreadyBlacklistedEmbed = new EmbedBuilder()
-            .setDescription(msgconfig.Mod.TicketBlacklist.Add.AlreadyBlacklisted.replace("{userTag}", user.tag) || ":x: User is already blacklisted.")
-            .setColor(supportbot.Embed.Colours.Warn);
-          return interaction.reply({ embeds: [alreadyBlacklistedEmbed], ephemeral: true });
-        }
-
-        blacklistedUsers.push(user.id);
-        fs.writeFileSync("./Data/BlacklistedUsers.json", JSON.stringify({ "blacklistedUsers": blacklistedUsers }, null, 4));
-
-        const successEmbed = new EmbedBuilder()
-          .setDescription(msgconfig.Mod.TicketBlacklist.Add.Success.replace("{userTag}", user.tag) || ":white_check_mark: User has been blacklisted.")
-          .setColor(supportbot.Embed.Colours.Success);
-
-        const blacklistChannel = interaction.guild.channels.cache.get(supportbot.Ticket.Log.TicketBlacklistLog);
-        if (blacklistChannel) {
-          const blacklistLogEmbed = new EmbedBuilder()
-            .setTitle(msgconfig.TicketBlacklistLog.Title || "Ticket Blacklist Log")
-            .setColor(msgconfig.TicketBlacklistLog.Colour || supportbot.Embed.Colours.Success)
-            .setFooter({ text: supportbot.Embed.Footer, iconURL: interaction.user.displayAvatarURL() })
-            .setDescription(`> **User:** ${user.tag} (\`${user.id}\`)\n> **Actioned by:** <@${interaction.user.id}>`)
-            .addFields({ name: "Action", value: "\`\`\`Removed from blacklist\`\`\`", inline: false })
-            .addFields({ name: "Reason", value: `\`\`\`${reason}\`\`\``, inline: false });
-
-          blacklistChannel.send({ embeds: [blacklistLogEmbed] });
-        }
-
-        return interaction.reply({
-          embeds: [successEmbed],
-          ephemeral: true 
-        });
-
-      } else if (subcommand === cmdconfig.Mod.TicketBlacklist.Remove.Command) {
-        if (!blacklistedUsers.includes(user.id)) {
-          const notBlacklistedEmbed = new EmbedBuilder()
-            .setDescription(msgconfig.Mod.TicketBlacklist.Remove.NotBlacklisted.replace("{userTag}", user.tag) || ":x: User is not blacklisted.")
-            .setColor(supportbot.Embed.Colours.Warn);
-          return interaction.reply({ embeds: [notBlacklistedEmbed], ephemeral: true });
-        }
-
-        blacklistedUsers = blacklistedUsers.filter(id => id !== user.id);
-        fs.writeFileSync("./Data/BlacklistedUsers.json", JSON.stringify({ "blacklistedUsers": blacklistedUsers }, null, 4));
-
-        const removedEmbed = new EmbedBuilder()
-          .setDescription(msgconfig.Mod.TicketBlacklist.Remove.Success.replace("{userTag}", user.tag) || ":white_check_mark: User has been removed from the blacklist.")
-          .setColor(supportbot.Embed.Colours.Success);
-
-        const blacklistChannel = interaction.guild.channels.cache.get(supportbot.Ticket.Log.TicketBlacklistLog);
-        if (blacklistChannel) {
-          const blacklistLogEmbed = new EmbedBuilder()
-            .setTitle(msgconfig.TicketBlacklistLog.Title || "Ticket Blacklist Log")
-            .setColor(msgconfig.TicketBlacklistLog.Colour || supportbot.Embed.Colours.Success)
-            .setFooter({ text: supportbot.Embed.Footer, iconURL: interaction.user.displayAvatarURL() })
-            .setDescription(`> **User:** ${user.tag} (\`${user.id}\`)\n> **Actioned by:** <@${interaction.user.id}>`)
-            .addFields({ name: "Action", value: "\`\`\`Removed from blacklist\`\`\`", inline: false })
-            .addFields({ name: "Reason", value: `\`\`\`${reason}\`\`\``, inline: false });
-
-          blacklistChannel.send({ embeds: [blacklistLogEmbed] });
-        }
-
-        return interaction.reply({ embeds: [removedEmbed], ephemeral: true });
-
-      } else if (subcommand === "view") {
-        if (blacklistedUsers.length === 0) {
-          const noBlacklistedUsersEmbed = new EmbedBuilder()
-            .setDescription(msgconfig.Mod.TicketBlacklist.View.NoBlacklistedUsers || "No users are blacklisted.")
-            .setColor(supportbot.Embed.Colours.Success);
-          return interaction.reply({ embeds: [noBlacklistedUsersEmbed], ephemeral: true });
-        }
-
-        const chunkedUsers = chunkArray(blacklistedUsers, 5);
-        let currentPage = 0;
-
-        const createEmbed = (page) => {
-          return new EmbedBuilder()
-            .setTitle(msgconfig.Mod.TicketBlacklist.View.EmbedTitle || "Blacklisted Users")
-            .setDescription(chunkedUsers[page].map(id => `<@${id}>`).join("\n"))
-            .setColor(supportbot.Embed.Colours.Success)
-            .setFooter({ text: `Page ${page + 1} of ${chunkedUsers.length}` });
-        };
-
-        const buttons = new ActionRowBuilder()
-          .addComponents(
-            new ButtonBuilder()
-              .setCustomId('previous')
-              .setLabel('Previous')
-              .setStyle(ButtonStyle.Secondary)
-              .setDisabled(currentPage === 0),
-            new ButtonBuilder()
-              .setCustomId('next')
-              .setLabel('Next')
-              .setStyle(ButtonStyle.Secondary)
-              .setDisabled(currentPage === chunkedUsers.length - 1)
-          );
-
-        const response = await interaction.reply({
-          embeds: [createEmbed(currentPage)],
-          components: chunkedUsers.length > 1 ? [buttons] : [],
-          ephemeral: true
-        });
-
-        if (chunkedUsers.length <= 1) return;
-
-        const collector = response.createMessageComponentCollector({
-          componentType: ComponentType.Button,
-          time: 60000 
-        });
-
-        collector.on('collect', async (i) => {
-          if (i.user.id !== interaction.user.id) {
-            return i.reply({
-              content: 'You cannot use these buttons.',
-              ephemeral: true
-            });
-          }
-
-          if (i.customId === 'previous' && currentPage > 0) {
-            currentPage--;
-          } else if (i.customId === 'next' && currentPage < chunkedUsers.length - 1) {
-            currentPage++;
-          }
-
-          buttons.components[0].setDisabled(currentPage === 0);
-          buttons.components[1].setDisabled(currentPage === chunkedUsers.length - 1);
-
-          await i.update({
-            embeds: [createEmbed(currentPage)],
-            components: [buttons]
-          });
-        });
-
-        collector.on('end', () => {
-          buttons.components.forEach(button => button.setDisabled(true));
-          interaction.editReply({
-            components: [buttons]
-          }).catch(() => {});
-        });
-      }
-    } catch (error) {
-      console.error("Error in mod command:", error);
-      const errorEmbed = new EmbedBuilder()
-        .setDescription(msgconfig.Error.ActionFailed || "An error occurred while processing your request.")
-        .setColor(supportbot.Embed.Colours.Warn);
-      interaction.reply({ embeds: [errorEmbed], ephemeral: true });
-    }
-  }
-});

Commands/ping.js

@@ -13,19 +13,17 @@ const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
 const Command = require("../Structures/Command.js");
 
 module.exports = new Command({
-  name: cmdconfig.Ping.Command,
-  description: cmdconfig.Ping.Description,
+  name: cmdconfig.PingCommand,
+  description: cmdconfig.PingCommandDesc,
   options: [],
-  permissions: cmdconfig.Ping.Permission,
+  permissions: ["SEND_MESSAGES"],
 
   async run(interaction) {
-    let disableCommand = true;
-
-    const PingEmbed = new Discord.EmbedBuilder()
+    const PingEmbed = new Discord.MessageEmbed()
       .setDescription(
         `:ping_pong: **Ping:** \`${interaction.client.ws.ping} ms\``
       )
-      .setColor(supportbot.Embed.Colours.General);
+      .setColor(supportbot.EmbedColour);
 
     interaction.reply({
       embeds: [PingEmbed],

Commands/profile.js

@@ -1,320 +0,0 @@
-const { EmbedBuilder, ModalBuilder, TextInputBuilder, TextInputStyle, ApplicationCommandType, ActionRowBuilder, ButtonBuilder, ButtonStyle, ApplicationCommandOptionType } = require("discord.js");
-const fs = require("fs");
-const yaml = require("js-yaml");
-
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
-
-const Command = require("../Structures/Command.js");
-
-const clockedInUsers = new Set();
-
-function updateClockedInStatus(profileEmbed, clockedIn) {
-  profileEmbed.data.fields = profileEmbed.data.fields.map(field => {
-    if (field.name === 'Clocked In Status') {
-      field.value = clockedIn ? '✅ Clocked In' : '❌ Clocked Out';
-    }
-    return field;
-  });
-  return profileEmbed;
-}
-
-module.exports = new Command({
-  name: cmdconfig.Profile.Command,
-  description: cmdconfig.Profile.Description,
-  type: ApplicationCommandType.ChatInput,
-  permissions: cmdconfig.Profile.Permission,
-  options: [
-    {
-      name: 'user',
-      description: 'The user to view the profile of',
-      type: ApplicationCommandOptionType.User,
-      required: false
-    }
-  ],
-
-  async run(interaction) {
-    await interaction.deferReply({ ephemeral: true }); 
-
-    const userOption = interaction.options.getUser('user');
-    const viewingUser = userOption || interaction.user;
-    const viewingUserId = viewingUser.id;
-    const interactionUserId = interaction.user.id;
-
-    const user = interaction.guild.members.cache.get(viewingUserId);
-    const { getRole, getChannel } = interaction.client;
-
-    const Staff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
-    const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
-
-    if (!Staff || !Admin) {
-      return interaction.editReply({
-        content: "Some roles seem to be missing!\nPlease check for errors when starting the bot.",
-        ephemeral: true,
-      });
-    }
-
-    const isStaff = user.roles.cache.has(Staff.id) || user.roles.cache.has(Admin.id);
-    const isOwnProfile = interactionUserId === viewingUserId;
-
-    const profilePath = `./Data/Profiles/${viewingUserId}.json`;
-    let profileData;
-
-    if (fs.existsSync(profilePath)) {
-      profileData = JSON.parse(fs.readFileSync(profilePath, "utf8"));
-    } else {
-      profileData = {
-        bio: "",
-        timezone: "",
-        clockedIn: false
-      };
-      fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
-    }
-
-    const { bio, timezone, clockedIn } = profileData;
-
-    let profileEmbed = new EmbedBuilder()
-      .setTitle(`${viewingUser.username}'s Profile`)
-      .setColor(supportbot.Embed.Colours.General)
-      .setThumbnail(viewingUser.displayAvatarURL())
-      .addFields(
-        { name: 'Bio', value: bio || 'No bio set.', inline: false },
-        { name: 'Timezone', value: timezone || 'No timezone set.', inline: true }
-      );
-
-    if (isStaff) {
-      profileEmbed.addFields({ name: 'Clocked In Status', value: clockedIn ? '✅ Clocked In' : '❌ Clocked Out', inline: true });
-    }
-
-    const buttonRow = new ActionRowBuilder();
-    if (isOwnProfile) {
-      buttonRow.addComponents(
-        new ButtonBuilder()
-          .setCustomId('editProfile')
-          .setLabel('Edit Profile')
-          .setStyle(ButtonStyle.Secondary)
-      );
-
-      if (isStaff) {
-        buttonRow.addComponents(
-          new ButtonBuilder()
-            .setCustomId('clockInOut')
-            .setLabel(clockedIn ? 'Clock Out' : 'Clock In')
-            .setStyle(ButtonStyle.Secondary)
-        );
-      }
-    }
-
-    if (isStaff && supportbot.Ticket.ClaimTickets.Enabled) {
-      buttonRow.addComponents(
-        new ButtonBuilder()
-          .setCustomId('viewTicketStats')
-          .setLabel('View Ticket Stats')
-          .setStyle(ButtonStyle.Secondary)
-      );
-    }
-
-    await interaction.editReply({ embeds: [profileEmbed], components: buttonRow.components.length > 0 ? [buttonRow] : [] });
-
-    const filter = i => (
-      ['editProfile', 'clockInOut', 'viewTicketStats', 'showOpenTickets', 'backToStats', 'backToProfile'].includes(i.customId) 
-      && i.user.id === interactionUserId
-    );
-
-    const collector = interaction.channel.createMessageComponentCollector({ filter, time: 60000 });
-
-    collector.on('collect', async i => {
-      if (i.customId === 'editProfile') {
-        const modal = new ModalBuilder()
-          .setCustomId('editProfileModal')
-          .setTitle('Edit Profile')
-          .addComponents(
-            new ActionRowBuilder().addComponents(
-              new TextInputBuilder()
-                .setCustomId('bio')
-                .setLabel('Bio')
-                .setStyle(TextInputStyle.Paragraph)
-                .setPlaceholder('Enter your bio')
-                .setValue(String(bio))
-                .setRequired(false)
-            ),
-            new ActionRowBuilder().addComponents(
-              new TextInputBuilder()
-                .setCustomId('timezone')
-                .setLabel('Timezone')
-                .setStyle(TextInputStyle.Short)
-                .setPlaceholder('Enter your timezone')
-                .setValue(String(timezone))
-                .setRequired(false)
-            )
-          );
-
-        await i.showModal(modal);
-      }
-
-      if (i.customId === 'clockInOut') {
-        profileData.clockedIn = !profileData.clockedIn;
-        fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
-        profileEmbed = updateClockedInStatus(profileEmbed, profileData.clockedIn);
-
-        if (profileData.clockedIn) {
-          clockedInUsers.add(viewingUserId);
-        } else {
-          clockedInUsers.delete(viewingUserId);
-        }
-
-        const updatedButtonRow = new ActionRowBuilder()
-          .addComponents(
-            new ButtonBuilder()
-              .setCustomId('editProfile')
-              .setLabel('Edit Profile')
-              .setStyle(ButtonStyle.Secondary)
-          );
-
-        if (isStaff) {
-          updatedButtonRow.addComponents(
-            new ButtonBuilder()
-              .setCustomId('clockInOut')
-              .setLabel(profileData.clockedIn ? 'Clock Out' : 'Clock In')
-              .setStyle(ButtonStyle.Secondary)
-          );
-
-          if (supportbot.Ticket.ClaimTickets.Enabled) {
-            updatedButtonRow.addComponents(
-              new ButtonBuilder()
-                .setCustomId('viewTicketStats')
-                .setLabel('View Ticket Stats')
-                .setStyle(ButtonStyle.Secondary)
-            );
-          }
-        }
-
-        await i.update({ embeds: [profileEmbed], components: [updatedButtonRow] });
-
-        let clockedinout = new EmbedBuilder()
-          .setTitle(profileData.clockedIn ? 'Clocked In!' : 'Clocked Out!') 
-          .setDescription(profileData.clockedIn ? 'You have successfully clocked in.' : 'You have successfully clocked out.')
-          .setColor(supportbot.Embed.Colours.General)
-
-        await interaction.followUp({ embeds: [clockedinout], ephemeral: true });
-      }
-
-      if (i.customId === 'viewTicketStats') {
-        const TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-        const ticketsClaimed = TicketData.tickets.filter(t => t.claimedBy === viewingUserId);
-        const ticketsOpen = ticketsClaimed.filter(t => t.open);
-        const totalTickets = ticketsClaimed.length;
-
-        let totalResponseTime = 0;
-        let responseCount = 0;
-
-        ticketsClaimed.forEach(ticket => {
-          if (ticket.claimedAt && ticket.createdAt) {
-            const responseTime = new Date(ticket.claimedAt) - new Date(ticket.createdAt);
-            totalResponseTime += responseTime;
-            responseCount++;
-          }
-        });
-
-        const averageResponseTime = responseCount ? totalResponseTime / responseCount : 0;
-        const averageResponseTimeMinutes = Math.round(averageResponseTime / 60000);
-
-        const statsEmbed = new EmbedBuilder()
-          .setTitle(msgconfig.TicketStats.Title)
-          .setDescription(`> Ticket stats for <@${viewingUserId}>`)
-          .setColor(supportbot.Embed.Colours.General)
-          .addFields(
-            { name: msgconfig.TicketStats.OpenTickets, value: `${ticketsOpen.length}`, inline: true },
-            { name: msgconfig.TicketStats.TotalTickets, value: `${totalTickets}`, inline: true },
-            { name: msgconfig.TicketStats.ResponseTime, value: `${averageResponseTimeMinutes} minutes`, inline: false }
-          );
-
-        const statsButtonRow = new ActionRowBuilder()
-          .addComponents(
-            new ButtonBuilder()
-              .setCustomId('showOpenTickets')
-              .setLabel('Show Open Tickets')
-              .setStyle(ButtonStyle.Secondary),
-            new ButtonBuilder()
-              .setCustomId('backToProfile')
-              .setLabel('Back to Profile')
-              .setStyle(ButtonStyle.Secondary)
-          );
-
-        await i.update({ embeds: [statsEmbed], components: [statsButtonRow] });
-      }
-
-      if (i.customId === 'showOpenTickets') {
-        const TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-        const ticketsOpen = TicketData.tickets.filter(t => t.claimedBy === viewingUserId && t.open);
-
-        const openTicketsEmbed = new EmbedBuilder()
-          .setTitle('Active Tickets')
-          .setDescription(ticketsOpen.map(t => `<#${t.id}>`).join('\n') || 'No active tickets.')
-          .setColor(supportbot.Embed.Colours.General);
-
-        const openTicketsButtonRow = new ActionRowBuilder()
-          .addComponents(
-            new ButtonBuilder()
-              .setCustomId('backToStats')
-              .setLabel('Back to Stats')
-              .setStyle(ButtonStyle.Secondary)
-          );
-
-        await i.update({ embeds: [openTicketsEmbed], components: [openTicketsButtonRow] });
-      }
-
-      if (i.customId === 'backToStats') {
-        const TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-        const ticketsClaimed = TicketData.tickets.filter(t => t.claimedBy === viewingUserId);
-        const ticketsOpen = ticketsClaimed.filter(t => t.open);
-        const totalTickets = ticketsClaimed.length;
-
-        let totalResponseTime = 0;
-        let responseCount = 0;
-
-        ticketsClaimed.forEach(ticket => {
-          if (ticket.claimedAt && ticket.createdAt) {
-            const responseTime = new Date(ticket.claimedAt) - new Date(ticket.createdAt);
-            totalResponseTime += responseTime;
-            responseCount++;
-          }
-        });
-
-        const averageResponseTime = responseCount ? totalResponseTime / responseCount : 0;
-        const averageResponseTimeMinutes = Math.round(averageResponseTime / 60000);
-
-        const statsEmbed = new EmbedBuilder()
-          .setTitle(msgconfig.TicketStats.Title)
-          .setDescription(`> Ticket stats for <@${viewingUserId}>`)
-          .setColor(supportbot.Embed.Colours.General)
-          .addFields(
-            { name: msgconfig.TicketStats.OpenTickets, value: `${ticketsOpen.length}`, inline: true },
-            { name: msgconfig.TicketStats.TotalTickets, value: `${totalTickets}`, inline: true },
-            { name: msgconfig.TicketStats.ResponseTime, value: `${averageResponseTimeMinutes} minutes`, inline: false }
-          );
-
-        const statsButtonRow = new ActionRowBuilder()
-          .addComponents(
-            new ButtonBuilder()
-              .setCustomId('showOpenTickets')
-              .setLabel('Show Open Tickets')
-              .setStyle(ButtonStyle.Secondary),
-            new ButtonBuilder()
-              .setCustomId('backToProfile')
-              .setLabel('Back to Profile')
-              .setStyle(ButtonStyle.Secondary)
-          );
-
-        await i.update({ embeds: [statsEmbed], components: [statsButtonRow] });
-      }
-
-      if (i.customId === 'backToProfile') {
-        await i.update({ embeds: [profileEmbed], components: buttonRow.components.length > 0 ? [buttonRow] : [] });
-      }
-    });
-  }
-});
-
-module.exports.clockedInUsers = clockedInUsers;

Commands/remove.js

@@ -0,0 +1,94 @@
+// SupportBot | Emerald Services
+// Ticket Remove Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.TicketRemove,
+  description: cmdconfig.TicketRemoveDesc,
+  options: [
+    {
+      name: "user",
+      description: "User to remove",
+      type: "USER",
+      required: true,
+    },
+  ],
+  permissions: ["SEND_MESSAGES"],
+
+  async run(interaction) {
+    const { getRole } = interaction.client;
+    let Staff = await getRole(supportbot.Staff, interaction.guild);
+    let Admin = await getRole(supportbot.Admin, interaction.guild);
+    if (!Staff || !Admin)
+      return interaction.reply(
+        "Some roles seem to be missing!\nPlease check for errors when starting the bot."
+      );
+
+    const NoPerms = new Discord.MessageEmbed()
+      .setTitle("Invalid Permissions!")
+      .setDescription(
+        `${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``
+      )
+      .setColor(supportbot.WarningColour);
+
+    if (
+      !interaction.member.roles.cache.has(Staff.id) &&
+      !interaction.member.roles.cache.has(Admin.id)
+    )
+      return interaction.reply({ embeds: [NoPerms] });
+    let TicketData = await JSON.parse(
+      fs.readFileSync("./Data/TicketData.json", "utf8")
+    );
+    let ticket = await TicketData.tickets.findIndex(
+      (t) => t.id === interaction.channel.id
+    );
+    if (ticket === -1) {
+      const Exists = new Discord.MessageEmbed()
+        .setTitle("No Ticket Found!")
+        .setDescription(supportbot.NoValidTicket)
+        .setColor(supportbot.WarningColour);
+      return interaction.reply({ ephemeral: true, embeds: [Exists] });
+    }
+
+    let uMember = interaction.options.getUser("user");
+    const UserNotExist = new Discord.MessageEmbed()
+      .setTitle("User Not Found!")
+      .setDescription(
+        `${supportbot.UserNotFound}\n\nTry Again:\`/${cmdconfig.TicketRemove} <user#0000>\``
+      )
+      .setColor(supportbot.ErrorColour);
+
+    if (!uMember) return interaction.reply({ ephemeral: true, embeds: [UserNotExist] });
+
+    await interaction.channel.permissionOverwrites.edit(uMember.id, {
+      VIEW_CHANNEL: false,
+    });
+
+    const Complete = new Discord.MessageEmbed()
+      .setTitle("User Removed!")
+      .setDescription(supportbot.RemovedUser.replace(/%user%/g, uMember.id))
+      .setTimestamp()
+      .setColor(supportbot.EmbedColour);
+    interaction.reply({ embeds: [Complete] });
+    TicketData.tickets[ticket].subUsers = TicketData.tickets[
+      ticket
+    ].subUsers.filter((u) => u !== uMember.id);
+    fs.writeFileSync(
+      "./Data/TicketData.json",
+      JSON.stringify(TicketData, null, 4),
+      (err) => {
+        if (err) console.error(err);
+      }
+    );
+  },
+});

Commands/removeUser.js

@@ -1,134 +0,0 @@
-const fs = require("fs");
-const {
-  EmbedBuilder,
-  ApplicationCommandOptionType,
-  ApplicationCommandType,
-  ChannelType,
-  ActionRowBuilder,
-  ButtonBuilder,
-  ButtonStyle,
-} = require("discord.js");
-const yaml = require("js-yaml");
-
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
-const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-
-const Command = require("../Structures/Command.js");
-
-module.exports = new Command({
-  name: cmdconfig.RemoveUser.Command,
-  description: cmdconfig.RemoveUser.Description,
-  type: ApplicationCommandType.ChatInput,
-  options: [
-    {
-      name: "user",
-      description: "The user to remove",
-      type: ApplicationCommandOptionType.User,
-      required: true,
-    },
-  ],
-  permissions: cmdconfig.RemoveUser.Permission,
-
-  async run(interaction) {
-
-    const { getRole } = interaction.client;
-    let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
-    let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
-    if (!SupportStaff || !Admin) {
-      return interaction.reply(
-        "Some roles seem to be missing!\nPlease check for errors when starting the bot."
-      );
-    }
-
-    const NoPerms = new EmbedBuilder()
-      .setTitle("Invalid Permissions!")
-      .setDescription(
-        `${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``
-      )
-      .setColor(supportbot.Embed.Colours.Warn);
-
-    if (
-      !interaction.member.roles.cache.has(SupportStaff.id) &&
-      !interaction.member.roles.cache.has(Admin.id)
-    ) {
-      return interaction.reply({ embeds: [NoPerms] });
-    }
-
-    const userToRemove = interaction.options.getUser("user");
-    const ticketChannel = interaction.channel;
-    const ticketDataPath = "./Data/TicketData.json";
-
-    // Check if the channel is a ticket thread or text channel based on TicketType
-    if (
-      (supportbot.Ticket.TicketType === "threads" && !ticketChannel.isThread()) ||
-      (supportbot.Ticket.TicketType === "channels" && ticketChannel.type !== ChannelType.GuildText)
-    ) {
-      const onlyInTicket = new EmbedBuilder()
-        .setTitle(msgconfig.RemoveUser.NotInTicket_Title)
-        .setDescription(msgconfig.RemoveUser.NotInTicket_Description)
-        .setColor(supportbot.Embed.Colours.Error);
-
-      return interaction.reply({
-        embeds: [onlyInTicket],
-        ephemeral: true,
-      });
-    }
-
-    try {
-      // Remove user from thread or channel based on TicketType
-      if (supportbot.Ticket.TicketType === "threads") {
-        await ticketChannel.members.remove(userToRemove.id); // For threads
-      } else if (supportbot.Ticket.TicketType === "channels") {
-        await ticketChannel.permissionOverwrites.delete(userToRemove.id); // For channels
-      }
-
-      // Update the ticket data
-      const ticketData = JSON.parse(fs.readFileSync(ticketDataPath, "utf8"));
-      const ticketIndex = ticketData.tickets.findIndex((t) => t.id === ticketChannel.id);
-      if (ticketIndex !== -1) {
-        const subUsers = ticketData.tickets[ticketIndex].subUsers;
-        const userIndex = subUsers.indexOf(userToRemove.id);
-        if (userIndex !== -1) {
-          subUsers.splice(userIndex, 1);
-          fs.writeFileSync(ticketDataPath, JSON.stringify(ticketData, null, 4));
-        }
-      }
-
-      const removedEmbed = new EmbedBuilder()
-        .setTitle(msgconfig.RemoveUser.Removed_Title)
-        .setDescription(msgconfig.RemoveUser.Removed_Message)
-        .setColor(supportbot.Embed.Colours.Success);
-
-      await interaction.reply({
-        embeds: [removedEmbed],
-        ephemeral: true,
-      });
-
-      const removedFromTicketEmbed = new EmbedBuilder()
-        .setTitle(msgconfig.RemoveUser.RemovedFromTicket_Title)
-        .setDescription(msgconfig.RemoveUser.RemovedFromTicket_Description.replace(
-          "%channel_link%",
-          `[${ticketChannel.name}](https://discord.com/channels/${ticketChannel.guild.id}/${ticketChannel.id})`
-        ))
-        .setColor(supportbot.Embed.Colours.General);
-
-      await userToRemove.send({
-        embeds: [removedFromTicketEmbed],
-      });
-
-    } catch (err) {
-      console.error("Error removing user from the ticket:", err);
-
-      const errorEmbed = new EmbedBuilder()
-        .setTitle(msgconfig.RemoveUser.Error_Title)
-        .setDescription(msgconfig.RemoveUser.Error_Removing)
-        .setColor(supportbot.Embed.Colours.Error);
-
-      await interaction.reply({
-        embeds: [errorEmbed],
-        ephemeral: true,
-      });
-    }
-  },
-});

Commands/settings.js

@@ -1,235 +0,0 @@
-const { Command } = require('../Structures/Addon.js');
-const Discord = require("discord.js");
-const fs = require("fs");
-const yaml = require("js-yaml");
-const path = require("path");
-
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-const settingsFilePath = path.resolve(__dirname, '../Data/settings.json');
-
-function loadSettings() {
-  try {
-    if (fs.existsSync(settingsFilePath)) {
-      const data = fs.readFileSync(settingsFilePath, 'utf8');
-      return JSON.parse(data);
-    } else {
-      return {};
-    }
-  } catch (error) {
-    console.error("Error reading settings file:", error);
-    return {};
-  }
-}
-
-function saveSettings(settings) {
-  try {
-    fs.writeFileSync(settingsFilePath, JSON.stringify(settings, null, 2), 'utf8');
-  } catch (error) {
-    console.error("Error writing settings file:", error);
-  }
-}
-
-module.exports = new Command({
-  name: cmdconfig.Settings.Command,
-  description: cmdconfig.Settings.Description,
-  permissions: cmdconfig.Settings.Permission,
-  options: [
-    {
-      name: 'setstatus',
-      type: Discord.ApplicationCommandOptionType.Subcommand,
-      description: 'Set the bot status',
-      options: [
-        {
-          name: 'status',
-          type: Discord.ApplicationCommandOptionType.String,
-          description: 'Choose the bot status',
-          required: true,
-          choices: [
-            { name: 'Online 🟢', value: 'online' },
-            { name: 'Idle 🌙', value: 'idle' },
-            { name: 'Do Not Disturb ⛔', value: 'dnd' },
-            { name: 'Invisible 👻', value: 'invisible' }
-          ],
-        },
-      ],
-    },
-    {
-      name: 'setactivity',
-      type: Discord.ApplicationCommandOptionType.Subcommand,
-      description: 'Set the bot activity',
-      options: [
-        {
-          name: 'type',
-          type: Discord.ApplicationCommandOptionType.String,
-          description: 'Choose the activity type',
-          required: true,
-          choices: [
-            { name: 'Playing 🎮', value: 'PLAYING' },
-            { name: 'Watching 👀', value: 'WATCHING' },
-            { name: 'Listening 🎧', value: 'LISTENING' },
-            { name: 'Competing 🏆', value: 'COMPETING' }
-          ],
-        },
-        {
-          name: 'message',
-          type: Discord.ApplicationCommandOptionType.String,
-          description: 'The activity message',
-          required: true,
-        },
-      ],
-    },
-    {
-      name: 'streammode',
-      type: Discord.ApplicationCommandOptionType.Subcommand,
-      description: 'Set the bot streaming status',
-      options: [
-        {
-          name: 'toggle',
-          type: Discord.ApplicationCommandOptionType.String,
-          description: 'Turn streaming mode on or off',
-          required: true,
-          choices: [
-            { name: 'On', value: 'on' },
-            { name: 'Off', value: 'off' }
-          ],
-        },
-        {
-          name: 'twitchurl',
-          type: Discord.ApplicationCommandOptionType.String,
-          description: 'Twitch stream URL (Required if turning on)',
-          required: false,
-        },
-      ],
-    },
-    {
-      name: 'setnickname',
-      type: Discord.ApplicationCommandOptionType.Subcommand,
-      description: 'Set the bot nickname',
-      options: [
-        {
-          name: 'nickname',
-          type: Discord.ApplicationCommandOptionType.String,
-          description: 'The new nickname for the bot',
-          required: true,
-        },
-      ],
-    },
-  ],
-
-  async run(interaction) {
-    const subcommand = interaction.options.getSubcommand();
-    const settings = loadSettings();
-
-    if (subcommand === 'setstatus') {
-      const status = interaction.options.getString('status');
-
-      try {
-        interaction.client.user.setPresence({
-          status: status,
-          activities: interaction.client.user.presence.activities || [],
-        });
-
-        settings.status = status;
-        saveSettings(settings);
-
-        const embed = new Discord.EmbedBuilder()
-          .setDescription(`Status set to **${status.charAt(0).toUpperCase() + status.slice(1)}**`)
-          .setColor(supportbot.Embed.Colours.General);
-
-        return interaction.reply({ embeds: [embed], ephemeral: true });
-      } catch (error) {
-        return interaction.reply({ content: `Failed to set status: ${error.message}`, ephemeral: true });
-      }
-    } 
-    
-    if (subcommand === 'setactivity') {
-      const activityType = interaction.options.getString('type');
-      const activityMessage = interaction.options.getString('message');
-
-      try {
-        interaction.client.user.setPresence({
-          activities: [{ name: activityMessage, type: Discord.ActivityType[activityType] }],
-          status: interaction.client.user.presence.status || 'online',
-        });
-
-        settings.activity = { type: activityType, message: activityMessage };
-        saveSettings(settings);
-
-        const embed = new Discord.EmbedBuilder()
-          .setDescription(`Activity set to **${activityType.toLowerCase()} ${activityMessage}**`)
-          .setColor(supportbot.Embed.Colours.General);
-
-        return interaction.reply({ embeds: [embed], ephemeral: true });
-      } catch (error) {
-        return interaction.reply({ content: `Failed to set activity: ${error.message}`, ephemeral: true });
-      }
-    } else if (subcommand === 'streammode') {
-      const toggle = interaction.options.getString('toggle');
-      const twitchUrl = interaction.options.getString('twitchurl');
-
-      if (toggle === 'on') {
-        if (!twitchUrl) {
-          return interaction.reply({ content: 'Please provide a Twitch URL to stream.', ephemeral: true });
-        }
-
-        try {
-          interaction.client.user.setPresence({
-            activities: [{ name: 'Streaming', type: Discord.ActivityType.Streaming, url: twitchUrl }],
-            status: 'online',
-          });
-
-          settings.streaming = { active: true, url: twitchUrl };
-          saveSettings(settings);
-
-          const embed = new Discord.EmbedBuilder()
-            .setDescription(`**Streaming mode enabled!**\nStreaming: [Twitch](${twitchUrl})`)
-            .setColor(supportbot.Embed.Colours.General);
-
-          return interaction.reply({ embeds: [embed], ephemeral: true });
-        } catch (error) {
-          return interaction.reply({ content: `Failed to enable streaming mode: ${error.message}`, ephemeral: true });
-        }
-      } else if (toggle === 'off') {
-        try {
-          interaction.client.user.setPresence({
-            activities: interaction.client.user.presence.activities.filter(a => a.type !== Discord.ActivityType.Streaming),
-            status: settings.status || 'online',
-          });
-
-          settings.streaming = { active: false };
-          saveSettings(settings);
-
-          const embed = new Discord.EmbedBuilder()
-            .setDescription(`**Streaming mode disabled!**`)
-            .setColor(supportbot.Embed.Colours.General);
-
-          return interaction.reply({ embeds: [embed], ephemeral: true });
-        } catch (error) {
-          return interaction.reply({ content: `Failed to disable streaming mode: ${error.message}`, ephemeral: true });
-        }
-      }
-    } else if (subcommand === 'setnickname') {
-      const nickname = interaction.options.getString('nickname');
-
-      try {
-        const guild = interaction.guild;
-        const botMember = guild.members.cache.get(interaction.client.user.id);
-        await botMember.setNickname(nickname);
-
-        settings.nickname = nickname;
-        saveSettings(settings);
-
-        const embed = new Discord.EmbedBuilder()
-          .setDescription(`Bot nickname set to **${nickname}**`)
-          .setColor(supportbot.Embed.Colours.General);
-
-        return interaction.reply({ embeds: [embed], ephemeral: true });
-      } catch (error) {
-        return interaction.reply({ content: `Failed to set nickname: ${error.message}`, ephemeral: true });
-      }
-    } else {
-      return interaction.reply({ content: 'Invalid command usage.', ephemeral: true });
-    }
-  },
-});

Commands/suggest.js

@@ -1,115 +1,84 @@
+// SupportBot | Emerald Services
+// Suggest Command
+
 const fs = require("fs");
+
 const Discord = require("discord.js");
 const yaml = require("js-yaml");
-
-// Load configurations
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
 const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
 
 const Command = require("../Structures/Command.js");
 
-// Ensure suggestions file exists and is correctly loaded
-let suggestions;
-try {
-  suggestions = require("../Data/SuggestionData.json");
-} catch (error) {
-  suggestions = {};
-}
-
 module.exports = new Command({
-  name: cmdconfig.Suggestion.Command,
-  description: cmdconfig.Suggestion.Description,
-  type: Discord.ApplicationCommandType.ChatInput,
+  name: cmdconfig.SuggestCommand,
+  description: cmdconfig.SuggestCommandDesc,
   options: [
     {
       name: "suggestion",
       description: "Create a Suggestion",
-      type: Discord.ApplicationCommandOptionType.String,
+      type: "STRING",
       required: true,
     },
   ],
-  permissions: cmdconfig.Suggestion.Permission,
+  permissions: ["SEND_MESSAGES"],
 
   async run(interaction) {
     const { getChannel } = interaction.client;
-
     const suggestChannel = await getChannel(
-      supportbot.Suggestions.Channel,
+      supportbot.SuggestionChannel,
       interaction.guild
     );
 
-    const NoChannel = new Discord.EmbedBuilder()
+    const NoChannel = new Discord.MessageEmbed()
       .setTitle("Missing Channel!")
-      .setDescription(msgconfig.Error.InvalidChannel)
-      .setColor(supportbot.Embed.Colours.Error);
+      .setDescription(supportbot.InvalidChannel)
+      .setColor(supportbot.ErrorColour);
 
     if (!suggestChannel) return interaction.reply({ embeds: [NoChannel] });
 
     let suggestion = interaction.options.getString("suggestion");
 
-    const SuggestEmbed = new Discord.EmbedBuilder()
-      .addFields(
-        { name: "Suggestion", value: suggestion, inline: true },
-        { name: "From", value: `<@${interaction.user.id}>` },
-        { name: `${supportbot.Suggestions.UpvoteEmoji} ${supportbot.Suggestions.UpvoteTitle}`, value: "0", inline: true },
-        { name: `${supportbot.Suggestions.DownvoteEmoji} ${supportbot.Suggestions.DownvoteTitle}`, value: "0", inline: true }
-      )
+    const SuggestEmbed = new Discord.MessageEmbed()
+      .addField("Suggestion", suggestion, true)
+      .addField("From", `<@${interaction.user.id}>`)
       .setThumbnail(interaction.user.displayAvatarURL())
       .setFooter({
-        text: supportbot.Embed.Footer,
+        text: supportbot.EmbedFooter,
         iconURL: interaction.user.displayAvatarURL(),
       })
-      .setColor(supportbot.Embed.Colours.General);
+      .setColor(supportbot.EmbedColour);
 
-    const UpvoteButton = new Discord.ButtonBuilder()
-      .setCustomId("upvote")
-      .setEmoji(supportbot.Suggestions.UpvoteEmoji)
-      .setStyle(supportbot.Suggestions.Buttons.Upvote);
+    const suggestionMsg = await suggestChannel.send({ embeds: [SuggestEmbed] });
+    if (supportbot.SuggestionUpvote && supportbot.SuggestionDownvote) {
+      await suggestionMsg.react(supportbot.SuggestionUpvote);
+      await suggestionMsg.react(supportbot.SuggestionDownvote);
 
-    const DownvoteButton = new Discord.ButtonBuilder()
-      .setCustomId("downvote")
-      .setEmoji(supportbot.Suggestions.DownvoteEmoji)
-      .setStyle(supportbot.Suggestions.Buttons.Downvote);
-
-    const RemoveVoteButton = new Discord.ButtonBuilder()
-      .setCustomId("removevote")
-      .setLabel(supportbot.Suggestions.Buttons.RemoveVote_Title)
-      .setStyle(supportbot.Suggestions.Buttons.RemoveVote); // Red button
-
-    const row = new Discord.ActionRowBuilder().addComponents(UpvoteButton, DownvoteButton, RemoveVoteButton);
-
-    const suggestionMsg = await suggestChannel.send({ embeds: [SuggestEmbed], components: [row] });
-
-    suggestions[suggestionMsg.id] = {
-      suggestion: suggestion,
-      author: interaction.user.id,
-      upvotes: [],
-      downvotes: []
-    };
-
-    fs.writeFileSync("./Data/SuggestionData.json", JSON.stringify(suggestions, null, 2));
-
-    if (supportbot.Suggestions.Threads.Enabled) {
-      await suggestionMsg.startThread({
-        name: supportbot.Suggestions.Threads.Title,
-        autoArchiveDuration: 60,
-        type: Discord.ChannelType.PublicThread,
-        reason: supportbot.Suggestions.Threads.Reason,
-      });
+      if (supportbot.SuggestionThreads) {
+        await suggestionMsg.startThread({
+              name: `Suggestion-releated Thread`,
+              autoArchiveDuration: 60,
+              type: 'GUILD_PUBLIC_THREAD',
+              reason: 'Suggestion-releated thread',
+          })
+    
+        }
     }
 
-    const Submitted = new Discord.EmbedBuilder()
-      .setTitle(`${msgconfig.Suggestions.Sent_Title}`)
-      .setDescription(`${msgconfig.Suggestions.Sent}`)
-      .addFields(
-        { name: "Sent to:", value: `<#${suggestChannel.id}>` },
+    const Submitted = new Discord.MessageEmbed()
+      .setTitle("Suggestion Submitted!")
+      .setDescription(
+        `:white_check_mark: You have successfully submitted a suggestion.`
       )
-      .setColor(supportbot.Embed.Colours.Success);
+      .addField("Sent to:", `<#${suggestChannel.id}>`)
+      .setColor(supportbot.SuccessColour);
 
-    await interaction.reply({ 
+    return interaction.reply({ 
       ephemeral: true, 
       embeds: [Submitted] 
-    });
+    })
+    
   },
 });

Commands/ticket.js

@@ -1,550 +1,334 @@
+// SupportBot | Emerald Services
+// Ticket Command
+
 const fs = require("fs");
+
 const {
-  EmbedBuilder,
-  ApplicationCommandOptionType,
-  ApplicationCommandType,
-  ChannelType,
-  ActionRowBuilder,
-  ButtonBuilder,
-  StringSelectMenuBuilder,
-  StringSelectMenuOptionBuilder,
-  ButtonStyle,
-  MessageCollector,
+  MessageEmbed,
+  Permissions,
+  MessageButton,
+  MessageActionRow,
 } = require("discord.js");
 const yaml = require("js-yaml");
-
-const panelconfig = yaml.load(fs.readFileSync("./Configs/ticket-panel.yml", "utf8"));
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
 const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
 
 const Command = require("../Structures/Command.js");
 const TicketNumberID = require("../Structures/TicketID.js");
 
-async function isBlacklisted(userId) {
-  let blacklistData;
-  try {
-    blacklistData = JSON.parse(fs.readFileSync("./Data/BlacklistedUsers.json", "utf8"));
-  } catch (error) {
-    console.error("Error reading BlacklistedUsers.json:", error);
-    return false; 
-  }
-  
-  if (!blacklistData || !Array.isArray(blacklistData.blacklistedUsers)) {
-    console.error("blacklistedUsers is not defined or is not an array");
-    return false;
-  }
-  
-  return blacklistData.blacklistedUsers.includes(userId);
-}
-
-async function getClockedInUsers(guild) {
-  const clockedInUsers = new Set();
-
-  const profilesDir = './Data/Profiles';
-  const profileFiles = fs.readdirSync(profilesDir);
-
-  for (const file of profileFiles) {
-    const profileData = JSON.parse(fs.readFileSync(`${profilesDir}/${file}`, "utf8"));
-    if (profileData.clockedIn) {
-      const userId = file.replace('.json', '');
-      const member = await guild.members.fetch(userId);
-      if (member) clockedInUsers.add(member.id);
-    }
-  }
-  return clockedInUsers;
-}
-
-async function askTicketQuestions(ticketChannel, interaction, questions) {
-  const answers = [];
-  let questionIndex = 0;
-
-  const sendNextQuestion = async () => {
-    if (questionIndex < questions.length) {
-
-      const questionsEmbed = new EmbedBuilder()
-        .setDescription(`**${questionIndex + 1}.** ${questions[questionIndex]}`)
-        .setColor(supportbot.Embed.Colours.General)
-
-      const questionMessage = await ticketChannel.send({
-        embeds: [questionsEmbed], 
-      });
-
-      const collector = new MessageCollector(ticketChannel, {
-        filter: (m) => m.author.id === interaction.user.id,
-        max: 1,
-        time: 60000,
-      });
-
-      collector.on("collect", async (message) => {
-        answers.push({ question: questions[questionIndex], answer: message.content });
-        questionIndex++;
-        await message.delete();
-        await questionMessage.delete();
-        sendNextQuestion();
-      });
-
-    } else {
-
-      const summaryEmbed = new EmbedBuilder()
-        .setTitle(msgconfig.Ticket.TicketQuestions.Details.Title)
-        .setDescription(msgconfig.Ticket.TicketQuestions.Details.Description.replace('%user%', interaction.user.id))
-        .setColor(supportbot.Embed.Colours.General)
-        .addFields(
-          answers.map((a) => ({
-            name: `Q: ${a.question}`,
-            value: `A: ${a.answer}`,
-            inline: false,
-          }))
-        )
-        .setTimestamp();
-
-      await ticketChannel.send({ 
-        embeds: [summaryEmbed] 
-      });
-    }
-  };
-
-  // Start asking the first question
-  sendNextQuestion();
-}
-
-async function assignTicketToUser(ticketChannel, Staff, Admin, interaction, attempts = 0) {
-
-  try {
-    const clockedInUsers = await getClockedInUsers(interaction.guild);
-
-    if (clockedInUsers.size === 0 || attempts >= 2) {
-      const claimChannel = await interaction.guild.channels.cache.get(supportbot.Ticket.ClaimTickets.Channel);
-      if (claimChannel) {
-        const claimEmbed = new EmbedBuilder()
-          .setTitle(msgconfig.Ticket.ClaimTickets.ClaimTitle)
-          .setDescription(msgconfig.Ticket.ClaimTickets.ClaimMessage)
-          .setColor(supportbot.Embed.Colours.General);
-
-        const claimButton = new ButtonBuilder()
-          .setCustomId(`claimticket-${ticketChannel.id}`)
-          .setLabel(supportbot.Ticket.ClaimTickets.ButtonTitle || 'Claim Ticket')
-          .setStyle(ButtonStyle.Primary);
-
-        const row = new ActionRowBuilder().addComponents(claimButton);
-
-        const claimMessage = await claimChannel.send({
-          content: `<@&${Staff.id}> <@&${Admin.id}>`,
-          embeds: [claimEmbed],
-          components: [row],
-        });
-
-        const filter = i => i.customId === `claimticket-${ticketChannel.id}` && i.member.roles.cache.has(Staff.id);
-        const collector = claimMessage.createMessageComponentCollector({ filter, time: 120000 });
-
-        collector.on('collect', async i => {
-          await ticketChannel.send({ content: `<@${i.user.id}> has claimed the ticket.` });
-        });
-
-        collector.on('end', async collected => {
-          if (collected.size === 0) {
-            await claimMessage.delete();
-
-            await claimChannel.send({
-              content: `Ticket is still unclaimed. \nCC: [<@&${Staff.id}> <@&${Admin.id}]`,
-              embeds: [new EmbedBuilder().setDescription(`Ticket is still unclaimed: <#${ticketChannel.id}>`).setColor(supportbot.Embed.Colours.Warn)],
-            });
-          }
-        });
-
-        return null;
-      } else {
-        console.error("Claim channel not found");
-        return null;
-      }
-    }
-
-    const clockedInArray = Array.from(clockedInUsers);
-    const assignedUserId = clockedInArray[Math.floor(Math.random() * clockedInArray.length)];
-    const assignedUser = await interaction.guild.members.fetch(assignedUserId);
-
-    const claimEmbed = new EmbedBuilder()
-      .setTitle(msgconfig.Ticket.ClaimTickets.ClaimTitle)
-      .setDescription(msgconfig.Ticket.ClaimTickets.ClaimMessage.replace('%user%', interaction.user.id))
-      .setColor(supportbot.Embed.Colours.General);
-
-    const claimButton = new ButtonBuilder()
-      .setCustomId(`claimticket-${ticketChannel.id}`)
-      .setLabel(supportbot.Ticket.ClaimTickets.ButtonTitle || 'Claim Ticket')
-      .setStyle(ButtonStyle.Primary);
-
-    const row = new ActionRowBuilder().addComponents(claimButton);
-
-    const claimChannel = await interaction.guild.channels.cache.get(supportbot.Ticket.ClaimTickets.Channel);
-    if (!claimChannel) {
-      console.error("Claim channel not found");
-      return null;
-    }
-
-    const claimMessage = await claimChannel.send({
-      content: `${assignedUser}`,
-      embeds: [claimEmbed],
-      components: [row],
-    });
-
-    const filter = i => i.customId === `claimticket-${ticketChannel.id}` && i.user.id === assignedUserId;
-    const collector = claimMessage.createMessageComponentCollector({ filter, time: 120000 });
-
-    collector.on('collect', async i => {
-      await ticketChannel.send({ content: `<@${assignedUserId}>` }).then(msg => setTimeout(() => msg.delete(), 5000));
-    });
-
-    collector.on('end', async collected => {
-      if (collected.size === 0) {
-        await claimMessage.delete();
-
-        if (attempts >= 1) {
-          await claimChannel.send({
-            content: `No one claimed the ticket. Tagging roles: <@&${Staff.id}> <@&${Admin.id}>`,
-            embeds: [new EmbedBuilder().setDescription(`Ticket is still unclaimed: <#${ticketChannel.id}>`).setColor(supportbot.Embed.Colours.Warn)],
-          });
-
-          const claimEmbed = new EmbedBuilder()
-            .setTitle(msgconfig.Ticket.ClaimTickets.ClaimTitle)
-            .setDescription(msgconfig.Ticket.ClaimTickets.ClaimMessage)
-            .setColor(supportbot.Embed.Colours.General);
-
-          const claimButton = new ButtonBuilder()
-            .setCustomId(`claimticket-${ticketChannel.id}`)
-            .setLabel(supportbot.Ticket.ClaimTickets.ButtonTitle)
-            .setEmoji(supportbot.Ticket.ClaimTickets.ButtonEmoji)
-            .setStyle(ButtonStyle.Primary);
-
-          const row = new ActionRowBuilder().addComponents(claimButton);
-
-          const claimMessage = await claimChannel.send({
-            embeds: [claimEmbed],
-            components: [row],
-          });
-
-          const filter = i => i.customId === `claimticket-${ticketChannel.id}` && i.member.roles.cache.has(Staff.id);
-          const collector = claimMessage.createMessageComponentCollector({ filter, time: 120000 });
-
-          collector.on('collect', async i => {
-            console.log(`Ticket ${ticketChannel.id} claimed by user ${i.user.id}`);
-            await ticketChannel.member.add(i.user.id);
-          });
-
-          collector.on('end', async collected => {
-            if (collected.size === 0) {
-              console.log(`No one claimed the ticket (${ticketChannel.id}), notifying all staff`);
-              await claimMessage.delete();
-
-              await claimChannel.send({
-                content: `No one claimed the ticket. Tagging roles: <@&${Staff.id}> <@&${Admin.id}>`,
-              });
-            }
-          });
-        } else {
-          const ReassigningEmbed = new EmbedBuilder()
-            .setTitle(msgconfig.Ticket.ClaimTickets.ReassigningTitle)
-            .setDescription(msgconfig.Ticket.ClaimTickets.ReassigningMessage.replace('%user%', assignedUserId))
-            .setColor(supportbot.Embed.Colours.General);
-
-          await claimChannel.send({ embeds: [ReassigningEmbed], components: [] });
-          await assignTicketToUser(ticketChannel, Staff, Admin, interaction, attempts + 1);
-        }
-      }
-    });
-
-    return assignedUserId;
-  } catch (error) {
-    console.error("Error in assignTicketToUser function:", error);
-    if (error instanceof CombinedError) {
-      console.error("CombinedError details:", error.errors);
-    }
-    return null;
-  }
-}
-
 module.exports = new Command({
-  name: cmdconfig.OpenTicket.Command,
-  description: cmdconfig.OpenTicket.Description,
-  type: ApplicationCommandType.ChatInput,
+  name: cmdconfig.OpenTicket,
+  description: cmdconfig.OpenTicketDesc,
   options: [
     {
       name: "reason",
       description: "Ticket Reason",
-      type: ApplicationCommandOptionType.String,
+      type: "STRING",
     },
   ],
-  permissions: cmdconfig.OpenTicket.Permission,
+  permissions: ["SEND_MESSAGES"],
 
   async run(interaction) {
-    
-    try {
+    let disableCommand = true;
+    if (interaction.isCommand() && disableCommand)
+      return interaction.reply({
+        content: "This command is disabled",
+        ephemeral: true,
+      });
+    let department = interaction.customId?.split("-")[1] || null;
+    let TicketData = await JSON.parse(
+      fs.readFileSync("./Data/TicketData.json", "utf8")
+    );
+    const { getRole, getCategory } = interaction.client;
+    let User = interaction.guild.members.cache.get(interaction.user.id);
 
-      if (await isBlacklisted(interaction.user.id)) {
-        return interaction.reply({
-          content: msgconfig.Ticket.Blacklisted,
-          ephemeral: true,
-        });
+    if (
+      supportbot.MaxAllowedTickets &&
+      TicketData.tickets.filter((t) => t.user === interaction.user.id && t.open)
+        .length >= supportbot.MaxAllowedTickets
+    ) {
+      return interaction.reply({
+        embeds: [
+          {
+            title: "Too Many Tickets!",
+            description: `You can't have more than ${supportbot.MaxAllowedTickets} open tickets!`,
+            color: supportbot.WarningColour,
+          },
+        ],
+        ephemeral: true,
+      });
+    }
+    if (
+      User.roles.cache.has(
+        getRole(supportbot.TicketBlackListRole, interaction.guild).id
+      )
+    ) {
+      return interaction.reply({
+        content: supportbot.TicketBlackListMessage,
+        ephemeral: true,
+      });
+    }
+
+    // Ticket ID
+    let ticketNumberID = await TicketNumberID.pad();
+
+    // Ticket Subject
+    const TicketSubject =
+      interaction.options?.getString("reason") || supportbot.NoTicketSubject;
+
+    const TicketExists = new MessageEmbed()
+      .setTitle("Ticket Exists!")
+      .setDescription(supportbot.TicketExists);
+
+    if (
+      await interaction.guild.channels.cache.find(
+        (ticketChannel) =>
+          ticketChannel.name === `${supportbot.TicketPrefix}${ticketNumberID}`
+      )
+    ) {
+      return await interaction.reply({
+        embeds: [TicketExists],
+        ephemeral: true,
+      });
+    }
+    const Staff = await getRole(supportbot.Staff, interaction.guild);
+    const Admin = await getRole(supportbot.Admin, interaction.guild);
+    if (!Staff || !Admin)
+      return interaction.reply({
+        content:
+          "Some roles seem to be missing!\nPlease check for errors when starting the bot.",
+        ephemeral: true,
+      });
+    let TicketCategory = await getCategory(
+      supportbot.Departments[department].category,
+      interaction.guild
+    );
+    const ticketChannel = await interaction.guild.channels.create(
+      `${supportbot.TicketPrefix}${ticketNumberID}`,
+      {
+        type: "GUILD_TEXT",
+        parent: TicketCategory.id,
+        permissionOverwrites: [
+          {
+            id: Admin.id,
+            allow: [Permissions.FLAGS.VIEW_CHANNEL],
+          },
+          {
+            id: interaction.user.id,
+            allow: [Permissions.FLAGS.VIEW_CHANNEL],
+          },
+          {
+            id: interaction.guild.id,
+            deny: [Permissions.FLAGS.VIEW_CHANNEL],
+          },
+        ],
       }
-
-      let TicketReason = null;
-      if (supportbot.Ticket.TicketReason) {
-        TicketReason = interaction.reason || null; // Retrieve the reason from the interaction object
+    );
+    if (supportbot.AllowAllStaff) {
+      await ticketChannel.permissionOverwrites.edit(Staff.id, {
+        VIEW_CHANNEL: true,
+      });
+    }
+    if (!department) {
+      await ticketChannel.permissionOverwrites.edit(interaction.user.id, {
+        SEND_MESSAGES: false,
+      });
+    }
+    await TicketData.tickets.push({
+      id: ticketChannel.id,
+      name: ticketChannel.name,
+      user: interaction.user.id,
+      number: ticketNumberID,
+      reason: TicketSubject,
+      open: true,
+      subUsers: [],
+    });
+    fs.writeFileSync(
+      "./Data/TicketData.json",
+      JSON.stringify(TicketData, null, 4),
+      (err) => {
+        if (err) console.error(err);
       }
+    );
 
-      let TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-      const { getRole, getChannel } = interaction.client;
-      let User = interaction.guild.members.cache.get(interaction.user.id);
-
-      if (
-        supportbot.Ticket.TicketsPerUser &&
-        TicketData.tickets.filter((t) => t.user === interaction.user.id && t.open).length >= supportbot.Ticket.TicketsPerUser
-      ) {
-        return interaction.reply({
-          embeds: [
-            {
-              title: "Too Many Tickets!",
-              description: `You can't have more than ${supportbot.Ticket.TicketsPerUser} open tickets!`,
-              color: supportbot.Embed.Colours.Warn,
-            },
-          ],
-          ephemeral: true,
-        });
-      }
-
-      let ticketNumberID = await TicketNumberID.pad();
-      const TicketSubject = TicketReason || msgconfig.Ticket.InvalidSubject;
-
-      const TicketExists = new EmbedBuilder()
-        .setTitle("Ticket Exists!")
-        .setDescription(msgconfig.Ticket.TicketExists);
-
-      if (
-        await interaction.guild.channels.cache.find(
-          (ticketChannel) => ticketChannel.name === `${supportbot.Ticket.Channel}${ticketNumberID}`
+    const CreatedTicket = new MessageEmbed()
+      .setDescription(
+        supportbot.TicketCreatedAlert.replace(
+          /%ticketauthor%/g,
+          interaction.user.id
         )
-      ) {
-        return await interaction.reply({
-          embeds: [TicketExists],
-          ephemeral: true,
-        });
+          .replace(/%ticketid%/g, ticketChannel.id)
+          .replace(/%ticketusername%/g, interaction.user.username)
+      )
+      .setColor(supportbot.EmbedColour);
+    await interaction.reply({ embeds: [CreatedTicket], ephemeral: true });
+
+    if (supportbot.AllowTicketMentions) {
+      await ticketChannel.send(`${interaction.user}`);
+    }
+
+    const TicketMessage = new MessageEmbed()
+      .setTitle(
+        supportbot.Ticket_Title.replace(/%ticketauthor%/g, interaction.user.id)
+          .replace(/%ticketid%/g, ticketChannel.id)
+          .replace(/%ticketusername%/g, interaction.user.username)
+      )
+      .setDescription(
+        supportbot.TicketMessage.replace(/%ticketauthor%/g, interaction.user.id)
+          .replace(/%ticketid%/g, ticketChannel.id)
+          .replace(/%ticketusername%/g, interaction.user.username)
+      )
+      .setColor(supportbot.EmbedColour);
+
+    if (supportbot.TicketSubject === "embed") {
+      if (TicketSubject !== "No Reason Provided.") {
+        TicketMessage.addFields({ name: "Reason", value: TicketSubject });
       }
+    }
 
-      const Staff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
-      const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
-      if (!Staff || !Admin)
-        return interaction.reply({
-          content: "Some roles seem to be missing!\nPlease check for errors when starting the bot.",
-          ephemeral: true,
+    if (supportbot.TicketSubject === "description") {
+      if (TicketSubject !== "No Reason Provided.") {
+        await ticketChannel.setTopic(
+          `Reason: ${TicketSubject}  -  User ID: ${interaction.user.id}  -  Ticket: ${ticketChannel.name}`
+        );
+      }
+    }
+
+    if (!department) {
+      TicketMessage.addFields({
+        name: "Departments",
+        value: ` **${supportbot.Departments.map((X) => X.title).join("\n")}**`,
+      });
+    }
+    const CloseButton = new MessageButton()
+      .setCustomId("ticketclose")
+      .setLabel("Close")
+      .setStyle(supportbot.TicketCloseColour)
+      .setEmoji(supportbot.TicketCloseEmoji);
+
+    const LockButton = new MessageButton()
+      .setCustomId("ticketlock")
+      .setLabel("Lock")
+      .setStyle(supportbot.TicketLockColour)
+      .setEmoji(supportbot.TicketLockEmoji);
+    const ClaimButton = new MessageButton()
+      .setCustomId("ticketclaim")
+      .setLabel("Claim")
+      .setStyle(supportbot.TicketClaimColour)
+      .setEmoji(supportbot.TicketClaimEmoji);
+
+    const row2 = new MessageActionRow().addComponents(CloseButton, LockButton, ClaimButton);
+    if (!department) {
+      try {
+        let buttons = await supportbot.Departments.map((x) =>
+          new MessageButton()
+            .setCustomId("Department" + supportbot.Departments.indexOf(x))
+            .setLabel(x.title)
+            .setStyle(x.color)
+            .setEmoji(x.emoji)
+        );
+        const row = new MessageActionRow().addComponents(buttons);
+        const m = await ticketChannel.send({
+          embeds: [TicketMessage],
+          components: [row],
         });
 
-      let ticketChannel;
-
-      if (supportbot.Ticket.TicketType === "threads") {
-        const TicketHome = interaction.guild.channels.cache.find(
-          (c) => c.name === supportbot.Ticket.TicketHome || c.id === supportbot.Ticket.TicketHome
-        );
-
-        const channel = await getChannel(supportbot.Ticket.TicketHome, interaction.guild);
-        ticketChannel = await channel.threads.create({
-          name: `${supportbot.Ticket.Channel}${ticketNumberID}`,
-          type: ChannelType.PrivateThread,
-          parent: TicketHome,
-          autoArchiveDuration: 60,
-          reason: 'support ticket',
-        });
-      } else if (supportbot.Ticket.TicketType === "channels") {
-        const category = interaction.guild.channels.cache.find(
-          (c) => c.name === supportbot.Ticket.TicketChannelsCategory || c.id === supportbot.Ticket.TicketChannelsCategory
-        );
-
-        if (!category) {
-          return interaction.reply({
-            content: "The ticket category does not exist!",
-            ephemeral: true,
+        let collector;
+        try {
+          const filter = (i) => i.user.id === interaction.user.id;
+          collector = await m.awaitMessageComponent({
+            filter,
+            max: 1,
+            componentType: "BUTTON",
+            time: supportbot.Timeout * 60000,
           });
-        }
-
-        ticketChannel = await interaction.guild.channels.create({
-          name: `${supportbot.Ticket.Channel}${ticketNumberID}`,
-          type: ChannelType.GuildText,
-          parent: category.id,
-          reason: 'support ticket',
-        });
-
-        // Move to secondary category if the primary one is full
-        if (category.children.size >= 50) {
-          const secondaryCategory = interaction.guild.channels.cache.find(
-            (c) => c.name === supportbot.Ticket.TicketChannelsCategory2 || c.id === supportbot.Ticket.TicketChannelsCategory2
-          );
-
-          if (secondaryCategory) {
-            await ticketChannel.setParent(secondaryCategory.id);
-          } else {
-            return interaction.reply({
-              content: "The secondary ticket category does not exist!",
-              ephemeral: true,
-            });
+        } catch (e) {
+          if (e.code === "INTERACTION_COLLECTOR_ERROR") {
+            try {
+              TicketData = await JSON.parse(
+                fs.readFileSync("./Data/TicketData.json", "utf8")
+              );
+              let ticket = await TicketData.tickets.findIndex(
+                (t) => t.id === ticketChannel.id
+              );
+              TicketData.tickets[ticket].open = false;
+              fs.writeFileSync(
+                "./Data/TicketData.json",
+                JSON.stringify(TicketData, null, 4),
+                (err) => {
+                  if (err) console.error(err);
+                }
+              );
+              interaction.user.send(
+                "Your ticket has timed out. Please open a new one, and select a department."
+              );
+            } catch (e) {}
+            return await ticketChannel.delete();
           }
         }
-      }
+        let num = collector.customId.split("Department")[1];
+        let role = getRole(supportbot.Departments[num].role, interaction.guild);
+        let title = supportbot.Departments[num].title;
 
-      // Assign ticket to a user if claiming tickets is enabled
-      if (supportbot.Ticket.ClaimTickets.Enabled) {
-        const assignedUserId = await assignTicketToUser(ticketChannel, Staff, Admin, interaction);
-        if (!assignedUserId) {
-          const claimChannel = await interaction.guild.channels.cache.get(supportbot.Ticket.ClaimTickets.Channel);
+        await ticketChannel.permissionOverwrites.edit(role.id, {
+          VIEW_CHANNEL: true,
+        });
+        await ticketChannel.permissionOverwrites.edit(interaction.user.id, {
+          SEND_MESSAGES: true,
+        });
+
+        await collector.reply({
+          embeds: [
+            {
+              description: `> Thank for reaching out to the **${title} Department**. Please provide us information regarding your query.`,
+              color: supportbot.EmbedColour,
+            },
+          ],
+        });
+
+        if (supportbot.AllowTicketMentions) {
+          await ticketChannel.send("@here");
         }
-      }
-
-      if (supportbot.Ticket.TicketType === "threads") {
-        await ticketChannel.members.add(interaction.user.id); 
-
-    } else if (supportbot.Ticket.TicketType === "channels") {
-
-        await ticketChannel.permissionOverwrites.create(interaction.user.id, {
-            ViewChannel: true,
-            SendMessages: true,
-            ReadMessageHistory: true,
-        }); 
-
-        await ticketChannel.permissionOverwrites.create(Admin, {
-          ViewChannel: true,
-          SendMessages: true,
-          ReadMessageHistory: true,
-      }); 
-
-        await ticketChannel.permissionOverwrites.create(interaction.guild.roles.everyone, {
-          ViewChannel: false,
-        }); 
-    }
-    
-      // Ask questions to the user after the ticket is opened
-      if (supportbot.Ticket.Questions.Enabled) {
-        const questions = supportbot.Ticket.Questions.List || [];
-        if (questions.length > 0) {
-          await askTicketQuestions(ticketChannel, interaction, questions);
-        }
-      }
-
-      // Save ticket data
-      TicketData.tickets.push({
-        id: ticketChannel.id,
-        name: ticketChannel.name,
-        user: interaction.user.id,
-        number: ticketNumberID,
-        reason: TicketSubject,
-        open: true,
-        subUsers: [],
-        createdAt: new Date().toISOString(),
-        claimedAt: null,
-      });
-
-      fs.writeFileSync(
-        "./Data/TicketData.json",
-        JSON.stringify(TicketData, null, 4),
-        (err) => {
-          if (err) console.error(err);
-        }
-      );
-
-      // Notify the user that the ticket was created
-      const CreatedTicket = new EmbedBuilder()
-        .setDescription(
-          msgconfig.Ticket.TicketCreatedAlert.replace(/%ticketauthor%/g, interaction.user.id)
-            .replace(/%ticketid%/g, ticketChannel.id)
-            .replace(/%ticketusername%/g, interaction.user.username)
-            .replace(/%ticketreason%/g, TicketSubject)
-        )
-        .setColor(supportbot.Embed.Colours.General);
-      await interaction.reply({ embeds: [CreatedTicket], ephemeral: true });
-
-      // Create the ticket message
-      const TicketMessage = new EmbedBuilder()
-        .setAuthor({
-          name: msgconfig.Ticket.TicketAuthorTitle.replace(/%ticketauthor%/g, interaction.user.id)
-            .replace(/%ticketid%/g, ticketChannel.id)
-            .replace(/%ticketusername%/g, interaction.user.username),
-          iconURL: interaction.user.displayAvatarURL(),
-        })
-        .setTitle(
-          msgconfig.Ticket.TicketTitle.replace(/%ticketauthor%/g, interaction.user.id)
-            .replace(/%ticketid%/g, ticketChannel.id)
-            .replace(/%ticketusername%/g, interaction.user.username)
-        )
-        .setDescription(
-          msgconfig.Ticket.TicketMessage.replace(/%ticketauthor%/g, interaction.user.id)
-            .replace(/%ticketid%/g, ticketChannel.id)
-            .replace(/%ticketusername%/g, interaction.user.username)
-            .replace(/%ticketreason%/g, TicketSubject)
-        )
-        .setColor(supportbot.Embed.Colours.General);
-
-      if (supportbot.Ticket.TicketReason && TicketReason) {
-        TicketMessage.addFields(
-          { name: "Reason", value: TicketReason, inline: false }
-        );
-      }
-
-      // Create the control panel
-      const SelectMenus = new StringSelectMenuBuilder()
-      .setCustomId("ticketcontrolpanel")
-      .setPlaceholder("Ticket Control Panel")
-      .addOptions(
-        new StringSelectMenuOptionBuilder()
-          .setLabel("Close")
-          .setDescription("Close the ticket.")
-          .setEmoji(supportbot.SelectMenus.Tickets.CloseEmoji)
-          .setValue("ticketclose"),
-        new StringSelectMenuOptionBuilder()
-          .setLabel("Voice Channel")
-          .setDescription("Create a support voice channel.")
-          .setEmoji(supportbot.SelectMenus.Tickets.VCEmoji)
-          .setValue("supportvc"),
-        new StringSelectMenuOptionBuilder()
-          .setLabel("Archive")
-          .setDescription("Archive the ticket.")
-          .setEmoji(supportbot.SelectMenus.Tickets.ArchiveEmoji)
-          .setValue("archiveticket"),
-        ...(supportbot.Ticket.TicketType === "threads" ? [
-          new StringSelectMenuOptionBuilder()
-            .setLabel("Lock Ticket")
-            .setDescription("Lock the ticket.")
-            .setEmoji(supportbot.SelectMenus.Tickets.LockEmoji)
-            .setValue("lockticket")
-        ] : []), 
-        new StringSelectMenuOptionBuilder()
-          .setLabel("Rename Ticket")
-          .setDescription("Rename the ticket.")
-          .setEmoji(supportbot.SelectMenus.Tickets.RenameEmoji)
-          .setValue("renameticket")
-      );
-
-        if (supportbot.Ticket.TicketType === "threads") {
-          SelectMenus.addOptions(
-            new StringSelectMenuOptionBuilder()
-              .setLabel("Enable Invites")
-              .setDescription("Enable invites.")
-              .setEmoji(supportbot.SelectMenus.Tickets.EnableInvitesEmoji)
-              .setValue("enableinvites"),
-            new StringSelectMenuOptionBuilder()
-              .setLabel("Disable Invites")
-              .setDescription("Disable invites.")
-              .setEmoji(supportbot.SelectMenus.Tickets.DisableInvitesEmoji)
-              .setValue("disableinvites"),
-          );
-        }
-
-      const row2 = new ActionRowBuilder().addComponents(SelectMenus);
-
+        await collector.message.edit({
+          embeds: [TicketMessage],
+          components: [row2],
+        });
+      } catch (error) {}
+    } else {
       await ticketChannel.send({
         embeds: [TicketMessage],
         components: [row2],
       });
-
-      
-    } catch (error) {
-      console.error("Error in run method:", error);
+      if (department) {
+        let role = await getRole(
+          supportbot.Departments[department].role,
+          interaction.guild
+        );
+        let title = supportbot.Departments[department].title;
+        await ticketChannel.permissionOverwrites.edit(role.id, {
+          VIEW_CHANNEL: true,
+        });
+        let TicketCat = await getCategory(
+          supportbot.Departments[department].category,
+          interaction.guild
+        );
+        await ticketChannel.setParent(TicketCat.id, { lockPermissions: false });
+        if (supportbot.AllowThanksForReachingOutMessage) {
+          await ticketChannel.send({
+            embeds: [
+              {
+                description: `> Thank for reaching out to the **${title} Department**. Please provide us information regarding your query.`,
+                color: supportbot.EmbedColour,
+              },
+            ],
+          });
+        }
+      }
+      if (supportbot.AllowTicketMentions) {
+        await ticketChannel.send(supportbot.TicketRoleMention);
+      }
     }
   },
 });

Commands/ticketpanel.js

@@ -1,120 +0,0 @@
-// ticketpanel.js
-const fs = require("fs");
-const {
-  EmbedBuilder,
-  ApplicationCommandType,
-  ActionRowBuilder,
-  ButtonBuilder,
-} = require("discord.js");
-const yaml = require("js-yaml");
-
-const panelconfig = yaml.load(fs.readFileSync("./Configs/ticket-panel.yml", "utf8"));
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-
-const Command = require("../Structures/Command.js");
-
-module.exports = new Command({
-  name: cmdconfig.TicketPanel.Command,
-  description: cmdconfig.TicketPanel.Description,
-  type: ApplicationCommandType.ChatInput,
-  options: [],
-  permissions: cmdconfig.TicketPanel.Permission,
-
-  async run(interaction) {
-    if (!panelconfig.Panel) {
-      console.log(
-        "\u001b[31m",
-        `[TICKET PANEL]`,
-        "\u001b[33m",
-        "Ticket Panel is not setup, You can set this in", `\u001b[31m`, '/Configs/ticket-panel.yml', `\n  `,
-      );
-      return interaction.reply({
-        content: "Ticket Panel is not set up. Please configure it in `/Configs/ticket-panel.yml`.",
-        ephemeral: true,
-      });
-    }
-
-    const { getChannel } = interaction.client;
-
-    const channel = await getChannel(
-      supportbot.Ticket.TicketHome,
-      interaction.guild
-    );
-
-    if (!channel) {
-      console.log(`[TICKET PANEL] ${channelName} channel not found. Please check your config file.`);
-      return interaction.reply({
-        content: `${channelName} channel not found. Please check your config file.`,
-        ephemeral: true,
-      });
-    }
-
-    const panelid = JSON.parse(fs.readFileSync("./Data/ticket-panel-id.json", "utf8"));
-
-    try {
-      await channel.messages.fetch(panelid.TicketPanelID);
-      return interaction.reply({
-        content: "Ticket panel message already exists.",
-        ephemeral: true,
-      });
-    } catch (error) {
-      let embed = new EmbedBuilder()
-        .setTitle(panelconfig.PanelTitle)
-        .setColor(panelconfig.PanelColour)
-        .setFooter({
-          text: supportbot.Embed.Footer,
-          iconURL: interaction.user.displayAvatarURL(),
-        });
-
-      if (panelconfig.TicketPanel_Description) {
-        embed.setDescription(panelconfig.PanelMessage);
-      }
-
-      if (panelconfig.TicketPanel_Thumbnail) {
-        embed.setThumbnail(panelconfig.PanelThumbnail);
-      }
-
-      if (panelconfig.TicketPanel_Image) {
-        embed.setImage(panelconfig.PanelImage);
-      }
-
-      const createTicketButton = new ButtonBuilder()
-        .setCustomId("createticket")
-        .setLabel(panelconfig.Button.Text)
-        .setEmoji(panelconfig.Button.Emoji)
-        .setStyle(panelconfig.Button.Color);
-
-      let row = new ActionRowBuilder().addComponents(createTicketButton);
-
-      try {
-        const message = await channel.send({
-          embeds: [embed],
-          components: [row],
-        });
-
-        let data = {
-          id: panelid.id,
-          TicketPanelID: message.id,
-        };
-
-        fs.writeFileSync(
-          "./Data/ticket-panel-id.json",
-          JSON.stringify(data),
-          "utf8"
-        );
-
-        return interaction.reply({
-          content: "Ticket panel message has been sent!",
-          ephemeral: true,
-        });
-      } catch (e) {
-        console.log("Error sending message:", e);
-        return interaction.reply({
-          content: "An error occurred while sending the ticket panel message.",
-          ephemeral: true,
-        });
-      }
-    }
-  },
-});

Commands/translate.js

@@ -5,60 +5,51 @@ const fs = require("fs");
 
 const Discord = require("discord.js");
 const yaml = require("js-yaml");
-
 const supportbot = yaml.load(
   fs.readFileSync("./Configs/supportbot.yml", "utf8")
 );
-
 const cmdconfig = yaml.load(
   fs.readFileSync("./Configs/commands.yml", "utf8")
-);
-
-const msgconfig = yaml.load(
-  fs.readFileSync("./Configs/messages.yml", "utf8")
-)
+  );
 
 const Command = require("../Structures/Command.js");
 const translate = require("@vitalets/google-translate-api");
 
 module.exports = new Command({
-  name: cmdconfig.Translate.Command,
-  description: cmdconfig.Translate.Description,
-  type: Discord.ApplicationCommandType.ChatInput,
+  name: cmdconfig.TranslateCommand, // Name of command
+  description: cmdconfig.TranslateCommandDesc, // Description of command
   options: [
     {
-      type: Discord.ApplicationCommandOptionType.String,
+      type: "STRING",
       name: "language",
       description: "A 2 letter language code",
       required: true,
     },
     {
-      type: Discord.ApplicationCommandOptionType.String,
+      type: "STRING",
       name: "text",
       description: "The text to translate",
       required: true,
     }, // The input text for the translation
   ],
-  permissions: cmdconfig.Translate.Permission, // The permission the user/role at least requires
+  permissions: ["SEND_MESSAGES"], // The permission the user/role at least requires
 
   async run(interaction) {
-    let disableCommand = true;
 
     const { getRole } = interaction.client;
-    let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
-    let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
-    if (!SupportStaff || !Admin)
-    
-      return interaction.reply(
-        "Some roles seem to be missing!\nPlease check for errors when starting the bot."
-      );
+    let SupportStaff = await getRole(supportbot.Staff, interaction.guild);
+    let Admin = await getRole(supportbot.Admin, interaction.guild);
+      if (!SupportStaff || !Admin)
+        return interaction.reply(
+          "Some roles seem to be missing!\nPlease check the error logs."
+        );
 
-      const NoPerms = new Discord.EmbedBuilder()
+    const NoPerms = new Discord.MessageEmbed()
       .setTitle("Invalid Permissions!")
       .setDescription(
-        `${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``
+        `${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``
       )
-      .setColor(supportbot.Embed.Colours.Warn);
+      .setColor(supportbot.WarningColour);
 
     if (
       !interaction.member.roles.cache.has(SupportStaff.id) &&
@@ -71,7 +62,7 @@ module.exports = new Command({
     let url = "https://www.science.co.il/language/Codes.php"; // URL to all available language codes
     let text = await interaction.options.getString("text"); // Grab the text to translate by the user
     let translatelog = await getChannel(
-      supportbot.Translate.TranslateLog,
+      supportbot.TranslateLogChannel,
       interaction.guild
     ); // Grab the set logging channel for translations
 
@@ -81,8 +72,8 @@ module.exports = new Command({
       if (err && err.code == 400) {
         await interaction.reply({
           embeds: [
-            new Discord.EmbedBuilder()
-              .setColor(supportbot.Embed.Colours.Warn)
+            new Discord.MessageEmbed()
+              .setColor(supportbot.WarningColour)
               .setTitle("Valid Language Codes")
               .setURL(url)
               .setDescription(
@@ -96,9 +87,9 @@ module.exports = new Command({
     if (!result) return;
 
     // Embed containing language code, original text and translated text
-    let transembed = new Discord.EmbedBuilder()
+    let transembed = new Discord.MessageEmbed()
       .setAuthor({ name: interaction.user.tag, iconURL: interaction.user.displayAvatarURL({ dynamic: true }) })
-      .setColor(supportbot.Embed.Colours.Success)
+      .setColor(supportbot.SuccessColour)
       .setDescription(`**Translation to ${lang}**`)
       .addFields(
         { name: "Original text", value: text },

Commands/userinfo.js

@@ -0,0 +1,127 @@
+// SupportBot | Emerald Services
+// User Info Command
+
+const fs = require("fs");
+const moment = require("moment");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(
+    fs.readFileSync("./Configs/commands.yml", "utf8")
+);
+
+const Command = require("../Structures/Command.js");
+
+module.exports =   new Command({
+    name: cmdconfig.UserInfoCommand, // Name of command
+    description: cmdconfig.UserInfoCommandDesc, // Description of command
+    options: [
+      {
+        type: "USER",
+        name: "user",
+        description: "The user you want to get info about.",
+        required: true,
+      }, // The user input
+    ],
+    permissions: ["SEND_MESSAGES"], // The permission the user/role at least requires
+
+    async run(interaction) {
+        const { getRole } = interaction.client;
+        let SupportStaff = await getRole(supportbot.Staff, interaction.guild);
+        let Admin = await getRole(supportbot.Admin, interaction.guild);
+            if (!SupportStaff || !Admin)
+            return interaction.reply(
+                "Some roles seem to be missing!\nPlease check the error logs."
+            );
+
+        const NoPerms = new Discord.MessageEmbed()
+            .setTitle("Invalid Permissions!")
+            .setDescription(
+            `${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``
+            )
+            .setColor(supportbot.WarningColour);
+
+        if (
+            !interaction.member.roles.cache.has(SupportStaff.id) &&
+            !interaction.member.roles.cache.has(Admin.id)
+        )
+          return interaction.reply({ embeds: [NoPerms] });
+
+        let user = await interaction.options.getUser("user") || interaction.author; // Grab the mentioned user
+        let member = await interaction.guild.members.cache.get(user.id) // Check for user and his ID
+
+        const UserNotExist = new Discord.MessageEmbed()
+          .setTitle("User Not Found!")
+          .setDescription(
+            `${supportbot.UserNotFound}\n\nTry Again:\`/${cmdconfig.UserInfoCommand} <@!User_ID> or @User\``
+          )
+          .setColor(supportbot.ErrorColour);
+        
+        if (!user) return interaction.reply({ embeds: [UserNotExist] });
+
+        // Flags a user/bot can have
+        const flags = {
+          DISCORD_EMPLOYEE: 'Discord Employee',
+          DISCORD_PARTNER: 'Discord Partner',
+          BUGHUNTER_LEVEL_1: 'Bug Hunter (Level 1)',
+          BUGHUNTER_LEVEL_2: 'Bug Hunter (Level 2)',
+          HYPESQUAD_EVENTS: 'HypeSquad Events',
+          HOUSE_BRAVERY: 'House of Bravery',
+          HOUSE_BRILLIANCE: 'House of Brilliance',
+          HOUSE_BALANCE: 'House of Balance',
+          EARLY_SUPPORTER: 'Early Supporter',
+          TEAM_USER: 'Team User',
+          SYSTEM: 'System',
+          VERIFIED_BOT: 'Verified Bot',
+          VERIFIED_DEVELOPER: 'Verified Bot Developer'
+        };
+
+        // Status message with icon
+        let status = {
+            online: "🟢Online",
+            idle: "🟡Idle",
+            dnd: "🔴Do Not Disturb",
+            offline: "⚫Offline"
+        };
+
+        const userFlags = user.flags.toArray();
+
+         // Embed containing the userinfo
+        let userembed = new Discord.MessageEmbed()
+          .setTitle(`User Info for User: ${user.tag}`)
+          .setThumbnail(member.displayAvatarURL({ dynamic: true, size: 512 }))
+          .setColor(member.roles.highest.hexColor)
+          .addFields(
+            { name: "Name:", value: `${user.tag}\n<@${member.id}>`, inline: true },
+            { name: "ID:", value: `${member.id}`, inline: true },
+            { name: "Is Bot:", value: user.bot ? "Yes" : "No", inline: true },
+            { name: "House/Badge:", value: `${userFlags.length ? userFlags.map(flag => flags[flag]).join("\n") : "None"}`, inline: true },
+            { name: "Current Status:", value: `${status[member.presence ? member.presence.status : "offline"]}`, inline: true },
+            { name: "Avatar URL:", value: `[Click Here](${member.displayAvatarURL()})`, inline: true },
+            { name: "\u200b", value: "\u200b", inline: false}
+          )
+          .addFields(
+            { name: "Creation Date:", value: `${moment(user.createdAt).format("MMMM Do YYYY, h:mm:ss a")}\n> ${moment(user.createdAt).startOf("day").fromNow()}`, inline: true },
+            { name: "Joined Date:", value: `${moment(member.joinedAt).format("MMMM Do YYYY, h:mm:ss a")}\n> ${moment(member.joinedAt).startOf("day").fromNow()}`, inline: true },
+            { name: "Roles Total:", value: `${member.roles.cache.size -1}`, inline: false },
+            { name: "Highest Role:", value: `${member.roles.highest.id === interaction.guild.id ? "None" : member.roles.highest.toString()}`, inline: true },
+            { name: "Roles:", value: `${member.roles.cache.map(r => r).join(" ").replace("@everyone", " ") || "None"}`, inline: false },
+          )
+          .setFooter({ text: supportbot.EmbedFooter })
+          .setTimestamp();
+
+        // Send embed [userembed]
+        await interaction.reply({ embeds: [userembed] }).catch((err) => console.error("An error has occured: ", err));
+
+    },
+  })
+
+/**
+ * @INFO
+ * UserInfo command by Sypher#3415 | 321332200668790786
+ * @INFO
+ * Solely created for SupportBot | https://github.com/Emerald-Services/SupportBot/
+ **/

Configs/commands.yml

@@ -7,131 +7,25 @@
 #           SupportBot created by Emerald Services
 #           Installed with MIT License
 #
-#           Discord Support: https://discord.gg/emeraldsrv
-#           Official Documentation: https://docs.emeraldsrv.com
-#           Addons Marketplace: https://community.emeraldsrv.com
-#
-#           Commands Configuration (commands.yml)
+#           Discord Support: https://emeraldsrv.dev/discord
+#           Community Resources: https://emeraldsrv.dev/resources
 
-Help:
-  Command: "help"
-  Description: "Get a list of all the commands."
-  Permission: ["SendMessages"]
-  Enabled: true
+# -------------------------------
+#   Command Name Configuration
+# -------------------------------
 
-Info:
-  Command: "info"
-  Description: "Get information about the **ServerName**."
-  Permission: ["SendMessages"]
-  Enabled: true
-
-TicketPanel:
-  Command: "ticketpanel"
-  Description: "Create the ticket creation panel"
-  Permission: ["Administrator"]
-  Enabled: true  
-
-Profile:
-  Command: "profile"
-  Description: "Shows the profile for a discord member."
-  Permission: ["SendMessages"]
-  # Command is automatically disabled when the TicketClaims is disabled.
-
-OpenTicket:
-  Command: "ticket"
-  Description: "Create a support ticket."
-  Permission: ["SendMessages"]
-  Enabled: true
-
-AddUser:
-  Command: "add"
-  Description: "Add a user to a support ticket."
-  Permission: ["SendMessages"]
-  Enabled: true
-
-ForceAddUser:
-  Command: "forceadd"
-  Description: "Add a user to a support ticket by bypassing the invite system."
-  Permission: ["SendMessages"]
-  Enabled: true
-
-RemoveUser:
-  Command: "remove"
-  Description: "Remove a user from a support ticket."
-  Permission: ["SendMessages"]
-  Enabled: true
-  
-CloseTicket:
-  Command: "close"
-  Description: "Close a support ticket"
-  Permission: ["SendMessages"]
-  Enabled: true
-
-Suggestion:
-  Command: "suggest"
-  Description: "Create a suggestion."
-  Permission: ["SendMessages"]
-  Enabled: true
-
-Embed:
-  Command: "embed"
-  Description: "Build a discord embed."
-  Permission: ["SendMessages"]
-  Enabled: true
-
-Translate:
-  Command: "translate"
-  Description: "Translate something to english"
-  Permission: ["SendMessages"]
-  Enabled: false
-
-UserInfo:
-  Command: "userinfo"
-  Description: "Get info about a user."
-  Permission: ["SendMessages"]
-  Enabled: true
-
-Ping:
-  Command: "ping"
-  Description: "Pong."
-  Permission: ["SendMessages"]
-  Enabled: true
-
-# ---------------------------------------
-#   Bot Moderator Commands
-# ---------------------------------------
-
-Mod:
-  Command: "mod"
-  Description: "Execute a moderation action."
-  Permission: ["BanMembers", "KickMembers"]
-  Enabled: true
-
-  TicketBlacklist:
-    Command: "ticket-blacklist"
-    Description: "Blacklist a user from creating Tickets."
-
-    Add: 
-      Command: "add"
-      Description: "Add a user to the blacklist."
-      
-    Remove:
-      Command: "remove"
-      Description: "Remove a user from the blacklist."
-
-    View:
-      Command: "view"
-      Description: "View all blacklisted users."
-
-# ---------------------------------------
-#   Bot Administrator Commands
-# ---------------------------------------
-
-Settings:
-  Command: "settings"
-  Description: "Update bot settings."
-  Permission: ["Administrator"]
-  Enabled: true
+Blacklist: "blacklist"
+TicketAdd: "add"
+TicketRemove: "remove"
+OpenTicket: "ticket"
+CloseTicket: "close"
+InfoCommand: "info"
+PingCommand: "ping"
+HelpCommand: "help"
+EmbedCommand: "embed"
+SuggestCommand: "suggest"
+TranslateCommand: "translate"
+UserInfoCommand: "userinfo"
 
 # ---------------------------------------
 #   Command Description Configuration

Configs/messages.yml

@@ -1,275 +0,0 @@
-#      ___                            _    ___        _
-#    / __> _ _  ___  ___  ___  _ _ _| |_ | . > ___ _| |_
-#     \__ \| | || . \| . \/ . \| '_> | |  | . \/ . \ | |
-#     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|
-#                |_|  |_|
-#
-#           SupportBot created by Emerald Services
-#           Installed with MIT License
-#
-#           Discord Support: https://discord.gg/emeraldsrv
-#           Official Documentation: https://docs.emeraldsrv.com
-#           Addons Marketplace: https://community.emeraldsrv.com
-#
-#           Messages Configuration (messages.yml)
-
-# ----------------------------
-# Info Command
-# ----------------------------
-
-Info:
-  Title: "About Us"
-  Description: "SupportBot is an open-sourced support system for discord. It's completely free to use with high amounts of customization to match your own brand."
-  Button: "Visit Site"
-  URL: "https://docs.emeraldsrv.com"
-  Colour: "#f74343"
-
-# ----------------------------
-# Welcome/Leave Messages
-# ----------------------------
-
-Welcome:
-  Embed:
-    Colour: "#f74343"
-    Title: "Welcome to ServerName"
-    Message: ":smile: %joined_user% has just landed!"
-    Thumbnail: "BOT"
-
-    ImageEnabled: false
-    ImageURL: "https://animagelink.png/"
-
-Leave:
-  Embed:
-    Colour: "#f74343"
-    Title: "Goodbye!"
-    Message: ":slight_frown: %joined_user% has recently dropped out!"
-    Thumbnail: "BOT"
-
-    ImageEnabled: false
-    ImageURL: "https://animagelink.png/"
-
-# ----------------------------
-# Suggestion Messages
-# ----------------------------
-
-Suggestions:
-  Sent_Title: "Suggestion Sent!"
-  Sent: ":white_check_mark: **You have successfully sent a suggestion.**"
-  NoSelfVote: ":x: **You cannot vote on your own suggestion.**"
-  RemoveVoteButton: "Remove Vote"
-
-# ----------------------------
-# Ticket Messages
-# ----------------------------
-
-Ticket:
-
-#  Available Placeholders:
-
-#  %ticketusername% - User who created the ticket.
-#  <@%ticketauthor%> - Tags the user who created the ticket.
-#  <#%ticketid%> - Mentions the ticket channel.
-
-  TicketAuthorTitle: "%ticketusername%'s Ticket"
-  TicketTitle: "Support Ticket"
-  TicketMessage: "Hello <@%ticketauthor%>, Thank you for creating a support ticket\nPlease wait patiently whilst a member of our team reaches out to you."
-  TicketThumbnail: "https://images.emojiterra.com/google/android-pie/512px/1f39f.png"
-  TicketCreatedAlert: ":ticket: Ticked Created: <#%ticketid%>"
-  TicketExists: "❌ Ticket already exists"
-  TicketClaim: ":white_check_mark: Ticket claimed by" #The user who claimed the ticket will be added to the end of this message
-  TicketUnclaim: ":white_check_mark: Ticket unclaimed by" #The user who claimed the ticket will be added to the end of this message
-
-  TicketArchived: ":white_check_mark: Ticket archived."
-  TicketUnarchived: ":white_check_mark: Ticket unarchived."
-  TicketLocked: ":lock: Ticket is locked."
-  DisableInvites: "🔒 Invites have been disabled for this ticket." 
-  EnableInvites: "🔓 Invites have been enabled for this ticket." 
-
-#  Available Placeholders:
-
-#  <@%user%> - Tags the user who was added to the ticket.
-
-  Blacklisted: ":x: You are not allowed to open a ticket"
-  Muted: ":x: You are `Muted` and therefore not allowed to open any tickets"
-  InvalidSubject: "No Reason Provided!"
-
-  ConfirmClose: "Please confirm closing the ticket by clicking the button below."
-  CloseTimeout: "Ticket close confirmation timed out."
-
-  RenamedSuccess: "🏷️ Ticket renamed successfully!"
-
-  ClaimTickets:
-    ClaimTitle: "Incoming Support Request!"
-    ClaimMessage: "A new ticket has been created by <@!%user%>. Click the button below to claim this ticket."
-    ClaimMessage_Edit: "<#%channel%> was claimed by <@!%user%>."
-
-    ClaimedTitle: "Ticket Claimed!"
-    Claimed: "You have successfully claimed this ticket. <#%channel%>"
-    NoPermsToClaimTitle: "Error, no permissions!"
-    NoPermsToClaim: ":x: **Err!** You do not permissions to claim this ticket."
-
-    ReassigningTitle: "Reassigning!..."
-    ReassigningMessage: "<@%user%> did not claim the ticket. **Reassigning...**"
-
-  TicketQuestions:
-    Details: 
-      Title: "Ticket Details"
-      Description: "Questions by <@%user%>" # Use <@%user%> to display the username.
-
-# ----------------------------
-# Review Messages
-# ----------------------------
-
-ReviewSystem:
-  Rate:
-    Title: "Review us!"
-    Description: "Please rate our support for this ticket (1-5 stars)."
-
-  Stars:
-    One: "⭐ 1 Star"
-    Two: "⭐⭐ 2 Stars"
-    Three: "⭐⭐⭐ 3 Stars"
-    Four: "⭐⭐⭐⭐ 4 Stars"
-    Five: "⭐⭐⭐⭐⭐ 5 Stars"
-
-  Comment:
-    Title: "Write a comment."
-    Description: "Write a comment about your experience."
-
-  ReviewEmbed:
-    Title: "Ticket Review"
-    CommentTitle: "Comment"
-    RatingTitle: "Rating"
-    ReviewedStaffTitle: "Reviewed Staff:"
-    ReviewedByTitle: "Reviewed By:"
-    ReviewEmoji: "⭐"
-    Color: "#f7a943"
-
-# ----------------------------
-# Profile Messages
-# ----------------------------
-
-TicketStats: 
-  OpenTickets: "✅ Open Tickets"
-  TotalTickets: "🎫 Total Tickets"
-  ResponseTime: "⏱️ Average Response Time"
-
-  Title: "Your Ticket Stats"
-
-# ----------------------------
-# Mod Command Messages
-# ----------------------------
-
-Mod:
-  
-  TicketBlacklist:
-    Add:
-      Description: "Add a user to the ticket blacklist"
-      UserDescription: "User to blacklist"
-      AlreadyBlacklisted: ":x: {userTag} is already blacklisted."
-      Success: ":white_check_mark: {userTag} has been added to the blacklist. They can no longer use the ticket system."
-
-    Remove:
-      Description: "Remove a user from the ticket blacklist"
-      UserDescription: "User to remove from blacklist"
-      NotBlacklisted: ":x: {userTag} is not blacklisted."
-      Success: ":white_check_mark: {userTag} has been removed from the blacklist. They can now use the ticket system again."
-
-    View:
-      Description: "View the list of all blacklisted users"
-      NoBlacklistedUsers: ":information_source: There are currently no users on the blacklist."
-
-
-# ----------------------------
-# Logging Messages
-# ----------------------------
-
-TicketLog:
-  Title: "Ticket Log"
-  Colour: "#0cc559"
-
-TicketBlacklistLog:
-  Title: "Ticket Blacklist Log"
-  Colour: "#0cc559"
-
-# ----------------------------
-# Misc Messages
-# ----------------------------
-
-AddUser:
-  NotInTicket_Title: "Ticket Invitation"
-  NotInTicket_Description: "This command can only be used within a ticket thread."
-  
-  Invite_Title: "User Invited"
-  Invite_Description: "%username% has been invited to join the ticket."
-
-  DM_Title: "Ticket Invitation"
-  DM_Description: "You have been invited to join the ticket %channelname%. Do you accept?"
-  
-  Accept_Label: "Accept"
-  Reject_Label: "Reject"
-  ViewTicket_Label: "Go to Ticket"
-  
-  Accepted_Title: "Invitation Accepted"
-  Accepted_Message: "You have been added to the ticket."
-  AddedToTicket_Title: "Added to Ticket"
-  AddedToTicket_Description: "You have been added to the ticket %channel_link%."
-
-  # Added Message for inside the ticket, this informs everyone inside the ticket that the user has been added.
-  Added_Title: "User Added"
-  Added_Description: "Successfully added **%username%** to the ticket."
-  
-  Declined_Title: "Invitation Declined"
-  Declined_Message: "You have declined the invitation."
-  
-  NoResponse_Title: "No Response"
-  NoResponse_Message: "You did not respond in time. Please contact staff if you wish to join the ticket."
-  
-  Error_Title: "Error"
-  Error_Adding: "There was an error adding you to the ticket. Please try again."
-  
-  DM_Error_Title: "Error"
-  DM_Error_Description: "Unable to send a DM to %username%. Please ensure your DMs are enabled."
-  
-  Unexpected_Error_Title: "Error"
-  Unexpected_Error_Description: "An unexpected error occurred: %error%"
-
-RemoveUser:
-  NotInTicket_Title: "Error"
-  NotInTicket_Description: "This command can only be used in ticket threads."
-  
-  Removed_Title: "User Removed"
-  Removed_Message: "The user has been successfully removed from the ticket."
-  
-  RemovedFromTicket_Title: "Removed from Ticket"
-  RemovedFromTicket_Description: "You have been removed from the ticket channel %channel_link%."
-
-  Error_Title: "Error"
-  Error_Removing: "There was an error removing the user from the ticket."
-
-ForceAddUser:
-  NotInTicket_Title: "Not a Ticket"
-  NotInTicket_Description: "This command can only be used within a ticket thread."
-
-  Added_Title: "User Added"
-  Added_Description: "Successfully added %username% to the ticket."
-
-  AddedToTicket_Title: "You have been added to a Ticket"
-  AddedToTicket_Description: "You have been added to the ticket channel [%channel_link%]."
-
-  Error_Title: "Error"
-  Error_Adding: "There was an error adding the user to the ticket."
-
-Error:
-  IncorrectPermissions: ":x: **Error!** You do not have the correct permissions to use this command."
-  MissingChannel: ":x: **Error!** Required channel not found. Please ensure it is set up correctly!"
-  UserNotFound: ":x: **Error!** Specified user not found. Please check if they are in this server."
-  CommandNotAllowedHere: ":warning: This command cannot be used in this channel."
-  EntryAlreadyExists: ":warning: Cannot complete the action, as the entry already exists."
-  EntryDoesNotExist: ":warning: Cannot complete the action, as the entry does not exist."
-  ActionFailed: ":x: **Error!** An error occurred while processing your request. Please try again later."
-
-
-
-
-  

Configs/supportbot-ai.yml

@@ -1,39 +0,0 @@
-# -------------------------
-#   SupportBot AI
-#
-# In order to use the SupportBot AI, You need to setup an OpenAI Account. 
-# this can be done at https://platform.openai.com/
-# -------------------------
-
-Enabled: true
-
-General:
-  Name: "SupportBot AI"
-  # What would you like to call your AI
-  Model: "gpt-4o-mini"
-  # You can see a list of OpenAI Models here: https://platform.openai.com/docs/models
-
-  Tokens: 400
-  # Max tokens you can set is 400
-  # For more information about tokens, go to https://openai.com/api/pricing/
-  OpenAI_Key: "OPEN_AI_API_KEY"
-  # To create an OpenAI API key, go to https://platform.openai.com/api-keys
-
-
-  PastebinAPI_Key: "PASTEBIN_API_KEY"
-  # You can get your Pastebin API Key from https://pastebin.com
-  PastebinAPI_URL: "https://pastebin.com/api/api_post.php" 
-
-Channels:
-  AIChannel: "AI_BOT_CHANNEL"
-  # This is the channel where AI will respond in without needing to mention the bot.
-
-Embed:
-  Color: 0x0cc559  # 0x<hexcode>
-  Footer: "SupportBot | Developed by Emerald Development"
-
-Messages:
-  MessageTooLong: "The response was too long, so I've posted it here: {pastebin}"
-  ErrorResponse: "I didn't receive a proper response from OpenAI. Please try again later."
-  OpenAIError: "I'm having some trouble talking to SupportBot AI's Model, OpenAI. Please try again later."
-  AIDisabled: "I am disabled, You have enable me in `supportbot-ai.yml`"

Configs/supportbot.yml

@@ -7,283 +7,258 @@
 #           SupportBot created by Emerald Services
 #           Installed with MIT License
 #
-#           Discord Support: https://discord.gg/emeraldsrv
-#           Official Documentation: https://docs.emeraldsrv.com
-#           Addons Marketplace: https://community.emeraldsrv.com
-#
-#           SupportBot Configuration (supportbot.yml)
+#           Discord Support: https://emeraldsrv.dev/discord
+#           Community Resources: https://emeraldsrv.dev/resources
 
-SupportBot_Version: "v8.3"
+SupportBot_Version: "v7.7.2"
 
 # -------------------------
-#   General
+#   General Configuration
 # -------------------------
 
-General:
-  Name: "SupportBot"
-  Token: "BOT_TOKEN"
-
-  Addons:
-    Enabled: true
-    
-# -------------------------
-#  Activity
-# -------------------------
-
-Activity:
-  Status: "SupportBot v8"
-  Type: "Competing"
-  StreamingURL: "https://www.twitch.tv/YOUR_TWITCH_NAME"
-
-  # Available Types:
-  # Playing
-  # Watching
-  # Listening
-  # Competing
-  # Streaming (URL required)
-
-  # You can also update the activity via Discord using: /settings
+Name: "SupportBot"
+Token: "BOT_TOKEN HTTPS://DISCORD.COM/DEVELOPERS"
 
 # -------------------------
-#  Embeds
+#  Activity Configuration
 # -------------------------
 
-Embed:
-  Colours:
-    General: 0x0cc559
-    Success: 0x04b545
-    Error: 0xd13030
-    Warn: 0xfca117
+BotActivity: "Here to help!"
 
-  Footer: "SupportBot | Developed by Emerald Development"
+StreamingURL: "https://www.twitch.tv/YOUR_TWITCH_NAME"
+# Set The ActivityType to "STREAMING" for a streaming status!
 
-  # Use 0x<hexcode>  to change the colour of the embeds.
+ActivityType: "PLAYING"
+# Activity status can either be PLAYING, WATCHING, LISTENING or STREAMING.
 
 # -------------------------
-#  Roles
+#  Embed Configuration
 # -------------------------
 
-Roles:
-  AutoRole:
-    Enabled: true
-    Role: "ROLE_ID"
+EmbedColour: "#f74343"
+EmbedFooter: "SupportBot | Developed by Emerald Services"
 
-  StaffMember:
-    Staff: "ROLE_ID"
-    Admin: "ROLE_ID"
-    Moderator: "ROLE_ID"
+ErrorColour: "#d12519"
+SuccessColour: "#04b545"
+WarningColour: "#fca117"
 
-  Mod:
-    AllowSupportStaff: false
+# -------------------------
+#  Role Configuration
+# -------------------------
 
-  # Allow Support Staff to use the /mod command. (More in detail customisation in commands.yml)
+AutoRole: true
+JoinRole: "Member"
+
+Staff: "Staff"
+Admin: "Admin"
+TicketBlackListRole: "Blacklisted"
 
 # ----------------------------
-#  System Messages
+#  Join/Leave Configuration
 # ----------------------------
 
-Welcome: 
-  Enabled: true
-  Channel: "JOIN_CHANNEL_ID"
+Welcome: true
+  # set to false to disable joining logs
 
-Leave: 
-  Enabled: true
-  Channel: "JOIN_CHANNEL_ID"
+WelcomeChannel: "join-leave-logs"
+WelcomeColour: "#f74343"
+WelcomeTitle: "User Joined!"
+WelcomeMessage: "%joined_user% has joined the server!"
+  # Available Placeholders:
+  # %joined_user% - Mentions the user who joined
+
+EmbedWelcomeImage: true
+EmbedWelcomeImageURL: "https://media.discordapp.net/attachments/958247876344025108/986777740738986094/unknown.png"
+
+EmbedWelcomeThumbnail: "BOT" 
+  # "USER" will display the user's profile picture.
+  # "BOT" will display the bot's profile picture.
+  # false to disable
+
+Leave: true
+  # set to false to disable leaving logs
+
+LeaveChannel: "join-leave-logs"
+LeaveColour: "#f74343"
+LeaveTitle: "User Left!"
+LeaveMessage: "%joined_user% has left the server!"
+  # Available Placeholders:
+  # %joined_user% - Mentions the user who joined
+
+EmbedLeaveImage: true
+EmbedLeaveImageURL: "https://cdn.discordapp.com/attachments/958247876344025108/986778170223120384/unknown.png"
+
+EmbedLeaveThumbnail: false 
+  # "USER" will display the user's profile picture.
+  # "BOT" will display the bot's profile picture.
+  # false to disable
+
+# -------------------------
+#  Information Configuration
+# -------------------------
+
+InfoTitle: "Information"
+
+InfoButtonText: "Visit Site"
+AboutMe: "I am SupportBot"
+InfoURL: "https://emeraldsrv.dev"
+InfoColour: "#f74343"
 
 # ----------------------------
-#  Suggestions
+#  Suggestions Configuration
 # ----------------------------
 
-Suggestions:
-  Channel: "SUGGESTIONS_CHANNEL_ID"
-  UpvoteEmoji: "✅"
-  DownvoteEmoji: "❌"
+SuggestionChannel: "suggestions"
+SuggestionUpvote: "✅"
+SuggestionDownvote: "❌"
 
-  UpvoteTitle: "Yes"
-  DownvoteTitle: "No"
+SuggestionThreads: true
+# set to false to disable threads being created from suggestions.
 
-  OwnSuggestion: true
-
-  # If false this will not allow the user to vote for a suggestion they created
-  # If true this will allow the user to vote for a suggestion they created
-
-  ShowUsers: true
-  
-  Threads:
-    Enabled: true
-    Title: "Suggestion-releated Thread"
-    Reason: "A thread releted to this suggestion"
-
-  Buttons:
-    Upvote: "2"
-    Downvote: "2"
-    RemoveVote: "4"
-    RemoveVote_Title: "Remove Vote"
-
-    # Available Button Styles
-    # 1 - Blurple
-    # 2 - Grey
-    # 3 - Green
-    # 4 - Red
+DisableSuggestions: false
+# Set to true to disable the suggestions feature.
 
 # -------------------------
-#  Tickets
+#  Translate Configuration
 # -------------------------
 
-VoiceTickets:
-  Name: "%username%'s VC" 
-  Category: "VOICEE_CATEGORY_ID"
-
-Ticket:
-  TicketType: "channels" 
-
-  # Available TicketTypes:
-  # channels - Tickets will be created as channels in the TicketChannelsCategory
-  # threads - Tickets will be created as threads through the "TicketHome" channel.
-
-  TicketHome: "TICKETHOME_CHANNEL_ID" 
-
-  # What is TicketHome?
-  # - Channel where the Ticket creation panel is sent.
-  # - Channel where ticket threads are made. (only if ticket threads is enabled above.)
-
-  # For TicketType: channels
-  TicketChannelsCategory: "TICKETCHANNEL_CATEGORY_ID" 
-  TicketChannelsCategory2: "TICKETCHANNEL_BACKUP_CATEGORY_ID" # This will be used if the first category has reached the max channel limit.
-  TicketArchiveCategory: "ARCHIVE_CATEGORY_ID"
-  # ---
-
-  Channel: "ticket-" # The prefix for ticket channel names
-  TicketsPerUser: 100
-  DMTranscripts: true
-  TicketReason: true
-  # If ticket reason is set to false, It will not prompt to create a reason
-
-  TicketSubject: "description"
-
-  # Available TicketSubjects:
-  # "description" will display the ticket reason within the channel description
-  # "embed" will display the ticket reason within the ticket embed
-
-  Timeout: 5
-  # Set to true to allow all staff to access the ticket
-
-  Close:
-    StaffOnly: true
-    # Set to false is anyone is able to close a ticket.
-
-    Confirmation_Button: "Confirm Close"
-    Confirmation_Emoji: "🗑️"
-    Confirmation_Style: "2"
-
-    Title: "Are you sure you want to close this ticket?"
-
-    # Available Button Styles:
-    # 1 - Blurple
-    # 2 - Grey
-    # 3 - Green
-    # 4 - Red
-
-  Invites:
-    StaffOnly: true
-
-  ClaimTickets:
-    Enabled: true
-    Channel: "CLAIM_TICKETS_CHANNEL_ID" 
-    # Channel where the ticket assignments are sent for staff to claim.
-    
-    ClaimAcceptTime: 120000
-    # How long the assigned user has to accept the ticket before it gets re-assigned to someone else.
-    # 120000 = 2 Minutes
-    # 180000 = 3 Minutes
-    # 240000 = 4 Minutes
-    # 300000 = 5 Minutes
-    # Time in Mliseconds
-
-    ButtonTitle: "Claim Ticket"
-    ButtonEmoji: "🎫"
-    Button: "1"
-
-    # Available Button Styles
-    # 1 - Blurple
-    # 2 - Grey
-    # 3 - Green
-    # 4 - Red
-
-  ReviewSystem:
-    Enabled: true                
-    Channel: "REVIEW_CHANNEL_ID"
-    UseModal: true
-
-  Questions:
-    Enabled: true  # Set to false to disable ticket questions
-    List:
-      - "Please provide your account email?"
-      - "What is the nature of your issue?"
-      - "Have you tried resolving the issue yourself?"
-
-  Log:
-    TicketDataLog: "TICKET_DATA_LOG_ID"
-    TickeDataTitle: "Ticket Data"
-    TicketBlacklistLog: "TICKET_BLACKLIST_LOG_ID"
+TranslateLogChannel: "translations-log"
 
 # -------------------------
-#  Buttons
-# -------------------------
-Buttons:
-  General:
-    Delete: "🗑️"
-    DeleteStyle: "4"
-
-  Voice:
-    TicketDeleteText: "Delete Voice Channel"
-
-  Tickets:
-    ClaimEmoji: "🧑‍💻"
-    ClaimStyle: "1"
-
-    Unarchive: "Unarchive Ticket"
-    Unarchive_Emoji: "♻️"
-    Unarchive_Style: "2"
-
-    Unlock: "Unlock Ticket"
-    Unlock_Emoji: "🔓"
-    Unlock_Style: "2"
-
-    # Available Button Styles
-    # 1 - Blurple
-    # 2 - Grey
-    # 3 - Green
-    # 4 - Red
-
-# -------------------------
-#  Select Menus
+#  Tickets Configuration
 # -------------------------
 
-SelectMenus:
-  Tickets:
-    PanelEmoji: "⚙️"
-    
-    CloseEmoji: "🗑️"
-    ArchiveEmoji: "♻️"
-    LockEmoji: "🔐"
-    RenameEmoji: "🏷️"
-    VCEmoji: "🔊"
+TicketPrefix: "ticket-" # The prefix for ticket channel names
 
-    EnableInvitesEmoji: "📤"
-    DisableInvitesEmoji: "📥"
+TicketLog: "ticket-data"
+TranscriptLog: "ticket-data"
+
+DMTranscripts: true
+TranscriptTitle: "Ticket Transcript"
+TicketLog_Title: "Ticket Closed"
+TicketBlackListMessage: "You are not allowed to open a ticket"
+TicketRoleMention: "@here"
+TicketClaimMessage: "Your ticket will be handled by" #Automaticly tags user to the end
+TicketClaimTitle: "Ticket Claimed"
+# To ping a role: <@ROLE_ID>
+
+MaxAllowedTickets: 2
+
+TicketSubject: "description"
+# "description" will display the ticket reason within the channel description
+# "embed" will display the ticket reason within the ticket embed
+
+AllowTicketMentions: true
+# Set to true to allow the ticket to mention the author and the support team.
+# Set false to dis-allow mentions within tickets.
+
+AllowThanksForReachingOutMessage: true 
+# Set to true to allow the "Thanks for reaching out Message" to be sent when the ticket is created
+DisableTicketLogChannel: false
+# Set to true to disable the requirement of the "TicketLog"
+# Set to true to also disable the ticket logs to be sent in the "TicketLogs" channel
+
+# --- Creation Config ---
+#      --- Start ---
+
+# Available Placeholders:
+
+# %ticketusername% - User who created the ticket.
+# <@%ticketauthor%> - Tags the user who created the ticket.
+# <#%ticketid%> - Mentions the ticket channel.
+
+Ticket_Title: "Server Support | %ticketusername%"
+TicketMessage: "Hello <@%ticketauthor%>, Thank you for creating a support ticket\nPlease wait patiently whilst a member of our team reaches out to you."
+
+Ticket_Thumbnail: "https://images.emojiterra.com/google/android-pie/512px/1f39f.png"
+NoTicketSubject: "No Reason Provided!"
+
+TicketCreatedAlert: ":ticket: Your support ticket has been created: <#%ticketid%>"
+
+AddedUser: "👍 <@%user%> has been added to this ticket"
+RemovedUser: "👍 <@%user%> has been removed from this ticket"
 
 # -------------------------
-#  Logging
+#   Tickets Categories
 # -------------------------
 
-MessageDelete:
-  Channel: "MESSAGE_DELETE_CHANNEL_ID""
-  Colour: "#d92525"
+Timeout: 5
 
-MessageUpdate:
-  Channel: "MESSAGE_UPDATE_CHANNEL_ID"
-  Colour: "#f2a024"
+# Set to true to allow all staff to access the ticket
+AllowAllStaff: false
 
-Translate:
-  TranslateLog: "TRANSLATE_LOG_ID"
+# Ticket roles are the roles that will be able to gain access to tickets depending on what department has been chosen.
+
+Departments:
+  - title: "Support"
+    role: "Staff"
+    color: "SECONDARY"
+    emoji: "1️⃣"
+    category: "Tickets"
+
+  - title: "Billing Support"
+    role: "Staff"
+    color: "SECONDARY"
+    emoji: "2️⃣"
+    category: "Tickets"
+
+  - title: "Admin Team"
+    role: "Admin"
+    color: "SECONDARY"
+    emoji: "3️⃣"
+    category: "Tickets"
+
+#  - title: "Other"
+#    role: "Staff"
+#    color: "SECONDARY"
+#    emoji: "3️⃣"
+#    category: "Tickets"
+
+# Discord Button Colour Selection
+# PRIMARY - Blurple
+# SECONDARY - Grey
+# DANGER - Red
+# SUCCESS - Green
+
+# --- Buttons Config ---
+#      --- Start ---
+
+LockTicketCategory: "Archive"
+
+TicketCloseEmoji: "❌"
+TicketDeleteEmoji: "⛔"
+TicketLockEmoji: "🔒"
+TicketClaimEmoji: "🧑‍💻"
+
+TicketCloseColour: "DANGER"
+TicketDeleteColour: "DANGER"
+TicketLockColour: "PRIMARY"
+TicketClaimColour: "SUCCESS"
+
+# Discord Button Colour Selection
+# PRIMARY - Blue
+# SECONDARY - Grey
+# DANGER - Red
+# SUCCESS - Green
+
+TranscriptSavedMessage: "📝 **Transcript Saved!**"
+TicketLockMessage: "❌ **Ticket Locked!**"
+TicketDeleteMessage: "⚠ **Ticket Deleting!**" # Tickets deleting after 5 seconds by default.
+
+# --- Closing Config ---
+#    --- Start ---
+
+StaffOnly: true
+ClosingTicket: ":warning: You have requested to close your support ticket."
+ClosingConfirmation_Word: "confirm"
+CloseConfirmation: true
+
+# ---------------------------
+#  Error / Warning Messages
+# ---------------------------
+
+IncorrectPerms: ":x: **Err!** You do not have the correct permissions to use this command."
+InvalidChannel: ":x: **Err!** Channel not found. Please create it!"
+UserNotFound: ":x: **Err!** This user doesn't exist, Are they in this server?"
+NoValidTicket: ":warning: You cannot execute this command here."
+TicketExists: ":warning: This ticket cannot be opened, It already exists!"

Configs/ticket-panel.yml

@@ -7,40 +7,28 @@
 #           SupportBot created by Emerald Services
 #           Installed with MIT License
 #
-#           Discord Support: https://discord.gg/emeraldsrv
-#           Official Documentation: https://docs.emeraldsrv.com
-#           Addons Marketplace: https://community.emeraldsrv.com
-#
-#           Ticket Creation Panel Configuration (ticket-panel.yml)
+#           Discord Support: https://emeraldsrv.dev/discord
+#           Community Resources: https://emeraldsrv.dev/resources
 
 # -------------------------------
 #   Ticket Panel Configuration
 # -------------------------------
 
-Panel: true
+TicketPanel: true
 
 # ----------------------------------------
-#   Ticket Panel Message Configuration #2b2d31
+#   Ticket Panel Message Configuration
 # ----------------------------------------
 
-PanelTitle: "SupportBot"
-PanelColour: "#0cc559"
+Channel: "ticket-creation"
 
-Button:
-  Text: "Create Ticket"
-  Emoji: "🎫"
-  Color: "2"
-
-# Available Button Styles
-# 1 - Blurple
-# 2 - Grey
-# 3 - Red
-# 4 - Green
+PanelTitle: "Need Help? Create a Support Ticket."
+PanelColour: "#f74343"
 
 TicketPanel_Description: true
-TicketPanel_Thumbnail: false
+TicketPanel_Thumbnail: true
 TicketPanel_Image: true
 
-PanelMessage: "Click on the button to file a `Ticket` and our team will try their best to assist you in the best way we can!"
+PanelMessage: "Click the button to open a new support ticket."
 PanelThumbnail: "https://i.imgur.com/ieeZejl.png"
-PanelImage: "https://i.imgur.com/dejQvkg.png"
+PanelImage: "https://i.imgur.com/5NkcmDq.png"

Data/BlacklistedUsers.json

@@ -1,3 +0,0 @@
-{
-    "blacklistedUsers": []
-}

Data/Profiles.json

@@ -1 +0,0 @@
-{}

Data/StaffData.json

@@ -1 +0,0 @@
-{}

Data/SuggestionData.json

@@ -1 +0,0 @@
-{}

Data/SupportBot-AI.json

@@ -1 +0,0 @@
-{}

Data/TicketData.json

@@ -1,5 +1 @@
-{
-    "tickets": [
-        {}
-    ]
-}
+{"tickets": [{}]}

Data/profiles/0000000000000000.json

@@ -1,5 +0,0 @@
-{
-  "bio": "",
-  "timezone": "",
-  "clockedIn": false
-}

Data/settings.json

@@ -1 +0,0 @@
-{}

Data/ticket-panel-id.json

@@ -1,4 +1,4 @@
 {
     "id": 0,
-    "TicketPanelID": "000000000000000"
+    "TicketPanelID": ""
 }

Events/guildMemberAdd.js

@@ -3,54 +3,44 @@ const Discord = require('discord.js');
 const fs = require("fs");
 const Event = require("../Structures/Event.js");
 const yaml = require("js-yaml");
-
 const supportbot = yaml.load(
-    fs.readFileSync("./Configs/supportbot.yml", "utf8")
-);
-  
-const cmdconfig = yaml.load(
-    fs.readFileSync("./Configs/commands.yml", "utf8")
-);
-  
-const msgconfig = yaml.load(
-    fs.readFileSync("./Configs/messages.yml", "utf8")
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
 );
 
 module.exports = new Event("guildMemberAdd", async (client, member, interaction, guild) => {
 
-    if (supportbot.Welcome.Enabled) {
-        const WelcomeChannel = member.guild.channels.cache.get(supportbot.Welcome.Channel) ||
-                               member.guild.channels.cache.find(channel => channel.name === supportbot.Welcome.Channel);
+    if (supportbot.Welcome) {
+        const WelcomeChannel = member.guild.channels.cache.find(channel => channel.name === supportbot.WelcomeChannel)
 
-        const WelcomeEmbed = new Discord.EmbedBuilder()
-            .setColor(msgconfig.Welcome.Embed.Colour)
-            .setTitle(msgconfig.Welcome.Embed.Title)
-            .setDescription(msgconfig.Welcome.Embed.Message.replace(/%joined_user%/g, member.user))
+        const WelcomeEmbed = new Discord.MessageEmbed()
+            .setColor(supportbot.WelcomeColour)
+            .setTitle(supportbot.WelcomeTitle)
+            .setDescription(supportbot.WelcomeMessage.replace(/%joined_user%/g, member.user))
             .setTimestamp();
         
-        if (msgconfig.Welcome.Embed.Thumbnail === "BOT") {
-            WelcomeEmbed.setThumbnail(client.user.displayAvatarURL())
-        } else if (msgconfig.Welcome.Embed.Thumbnail === "USER") {
-            WelcomeEmbed.setThumbnail(member.user.displayAvatarURL())
-        }
-    
-        if (msgconfig.Welcome.Embed.ImageEnabled) {
-            WelcomeEmbed.setImage(msgconfig.Welcome.Embed.ImageURL)
-        }
-    
-        if (WelcomeChannel) {
-            WelcomeChannel.send({ embeds: [WelcomeEmbed] });
-        }
-    
-        if (supportbot.Roles.AutoRole.Enabled) {
-            const role = member.guild.roles.cache.get(supportbot.Roles.AutoRole.Role) ||
-                         member.guild.roles.cache.find(role => role.name === supportbot.Roles.AutoRole.Role);
-            if (role) {
-                member.roles.add(role);
+            if (supportbot.EmbedWelcomeThumbnail === "BOT") {
+                WelcomeEmbed.setThumbnail(client.user.displayAvatarURL())
             }
-        }
     
-        console.log(`\u001b[32m`, `[+]`, `\u001b[33m`, `${member.user.username} joined the server!`);
+            if (supportbot.EmbedWelcomeThumbnail === "USER") {
+                WelcomeEmbed.setThumbnail(member.user.displayAvatarURL())
+            }
+    
+            if (supportbot.EmbedWelcomeImage) {
+                WelcomeEmbed.setImage(supportbot.EmbedWelcomeImageURL)
+            }
+    
+            WelcomeChannel.send({
+                embeds: [WelcomeEmbed]
+            })
+    
+            if (supportbot.AutoRole) {
+                var role = member.guild.roles.cache.find(role => role.name === supportbot.JoinRole);
+                member.roles.add(role);
+            } 
+    
+            console.log(`\u001b[32m`, `[+]`, `\u001b[33m`, `${member.user.username} joined the server!`)
+    
     }
 
 });

Events/guildMemberRemove.js

@@ -3,48 +3,39 @@ const Discord = require('discord.js');
 const fs = require("fs");
 const Event = require("../Structures/Event.js");
 const yaml = require("js-yaml");
-
 const supportbot = yaml.load(
-    fs.readFileSync("./Configs/supportbot.yml", "utf8")
-);
-  
-const cmdconfig = yaml.load(
-    fs.readFileSync("./Configs/commands.yml", "utf8")
-);
-  
-const msgconfig = yaml.load(
-    fs.readFileSync("./Configs/messages.yml", "utf8")
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
 );
 
 module.exports = new Event("guildMemberRemove", async (client, member, interaction, guild) => {
 
-    if (supportbot.Leave.Enabled) {
-        const LeaveChannel = member.guild.channels.cache.get(supportbot.Leave.Channel) ||
-                             member.guild.channels.cache.find(channel => channel.name === supportbot.Leave.Channel);
+    if (supportbot.Leave) {
+        const LeaveChannel = member.guild.channels.cache.find(channel => channel.name === supportbot.LeaveChannel)
 
-        const LeaveEmbed = new Discord.EmbedBuilder()
-            .setColor(msgconfig.Leave.Embed.Colour)
-            .setTitle(msgconfig.Leave.Embed.Title)
-            .setDescription(msgconfig.Leave.Embed.Message.replace(/%left_user%/g, member.user))
+        const LeaveEmbed = new Discord.MessageEmbed()
+            .setColor(supportbot.LeaveColour)
+            .setTitle(supportbot.LeaveTitle)
+            .setDescription(supportbot.LeaveMessage.replace(/%joined_user%/g, member.user))
             .setTimestamp();
-        
-        if (msgconfig.Leave.Embed.Thumbnail === "BOT") {
-            LeaveEmbed.setThumbnail(client.user.displayAvatarURL());
-        } else if (msgconfig.Leave.Embed.Thumbnail === "USER") {
-            LeaveEmbed.setThumbnail(member.user.displayAvatarURL());
-        }
     
-        if (msgconfig.Leave.Embed.ImageEnabled) {
-            LeaveEmbed.setImage(msgconfig.Leave.Embed.ImageURL);
-        }
+            if (supportbot.EmbedLeaveThumbnail === "BOT") {
+                LeaveEmbed.setThumbnail(client.user.displayAvatarURL())
+            }
+    
+            if (supportbot.EmbedLeaveThumbnail === "USER") {
+                LeaveEmbed.setThumbnail(member.user.displayAvatarURL())
+            }
+    
+            if (supportbot.EmbedLeaveImage) {
+                LeaveEmbed.setImage(supportbot.EmbedLeaveImageURL)
+            }
     
-        if (LeaveChannel) {
             LeaveChannel.send({
                 embeds: [LeaveEmbed]
-            });
-        }
+            })
     
-        console.log(`\u001b[31m`, `[-]`, `\u001b[33m`, `${member.user.username} left the server!`);
+            console.log(`\u001b[31m`, `[-]`, `\u001b[33m`, `${member.user.username} joined the server!`)
     }
 
-});
+});
+

Events/interactionCreate.js

@@ -1,831 +1,170 @@
+// SupportBot | Emerald Services
+// Interaction Create Event
+
 const fs = require("fs");
+
 const Discord = require("discord.js");
 const yaml = require("js-yaml");
-
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
 const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
 
 const Event = require("../Structures/Event.js");
+const TicketNumberID = require("../Structures/TicketID.js");
+
 
-let suggestions;
-try {
-  suggestions = require("../Data/SuggestionData.json");
-} catch (error) {
-  suggestions = {};
-}
 
 module.exports = new Event("interactionCreate", async (client, interaction) => {
-
-  if (interaction.type === Discord.InteractionType.ApplicationCommand) {
+  if (interaction.isCommand()) {
     const command = client.commands.find(
       (cmd) => cmd.name.toLowerCase() === interaction.commandName
     );
 
     if (interaction.user.bot || !interaction.guild) return;
 
-    const NotValid = new Discord.EmbedBuilder()
-      .setDescription(`:x: \`Invalid Command\``)
-      .setColor(supportbot.Embed.Colours.Error);
+    const NotValid = new Discord.MessageEmbed()
+      .setDescription(`:x: \`Invalid Command\` `)
+      .setColor(supportbot.ErrorColour);
 
     if (!command)
       return interaction.reply({
         embeds: [NotValid],
-        ephemeral: true,
       });
 
     const permission = interaction.member.permissions.has(command.permissions);
 
-    const ValidPerms = new Discord.EmbedBuilder()
+    const ValidPerms = new Discord.MessageEmbed()
       .setDescription(
-        "> :x: `Invalid Permissions` Do you have the correct permissions to execute this command?"
+        ":x: `Invalid Permissions` Do you have the correct permissions to execute this command?"
       )
-      .setColor(supportbot.Embed.Colours.Error);
+      .setColor(supportbot.ErrorColour);
 
     if (!permission)
       return interaction.reply({
         embeds: [ValidPerms],
-        ephemeral: true,
       });
-
-    try {
-      if (command.name === cmdconfig.OpenTicket.Command && supportbot.Ticket.TicketReason) {
-        const modal = new Discord.ModalBuilder()
-          .setCustomId("ticketReasonModal")
-          .setTitle("Ticket Reason")
-          .addComponents(
-            new Discord.ActionRowBuilder().addComponents(
-              new Discord.TextInputBuilder()
-                .setCustomId("reasonInput")
-                .setLabel("Reason")
-                .setStyle(Discord.TextInputStyle.Paragraph)
-                .setRequired(true)
-            )
-          );
-
-        await interaction.showModal(modal);
-      } else {
-        console.log("\u001b[32m", "[Executed]", "\u001b[37;1m", `${interaction.user.username} has executed ${command.name}`);
-        await command.run(interaction);
-      }
-    } catch (error) {
-      console.error("Error executing command:", error);
-      await interaction.reply({
-        content: "An error occurred while executing the command.",
-        ephemeral: true,
-      });
-    }
+    command.run(interaction);
   }
-
-  if (interaction.isModalSubmit()) {
-    if (interaction.customId === "ticketReasonModal") {
-      const reason = interaction.fields.getTextInputValue("reasonInput");
-      interaction.customId = `createticket-${reason}`;
-      const cmd = client.commands.get(cmdconfig.OpenTicket.Command);
-      if (cmd) {
-        interaction.reason = reason; // Attach the reason to the interaction object
-        await cmd.run(interaction);
-      } else {
-        console.error("Command not found.");
-      }
-    }
-  }
-
-  if (interaction.customId === "renameTicketModal") {
-    const newTicketName = interaction.fields.getTextInputValue("renameTicket");
-
-    // Fixing the ticketChannelId extraction and lookup
-    const ticketChannelId = interaction.channel.id;
-
-    let ticketChannel;
-    if (supportbot.Ticket.TicketType === "threads") {
-        ticketChannel = interaction.guild.channels.cache.get(ticketChannelId);
-    } else if (supportbot.Ticket.TicketType === "channels") {
-        ticketChannel = interaction.guild.channels.cache.get(ticketChannelId);
-    }
-
-    if (!ticketChannel) {
-        return interaction.reply({
-            content: "Ticket channel not found.",
-            ephemeral: true,
-        });
-    }
-
-    try {
-        await ticketChannel.setName(newTicketName);
-
-        const renamedsuccess = new Discord.EmbedBuilder()
-            .setDescription(msgconfig.Ticket.RenamedSuccess)
-            .setColor(supportbot.Embed.Colours.Success);
-
-        return interaction.reply({
-            embeds: [renamedsuccess],
-            ephemeral: true,
-        });
-    } catch (error) {
-        console.error("Error renaming the ticket:", error);
-        return interaction.reply({
-            content: "There was an error renaming the ticket.",
-            ephemeral: true,
-        });
-    }
-}
-  if (interaction.isStringSelectMenu()) {
-    if (interaction.customId === "ticketcontrolpanel") {
-      const selectedOption = interaction.values[0];
-      const { getRole, getChannel } = interaction.client;
-      switch (selectedOption) {
-
-        case "ticketclose":
-          const closeCommand = client.commands.get(cmdconfig.CloseTicket.Command);
-          if (closeCommand) {
-            await closeCommand.run(interaction);
-          } else {
-            console.error("[X] Close Command Not Found");
-          }
-          break;
-
-          case "supportvc":
-            const ticketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-            const ticketInfo = ticketData.tickets.find(t => t.id === interaction.channel.id);
-        
-            if (ticketInfo) {
-              const user = interaction.guild.members.cache.get(ticketInfo.user) || ticketInfo.user;
-              const claimedBy = interaction.guild.members.cache.get(ticketInfo.claimedBy) || ticketInfo.claimedBy;
-              const Admin = await interaction.guild.roles.fetch(supportbot.Roles.StaffMember.Admin);
-              const Staff = await interaction.guild.roles.fetch(supportbot.Roles.StaffMember.Staff);
-
-              const VCcategory = interaction.guild.channels.cache.find(
-                (c) => c.name === supportbot.VoiceTickets.Category || c.id === supportbot.VoiceTickets.Category
-              );
-      
-              if (!VCcategory) {
-                return interaction.reply({
-                  content: "The Support VC category does not exist!",
-                  ephemeral: true,
-                });
-              }
-
-              let username = user ? user.user.username : "Unknown User"; 
-
-              let SupportVoice = await interaction.guild.channels.create({
-                name: supportbot.VoiceTickets.Name.replace(/%username%/g, username),
-                type: Discord.ChannelType.GuildVoice,
-                parent: VCcategory,
-                permissionOverwrites: [
-                  {
-                    id: user,
-                    allow: [
-                      Discord.PermissionsBitField.Flags.Connect,
-                      Discord.PermissionsBitField.Flags.Speak,
-                      Discord.PermissionsBitField.Flags.ViewChannel,
-                    ],
-                  },
-                  {
-                    id: Staff,
-                    allow: [
-                      Discord.PermissionsBitField.Flags.Connect,
-                      Discord.PermissionsBitField.Flags.Speak,
-                      Discord.PermissionsBitField.Flags.ViewChannel,
-                    ],
-                  },
-                  {
-                    id: Admin,
-                    allow: [
-                      Discord.PermissionsBitField.Flags.Connect,
-                      Discord.PermissionsBitField.Flags.Speak,
-                      Discord.PermissionsBitField.Flags.ViewChannel,
-                    ],
-                  },
-                  {
-                    id: interaction.guild.id,
-                    deny: [Discord.PermissionsBitField.Flags.ViewChannel],
-                  },
-                ],
-              });
-
-              ticketInfo.voiceChannelId = SupportVoice.id;
-              
-              fs.writeFileSync("./Data/TicketData.json", JSON.stringify(ticketData, null, 2));
-              
-              const VCDeleteButton = new Discord.ButtonBuilder()
-                .setCustomId("deleteSupportVC")
-                .setLabel(supportbot.Buttons.Voice.TicketDeleteText)
-                .setEmoji(supportbot.Buttons.General.Delete)
-                .setStyle(supportbot.Buttons.General.DeleteStyle);
-              
-              const VCDeleteRow = new Discord.ActionRowBuilder().addComponents(VCDeleteButton);
-              
-              const vcmadeembed = new Discord.EmbedBuilder()
-                .setDescription(`> **Support VC Created:** <#${SupportVoice.id}>`)
-                .setColor(supportbot.Embed.Colours.Success);
-              
-              await interaction.reply({
-                embeds: [vcmadeembed],
-                components: [VCDeleteRow],
-              });
-
-            }
-          break;
-
-          case "archiveticket":
-              const arcembed = new Discord.EmbedBuilder()
-                .setDescription(msgconfig.Ticket.TicketArchived)
-                .setColor(supportbot.Embed.Colours.Success);
-
-              const CloseButton = new Discord.ButtonBuilder()
-                .setCustomId("confirmCloseTicket")
-                .setLabel(supportbot.Ticket.Close.Confirmation_Button)
-                .setEmoji(supportbot.Ticket.Close.Confirmation_Emoji)
-                .setStyle(supportbot.Ticket.Close.Confirmation_Style);
-
-              const unarchiveButton = new Discord.ButtonBuilder()
-                .setCustomId("unarchiveTicket")
-                .setLabel(supportbot.Buttons.Tickets.Unarchive)
-                .setEmoji(supportbot.Buttons.Tickets.Unarchive_Emoji)
-                .setStyle(supportbot.Buttons.Tickets.Unarchive_Style);
-
-              const ArchivedOptions = new Discord.ActionRowBuilder() 
-                .addComponents(CloseButton, unarchiveButton);
-
-                await interaction.channel.send({
-                  embeds: [arcembed],
-                  components: [ArchivedOptions],
-                });
-
-                if (supportbot.Ticket.TicketType === "threads") {
-                  await interaction.channel.setArchived(true);
-                }
-              
-                if (supportbot.Ticket.TicketType === "channels") {
-                  const { getRole, getChannel } = interaction.client;
-                  await interaction.channel.setParent(supportbot.Ticket.TicketArchiveCategory);
-
-                  const ticketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-                  const ticketInfo = ticketData.tickets.find(t => t.id === interaction.channel.id);
-              
-                  if (ticketInfo) {
-                    const user = interaction.guild.members.cache.get(ticketInfo.user) || ticketInfo.user;
-                    const claimedBy = interaction.guild.members.cache.get(ticketInfo.claimedBy) || ticketInfo.claimedBy;
-                    const Admin = await interaction.guild.roles.fetch(supportbot.Roles.StaffMember.Admin);
-                    const Staff = await interaction.guild.roles.fetch(supportbot.Roles.StaffMember.Staff);
-              
-                    if (user && user.id) {
-                      await interaction.channel.permissionOverwrites.edit(user.id, {
-                        ViewChannel: false,
-                        SendMessages: false,
-                      });
-                    }
-              
-                    if (supportbot.ClaimTickets === true) {
-                      if (claimedBy && claimedBy.id) {
-                        await interaction.channel.permissionOverwrites.edit(claimedBy.id, {
-                          ViewChannel: true,
-                          SendMessages: true,
-                          ReadMessageHistory: true,
-                        });
-                      }  
-                    }
-  
-                    if (supportbot.ClaimTickets === false) {
-                      if (Staff && Staff.id) {
-                        await interaction.channel.permissionOverwrites.edit(claimedBy.id, {
-                          ViewChannel: true,
-                          SendMessages: true,
-                          ReadMessageHistory: true,
-                        });
-                      }  
-                    }
-              
-                    if (Admin && Admin.id) {
-                      await interaction.channel.permissionOverwrites.edit(Admin.id, {
-                        ViewChannel: true,
-                        SendMessages: true,
-                        ReadMessageHistory: true,
-                      });
-                    }
-              
-                    await interaction.channel.permissionOverwrites.edit(interaction.guild.roles.everyone.id, {
-                      ViewChannel: false,
-                      SendMessages: false,
-                      ReadMessageHistory: false,
-                    });
-                  }
-            
-                }
-
-                break;
-
-                case "lockticket":
-                  const lockembed = new Discord.EmbedBuilder()
-                    .setDescription(msgconfig.Ticket.TicketLocked)
-                    .setColor(supportbot.Embed.Colours.Success);
-              
-                  const unlockButton = new Discord.ButtonBuilder()
-                    .setCustomId("unlockTicket")
-                    .setLabel(supportbot.Buttons.Tickets.Unlock)
-                    .setEmoji(supportbot.Buttons.Tickets.Unlock_Emoji)
-                    .setStyle(supportbot.Buttons.Tickets.Unlock_Style);
-              
-                  const LockedOptions = new Discord.ActionRowBuilder()
-                    .addComponents(unlockButton);
-              
-                  await interaction.channel.send({
-                    embeds: [lockembed],
-                    components: [LockedOptions],
-                    ephemeral: false, 
-                  });
-              
-
-                  if (supportbot.Ticket.TicketType === "threads") {
-                    await interaction.channel.setLocked(true);  
-                  }
-              
-                  break;
-
-                  case "unlockTicket":
-                    const unlockEmbed = new Discord.EmbedBuilder()
-                      .setDescription(msgconfig.Ticket.TicketUnlocked)
-                      .setColor(supportbot.Embed.Colours.Success);
-                
-                    await interaction.channel.send({
-                      embeds: [unlockEmbed],
-                      ephemeral: false,
-                    });
-                
-                    if (supportbot.Ticket.TicketType === "threads") {
-                      await interaction.channel.setLocked(false);  
-                    }
-                
-                    break;
-              
-        case "enableinvites":
-          await handleInvites(interaction, true);
-          break;
-
-        case "disableinvites":
-          await handleInvites(interaction, false);
-          break;
-
-        case "renameticket":
-          const modal = new Discord.ModalBuilder()
-          .setCustomId("renameTicketModal")
-          .setTitle("Rename Channel")
-          .addComponents(
-            new Discord.ActionRowBuilder()
-              .addComponents(
-                new Discord.TextInputBuilder()
-                  .setCustomId("renameTicket")
-                  .setLabel("New Channel Name")
-                  .setStyle(Discord.TextInputStyle.Short)
-                  .setRequired(true)
-                )
-              );
-            await interaction.showModal(modal);
-            break;
-
-      }
-    }
-  }
-
-  if (interaction.customId === 'deleteSupportVC') {
-    const ticketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-    const ticketInfo = ticketData.tickets.find(t => t.id === interaction.channel.id);
-  
-    if (ticketInfo && ticketInfo.voiceChannelId) {
-      try {
-        const voiceChannel = await interaction.guild.channels.fetch(ticketInfo.voiceChannelId).catch(() => null);
-  
-        if (voiceChannel) {
-          await voiceChannel.delete();
-  
-          const successEmbed = new Discord.EmbedBuilder()
-            .setDescription('✅ Support voice channel has been successfully deleted!')
-            .setColor(supportbot.Embed.Colours.Success);
-  
-          await interaction.reply({
-            embeds: [successEmbed],
-            ephemeral: true,
-          });
-  
-          ticketInfo.voiceChannelId = null; 
-          fs.writeFileSync("./Data/TicketData.json", JSON.stringify(ticketData, null, 2));
-        } else {
-          const errorEmbed = new Discord.EmbedBuilder()
-            .setDescription('❌ The associated voice channel could not be found.')
-            .setColor(supportbot.Embed.Colours.Error);
-  
-          await interaction.reply({
-            embeds: [errorEmbed],
-            ephemeral: true,
-          });
-        }
-      } catch (error) {
-        console.error('Error deleting the Voice Channel:', error);
-  
-        const errorEmbed = new Discord.EmbedBuilder()
-          .setDescription('❌ **There was an error trying to delete this voice channel. Please try again later.**')
-          .setColor(supportbot.Embed.Colours.Error);
-  
-        await interaction.reply({
-          embeds: [errorEmbed],
-          ephemeral: true,
-        });
-      }
-    } else {
-      const errorEmbed = new Discord.EmbedBuilder()
-        .setDescription('⚠️ This button is not linked to a valid voice channel.')
-        .setColor(supportbot.Embed.Colours.Warn);
-  
-      await interaction.reply({
-        embeds: [errorEmbed],
-        ephemeral: true,
-      });
-    }
-  }
-  
-
-
   if (interaction.isButton()) {
-    if (interaction.customId === "unarchiveTicket") {
-
-      if (supportbot.Ticket.TicketType === "threads") {
-        await interaction.channel.setArchived(false);
+    if (
+      interaction.customId === "openticket" ||
+      interaction.customId.includes("department-")
+    ) {
+      try {
+        const cmd = client.commands.get(cmdconfig.OpenTicket);
+        if (!cmd) return;
+        cmd.run(interaction);
+      } catch (error) {
+        console.error(error);
       }
-    
-      if (supportbot.Ticket.TicketType === "channels") {
-        const { getRole, getChannel } = interaction.client;
-        await interaction.channel.setParent(supportbot.Ticket.TicketChannelsCategory);
-
-        const ticketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-        const ticketInfo = ticketData.tickets.find(t => t.id === interaction.channel.id);
-      
-        if (ticketInfo) {
-          const user = interaction.guild.members.cache.get(ticketInfo.user) || ticketInfo.user;
-          const claimedBy = interaction.guild.members.cache.get(ticketInfo.claimedBy) || ticketInfo.claimedBy;
-          const Admin = await interaction.guild.roles.fetch(supportbot.Roles.StaffMember.Admin);
-          const Staff = await interaction.guild.roles.fetch(supportbot.Roles.StaffMember.Staff);
-      
-          if (user && user.id) {
-            await interaction.channel.permissionOverwrites.edit(user.id, {
-              ViewChannel: true,
-              SendMessages: true,
-              ReadMessageHistory: true,
-            });
-          }
-      
-          if (supportbot.ClaimTickets === true) {
-            if (claimedBy && claimedBy.id) {
-              await interaction.channel.permissionOverwrites.edit(claimedBy.id, {
-                ViewChannel: true,
-                SendMessages: true,
-                ReadMessageHistory: true,
-              });
-            }  
-          }
-
-          if (supportbot.ClaimTickets === false) {
-            if (Staff && Staff.id) {
-              await interaction.channel.permissionOverwrites.edit(claimedBy.id, {
-                ViewChannel: true,
-                SendMessages: true,
-                ReadMessageHistory: true,
-              });
-            }  
-          }
-      
-          if (Admin && Admin.id) {
-            await interaction.channel.permissionOverwrites.edit(Admin.id, {
-              ViewChannel: true,
-              SendMessages: true,
-              ReadMessageHistory: true,
-            });
-          }
-      
-          await interaction.channel.permissionOverwrites.edit(interaction.guild.roles.everyone.id, {
-            ViewChannel: false,
-            SendMessages: false,
-            ReadMessageHistory: false,
-          });
-        }
-      }
-    
-      const unrcembed = new Discord.EmbedBuilder()
-        .setDescription(msgconfig.Ticket.TicketUnarchived)
-        .setColor(supportbot.Embed.Colours.Success);
-    
-      await interaction.update({
-        embeds: [unrcembed],
-        components: [],
-      });
-    
     }
 
-    if (interaction.customId === "createticket") {
-      if (supportbot.Ticket.TicketReason) {
-        const modal = new Discord.ModalBuilder()
-          .setCustomId("ticketReasonModal")
-          .setTitle("Ticket Reason")
-          .addComponents(
-            new Discord.ActionRowBuilder().addComponents(
-              new Discord.TextInputBuilder()
-                .setCustomId("reasonInput")
-                .setLabel("Reason")
-                .setStyle(Discord.TextInputStyle.Paragraph)
-                .setRequired(true)
-            )
+    if (interaction.customId === "ticketclose") {
+      try {
+        const cmd = client.commands.get(cmdconfig.CloseTicket);
+        if (!cmd) return;
+        cmd.run(interaction);
+      } catch (error) {
+        console.error(error);
+      }
+    }
+    if (interaction.customId === "ticketlock") {
+      if (interaction.channel.name.startsWith(supportbot.TicketPrefix)) {
+        interaction.message.fetch();
+        let Admin =
+          interaction.guild.roles.cache.find(
+            (AdminUser) => AdminUser.name === supportbot.Admin
+          ) ||
+          interaction.guild.roles.cache.find(
+            (AdminUser) => AdminUser.id === supportbot.Admin
           );
-
-        await interaction.showModal(modal);
-      } else {
-        try {
-          const cmd = client.commands.get(cmdconfig.OpenTicket.Command);
-          if (!cmd) return;
-          await cmd.run(interaction);
-        } catch (error) {
-          console.error("Error executing the ticket command:", error);
-          await interaction.reply({
-            content: "An error occurred while creating the ticket.",
+        if (!interaction.member.roles.cache.has(Admin.id)) {
+          return await interaction.reply({
+            content: "You don't have permission to do that.",
             ephemeral: true,
           });
         }
-      }
-    }
+        let all = interaction.channel.permissionOverwrites.cache;
 
-    if (interaction.customId === "openticket") {
-      if (supportbot.Ticket.TicketReason) {
-        const modal = new Discord.ModalBuilder()
-          .setCustomId("ticketReasonModal")
-          .setTitle("Ticket Reason")
-          .addComponents(
-            new Discord.ActionRowBuilder().addComponents(
-              new Discord.TextInputBuilder()
-                .setCustomId("reasonInput")
-                .setLabel("Reason")
-                .setStyle(Discord.TextInputStyle.Paragraph)
-                .setRequired(true)
-            )
+        let parent =
+          interaction.guild.channels.cache.find(
+            (c) => c.name === supportbot.LockTicketCategory
+          ) ||
+          interaction.guild.channels.cache.find(
+            (c) => c.id === supportbot.LockTicketCategory
           );
-
-        await interaction.showModal(modal);
-      } else {
-        try {
-          const cmd = client.commands.get(cmdconfig.OpenTicket.Command);
-          if (!cmd) return;
-          await cmd.run(interaction);
-        } catch (error) {
-          console.error(error);
+        if (parent) {
+          await interaction.channel.setParent(parent.id);
         }
-      }
-    }
 
-    if (interaction.customId.startsWith("claimticket-")) {
-      const ticketChannelId = interaction.customId.split("-")[1];
-      const ticketChannel = interaction.guild.channels.cache.get(ticketChannelId);
-      if (!ticketChannel) {
-        return interaction.reply({
-          content: "Ticket channel not found.",
-          ephemeral: true,
+        all.forEach((perm) => {
+          interaction.channel.permissionOverwrites.delete(perm.id);
         });
-      }
-
-      const { getRole, getChannel } = interaction.client;
-      const Staff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
-      const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
-
-      const RolePerms = new Discord.EmbedBuilder()
-        .setTitle("Invalid Permissions!")
-        .setDescription(
-          `${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``
-        )
-        .setColor(supportbot.Embed.Colours.Warn);
-
-      if (!Staff || !Admin) {
-        return interaction.reply({
-          embeds: [RolePerms],
-          ephemeral: true,
+        await interaction.channel.permissionOverwrites.create(Admin.id, {
+          VIEW_CHANNEL: true,
         });
-      }
 
-      const NoPermsClaim = new Discord.EmbedBuilder()
-        .setTitle(msgconfig.Ticket.ClaimTickets.NoPermsToClaimTitle)
-        .setDescription(
-          msgconfig.Ticket.ClaimTickets.NoPermsToClaim.replace("%channel%", ticketChannel.name)
-        )
-        .setColor(supportbot.Embed.Colours.Error);
-
-      if (!interaction.member.roles.cache.has(Staff.id) && !interaction.member.roles.cache.has(Admin.id)) {
-        return interaction.reply({
-          embeds: [NoPermsClaim],
-          ephemeral: true,
-        });
-      }
-
-      if (supportbot.Ticket.TicketType === "threads") {
-        await ticketChannel.members.add(interaction.user.id); 
-
-    } else if (supportbot.Ticket.TicketType === "channels") {
-        await ticketChannel.permissionOverwrites.create(interaction.user.id, {
-            ViewChannel: true,
-            SendMessages: true,
-            ReadMessageHistory: true,
-        }); 
-
-        await ticketChannel.permissionOverwrites.create(Admin, {
-            ViewChannel: true,
-            SendMessages: true,
-            ReadMessageHistory: true,
-        }); 
-
-        await ticketChannel.permissionOverwrites.create(interaction.guild.roles.everyone, {
-          ViewChannel: false,
-        }); 
-    }
-    
-      const pingclaimedstaff = await ticketChannel.send(`<@${interaction.user.id}>`);
-
-      setTimeout(() => {
-        pingclaimedstaff.delete();
-      }, 2000);
-
-      const TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-      const ticketIndex = TicketData.tickets.findIndex((t) => t.id === ticketChannelId);
-      if (ticketIndex !== -1) {
-        TicketData.tickets[ticketIndex].claimedBy = interaction.user.id;
-        TicketData.tickets[ticketIndex].claimedAt = new Date().toISOString();
-        fs.writeFileSync("./Data/TicketData.json", JSON.stringify(TicketData, null, 4));
-      }
-
-      const claimMessage = await interaction.message.fetch();
-      const claimedEmbed = new Discord.EmbedBuilder(claimMessage.embeds[0].data)
-        .setTitle(msgconfig.Ticket.ClaimTickets.ClaimedTitle)
-        .setDescription(
-          msgconfig.Ticket.ClaimTickets.ClaimMessage_Edit.replace("%user%", interaction.user.id).replace("%channel%", ticketChannel.id)
-        )
-        .setColor(supportbot.Embed.Colours.Success);
-
-      const successfullyClaimed = new Discord.EmbedBuilder()
-        .setTitle(msgconfig.Ticket.ClaimTickets.ClaimedTitle)
-        .setDescription(msgconfig.Ticket.ClaimTickets.Claimed.replace("%channel%", ticketChannel.id))
-        .setColor(supportbot.Embed.Colours.Success);
-
-      await claimMessage.edit({ embeds: [claimedEmbed], components: [] });
-      await interaction.reply({
-        embeds: [successfullyClaimed],
-        ephemeral: true,
-      });
-    }
-
-    // SUGGESTION INTERACTIONS [START]
-
-    if (
-      interaction.customId === "upvote" ||
-      interaction.customId === "downvote" ||
-      interaction.customId === "removevote"
-    ) {
-      const suggestion = suggestions[interaction.message.id];
-      if (!suggestion)
-        return interaction.reply({ content: "Suggestion not found.", ephemeral: true });
-
-      const userId = interaction.user.id;
-      const hasUpvoted = suggestion.upvotes.includes(userId);
-      const hasDownvoted = suggestion.downvotes.includes(userId);
-
-      if (interaction.customId === "upvote") {
-        if (hasUpvoted) {
-          suggestion.upvotes = suggestion.upvotes.filter((id) => id !== userId);
-        } else {
-          suggestion.upvotes.push(userId);
-          if (hasDownvoted) {
-            suggestion.downvotes = suggestion.downvotes.filter((id) => id !== userId);
+        await interaction.channel.permissionOverwrites.create(
+          interaction.guild.id,
+          {
+            VIEW_CHANNEL: false,
           }
-        }
-      } else if (interaction.customId === "downvote") {
-        if (hasDownvoted) {
-          suggestion.downvotes = suggestion.downvotes.filter((id) => id !== userId);
-        } else {
-          suggestion.downvotes.push(userId);
-          if (hasUpvoted) {
-            suggestion.upvotes = suggestion.upvotes.filter((id) => id !== userId);
-          }
-        }
-      } else if (interaction.customId === "removevote") {
-        suggestion.upvotes = suggestion.upvotes.filter((id) => id !== userId);
-        suggestion.downvotes = suggestion.downvotes.filter((id) => id !== userId);
-      }
-
-      fs.writeFileSync("./Data/SuggestionData.json", JSON.stringify(suggestions, null, 2));
-
-      const upvoteCount = suggestion.upvotes.length;
-      const downvoteCount = suggestion.downvotes.length;
-
-      const updatedEmbed = new Discord.EmbedBuilder(interaction.message.embeds[0].data).setFields([
-        { name: "Suggestion", value: suggestion.suggestion, inline: true },
-        { name: "From", value: `<@${suggestion.author}>` },
-        {
-          name: `${supportbot.Suggestions.UpvoteEmoji} ${supportbot.Suggestions.UpvoteTitle}`,
-          value: `${upvoteCount}`,
-          inline: true,
-        },
-        {
-          name: `${supportbot.Suggestions.DownvoteEmoji} ${supportbot.Suggestions.DownvoteTitle}`,
-          value: `${downvoteCount}`,
-          inline: true,
-        },
-      ]);
-
-      await interaction.update({ embeds: [updatedEmbed] });
-    }
-
-  }
-
-  async function handleInvites(interaction, enable) {
-    if (supportbot.Ticket.Invites.StaffOnly) {
-      const { getRole, getChannel } = interaction.client;
-      const SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
-      const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
-
-      if (!SupportStaff || !Admin) {
-        return interaction.reply(
-          "Some roles seem to be missing!\nPlease check for errors when starting the bot."
-        );
-      }
-
-      const NoPerms = new Discord.EmbedBuilder()
-        .setTitle("Invalid Permissions!")
-        .setDescription(
-          `${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``
-        )
-        .setColor(supportbot.Embed.Colours.Warn);
-
-      if (
-        !interaction.member.roles.cache.has(SupportStaff.id) &&
-        !interaction.member.roles.cache.has(Admin.id)
-      ) {
-        return interaction.reply({ embeds: [NoPerms] });
-      }
-    }
-
-    await interaction.channel.setInvitable(enable);
-
-    const message = enable ? msgconfig.Ticket.EnableInvites : msgconfig.Ticket.DisableInvites;
-    const embed = new Discord.EmbedBuilder().setDescription(message).setColor(supportbot.Embed.Colours.General);
-
-    await interaction.reply({
-      embeds: [embed],
-      ephemeral: true,
-    });
-  }
-
-  // Modal submission handler for editing profile
-  if (interaction.type === Discord.InteractionType.ModalSubmit && interaction.customId === "editProfileModal") {
-    const userId = interaction.user.id;
-    const profilePath = `./Data/Profiles/${userId}.json`;
-
-    let profileData;
-    if (fs.existsSync(profilePath)) {
-      profileData = JSON.parse(fs.readFileSync(profilePath, "utf8"));
-    } else {
-      profileData = {
-        bio: "",
-        timezone: "",
-        clockedIn: false,
-      };
-    }
-
-    try {
-      const newBio = interaction.fields.getTextInputValue("bio");
-      const newTimezone = interaction.fields.getTextInputValue("timezone");
-
-      profileData.bio = newBio;
-      profileData.timezone = newTimezone;
-
-      fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
-
-      const updatedProfileEmbed = new Discord.EmbedBuilder()
-        .setTitle(`${interaction.user.username}'s Profile`)
-        .setColor(supportbot.Embed.Colours.General)
-        .setThumbnail(interaction.user.displayAvatarURL())
-        .addFields(
-          { name: "Bio", value: newBio || "No bio set.", inline: false },
-          { name: "Timezone", value: newTimezone || "No timezone set.", inline: true }
         );
 
-      if (profileData.clockedIn !== undefined) {
-        updatedProfileEmbed.addFields({
-          name: "Clocked In Status",
-          value: profileData.clockedIn ? "✅ Clocked In" : "❌ Clocked Out",
-          inline: true,
-        });
-      }
+        const ticketDeleteButton = new Discord.MessageButton()
+          .setCustomId("ticketclose")
+          .setLabel("Close")
+          .setStyle(supportbot.TicketDeleteColour)
+          .setEmoji(supportbot.TicketDeleteEmoji);
 
-      await interaction.reply({ embeds: [updatedProfileEmbed], ephemeral: true });
-    } catch (error) {
-      console.error("Failed to update profile data: ", error);
-      await interaction.reply({
-        content: "There was an error while updating your profile. Please try again later.",
-        ephemeral: true,
-      });
+        const row = new Discord.MessageActionRow().addComponents(
+          ticketDeleteButton
+        );
+        const ArchiveEmbed = new Discord.MessageEmbed()
+          .setTitle("Archived")
+          .setDescription(`Archived ${interaction.channel.name}`)
+          .setColor(supportbot.SuccessColour);
+
+        interaction.reply({ embeds: [ArchiveEmbed] });
+        interaction.message.edit({ components: [row] });
+      }
     }
-  }
-});
+    if (interaction.customId === "ticketclaim") {
+      if (interaction.channel.name.startsWith(supportbot.TicketPrefix)) {
+        const Staff = await interaction.client.getRole(supportbot.Staff, interaction.guild);
+        interaction.message.fetch();
+        let User = interaction.guild.members.cache.get(interaction.user.id);
+        let Admin =
+          interaction.guild.roles.cache.find(
+            (AdminUser) => AdminUser.name === supportbot.Admin
+          ) ||
+          interaction.guild.roles.cache.find(
+            (AdminUser) => AdminUser.id === supportbot.Admin
+          );
+        if (!interaction.member.roles.cache.has(Admin.id)) {
+          return await interaction.reply({
+            content: "You don't have permission to do that.",
+            ephemeral: true,
+          });
+        }
+        let all = interaction.channel.permissionOverwrites.cache;
+ 
+        const ArchiveEmbed = new Discord.MessageEmbed()
+          .setTitle(supportbot.TicketClaimTitle)
+          .setDescription(supportbot.TicketClaimMessage + " <@" + interaction.user.id + ">")
+          .setColor(supportbot.EmbedColour);
+
+        interaction.reply({ embeds: [ArchiveEmbed] });
+        await interaction.channel.permissionOverwrites.edit(Staff.id, {
+               VIEW_CHANNEL: true,
+               SEND_MESSAGES: false,
+           });   
+      }
+        await interaction.channel.permissionOverwrites.edit(interaction.user.id, {
+               VIEW_CHANNEL: true,
+               SEND_MESSAGES: true,
+           });   
+      }
+    }
+  });

Events/messageCreate.js

@@ -1,166 +0,0 @@
-const fs = require("fs");
-const Discord = require("discord.js");
-const yaml = require("js-yaml");
-const axios = require("axios");
-const { OpenAI } = require('openai');
-
-// Load configuration files with validation
-function loadConfig(path) {
-    try {
-        return yaml.load(fs.readFileSync(path, "utf8"));
-    } catch (error) {
-        console.error(`Error loading config file at ${path}:`, error);
-        throw error;
-    }
-}
-
-const supportbotai = yaml.load(fs.readFileSync("./Configs/supportbot-ai.yml"));
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
-// Validate configuration values
-function validateConfig(config, keys) {
-    keys.forEach(key => {
-        if (!config[key]) {
-            throw new Error(`Missing configuration key: ${key}`);
-        }
-    });
-}
-
-const CHANNELS = [supportbotai.Channels.AIChannel];
-
-// Initialize Discord client
-const client = new Discord.Client({
-    intents: ['Guilds', 'GuildMembers', 'GuildMessages']
-});
-
-// Load custom Event structure
-const Event = require("../Structures/Event.js");
-
-// Initialize OpenAI client
-const openai = new OpenAI({
-    apiKey: supportbotai.General.OpenAI_Key,
-});
-
-const PASTEBIN_API_KEY = supportbotai.General.PastebinAPI_Key;
-const PASTEBIN_API_URL = supportbotai.General.PastebinAPI_URL;
-
-// Function to create a paste on Pastebin
-async function createPaste(content) {
-    try {
-        const response = await axios.post(PASTEBIN_API_URL, new URLSearchParams({
-            api_dev_key: PASTEBIN_API_KEY,
-            api_option: 'paste',
-            api_paste_code: content,
-            api_paste_private: 1, // 0 = public, 1 = unlisted, 2 = private
-            api_paste_expire_date: '1D', // Expire in 1 day
-            api_paste_format: 'text'
-        }));
-        return response.data;
-    } catch (error) {
-        console.error('Pastebin Error:', error);
-        throw error;
-    }
-}
-
-// Event handler for message creation
-module.exports = new Event("messageCreate", async (client, message) => {
-    if (message.author.bot || !message.guild) return;
-    if (!CHANNELS.includes(message.channelId) && !message.mentions.users.has(client.user.id)) return;
-
-if (supportbotai.Enabled) {
-
-    const sendTypingInterval = setInterval(() => {
-        message.channel.sendTyping();
-    }, 5000);
-
-    let conversation = [{
-        role: "system",
-        content: "SupportBot is your friendly neighbourhood support bot."
-    }];
-
-    let prevMessages = await message.channel.messages.fetch({ limit: 10 });
-    prevMessages = prevMessages.reverse().filter(msg => !msg.author.bot || msg.author.id === client.user.id);
-
-    prevMessages.forEach((msg) => {
-        const username = msg.author.username.replace(/\s+/g, '_').replace(/[^\w\s]/gi, '');
-
-        conversation.push({
-            role: msg.author.id === client.user.id ? "assistant" : "user",
-            name: username,
-            content: msg.content,
-        });
-    });
-
-    try {
-        const response = await openai.chat.completions.create({
-            model: supportbotai.General.Model,
-            messages: conversation,
-            max_tokens: supportbotai.General.Tokens,
-        });
-
-        clearInterval(sendTypingInterval);
-
-        if (response.choices && response.choices.length > 0) {
-            const replyContent = response.choices[0].message.content;
-
-            const SupportBotAI = new Discord.EmbedBuilder()
-                .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
-                .setDescription(replyContent)
-                .setColor(supportbotai.Embed.Color)
-                .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
-                .setTimestamp();
-
-            if (replyContent.length > 2000) {
-                const pasteLink = await createPaste(replyContent);
-
-                const SupportBotAIPastebin = new Discord.EmbedBuilder()
-                    .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
-                    .setDescription(supportbotai.Messages.MessageTooLong.replace("{pastebin}", pasteLink))
-                    .setColor(supportbotai.Embed.Color)
-                    .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
-                    .setTimestamp();
-
-                message.reply({ embeds: [SupportBotAIPastebin] });
-            } else {
-                message.reply({ embeds: [SupportBotAI] });
-            }
-        } else {
-            const SupportBotAIErrorResponse = new Discord.EmbedBuilder()
-                .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
-                .setDescription(supportbotai.Messages.ErrorResponse)
-                .setColor(supportbotai.Embed.Color)
-                .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
-                .setTimestamp();
-
-            message.reply({ embeds: [SupportBotAIErrorResponse], ephemeral: true });
-        }
-    } catch (error) {
-        clearInterval(sendTypingInterval);
-
-        const SupportBotAIErrorResponse = new Discord.EmbedBuilder()
-            .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
-            .setDescription(supportbotai.Messages.OpenAIError)
-            .setColor(supportbot.Embed.Colours.Error)
-            .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
-            .setTimestamp();
-
-        console.error('OpenAI Error:', error);
-        message.reply({ embeds: [SupportBotAIErrorResponse], ephemeral: true });
-    }
-
-}
-
-if (supportbotai.Enabled === false) {
-    const AIDisabled = new Discord.EmbedBuilder()
-        .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
-        .setDescription(supportbotai.Messages.AIDisabled)
-        .setColor(supportbot.Embed.Colours.Error)
-        .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
-        .setTimestamp();
-
-    message.reply({ embeds: [AIDisabled], ephemeral: true })
-    return;
-}
-
-});

Events/messageDelete.js

@@ -1,43 +0,0 @@
-const { EmbedBuilder } = require('discord.js');
-const fs = require("fs");
-const yaml = require("js-yaml");
-const Event = require("../Structures/Event.js");
-
-// Load the configuration files
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
-
-module.exports = new Event("messageDelete", async (client, message) => {
-
-    // Check if the message is from a guild and not from a bot
-    if (!message.guild || message.author.bot) return;
-
-    // Get the delete log channel either by ID or by name
-    const deleteLogChannel = message.guild.channels.cache.get(supportbot.MessageDelete.Channel) ||
-        message.guild.channels.cache.find(channel => channel.name === supportbot.MessageDelete.Channel);
-
-    // Create the embed for the deleted message
-    const deletedMessageEmbed = new EmbedBuilder()
-        .setColor(supportbot.MessageDelete.Colour)
-        .setTitle("Message Deleted")
-        .setDescription(`> **Channel:** <#${message.channel.id}>\n> **Message ID** [${message.id}](https://discord.com/channels/${message.guild.id}/${message.channel.id}/${message.id})\n> **Message author:** ${message.author.tag} (${message.author.id})\n> **Message Crated:** <t:${Math.floor(message.createdTimestamp / 1000)}:F>`)
-        .addFields(
-            { name: 'Message', value: message.content || '*No content*', inline: false }
-        )
-        .setThumbnail(message.author.displayAvatarURL())
-        .setTimestamp();
-
-    // If the message contains an attachment, add it to the embed
-    if (message.attachments.size > 0) {
-        const attachment = message.attachments.first();
-        deletedMessageEmbed.addFields({ name: 'Attachment', value: `[${attachment.name}](${attachment.proxyURL})` });
-    }
-
-    // Send the embed to the delete log channel if the channel is found
-    if (deleteLogChannel) {
-        deleteLogChannel.send({
-            embeds: [deletedMessageEmbed]
-        });
-    }
-});
-

Events/messageUpdate.js

@@ -1,57 +0,0 @@
-const { EmbedBuilder } = require('discord.js');
-const fs = require("fs");
-const yaml = require("js-yaml");
-const Event = require("../Structures/Event.js");
-
-// Load the configuration files
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
-
-module.exports = new Event("messageUpdate", async (client, oldMessage, newMessage) => {
-
-    // Check if the message is from a guild and not from a bot
-    if (!newMessage.guild || newMessage.author.bot) return;
-
-    // Fetch old message if it's not cached (important for message content)
-    if (!oldMessage.content && oldMessage.partial) {
-        try {
-            oldMessage = await oldMessage.fetch();
-        } catch (err) {
-            console.error('Error fetching old message:', err);
-            return;
-        }
-    }
-
-    // Fallback if content is missing
-    const oldMessageContent = oldMessage.content || (oldMessage.attachments.size > 0 ? 'Contains attachment(s)' : '*No content*');
-    const newMessageContent = newMessage.content || (newMessage.attachments.size > 0 ? 'Contains attachment(s)' : '*No content*');
-
-    // Get the update log channel either by ID or by name
-    const updateLogChannel = newMessage.guild.channels.cache.get(supportbot.MessageUpdate.Channel) ||
-        newMessage.guild.channels.cache.find(channel => channel.name === supportbot.MessageUpdate.Channel);
-
-    // Create the embed for the updated message
-    const updatedMessageEmbed = new EmbedBuilder()
-        .setColor(supportbot.MessageUpdate.Colour)
-        .setTitle("Message Updated")
-        .setDescription(`> **Channel:** <#${newMessage.channel.id}>\n> **Message ID:** [${newMessage.id}](https://discord.com/channels/${newMessage.guild.id}/${newMessage.channel.id}/${newMessage.id})\n> **Message author:** ${newMessage.author.tag} (${newMessage.author.id})\n> **Message Created:** <t:${Math.floor(oldMessage.createdTimestamp / 1000)}:F>`)
-        .addFields(
-            { name: 'Old Message', value: oldMessageContent, inline: false },
-            { name: 'New Message', value: newMessageContent, inline: false }
-        )
-        .setThumbnail(newMessage.author.displayAvatarURL())
-        .setTimestamp();
-
-    // If the new message contains an attachment, add it to the embed
-    if (newMessage.attachments.size > 0) {
-        const attachment = newMessage.attachments.first();
-        updatedMessageEmbed.addFields({ name: 'Attachment', value: `[${attachment.name}](${attachment.proxyURL})` });
-    }
-
-    // Send the embed to the update log channel if the channel is found
-    if (updateLogChannel) {
-        updateLogChannel.send({
-            embeds: [updatedMessageEmbed]
-        });
-    }
-});

Events/ready.js

@@ -4,11 +4,7 @@
 const fs = require("fs");
 
 const Discord = require("discord.js");
-const { Client, GatewayIntentBits, ActivityType } = require('discord.js');
-const client = new Discord.Client({intents: 32767})
-
 const yaml = require("js-yaml");
-
 const supportbot = yaml.load(
   fs.readFileSync("./Configs/supportbot.yml", "utf8")
 );
@@ -16,107 +12,103 @@ const panelconfig = yaml.load(
   fs.readFileSync("./Configs/ticket-panel.yml", "utf8")
 );
 
-const cmdconfig = yaml.load(
-  fs.readFileSync("./Configs/commands.yml", "utf8")
-);
-
-const msgconfig = yaml.load(
-  fs.readFileSync("./Configs/messages.yml", "utf8")
-);
-
 const Event = require("../Structures/Event.js");
 
-let chan1 = client.channels.cache.get(supportbot.Ticket.TicketHome);
-
 module.exports = new Event("ready", async (client, interaction) => {
   const { getRole, getChannel, getCategory } = client;
+  client.user.setActivity(supportbot.BotActivity, {
+    type: supportbot.ActivityType,
+    url: supportbot.StreamingURL,
+  });
 
-  if (supportbot.Activity.Type === "Playing", "playing") {
-    client.user.setPresence({
-      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Playing }],
-      status: supportbot.Activity.Type,
-    });
-  }
+  console.log(`\u001b[36m`, `――――――――――――――――――――――――――――――――――――――――――――`);
+  console.log(`\u001b[91m`, `┏━━━┓╋╋╋╋╋╋╋╋╋╋╋╋╋┏┓┏━━┓╋╋╋┏┓`);
+  console.log(`\u001b[91m`, `┃┏━┓┃╋╋╋╋╋╋╋╋╋╋╋╋┏┛┗┫┏┓┃╋╋┏┛┗┓`);
+  console.log(`\u001b[91m`, `┃┗━━┳┓┏┳━━┳━━┳━━┳┻┓┏┫┗┛┗┳━┻┓┏┛`);
+  console.log(`\u001b[91m`, `┗━━┓┃┃┃┃┏┓┃┏┓┃┏┓┃┏┫┃┃┏━┓┃┏┓┃┃`);
+  console.log(`\u001b[91m`, `┃┗━┛┃┗┛┃┗┛┃┗┛┃┗┛┃┃┃┗┫┗━┛┃┗┛┃┗┓`);
+  console.log(`\u001b[91m`, `┗━━━┻━━┫┏━┫┏━┻━━┻┛┗━┻━━━┻━━┻━┛`);
+  console.log(`\u001b[91m`, `┗╋╋╋╋╋╋╋┃┃╋┃┃`);
+  console.log(`\u001b[91m`, `╋╋╋╋╋╋╋┗┛╋┗┛`);
+  console.log(`    `);
+  console.log(`\u001b[36m`, `――――――――――――――――――――――――――――――――――――――――――――`);
+  console.log(`    `);
+  console.log(
+    `\u001b[33m`,
+    `${supportbot.Name} | ${supportbot.SupportBot_Version}`,
+    `\u001b[36m`,
+    `Connected to Discord`
+  );
+  console.log(
+    `\u001b[33m`,
+    `Invite to your server:`,
+    `\u001b[36m`,
+    `https://discord.com/api/oauth2/authorize?client_id=` +
+      client.user.id +
+      `&permissions=8&scope=bot%20applications.commands`
+  );
+  console.log(
+    `\u001b[33m`,
+    `Resources:`,
+    `\u001b[36m`,
+    `https://emeraldsrv.dev/resources`
+  );
+  console.log(
+    `\u001b[33m`,
+    `Documentation:`,
+    `\u001b[36m`,
+    `https://emeraldsrv.dev/wiki/supportbot`
+  );
+  console.log(
+    `\u001b[33m`,
+    `Discord:`,
+    `\u001b[36m`,
+    `https://emeraldsrv.dev/discord`
+  );
+  console.log(
+    `\u001b[33m`,
+    `Hosting:`,
+    `\u001b[36m`,
+    `https://emeraldsrv.dev/hosting`
+  );
+  console.log(`    `);
+  console.log(`\u001b[37m`, `SupportBot proudly created by Emerald Services`);
+  console.log(`    `);
+  console.log(`\u001b[31m`, `――――――――――――――――――――――――――――――――――――――――――――`);
 
-  if (supportbot.Activity.Type === "Watching", "watching") {
-    client.user.setPresence({
-      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Watching }],
-      status: supportbot.Activity.Type,
-    });
-  }
-  
-  if (supportbot.Activity.Type === "Listening", "listening") {
-    client.user.setPresence({
-      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Listening }],
-      status: supportbot.Activity.Type,
-    });
-  }
 
-  if (supportbot.Activity.Type === "Competing", "competing") {
-    client.user.setPresence({
-      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Competing }],
-      status: supportbot.Activity.Type,
-    });
-  }
 
-  console.log(`\u001b[33m`, `――――――――――――――――――――――――――――――――――――――――――――`);
-  console.log(`    `);
-  console.log(`\u001b[31m`, `┏━━━┓╋╋╋╋╋╋╋╋╋╋╋╋╋┏┓┏━━┓╋╋╋┏┓`);
-  console.log(`\u001b[31m`, `┃┏━┓┃╋╋╋╋╋╋╋╋╋╋╋╋┏┛┗┫┏┓┃╋╋┏┛┗┓`);
-  console.log(`\u001b[31m`, `┃┗━━┳┓┏┳━━┳━━┳━━┳┻┓┏┫┗┛┗┳━┻┓┏┛`);
-  console.log(`\u001b[31m`, `┗━━┓┃┃┃┃┏┓┃┏┓┃┏┓┃┏┫┃┃┏━┓┃┏┓┃┃`);
-  console.log(`\u001b[31m`, `┃┗━┛┃┗┛┃┗┛┃┗┛┃┗┛┃┃┃┗┫┗━┛┃┗┛┃┗┓`);
-  console.log(`\u001b[31m`, `┗━━━┻━━┫┏━┫┏━┻━━┻┛┗━┻━━━┻━━┻━┛`);
-  console.log(`\u001b[31m`, `┗╋╋╋╋╋╋╋┃┃╋┃┃`);
-  console.log(`\u001b[31m`, `╋╋╋╋╋╋╋┗┛╋┗┛`);
-  console.log(`    `);
-  console.log(`\u001b[33m`, `――――――――――――――――――――――――――――――――――――――――――――`);
-  console.log(`    `);  
-  console.log(`\u001b[33m`, `${supportbot.General.Name} | [${supportbot.SupportBot_Version}]`, `\u001b[32m`, `Connected to Discord`,);
-  console.log("\u001b[32m", "SupportBot created by Emerald Development ");
-  console.log(`    `);
-  console.log(`\u001b[33m`, `――――――――――――――――― [Links] ――――――――――――――――――`);
-  console.log("\u001b[32m", "Discord: https://dsc.gg/emerald-dev");
-  console.log("\u001b[32m", "Website: https://emeraldsrv.com");
-  console.log("\u001b[32m", "Community: https://community.emeraldsrv.com");
-  console.log("\u001b[32m", "Documentation: https://docs.emeraldsrv.com");
-  console.log(`    `);
-  console.log(`\u001b[33m`, `――――――――――――――――― [Invite] ――――――――――――――――――`);
-  console.log("\u001b[32m", `Invite URL: https://discord.com/api/oauth2/authorize?client_id=${client.user.id}&permissions=8&scope=bot%20applications.commands`);
-  console.log(`    `);
-  console.log(`\u001b[33m`, `――――――――――――――――― [Config Check] ――――――――――――――――――`);
-  console.log("\u001b[32m", "Config initialization...");
 
   const roles = [
-    supportbot.Roles.StaffMember.Admin,
-    supportbot.Roles.StaffMember.Staff
+    supportbot.Admin,
+    supportbot.Staff,
+    supportbot.TicketBlackListRole,
   ];
 
-  if (supportbot.Roles.AutoRole.Role) roles.push(supportbot.Roles.AutoRole.Role);
-  
-   const channels = [
-     supportbot.Suggestions.Channel,
-     supportbot.Ticket.Log.TicketLog,
-     supportbot.Ticket.Log.TranscriptLog,
-     supportbot.Ticket.TicketHome,
-     supportbot.Welcome.Channel,
-     supportbot.Leave.Channel,
-     supportbot.Translate.Log
-   ];
-  //const categories = [supportbot.TicketCategory];
+    supportbot.Departments.forEach((department) => roles.push(department.role));
 
-  if (!channels) {
-      console.log("\u001b[31m", `[MISSING CHANNEL]`, `\u001b[37;1m`, `${channels}`, "\u001b[31m", `channel not found. Please check your config file.`);
-      return;
-  }
-//  else {
-//      console.log(`\u001b[32m`, `[CHANNEL LOCATED]`, `\u001b[37;1m`, `${channels}`, `\u001b[32;1m`, `channel has been found.`);
-//  }
+  if (supportbot.AutoRole) roles.push(supportbot.JoinRole);
+  const channels = [
+    supportbot.SuggestionChannel,
+    supportbot.TicketLog,
+    supportbot.TranscriptLog,
+    panelconfig.Channel,
+    supportbot.WelcomeChannel,
+    supportbot.LeaveChannel,
+    supportbot.TranslateLogChannel
+  ];
+  //const categories = [supportbot.TicketCategory];
 
   const missingC = [];
   const missingR = [];
   const missingCat = [];
-  
+  for (let c of channels) {
+    if ((c === supportbot.SuggestionChannel && supportbot.DisableSuggestionsChannel) || c === supportbot.TicketLog && supportbot.DisableTicketLogChannel) {
+      continue;
+    }
+    const find = await getChannel(c, client.guilds.cache.first());
+    if (!find) missingC.push(c);
+  }
   for (let r of roles) {
     const find = await getRole(r, client.guilds.cache.first());
     if (!find) missingR.push(r);
@@ -126,18 +118,100 @@ module.exports = new Event("ready", async (client, interaction) => {
  //   if (!find) missingCat.push(cat);
  // }
 
- const missingRoles = await Promise.all(roles.map(role => getRole(role, client.guilds.cache.first())));
- const missingChannels = await Promise.all(channels.map(channel => getChannel(channel, client.guilds.cache.first())));
-
- if (missingRoles.some(role => !role)) {
-  console.log("\u001b[31m", `Missing roles in your server configuration: ${missingRoles.filter(role => !role).join(', ')}`);
+  if (missingR.length > 0) {
+    console.log(
+      "\u001b[33m",
+      `[WARN] The following Roles could not be found! Please check your configs!\n${missingR.join(
+        ", "
+      )}`
+    );
   }
 
-  if (missingChannels.some(channel => !channel)) {
-  console.log("\u001b[31m", `Missing channels in your server configuration: ${missingChannels.filter(channel => !channel).join(', ')}`);
+  if (missingC.length > 0) {
+    console.log(
+      "\u001b[33m",
+      `[WARN] The following Channels could not be found! Please check your configs!\n${missingC.join(
+        ", "
+      )}`
+    );
   }
+  if (missingCat.length > 0) {
+    console.log(
+      "\u001b[33m",
+      `[WARN] The following Categories could not be found! Please check your configs!\n${missingCat.join(
+        ", "
+      )}`
+    );
+  }
+  if (panelconfig.TicketPanel) {
+    let chan1 = await client.getChannel(
+      panelconfig.Channel,
+      client.guilds.cache.first()
+    );
 
-  console.log("\u001b[32m", "Configs initialized, No problems were detected.");
-  console.log(`    `);
+    if (!chan1) {
+      console.log(
+        "\u001b[33m",
+        "[WARN] Ticket reaction panel is not setup, You can do so via the configuration file!"
+      );
+      return false;
+    }
 
-});
+    const panelid = JSON.parse(
+      fs.readFileSync("./Data/ticket-panel-id.json", "utf8")
+    );
+
+    chan1.messages.fetch(panelid.TicketPanelID).catch(async () => {
+      let embed = new Discord.MessageEmbed()
+        .setTitle(panelconfig.PanelTitle)
+        .setColor(panelconfig.PanelColour)
+        .setFooter({
+          text: supportbot.EmbedFooter,
+          iconURL: interaction.user.displayAvatarURL(),
+        });
+
+      if (panelconfig.TicketPanel_Description) {
+        embed.setDescription(panelconfig.PanelMessage);
+      }
+
+      if (panelconfig.TicketPanel_Thumbnail) {
+        embed.setThumbnail(panelconfig.PanelThumbnail);
+      }
+
+      if (panelconfig.TicketPanel_Image) {
+        embed.setImage(panelconfig.PanelImage);
+      }
+      let button;
+
+        button = supportbot.Departments.map((x) =>
+          new Discord.MessageButton()
+            .setCustomId("department-" + supportbot.Departments.indexOf(x))
+            .setLabel(x.title)
+            .setStyle(x.color)
+            .setEmoji(x.emoji)
+        );
+
+      let row = new Discord.MessageActionRow().addComponents(button);
+
+      await chan1
+        .send({
+          embeds: [embed],
+          components: [row],
+        })
+        .then((r) => {
+          let data = {
+            id: panelid.id,
+            TicketPanelID: r.id,
+          };
+          fs.writeFileSync(
+            "./Data/ticket-panel-id.json",
+            JSON.stringify(data),
+            "utf8"
+          );
+        })
+        .catch((e) => {
+          console.log("Raw: " + e);
+        });
+    });
+  }
+});

LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Emerald Services
+Copyright (c) 2022 Emerald Services
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,6 +1,6 @@
 <h1 align="center">
     <br>
-    <a href="https://github.com/Emerald-Services/SupportBot"><img src="https://i.imgur.com/cuadAYv.png"></a>
+    <a href="https://github.com/Emerald-Services/SupportBot"><img src="https://i.imgur.com/tzi3d7Q.png"></a>
     <br>
     SupportBot
     <br>
@@ -13,33 +13,21 @@
 </a>
 
 <a href="https://github.com/discordjs">
-    <img src="https://img.shields.io/badge/DISCORD.JS%20-%20v14-blue?style=for-the-badge" alt="shield.png">
+    <img src="https://img.shields.io/badge/discord.js-v13.6.x-blue.svg?style=for-the-badge&logo=javascript.svg" alt="shield.png">
 </a>
 
 <a href="https://github.com/nodejs/node">
-    <img src="https://img.shields.io/badge/NODE.JS%20-%20v20.x-green?style=for-the-badge" alt="shield.png">
+    <img src="https://img.shields.io/badge/node.js-v16.14.x-green.svg?style=for-the-badge&logo=node" alt="shield.png">
 </a>
 
 <a href="https://github.com/Emerald-Services/SupportBot/releases">
     <img src="https://img.shields.io/github/downloads/Emerald-Services/SupportBot/total?style=for-the-badge" alt="shield.png">
 </a>
 
-## Supported Versions
-
-| SupportBot | Node.JS | Discord.JS |  Supported |
-|------------|---------|------------|------------|
-|    8.x     |   20.x  |    14.x.   | ✅ Yes
-|    7.7.3   |   16.x  |    13.x.   | ✅ Yes
-|    7.x     |   16.x  |    13.x.   | ❌ No
-|    6.x     |   14.x  |    13.x.   | ❌ No
-|    5.x     |   12.x  |    13.x.   | ❌ No
-|    4.x     |   11.x  |    13.x.   | ❌ No
-|    Older   | 10.x    |    13.x.   | ❌ No
-
 </div>
 
 <p align="center">
-  <a href="https://emeraldsrv.com/">Website</a>
+  <a href="https://emeraldsrv.dev/">Website</a>
   •
   <a href="https://github.com/Emerald-Services/SupportBot/wiki">Wiki</a>
 <br>
@@ -60,7 +48,7 @@ SupportBot is an Open-Source discord bot built with [discord.js](https://github.
 
 ## Support
 
-<a href="https://emeraldsrv.com/discord">
+<a href="https://emeraldsrv.dev/discord">
     <img alt="Discord" src="https://img.shields.io/discord/597779408295821323?logo=discord&logoColor=white&style=for-the-badge">
 </a>
 
@@ -72,7 +60,6 @@ Released under the [MIT](https://opensource.org/licenses/MIT) license.
 
 ## Third-Party
 
-- [Official addons repository](https://github.com/Emerald-Services/Addons/)
 - [Syphers Addons](https://github.com/SypherRed/SB_Addons_Unofficial)
 - [BuiltByBit](https://builtbybit.com/supportbot)
 - [Polymart](https://polymart.org/resource/supportbot-1-discord-ticket-bot.518)
@@ -84,13 +71,5 @@ Released under the [MIT](https://opensource.org/licenses/MIT) license.
   <img src="https://contrib.rocks/image?repo=Emerald-Services/SupportBot">
 </a>
 
-## Hosting
-
-You can use our [Pterodactyl egg](https://github.com/Emerald-Services/Pterodactyl-Egg) to host it on your own panel. We currently don't offer hosting for you, altough we might add this in the future.
-If you don't know how to install pterodactyl, you could always host it on replit:
-
-[![Run on Repl.it](https://repl.it/badge/github/ItsNyoty/IKI-bot)]([https://repl.it/github/ItsNyoty/iki](https://repl.it/github/Emerald-Services/SupportBot
-)
-
 
 

SECURITY.md

@@ -1,20 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Use this section to tell people about which versions of your project are
-currently being supported with security updates.
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 7.7.2   | :white_check_mark: |
-| 7.7.1   | :white_check_mark: |
-| < 4.0   | :x:                |
-
-## Reporting a Vulnerability
-
-Use this section to tell people how to report a vulnerability.
-
-Tell them where to go, how often they can expect to get an update on a
-reported vulnerability, what to expect if the vulnerability is accepted or
-declined, etc.

Structures/Addon.js

@@ -1,6 +1,6 @@
-
 // SupportBot | Emerald Services
 // Addon Structure
+
 class Command {
   constructor(options) {
     this.name = options.name;
@@ -10,13 +10,7 @@ class Command {
     this.run = options.run;
     this.defaultPermission = true;
   }
-
-  // Method to dynamically update options
-  setOptions(options) {
-    this.options = options;
-  }
 }
-
 class Event {
   constructor(event, run) {
     this.event = event;

Structures/Client.js

@@ -1,190 +1,117 @@
-const fs = require("fs");
-const Discord = require("discord.js");
-const { GatewayIntentBits, Partials } = require('discord.js');
-const yaml = require("js-yaml");
-const { Command, Event } = require('./Addon.js'); // Adjust the path as needed
+// SupportBot | Emerald Services
+// Client Structure
 
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const intents = new Discord.Intents(32767);
+
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
 
 class Client extends Discord.Client {
   constructor() {
-    super({
-      intents: [
-        GatewayIntentBits.Guilds,
-        GatewayIntentBits.GuildMembers,
-        GatewayIntentBits.GuildMessages,
-        GatewayIntentBits.MessageContent
-      ],
-      partials: [Partials.Message, Partials.Channel]
-    });
+    super({ intents });
 
     this.commands = new Discord.Collection();
   }
-
   async getChannel(channel, guild) {
-    if (!channel) return null; // Add check for undefined channel
     return guild.channels.cache.find(
       (c) =>
-        (c.type === Discord.ChannelType.GuildText || c.type === Discord.ChannelType.GuildNews) &&
-        (c.id === channel || (c.name && c.name.toLowerCase() === channel.toLowerCase()))
+        (c.type === "GUILD_TEXT" || c.type === "GUILD_NEWS") &&
+        (c.id === channel || c.name.toLowerCase() === channel.toLowerCase())
     );
   }
-
   async getRole(role, guild) {
-    if (!role) return null; // Add check for undefined role
     return guild.roles.cache.find(
-      (r) => r.id === role || (r.name && r.name.toLowerCase() === role.toLowerCase())
+      (r) => r.id === role || r.name.toLowerCase() === role.toLowerCase()
     );
   }
-
   async getCategory(category, guild) {
-    if (!category) return null; // Add check for undefined category
     return guild.channels.cache.find(
       (c) =>
-        c.type === Discord.ChannelType.GuildCategory &&
-        (c.id === category || (c.name && c.name.toLowerCase() === category.toLowerCase()))
+        c.type === "GUILD_CATEGORY" &&
+        (c.id === category || c.name.toLowerCase() === category.toLowerCase())
     );
   }
 
   async start(token) {
-    let tempCommandFiles = fs.readdirSync("./Commands").filter((file) => file.endsWith(".js"));
+    var tempCommandFiles = fs.readdirSync("./Commands").filter((file) => file.endsWith(".js"));
 
-    if (cmdconfig.Suggestion.Enabled === false) {
+    if (supportbot.DisableSuggestions) {
       tempCommandFiles = tempCommandFiles.filter(item => item !== "suggest.js");
     }
-
-    if (cmdconfig.Help.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "help.js");
-    }
-
-    if (cmdconfig.Info.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "info.js");
-    }
-
-    if (cmdconfig.OpenTicket.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "ticket.js");
-    }
-
-    if (cmdconfig.CloseTicket.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "close.js");
-    }
-
-    if (cmdconfig.Embed.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "embed.js");
-    }
-
-    if (cmdconfig.Translate.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "translate.js");
-    }
-
-    if (cmdconfig.UserInfo.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "userinfo.js");
-    }
-
-    if (cmdconfig.Ping.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "Ping.js");
-    }
-
-    if (cmdconfig.AddUser.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "addUser.js");
-    }
-
-    if (cmdconfig.RemoveUser.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "removeUser.js");
-    }    
-
-    if (cmdconfig.ForceAddUser.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "forceaddUser.js");
-    }   
-
-    if (cmdconfig.Profile.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "profile.js");
-    }    
-
-    if (cmdconfig.Settings.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "settings.js");
-    }    
-
-    if (cmdconfig.Mod.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "mod.js");
-    }    
-
+    
     const commandFiles = tempCommandFiles;
+
+    const addonFiles = fs
+      .readdirSync("./Addons")
+      .filter((file) => file.endsWith(".js"));
+
+    const addons = addonFiles.map((file) => {
+      let addon = require(`../Addons/${file}`);
+      addon.name = file.split(".")[0];
+      return addon;
+    });
+
     const commands = commandFiles.map((file) => require(`../Commands/${file}`));
 
-    // Load main commands
-    console.log(`\u001b[33m`, "――――――――――――――――――――――――――――――――――――――――――――");
+    // Commands
+    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Commands ▬▬▬▬▬▬▬");
 
     commands.forEach((cmd) => {
-      console.log(`\u001b[32m`, `[CMD]`, `\u001b[37;1m`, `${cmd.name}`, `\u001b[32;1m`, "Loaded");
+      console.log(`\u001b[31;1m`, `${cmd.name}`, `\u001b[32;1m`, "Loaded");
       this.commands.set(cmd.name, cmd);
     });
 
-    // Load addon commands and events
-    console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Commands ▬▬▬▬▬▬▬");
+    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Commands ▬▬▬▬▬▬▬");
+    // Addons
+    console.log("   ");
+    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Addons ▬▬▬▬▬▬▬");
 
-    if (supportbot.General.Addons.Enabled) {
-      const addonFiles = fs.readdirSync("./Addons").filter((file) => file.endsWith(".js"));
-
-      const addons = addonFiles.map((file) => {
-        const addon = require(`../Addons/${file}`);
-        addon.name = file.split(".")[0];
-        return addon;
+    addons.forEach((addon) => {
+      console.log(
+        `\u001b[33m`,
+        `[ADDON]`,
+        `\u001b[31;1m`,
+        `${addon.name}`,
+        `\u001b[32;1m`,
+        "Loaded"
+      );
+      addon.commands?.forEach((command) => {
+        this.commands.set(command.name, command);
       });
-
-      // Addons
-      console.log("   ");
-      console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Addons ▬▬▬▬▬▬▬");
-
-      addons.forEach((addon) => {
-        console.log(
-          `\u001b[32m`,
-          `[ADDON]`,
-          `\u001b[37;1m`,
-          `${addon.name}`,
-          `\u001b[32;1m`,
-          "Loaded"
-        );
-
-        if (addon instanceof Command) {
-          this.commands.set(addon.name, addon);
-        }
-
-        if (addon.events && Array.isArray(addon.events)) {
-          addon.events.forEach((event) => {
-            if (event instanceof Event) {
-              this.on(event.event, (...args) => event.run(this, ...args));
-            }
-          });
-        }
+      addon.events?.forEach((event) => {
+        this.on(event.event, (...args) => event.run(this, ...args));
       });
+    });
 
-      console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Addons ▬▬▬▬▬▬▬");
-    }
+    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Addons ▬▬▬▬▬▬▬");
 
-    // Register Slash Commands
+    // Slash Commands
 
     this.once("ready", async () => {
       await this.guilds.cache.first()?.commands.set(this.commands);
       console.log(
-        "\u001b[32m",
-        `[SUCCESS]`,
-        `\u001b[37;1m`,
+        `\u001b[32;1m`,
         `Slash Commands Registered for ${this.guilds.cache.first().name}`
       );
     });
 
     console.log("   ");
-    console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
+    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
 
-    fs.readdirSync("./Events").filter((file) => file.endsWith(".js")).forEach((file) => {
-      const event = require(`../Events/${file}`);
-      console.log(`\u001b[32m`, `[EVENT]`, `\u001b[37;1m`, `${event.event}`, `\u001b[32;1m`, "Loaded");
-      this.on(event.event, (...args) => event.run(this, ...args));
-    });
+    fs.readdirSync("./Events")
+      .filter((file) => file.endsWith(".js"))
+      .forEach((file) => {
+        const event = require(`../Events/${file}`);
+        console.log(`\u001b[31;1m`, `${event.event}`, `\u001b[32;1m`, "Loaded");
+        this.on(event.event, (...args) => event.run(this, ...args));
+      });
 
-    console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
+    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
     if (process.argv[2] !== "test") {
       await this.login(token);
     } else {

index.js

@@ -18,27 +18,6 @@ const supportbot = yaml.load(
 );
 
 const Client = require("./Structures/Client.js");
-const client = new Client({
-  intents: ['Guilds', 'GuildMembers', 'GuildMessages', 'MessageContent']
-});
-
-client.start(supportbot.General.Token);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+const client = new Client({});
 
+client.start(supportbot.Token);

package.json

@@ -1,11 +1,11 @@
 {
   "name": "supportbot",
-  "version": "8.3",
+  "version": "7.7.2",
   "description": "SupportBot is an open-sourced support system for discord. It's completely free to use with high amounts of customization to match your own brand.",
   "main": "index.js",
   "scripts": {
-    "setup": "npm i && node index.js",
-    "start": "node index.js"
+    "start": "npm i && node index.js",
+    "test": "node index.js test"
   },
   "repository": {
     "type": "git",
@@ -16,16 +16,11 @@
   "bugs": {
     "url": "https://github.com/Emerald-Services/SupportBot/issues"
   },
-  "homepage": "https://community.emeraldsrv.dev",
+  "homepage": "https://github.com/Emerald-Services/SupportBot#readme",
   "dependencies": {
-    "@paypal/checkout-server-sdk": "^1.0.3",
     "@vitalets/google-translate-api": "^8.0.0",
-    "axios": "^1.7.2",
-    "discord.js": "^14.13.0",
-    "js": "^0.1.0",
+    "discord.js": "^13.6.0",
     "js-yaml": "^4.1.0",
-    "moment": "^2.29.3",
-    "ms": "^2.1.3",
-    "openai": "^4.50.0"
+    "moment": "^2.29.3"
   }
 }