Merge pull request #196 from Emerald-Services/dev

8.4.1 guilldMemberAdd update.

CODE_OF_CONDUCT.md

@@ -1,128 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-our discord.
-All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series
-of actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
-
-Community Impact Guidelines were inspired by [Mozilla's code of conduct
-enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -1,92 +0,0 @@
-# Contributing
-
-When contributing to this repository, please first discuss the change you wish to make via issue,
-email, or any other method with the owners of this repository before making a change. 
-
-Please note we have a code of conduct, please follow it in all your interactions with the project.
-
-## Pull Request Process
-
-1. Ensure any install or build dependencies are removed before the end of the layer when doing a 
-   build.
-2. Update the README.md with details of changes to the interface, this includes new environment 
-   variables, exposed ports, useful file locations and container parameters.
-3. Increase the version numbers in any examples files and the README.md to the new version that this
-   Pull Request would represent. The versioning scheme we use is [SemVer](http://semver.org/).
-4. You may merge the Pull Request in once you have the sign-off of two other developers, or if you 
-   do not have permission to do that, you may request the second reviewer to merge it for you.
-
-## Code of Conduct
-
-### Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, gender identity and expression, level of experience,
-nationality, personal appearance, race, religion, or sexual identity and
-orientation.
-
-### Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-### Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-### Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-### Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at [INSERT EMAIL ADDRESS]. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-### Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

Commands/General/help.js

@@ -5,7 +5,7 @@ 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");
+const Command = require("../../Structures/Command.js");
 
 module.exports = new Command({
   name: cmdconfig.Help.Command,
@@ -55,7 +55,7 @@ module.exports = new Command({
     });
 
     interaction.reply({
-      ephemeral: true,
+      flags: Discord.MessageFlags.Ephemeral,
       embeds: [HelpEmbed1],
     });
   },

Commands/General/info copy.js

@@ -0,0 +1,45 @@
+// SupportBot | Emerald Services
+// Info Command
+
+const fs = require("fs");
+
+const { ContainerBuilder, UserSelectMenuBuilder, ButtonStyle, MessageFlags } = 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 db = require("../../Structures/Database.js");
+const Command = require("../../Structures/Command.js");
+
+module.exports = new Command({
+  name: "test",
+  description: cmdconfig.Info.Description,
+  options: [],
+  permissions: cmdconfig.Info.Permission,
+
+  async run(interaction, client) {
+
+    const ticketPanelembed = new ContainerBuilder()
+      .addTextDisplayComponents(
+        textDisplay => textDisplay
+        .setContent("SupportBot"),
+      )
+
+
+await interaction.reply({
+	components: [ticketPanelembed],
+	flags: MessageFlags.IsComponentsV2,
+});
+
+  },
+});

Commands/General/info.js

@@ -18,7 +18,7 @@ const msgconfig = yaml.load(
   fs.readFileSync("./Configs/messages.yml", "utf8")
 );
 
-const Command = require("../Structures/Command.js");
+const Command = require("../../Structures/Command.js");
 
 module.exports = new Command({
   name: cmdconfig.Info.Command,

Commands/General/ping.js

@@ -10,7 +10,7 @@ const supportbot = yaml.load(
 );
 const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
 
-const Command = require("../Structures/Command.js");
+const Command = require("../../Structures/Command.js");
 
 module.exports = new Command({
   name: cmdconfig.Ping.Command,

Commands/General/profile.js

@@ -0,0 +1,296 @@
+const {
+  EmbedBuilder,
+  ModalBuilder,
+  TextInputBuilder,
+  TextInputStyle,
+  ApplicationCommandType,
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  ApplicationCommandOptionType
+} = require("discord.js");
+const fs = require("fs");
+const yaml = require("js-yaml");
+const db = require("../../Structures/Database.js");
+const Command = require("../../Structures/Command.js");
+
+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 clockedInUsers = new Set();
+
+function updateClockedInStatus(embed, clockedIn) {
+  embed.data.fields = embed.data.fields.map(f =>
+    f.name === "Clocked In Status"
+      ? { ...f, value: clockedIn ? "✅ Clocked In" : "❌ Clocked Out" }
+      : f
+  );
+  return embed;
+}
+
+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 viewingUser = interaction.options.getUser("user") || interaction.user;
+    const viewingUserId = viewingUser.id;
+    const interactionUserId = interaction.user.id;
+
+    const member = await interaction.guild.members.fetch(viewingUserId);
+    const { getRole } = 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 = member.roles.cache.has(Staff.id) || member.roles.cache.has(Admin.id);
+    const isOwnProfile = interactionUserId === viewingUserId;
+
+    const profileData = db.getProfile(viewingUserId);
+    let { bio, timezone, clockedIn } = profileData;
+    clockedIn = Boolean(clockedIn);
+
+    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 ? [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)
+            )
+          );
+
+        return i.showModal(modal);
+      }
+
+      if (i.customId === "clockInOut") {
+        const newStatus = !clockedIn;
+        db.setClockedIn(viewingUserId, newStatus);
+        clockedIn = newStatus;
+        profileEmbed = updateClockedInStatus(profileEmbed, newStatus);
+
+        if (newStatus) clockedInUsers.add(viewingUserId);
+        else clockedInUsers.delete(viewingUserId);
+
+        const updatedRow = new ActionRowBuilder().addComponents(
+          new ButtonBuilder()
+            .setCustomId("editProfile")
+            .setLabel("Edit Profile")
+            .setStyle(ButtonStyle.Secondary)
+        );
+        if (isStaff) {
+          updatedRow.addComponents(
+            new ButtonBuilder()
+              .setCustomId("clockInOut")
+              .setLabel(newStatus ? "Clock Out" : "Clock In")
+              .setStyle(ButtonStyle.Secondary)
+          );
+          if (supportbot.Ticket.ClaimTickets.Enabled) {
+            updatedRow.addComponents(
+              new ButtonBuilder()
+                .setCustomId("viewTicketStats")
+                .setLabel("View Ticket Stats")
+                .setStyle(ButtonStyle.Secondary)
+            );
+          }
+        }
+
+        await i.update({ embeds: [profileEmbed], components: [updatedRow] });
+
+        const clockEmbed = new EmbedBuilder()
+          .setTitle(newStatus ? "Clocked In!" : "Clocked Out!")
+          .setDescription(newStatus ? "You have successfully clocked in." : "You have successfully clocked out.")
+          .setColor(supportbot.Embed.Colours.General);
+
+        return interaction.followUp({ embeds: [clockEmbed], 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(t => {
+          if (t.claimedAt && t.createdAt) {
+            totalResponseTime += new Date(t.claimedAt) - new Date(t.createdAt);
+            responseCount++;
+          }
+        });
+
+        const avgMinutes = responseCount ? Math.round(totalResponseTime / responseCount / 60000) : 0;
+
+        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: `${avgMinutes} minutes`, inline: false }
+          );
+
+        const statsRow = 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)
+        );
+
+        return i.update({ embeds: [statsEmbed], components: [statsRow] });
+      }
+
+      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 openEmbed = new EmbedBuilder()
+          .setTitle("Active Tickets")
+          .setDescription(ticketsOpen.map(t => `<#${t.id}>`).join("\n") || "No active tickets.")
+          .setColor(supportbot.Embed.Colours.General);
+
+        const backRow = new ActionRowBuilder().addComponents(
+          new ButtonBuilder().setCustomId("backToStats").setLabel("Back to Stats").setStyle(ButtonStyle.Secondary)
+        );
+
+        return i.update({ embeds: [openEmbed], components: [backRow] });
+      }
+
+      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(t => {
+          if (t.claimedAt && t.createdAt) {
+            totalResponseTime += new Date(t.claimedAt) - new Date(t.createdAt);
+            responseCount++;
+          }
+        });
+        const avgMinutes = responseCount ? Math.round(totalResponseTime / responseCount / 60000) : 0;
+
+        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: `${avgMinutes} minutes`, inline: false }
+          );
+
+        const statsRow = 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)
+        );
+
+        return i.update({ embeds: [statsEmbed], components: [statsRow] });
+      }
+
+      if (i.customId === "backToProfile") {
+        return i.update({
+          embeds: [profileEmbed],
+          components: buttonRow.components.length ? [buttonRow] : []
+        });
+      }
+    });
+  }
+});
+
+module.exports.clockedInUsers = clockedInUsers;

Commands/General/translate.js

@@ -18,7 +18,7 @@ const msgconfig = yaml.load(
   fs.readFileSync("./Configs/messages.yml", "utf8")
 )
 
-const Command = require("../Structures/Command.js");
+const Command = require("../../Structures/Command.js");
 const translate = require("@vitalets/google-translate-api");
 
 module.exports = new Command({
@@ -71,7 +71,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.Log,
+      supportbot.Translate.TranslateLog,
       interaction.guild
     ); // Grab the set logging channel for translations
 
@@ -89,7 +89,7 @@ module.exports = new Command({
                 "Click the title to see which 2 letter language codes are valid."
               ),
           ],
-          ephemeral: true,
+          flags: Discord.MessageFlags.Ephemeral,
         });
       }
     });

Commands/Suggestions/suggest.js

@@ -0,0 +1,147 @@
+const fs = require("fs");
+const Discord = require("discord.js");
+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 msgconfig  = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+
+const Command = require("../../Structures/Command.js");
+const DB = require("../../Structures/Database.js"); 
+
+module.exports = new Command({
+  name: "suggest",
+  description: cmdconfig.Suggestion?.Description || "Submit a new suggestion",
+  type: Discord.ApplicationCommandType.ChatInput,
+  options: [
+    {
+      name: "text",
+      description: "Your suggestion text",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: true
+    }
+  ],
+
+  async run(interaction) {
+    const suggestion = interaction.options.getString("text");
+    const mode = supportbot.Suggestions.Mode || "Channel";
+
+    const embed = 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 }
+      )
+      .setThumbnail(interaction.user.displayAvatarURL())
+      .setColor(supportbot.Embed.Colours.General);
+
+    const row = new Discord.ActionRowBuilder().addComponents(
+      new Discord.ButtonBuilder()
+        .setCustomId("upvote")
+        .setEmoji(supportbot.Suggestions.UpvoteEmoji)
+        .setStyle(supportbot.Suggestions.Buttons.Upvote),
+      new Discord.ButtonBuilder()
+        .setCustomId("downvote")
+        .setEmoji(supportbot.Suggestions.DownvoteEmoji)
+        .setStyle(supportbot.Suggestions.Buttons.Downvote),
+      new Discord.ButtonBuilder()
+        .setCustomId("removevote")
+        .setLabel(supportbot.Suggestions.Buttons.RemoveVote_Title)
+        .setStyle(supportbot.Suggestions.Buttons.RemoveVote)
+    );
+
+    if (mode === "Forum") {
+      const forum = await interaction.guild.channels
+        .fetch(supportbot.Suggestions.ForumChannel)
+        .catch(() => null);
+
+      if (!forum || forum.type !== Discord.ChannelType.GuildForum) {
+        return interaction.reply({
+          embeds: [
+            new Discord.EmbedBuilder()
+              .setTitle("⚠ Missing Forum Channel")
+              .setDescription(msgconfig.Error.MissingChannel)
+              .setColor(supportbot.Embed.Colours.Error)
+          ],
+          flags: Discord.MessageFlags.Ephemeral,
+        });
+      }
+
+      const appliedTags = supportbot.Suggestions.Tags?.Created
+        ? [supportbot.Suggestions.Tags.Created]
+        : [];
+
+      const thread = await forum.threads.create({
+        name: suggestion.slice(0, 100),
+        message: {
+          content: "\u200B",          
+          embeds: [embed],
+          components: [row]
+        },
+        appliedTags,
+        autoArchiveDuration: Discord.ThreadAutoArchiveDuration.OneDay,
+        reason: "New Suggestion"
+      });
+
+      embed.setFooter({
+        text: `${supportbot.Embed.Footer} | Suggestion ID: ${thread.id}`,
+        iconURL: interaction.user.displayAvatarURL()
+      });
+      const starter = await thread.fetchStarterMessage();
+      await starter.edit({ embeds: [embed], components: [row] });
+
+      DB.add(thread.id, interaction.user.id, suggestion);
+
+      return interaction.reply({
+        embeds: [
+          new Discord.EmbedBuilder()
+            .setTitle(msgconfig.Suggestions.Sent_Title)
+            .setDescription(`${msgconfig.Suggestions.Sent}`)
+            .addFields({ name: 'Posted in:', value: `<#${forum.id}>` })
+            .setColor(supportbot.Embed.Colours.Success)
+        ],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+
+    // ---------- Channel Mode ----------
+    const channel = await interaction.guild.channels
+      .fetch(supportbot.Suggestions.Channel)
+      .catch(() => null);
+
+    if (!channel) {
+      return interaction.reply({
+        embeds: [
+          new Discord.EmbedBuilder()
+            .setTitle("⚠ Missing Suggestion Channel")
+            .setDescription(msgconfig.Error.MissingChannel)
+            .setColor(supportbot.Embed.Colours.Error)
+        ],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+
+    const message = await channel.send({ embeds: [embed], components: [row] });
+
+    embed.setFooter({
+      text: `${supportbot.Embed.Footer} | Suggestion ID: ${message.id}`,
+      iconURL: interaction.user.displayAvatarURL()
+    });
+    await message.edit({ embeds: [embed], components: [row] });
+
+    DB.add(message.id, interaction.user.id, suggestion);
+
+    return interaction.reply({
+      embeds: [
+        new Discord.EmbedBuilder()
+          .setTitle(msgconfig.Suggestions.Sent_Title)
+          .setDescription(`${msgconfig.Suggestions.Sent}`)
+          .addFields({ name: 'Posted in:', value: `<#${channel.id}>` })
+          .setColor(supportbot.Embed.Colours.Success)
+      ],
+      flags: Discord.MessageFlags.Ephemeral,
+    });
+  }
+});

Commands/Suggestions/suggestadmin.js

@@ -0,0 +1,183 @@
+const Discord = require("discord.js");
+const fs      = require("fs");
+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 SuggestionDB = require("../../Structures/Database.js");
+const Command     = require("../../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.SuggestionAdmin.Command,
+  description: cmdconfig.SuggestionAdmin.Description,
+  type: Discord.ApplicationCommandType.ChatInput,
+  permissions: cmdconfig.SuggestionAdmin.Permission,
+  options: [
+    {
+      name: "status",
+      description: "New status",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: true,
+      choices: [
+        { name: "Solved",      value: "Solved" },
+        { name: "Denied",      value: "Denied" },
+        { name: "Considering", value: "Considering" }
+      ]
+    },
+    {
+      name: "id",
+      description: "Message ID (required in Channel mode)",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: false
+    }
+  ],
+
+  async run(interaction) {
+    const status   = interaction.options.getString("status");
+    const idOption = interaction.options.getString("id");
+    const mode     = supportbot.Suggestions.Mode || "Channel";
+
+    const { getRole } = interaction.client;
+    const staffRole = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
+    const adminRole = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+    if (
+      !interaction.member.roles.cache.has(staffRole?.id) &&
+      !interaction.member.roles.cache.has(adminRole?.id)
+    ) {
+      return interaction.reply({
+        embeds: [
+          new Discord.EmbedBuilder()
+            .setTitle("Invalid Permissions!")
+            .setDescription(
+              `${msgconfig.Error.IncorrectPerms}\nRequired: ${supportbot.Roles.StaffMember.Staff} or ${supportbot.Roles.StaffMember.Admin}`
+            )
+            .setColor(supportbot.Embed.Colours.Warn)
+        ],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+
+    if (mode === "Forum") {
+      const thread = interaction.channel;
+      if (!thread.isThread() || thread.parentId !== supportbot.Suggestions.ForumChannel) {
+        return interaction.reply({
+          embeds: [
+            new Discord.EmbedBuilder()
+              .setTitle("Not a Suggestion Thread")
+              .setDescription(msgconfig.Error.MissingChannel)
+              .setColor(supportbot.Embed.Colours.Error)
+          ],
+          flags: Discord.MessageFlags.Ephemeral,
+        });
+      }
+
+      const tagMap = {
+        Solved:      supportbot.Suggestions.Tags.Solved,
+        Denied:      supportbot.Suggestions.Tags.Denied,
+        Considering: supportbot.Suggestions.Tags.Considering
+      };
+      const tagId = tagMap[status];
+      if (!tagId) {
+        return interaction.reply({
+          embeds: [
+            new Discord.EmbedBuilder()
+              .setTitle("Tag Missing")
+              .setDescription("No forum tag configured for this status.")
+              .setColor(supportbot.Embed.Colours.Error)
+          ],
+          flags: Discord.MessageFlags.Ephemeral,
+        });
+      }
+
+      await thread.setAppliedTags([tagId]).catch(() => null);
+      SuggestionDB.setStatus(thread.id, status);
+
+      return interaction.reply({
+        embeds: [
+          new Discord.EmbedBuilder()
+            .setTitle("Suggestion Updated")
+            .setDescription(`Status set to **${status}**.`)
+            .setColor(supportbot.Embed.Colours.Success)
+        ],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+
+    if (!idOption) {
+      return interaction.reply({
+        embeds: [
+          new Discord.EmbedBuilder()
+            .setTitle("Message ID Required")
+            .setDescription("Provide the suggestion’s message ID when in Channel mode.")
+            .setColor(supportbot.Embed.Colours.Error)
+        ],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+
+    const channel = await interaction.guild.channels
+      .fetch(supportbot.Suggestions.Channel)
+      .catch(() => null);
+    if (!channel) {
+      return interaction.reply({
+        embeds: [
+          new Discord.EmbedBuilder()
+            .setTitle("Missing Suggestion Channel")
+            .setDescription(msgconfig.Error.MissingChannel)
+            .setColor(supportbot.Embed.Colours.Error)
+        ],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+
+    const targetMsg = await channel.messages.fetch(idOption).catch(() => null);
+    if (!targetMsg) {
+      return interaction.reply({
+        embeds: [
+          new Discord.EmbedBuilder()
+            .setTitle("Message Not Found")
+            .setDescription("Could not fetch a suggestion with that ID.")
+            .setColor(supportbot.Embed.Colours.Error)
+        ],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+
+    const oldEmbed = targetMsg.embeds[0];
+    if (!oldEmbed) {
+      return interaction.reply({
+        embeds: [
+          new Discord.EmbedBuilder()
+            .setTitle("No Embed Found")
+            .setDescription("The target message has no suggestion embed.")
+            .setColor(supportbot.Embed.Colours.Error)
+        ],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+
+    const colorMap = {
+      Solved:      supportbot.Embed.Colours.Success,
+      Denied:      supportbot.Embed.Colours.Error,
+      Considering: supportbot.Embed.Colours.Warn
+    };
+
+    const newEmbed = Discord.EmbedBuilder.from(oldEmbed)
+      .setColor(colorMap[status])
+      .addFields({ name: "Status", value: status, inline: true });
+
+    await targetMsg.edit({ embeds: [newEmbed], components: targetMsg.components });
+    SuggestionDB.setStatus(idOption, status);
+
+    return interaction.reply({
+      embeds: [
+        new Discord.EmbedBuilder()
+          .setTitle("Suggestion Updated")
+          .setDescription(`Suggestion **${idOption}** marked as **${status}**.`)
+          .setColor(supportbot.Embed.Colours.Success)
+      ],
+      flags: Discord.MessageFlags.Ephemeral,
+    });
+  }
+});

Commands/Tickets/addUser.js

@@ -0,0 +1,119 @@
+const fs = require("fs");
+const {
+  EmbedBuilder,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ChannelType,
+  MessageFlags,
+} = 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");
+const db = require("../../Structures/Database.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;
+
+    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],
+        flags: MessageFlags.Ephemeral,
+      });
+    }
+
+    const ticketRow = db.getTicket(ticketChannel.id);
+    if (!ticketRow) {
+      const notFound = new EmbedBuilder()
+        .setTitle(msgconfig.ForceAddUser.NotInTicket_Title)
+        .setDescription(msgconfig.ForceAddUser.NotInTicket_Description)
+        .setColor(supportbot.Embed.Colours.Error);
+
+      return interaction.reply({
+        embeds: [notFound],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+
+    try {
+      if (supportbot.Ticket.TicketType === "threads") {
+        const botMember = await ticketChannel.members.fetch(interaction.client.user.id).catch(() => null);
+        if (!botMember) await ticketChannel.join();
+        await new Promise(res => setTimeout(res, 1000));
+        await ticketChannel.members.add(userToAdd.id);
+      } else if (supportbot.Ticket.TicketType === "channels") {
+        await ticketChannel.permissionOverwrites.create(userToAdd.id, {
+          ViewChannel: true,
+          SendMessages: true,
+          ReadMessageHistory: true,
+        });
+      }
+
+      db.addUserToTicket(ticketChannel.id, userToAdd.id);
+
+      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],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+
+      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],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+  },
+});

Commands/Tickets/close.js

@@ -0,0 +1,468 @@
+const fs = require("fs");
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+
+const db = require("../../Structures/Database.js");
+
+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,
+  options: [
+    {
+      name: "reason",
+      description: "Ticket Close Reason",
+      type: Discord.ApplicationCommandOptionType.String,
+    }
+  ],
+  permissions: cmdconfig.CloseTicket.Permission,
+
+  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()
+        .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 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();
+
+    const ticket = db.getTicket(interaction.channel.id);
+    
+    if (!ticket) {
+      const Exists = new Discord.EmbedBuilder()
+        .setTitle("No Ticket Found!")
+        .setDescription(msgconfig.Error.NoValidTicket)
+        .setColor(supportbot.Embed.Colours.Warn);
+      return interaction.followUp({ embeds: [Exists] });
+    }
+
+    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
+          }
+        )
+        .setColor(msgconfig.ReviewSystem.ReviewEmbed.Color);
+
+      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}>`
+        );
+      }
+
+      if (reviewChannel) {
+        await reviewChannel.send({ embeds: [reviewEmbed] });
+      }
+
+      if (!interaction.replied && !interaction.deferred) {
+        await interaction.followUp({ embeds: [reviewEmbed] });
+      }
+
+      await handleCloseTicket(interaction, reason, ticket);
+    } else {
+      await handleCloseTicket(interaction, reason, ticket);
+    }
+  },
+});
+
+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],
+    flags: Discord.MessageFlags.Ephemeral,
+  });
+
+  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],
+    flags: Discord.MessageFlags.Ephemeral,
+  });
+
+  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) {
+  const { getChannel } = interaction.client;
+
+  let tUser = interaction.client.users.cache.get(ticket.user_id);
+  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 {
+    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;
+    }
+
+    allMessages.sort((a, b) => a.createdTimestamp - b.createdTimestamp);
+
+    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
+      }))
+    }));
+
+    db.updateTicketStatus(interaction.channel.id, "closed");
+
+    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_id}\`)` +
+        `> **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 transcriptDir = "./Data/Transcripts";
+    
+    if (!fs.existsSync(transcriptDir)) {
+      fs.mkdirSync(transcriptDir, { recursive: true });
+    }
+
+    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) {
+  content = content.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
+  
+  content = content.replace(/_(.*?)_/g, '<em>$1</em>');
+  
+  content = content.replace(/`(.*?)`/g, '<code>$1</code>');
+  
+  content = content.replace(/\[(.*?)\]\((.*?)\)/g, '<a href="$2" target="_blank">$1</a>');
+  
+  content = content.replace(/```(.*?)```/gs, '<pre><code>$1</code></pre>');
+  
+  return content;
+}
+
+function createTranscriptHTML(ticket, reason) {
+  return `
+  <!DOCTYPE html>
+  <html lang="en">
+    <head>
+      <meta charset="UTF-8">
+      <meta name="viewport" content="width=device-width, initial-scale=1.0">
+      <title>Ticket Transcript</title>
+      <link href="https://cdnjs.cloudflare.com/ajax/libs/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
+      <style>
+        body {
+          background: linear-gradient(135deg, #0f2027, #203a43, #2c5364);
+          font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+          color: #e5e7eb;
+          margin: 0;
+          padding: 40px;
+        }
+
+        .container {
+          max-width: 1000px;
+          margin: auto;
+          padding: 25px;
+          border-radius: 20px;
+          backdrop-filter: blur(18px) saturate(180%);
+          background: rgba(17, 25, 40, 0.75);
+          box-shadow: 0 8px 32px rgba(0,0,0,0.6);
+          border: 1px solid rgba(255, 255, 255, 0.1);
+        }
+
+        h1 {
+          font-size: 2rem;
+          font-weight: 700;
+          text-align: center;
+          color: #22c55e; /* green accent */
+          margin-bottom: 20px;
+          text-shadow: 0 0 4px rgba(34,197,94,0.4); /* subtle glow */
+        }
+
+        .ticket-info {
+          margin-bottom: 25px;
+          padding: 15px;
+          border-radius: 12px;
+          background: rgba(255, 255, 255, 0.05);
+          border: 1px solid rgba(255,255,255,0.1);
+        }
+
+        .ticket-info p {
+          margin: 6px 0;
+          font-size: 0.95rem;
+        }
+
+        .message {
+          background: rgba(255, 255, 255, 0.05);
+          border: 1px solid rgba(255, 255, 255, 0.1);
+          border-radius: 15px;
+          padding: 16px;
+          margin-bottom: 15px;
+          transition: all 0.2s ease-in-out;
+        }
+
+        .message:hover {
+          background: rgba(255, 255, 255, 0.08);
+          transform: translateY(-2px);
+          box-shadow: 0 6px 20px rgba(0,0,0,0.4);
+        }
+
+        .message-header {
+          display: flex;
+          align-items: center;
+          margin-bottom: 12px;
+        }
+
+        .avatar {
+          width: 45px;
+          height: 45px;
+          border-radius: 50%;
+          margin-right: 12px;
+          border: 2px solid rgba(34,197,94,0.6);
+        }
+
+        .username {
+          font-weight: 600;
+          color: #22c55e;
+        }
+
+        .timestamp {
+          margin-left: auto;
+          font-size: 0.85rem;
+          color: #9ca3af;
+        }
+
+        .content {
+          word-break: break-word;
+          font-size: 0.95rem;
+          line-height: 1.4rem;
+        }
+
+        .embed {
+          margin-top: 12px;
+          border-left: 4px solid #22c55e;
+          padding-left: 12px;
+          border-radius: 6px;
+          background: rgba(34,197,94,0.1);
+        }
+
+        .embed strong {
+          color: #f9fafb;
+        }
+
+        .attachment {
+          display: inline-block;
+          background: rgba(34,197,94,0.1);
+          border: 1px solid #22c55e;
+          border-radius: 6px;
+          padding: 6px 12px;
+          margin: 6px 0;
+          color: #22c55e;
+          text-decoration: none;
+          font-size: 0.9rem;
+        }
+
+        .attachment:hover {
+          background: rgba(34,197,94,0.2);
+        }
+
+        code, pre {
+          background: rgba(0,0,0,0.4);
+          color: #f8fafc;
+          padding: 4px 8px;
+          border-radius: 6px;
+          font-family: 'Consolas', 'Monaco', monospace;
+        }
+      </style>
+    </head>
+    <body>
+      <div class="container">
+        <h1>Ticket Transcript</h1>
+        <div class="ticket-info">
+          <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/Tickets/forceaddUser.js

@@ -0,0 +1,119 @@
+const fs = require("fs");
+const {
+  EmbedBuilder,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ChannelType,
+  MessageFlags,
+} = 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");
+const db = require("../../Structures/Database.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;
+
+    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],
+        flags: MessageFlags.Ephemeral,
+      });
+    }
+
+    const ticketRow = db.getTicket(ticketChannel.id);
+    if (!ticketRow) {
+      const notFound = new EmbedBuilder()
+        .setTitle(msgconfig.ForceAddUser.NotInTicket_Title)
+        .setDescription(msgconfig.ForceAddUser.NotInTicket_Description)
+        .setColor(supportbot.Embed.Colours.Error);
+
+      return interaction.reply({
+        embeds: [notFound],
+        flags: MessageFlags.Ephemeral,
+      });
+    }
+
+    try {
+      if (supportbot.Ticket.TicketType === "threads") {
+        const botMember = await ticketChannel.members.fetch(interaction.client.user.id).catch(() => null);
+        if (!botMember) await ticketChannel.join();
+        await new Promise(res => setTimeout(res, 1000));
+        await ticketChannel.members.add(userToAdd.id);
+      } else if (supportbot.Ticket.TicketType === "channels") {
+        await ticketChannel.permissionOverwrites.create(userToAdd.id, {
+          ViewChannel: true,
+          SendMessages: true,
+          ReadMessageHistory: true,
+        });
+      }
+
+      db.addUserToTicket(ticketChannel.id, userToAdd.id);
+
+      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],
+        flags: MessageFlags.Ephemeral,
+      });
+
+      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],
+        flags: MessageFlags.Ephemeral,
+      });
+    }
+  },
+});

Commands/Tickets/removeUser.js

@@ -0,0 +1,108 @@
+// SupportBot | Emerald Services
+// Remove user from a ticket 
+
+const {
+  EmbedBuilder,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ChannelType,
+  MessageFlags,
+} = require("discord.js");
+const yaml = require("js-yaml");
+const fs = require("fs");
+
+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");
+const db      = require("../../Structures/Database.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;
+    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("Missing staff/admin roles in config.");
+    }
+    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(supportbot.Embed.Colours.Warn);
+      return interaction.reply({ embeds: [NoPerms], flags: MessageFlags.Ephemeral });
+    }
+
+    const userToRemove = interaction.options.getUser("user");
+    const ticketChannel = interaction.channel;
+
+    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], flags: MessageFlags.Ephemeral });
+    }
+
+    try {
+      if (supportbot.Ticket.TicketType === "threads") {
+        await ticketChannel.members.remove(userToRemove.id);
+      } else {
+        await ticketChannel.permissionOverwrites.delete(userToRemove.id);
+      }
+
+      db.removeUserFromTicket(ticketChannel.id, userToRemove.id);
+
+      const removedEmbed = new EmbedBuilder()
+        .setTitle(msgconfig.RemoveUser.Removed_Title)
+        .setDescription(msgconfig.RemoveUser.Removed_Message)
+        .setColor(supportbot.Embed.Colours.Success);
+
+      await interaction.reply({ embeds: [removedEmbed], flags: MessageFlags.Ephemeral });
+
+      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(() => {});
+    } 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], flags: MessageFlags.Ephemeral });
+    }
+  },
+});

Commands/Tickets/ticket.js

@@ -0,0 +1,585 @@
+const fs = require("fs");
+const {
+  EmbedBuilder,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ChannelType,
+  ActionRowBuilder,
+  ButtonBuilder,
+  StringSelectMenuBuilder,
+  StringSelectMenuOptionBuilder,
+  ButtonStyle,
+  MessageCollector,
+  MessageFlags,
+  SeparatorBuilder,
+  ContainerBuilder,
+  TextDisplayBuilder
+} = require("discord.js");
+const yaml = require("js-yaml");
+
+const db = require("../../Structures/Database.js");
+
+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 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 rows = guild.members.cache.map(m => m.id);
+  for (const id of rows) {
+    const profile = db.getProfile(id);
+    if (profile && profile.clockedIn) {
+      clockedInUsers.add(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] });
+    }
+  };
+
+  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);
+    return null;
+  }
+}
+
+module.exports = new Command({
+  name: cmdconfig.OpenTicket.Command,
+  description: cmdconfig.OpenTicket.Description,
+  type: ApplicationCommandType.ChatInput,
+  options: [
+    {
+      name: "reason",
+      description: "Ticket Reason",
+      type: ApplicationCommandOptionType.String,
+    },
+  ],
+  permissions: cmdconfig.OpenTicket.Permission,
+
+  async run(interaction) {
+    
+    try {
+
+      if (await isBlacklisted(interaction.user.id)) {
+        return interaction.reply({
+          content: msgconfig.Ticket.Blacklisted,
+          flags: MessageFlags.Ephemeral 
+        });
+      }
+
+      let TicketReason = null;
+      if (supportbot.Ticket.TicketReason) {
+        TicketReason = interaction.reason || null; 
+      }
+
+      let TicketData = { tickets: db.getAllTickets() };
+
+      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,
+            },
+          ],
+          flags: MessageFlags.Ephemeral 
+        });
+      }
+
+      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}`
+        )
+      ) {
+        return await interaction.reply({
+          embeds: [TicketExists],
+          flags: MessageFlags.Ephemeral 
+        });
+      }
+
+      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.",
+          flags: MessageFlags.Ephemeral 
+        });
+
+      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!",
+            flags: MessageFlags.Ephemeral 
+          });
+        }
+
+        ticketChannel = await interaction.guild.channels.create({
+          name: `${supportbot.Ticket.Channel}${ticketNumberID}`,
+          type: ChannelType.GuildText,
+          parent: category.id,
+          reason: 'support ticket',
+        });
+
+        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!",
+              flags: MessageFlags.Ephemeral 
+            });
+          }
+        }
+      }
+
+      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);
+        }
+      }
+
+      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,
+        }); 
+    }
+
+      db.addTicket({
+        id: ticketChannel.id,
+        name: ticketChannel.name,
+        user: interaction.user.id,
+        number: ticketNumberID,
+        reason: TicketSubject,
+        open: true,
+        subUsers: [],
+        createdAt: new Date().toISOString(),
+        claimedAt: null,
+      });
+      TicketData.tickets = db.getAllTickets();
+
+      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], flags: MessageFlags.Ephemeral  });
+
+      // TICKET MESSAGE - UPDATED WITH COMPONENTS V2
+      
+      const ticketMsgContainer = new ContainerBuilder()
+        
+      if (supportbot.Embed.Colours.General) {
+        ticketMsgContainer.setAccentColor(
+          parseInt(supportbot.Embed.Colours.General.replace("#", ""), 16)
+        )
+      }
+
+      const ticketAuthor = new TextDisplayBuilder().setContent(
+        msgconfig.Ticket.TicketAuthorTitle.replace(/%ticketauthor%/g, interaction.user.id)
+          .replace(/%ticketid%/g, ticketChannel.id)
+          .replace(/%ticketusername%/g, interaction.user.username),
+      );
+
+      ticketMsgContainer.addTextDisplayComponents(ticketAuthor)
+
+      const ticketTitle = new TextDisplayBuilder().setContent(
+        msgconfig.Ticket.TicketTitle.replace(/%ticketauthor%/g, interaction.user.id)
+          .replace(/%ticketid%/g, ticketChannel.id)
+          .replace(/%ticketusername%/g, interaction.user.username)
+      );
+
+      ticketMsgContainer.addTextDisplayComponents(ticketTitle)
+      
+      const seperator2 = new SeparatorBuilder()
+        .setDivider(true)
+
+      ticketMsgContainer.addSeparatorComponents(seperator2)
+
+      const ticketDescription = new TextDisplayBuilder().setContent(
+        msgconfig.Ticket.TicketMessage.replace(/%ticketauthor%/g, interaction.user.id)
+          .replace(/%ticketid%/g, ticketChannel.id)
+          .replace(/%ticketusername%/g, interaction.user.username)
+          .replace(/%ticketreason%/g, TicketSubject)
+      );
+
+      ticketMsgContainer.addTextDisplayComponents(ticketDescription)
+
+      const seperator3 = new SeparatorBuilder()
+        .setDivider(true)
+
+      ticketMsgContainer.addSeparatorComponents(seperator3)
+
+      const ticketReason = new TextDisplayBuilder().setContent(
+        `**Reason:**\n ${TicketReason}`
+      );
+
+      if (supportbot.Ticket.TicketReason && TicketReason) {
+        ticketMsgContainer.addTextDisplayComponents(ticketReason)
+      }
+
+      const selectMenuRow = new ActionRowBuilder();
+
+      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"),
+          );
+        }
+
+      selectMenuRow.addComponents(SelectMenus)
+
+      ticketMsgContainer.addActionRowComponents(selectMenuRow)
+
+      await ticketChannel.send({
+        flags: MessageFlags.IsComponentsV2,
+        components: [ticketMsgContainer],
+      });
+
+      if (supportbot.Ticket.Questions.Enabled) {
+        const questions = supportbot.Ticket.Questions.List || [];
+        
+        if (questions.length > 0) {
+          await askTicketQuestions(ticketChannel, interaction, questions);
+        }
+}
+      
+    } catch (error) {
+      console.error("Error in run method:", error);
+    }
+  },
+});

Commands/Tickets/ticketpanel.js

@@ -0,0 +1,181 @@
+const fs = require("fs");
+const {
+  EmbedBuilder,
+  ApplicationCommandType,
+  ActionRowBuilder,
+  ButtonBuilder,
+  MessageFlags,
+  ContainerBuilder,
+  TextDisplayBuilder,
+  MediaGalleryBuilder,
+  SeparatorBuilder,
+  ThumbnailBuilder,
+  SectionBuilder
+} = 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");
+const db = require("../../Structures/Database.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`.",
+        flags: MessageFlags.Ephemeral 
+      });
+    }
+
+    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.`,
+        flags: MessageFlags.Ephemeral 
+      });
+    }
+
+    const panelRow = db.getTicketPanel();
+
+    if (panelRow) {
+      try {
+        await channel.messages.fetch(panelRow.message_id);
+        return interaction.reply({
+          content: "Ticket panel message already exists.",
+          flags: MessageFlags.Ephemeral 
+        });
+      } catch (err) {}
+    }
+
+    const panelContainer = new ContainerBuilder()
+
+    if (panelconfig.Style.Color) {
+      panelContainer.setAccentColor(
+        parseInt(panelconfig.Style.Color.replace("#", ""), 16)
+      )
+    }
+
+    const panelTitle = new TextDisplayBuilder().setContent(
+      panelconfig.Style.Title,
+    );
+
+    const topSeperator = new SeparatorBuilder()
+      .setDivider(true)
+
+    if (panelconfig.Settings.TopTitle) {
+      panelContainer.addTextDisplayComponents(panelTitle)
+    }
+
+    if (panelconfig.Settings.TopDivider) {
+      panelContainer.addSeparatorComponents(topSeperator)
+    }
+
+    const panelDesc = new TextDisplayBuilder().setContent(
+      panelconfig.Style.Description,
+    );
+
+    if (panelconfig.Style.Layout === "3") {
+      panelContainer.addTextDisplayComponents(panelDesc)
+    }
+
+    const createTicketButton = new ButtonBuilder()
+      .setCustomId("createticket")
+      .setLabel(panelconfig.Button.Text)
+      .setEmoji(panelconfig.Button.Emoji)
+      .setStyle(panelconfig.Button.Color);
+
+    const middleSection = new SectionBuilder()
+      .addTextDisplayComponents(panelDesc)
+      .setButtonAccessory(createTicketButton)
+
+    if (panelconfig.Style.Layout === "1") {
+      panelContainer.addSectionComponents(middleSection)
+    }
+
+    const panelImage = new MediaGalleryBuilder()
+      .addItems([
+        {
+          media: {
+            url: panelconfig.Style.Image,
+          },
+        }
+      ])
+
+    if (panelconfig.Settings.Image) {
+      panelContainer.addMediaGalleryComponents(panelImage)
+    }
+
+    // START OF STYLE 2 - TEXT UNDER THE IMAGE
+
+    const bottomSeperator = new SeparatorBuilder()
+      .setDivider(true)
+
+    if (panelconfig.Settings.BottomTitle) {
+      panelContainer.addTextDisplayComponents(panelTitle)
+    }
+
+    if (panelconfig.Settings.BottomDivider) {
+      panelContainer.addSeparatorComponents(bottomSeperator)
+    }
+
+    if (panelconfig.Style.Layout === "2") {
+      panelContainer.addSectionComponents(middleSection)
+    }
+
+    // START OF STYLE 3
+
+    const buttonRow = new ActionRowBuilder();
+      const ticketButtonRow = new ButtonBuilder()
+        .setCustomId("createticket")
+        .setLabel(panelconfig.Button.Text)
+        .setEmoji(panelconfig.Button.Emoji)
+        .setStyle(panelconfig.Button.Color);
+      buttonRow.addComponents(ticketButtonRow)
+
+    if (panelconfig.Style.Layout === "3") {
+      panelContainer.addActionRowComponents(buttonRow)
+    }
+
+    try {
+      const message = await channel.send({
+        flags: MessageFlags.IsComponentsV2,
+        components: [panelContainer],
+      });
+
+      db.saveTicketPanel(message.id, channel.id);
+
+      return interaction.reply({
+        content: "Ticket panel message has been sent!",
+        flags: MessageFlags.Ephemeral 
+      });
+    } catch (e) {
+      console.log("Error sending message:", e);
+      return interaction.reply({
+        content: "An error occurred while sending the ticket panel message.",
+        flags: MessageFlags.Ephemeral 
+      });
+    }
+  },
+});

Commands/Utils/embed.js

@@ -0,0 +1,468 @@
+const { 
+  ApplicationCommandType, 
+  ApplicationCommandOptionType,
+  ActionRowBuilder, 
+  ButtonBuilder, 
+  EmbedBuilder,
+  StringSelectMenuBuilder,
+  ModalBuilder,
+  TextInputBuilder,
+  TextInputStyle,
+  ButtonStyle,
+  ComponentType,
+  MessageFlags,
+} = require('discord.js');
+const Command = require('../../Structures/Command.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'));
+
+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;
+}
+
+module.exports = new Command({
+  name: cmdconfig.Embed.Command,
+  description: cmdconfig.Embed.Description,
+  type: ApplicationCommandType.ChatInput,
+  options: [
+    {
+      name: 'channel',
+      description: 'Select channel to send the message',
+      type: ApplicationCommandOptionType.Channel,
+      required: true
+    }
+  ],
+  permissions: cmdconfig.Embed.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.');
+    }
+
+    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], flags: MessageFlags.Ephemeral });
+    }
+
+    const channel = interaction.options.getChannel('channel');
+    
+    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
+    };
+
+    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;
+    }
+
+    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'
+            }
+          ])
+      );
+
+    function createButtons(messageType) {
+      const buttons = [];
+      
+      if (messageType === 'embed') {
+        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)
+          );
+
+        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 {
+        const textRow = new ActionRowBuilder()
+          .addComponents(
+            new ButtonBuilder()
+              .setCustomId('edit_description')
+              .setLabel('Edit Text')
+              .setStyle(ButtonStyle.Secondary)
+          );
+        
+        buttons.push(textRow);
+      }
+
+      // Send button always shows
+      const sendRow = new ActionRowBuilder()
+        .addComponents(
+          new ButtonBuilder()
+            .setCustomId('send_message')
+            .setLabel('Send')
+            .setStyle(ButtonStyle.Success)
+        );
+      
+      buttons.push(sendRow);
+      return buttons;
+    }
+
+    async function updatePreview(i) {
+      if (messageData.type === 'embed') {
+        await i.update({
+          content: 'Customize your message:',
+          embeds: [createEmbed()],
+          components: [typeRow, ...createButtons('embed')]
+        });
+      } else {
+        await i.update({
+          content: messageData.description,
+          embeds: [],
+          components: [typeRow, ...createButtons('text')]
+        });
+      }
+    }
+
+    const message = await interaction.reply({
+      content: messageData.type === 'text' ? messageData.description : 'Customize your message:',
+      components: [typeRow, ...createButtons(messageData.type)],
+      embeds: messageData.type === 'embed' ? [createEmbed()] : [],
+      flags: MessageFlags.Ephemeral 
+    });
+
+    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.', 
+          flags: MessageFlags.Ephemeral  
+        });
+      }
+
+      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.', 
+              flags: MessageFlags.Ephemeral  
+            });
+          }
+          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/Utils/mod.js

@@ -0,0 +1,261 @@
+const fs = require("fs");
+const { ApplicationCommandOptionType, ApplicationCommandType, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, ComponentType, MessageFlags } = 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], flags: MessageFlags.Ephemeral  });
+        }
+
+        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],
+          flags: MessageFlags.Ephemeral  
+        });
+
+      } 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], flags: MessageFlags.Ephemeral  });
+        }
+
+        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], flags: MessageFlags.Ephemeral  });
+
+      } 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], flags: MessageFlags.Ephemeral  });
+        }
+
+        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] : [],
+          flags: MessageFlags.Ephemeral 
+        });
+
+        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.',
+              flags: MessageFlags.Ephemeral 
+            });
+          }
+
+          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], flags: MessageFlags.Ephemeral  });
+    }
+  }
+});

Commands/Utils/settings.js

@@ -0,0 +1,237 @@
+const { Command } = require('../../Structures/Addon.js');
+const Discord = require("discord.js");
+const fs = require("fs");
+const yaml = require("js-yaml");
+const db = require("../../Structures/Database.js");
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+async function loadSettings() {
+  return new Promise((resolve, reject) => {
+    db.get("SELECT data FROM settings WHERE id = 1", (err, row) => {
+      if (err) return reject(err);
+      if (!row) return resolve({});
+      try {
+        resolve(JSON.parse(row.data));
+      } catch (e) {
+        resolve({});
+      }
+    });
+  });
+}
+
+async function saveSettings(settings) {
+  const data = JSON.stringify(settings);
+  return new Promise((resolve, reject) => {
+    db.run(
+      "INSERT INTO settings (id, data) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data",
+      [data],
+      (err) => (err ? reject(err) : resolve())
+    );
+  });
+}
+
+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 = await 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;
+        await 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], flags: Discord.MessageFlags.Ephemeral });
+      } catch (error) {
+        return interaction.reply({ content: `Failed to set status: ${error.message}`, flags: Discord.MessageFlags.Ephemeral });
+      }
+    } 
+    
+    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 };
+        await saveSettings(settings);
+
+        const embed = new Discord.EmbedBuilder()
+          .setDescription(`Activity set to **${activityType.toLowerCase()} ${activityMessage}**`)
+          .setColor(supportbot.Embed.Colours.General);
+
+        return interaction.reply({ embeds: [embed], flags: Discord.MessageFlags.Ephemeral  });
+      } catch (error) {
+        return interaction.reply({ content: `Failed to set activity: ${error.message}`, flags: Discord.MessageFlags.Ephemeral  });
+      }
+    } 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.', flags: Discord.MessageFlags.Ephemeral  });
+        }
+
+        try {
+          interaction.client.user.setPresence({
+            activities: [{ name: 'Streaming', type: Discord.ActivityType.Streaming, url: twitchUrl }],
+            status: 'online',
+          });
+
+          settings.streaming = { active: true, url: twitchUrl };
+          await saveSettings(settings);
+
+          const embed = new Discord.EmbedBuilder()
+            .setDescription(`**Streaming mode enabled!**\nStreaming: [Twitch](${twitchUrl})`)
+            .setColor(supportbot.Embed.Colours.General);
+
+          return interaction.reply({ embeds: [embed], flags: Discord.MessageFlags.Ephemeral  });
+        } catch (error) {
+          return interaction.reply({ content: `Failed to enable streaming mode: ${error.message}`, flags: Discord.MessageFlags.Ephemeral  });
+        }
+      } 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 };
+          await saveSettings(settings);
+
+          const embed = new Discord.EmbedBuilder()
+            .setDescription(`**Streaming mode disabled!**`)
+            .setColor(supportbot.Embed.Colours.General);
+
+          return interaction.reply({ embeds: [embed], flags: Discord.MessageFlags.Ephemeral  });
+        } catch (error) {
+          return interaction.reply({ content: `Failed to disable streaming mode: ${error.message}`, flags: Discord.MessageFlags.Ephemeral  });
+        }
+      }
+    } 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;
+        await saveSettings(settings);
+
+        const embed = new Discord.EmbedBuilder()
+          .setDescription(`Bot nickname set to **${nickname}**`)
+          .setColor(supportbot.Embed.Colours.General);
+
+        return interaction.reply({ embeds: [embed], flags: Discord.MessageFlags.Ephemeral  });
+      } catch (error) {
+        return interaction.reply({ content: `Failed to set nickname: ${error.message}`, flags: Discord.MessageFlags.Ephemeral  });
+      }
+    } else {
+      return interaction.reply({ content: 'Invalid command usage.', flags: Discord.MessageFlags.Ephemeral  });
+    }
+  },
+});

Commands/close.js

@@ -1,335 +0,0 @@
-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");
-
-module.exports = new Command({
-  name: cmdconfig.CloseTicket.Command,
-  description: cmdconfig.CloseTicket.Description,
-  type: Discord.ApplicationCommandType.ChatInput,
-  options: [
-    {
-      name: "reason",
-      description: "Ticket Close Reason",
-      type: Discord.ApplicationCommandOptionType.String,
-    },
-  ],
-  permissions: cmdconfig.CloseTicket.Permission,
-
-  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!\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] });
-    }
-
-    if (interaction.channel.type !== Discord.ChannelType.PrivateThread) {
-      const NotTicketChannel = new Discord.EmbedBuilder()
-        .setTitle("Invalid Channel!")
-        .setDescription("This command can only be used in a ticket thread.")
-        .setColor(supportbot.Embed.Colours.Warn);
-
-      return interaction.reply({ embeds: [NotTicketChannel], ephemeral: true });
-    }
-
-    await interaction.deferReply();
-
-    let tickets = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-    let TicketData = tickets.tickets.findIndex((t) => t.id === interaction.channel.id);
-    let ticket = tickets.tickets[TicketData];
-
-    if (TicketData === -1) {
-      const Exists = new Discord.EmbedBuilder()
-        .setTitle("No Ticket Found!")
-        .setDescription(msgconfig.Error.NoValidTicket)
-        .setColor(supportbot.Embed.Colours.Warn);
-      return interaction.followUp({ embeds: [Exists] });
-    }
-
-    let reason = interaction.options?.getString("reason") || "No Reason Provided.";
-
-    const CloseButton = new Discord.ButtonBuilder()
-      .setCustomId("confirmCloseTicket")
-      .setLabel(supportbot.Ticket.Close.Confirmation_Button)
-      .setStyle(Discord.ButtonStyle.Danger);
-
-    const row = new Discord.ActionRowBuilder().addComponents(CloseButton);
-
-    const CloseTicketRequest = new Discord.EmbedBuilder()
-      .setTitle(`**${supportbot.Ticket.Close.Title}**`)
-      .setDescription(
-        `${msgconfig.Ticket.ConfirmClose}`
-      )
-      .setColor(supportbot.Embed.Colours.General);
-
-    await interaction.followUp({
-      embeds: [CloseTicketRequest],
-      components: [row],
-    });
-
-    const filter = (btnInteraction) => btnInteraction.customId === "confirmCloseTicket" && btnInteraction.user.id === interaction.user.id;
-
-    interaction.channel.awaitMessageComponent({ filter, time: 20000 })
-      .then(async (btnInteraction) => {
-        await handleCloseTicket(interaction, reason, ticket, TicketData);
-        await btnInteraction.reply({ content: "Ticket successfully closed.", ephemeral: true });
-      })
-      .catch((err) => {
-        interaction.followUp(`${msgconfig.Ticket.CloseTimeout}`);
-        console.error(err);
-      });
-  },
-});
-
-async function handleCloseTicket(interaction, reason, ticket, TicketData) {
-  const { getChannel } = interaction.client;
-
-  let tickets = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
-  let tUser = interaction.client.users.cache.get(ticket.user);
-  let transcriptChannel = await getChannel(supportbot.Ticket.Log.TranscriptLog, interaction.guild);
-  let logChannel = await getChannel(supportbot.Ticket.Log.TicketLog, interaction.guild);
-
-  if (!transcriptChannel || !logChannel)
-    return interaction.followUp("Some Channels seem to be missing!");
-
-  try {
-    tickets.tickets[TicketData].open = false;
-    fs.writeFileSync(
-      "./Data/TicketData.json",
-      JSON.stringify(tickets, null, 4),
-      (err) => {
-        if (err) console.error(err);
-      }
-    );
-
-    const transcriptEmbed = new Discord.EmbedBuilder()
-      .setTitle(supportbot.Ticket.Log.TranscriptTitle)
-      .setColor(supportbot.Embed.Colours.General)
-      .setFooter({
-        text: supportbot.Embed.Footer,
-        iconURL: interaction.user.displayAvatarURL(),
-      })
-      .addFields(
-        { name: "Ticket", value: `${interaction.channel.name} (${interaction.channel.id})` },
-        { name: "User", value: `${tUser?.username || "N/A"}#${tUser?.discriminator || "N/A"} (${tUser?.id || ticket.user})` },
-        { name: "Closed By", value: interaction.user.tag },
-        { name: "Reason", value: reason }
-      );
-
-    const logEmbed = new Discord.EmbedBuilder()
-      .setTitle(supportbot.Ticket.Log.TicketLog_Title)
-      .setColor(supportbot.Embed.Colours.General)
-      .setFooter({
-        text: supportbot.Embed.Footer,
-        iconURL: interaction.user.displayAvatarURL(),
-      })
-      .addFields(
-        { name: "Ticket", value: `${interaction.channel.name} (${interaction.channel.id})` },
-        { name: "User", value: `${tUser?.username || "N/A"}#${tUser?.discriminator || "N/A"} (${tUser?.id || ticket.user})` },
-        { name: "Closed By", value: interaction.user.tag },
-        { name: "Reason", value: reason }
-      );
-
-    let msgs = await interaction.channel.messages.fetch({ limit: 100 });
-    let html = `
-      <html>
-        <head>
-          <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: 0;
-              height: 100%;
-              display: flex;
-              flex-direction: column;
-            }
-            .container {
-              backdrop-filter: blur(10px);
-              background-color: rgba(0, 128, 0, 0.3);
-              border-radius: 15px;
-              padding: 20px;
-              margin: 20px;
-              box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
-              flex-grow: 1;
-              display: flex;
-              flex-direction: column;
-              max-width: 1000px;
-              width: 100%;
-              margin: auto;
-            }
-            .message {
-              display: flex;
-              align-items: center;
-              margin-bottom: 10px;
-              padding: 10px;
-              background-color: rgba(255, 255, 255, 0.1);
-              border-radius: 10px;
-            }
-            .avatar {
-              width: 40px;
-              height: 40px;
-              border-radius: 50%;
-              margin-right: 10px;
-            }
-            .content {
-              flex: 1;
-            }
-            .username {
-              font-weight: bold;
-            }
-            .timestamp {
-              font-size: 0.8em;
-              color: #bbb;
-            }
-            .download-button {
-              background-color: #4CAF50;
-              color: white;
-              padding: 10px 20px;
-              text-align: center;
-              text-decoration: none;
-              display: inline-block;
-              font-size: 16px;
-              margin-top: 20px;
-              border-radius: 5px;
-            }
-          </style>
-        </head>
-        <body>
-          <div class="container">
-            <h1 class="text-2xl font-bold mb-4">Ticket Transcript</h1>
-            <p><strong>Server Name:</strong> ${interaction.guild.name}</p>
-            <p><strong>Ticket:</strong> ${interaction.channel.name}</p>
-            <p><strong>Messages:</strong> ${msgs.size} Messages</p>
-            <div class="mt-4">
-    `;
-
-    msgs = msgs.sort((a, b) => a.createdTimestamp - b.createdTimestamp);
-    msgs.forEach((msg) => {
-      if (msg.content) {
-        html += `
-          <div class="message">
-            <img class="avatar" src="${msg.author.displayAvatarURL()}" alt="Avatar">
-            <div class="content">
-              <p class="username">${msg.author.tag}</p>
-              <p class="timestamp">${msg.createdAt.toLocaleString()}</p>
-              <p>${convertMarkdownToHTML(msg.content)}</p>
-            </div>
-          </div>
-        `;
-      }
-    });
-
-    const fileName = `${interaction.channel.name}.html`;
-
-    html += `
-            </div>
-            <a href="${fileName}" download class="download-button">Download Transcript</a>
-          </div>
-        </body>
-      </html>
-    `;
-
-    if (!supportbot.Ticket.Log.DisableTicketLogChannel) {
-      await logChannel.send({ embeds: [logEmbed] }).catch((err) => {
-        console.error(err);
-      });
-    }
-
-    let file = new Discord.AttachmentBuilder(
-      Buffer.from(html),
-      { name: fileName }
-    );
-
-    await transcriptChannel
-      .send({ embeds: [transcriptEmbed], files: [file] })
-      .catch((err) => {
-        console.error(err);
-      });
-
-    if (supportbot.Ticket.DMTranscripts) {
-      await tUser
-        ?.send({ embeds: [transcriptEmbed], files: [file] })
-        .catch((err) => {
-          console.error(err);
-        });
-
-      if (ticket.subUsers) {
-        ticket.subUsers.forEach(async (subUser) => {
-          await interaction.client.users.cache
-            .get(subUser)
-            ?.send({ embeds: [transcriptEmbed], files: [file] });
-        });
-      }
-    }
-
-    await interaction.channel.delete().catch((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);
-  }
-}
-
-function convertMarkdownToHTML(text) {
-  // Convert **bold** to <strong>bold</strong>
-  text = text.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
-
-  // Convert *italic* to <em>italic</em>
-  text = text.replace(/\*(.*?)\*/g, '<em>$1</em>');
-
-  // Convert __underline__ to <u>underline</u>
-  text = text.replace(/__(.*?)__/g, '<u>$1</u>');
-
-  // Convert ~~strikethrough~~ to <s>strikethrough</s>
-  text = text.replace(/~~(.*?)~~/g, '<s>$1</s>');
-
-  // Convert inline code `code` to <code>code</code>
-  text = text.replace(/`(.*?)`/g, '<code>$1</code>');
-
-  // Convert blockquotes > quote to <blockquote>quote</blockquote>
-  text = text.replace(/^> (.*?$)/gm, '<blockquote>$1</blockquote>');
-
-  // Convert multiline code blocks ```code``` to <pre><code>code</code></pre>
-  text = text.replace(/```(.*?)```/gs, '<pre><code>$1</code></pre>');
-
-  // Convert line breaks to <br>
-  text = text.replace(/\n/g, '<br>');
-
-  return text;
-}

Commands/embed.js

@@ -1,167 +0,0 @@
-// File path: ./commands/embed.js
-
-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");
-
-module.exports = new Command({
-  name: cmdconfig.Embed.Command,
-  description: cmdconfig.Embed.Description,
-  type: Discord.ApplicationCommandType.ChatInput,
-  options: [
-    {
-      name: "title",
-      description: "Embed Title",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: true,
-    },
-    {
-      name: "message",
-      description: "Embed Message",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: true,
-    },
-    {
-      name: "color",
-      description: "Embed HEX Color",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: false,
-    },
-    {
-      name: "fields",
-      description: "Embed Fields (title|content;title|content;...)",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: false,
-    },
-    {
-      name: "thumbnail",
-      description: "Embed Thumbnail URL",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: false,
-    },
-    {
-      name: "image",
-      description: "Embed Image URL",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: false,
-    },
-    {
-      name: "footer",
-      description: "Embed Footer Text",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: false,
-    },
-    {
-      name: "footericon",
-      description: "Embed Footer Icon URL",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: false,
-    },
-    {
-      name: "author",
-      description: "Embed Author Name",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: false,
-    },
-    {
-      name: "authoricon",
-      description: "Embed Author Icon URL",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: false,
-    },
-    {
-      name: "authorurl",
-      description: "Embed Author URL",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: false,
-    },
-    {
-      name: "timestamp",
-      description: "Include Timestamp",
-      type: Discord.ApplicationCommandOptionType.Boolean,
-      required: false,
-    },
-    {
-      name: "inline",
-      description: "Make Fields Inline",
-      type: Discord.ApplicationCommandOptionType.Boolean,
-      required: false,
-    }
-  ],
-  permissions: cmdconfig.Embed.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 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)
-    ) {
-      const EmbedTitle = interaction.options.getString("title").replace(/\\n/g, '\n');
-      const EmbedSubject = interaction.options.getString("message").replace(/\\n/g, '\n');
-      const GeneralColour = interaction.options.getString("color") || supportbot.Embed.Colours.Default;
-      const EmbedThumbnail = interaction.options.getString("thumbnail");
-      const EmbedImage = interaction.options.getString("image");
-      const EmbedFields = interaction.options.getString("fields");
-      const EmbedFooter = interaction.options.getString("footer")?.replace(/\\n/g, '\n');
-      const EmbedFooterIcon = interaction.options.getString("footericon");
-      const EmbedAuthor = interaction.options.getString("author")?.replace(/\\n/g, '\n');
-      const EmbedAuthorIcon = interaction.options.getString("authoricon");
-      const EmbedAuthorURL = interaction.options.getString("authorurl");
-      const EmbedTimestamp = interaction.options.getBoolean("timestamp");
-      const InlineFields = interaction.options.getBoolean("inline");
-
-      const EmbedMsg = new Discord.EmbedBuilder()
-        .setTitle(EmbedTitle)
-        .setDescription(EmbedSubject)
-        .setColor(GeneralColour)
-        .setThumbnail(EmbedThumbnail)
-        .setImage(EmbedImage);
-
-      if (EmbedFields) {
-        const fieldsArray = EmbedFields.split(';');
-        fieldsArray.forEach(field => {
-          const [title, value] = field.split('|');
-          if (title && value) {
-            EmbedMsg.addFields({ name: title.replace(/\\n/g, '\n'), value: value.replace(/\\n/g, '\n'), inline: InlineFields || false });
-          }
-        });
-      }
-
-      if (EmbedFooter) {
-        EmbedMsg.setFooter({ text: EmbedFooter, iconURL: EmbedFooterIcon });
-      }
-
-      if (EmbedAuthor) {
-        EmbedMsg.setAuthor({ name: EmbedAuthor, iconURL: EmbedAuthorIcon, url: EmbedAuthorURL });
-      }
-
-      if (EmbedTimestamp) {
-        EmbedMsg.setTimestamp();
-      }
-
-      interaction.reply({
-        embeds: [EmbedMsg],
-      });
-    } else {
-      return interaction.reply({ embeds: [NoPerms] });
-    }
-  },
-});

Commands/genImage.js

@@ -1,79 +0,0 @@
-const fs = require("fs");
-const Discord = require("discord.js");
-const yaml = require("js-yaml");
-const generateImage = require('../Structures/generateImage.js');
-
-const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
-const Command = require("../Structures/Command.js");
-
-module.exports = new Command({
-  name: "image",
-  description: "Create an image through SupportBot AI",
-  type: Discord.ApplicationCommandType.ChatInput,
-  options: [
-    {
-      name: "prompt",
-      description: "The prompt to generate an image from",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: true,
-    },
-    {
-      name: "negativeprompt",
-      description: "The negative prompt to exclude from the image",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: false,
-    },
-    {
-      name: "cfgscale",
-      description: "The cfg scale for the image generation",
-      type: Discord.ApplicationCommandOptionType.Number,
-      required: false,
-    }
-  ],
-  permissions: "SendMessages",
-
-  async run(interaction) {
-    const prompt = interaction.options.getString("prompt");
-    const negativePrompt = interaction.options.getString("negativeprompt") || "";
-    const cfgScale = interaction.options.getNumber("cfgscale") || 7.5; // Default value
-
-    try {
-      const imageUrl = await generateImage(prompt, negativePrompt, cfgScale);
-
-      const ImageEmbed = new Discord.EmbedBuilder()
-        .setTitle("Generated Image")
-        .setDescription(`Here is the image generated for your prompt: "${prompt}"`)
-        .setImage(imageUrl)
-        .setColor(supportbot.Embed.Colours.General)
-        .setFooter({
-          text: supportbot.Embed.Footer,
-          iconURL: interaction.user.displayAvatarURL(),
-        });
-
-      if (!interaction.replied) {
-        await interaction.reply({
-          ephemeral: true,
-          embeds: [ImageEmbed],
-        });
-      } else {
-        await interaction.followUp({
-          ephemeral: true,
-          embeds: [ImageEmbed],
-        });
-      }
-    } catch (error) {
-      console.error('Error generating image:', error);
-      if (!interaction.replied) {
-        await interaction.reply({
-          ephemeral: true,
-          content: `An error occurred while generating the image: ${error.message}. Please try again later.`,
-        });
-      } else {
-        await interaction.followUp({
-          ephemeral: true,
-          content: `An error occurred while generating the image: ${error.message}. Please try again later.`,
-        });
-      }
-    }
-  },
-});

Commands/profile.js

@@ -1,323 +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();
-
-async function getRole(roleName, guild) {
-  return guild.roles.cache.find(role => role.name === roleName);
-}
-
-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: 'profile',
-  description: 'Show user profile',
-  type: ApplicationCommandType.ChatInput,
-  permissions: ["SendMessages"],
-  options: [
-    {
-      name: 'user',
-      description: 'The user to view the profile of',
-      type: ApplicationCommandOptionType.User,
-      required: false
-    }
-  ],
-
-  async run(interaction) {
-    await interaction.deferReply({ ephemeral: true });  // Acknowledge the interaction immediately
-
-    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 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/suggest.js

@@ -1,115 +0,0 @@
-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 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,
-  options: [
-    {
-      name: "suggestion",
-      description: "Create a Suggestion",
-      type: Discord.ApplicationCommandOptionType.String,
-      required: true,
-    },
-  ],
-  permissions: cmdconfig.Suggestion.Permission,
-
-  async run(interaction) {
-    const { getChannel } = interaction.client;
-
-    const suggestChannel = await getChannel(
-      supportbot.Suggestions.Channel,
-      interaction.guild
-    );
-
-    const NoChannel = new Discord.EmbedBuilder()
-      .setTitle("Missing Channel!")
-      .setDescription(msgconfig.Error.InvalidChannel)
-      .setColor(supportbot.Embed.Colours.Error);
-
-    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 }
-      )
-      .setThumbnail(interaction.user.displayAvatarURL())
-      .setFooter({
-        text: supportbot.Embed.Footer,
-        iconURL: interaction.user.displayAvatarURL(),
-      })
-      .setColor(supportbot.Embed.Colours.General);
-
-    const UpvoteButton = new Discord.ButtonBuilder()
-      .setCustomId("upvote")
-      .setEmoji(supportbot.Suggestions.UpvoteEmoji)
-      .setStyle(supportbot.Suggestions.Buttons.Upvote);
-
-    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,
-      });
-    }
-
-    const Submitted = new Discord.EmbedBuilder()
-      .setTitle(`${msgconfig.Suggestions.Sent_Title}`)
-      .setDescription(`${msgconfig.Suggestions.Sent}`)
-      .addFields(
-        { name: "Sent to:", value: `<#${suggestChannel.id}>` },
-      )
-      .setColor(supportbot.Embed.Colours.Success);
-
-    await interaction.reply({ 
-      ephemeral: true, 
-      embeds: [Submitted] 
-    });
-  },
-});

Commands/ticket.js

@@ -1,451 +0,0 @@
-const fs = require("fs");
-const {
-  EmbedBuilder,
-  ApplicationCommandOptionType,
-  ApplicationCommandType,
-  ChannelType,
-  ActionRowBuilder,
-  ButtonBuilder,
-  StringSelectMenuBuilder,
-  StringSelectMenuOptionBuilder,
-  ButtonStyle
-} = 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 msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
-
-const Command = require("../Structures/Command.js");
-const TicketNumberID = require("../Structures/TicketID.js");
-
-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 assignTicketToUser(ticketChannel, Staff, Admin, interaction, attempts = 0) {
-  console.log(`Assigning ticket attempt ${attempts}`);
-
-  try {
-    const clockedInUsers = await getClockedInUsers(interaction.guild);
-    console.log(`Clocked in users: ${Array.from(clockedInUsers).join(', ')}`);
-
-    if (clockedInUsers.size === 0 || attempts >= 2) {
-      console.log("No clocked in users or max attempts reached");
-      const claimChannel = await interaction.guild.channels.cache.get(supportbot.Ticket.ClaimTickets.Channel);
-      if (claimChannel) {
-        const claimEmbed = new EmbedBuilder()
-          .setTitle(msgconfig.Ticket.ClaimTickets.ClaimTitle || 'Default Claim Title')
-          .setDescription(msgconfig.Ticket.ClaimTickets.ClaimMessage || 'Default Claim Message')
-          .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 => {
-          console.log(`Ticket claimed by user ${i.user.id}`);
-          await ticketChannel.send({ content: `<@${i.user.id}> has claimed the ticket.` });
-        });
-
-        collector.on('end', async collected => {
-          if (collected.size === 0) {
-            console.log("No one claimed the ticket, notifying admins");
-            await claimMessage.delete();
-
-            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)],
-            });
-          }
-        });
-
-        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);
-    console.log(`Assigned user: ${assignedUserId}`);
-
-    const claimEmbed = new EmbedBuilder()
-      .setTitle(msgconfig.Ticket.ClaimTickets.ClaimTitle || 'Default Claim Title')
-      .setDescription(msgconfig.Ticket.ClaimTickets.ClaimMessage.replace('%user%', interaction.user.id) || 'Default Claim Message')
-      .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 => {
-      console.log(`Ticket claimed by user ${i.user.id}`);
-      await ticketChannel.send({ content: `<@${assignedUserId}>` });
-    });
-
-    collector.on('end', async collected => {
-      if (collected.size === 0) {
-        console.log("No one claimed the ticket, attempting reassignment");
-        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)],
-          });
-
-          // Add a claim button for any staff member to click
-          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({
-            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 => {
-            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,
-  options: [
-    {
-      name: "reason",
-      description: "Ticket Reason",
-      type: ApplicationCommandOptionType.String,
-    },
-  ],
-  permissions: cmdconfig.OpenTicket.Permission,
-
-  async run(interaction) {
-    try {
-      let department = interaction.customId?.split("-")[1] || null;
-      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,
-        });
-      }
-
-      if (User.roles.cache.has(supportbot.Roles.ModRoles.Blacklisted)) {
-        return interaction.reply({
-          content: msgconfig.Ticket.Blacklisted,
-          ephemeral: true,
-        });
-      }
-
-      if (User.roles.cache.has(supportbot.Roles.ModRoles.Muted)) {
-        return interaction.reply({
-          content: msgconfig.Ticket.Muted,
-          ephemeral: true,
-        });
-      }
-
-      let ticketNumberID = await TicketNumberID.pad();
-      const TicketSubject = interaction.options?.getString("reason") || 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}`
-        )
-      ) {
-        return await interaction.reply({
-          embeds: [TicketExists],
-          ephemeral: true,
-        });
-      }
-
-      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,
-        });
-
-      const TicketCategory = interaction.guild.channels.cache.find(
-        (c) => c.name === supportbot.Ticket.TicketCategory || c.id === supportbot.Ticket.TicketCategory
-      );
-
-      const channel = await getChannel(supportbot.Ticket.TicketCategory, interaction.guild);
-      const ticketChannel = await channel.threads.create({
-        name: `${supportbot.Ticket.Channel}${ticketNumberID}`,
-        type: ChannelType.PrivateThread,
-        parent: TicketCategory,
-        autoArchiveDuration: 60,
-        reason: 'support ticket',
-      });
-
-      // 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 claimChannel.send(`<@&${Staff.id}> <@&${Admin.id}>`);
-        }
-      }
-
-      // Add user to the ticket channel
-      if (!department) {
-        await ticketChannel.members.add(interaction.user.id);
-      }
-
-      // 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)
-        )
-        .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)
-        )
-        .setColor(supportbot.Embed.Colours.General);
-
-      // Create the control panel
-      const SelectMenus = new StringSelectMenuBuilder()
-        .setCustomId("ticketcontrolpanel")
-        .setPlaceholder("Ticket Control Panel")
-        .addOptions(
-          new StringSelectMenuOptionBuilder()
-            .setLabel("Add User")
-            .setDescription("Add a user to the ticket.")
-            .setEmoji(supportbot.SelectMenus.Tickets.AddUserEmoji)
-            .setValue("ticketadduser"),
-          new StringSelectMenuOptionBuilder()
-            .setLabel("Remove User")
-            .setDescription("Remove a user from the ticket.")
-            .setEmoji(supportbot.SelectMenus.Tickets.RemoveUserEmoji)
-            .setValue("ticketremoveuser"),
-          new StringSelectMenuOptionBuilder()
-            .setLabel("Close")
-            .setDescription("Close the ticket.")
-            .setEmoji(supportbot.SelectMenus.Tickets.CloseEmoji)
-            .setValue("ticketclose"),
-          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);
-
-      // Send the ticket message and control panel
-      await ticketChannel.send({
-        embeds: [TicketMessage],
-        components: [row2],
-      });
-
-      if (!department) {
-        try {
-          let buttons = supportbot.Departments.map((x) =>
-            new ButtonBuilder()
-              .setCustomId("Department" + supportbot.Departments.indexOf(x))
-              .setLabel(x.title)
-              .setStyle(x.color)
-              .setEmoji(x.emoji)
-          );
-
-          const row = new ActionRowBuilder().addComponents(buttons);
-
-          try {
-            const filter = (i) => i.user.id === interaction.user.id;
-            await m.awaitMessageComponent({
-              filter,
-              max: 1,
-              componentType: "BUTTON",
-              time: supportbot.Ticket.Timeout * 60000,
-            });
-          } catch (e) {
-            if (e.code === "COLLECTOR_ERROR") {
-              try {
-                let ticket = 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 (error) {return assignedUserId;
-                console.error("An error occurred while handling collector:", error);
-              }
-              return await ticketChannel.delete();
-            }
-          }
-        } catch (error) {
-          console.error("Error sending message:", error);
-        }
-      }
-    } catch (error) {
-      console.error("Error in run method:", error);
-    }
-  },
-});

Commands/ticketpanel.js

@@ -1,115 +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 channelName = panelconfig.Channel;
-    const channel = interaction.guild.channels.cache.find(ch => ch.name === channelName);
-    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/userinfo.js

@@ -1,137 +0,0 @@
-// 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 msgconfig = yaml.load(
-  fs.readFileSync("./Configs/messages.yml", "utf8")
-)
-
-const Command = require("../Structures/Command.js");
-
-module.exports =   new Command({
-    name: cmdconfig.UserInfo.Command,
-    description: cmdconfig.UserInfo.Description, 
-    type: Discord.ApplicationCommandType.ChatInput,
-    options: [
-      {
-        type: Discord.ApplicationCommandOptionType.User,
-        name: "user",
-        description: "The user you want to get info about.",
-        required: true,
-      }, // The user input
-    ],
-    permissions: cmdconfig.UserInfo.Permission,
-
-    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."
-          );
-    
-          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] });
-
-        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.EmbedBuilder()
-          .setTitle("User Not Found!")
-          .setDescription(
-            `${msgconfig.Error.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.EmbedBuilder()
-          .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.Footer })
-          .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,11 +7,11 @@
 #           SupportBot created by Emerald Services
 #           Installed with MIT License
 #
-#           Discord Support: https://dsc.gg/emerald-dev
-#           Official Documentation: https://emeraldsrv.dev/wiki
-#           Third-Party Documentation: https://emeraldsrv.dev/third-party
+#           Discord Support: https://discord.gg/emeraldsrv
+#           Official Documentation: https://docs.emeraldsrv.com
+#           Addons Marketplace: https://community.emeraldsrv.com
 #
-#           Command Configuration
+#           Commands Configuration (commands.yml)
 
 Help:
   Command: "help"
@@ -19,12 +19,6 @@ Help:
   Permission: ["SendMessages"]
   Enabled: true
 
-EnableAI:
-  Command: "enableai"
-  Description: "Talk with SupportBot"
-  Permission: ["SendMessages"]
-  Enabled: true
-
 Info:
   Command: "info"
   Description: "Get information about the **ServerName**."
@@ -37,9 +31,9 @@ TicketPanel:
   Permission: ["Administrator"]
   Enabled: true  
 
-TicketStats:
-  Command: "ticketstats"
-  Description: "Shows staff members their ticket statistics"
+Profile:
+  Command: "profile"
+  Description: "Shows the profile for a discord member."
   Permission: ["SendMessages"]
   # Command is automatically disabled when the TicketClaims is disabled.
 
@@ -49,9 +43,21 @@ OpenTicket:
   Permission: ["SendMessages"]
   Enabled: true
 
-Add:
+AddUser:
   Command: "add"
-  Description: "Add a user to the ticket."
+  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
   
@@ -67,6 +73,12 @@ Suggestion:
   Permission: ["SendMessages"]
   Enabled: true
 
+SuggestionAdmin:
+  Command: "suggestadmin"
+  Description: "Update a suggestion’s status."
+  Permission: ['SendMessages']
+  # Disable "Suggestion" to disable this command.
+
 Embed:
   Command: "embed"
   Description: "Build a discord embed."
@@ -91,6 +103,42 @@ Ping:
   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
+
 # ---------------------------------------
 #   Command Description Configuration
 # ---------------------------------------

Configs/messages.yml

@@ -7,45 +7,108 @@
 #           SupportBot created by Emerald Services
 #           Installed with MIT License
 #
-#           Discord Support: https://dsc.gg/emerald-dev
-#           Official Documentation: https://emeraldsrv.com/wiki
-#           Third-Party Documentation: https://emeraldsrv.com/third-party
+#           Discord Support: https://discord.gg/emeraldsrv
+#           Official Documentation: https://docs.emeraldsrv.com
+#           Addons Marketplace: https://community.emeraldsrv.com
 #
-#           Messages Configuration
+#           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://emeraldsrv.com"
-  Colour: "#f74343"
+  URL: "https://docs.emeraldsrv.com"
+  Colour: "#45b463"
+
+# ----------------------------
+# Welcome/Leave Messages
+# ----------------------------
 
 Welcome:
-  Embed:
-    Colour: "#f74343"
-    Title: "Welcome to ServerName"
-    Message: "> :smile: %joined_user% has just landed!"
-    Thumbnail: "BOT"
+  Enabled: true
+  LayoutStyle: "modern" 
+  # Available Layout Styles
+  #  "modern" - For the new Discord v2 components
+  #  "classic" - Use the classic Discord look.
 
-    ImageEnabled: false
-    ImageURL: "https://animagelink.png/"
+  Embed:
+    Colour: "#45b463"
+    Title: "Welcome to ServerName"
+    Message: ":smile: %joined_user% has just landed!\n\n🔨 **Server Rules:** <#1202667199853232129>"
+    Icon:
+      Mode: "USER" # USER | BOT | CUSTOM
+      CustomURL: "https://example.com/custom.png"
+    Image:
+      Enabled: false
+      URL: "https://example.com/banner.png"
+    Buttons:
+      Enabled: true
+      List:
+        - label: "BuiltByBit"
+          style: "Link"
+          url: "https://your-website.com/how-to-play-java"
+          emoji: "⌨️"
+        - label: "GitHub"
+          style: "Link"
+          url: "https://your-website.com/how-to-play-bedrock"
+          emoji: "👾"
+        - label: "Tebex"
+          style: "Link"
+          url: "https://your-store.tebex.io/"
+          emoji: "🛒"
+
+  Modern:
+    Colour: "#45b463"
+    Title: "**Welcome to ServerName**"
+    Body: ":smile: %joined_user% has just landed!\n\n🔨 **Server Rules:** <#1202667199853232129>"
+    Icon:
+      Mode: "BOT" # USER | BOT | CUSTOM
+      CustomURL: "https://example.com/custom-icon.png"
+    Image:
+      Enabled: false
+      URL: "https://example.com/banner.png"
+    Buttons:
+      - label: "BuiltByBit"
+        style: "Link"
+        url: "https://your-website.com/how-to-play-java"
+        emoji: "⌨️"
+      - label: "GitHub"
+        style: "Link"
+        url: "https://your-website.com/how-to-play-bedrock"
+        emoji: "👾"
+      - label: "Tebex"
+        style: "Link"
+        url: "https://your-store.tebex.io/"
+        emoji: "🛒"
 
 Leave:
   Embed:
     Colour: "#f74343"
     Title: "Goodbye!"
-    Message: "> :slight_frown: %joined_user% has recently dropped out!"
+    Message: ":slight_frown: %left_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.**"
+  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:
@@ -54,52 +117,94 @@ 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
+  # You can use Markdown formatting in this message:
+  # # Heading 1
+  # ## Heading 2
+  # ### Heading 3
+  # **Bold** text
+  # *Italic* text
+  # -# Small text
+  # - Bullet points
+  # Links: [text](https://example.com)
 
-  DisableInvites: "> 🔒 Invites have been disabled for this ticket." 
-  EnableInvites: "> 🔓 Invites have been enabled for this ticket." 
+  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.
 
-  AddUserToTicket_Title: "➕ Add User!"
-  AddUserToTicket: "> To add a user to this ticket, Tag them."
+  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!"
 
-  RemovedUserFromTicket_Title: "➖ Removed User!"
-  RemovedUserFromTicket: "> <@%user%> has been `Removed` from this ticket"
+  ConfirmClose: "Please confirm closing the ticket by clicking the button below."
+  CloseTimeout: "Ticket close confirmation timed out."
 
-  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!"
-
-  TranscriptSavedMessage: "📝 **Transcript Saved!**"
-  TicketLockMessage: "❌ **Ticket Locked!**"
-  TicketDeleteMessage: "⚠ **Ticket Deleting!**" 
-
-  ClosingTicket: "> :warning: You have requested to close your support ticket."
-  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%>."
+    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%>"
+    Claimed: "You have successfully claimed this ticket. <#%channel%>"
     NoPermsToClaimTitle: "Error, no permissions!"
-    NoPermsToClaim: "> :x: **Err!** You do not permissions to claim this ticket."
+    NoPermsToClaim: ":x: **Err!** You do not permissions to claim this ticket."
 
     ReassigningTitle: "Reassigning!..."
-    ReassigningMessage: "> <@%user%> did not claim the ticket. **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"
@@ -108,14 +213,116 @@ TicketStats:
 
   Title: "Your Ticket Stats"
 
-Error:
-  IncorrectPerms: "> :x: **Err!** You do not have the correct permissions to use this."
-  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!"
-
-
-
+# ----------------------------
+# 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."
+  InvalidChannel: ":x: **Error!** The suggestions channel has not been set up correctly."

Configs/supportbot-ai.yml

@@ -10,23 +10,22 @@ Enabled: true
 General:
   Name: "SupportBot AI"
   # What would you like to call your AI
-  Model: "gpt-4o"
+  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 KEY"
+  OpenAI_Key: "OPEN_AI_API_KEY"
   # To create an OpenAI API key, go to https://platform.openai.com/api-keys
 
 
-  PastebinAPI_Key: "PASTEBIN KEY"
+  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: "1250190338954498048"
+  AIChannel: "AI_BOT_CHANNEL"
   # This is the channel where AI will respond in without needing to mention the bot.
 
 Embed:

Configs/supportbot.yml

@@ -4,15 +4,16 @@
 #     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|
 #                |_|  |_|
 #
-#           SupportBot created by Emerald Development
+#           SupportBot created by Emerald Services
 #           Installed with MIT License
 #
-#           Discord Support: https://dsc.gg/emerald-dev
-#           Official Documentation: https://github.com/Emerald-Services/SupportBot/wiki
-#           Third-Party Documentation: COMING SOON
+#           Discord Support: https://discord.gg/emeraldsrv
+#           Official Documentation: https://docs.emeraldsrv.dev
+#           Addons Marketplace: https://community.emeraldsrv.dev
+#
+#           SupportBot Configuration (supportbot.yml)
 
-SupportBot_Version: "v8.0.1"
-# Do not change the version number
+SupportBot_Version: "v8.4.1"
 
 # -------------------------
 #   General
@@ -20,8 +21,7 @@ SupportBot_Version: "v8.0.1"
 
 General:
   Name: "SupportBot"
-  Token: "BOT TOKEN HERE"
-  # To get your Discord Bot Token, Go to https://discord.com/developers/applications
+  Token: "BOT_TOKEN"
 
   Addons:
     Enabled: true
@@ -33,9 +33,16 @@ General:
 Activity:
   Status: "SupportBot v8"
   Type: "Competing"
-  # The Type can either be Playing, Watching, Listening or Competing
   StreamingURL: "https://www.twitch.tv/YOUR_TWITCH_NAME"
-  # Set The Type to "Streaming" for a streaming status!
+
+  # Available Types:
+  # Playing
+  # Watching
+  # Listening
+  # Competing
+  # Streaming (URL required)
+
+  # You can also update the activity via Discord using: /settings
 
 # -------------------------
 #  Embeds
@@ -43,13 +50,15 @@ Activity:
 
 Embed:
   Colours:
-    General: 0x0cc559 # 0x<hexcode>
-    Success: 0x04b545 # 0x<hexcode>
-    Error: 0xd13030 # 0x<hexcode>
-    Warn: 0xfca117 # 0x<hexcode>
+    General: "#0cc559"
+    Success: "#04b545"
+    Error: "#d13030"
+    Warn: "#fca117"
 
   Footer: "SupportBot | Developed by Emerald Development"
 
+  # Use 0x<hexcode>  to change the colour of the embeds.
+
 # -------------------------
 #  Roles
 # -------------------------
@@ -57,15 +66,17 @@ Embed:
 Roles:
   AutoRole:
     Enabled: true
-    Role: "Member"
+    Role: "1111111111111111"
 
   StaffMember:
-    Staff: "Staff"
-    Admin: "Admin"
+    Staff: "1111111111111111"
+    Admin: "1111111111111111"
+    Moderator: "1111111111111111"
 
-  ModRoles:
-    Muted: "Muted"
-    Blacklisted: "Blacklisted"
+  Mod:
+    AllowSupportStaff: false
+
+  # Allow Support Staff to use the /mod command. (More in detail customisation in commands.yml)
 
 # ----------------------------
 #  System Messages
@@ -73,18 +84,21 @@ Roles:
 
 Welcome: 
   Enabled: true
-  Channel: "🚨┃join-leave-logs"
+  Channel: "1111111111111111"
 
 Leave: 
   Enabled: true
-  Channel: "🚨┃join-leave-logs"
+  Channel: "1111111111111111"
 
 # ----------------------------
 #  Suggestions
 # ----------------------------
 
 Suggestions:
-  Channel: "📗┃suggestions"
+  Mode: "Channel" # Channel or Forum
+  ForumChannel: "1111111111111111"
+  Channel: "1111111111111111"
+
   UpvoteEmoji: "✅"
   DownvoteEmoji: "❌"
 
@@ -92,6 +106,7 @@ Suggestions:
   DownvoteTitle: "No"
 
   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
 
@@ -114,49 +129,85 @@ Suggestions:
     # 3 - Green
     # 4 - Red
 
+  Tags:
+   Created: "1111111111111111"
+   Considering: "1111111111111111"
+   Solved: "1111111111111111"
+   Denied: "1111111111111111"
+
 # -------------------------
 #  Tickets
 # -------------------------
 
+VoiceTickets:
+  Name: "%username%'s VC" 
+  Category: "1111111111111111"
+
 Ticket:
-  TicketCategory: "📗┃tickets" #Where tickets normally go with the /ticket command
-  # This is the channel name for the ticket threads to be created, NOT A DISCORD CATEGORY!
+  TicketType: "threads" 
+
+  # Available TicketTypes:
+  # channels - Tickets will be created as channels in the TicketChannelsCategory
+  # threads - Tickets will be created as threads through the "TicketHome" channel.
+
+  TicketHome: "1111111111111111" 
+
+  # 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: "1111111111111111" 
+  TicketChannelsCategory2: "1111111111111111" # This will be used if the first category has reached the max channel limit.
+  TicketArchiveCategory: "1111111111111111"
+  # ---
 
   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
 
-  Log:
-    TicketLog: "🚨┃ticket-data"
-    TicketLog_Title: "Ticket Closed"
-    DisableTicketLogChannel: false
-
-    TranscriptLog: "🚨┃ticket-data"
-    TranscriptTitle: "Ticket Transcript"
-
   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: "1249723473757077624" 
-    # Channel name or Channel ID
+    Channel: "1111111111111111" 
+    # 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: "🎫"
@@ -168,33 +219,52 @@ Ticket:
     # 3 - Green
     # 4 - Red
 
+  ReviewSystem:
+    Enabled: false                
+    Channel: "1111111111111111"
+    UseModal: true
 
-# -------------------------
-#   Departments - NOT IN THIS UPDATE
-# -------------------------
+  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?"
 
-Departments:
-  - title: "Create Ticket"
-    role: "Staff"
-    color: "2"
-    emoji: "🎫"
-    category: "TICKETS"
+  Log:
+    TicketDataLog: "1111111111111111"
+    TickeDataTitle: "Ticket Data"
+    TicketBlacklistLog: "1111111111111111"
 
 # -------------------------
 #  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
 # -------------------------
@@ -202,19 +272,27 @@ Buttons:
 SelectMenus:
   Tickets:
     PanelEmoji: "⚙️"
+    
     CloseEmoji: "🗑️"
     ArchiveEmoji: "♻️"
-    LockTicketEmoji: "🔒"
-    UnLockTicketEmoji: "🔓"
-    EnableInvitesEmoji: "🔒"
-    DisableInvitesEmoji: "🔓"
-    AddUserEmoji: "➕"
-    RemoveUserEmoji: "➖"
+    LockEmoji: "🔐"
+    RenameEmoji: "🏷️"
+    VCEmoji: "🔊"
 
+    EnableInvitesEmoji: "📤"
+    DisableInvitesEmoji: "📥"
 
 # -------------------------
-#  Misc
+#  Logging
 # -------------------------
 
+MessageDelete:
+  Channel: "1111111111111111"
+  Colour: "#d92525"
+
+MessageUpdate:
+  Channel: "1111111111111111"
+  Colour: "#f2a024"
+
 Translate:
-  Log: "🚨┃logs"
+  TranslateLog: "1111111111111111"

Configs/ticket-panel.yml

@@ -7,8 +7,11 @@
 #           SupportBot created by Emerald Services
 #           Installed with MIT License
 #
-#           Discord Support: https://emeraldsrv.dev/discord
-#           Community Resources: https://emeraldsrv.dev/resources
+#           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)
 
 # -------------------------------
 #   Ticket Panel Configuration
@@ -20,16 +23,24 @@ Panel: true
 #   Ticket Panel Message Configuration #2b2d31
 # ----------------------------------------
 
-Channel: "📗┃tickets"
-# The channel used to create the ticket panel, Use command /ticketpanel to generate it.
+Style:
+  Title: "## SupportBot Ticket Creation"
+  Description: "Click on the button to file a `Ticket` and our team will try their best to assist you in the best way we can!"
+  Image: "https://i.imgur.com/dejQvkg.png"
+  Color: "#45b463"
+  # Leave Color empty to remove the color from the embed/container.
 
-PanelTitle: "SupportBot"
-PanelColour: "#0cc559"
+  Layout: "3"
+
+# Available Layout Styles
+# "1" - Style 1 - Title & Text, Button at the top -- Image at the bottom
+# "2" - Style 2 - Title & Text, Button at the bottom -- Image at the top
+# "3" - Style 3 - The classic look - Title & Text at the top -- Image in the middle -- Button at the bottom
 
 Button:
   Text: "Create Ticket"
   Emoji: "🎫"
-  Color: "2"
+  Color: "3"
 
 # Available Button Styles
 # 1 - Blurple
@@ -37,10 +48,15 @@ Button:
 # 3 - Red
 # 4 - Green
 
-TicketPanel_Description: true
-TicketPanel_Thumbnail: false
-TicketPanel_Image: true
+Settings:
+  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!"
-PanelThumbnail: "https://i.imgur.com/ieeZejl.png"
-PanelImage: "https://i.imgur.com/dejQvkg.png"
+  # Text and divider will appear above the image.
+  TopTitle: true
+  TopDivider: true
+
+  # Text and divider will appear below the image.
+  BottomTitle: false
+  BottomDivider: false
+
+  # Note: If Image is set to false, the bottom and top settings will look the samme.

Data/BlacklistedUsers.json

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

Data/Profiles.json

@@ -1,7 +0,0 @@
-{
-    "419821884431925260": {
-        "bio": "Hi",
-        "timezone": "",
-        "isClockedIn": false
-    }
-}

Data/Profiles/294146279456636929.json

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

Data/Profiles/419821884431925260.json

@@ -1,5 +0,0 @@
-{
-  "clockedIn": true,
-  "bio": "Hi",
-  "timezone": "GMT"
-}

Data/Profiles/682708736359399524.json

@@ -1,5 +0,0 @@
-{
-  "bio": "This is the most W bio",
-  "timezone": "cst",
-  "clockedIn": false
-}

Data/StaffData.json

@@ -1,3 +0,0 @@
-[
-    "419821884431925260"
-]

Data/SuggestionData.json

@@ -1,16 +0,0 @@
-{
-  "1250864227460186240": {
-    "suggestion": "hi",
-    "author": "419821884431925260",
-    "upvotes": [
-      "419821884431925260"
-    ],
-    "downvotes": []
-  },
-  "1250900161958248533": {
-    "suggestion": "blob",
-    "author": "419821884431925260",
-    "upvotes": [],
-    "downvotes": []
-  }
-}

Data/SupportBot-AI.json

@@ -1,3 +1 @@
-{
-    
-}
+{}

Data/TicketData.json

@@ -1,184 +0,0 @@
-{
-    "tickets": [
-        {},
-        {
-            "id": "1253862843053510687",
-            "name": "ticket-0021",
-            "user": "419821884431925260",
-            "number": "0021",
-            "reason": "> No Reason Provided!",
-            "open": true,
-            "subUsers": [],
-            "createdAt": "2024-06-22T00:03:18.227Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1253863588012232727",
-            "name": "ticket-0022",
-            "user": "419821884431925260",
-            "number": "0022",
-            "reason": "> No Reason Provided!",
-            "open": true,
-            "subUsers": [],
-            "createdAt": "2024-06-22T00:06:16.126Z",
-            "claimedAt": "2024-06-22T00:09:12.693Z",
-            "claimedBy": "419821884431925260"
-        },
-        {
-            "id": "1255499438483574847",
-            "name": "ticket-0023",
-            "user": "419821884431925260",
-            "number": "0023",
-            "reason": "> No Reason Provided!",
-            "open": true,
-            "subUsers": [],
-            "createdAt": "2024-06-26T12:26:35.729Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1255500796355678229",
-            "name": "ticket-0024",
-            "user": "419821884431925260",
-            "number": "0024",
-            "reason": "> No Reason Provided!",
-            "open": true,
-            "subUsers": [],
-            "createdAt": "2024-06-26T12:31:56.888Z",
-            "claimedAt": "2024-06-26T12:32:41.240Z",
-            "claimedBy": "419821884431925260"
-        },
-        {
-            "id": "1255501873386094603",
-            "name": "ticket-0025",
-            "user": "419821884431925260",
-            "number": "0025",
-            "reason": "> No Reason Provided!",
-            "open": false,
-            "subUsers": [],
-            "createdAt": "2024-06-26T12:36:13.810Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1255508653906198709",
-            "name": "ticket-0026",
-            "user": "419821884431925260",
-            "number": "0026",
-            "reason": "> No Reason Provided!",
-            "open": true,
-            "subUsers": [],
-            "createdAt": "2024-06-26T13:03:10.321Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1256299016023572572",
-            "name": "ticket-0027",
-            "user": "419821884431925260",
-            "number": "0027",
-            "reason": "> No Reason Provided!",
-            "open": false,
-            "subUsers": [],
-            "createdAt": "2024-06-28T17:23:50.113Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1256300956824633426",
-            "name": "ticket-0028",
-            "user": "419821884431925260",
-            "number": "0028",
-            "reason": "> No Reason Provided!",
-            "open": false,
-            "subUsers": [],
-            "createdAt": "2024-06-28T17:31:31.454Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1256302271461986507",
-            "name": "ticket-0029",
-            "user": "419821884431925260",
-            "number": "0029",
-            "reason": "> No Reason Provided!",
-            "open": false,
-            "subUsers": [],
-            "createdAt": "2024-06-28T17:36:44.673Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1256303116505317457",
-            "name": "ticket-0030",
-            "user": "419821884431925260",
-            "number": "0030",
-            "reason": "> No Reason Provided!",
-            "open": true,
-            "subUsers": [],
-            "createdAt": "2024-06-28T17:40:06.292Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1257775687562166304",
-            "name": "ticket-0031",
-            "user": "419821884431925260",
-            "number": "0031",
-            "reason": "> No Reason Provided!",
-            "open": false,
-            "subUsers": [],
-            "createdAt": "2024-07-02T19:11:33.760Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1257776136843427841",
-            "name": "ticket-0032",
-            "user": "419821884431925260",
-            "number": "0032",
-            "reason": "> No Reason Provided!",
-            "open": false,
-            "subUsers": [],
-            "createdAt": "2024-07-02T19:13:20.641Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1257777774483996795",
-            "name": "ticket-0033",
-            "user": "419821884431925260",
-            "number": "0033",
-            "reason": "> No Reason Provided!",
-            "open": false,
-            "subUsers": [],
-            "createdAt": "2024-07-02T19:19:51.116Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1257778630600167535",
-            "name": "ticket-0034",
-            "user": "419821884431925260",
-            "number": "0034",
-            "reason": "> No Reason Provided!",
-            "open": false,
-            "subUsers": [],
-            "createdAt": "2024-07-02T19:23:15.328Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1257780259374366841",
-            "name": "ticket-0035",
-            "user": "419821884431925260",
-            "number": "0035",
-            "reason": "> No Reason Provided!",
-            "open": false,
-            "subUsers": [],
-            "createdAt": "2024-07-02T19:29:43.607Z",
-            "claimedAt": null
-        },
-        {
-            "id": "1257782171389657180",
-            "name": "ticket-0036",
-            "user": "419821884431925260",
-            "number": "0036",
-            "reason": "> No Reason Provided!",
-            "open": true,
-            "subUsers": [],
-            "createdAt": "2024-07-02T19:37:19.467Z",
-            "claimedAt": "2024-07-02T19:43:12.873Z",
-            "claimedBy": "419821884431925260"
-        }
-    ]
-}

Data/ticket-panel-id.json

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

Events/guildMemberAdd.js

@@ -1,55 +1,154 @@
-
-const Discord = require('discord.js');
+const {
+    EmbedBuilder,
+    ActionRowBuilder,
+    ButtonBuilder,
+    ButtonStyle,
+    MessageFlags,
+    ContainerBuilder,
+    TextDisplayBuilder,
+    SectionBuilder,
+    ThumbnailBuilder,
+    AttachmentBuilder
+} = require("discord.js");
 const fs = require("fs");
-const Event = require("../Structures/Event.js");
 const yaml = require("js-yaml");
+const Event = require("../Structures/Event.js");
 
 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")
 );
 
-module.exports = new Event("guildMemberAdd", async (client, member, interaction, guild) => {
+function getWelcomeThumbnail(client, member, iconCfg) {
+    switch ((iconCfg?.Mode || "").toUpperCase()) {
+        case "USER":
+            return member.user.displayAvatarURL();
+        case "BOT":
+            return client.user.displayAvatarURL();
+        case "CUSTOM":
+            return iconCfg.CustomURL;
+        default:
+            return null;
+    }
+}
 
-    if (supportbot.Welcome.Enabled) {
-        const WelcomeChannel = member.guild.channels.cache.find(channel => channel.name === supportbot.Welcome.Channel)
+function buildModernComponents(client, member) {
+    const container = new ContainerBuilder()
 
-        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))
-            .setTimestamp();
-        
-            if (msgconfig.Welcome.Embed.Thumbnail === "BOT") {
-                WelcomeEmbed.setThumbnail(client.user.displayAvatarURL())
-            }
-    
-            if (msgconfig.Welcome.Embed.Thumbnail === "USER") {
-                WelcomeEmbed.setThumbnail(member.user.displayAvatarURL())
-            }
-    
-            if (msgconfig.Welcome.Embed.ImageEnabled) {
-                WelcomeEmbed.setImage(msgconfig.Welcome.Embed.ImageURL)
-            }
-    
-            WelcomeChannel.send({
-                embeds: [WelcomeEmbed]
-            })
-    
-            if (supportbot.Roles.AutoRole.Enabled) {
-                var role = member.guild.roles.cache.find(role => role.name === supportbot.Roles.AutoRole.Role);
-                member.roles.add(role);
-            } 
-    
-            console.log(`\u001b[32m`, `[+]`, `\u001b[33m`, `${member.user.username} joined the server!`)
+    if (msgconfig.Welcome.Modern.Colour) {
+        container .setAccentColor(parseInt(msgconfig.Welcome.Modern.Colour.replace("#", ""), 16));
+    }
     
+    const section = new SectionBuilder().addTextDisplayComponents(
+        new TextDisplayBuilder().setContent(
+            msgconfig.Welcome.Modern.Title.replace(/%joined_user%/g, member.user)
+        ),
+        new TextDisplayBuilder().setContent(
+            msgconfig.Welcome.Modern.Body.replace(/%joined_user%/g, member.user)
+        )
+    );
+
+    const thumbUrl = getWelcomeThumbnail(client, member, msgconfig.Welcome.Modern.Icon);
+    if (thumbUrl) {
+        section.setThumbnailAccessory(
+            new ThumbnailBuilder()
+                .setURL(thumbUrl)
+        );
     }
 
-});
+    container.addSectionComponents(section);
+
+    if (msgconfig.Welcome.Modern.Image?.Enabled && msgconfig.Welcome.Modern.Image.URL) {
+        container.addTextDisplayComponents(
+            new TextDisplayBuilder().setContent(
+                `![image](${msgconfig.Welcome.Modern.Image.URL})`
+            )
+        );
+    }
+
+    if (Array.isArray(msgconfig.Welcome.Modern.Buttons)) {
+        const row = new ActionRowBuilder();
+        msgconfig.Welcome.Modern.Buttons.slice(0, 5).forEach(b => {
+            const btn = new ButtonBuilder()
+                .setLabel(b.label)
+                .setStyle(ButtonStyle[b.style])
+                .setEmoji(b.emoji || null);
+            if (b.style === "Link") btn.setURL(b.url);
+            else if (b.customId) btn.setCustomId(b.customId);
+            row.addComponents(btn);
+        });
+
+        container.addActionRowComponents(row);
+        
+    }
+
+    return [container];
+}
+
+module.exports = new Event("guildMemberAdd", async (client, member) => {
+    if (!supportbot.Welcome.Enabled) return;
+
+    const WelcomeChannel =
+        member.guild.channels.cache.get(supportbot.Welcome.Channel) ||
+        member.guild.channels.cache.find(c => c.name === supportbot.Welcome.Channel);
+    if (!WelcomeChannel) return;
+
+    const style = (msgconfig.Welcome.LayoutStyle || "classic").toLowerCase();
+
+    if (style === "classic") {
+        const WelcomeEmbed = new EmbedBuilder()
+            .setColor(msgconfig.Welcome.Embed.Colour)
+            .setTitle(msgconfig.Welcome.Embed.Title || null)
+            .setDescription(
+                msgconfig.Welcome.Embed.Message.replace(/%joined_user%/g, member.user)
+            )
+            .setTimestamp();
+
+        const thumb = getWelcomeThumbnail(client, member, msgconfig.Welcome.Embed.Icon);
+        if (thumb) WelcomeEmbed.setThumbnail(thumb);
+
+        if (msgconfig.Welcome.Embed.Image?.Enabled && msgconfig.Welcome.Embed.Image.URL) {
+            WelcomeEmbed.setImage(msgconfig.Welcome.Embed.Image.URL);
+        }
+
+        const components = [];
+        if (
+            msgconfig.Welcome.Embed.Buttons?.Enabled &&
+            Array.isArray(msgconfig.Welcome.Embed.Buttons.List)
+        ) {
+            const row = new ActionRowBuilder();
+            msgconfig.Welcome.Embed.Buttons.List.slice(0, 5).forEach(b => {
+                const btn = new ButtonBuilder()
+                    .setLabel(b.label)
+                    .setStyle(ButtonStyle[b.style])
+                    .setEmoji(b.emoji || null);
+                if (b.style === "Link") btn.setURL(b.url);
+                else if (b.customId) btn.setCustomId(b.customId);
+                row.addComponents(btn);
+            });
+            components.push(row);
+        }
+
+        await WelcomeChannel.send({ embeds: [WelcomeEmbed], components });
+    } else if (style === "modern") {
+        const components = buildModernComponents(client, member);
+        if (components.length > 0) {
+            await WelcomeChannel.send({
+                components,
+                flags: MessageFlags.IsComponentsV2
+            });
+        }
+    }
+
+    if (supportbot.Roles.AutoRole.Enabled) {
+        const role =
+            member.guild.roles.cache.get(supportbot.Roles.AutoRole.Role) ||
+            member.guild.roles.cache.find(r => r.name === supportbot.Roles.AutoRole.Role);
+        if (role) await member.roles.add(role);
+    }
+
+    console.log("\u001b[32m", "[+]", "\u001b[33m", `${member.user.username} joined the server!`);
+    
+});

Events/guildMemberRemove.js

@@ -1,50 +1,40 @@
-
-const Discord = require('discord.js');
+const { EmbedBuilder } = require("discord.js");
 const fs = require("fs");
-const Event = require("../Structures/Event.js");
 const yaml = require("js-yaml");
+const Event = require("../Structures/Event.js");
 
-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 supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const msgconfig   = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
 
-module.exports = new Event("guildMemberRemove", async (client, member, interaction, guild) => {
+module.exports = new Event("guildMemberRemove", async (client, member) => {
 
-    if (supportbot.Leave.Enabled) {
-        const LeaveChannel = member.guild.channels.cache.find(channel => channel.name === supportbot.Leave.Channel)
+    if (!supportbot.Leave || !supportbot.Leave.Enabled) return;
 
-        const LeaveEmbed = new Discord.EmbedBuilder()
-            .setColor(msgconfig.Leave.Embed.Colour)
-            .setTitle(msgconfig.Leave.Embed.Title)
-            .setDescription(msgconfig.Leave.Embed.Message.replace(/%joined_user%/g, member.user))
-            .setTimestamp();
-        
-            if (msgconfig.Leave.Embed.Thumbnail === "BOT") {
-                LeaveEmbed.setThumbnail(client.user.displayAvatarURL())
-            }
-    
-            if (msgconfig.Leave.Embed.Thumbnail === "USER") {
-                LeaveEmbed.setThumbnail(member.user.displayAvatarURL())
-            }
-    
-            if (msgconfig.Leave.Embed.ImageEnabled) {
-                LeaveEmbed.setImage(msgconfig.Leave.Embed.ImageURL)
-            }
-    
-            LeaveChannel.send({
-                embeds: [LeaveEmbed]
-            })
-    
-            console.log(`\u001b[31m`, `[-]`, `\u001b[33m`, `${member.user.username} left the server!`)
+    const leaveChannel =
+        member.guild.channels.cache.get(supportbot.Leave.Channel) ||
+        member.guild.channels.cache.find(c => c.name === supportbot.Leave.Channel);
+
+    if (!leaveChannel) return;
+
+    const leaveEmbed = new EmbedBuilder()
+        .setColor(msgconfig.Leave.Embed.Colour)
+        .setTitle(msgconfig.Leave.Embed.Title)
+        .setDescription(
+            msgconfig.Leave.Embed.Message.replace(/%left_user%/g, member.user.toString())
+        )
+        .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);
+    }
 
+    await leaveChannel.send({ embeds: [leaveEmbed] });
+
+    console.log(`[-] ${member.user.tag} left the server`);
+});

Events/interactionCreate.js

@@ -7,16 +7,11 @@ 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 suggestions;
-try {
-  suggestions = require("../Data/SuggestionData.json");
-} catch (error) {
-  suggestions = {};
-}
+const db = require("../Structures/Database.js");
 
 module.exports = new Event("interactionCreate", async (client, interaction) => {
-  if (interaction.type == Discord.InteractionType.ApplicationCommand) {
+
+  if (interaction.type === Discord.InteractionType.ApplicationCommand) {
     const command = client.commands.find(
       (cmd) => cmd.name.toLowerCase() === interaction.commandName
     );
@@ -24,12 +19,13 @@ module.exports = new Event("interactionCreate", async (client, interaction) => {
     if (interaction.user.bot || !interaction.guild) return;
 
     const NotValid = new Discord.EmbedBuilder()
-      .setDescription(`:x: \`Invalid Command\` `)
+      .setDescription(`:x: \`Invalid Command\``)
       .setColor(supportbot.Embed.Colours.Error);
 
     if (!command)
       return interaction.reply({
         embeds: [NotValid],
+        flags: Discord.MessageFlags.Ephemeral,
       });
 
     const permission = interaction.member.permissions.has(command.permissions);
@@ -43,40 +39,270 @@ module.exports = new Event("interactionCreate", async (client, interaction) => {
     if (!permission)
       return interaction.reply({
         embeds: [ValidPerms],
+        flags: Discord.MessageFlags.Ephemeral,
       });
-    command.run(interaction);
+
+    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.",
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
   }
 
+  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; 
+        await cmd.run(interaction);
+      } else {
+        console.error("Command not found.");
+      }
+    }
+  }
+
+  if (interaction.customId === "renameTicketModal") {
+    const newTicketName = interaction.fields.getTextInputValue("renameTicket");
+    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.",
+            flags: Discord.MessageFlags.Ephemeral,
+        });
+    }
+    try {
+        await ticketChannel.setName(newTicketName);
+        const renamedsuccess = new Discord.EmbedBuilder()
+            .setDescription(msgconfig.Ticket.RenamedSuccess)
+            .setColor(supportbot.Embed.Colours.Success);
+        return interaction.reply({
+            embeds: [renamedsuccess],
+            flags: Discord.MessageFlags.Ephemeral,
+        });
+    } catch (error) {
+        console.error("Error renaming the ticket:", error);
+        return interaction.reply({
+            content: "There was an error renaming the ticket.",
+            flags: Discord.MessageFlags.Ephemeral,
+        });
+    }
+}
+
   if (interaction.isStringSelectMenu()) {
     if (interaction.customId === "ticketcontrolpanel") {
       const selectedOption = interaction.values[0];
       const { getRole, getChannel } = interaction.client;
       switch (selectedOption) {
-        case "ticketadduser":
-          const AddUserThreadTicket = new Discord.EmbedBuilder()
-            .setTitle(`${msgconfig.Ticket.AddUserToTicket}`)
-            .setDescription(`${msgconfig.Ticket.AddUserToTicket}`)
-            .setColor(supportbot.Embed.Colours.General);
-
-          await interaction.reply({
-            embeds: [AddUserThreadTicket],
-            ephemeral: true,
-          });
-          break;
-
-        case "ticketremoveuser":
-          await removeUserFromThread(interaction);
-          break;
 
         case "ticketclose":
           const closeCommand = client.commands.get(cmdconfig.CloseTicket.Command);
           if (closeCommand) {
-            closeCommand.run(interaction);
+            await closeCommand.run(interaction);
           } else {
             console.error("[X] Close Command Not Found");
           }
           break;
 
+          case "supportvc":
+            const ticketInfo = db.getTicket(interaction.channel.id);
+            if (!ticketInfo) {
+              return interaction.reply({
+                content: "⚠️ This channel isn’t a valid ticket.",
+                flags: Discord.MessageFlags.Ephemeral
+              });
+            }
+
+            const user = interaction.guild.members.cache.get(ticketInfo.user_id) || ticketInfo.user_id;
+            const username = user?.user?.username || "Unknown User";
+
+            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!",
+                flags: Discord.MessageFlags.Ephemeral,
+              });
+            }
+
+            const SupportVoice = await interaction.guild.channels.create({
+              name: supportbot.VoiceTickets.Name.replace(/%username%/g, username),
+              type: Discord.ChannelType.GuildVoice,
+              parent: VCcategory,
+              permissionOverwrites: [
+                {
+                  id: interaction.guild.id,
+                  deny: [Discord.PermissionsBitField.Flags.Connect]
+                },
+                {
+                  id: user.id || user, // works if user is a Member or just ID
+                  allow: [
+                    Discord.PermissionsBitField.Flags.Connect,
+                    Discord.PermissionsBitField.Flags.Speak,
+                    Discord.PermissionsBitField.Flags.ViewChannel,
+                  ],
+                },
+              ],
+            });
+
+            db.updateTicketVoice(ticketInfo.ticket_id, SupportVoice.id);
+
+            const vcmadeembed = new Discord.EmbedBuilder()
+              .setDescription(`> **Support VC Created:** <#${SupportVoice.id}>`)
+              .setColor(supportbot.Embed.Colours.Success);
+
+            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);
+
+            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 tickets = db.getAllTickets();
+                  const ticketInfo = tickets.find(t => t.ticket_id === interaction.channel.id);
+                  if (ticketInfo) {
+                    const user = interaction.guild.members.cache.get(ticketInfo.user_id) || ticketInfo.user_id;
+                    const claimedBy = interaction.guild.members.cache.get(ticketInfo.claimed_by) || ticketInfo.claimed_by;
+                    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;
@@ -84,46 +310,202 @@ module.exports = new Event("interactionCreate", async (client, interaction) => {
         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.isButton()) {
-    if (interaction.customId === 'createticket') {
+  if (interaction.customId === 'deleteSupportVC') {
+    const ticketData = db.getAllTickets();
+    const ticketInfo = ticketData.find(t => t.ticket_id === interaction.channel.id);
+    if (ticketInfo && ticketInfo.voiceChannelId) {
       try {
-        const cmd = client.commands.get(cmdconfig.OpenTicket.Command);
-        if (!cmd) return;
-        cmd.run(interaction);
+        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],
+            flags: Discord.MessageFlags.Ephemeral,
+          });
+        } 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],
+            flags: Discord.MessageFlags.Ephemeral,
+          });
+        }
       } catch (error) {
-        console.error("Error executing the ticket command:", 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({
-          content: "An error occurred while creating the ticket.",
-          ephemeral: true,
+          embeds: [errorEmbed],
+          flags: Discord.MessageFlags.Ephemeral,
         });
       }
+    } 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],
+        flags: Discord.MessageFlags.Ephemeral,
+      });
+    }
+  }
+
+  if (interaction.isButton()) {
+    if (interaction.customId === "unarchiveTicket") {
+      if (supportbot.Ticket.TicketType === "threads") {
+        await interaction.channel.setArchived(false);
+      }
+      if (supportbot.Ticket.TicketType === "channels") {
+        const { getRole, getChannel } = interaction.client;
+        await interaction.channel.setParent(supportbot.Ticket.TicketChannelsCategory);
+        const ticketData = db.getAllTickets();
+        const ticketInfo = ticketData.find(t => t.ticket_id === interaction.channel.id);
+        if (ticketInfo) {
+          const user = interaction.guild.members.cache.get(ticketInfo.user_id) || ticketInfo.user_id;
+          const claimedBy = interaction.guild.members.cache.get(ticketInfo.claimed_by) || ticketInfo.claimed_by;
+          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)
+            )
+          );
+        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.",
+            flags: Discord.MessageFlags.Ephemeral,
+          });
+        }
+      }
     }
 
     if (interaction.customId === "openticket") {
-      try {
-        const cmd = client.commands.get(cmdconfig.OpenTicket);
-        if (!cmd) return;
-        cmd.run(interaction);
-      } catch (error) {
-        console.error(error);
+      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)
+            )
+          );
+        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 (interaction.customId.startsWith('claimticket-')) {
-      const ticketChannelId = interaction.customId.split('-')[1];
+    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,
+          flags: Discord.MessageFlags.Ephemeral,
         });
       }
 
-      const { getRole, getChannel } = interaction.client;
+      const { getRole } = interaction.client;
       const Staff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
       const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
 
@@ -135,92 +517,104 @@ module.exports = new Event("interactionCreate", async (client, interaction) => {
         .setColor(supportbot.Embed.Colours.Warn);
 
       if (!Staff || !Admin) {
-        return interaction.reply({
-          embeds: [RolePerms],
-          ephemeral: true,
-        });
+        return interaction.reply({ embeds: [RolePerms], ephemeral: true });
       }
 
       const NoPermsClaim = new Discord.EmbedBuilder()
         .setTitle(msgconfig.Ticket.ClaimTickets.NoPermsToClaimTitle)
         .setDescription(
-          msgconfig.Ticket.ClaimTickets.NoPermsToClaim.replace('%channel%', ticketChannel.name)
+          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,
+        return interaction.reply({ embeds: [NoPermsClaim], ephemeral: true });
+      }
+
+      if (supportbot.Ticket.TicketType === "threads") {
+        await ticketChannel.members.add(interaction.user.id);
+      } else {
+        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,
         });
       }
 
-      await ticketChannel.members.add(interaction.user.id);
       const pingclaimedstaff = await ticketChannel.send(`<@${interaction.user.id}>`);
+      setTimeout(() => pingclaimedstaff.delete(), 2000);
 
-      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 ticketInfo = db.getTicket(ticketChannelId);
+      if (ticketInfo) {
+        db.updateTicketStatus(ticketChannelId, ticketInfo.status);
+        ticketInfo.claimed_by = interaction.user.id;
       }
 
       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)
+          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))
+        .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,
-      });
+      await interaction.reply({ embeds: [successfullyClaimed], ephemeral: true });
     }
 
     // SUGGESTION INTERACTIONS [START]
-    
-    if (interaction.customId === 'upvote' || interaction.customId === 'downvote' || interaction.customId === 'removevote') {
+
+    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 });
+      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 (interaction.customId === "upvote") {
         if (hasUpvoted) {
-          suggestion.upvotes = suggestion.upvotes.filter(id => id !== userId);
+          suggestion.upvotes = suggestion.upvotes.filter((id) => id !== userId);
         } else {
           suggestion.upvotes.push(userId);
           if (hasDownvoted) {
-            suggestion.downvotes = suggestion.downvotes.filter(id => id !== userId);
+            suggestion.downvotes = suggestion.downvotes.filter((id) => id !== userId);
           }
         }
-      } else if (interaction.customId === 'downvote') {
+      } else if (interaction.customId === "downvote") {
         if (hasDownvoted) {
-          suggestion.downvotes = suggestion.downvotes.filter(id => id !== userId);
+          suggestion.downvotes = suggestion.downvotes.filter((id) => id !== userId);
         } else {
           suggestion.downvotes.push(userId);
           if (hasUpvoted) {
-            suggestion.upvotes = suggestion.upvotes.filter(id => id !== userId);
+            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);
+      } 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));
@@ -228,25 +622,36 @@ module.exports = new Event("interactionCreate", async (client, interaction) => {
       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 }
-        ]);
+      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.");
+        return interaction.reply(
+          "Some roles seem to be missing!\nPlease check for errors when starting the bot."
+        );
       }
 
       const NoPerms = new Discord.EmbedBuilder()
@@ -256,7 +661,10 @@ module.exports = new Event("interactionCreate", async (client, interaction) => {
         )
         .setColor(supportbot.Embed.Colours.Warn);
 
-      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] });
       }
     }
@@ -264,18 +672,15 @@ module.exports = new Event("interactionCreate", async (client, interaction) => {
     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);
+    const embed = new Discord.EmbedBuilder().setDescription(message).setColor(supportbot.Embed.Colours.General);
 
     await interaction.reply({
       embeds: [embed],
-      ephemeral: true,
+      flags: Discord.MessageFlags.Ephemeral,
     });
   }
 
-  // Modal submission handler for editing profile
-  if (interaction.type === Discord.InteractionType.ModalSubmit && interaction.customId === 'editProfileModal') {
+  if (interaction.type === Discord.InteractionType.ModalSubmit && interaction.customId === "editProfileModal") {
     const userId = interaction.user.id;
     const profilePath = `./Data/Profiles/${userId}.json`;
 
@@ -286,13 +691,13 @@ module.exports = new Event("interactionCreate", async (client, interaction) => {
       profileData = {
         bio: "",
         timezone: "",
-        clockedIn: false
+        clockedIn: false,
       };
     }
 
     try {
-      const newBio = interaction.fields.getTextInputValue('bio');
-      const newTimezone = interaction.fields.getTextInputValue('timezone');
+      const newBio = interaction.fields.getTextInputValue("bio");
+      const newTimezone = interaction.fields.getTextInputValue("timezone");
 
       profileData.bio = newBio;
       profileData.timezone = newTimezone;
@@ -304,22 +709,25 @@ module.exports = new Event("interactionCreate", async (client, interaction) => {
         .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 }
+          { 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
+          name: "Clocked In Status",
+          value: profileData.clockedIn ? "✅ Clocked In" : "❌ Clocked Out",
+          inline: true,
         });
       }
 
       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 });
+      await interaction.reply({
+        content: "There was an error while updating your profile. Please try again later.",
+        flags: Discord.MessageFlags.Ephemeral,
+      });
     }
   }
 });

Events/messageCreate.js

@@ -18,7 +18,6 @@ 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 => {
@@ -69,150 +68,99 @@ 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);
+if (supportbotai.Enabled) {
 
-        let conversation = [{
-            role: "system",
-            content: `SupportBot is your friendly neighbourhood support bot. Current date and time: ${new Date().toLocaleString()}.
-            The bot uses a modular command handler where commands are loaded dynamically from the './Commands' directory. Each command has a name, description, and execute method.
-            
-            The main Client class structure:
-            - Commands are loaded from the './Commands/' directory.
-            - Configs are loaded from the './Configs/' directory if enabled.
-            - Events are loaded from the './Events/' directory.
-            - Addons are loaded from the './Addons/' directory if enabled.
-            
-            Example of a command structure:
-            {
-                module.exports = new Command({
-                    name: cmdconfig.Ping.Command,
-                    description: cmdconfig.Ping.Description,
-                    options: [],
-                    permissions: cmdconfig.Ping.Permission,
-                )}
-            }
+    const sendTypingInterval = setInterval(() => {
+        message.channel.sendTyping();
+    }, 5000);
 
-            You can find more information about the commands and configuration files in the 'Configs' and 'Commands' directories.
+    let conversation = [{
+        role: "system",
+        content: "SupportBot is your friendly neighbourhood support bot."
+    }];
 
-            All commands are loaded into the bot at startup from ./Events/ready.js and ./Client.js.
+    let prevMessages = await message.channel.messages.fetch({ limit: 10 });
+    prevMessages = prevMessages.reverse().filter(msg => !msg.author.bot || msg.author.id === client.user.id);
 
-            If someone asks you to do something, you can use the 'assist' command to have the bot respond, For example: "Can I speak to a support agent?", You would respond by opening a ticket which is the /Commands/ticket.js file or you can tell them to create a ticket in the channel defined as supportbot.Ticket.
+    prevMessages.forEach((msg) => {
+        const username = msg.author.username.replace(/\s+/g, '_').replace(/[^\w\s]/gi, '');
 
-            You can find the source code for the bot at https://github.com/EmeraldServices/SupportBot.
+        conversation.push({
+            role: msg.author.id === client.user.id ? "assistant" : "user",
+            name: username,
+            content: msg.content,
+        });
+    });
 
-            You then need to understand how the bot works. Interactions are handled by the ./Events/interactionCreate.js file.
-            
-            Commands are filtered based on configuration settings and loaded into the bot at startup.
-            
-            Xiled Gaming Network (XGN) is a gaming community that typically offers various services and activities for gamers. 
-            
-            Xiled Gaming Network (XGN) has 4 divisions, Team Xiled International (TXI), The XiledOnes (TXO), Dealers of Death (DOD), Psychotic Solutions (PS)
-            Xiled Gaming Network (XGN) can be found at https://officialxgn.gg/handbook/, This is where you can the code of conduct, policies and other important information for members.
-            You can join XGN with the discord - discord.gg/xgn
-            You can apply to join the XGN Clan - join.officialxgn.gg
-            
-            You can find the founders of XGN under the history section of the handbook. https://officialxgn.gg/handbook/.
-            `
-        }];
-
-        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,
         });
 
-        try {
-            const response = await openai.chat.completions.create({
-                model: supportbotai.General.Model,
-                messages: conversation,
-                max_tokens: supportbotai.General.Tokens,
-            });
+        clearInterval(sendTypingInterval);
 
-            clearInterval(sendTypingInterval);
+        if (response.choices && response.choices.length > 0) {
+            const replyContent = response.choices[0].message.content;
 
-            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.toLowerCase().startsWith("generate image:")) {
-                    const prompt = replyContent.substring(15).trim();
-                    const imageUrl = await generateImage(prompt);
+            if (replyContent.length > 2000) {
+                const pasteLink = await createPaste(replyContent);
 
-                    const SupportBotAIImage = new Discord.EmbedBuilder()
-                        .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
-                        .setDescription(`Here is the image generated for your prompt: "${prompt}"`)
-                        .setImage(imageUrl)
-                        .setColor(supportbotai.Embed.Color)
-                        .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
-                        .setTimestamp();
-
-                    message.reply({ embeds: [SupportBotAIImage] });
-                } else {
-                    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()
+                const SupportBotAIPastebin = new Discord.EmbedBuilder()
                     .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
-                    .setDescription(supportbotai.Messages.ErrorResponse)
+                    .setDescription(supportbotai.Messages.MessageTooLong.replace("{pastebin}", pasteLink))
                     .setColor(supportbotai.Embed.Color)
                     .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
                     .setTimestamp();
 
-                message.reply({ embeds: [SupportBotAIErrorResponse], ephemeral: true });
+                message.reply({ embeds: [SupportBotAIPastebin] });
+            } else {
+                message.reply({ embeds: [SupportBotAI] });
             }
-        } catch (error) {
-            clearInterval(sendTypingInterval);
-
+        } else {
             const SupportBotAIErrorResponse = new Discord.EmbedBuilder()
                 .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
-                .setDescription(supportbotai.Messages.OpenAIError)
-                .setColor(supportbot.Embed.Colours.Error)
+                .setDescription(supportbotai.Messages.ErrorResponse)
+                .setColor(supportbotai.Embed.Color)
                 .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
                 .setTimestamp();
 
-            console.error('OpenAI Error:', error);
             message.reply({ embeds: [SupportBotAIErrorResponse], ephemeral: true });
         }
-    }
+    } catch (error) {
+        clearInterval(sendTypingInterval);
 
-    if (!supportbotai.Enabled) {
-        const AIDisabled = new Discord.EmbedBuilder()
+        const SupportBotAIErrorResponse = new Discord.EmbedBuilder()
             .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
-            .setDescription(supportbotai.Messages.AIDisabled)
+            .setDescription(supportbotai.Messages.OpenAIError)
             .setColor(supportbot.Embed.Colours.Error)
             .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
             .setTimestamp();
 
-        message.reply({ embeds: [AIDisabled], ephemeral: true });
-        return;
+        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

@@ -0,0 +1,36 @@
+const { EmbedBuilder } = require('discord.js');
+const fs = require("fs");
+const yaml = require("js-yaml");
+const Event = require("../Structures/Event.js");
+
+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) => {
+    if (!message.guild) return;
+
+    const author = message.author || (message.partial ? await message.fetch().then(m => m.author).catch(() => null) : null);
+    if (!author || author.bot) return;
+
+    const content = message.content || (message.attachments.size > 0 ? "Contains attachment(s)" : "*No content*");
+
+    const deleteLogChannel = message.guild.channels.cache.get(supportbot.MessageDelete.Channel) ||
+        message.guild.channels.cache.find(c => c.name === supportbot.MessageDelete.Channel);
+
+    const deletedMessageEmbed = new EmbedBuilder()
+        .setColor(supportbot.MessageDelete.Colour)
+        .setTitle("Message Deleted")
+        .setDescription(`> **Channel:** <#${message.channel.id}>\n> **Message ID:** ${message.id}\n> **Message author:** ${author.tag} (${author.id})\n> **Message Created:** <t:${Math.floor(message.createdTimestamp / 1000)}:F>`)
+        .addFields({ name: "Deleted Content", value: content, inline: false })
+        .setThumbnail(author.displayAvatarURL())
+        .setTimestamp();
+
+    if (message.attachments.size > 0) {
+        const attachment = message.attachments.first();
+        deletedMessageEmbed.addFields({ name: "Attachment", value: `[${attachment.name}](${attachment.proxyURL})` });
+    }
+
+    if (deleteLogChannel) {
+        deleteLogChannel.send({ embeds: [deletedMessageEmbed] });
+    }
+});

Events/messageUpdate.js

@@ -0,0 +1,57 @@
+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

@@ -1,202 +1,128 @@
-// SupportBot | Emerald Services
-// Ready Event
-
 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")
-);
-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");
+const gradient = require("gradient-string");
+const figlet = require("figlet");
 
-let chan1 = client.channels.cache.get(panelconfig.Channel);
+// Load configs
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const panel = 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"));
 
-module.exports = new Event("ready", async (client, interaction) => {
-  const { getRole, getChannel, getCategory } = client;
+const ACTIVITY_TYPES = {
+  PLAYING: Discord.ActivityType.Playing,
+  WATCHING: Discord.ActivityType.Watching,
+  LISTENING: Discord.ActivityType.Listening,
+  COMPETING: Discord.ActivityType.Competing
+};
 
-  if (supportbot.Activity.Type === "Playing", "playing") {
+const setActivity = (client, type, status) => {
+  const activityType = ACTIVITY_TYPES[type?.toUpperCase()];
+  if (activityType) {
     client.user.setPresence({
-      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Playing }],
-      status: supportbot.Activity.Type,
+      activities: [{ name: status || "Online", type: activityType }],
+      status: type?.toLowerCase() || "online"
     });
   }
+};
 
-  if (supportbot.Activity.Type === "Watching", "watching") {
-    client.user.setPresence({
-      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Watching }],
-      status: supportbot.Activity.Type,
-    });
-  }
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const logStartup = async (client) => {
+  console.clear();
   
-  if (supportbot.Activity.Type === "Listening", "listening") {
-    client.user.setPresence({
-      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Listening }],
-      status: supportbot.Activity.Type,
-    });
+  // Animated loading
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  for (let i = 0; i < frames.length * 2; i++) {
+    process.stdout.write(`\r${frames[i % frames.length]} Initializing SupportBot...`);
+    await sleep(100);
   }
+  console.clear();
 
-  if (supportbot.Activity.Type === "Competing", "competing") {
-    client.user.setPresence({
-      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Competing }],
-      status: supportbot.Activity.Type,
-    });
-  }
+  // Main title
+  console.log("\n" + gradient.pastel.multiline(figlet.textSync("SupportBot", { font: "ANSI Shadow", horizontalLayout: "fitted" })));
 
-  console.log(`\u001b[32m`, `――――――――――――――――――――――――――――――――――――――――――――`);
-  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[32m`, `――――――――――――――――――――――――――――――――――――――――――――`);
-  console.log(`    `);
-  console.log(
-    `\u001b[31m`,
-    `${supportbot.General.Name} | [${supportbot.SupportBot_Version}]`,
-    `\u001b[32m`,
-    `Connected to Discord`,
-  );
-  
-  console.log(`\u001b[31m`, `SupportBot proudly created by Emerald Development`);
+  // Extract bot details safely
+  const botName = supportbot?.General?.Name || "SupportBot";
+  const botVersion = supportbot.SupportBot_Version;
 
-  console.log(`    `);
+  console.log("\n╔═══════════════════════════════════════════════════════════════╗");
+  console.log("║                      System Information                       ║");
+  console.log("╠═══════════════════════════════════════════════════════════════╣");
+  console.log(`║  Bot Name    : ${botName.padEnd(45)}  ║`);
+  console.log(`║  Version     : ${botVersion.padEnd(45)}  ║`);
+  console.log(`║  Node.js     : ${process.version.padEnd(45)}  ║`);
+  console.log(`║  Discord.js  : v${Discord.version.padEnd(44)}  ║`);
+  console.log("╚═══════════════════════════════════════════════════════════════╝\n");
 
-  console.log(
-    `\u001b[31m`,
-    `Discord`,
-    `\u001b[32m`,
-    `https://dsc.gg/emerald-dev`,
-  );
+  // Links section
+  console.log(gradient.summer("┏━━━━━━━━━━━━━━━━━━━ Important Links ━━━━━━━━━━━━━━━━━━━┓"));
+  console.log(gradient.summer("┃                                                       ┃"));
+  console.log(gradient.summer("┃  ") + "📚 Docs       : " + gradient.cristal("https://emerald-services.gitbook.io/ ┃"));
+  console.log(gradient.summer("┃  ") + "🤝 Discord    : " + gradient.cristal("https://dsc.gg/emerald-dev           ┃"));
+  console.log(gradient.summer("┃                                                       ┃"));
+  console.log(gradient.summer("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n"));
 
-  console.log(
-    `\u001b[31m`,
-    `Website`,
-    `\u001b[32m`,
-    `https://emeraldsrv.com`,
-  );
+  // Bot Invite
+  const inviteUrl = `https://discord.com/api/oauth2/authorize?client_id=${client.user.id}&permissions=8&scope=bot%20applications.commands`;
+  console.log(gradient.teen("╔════════════════════════ Bot Invite ════════════════════════╗"));
+  console.log(gradient.teen("║                                                            ║"));
+  console.log(gradient.teen("║  ") + gradient.pastel(inviteUrl.padEnd(56)) + gradient.teen("║"));
+  console.log(gradient.teen("║                                                            ║"));
+  console.log(gradient.teen("╚════════════════════════════════════════════════════════════╝\n"));
+};
 
-  console.log(
-    `\u001b[31m`,
-    `Marketplace`,
-    `\u001b[32m`,
-    `https://market.emeraldsrv.com`,
-  );
+const checkConfigs = async (client) => {
+  const guild = client.guilds.cache.first();
+  if (!guild) return;
 
-  console.log(
-    `\u001b[31m`,
-    `Documentation`,
-    `\u001b[32m`,
-    `https://emeraldsrv.com/third-party`,
-  );
-
-  console.log(`    `);
-
-  console.log(
-    `\u001b[31m`,
-    `Invite URL:`,
-    `\u001b[36m`,
-    `https://discord.com/api/oauth2/authorize?client_id=` +
-      client.user.id +
-      `&permissions=8&scope=bot%20applications.commands`
-  );
-
-  console.log(`    `);
-  console.log(`\u001b[32m`, `――――――――――――――――――――――――――――――――――――――――――――`);
+  console.log(gradient.morning("┏━━━━━━━━━━━━━━━━━━━━ Config Check ━━━━━━━━━━━━━━━━━━━━━┓"));
 
   const roles = [
-    supportbot.Roles.StaffMember.Admin,
-    supportbot.Roles.StaffMember.Staff,
-    supportbot.Roles.ModRoles.Blacklisted,
-    supportbot.Roles.ModRoles.Muted
-  ];
+    supportbot?.Roles?.StaffMember?.Admin,
+    supportbot?.Roles?.StaffMember?.Staff,
+    supportbot?.Roles?.AutoRole?.Role
+  ].filter(Boolean);
 
-    supportbot.Departments.forEach((department) => roles.push(department.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
+  ].filter(Boolean);
 
-  if (supportbot.Roles.AutoRole.Role) roles.push(supportbot.Roles.AutoRole.Role);
-  
-   const channels = [
-     supportbot.Suggestions.Channel,
-     supportbot.Ticket.Log.TicketLog,
-     supportbot.Ticket.Log.TranscriptLog,
-     panelconfig.Channel,
-     supportbot.Welcome.Channel,
-     supportbot.Leave.Channel,
-     supportbot.Translate.Log
-   ];
-  //const categories = [supportbot.TicketCategory];
+  const [missingRoles, missingChannels] = await Promise.all([
+    Promise.all(roles.map((role) => client.getRole(role, guild))),
+    Promise.all(channels.map((channel) => client.getChannel(channel, guild)))
+  ]);
 
-  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.`);
-//  }
+  const missing = {
+    roles: roles.filter((_, i) => !missingRoles[i]),
+    channels: channels.filter((_, i) => !missingChannels[i])
+  };
 
-  const missingC = [];
-  const missingR = [];
-  const missingCat = [];
-  
-  for (let r of roles) {
-    const find = await getRole(r, client.guilds.cache.first());
-    if (!find) missingR.push(r);
-  }
- // for (let cat of categories) {
- //   const find = await getCategory(cat, client.guilds.cache.first());
- //   if (!find) missingCat.push(cat);
- // }
-
-  if (missingR.length > 0) {
-    console.log(
-      "\u001b[31m",
-      `[MISSING CONFIGURATION]`,
-      "\u001b[33m",
-      `The following Roles could not be found in your server.\n`, `\u001b[31m`, `[${missingR.join(
-        ", "
-      )}]`, `\n  `,
-    );
+  if (missing.roles.length || missing.channels.length) {
+    console.log(gradient.morning("┃  ⚠️ - Configuration Issues Found:                     ┃"));
+    if (missing.roles.length) {
+      console.log(gradient.morning("┃  • Missing Roles: ") + gradient.fruit(missing.roles.join(", ")));
+    }
+    if (missing.channels.length) {
+      console.log(gradient.morning("┃  • Missing Channels: ") + gradient.fruit(missing.channels.join(", ")));
+    }
+  } else {
+    console.log(gradient.morning("┃  ✅ - All configurations validated successfully       ┃"));
   }
 
-  if (missingC.length > 0) {
-    console.log(
-      "\u001b[31m",
-      `[MISSING CONFIGURATION]`,
-      "\u001b[33m",
-      `The following Channels could not be found in your server.\n`, `\u001b[31m`, `[${missingC.join(
-        ", "
-      )}]`, `\n  `
-    );
-  }
-  if (missingCat.length > 0) {
-    console.log(
-      "\u001b[31m",
-      `[MISSING CONFIGURATION]`,
-      "\u001b[33m",
-      `The following Categories could not be found in your server.\n`, `\u001b[31m`, `[${missingCat.join(
-        ", "
-      )}]`, `\n  `,
-    );
-  }
+  console.log(gradient.morning("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n"));
+};
+
+module.exports = new Event("clientReady", async (client) => {
+  setActivity(client, supportbot?.Activity?.Type, supportbot?.Activity?.Status);
+  await logStartup(client);
+  await checkConfigs(client);
 });

LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Emerald Services
+Copyright (c) 2025 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

@@ -13,11 +13,11 @@
 </a>
 
 <a href="https://github.com/discordjs">
-    <img src="https://img.shields.io/badge/discord.js-v13.6.x-blue.svg?style=for-the-badge&logo=javascript.svg" alt="shield.png">
+    <img src="https://img.shields.io/badge/DISCORD.JS%20-%20v14-blue?style=for-the-badge" alt="shield.png">
 </a>
 
 <a href="https://github.com/nodejs/node">
-    <img src="https://img.shields.io/badge/node.js-v16.14.x-green.svg?style=for-the-badge&logo=node" alt="shield.png">
+    <img src="https://img.shields.io/badge/NODE.JS%20-%20v20.x-green?style=for-the-badge" alt="shield.png">
 </a>
 
 <a href="https://github.com/Emerald-Services/SupportBot/releases">
@@ -84,5 +84,13 @@ 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
+)
+
 
 

Structures/Addon.js

@@ -1,6 +1,6 @@
+
 // SupportBot | Emerald Services
 // Addon Structure
-
 class Command {
   constructor(options) {
     this.name = options.name;
@@ -10,7 +10,13 @@ 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,28 +1,45 @@
 const fs = require("fs");
+const path = require("path");
 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
+const { Command, Event } = require('./Addon.js');
 
 const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
 const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
 
+
+function walk(dir, ext = ".js", fileList = []) {
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const full = `${dir}/${file}`;
+    const stat = fs.statSync(full);
+    if (stat.isDirectory()) {
+      walk(full, ext, fileList);
+    } else if (file.endsWith(ext)) {
+      fileList.push(full);
+    }
+  }
+  return fileList;
+}
+
 class Client extends Discord.Client {
   constructor() {
     super({
       intents: [
         GatewayIntentBits.Guilds,
         GatewayIntentBits.GuildMembers,
-        GatewayIntentBits.GuildMessages
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent
       ],
-      partials: [Partials.Channel]
+      partials: [Partials.Message, Partials.Channel]
     });
 
     this.commands = new Discord.Collection();
   }
 
   async getChannel(channel, guild) {
-    if (!channel) return null; // Add check for undefined channel
+    if (!channel) return null;
     return guild.channels.cache.find(
       (c) =>
         (c.type === Discord.ChannelType.GuildText || c.type === Discord.ChannelType.GuildNews) &&
@@ -31,14 +48,14 @@ class Client extends Discord.Client {
   }
 
   async getRole(role, guild) {
-    if (!role) return null; // Add check for undefined role
+    if (!role) return null;
     return guild.roles.cache.find(
       (r) => r.id === role || (r.name && r.name.toLowerCase() === role.toLowerCase())
     );
   }
 
   async getCategory(category, guild) {
-    if (!category) return null; // Add check for undefined category
+    if (!category) return null;
     return guild.channels.cache.find(
       (c) =>
         c.type === Discord.ChannelType.GuildCategory &&
@@ -47,61 +64,83 @@ class Client extends Discord.Client {
   }
 
   async start(token) {
-    let tempCommandFiles = fs.readdirSync("./Commands").filter((file) => file.endsWith(".js"));
+    let tempCommandFiles = walk("./Commands");
 
     if (cmdconfig.Suggestion.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "suggest.js");
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "suggest.js");
+    }
+
+    if (cmdconfig.Suggestion.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "suggestadmin.js");
     }
 
     if (cmdconfig.Help.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "help.js");
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "help.js");
     }
 
     if (cmdconfig.Info.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "info.js");
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "info.js");
     }
 
     if (cmdconfig.OpenTicket.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "ticket.js");
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "ticket.js");
     }
 
     if (cmdconfig.CloseTicket.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "close.js");
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "close.js");
     }
 
     if (cmdconfig.Embed.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "embed.js");
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "embed.js");
     }
 
     if (cmdconfig.Translate.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "translate.js");
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "translate.js");
     }
 
     if (cmdconfig.UserInfo.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "userinfo.js");
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "userinfo.js");
     }
 
     if (cmdconfig.Ping.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "Ping.js");
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "Ping.js");
     }
 
-    if (supportbot.Ticket.ClaimTickets.Enabled === false) {
-      tempCommandFiles = tempCommandFiles.filter(item => item !== "ticketstats.js");
+    if (cmdconfig.AddUser.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "addUser.js");
     }
 
+    if (cmdconfig.RemoveUser.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "removeUser.js");
+    }    
+
+    if (cmdconfig.ForceAddUser.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "forceaddUser.js");
+    }   
+
+    if (cmdconfig.Profile.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "profile.js");
+    }    
+
+    if (cmdconfig.Settings.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "settings.js");
+    }    
+
+    if (cmdconfig.Mod.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => path.basename(item) !== "mod.js");
+    }    
+
     const commandFiles = tempCommandFiles;
-    const commands = commandFiles.map((file) => require(`../Commands/${file}`));
+    const commands = commandFiles.map((file) => require(`../${file}`));
 
-    // Load main commands
-    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Commands ▬▬▬▬▬▬▬");
+    console.log(`\u001b[33m`, "――――――――――――――――――――――――――――――――――――――――――――");
 
     commands.forEach((cmd) => {
       console.log(`\u001b[32m`, `[CMD]`, `\u001b[37;1m`, `${cmd.name}`, `\u001b[32;1m`, "Loaded");
       this.commands.set(cmd.name, cmd);
     });
 
-    // Load addon commands and events
-    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Commands ▬▬▬▬▬▬▬");
+    console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Commands ▬▬▬▬▬▬▬");
 
     if (supportbot.General.Addons.Enabled) {
       const addonFiles = fs.readdirSync("./Addons").filter((file) => file.endsWith(".js"));
@@ -112,9 +151,8 @@ class Client extends Discord.Client {
         return addon;
       });
 
-      // Addons
       console.log("   ");
-      console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Addons ▬▬▬▬▬▬▬");
+      console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Addons ▬▬▬▬▬▬▬");
 
       addons.forEach((addon) => {
         console.log(
@@ -139,12 +177,10 @@ class Client extends Discord.Client {
         }
       });
 
-      console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Addons ▬▬▬▬▬▬▬");
+      console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Addons ▬▬▬▬▬▬▬");
     }
 
-    // Register Slash Commands
-
-    this.once("ready", async () => {
+    this.once("clientReady", async () => {
       await this.guilds.cache.first()?.commands.set(this.commands);
       console.log(
         "\u001b[32m",
@@ -155,7 +191,7 @@ class Client extends Discord.Client {
     });
 
     console.log("   ");
-    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
+    console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
 
     fs.readdirSync("./Events").filter((file) => file.endsWith(".js")).forEach((file) => {
       const event = require(`../Events/${file}`);
@@ -163,7 +199,7 @@ class Client extends Discord.Client {
       this.on(event.event, (...args) => event.run(this, ...args));
     });
 
-    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
+    console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
     if (process.argv[2] !== "test") {
       await this.login(token);
     } else {

Structures/Database.js

@@ -0,0 +1,221 @@
+// SupportBot | Emerald Services
+// Database Structure
+
+const Database = require("better-sqlite3");
+const path = require("path");
+
+const db = new Database(path.join(__dirname, "../Data/supportbot.db"));
+
+db.prepare(`
+  CREATE TABLE IF NOT EXISTS suggestions (
+    thread_id TEXT PRIMARY KEY,
+    author_id TEXT,
+    text      TEXT,
+    status    TEXT DEFAULT 'Created'
+  )
+`).run();
+
+db.prepare(`
+  CREATE TABLE IF NOT EXISTS profiles (
+    user_id   TEXT PRIMARY KEY,
+    bio       TEXT,
+    timezone  TEXT,
+    clockedIn INTEGER DEFAULT 0
+  )
+`).run();
+
+db.prepare(`
+  CREATE TABLE IF NOT EXISTS tickets (
+    ticket_id      TEXT PRIMARY KEY,
+    user_id        TEXT,
+    status         TEXT DEFAULT 'open',
+    created_at     INTEGER,
+    updated_at     INTEGER,
+    subject        TEXT,
+    description    TEXT
+  )
+`).run();
+
+try {
+  db.prepare("ALTER TABLE tickets ADD COLUMN voiceChannelId TEXT").run();
+} catch (e) {
+  if (!String(e).includes("duplicate column name")) {
+    throw e;
+  }
+}
+
+db.prepare(`
+  CREATE TABLE IF NOT EXISTS ticket_panel (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    message_id TEXT,
+    channel_id TEXT,
+    created_at INTEGER
+  )
+`).run();
+
+db.prepare(`
+  CREATE TABLE IF NOT EXISTS ticket_users (
+    ticket_id TEXT,
+    user_id   TEXT,
+    PRIMARY KEY(ticket_id, user_id)
+  )
+`).run();
+
+db.prepare(`
+  CREATE TABLE IF NOT EXISTS settings (
+    id   INTEGER PRIMARY KEY,
+    data TEXT
+  )
+`).run();
+
+module.exports = {
+  addSuggestion(threadId, authorId, text) {
+    db.prepare(`
+      INSERT INTO suggestions (thread_id, author_id, text)
+      VALUES (@threadId, @authorId, @text)
+      ON CONFLICT(thread_id) DO NOTHING
+    `).run({ threadId, authorId, text });
+  },
+
+  setSuggestionStatus(threadId, status) {
+    db.prepare(`
+      UPDATE suggestions SET status=@status WHERE thread_id=@threadId
+    `).run({ threadId, status });
+  },
+
+  getSuggestion(threadId) {
+    return db.prepare(`
+      SELECT * FROM suggestions WHERE thread_id=@threadId
+    `).get({ threadId });
+  },
+
+  // ----- Profiles -----
+  getProfile(userId) {
+    const row = db.prepare(`SELECT * FROM profiles WHERE user_id=?`).get(userId);
+    if (!row) {
+      db.prepare(`
+        INSERT INTO profiles (user_id, bio, timezone, clockedIn)
+        VALUES (?, '', '', 0)
+      `).run(userId);
+      return { user_id: userId, bio: "", timezone: "", clockedIn: 0 };
+    }
+    return row;
+  },
+
+  updateProfile(userId, data) {
+    const { bio = "", timezone = "", clockedIn = 0 } = data;
+    db.prepare(`
+      INSERT INTO profiles (user_id, bio, timezone, clockedIn)
+      VALUES (@userId, @bio, @timezone, @clockedIn)
+      ON CONFLICT(user_id) DO UPDATE SET
+        bio       = excluded.bio,
+        timezone  = excluded.timezone,
+        clockedIn = excluded.clockedIn
+    `).run({ userId, bio, timezone, clockedIn });
+  },
+
+  setClockedIn(userId, value) {
+    db.prepare(`UPDATE profiles SET clockedIn=? WHERE user_id=?`)
+      .run(value ? 1 : 0, userId);
+  },
+
+  addTicket(ticket) {
+    const now = Date.now();
+    db.prepare(`
+      INSERT INTO tickets (ticket_id, user_id, subject, description, created_at, updated_at)
+      VALUES (@ticket_id, @user_id, @subject, @description, @created_at, @updated_at)
+      ON CONFLICT(ticket_id) DO NOTHING
+    `).run({
+      ticket_id: ticket.id,
+      user_id: ticket.user,
+      subject: ticket.reason || "",
+      description: ticket.description || "",
+      created_at: now,
+      updated_at: now
+    });
+  },
+
+  updateTicketVoice(ticketId, voiceChannelId) {
+    db.prepare(`
+      UPDATE tickets SET voiceChannelId=@voiceChannelId, updated_at=@updatedAt WHERE ticket_id=@ticketId
+    `).run({ ticketId, voiceChannelId, updatedAt: Date.now() });
+  },
+
+  getTicketVoice(ticketId) {
+    return db.prepare(`SELECT voiceChannelId FROM tickets WHERE ticket_id=?`).get(ticketId);
+  },
+
+  deleteTicketVoice(ticketId) {
+    db.prepare(`
+      UPDATE tickets SET voiceChannelId=NULL, updated_at=@updatedAt WHERE ticket_id=@ticketId
+    `).run({ ticketId, updatedAt: Date.now() });
+  },
+
+  updateTicketStatus(ticketId, status) {
+    db.prepare(`
+      UPDATE tickets SET status=@status, updated_at=@updatedAt WHERE ticket_id=@ticketId
+    `).run({ status, updatedAt: Date.now(), ticketId });
+  },
+
+  getTicket(ticketId) {
+    return db.prepare(`
+      SELECT * FROM tickets WHERE ticket_id=@ticketId
+    `).get({ ticketId });
+  },
+
+  getAllTickets() {
+    return db.prepare(`SELECT * FROM tickets`).all();
+  },
+
+  saveTicketPanel(messageId, channelId) {
+    db.prepare(`
+      INSERT INTO ticket_panel (message_id, channel_id, created_at)
+      VALUES (@messageId, @channelId, @createdAt)
+    `).run({ messageId, channelId, createdAt: Date.now() });
+  },
+
+  getTicketPanel() {
+    return db.prepare(`
+      SELECT * FROM ticket_panel ORDER BY id DESC LIMIT 1
+    `).get();
+  },
+
+  addUserToTicket(ticketId, userId) {
+    db.prepare(`
+      INSERT INTO ticket_users (ticket_id, user_id)
+      VALUES (?, ?)
+      ON CONFLICT(ticket_id, user_id) DO NOTHING
+    `).run(ticketId, userId);
+  },
+
+  removeUserFromTicket(ticketId, userId) {
+    db.prepare(`
+      DELETE FROM ticket_users WHERE ticket_id=? AND user_id=?
+    `).run(ticketId, userId);
+  },
+
+  getTicketUsers(ticketId) {
+    return db.prepare(`
+      SELECT user_id FROM ticket_users WHERE ticket_id=?
+    `).all(ticketId).map(r => r.user_id);
+  },
+
+  getSettings() {
+    const row = db.prepare(`SELECT data FROM settings WHERE id=1`).get();
+    if (!row) return {};
+    try {
+      return JSON.parse(row.data);
+    } catch {
+      return {};
+    }
+  },
+
+  saveSettings(obj) {
+    const data = JSON.stringify(obj);
+    db.prepare(`
+      INSERT INTO settings (id, data)
+      VALUES (1, @data)
+      ON CONFLICT(id) DO UPDATE SET data = excluded.data
+    `).run({ data });
+  }
+};

Structures/Event.js

@@ -1,5 +1,6 @@
 // SupportBot | Emerald Services
 // Event Structure
+
 class Event {
   constructor(event, run) {
     this.event = event;

Structures/TicketID.js

@@ -1,47 +1,30 @@
 // SupportBot | Emerald Services
 // Ticket ID Structure
 
-const fs = require("fs");
+const db = require("./Database")
 
 class TicketNumberID {
   static async pad() {
-    let num = await this.get();
-    let n = num + "";
-    await this.set(num + 1);
-    return n.length >= 4 ? n : new Array(4 - n.length + 1).join("0") + n;
+    let num = await this.get()
+    let n = num + ""
+    await this.set(num + 1)
+    return n.length >= 4 ? n : new Array(4 - n.length + 1).join("0") + n
   }
 
   static async get() {
-    let ticketnumberID = await JSON.parse(
-      fs.readFileSync("./Data/ticket-panel-id.json", "utf8")
-    );
-    if (!ticketnumberID.id) {
-      return this.set(0);
-    } else {
-      return ticketnumberID.id;
-    }
+    const row = db.getTicketPanel()
+    if (!row) return await this.set(0)
+    return row.id
   }
 
   static async set(value) {
-    let ticketnumberID = await JSON.parse(
-      fs.readFileSync("./Data/ticket-panel-id.json", "utf8")
-    );
-
-    ticketnumberID.id = value;
-    fs.writeFileSync(
-      "./Data/ticket-panel-id.json",
-      JSON.stringify(ticketnumberID, null, 4),
-      (err) => {
-        if (err) console.error(err);
-      }
-    );
-
-    return value;
+    db.saveTicketPanel(`panel-${value}`, "none")
+    return value
   }
 
   static async reset() {
-    return await this.set(0);
+    return await this.set(0)
   }
 }
 
-module.exports = TicketNumberID;
+module.exports = TicketNumberID

index.js

@@ -8,9 +8,10 @@
 //           Installed with MIT License
 //
 //           Discord Support: https://emeraldsrv.dev/discord
-//           Community Resources: https://emeraldsrv.dev/resources
+//           Community Resources: https://community.emeraldsrv.dev
 
 const fs = require("fs");
+const path = require("path");
 
 const yaml = require("js-yaml");
 const supportbot = yaml.load(
@@ -19,18 +20,56 @@ const supportbot = yaml.load(
 
 const Client = require("./Structures/Client.js");
 const client = new Client({
-  intents: ['Guilds', 'GuildMembers', 'GuildMessages']
+  intents: ['Guilds', 'GuildMembers', 'GuildMessages', 'MessageContent']
 });
 
 client.start(supportbot.General.Token);
 
-
-
-
-
-
-
-
+// SupportBot - New Logging System
+
+const logTypes = ["Output", "Warn", "Error"];
+
+if (!fs.existsSync("./Logs")) {
+  fs.mkdirSync("./Logs");
+}
+logTypes.forEach((type) => {
+  const dir = `./Logs/${type}`;
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+});
+
+function logToFile(type, data) {
+  const date = new Date().toISOString().split("T")[0];
+  const file = path.join(`./Logs/${type}`, `${type}-${date}.log`);
+  fs.appendFileSync(file, `[${new Date().toISOString()}] ${data}\n`);
+}
+
+const origLog = console.log;
+console.log = (...args) => {
+  origLog(...args);
+  logToFile("Output", args.join(" "));
+};
+
+const origWarn = console.warn;
+console.warn = (...args) => {
+  origWarn(...args);
+  logToFile("Warn", args.join(" "));
+};
+
+const origError = console.error;
+console.error = (...args) => {
+  origError(...args);
+  logToFile("Error", args.join(" "));
+};
+
+process.on("unhandledRejection", (reason) => {
+  console.error("Unhandled Rejection:", reason);
+});
+
+process.on("uncaughtException", (err) => {
+  console.error("Uncaught Exception:", err);
+});
 
 
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "supportbot",
-  "version": "8.0.1",
+  "version": "8.4",
   "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": {
@@ -16,14 +16,17 @@
   "bugs": {
     "url": "https://github.com/Emerald-Services/SupportBot/issues"
   },
-  "homepage": "https://github.com/Emerald-Services/SupportBot#readme",
+  "homepage": "https://community.emeraldsrv.dev",
   "dependencies": {
-    "@vitalets/google-translate-api": "^8.0.0",
     "axios": "^1.7.2",
-    "chatgpt": "^5.2.5",
+    "better-sqlite3": "^12.2.0",
     "discord.js": "^14.13.0",
+    "figlet": "^1.9.3",
+    "gradient-string": "^3.0.0",
+    "js": "^0.1.0",
     "js-yaml": "^4.1.0",
     "moment": "^2.29.3",
+    "ms": "^2.1.3",
     "openai": "^4.50.0"
   }
 }