7.3

SupportBot 7.1 merge to main branch

.github/workflows/node.js.yml

@@ -0,0 +1,31 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x, 14.x, 15.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm ci
+      - run: npm install discord.js --save
+      - run: npm install js-yaml
+      - run: npm run build --if-present
+      - run: node index.js

.gitignore

@@ -0,0 +1 @@
+node_modules/

Addons/hello.js

@@ -0,0 +1,31 @@
+// SupportBot | Emerald Services
+// Example (default) Addon
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(fs.readFileSync("./Data/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Data/commands.yml", "utf8"));
+
+// Your Addon Config file! Saved in /Addons/Settings/YourAddonConfig.yml
+//  const exampleaddon = yaml.load(fs.readFileSync('./Addons/Settings/YourAddonConfig.yml', 'utf8'));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: "hello",
+  description: "hello",
+  slashCommandOptions: [],
+  permission: "SEND_MESSAGES",
+
+  async run(interaction) {
+    const Embed = new Discord.MessageEmbed()
+      .setDescription("Hello World!")
+      .setColor(supportbot.InfoColour);
+
+    interaction.reply({
+      embeds: [Embed],
+    });
+  },
+});

Commands/add.js

@@ -0,0 +1,95 @@
+// SupportBot | Emerald Services
+// Ticket Add Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+async function asyncForEach(array, callback) {
+  for (let index = 0; index < array.length; index++) {
+    await callback(array[index], index, array);
+  }
+}
+
+module.exports = new Command({
+  name: cmdconfig.TicketAdd,
+  description: cmdconfig.TicketAddDesc,
+  slashCommandOptions: [
+    {
+      name: "user",
+      description: "User to add",
+      type: "USER",
+      required: true,
+    },
+  ],
+  permission: "SEND_MESSAGES",
+
+  async run(interaction) {
+    let SupportStaff =
+      interaction.guild.roles.cache.find(
+        (SupportTeam) => SupportTeam.name === supportbot.Staff
+      ) ||
+      interaction.guild.roles.cache.find(
+        (SupportTeam) => SupportTeam.id === supportbot.Staff
+      );
+    let Admins =
+      interaction.guild.roles.cache.find(
+        (AdminUser) => AdminUser.name === supportbot.Admin
+      ) ||
+      interaction.guild.roles.cache.find(
+        (AdminUser) => AdminUser.id === supportbot.Admin
+      );
+
+    const NoPerms = new Discord.MessageEmbed()
+      .setTitle("Invalid Permissions!")
+      .setDescription(
+        `${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``
+      )
+      .setColor(supportbot.WarningColour);
+
+    if (
+      interaction.member.roles.cache.has(SupportStaff.id) ||
+      interaction.member.roles.cache.has(Admins.id)
+    ) {
+      if (!interaction.channel.name.startsWith(`${supportbot.TicketPrefix}`)) {
+        const Exists = new Discord.MessageEmbed()
+          .setTitle("No Ticket Found!")
+          .setDescription(`${supportbot.NoValidTicket}`)
+          .setColor(supportbot.WarningColour);
+        return interaction.reply({ embeds: [Exists] });
+      }
+
+      let uMember = interaction.options.getUser("user");
+      const UserNotExist = new Discord.MessageEmbed()
+        .setTitle("User Not Found!")
+        .setDescription(
+          `${supportbot.UserNotFound}\n\nTry Again:\`/${cmdconfig.TicketAdd} <user#0000>\``
+        )
+        .setColor(supportbot.ErrorColour);
+
+      if (!uMember) return interaction.reply({ embeds: [UserNotExist] });
+
+      interaction.channel.permissionOverwrites.edit(uMember, {
+        VIEW_CHANNEL: true,
+        READ_MESSAGE_HISTORY: true,
+        SEND_MESSAGES: true,
+      });
+
+      const Complete = new Discord.MessageEmbed()
+        .setTitle("User Added!")
+        .setDescription(supportbot.AddedUser.replace(/%user%/g, uMember.id))
+        .setTimestamp()
+        .setColor(supportbot.EmbedColour);
+      interaction.reply({ embeds: [Complete] });
+    } else {
+      return interaction.reply({ embeds: [NoPerms] });
+    }
+  },
+});

Commands/close.js

@@ -0,0 +1,231 @@
+// SupportBot | Emerald Services
+// Close Ticket Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+const TicketNumberID = require("../Structures/TicketID.js");
+
+async function asyncForEach(array, callback) {
+  for (let index = 0; index < array.length; index++) {
+    await callback(array[index], index, array);
+  }
+}
+
+module.exports = new Command({
+  name: cmdconfig.CloseTicket,
+  description: cmdconfig.CloseTicketDesc,
+  slashCommandOptions: [
+    {
+      name: "reason",
+      description: "Ticket Close Reason",
+      type: "STRING",
+    },
+  ],
+  permission: "SEND_MESSAGES",
+
+  async run(interaction) {
+    if (!interaction.channel.name.startsWith(`${supportbot.TicketPrefix}`)) {
+      const Exists = new Discord.MessageEmbed()
+        .setTitle("No Ticket Found!")
+        .setDescription(`${supportbot.NoValidTicket}`)
+        .setColor(supportbot.WarningColour);
+      return interaction.reply({ embed: Exists });
+    }
+
+    if (supportbot.CloseConfirmation) {
+      const CloseTicketRequest = new Discord.MessageEmbed()
+        .setTitle(`**${supportbot.ClosingTicket}**`)
+        .setDescription(
+          `Please confirm by repeating the following word.. \`${supportbot.ClosingConfirmation_Word}\` `
+        )
+        .setColor(supportbot.EmbedColour);
+
+      interaction
+        .reply(CloseTicketRequest)
+        .then((m) => {
+          interaction.channel
+            .awaitMessages(
+              (response) =>
+                response.content.toLowerCase() ===
+                supportbot.ClosingConfirmation_Word,
+              {
+                max: 1,
+                time: 20000,
+                errors: ["time"],
+              }
+            )
+            .then((collected) => {
+              let logChannel =
+                interaction.guild.channels.cache.find(
+                  (channel) => channel.name === supportbot.TranscriptLog
+                ) ||
+                interaction.guild.channels.cache.find(
+                  (channel) => channel.id === supportbot.TranscriptLog
+                );
+              let user = interaction.user;
+              let reason =
+                interaction.options.getString("reason") ||
+                "No Reason Provided.";
+
+              let name = interaction.channel.name;
+              let ticketChannel = interaction.channel;
+
+              interaction
+                .reply(`**${supportbot.ClosingTicket}**`)
+
+                .then(() => {
+                  const logEmbed = new Discord.MessageEmbed()
+                    .setTitle(supportbot.TranscriptTitle)
+                    .setColor(supportbot.EmbedColour)
+                    .setFooter(supportbot.EmbedFooter)
+                    .addField("Closed By", interaction.user.tag)
+                    .addField("Reason", reason);
+
+                  interaction.channel.interactions
+                    .fetch({ limit: 100 })
+                    .then((msgs) => {
+                      let html = "";
+
+                      msgs = msgs.sort(
+                        (a, b) => a.createdTimestamp - b.createdTimestamp
+                      );
+                      html += `<style>* {background-color: #2c2f33;color: #fff;font-family: Arial, Helvetica, sans-serif;}</style>`;
+                      html += `<strong>Server Name:</strong> ${interaction.guild.name}<br>`;
+                      html += `<strong>Ticket:</strong> ${ticketChannel.name}<br>`;
+                      html += `<strong>Message:</strong> ${msgs.size} Messages<br><br><br>`;
+
+                      msgs.forEach((msg) => {
+                        if (msg.content) {
+                          html += `<strong>User:</strong> ${msg.author.tag}<br>`;
+                          html += `<strong>Message:</strong> ${msg.content}<br>`;
+                          html += `-----<br><br>`;
+                        }
+                      });
+
+                      logChannel.send({ embeds: [logEmbed] }).catch((err) => {
+                        interaction.reply(err);
+                      });
+
+                      let file = new Discord.MessageAttachment(
+                        Buffer.from(html),
+                        `${name}.html`
+                      );
+                      logChannel
+                        .send({ embeds: [logEmbed], files: [file] })
+                        .catch((err) => {
+                          interaction.reply(err);
+                        });
+
+                      interaction.channel.delete().catch((error) => {
+                        if (
+                          error.code !==
+                          Discord.Constants.APIErrors.UNKNOWN_CHANNEL
+                        ) {
+                          console.error(
+                            "Failed to delete the interaction:",
+                            error
+                          );
+                        }
+                      });
+                    });
+                });
+            });
+        })
+        .catch(() => {
+          interaction
+            .followUp({
+              content: "The request to close the ticket has timed out.",
+            })
+            .then((m2) => setTimeout(() => interaction.channel.delete(3000)));
+        });
+    }
+
+    if (!supportbot.CloseConfirmation) {
+      let logChannel =
+        interaction.guild.channels.cache.find(
+          (channel) => channel.name === supportbot.TranscriptLog
+        ) ||
+        interaction.guild.channels.cache.find(
+          (channel) => channel.id === supportbot.TranscriptLog
+        );
+      let user = interaction.user;
+      let reason =
+        (await interaction.options.getString("reason")) ||
+        "No Reason Provided.";
+
+      let name = interaction.channel.name;
+      let ticketChannel = interaction.channel;
+
+      interaction
+        .reply(`**${supportbot.ClosingTicket}**`)
+
+        .then(() => {
+          const logEmbed = new Discord.MessageEmbed()
+            .setTitle(supportbot.TranscriptTitle)
+            .setColor(supportbot.EmbedColour)
+            .setFooter(supportbot.EmbedFooter)
+            .addField("Closed By", interaction.user.tag)
+            .addField("Reason", reason);
+
+          interaction.channel.interactions
+            .fetch({ limit: 100 })
+            .then((msgs) => {
+              let html = "";
+
+              msgs = msgs.sort(
+                (a, b) => a.createdTimestamp - b.createdTimestamp
+              );
+              html += `<style>* {background-color: #2c2f33;color: #fff;font-family: Arial, Helvetica, sans-serif;}</style>`;
+              html += `<strong>Server Name:</strong> ${interaction.guild.name}<br>`;
+              html += `<strong>Ticket:</strong> ${ticketChannel.name}<br>`;
+              html += `<strong>Message:</strong> ${msgs.size} Messages<br><br><br>`;
+
+              msgs.forEach((msg) => {
+                if (msg.content) {
+                  html += `<strong>User:</strong> ${msg.author.tag}<br>`;
+                  html += `<strong>Message:</strong> ${msg.content}<br>`;
+                  html += `-----<br><br>`;
+                }
+              });
+
+              logChannel.send({ embeds: [logEmbed] }).catch((err) => {
+                interaction.reply(err);
+              });
+
+              let file = new Discord.MessageAttachment(
+                Buffer.from(html),
+                `${name}.html`
+              );
+              logChannel
+                .send({ embeds: [logEmbed], files: [file] })
+                .catch((err) => {
+                  interaction.reply(err);
+                });
+
+              interaction.channel.delete().catch((error) => {
+                if (
+                  error.code !== Discord.Constants.APIErrors.UNKNOWN_CHANNEL
+                ) {
+                  console.error("Failed to delete the interaction:", error);
+                }
+              });
+            });
+        })
+        .catch(() => {
+          interaction
+            .followUp({
+              content: "The request to close the ticket has timed out.",
+            })
+            .then((m2) => setTimeout(() => interaction.channel.delete(3000)));
+        });
+    }
+  },
+});

Commands/embed.js

@@ -0,0 +1,74 @@
+// SupportBot | Emerald Services
+// Embed Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.EmbedCommand,
+  description: cmdconfig.EmbedCommandDesc,
+  slashCommandOptions: [
+    {
+      name: "title",
+      description: "Embed Title",
+      type: "STRING",
+    },
+
+    {
+      name: "message",
+      description: "Embed Message",
+      type: "STRING",
+    },
+  ],
+  permission: "SEND_MESSAGES",
+
+  async run(interaction) {
+    let SupportStaff =
+      interaction.guild.roles.cache.find(
+        (SupportTeam) => SupportTeam.name === supportbot.Staff
+      ) ||
+      interaction.guild.roles.cache.find(
+        (SupportTeam) => SupportTeam.id === supportbot.Staff
+      );
+    let Admins =
+      interaction.guild.roles.cache.find(
+        (AdminUser) => AdminUser.name === supportbot.Admin
+      ) ||
+      interaction.guild.roles.cache.find(
+        (AdminUser) => AdminUser.id === supportbot.Admin
+      );
+
+    const NoPerms = new Discord.MessageEmbed()
+      .setTitle("Invalid Permissions!")
+      .setDescription(
+        `${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``
+      )
+      .setColor(supportbot.WarningColour);
+
+    if (
+      interaction.member.roles.cache.has(SupportStaff.id) ||
+      interaction.member.roles.cache.has(Admins.id)
+    ) {
+      const EmbedTitle = interaction.options.getString("title");
+      const EmbedSubject = interaction.options.getString("message");
+
+      const EmbedMsg = new Discord.MessageEmbed()
+        .setTitle(EmbedTitle)
+        .setDescription(EmbedSubject);
+
+      interaction.reply({
+        embeds: [EmbedMsg],
+      });
+    } else {
+      return interaction.reply({ embeds: [NoPerms] });
+    }
+  },
+});

Commands/help.js

@@ -0,0 +1,106 @@
+// SupportBot | Emerald Services
+// Help Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+async function asyncForEach(array, callback) {
+  for (let index = 0; index < array.length; index++) {
+    await callback(array[index], index, array);
+  }
+}
+
+module.exports = new Command({
+  name: cmdconfig.HelpCommand,
+  description: cmdconfig.HelpCommandDesc,
+  slashCommandOptions: [],
+  permission: "SEND_MESSAGES",
+
+  async run(interaction) {
+    let SupportStaff =
+      interaction.guild.roles.cache.find(
+        (adminRole) => adminRole.name === supportbot.Staff
+      ) ||
+      interaction.guild.roles.cache.find(
+        (staffRole) => staffRole.id === supportbot.Staff
+      );
+    let AdminStaff =
+      interaction.guild.roles.cache.find(
+        (adminRole) => adminRole.name === supportbot.Admin
+      ) ||
+      interaction.guild.roles.cache.find(
+        (adminRole) => adminRole.id === supportbot.Admin
+      );
+
+    if (supportbot.HelpMenu) {
+      let botCommands = "";
+      botCommands += `**/${cmdconfig.HelpCommand}** ${cmdconfig.HelpCommandDesc}\n`;
+      botCommands += `**/${cmdconfig.InfoCommand}** ${cmdconfig.InfoCommandDesc}\n`;
+      botCommands += `**/${cmdconfig.PingCommand}** ${cmdconfig.PingCommandDesc}\n`;
+
+      let ticketCommands = "";
+      ticketCommands += `**/${cmdconfig.OpenTicket}** ${cmdconfig.OpenTicketDesc}\n`;
+      ticketCommands += `**/${cmdconfig.CloseTicket}** ${cmdconfig.CloseTicketDesc}\n`;
+
+      let staffCommands = "";
+      staffCommands += `**/${cmdconfig.TicketAdd}** ${cmdconfig.TicketAddDesc}\n`;
+      staffCommands += `**/${cmdconfig.TicketRemove}** ${cmdconfig.TicketRemoveDesc}\n`;
+
+      const HelpEmbed1 = new Discord.MessageEmbed()
+        .setTitle(supportbot.Name + " Commands")
+        .setThumbnail(interaction.user.displayAvatarURL())
+
+        .addFields(
+          {
+            name: "🖥️ General Commands\n",
+            value: `${botCommands}\n`,
+            inline: false,
+          },
+          {
+            name: "🎫 Support Commands\n",
+            value: `${ticketCommands}\n`,
+            inline: false,
+          }
+        )
+
+        .setColor(supportbot.EmbedColour)
+        .setFooter(supportbot.EmbedFooter, interaction.user.displayAvatarURL());
+
+      if (interaction.member.roles.cache.has(SupportStaff.id)) {
+        HelpEmbed1.addFields({
+          name: "🔐 Staff Commands\n",
+          value: `${staffCommands}\n`,
+          inline: false,
+        });
+      } else {
+        if (interaction.member.roles.cache.has(AdminStaff.id)) {
+          HelpEmbed1.addFields({
+            name: "🔐 Staff Commands\n",
+            value: `${staffCommands}\n`,
+            inline: false,
+          });
+        }
+      }
+
+      if (supportbot.SendHelpPage === "dm") {
+        interaction.user.reply({
+          embeds: [HelpEmbed1],
+        });
+      }
+
+      if (supportbot.SendHelpPage === "channel") {
+        interaction.reply({
+          embeds: [HelpEmbed1],
+        });
+      }
+    }
+  },
+});

Commands/info.js

@@ -0,0 +1,40 @@
+// SupportBot | Emerald Services
+// Info Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.InfoCommand,
+  description: cmdconfig.InfoCommandDesc,
+  slashCommandOptions: [],
+  permission: "SEND_MESSAGES",
+
+  async run(interaction) {
+    const InfoButton = new Discord.MessageButton()
+      .setLabel(supportbot.InfoButtonText)
+      .setURL(supportbot.InfoURL)
+      .setStyle("LINK");
+
+    const inforow = new Discord.MessageActionRow().addComponents(InfoButton);
+
+    const InfoEmbed = new Discord.MessageEmbed()
+      .setURL(supportbot.InfoURL)
+      .setTitle(supportbot.InfoTitle)
+      .setDescription(supportbot.AboutMe)
+      .setColor(supportbot.InfoColour);
+
+    interaction.reply({
+      embeds: [InfoEmbed],
+      components: [inforow],
+    });
+  },
+});

Commands/ping.js

@@ -0,0 +1,32 @@
+// SupportBot | Emerald Services
+// Ping Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.PingCommand,
+  description: cmdconfig.PingCommandDesc,
+  slashCommandOptions: [],
+  permission: "SEND_MESSAGES",
+
+  async run(interaction) {
+    const PingEmbed = new Discord.MessageEmbed()
+      .setDescription(
+        `:ping_pong: **Ping:** \`${interaction.client.ws.ping} ms\``
+      )
+      .setColor(supportbot.EmbedColour);
+
+    interaction.reply({
+      embeds: [PingEmbed],
+    });
+  },
+});

Commands/remove.js

@@ -0,0 +1,95 @@
+// SupportBot | Emerald Services
+// Ticket Remove Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+async function asyncForEach(array, callback) {
+  for (let index = 0; index < array.length; index++) {
+    await callback(array[index], index, array);
+  }
+}
+
+module.exports = new Command({
+  name: cmdconfig.TicketRemove,
+  description: cmdconfig.TicketRemoveDesc,
+  slashCommandOptions: [
+    {
+      name: "user",
+      description: "User to remove",
+      type: "USER",
+      required: true,
+    },
+  ],
+  permission: "SEND_MESSAGES",
+
+  async run(interaction) {
+    let SupportStaff =
+      interaction.guild.roles.cache.find(
+        (SupportTeam) => SupportTeam.name === supportbot.Staff
+      ) ||
+      interaction.guild.roles.cache.find(
+        (SupportTeam) => SupportTeam.id === supportbot.Staff
+      );
+    let Admins =
+      interaction.guild.roles.cache.find(
+        (AdminUser) => AdminUser.name === supportbot.Admin
+      ) ||
+      interaction.guild.roles.cache.find(
+        (AdminUser) => AdminUser.id === supportbot.Admin
+      );
+
+    const NoPerms = new Discord.MessageEmbed()
+      .setTitle("Invalid Permissions!")
+      .setDescription(
+        `${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``
+      )
+      .setColor(supportbot.WarningColour);
+
+    if (
+      interaction.member.roles.cache.has(SupportStaff.id) ||
+      interaction.member.roles.cache.has(Admins.id)
+    ) {
+      if (!interaction.channel.name.startsWith(`${supportbot.TicketPrefix}`)) {
+        const Exists = new Discord.MessageEmbed()
+          .setTitle("No Ticket Found!")
+          .setDescription(`${supportbot.NoValidTicket}`)
+          .setColor(supportbot.WarningColour);
+        return interaction.reply({ embeds: [Exists] });
+      }
+
+      let uMember = interaction.options.getUser("user");
+      const UserNotExist = new Discord.MessageEmbed()
+        .setTitle("User Not Found!")
+        .setDescription(
+          `${supportbot.UserNotFound}\n\nTry Again:\`/${cmdconfig.TicketRemove} <user#0000>\``
+        )
+        .setColor(supportbot.ErrorColour);
+
+      if (!uMember) return interaction.reply({ embeds: [UserNotExist] });
+
+      interaction.channel.permissionOverwrites.edit(uMember, {
+        VIEW_CHANNEL: false,
+        READ_MESSAGE_HISTORY: false,
+        SEND_MESSAGES: false,
+      });
+
+      const Complete = new Discord.MessageEmbed()
+        .setTitle("User Removed!")
+        .setDescription(supportbot.RemovedUser.replace(/%user%/g, uMember.id))
+        .setTimestamp()
+        .setColor(supportbot.EmbedColour);
+      interaction.reply({ embeds: [Complete] });
+    } else {
+      return interaction.reply({ embeds: [NoPerms] });
+    }
+  },
+});

Commands/suggest.js

@@ -0,0 +1,68 @@
+// SupportBot | Emerald Services
+// Ping Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.SuggestCommand,
+  description: cmdconfig.SuggestCommandDesc,
+  slashCommandOptions: [
+    {
+      name: "suggestion",
+      description: "Create a Suggestion",
+      type: "STRING",
+    },
+  ],
+  permission: "SEND_MESSAGES",
+
+  async run(interaction) {
+    const suggestChannel =
+      interaction.guild.channels.cache.find(
+        (channel) => channel.name === supportbot.SuggestionChannel
+      ) ||
+      interaction.guild.channels.cache.find(
+        (channel) => channel.id === supportbot.SuggestionChannel
+      );
+
+    const NoChannel = new Discord.MessageEmbed()
+      .setTitle("Missing Channel!")
+      .setDescription(`${supportbot.InvalidChannel}`)
+      .setColor(supportbot.ErrorColour);
+
+    if (!suggestChannel) return interaction.reply({ embeds: [NoChannel] });
+
+    let suggestion = interaction.options.getString("suggestion");
+
+    const SuggestEmbed = new Discord.MessageEmbed()
+      .addField("Suggestion", suggestion, true)
+      .addField("From", `<@${interaction.user.id}>`)
+      .setThumbnail(interaction.user.displayAvatarURL())
+      .setFooter(supportbot.EmbedFooter, interaction.user.displayAvatarURL())
+      .setColor(supportbot.EmbedColour);
+
+    const suggestionMsg = await suggestChannel.send({ embeds: [SuggestEmbed] });
+    if (supportbot.SuggestionUpvote && supportbot.SuggestionDownvote) {
+      suggestionMsg.react(supportbot.SuggestionUpvote);
+      suggestionMsg.react(supportbot.SuggestionDownvote);
+    }
+
+    const Submitted = new Discord.MessageEmbed()
+      .setTitle("Suggestion Submitted!")
+      .setDescription(
+        `:white_check_mark: You have successfully submitted a suggestion.`
+      )
+      .addField("Sent to:", `<#${suggestChannel.id}>`)
+      .setColor(supportbot.SuccessColour);
+
+    return interaction.reply({ embeds: [Submitted] });
+  },
+});

Commands/ticket.js

@@ -0,0 +1,362 @@
+// SupportBot | Emerald Services
+// Ticket Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+const TicketNumberID = require("../Structures/TicketID.js");
+
+async function asyncForEach(array, callback) {
+  for (let index = 0; index < array.length; index++) {
+    await callback(array[index], index, array);
+  }
+}
+
+module.exports = new Command({
+  name: cmdconfig.OpenTicket,
+  description: cmdconfig.OpenTicketDesc,
+  slashCommandOptions: [
+    {
+      name: "reason",
+      description: "Ticket Reason",
+      type: "STRING",
+    },
+  ],
+  permission: "SEND_MESSAGES",
+
+  async run(interaction) {
+    let reactionUser = interaction.guild.members.cache.get(interaction.user.id);
+
+    if (
+      reactionUser.roles.cache.find(
+        (role) => role.name === supportbot.TicketBlackListRole
+      ) ||
+      reactionUser.roles.cache.find(
+        (role) => role.id === supportbot.TicketBlackListRole
+      )
+    ) {
+      return interaction
+        .reply({
+          content: `<@${interaction.user.id}> ${supportbot.TicketBlackListMessage}`,
+        })
+        .then((msg) => {
+          setTimeout(() => msg.delete(), 3500);
+        });
+    }
+
+    // Ticket ID
+    let ticketNumberID = TicketNumberID.pad(interaction.guild.id);
+
+    // Ticket Subject
+    const TicketSubject =
+      interaction.options?.getString("reason") || supportbot.NoTicketSubject;
+
+    const TicketExists = new Discord.MessageEmbed()
+      .setTitle("Ticket Exists!")
+      .setDescription(`${supportbot.TicketExists}`)
+      .setColor(supportbot.WarningColour);
+
+    if (
+      await interaction.guild.channels.cache.find((ticketChannel) => {
+        ticketChannel.name === `${supportbot.TicketPrefix}${ticketNumberID}`;
+      })
+    ) {
+      return interaction.reply({ embeds: [TicketExists] });
+    }
+    const Staff =
+      interaction.guild.roles.cache.find(
+        (SupportTeam) => SupportTeam.name === supportbot.Staff
+      ) ||
+      interaction.guild.roles.cache.find(
+        (SupportTeam) => SupportTeam.id === supportbot.Staff
+      );
+    const Admins =
+      interaction.guild.roles.cache.find(
+        (AdminUser) => AdminUser.name === supportbot.Admin
+      ) ||
+      interaction.guild.roles.cache.find(
+        (AdminUser) => AdminUser.id === supportbot.Admin
+      );
+    const DeptRole1 =
+      interaction.guild.roles.cache.find(
+        (DepartmentRole) =>
+          DepartmentRole.name === `${supportbot.DepartmentRole_1}`
+      ) ||
+      interaction.guild.roles.cache.find(
+        (DepartmentRole) =>
+          DepartmentRole.id === `${supportbot.DepartmentRole_1}`
+      );
+    const DeptRole2 =
+      interaction.guild.roles.cache.find(
+        (DepartmentRole) =>
+          DepartmentRole.name === `${supportbot.DepartmentRole_2}`
+      ) ||
+      interaction.guild.roles.cache.find(
+        (DepartmentRole) =>
+          DepartmentRole.id === `${supportbot.DepartmentRole_2}`
+      );
+    const DeptRole3 =
+      interaction.guild.roles.cache.find(
+        (DepartmentRole) =>
+          DepartmentRole.name === `${supportbot.DepartmentRole_3}`
+      ) ||
+      interaction.guild.roles.cache.find(
+        (DepartmentRole) =>
+          DepartmentRole.id === `${supportbot.DepartmentRole_3}`
+      );
+    const Author = interaction.user;
+    const Everyone = interaction.guild.id;
+    const ticketChannel = await interaction.guild.channels.create(
+      `${supportbot.TicketPrefix}${ticketNumberID}`,
+      {
+        type: "GUILD_TEXT",
+      }
+    );
+
+    if (
+      interaction.channel.name === supportbot.ReactionChannel ||
+      interaction.channel.id === supportbot.ReactionChannel
+    ) {
+      const CreatedTicket = new Discord.MessageEmbed()
+        .setDescription(
+          supportbot.TicketCreatedAlert.replace(
+            /%ticketauthor%/g,
+            interaction.user.id
+          )
+            .replace(/%ticketid%/g, ticketChannel.id)
+            .replace(/%ticketusername%/g, interaction.user.username)
+        )
+        .setColor(supportbot.EmbedColour);
+      interaction.reply({ embeds: [CreatedTicket], ephemeral: true });
+    } else {
+      const CreatedTicket = new Discord.MessageEmbed()
+        .setDescription(
+          supportbot.TicketCreatedAlert.replace(
+            /%ticketauthor%/g,
+            interaction.user.id
+          )
+            .replace(/%ticketid%/g, ticketChannel.id)
+            .replace(/%ticketusername%/g, interaction.user.username)
+        )
+        .setColor(supportbot.EmbedColour);
+      interaction.reply({ embeds: [CreatedTicket], ephemeral: true });
+    }
+    let AllowArr = [Staff, Staff, Admins, Author];
+    await asyncForEach(AllowArr, (index) => {
+      ticketChannel.permissionOverwrites.create(index, { VIEW_CHANNEL: true });
+    });
+
+    let DenyArr = [Everyone];
+    await asyncForEach(DenyArr, (index) => {
+      ticketChannel.permissionOverwrites.create(index, { VIEW_CHANNEL: false });
+    });
+
+    let TicketCategory =
+      interaction.guild.channels.cache.find(
+        (category) => category.name === supportbot.TicketCategory
+      ) ||
+      interaction.guild.channels.cache.find(
+        (category) => category.id === supportbot.TicketCategory
+      );
+    if (TicketCategory) {
+      ticketChannel.setParent(TicketCategory.id);
+    }
+
+    if (supportbot.AllowTicketMentions) {
+      ticketChannel.send({ content: `${interaction.user}` });
+    }
+
+    const TicketMessage = new Discord.MessageEmbed()
+      .setTitle(
+        supportbot.Ticket_Title.replace(/%ticketauthor%/g, interaction.user.id)
+          .replace(/%ticketid%/g, ticketChannel.id)
+          .replace(/%ticketusername%/g, interaction.user.username)
+      )
+      .setDescription(
+        supportbot.TicketMessage.replace(/%ticketauthor%/g, interaction.user.id)
+          .replace(/%ticketid%/g, ticketChannel.id)
+          .replace(/%ticketusername%/g, interaction.user.username)
+      )
+      .setColor(supportbot.EmbedColour);
+
+    if (supportbot.TicketSubject === "embed") {
+      if (TicketSubject != "No Reason Provided.") {
+        TicketMessage.addFields({ name: "Reason", value: TicketSubject });
+      }
+    }
+
+    if (supportbot.TicketSubject === "description") {
+      if (TicketSubject != "No Reason Provided.") {
+        ticketChannel.setTopic(
+          `Reason: ${TicketSubject}  -  User ID: ${interaction.user.id}  -  Ticket: ${ticketChannel.name}`
+        );
+      }
+    }
+
+    if (supportbot.TicketDepartments) {
+      TicketMessage.addFields({
+        name: "Departments",
+        value: ` **${supportbot.DepartmentTitle_1}**\n **${supportbot.DepartmentTitle_2}**\n **${supportbot.DepartmentTitle_3}**`,
+      });
+    }
+    const CloseButton = new Discord.MessageButton()
+      .setCustomId("ticketclose")
+      .setLabel("Close")
+      .setStyle(supportbot.TicketCloseColour)
+      .setEmoji(supportbot.TicketCloseEmoji);
+
+    const LockButton = new Discord.MessageButton()
+      .setCustomId("ticketlock")
+      .setLabel("Lock")
+      .setStyle(supportbot.TicketLockColour)
+      .setEmoji(supportbot.TicketLockEmoji);
+
+    const row2 = new Discord.MessageActionRow().addComponents(
+      CloseButton,
+      LockButton
+    );
+
+    if (supportbot.TicketDepartments) {
+      let DenyArr = [DeptRole1, DeptRole2, DeptRole3];
+      await asyncForEach(DenyArr, (index) => {
+        ticketChannel.permissionOverwrites.create(index, {
+          VIEW_CHANNEL: false,
+        });
+      });
+      const Department1Button = new Discord.MessageButton()
+        .setCustomId("Department1")
+        .setLabel(`${supportbot.DepartmentTitle_1}`)
+        .setStyle(supportbot.TicketDept1Colour)
+        .setEmoji(supportbot.TicketDept1Emoji);
+
+      const Department2Button = new Discord.MessageButton()
+        .setCustomId("Department2")
+        .setLabel(`${supportbot.DepartmentTitle_2}`)
+        .setStyle(supportbot.TicketDept2Colour)
+        .setEmoji(supportbot.TicketDept2Emoji);
+
+      const Department3Button = new Discord.MessageButton()
+        .setCustomId("Department3")
+        .setLabel(`${supportbot.DepartmentTitle_3}`)
+        .setStyle(supportbot.TicketDept3Colour)
+        .setEmoji(supportbot.TicketDept3Emoji);
+
+      const row = new Discord.MessageActionRow().addComponents(
+        Department1Button,
+        Department2Button,
+        Department3Button
+      );
+
+      const m = await ticketChannel.send({
+        embeds: [TicketMessage],
+        components: [row],
+      });
+
+      const filter = (i) => {
+        i.deferUpdate();
+        return i.user.id === interaction.user.id;
+      };
+      const collector = m.createMessageComponentCollector({
+        filter,
+        max: 1,
+        componentType: "BUTTON",
+        time: 60000,
+      });
+
+      collector.on("collect", async (i) => {
+        if (i.customId === "Department1") {
+          ticketChannel.permissionOverwrites.edit(DeptRole1, {
+            VIEW_CHANNEL: true,
+            READ_MESSAGE_HISTORY: true,
+            SEND_MESSAGES: true,
+          });
+
+          if (!supportbot.AllowStaff) {
+            ticketChannel.permissionOverwrites.edit(Staff, {
+              VIEW_CHANNEL: false,
+              READ_MESSAGE_HISTORY: false,
+              SEND_MESSAGES: false,
+            });
+          }
+
+          const Department1 = new Discord.MessageEmbed()
+            .setDescription(
+              `> Thank for reaching out to the **${supportbot.DepartmentTitle_1} Department**. Please provide us information regarding your query.`
+            )
+            .setColor(supportbot.EmbedColour);
+          ticketChannel.send({ embeds: [Department1] });
+
+          if (supportbot.AllowTicketMentions) {
+            ticketChannel.send({ content: `@here` });
+          }
+        }
+        i.message.edit({ embeds: [TicketMessage], components: [row2] });
+
+        if (i.customId === "Department2") {
+          ticketChannel.permissionOverwrites.edit(DeptRole2, {
+            VIEW_CHANNEL: true,
+            READ_MESSAGE_HISTORY: true,
+            SEND_MESSAGES: true,
+          });
+
+          if (!supportbot.AllowStaff) {
+            ticketChannel.permissionOverwrites.edit(Staff, {
+              VIEW_CHANNEL: false,
+              READ_MESSAGE_HISTORY: false,
+              SEND_MESSAGES: false,
+            });
+          }
+
+          const Department2 = new Discord.MessageEmbed()
+            .setDescription(
+              `> Thank for reaching out to the **${supportbot.DepartmentTitle_2} Department**. Please provide us information regarding your query.`
+            )
+            .setColor(supportbot.EmbedColour);
+          ticketChannel.send({ embeds: [Department2] });
+
+          if (supportbot.AllowTicketMentions) {
+            ticketChannel.send({ content: `@here` });
+          }
+
+          i.message.edit({ embeds: [TicketMessage], components: [row2] });
+        }
+        if (i.customId === "Department3") {
+          ticketChannel.permissionOverwrites.edit(DeptRole3, {
+            VIEW_CHANNEL: true,
+            READ_MESSAGE_HISTORY: true,
+            SEND_MESSAGES: true,
+          });
+
+          if (!supportbot.AllowStaff) {
+            ticketChannel.permissionOverwrites.edit(Staff, {
+              VIEW_CHANNEL: false,
+              READ_MESSAGE_HISTORY: false,
+              SEND_MESSAGES: false,
+            });
+          }
+
+          const Department3 = new Discord.MessageEmbed()
+            .setDescription(
+              `> Thank for reaching out to the **${supportbot.DepartmentTitle_3} Department**. Please provide us information regarding your query.`
+            )
+            .setColor(supportbot.EmbedColour);
+          ticketChannel.send({ embeds: [Department3] });
+
+          if (supportbot.AllowTicketMentions) {
+            ticketChannel.send({ content: `@here` });
+          }
+          i.message.edit({ embeds: [TicketMessage], components: [row2] });
+        }
+      });
+    } else {
+      ticketChannel.send({ embeds: [TicketMessage], components: [row2] });
+    }
+  },
+});

Configs/commands.yml

@@ -0,0 +1,39 @@
+#      ___                            _    ___        _
+#    / __> _ _  ___  ___  ___  _ _ _| |_ | . > ___ _| |_
+#     \__ \| | || . \| . \/ . \| '_> | |  | . \/ . \ | |
+#     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|
+#                |_|  |_|
+#
+#           SupportBot created by Emerald Services
+#           Installed with MIT License
+#
+#           Discord Support: https://emeraldsrv.dev/discord
+#           Community Resources: https://emeraldsrv.dev/resources
+
+# -------------------------------
+#   Command Name Configuration
+# -------------------------------
+
+TicketAdd: "add"
+TicketRemove: "remove"
+OpenTicket: "ticket"
+CloseTicket: "close"
+InfoCommand: "info"
+PingCommand: "ping"
+HelpCommand: "help"
+EmbedCommand: "embed"
+SuggestCommand: "suggest"
+
+# ---------------------------------------
+#   Command Description Configuration
+# ---------------------------------------
+
+TicketAddDesc: "Add a user to a support ticket."
+TicketRemoveDesc: "Remove a user from a support ticket."
+OpenTicketDesc: "Open a new support ticket."
+CloseTicketDesc: "Close your support ticket."
+InfoCommandDesc: "Get information about the brand."
+PingCommandDesc: "Pong!"
+HelpCommandDesc: "Get a list of all the commands."
+EmbedCommandDesc: "Send a message as an embed."
+SuggestCommandDesc: "Suggest a feature for the server."

Configs/supportbot.yml

@@ -0,0 +1,194 @@
+#      ___                            _    ___        _
+#    / __> _ _  ___  ___  ___  _ _ _| |_ | . > ___ _| |_
+#     \__ \| | || . \| . \/ . \| '_> | |  | . \/ . \ | |
+#     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|
+#                |_|  |_|
+#
+#           SupportBot created by Emerald Services
+#           Installed with MIT License
+#
+#           Discord Support: https://emeraldsrv.dev/discord
+#           Community Resources: https://emeraldsrv.dev/resources
+
+SupportBot_Version: "7.2"
+
+# -------------------------
+#   General Configuration
+# -------------------------
+
+Name: "SupportBot"
+# No Prefix, as everything uses the new Slash (/) Commands feature!
+Token: "BOT_TOKEN"
+
+# -------------------------
+#  Activity Configuration
+# -------------------------
+
+BotActivity: "Need Help? /ticket"
+
+StreamingURL: "https://www.twitch.tv/YOUR_TWITCH_NAME"
+# Set The ActivityType to "STREAMING" for a streaming status!
+
+ActivityType: "PLAYING"
+# Activity status can either be PLAYING, WATCHING, LISTENING or STREAMING.
+
+# -------------------------
+#  Embed Configuration
+# -------------------------
+
+EmbedColour: "#f74343"
+EmbedFooter: "SupportBot | An Advanced Ticket System"
+
+ErrorColour: "#d12519"
+SuccessColour: "#04b545"
+WarningColour: "#fca117"
+
+# -------------------------
+#  Information Configuration
+# -------------------------
+
+InfoTitle: "Information"
+AboutMe: "Hi, I'm SupportBot an advanced discord ticket bot with 100% customization! [Download](https://emeraldsrv.dev/download)"
+
+InfoButtonText: "Visit Site"
+InfoURL: "https://emeraldsrv.dev"
+InfoColour: "#f74343"
+
+# -------------------------
+#  Help Configuration
+# -------------------------
+
+HelpMenu: true # Do not change!
+SendHelpPage: "channel" # Set to channel or dm
+
+# -------------------------
+#  Role Configuration
+# -------------------------
+
+AutoRole: true
+AutoRole_Role: "Member"
+LockdownRole: "@everyone"
+
+Staff: "Staff"
+Admin: "Project Developer"
+TicketBlackListRole: "Blacklisted"
+
+# ----------------------------
+#  Suggestions Configuration
+# ----------------------------
+
+SuggestionChannel: "suggestions"
+
+# -------------------------
+#  Tickets Configuration
+# -------------------------
+
+TicketCategory: "Tickets"
+TicketPrefix: "ticket-" # The prefix for ticket channel names
+
+TicketLog: "logs"
+TranscriptLog: "transcripts"
+
+TranscriptTitle: "Ticket Transcript"
+TicketLog_Title: "Ticket Log"
+TicketBlackListMessage: "You are not allowed to open a ticket"
+
+TicketSubject: "description"
+# "description" will displays the ticket reason within the channel description
+# "embed" will displays the ticket reason within the ticket embed
+
+AllowTicketMentions: true
+# Set to true to allow the ticket to mention the author and the support team.
+# Set to false to dis-allow mentions within tickets.
+
+# --- Creation Config ---
+#      --- Start ---
+
+# Available Placeholders:
+
+# %ticketusername% - User who created the ticket.
+# <@%ticketauthor%> - Tags the user who created the ticket.
+# <#%ticketid%> - Mentions the ticket channel.
+
+Ticket_Title: "Server Support | %ticketusername%"
+TicketMessage: "Hello <@%ticketauthor%>, Thank you for creating a support ticket\nPlease wait patiently whilst a member of our team reaches out to you."
+
+Ticket_Thumbnail: "https://images.emojiterra.com/google/android-pie/512px/1f39f.png"
+NoTicketSubject: "No Reason Provided!"
+
+TicketCreatedAlert: ":ticket: Your support ticket has been created: <#%ticketid%>"
+
+AddedUser: "👍 <@%user%> has been added to this ticket"
+RemovedUser: "👍 <@%user%> has been removed from this ticket"
+
+# --- Buttons Config ---
+#      --- Start ---
+
+# Discord Button Colour Selection
+# PRIMARY - Blurple
+# DANGER - Red
+# SUCCESS - Green
+# Secondary - Grey
+
+TicketLockReaction: "🔒"
+TicketDeleteReaction: "⛔"
+LockTicketCategory: "Archive"
+
+TicketCloseEmoji: "❌"
+TicketDeleteEmoji: "⛔"
+TicketLockEmoji: "🔒"
+
+TicketCloseColour: "DANGER"
+TicketDeleteColour: "DANGER"
+TicketLockColour: "PRIMARY"
+
+TicketDept1Colour: "PRIMARY"
+TicketDept2Colour: "PRIMARY"
+TicketDept3Colour: "PRIMARY"
+
+TicketDept1Emoji: "1️⃣"
+TicketDept2Emoji: "2️⃣"
+TicketDept3Emoji: "3️⃣"
+
+TranscriptSavedMessage: "📝 **Transcript Saved!**"
+TicketLockMessage: "❌ **Ticket Locked!**"
+TicketDeleteMessage: "⚠ **Ticket Deleting!**" # Tickets deleting after 5 seconds by default.
+TicketDeleteTime: 5000 # Time must be set in milliseconds.
+
+# --- Departments Config ---
+#     --- Start ---
+
+TicketDepartments: true
+
+AllowStaff: true
+# If set to false users with the "Staff" role will not be able to view tickets
+# without a valid department role set below.
+
+# Set to false to allow "Staff" to see tickets whether its a department for them or not.
+
+DepartmentTitle_1: "General Support"
+DepartmentTitle_2: "Billing Support"
+DepartmentTitle_3: "Admin Team"
+# Ticket department title, This is the title for a ticket department to help users know what is available.
+
+DepartmentRole_1: "Support"
+DepartmentRole_2: "Support"
+DepartmentRole_3: "Admin"
+# Ticket roles are the roles that will be able to gain access to tickets depending on what department has been chosen.
+
+# --- Closing Config ---
+#    --- Start ---
+
+ClosingTicket: ":warning: You have requested to close your support ticket."
+ClosingConfirmation_Word: "confirm"
+CloseConfirmation: false
+
+# ---------------------------
+#  Error / Warning Messages
+# ---------------------------
+
+IncorrectPerms: ":x: **Err!** You do not have the correct permissions to use this command."
+InvalidChannel: ":x: **Err!** Channel not found. Please create it!"
+UserNotFound: ":x: **Err!** This user doesn't exist, Are they in this server?"
+NoValidTicket: ":warning: You cannot execute this command here."
+TicketExists: ":warning: This ticket cannot be opened, It already exists!"

Configs/ticket-panel.yml

@@ -0,0 +1,41 @@
+#      ___                            _    ___        _
+#    / __> _ _  ___  ___  ___  _ _ _| |_ | . > ___ _| |_
+#     \__ \| | || . \| . \/ . \| '_> | |  | . \/ . \ | |
+#     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|
+#                |_|  |_|
+#
+#           SupportBot created by Emerald Services
+#           Installed with MIT License
+#
+#           Discord Support: https://emeraldsrv.dev/discord
+#           Community Resources: https://emeraldsrv.dev/resources
+
+# -------------------------------
+#   Ticket Panel Configuration
+# -------------------------------
+
+TicketPanel: true
+
+# ----------------------------------------
+#   Ticket Panel Message Configuration
+# ----------------------------------------
+
+Channel: "create-ticket"
+ButtonEmoji: "📩"
+ButtonLabel: "Open Ticket"
+ButtonColour: "SUCCESS"
+# Colour Options:
+#   -> PRIMARY - Blurple
+#   -> SECONDARY - Grey
+#   -> SUCCESS - Green
+#   -> DANGER - Red
+
+PanelTitle: "Need Help? Create a Support Ticket."
+
+TicketPanel_Description: true
+TicketPanel_Thumbnail: false
+TicketPanel_Image: false
+
+PanelMessage: "Click the button to open a new support ticket."
+PanelThumbnail: "https://i.imgur.com/ieeZejl.png"
+PanelImage: "https://i.imgur.com/5NkcmDq.png"

Data/TicketData.json

@@ -0,0 +1,5 @@
+{
+    "854057237495676938": {
+        "id": 2
+    }
+}

Data/ticket-panel-id.yml

@@ -0,0 +1 @@
+TicketPanelID: ''

Events/interactionCreate.js

@@ -0,0 +1,183 @@
+// SupportBot | Emerald Services
+// Interaction Create Event
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Event = require("../Structures/Event.js");
+
+module.exports = new Event("interactionCreate", (client, interaction) => {
+  if (interaction.isCommand()) {
+    const command = client.commands.find(
+      (cmd) => cmd.name.toLowerCase() == interaction.commandName
+    );
+
+    if (interaction.user.bot || !interaction.isCommand() || !interaction.guild)
+      return;
+
+    const NotValid = new Discord.MessageEmbed()
+      .setDescription(`:x: \`Invalid Command\` `)
+      .setColor(supportbot.ErrorColour);
+
+    if (!command)
+      return interaction.reply({
+        embeds: [NotValid],
+      });
+
+    const permission = interaction.member.permissions.has(command.permission);
+
+    const ValidPerms = new Discord.MessageEmbed()
+      .setDescription(
+        ":x: `Invalid Permissions` Do you have the correct permissions to execute this command?"
+      )
+      .setColor(supportbot.ErrorColour);
+
+    if (!permission)
+      return interaction.reply({
+        embeds: [ValidPerms],
+      });
+    interaction.user = interaction.user;
+    command.run(interaction);
+  }
+  if (interaction.isButton()) {
+    if (interaction.customId === "openticket") {
+      try {
+        const cmd = client.commands.get(cmdconfig.OpenTicket);
+        if (!cmd) return;
+        cmd.run(interaction);
+      } catch (error) {
+        console.error(error);
+      }
+    }
+
+    if (interaction.customId === "ticketclose") {
+      if (interaction.channel.name.startsWith(`${supportbot.TicketPrefix}`)) {
+        interaction.message.fetch();
+        interaction.deferUpdate();
+        const DeleteTicketEmbed = new Discord.MessageEmbed()
+          .setDescription(supportbot.TicketDeleteMessage)
+          .setColor(supportbot.EmbedColour);
+        interaction.channel.send({ embeds: [DeleteTicketEmbed] });
+
+        let logChannel =
+          interaction.guild.channels.cache.find(
+            (channel) => channel.name === supportbot.TranscriptLog
+          ) ||
+          interaction.guild.channels.cache.find(
+            (channel) => channel.id === supportbot.TranscriptLog
+          );
+
+        let user = interaction.user;
+        let name = interaction.channel.name;
+        let ticketChannel = interaction.channel;
+        let reason = "No Reason Provided.";
+
+        interaction.channel
+          .send({ content: `**${supportbot.ClosingTicket}**` })
+          .then(() => {
+            const logEmbed = new Discord.MessageEmbed()
+              .setTitle(supportbot.TranscriptTitle)
+              .setColor(supportbot.EmbedColour)
+              .setFooter(supportbot.EmbedFooter)
+              .addField("Closed By", user.username)
+              .addField("Reason", reason);
+
+            interaction.channel.messages.fetch({ limit: 100 }).then((msgs) => {
+              let html = "";
+
+              msgs = msgs.sort(
+                (a, b) => a.createdTimestamp - b.createdTimestamp
+              );
+              html += `<style>* {background-color: #2c2f33;color: #fff;font-family: Arial, Helvetica, sans-serif;}</style>`;
+              html += `<strong>Server Name:</strong> ${interaction.guild.name}<br>`;
+              html += `<strong>Ticket:</strong> ${ticketChannel.name}<br>`;
+              html += `<strong>Message:</strong> ${msgs.size} Messages<br><br><br>`;
+
+              msgs.forEach((msg) => {
+                if (msg.content) {
+                  html += `<strong>User:</strong> ${msg.author.tag}<br>`;
+                  html += `<strong>Message:</strong> ${msg.content}<br>`;
+                  html += `-----<br><br>`;
+                }
+              });
+
+              const TranscriptSavedEmbed = new Discord.MessageEmbed()
+                .setDescription(supportbot.TranscriptSavedMessage)
+                .setColor(supportbot.SuccessColour);
+              interaction.channel.send({ embeds: [TranscriptSavedEmbed] });
+
+              let file = new Discord.MessageAttachment(
+                Buffer.from(html),
+                `${name}.html`
+              );
+              logChannel.send({ embeds: [logEmbed], files: [file] });
+
+              setTimeout(
+                () => interaction.channel.delete(),
+                supportbot.TicketDeleteTime
+              );
+            });
+          });
+      }
+    }
+    if (interaction.customId === "ticketlock") {
+      if (interaction.channel.name.startsWith(`${supportbot.TicketPrefix}`)) {
+        interaction.message.fetch();
+        interaction.deferUpdate();
+        let Admin =
+          interaction.guild.roles.cache.find(
+            (AdminUser) => AdminUser.name === supportbot.Admin
+          ) ||
+          interaction.guild.roles.cache.find(
+            (AdminUser) => AdminUser.id === supportbot.Admin
+          );
+        let all = interaction.channel.permissionOverwrites.cache;
+
+        let parent =
+          interaction.guild.channels.cache.find(
+            (c) => c.name === `${supportbot.LockTicketCategory}`
+          ) ||
+          interaction.guild.channels.cache.find(
+            (c) => c.id === `${supportbot.LockTicketCategory}`
+          );
+        if (parent) {
+          interaction.channel.setParent(parent.id);
+        }
+
+        all.forEach((perm) => {
+          interaction.channel.permissionOverwrites.delete(perm.id);
+        });
+        interaction.channel.permissionOverwrites.create(Admin.id, {
+          VIEW_CHANNEL: true,
+        });
+
+        interaction.channel.permissionOverwrites.create(interaction.guild.id, {
+          VIEW_CHANNEL: false,
+        });
+
+        const ticketDeleteButton = new Discord.MessageButton()
+          .setCustomId("ticketclose")
+          .setLabel("Close")
+          .setStyle(supportbot.TicketDeleteColour)
+          .setEmoji(supportbot.TicketDeleteEmoji);
+
+        const row = new Discord.MessageActionRow().addComponents(
+          ticketDeleteButton
+        );
+        const ArchiveEmbed = new Discord.MessageEmbed()
+          .setTitle("Archived")
+          .setDescription(`Archived ${interaction.channel.name}`)
+          .setColor(`${supportbot.SuccessColour}`);
+
+        interaction.channel.send({ embeds: [ArchiveEmbed] });
+        interaction.message.edit({ components: [row] });
+      }
+    }
+  }
+});

Events/ready.js

@@ -0,0 +1,131 @@
+// SupportBot | Emerald Services
+// Ready Event
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const panelconfig = yaml.load(
+  fs.readFileSync("./Configs/ticket-panel.yml", "utf8")
+);
+
+const Event = require("../Structures/Event.js");
+
+module.exports = new Event("ready", (client) => {
+  client.user.setActivity(supportbot.BotActivity, {
+    type: supportbot.ActivityType,
+    url: supportbot.StreamingURL,
+  });
+
+  console.log(`\u001b[32m`, `┏━━━┓╋╋╋╋╋╋╋╋╋╋╋╋╋┏┓┏━━┓╋╋╋┏┓`);
+  console.log(`\u001b[32m`, `┃┏━┓┃╋╋╋╋╋╋╋╋╋╋╋╋┏┛┗┫┏┓┃╋╋┏┛┗┓`);
+  console.log(`\u001b[32m`, `┃┗━━┳┓┏┳━━┳━━┳━━┳┻┓┏┫┗┛┗┳━┻┓┏┛`);
+  console.log(`\u001b[32m`, `┗━━┓┃┃┃┃┏┓┃┏┓┃┏┓┃┏┫┃┃┏━┓┃┏┓┃┃`);
+  console.log(`\u001b[32m`, `┃┗━┛┃┗┛┃┗┛┃┗┛┃┗┛┃┃┃┗┫┗━┛┃┗┛┃┗┓`);
+  console.log(`\u001b[32m`, `┗━━━┻━━┫┏━┫┏━┻━━┻┛┗━┻━━━┻━━┻━┛`);
+  console.log(`\u001b[32m`, `┗╋╋╋╋╋╋╋┃┃╋┃┃`);
+  console.log(`\u001b[32m`, `╋╋╋╋╋╋╋┗┛╋┗┛`);
+  console.log(`    `);
+  console.log(`\u001b[31m`, `――――――――――――――――――――――――――――――――――――――――――――`);
+  console.log(`    `);
+  console.log(
+    `\u001b[33m`,
+    `${supportbot.Name} v${supportbot.SupportBot_Version}`,
+    `\u001b[36m`,
+    `Connected to Discord`
+  );
+  console.log(
+    `\u001b[33m`,
+    `Resources:`,
+    `\u001b[36m`,
+    `https://emeraldsrv.dev/resources`
+  );
+  console.log(
+    `\u001b[33m`,
+    `Documentation:`,
+    `\u001b[36m`,
+    `https://supportbot.emeraldsrv.dev`
+  );
+  console.log(
+    `\u001b[33m`,
+    `Discord:`,
+    `\u001b[36m`,
+    `https://emeraldsrv.dev/discord`
+  );
+  console.log(
+    `\u001b[33m`,
+    `Hosting:`,
+    `\u001b[36m`,
+    `https://emeraldsrv.dev/hosting`
+  );
+  console.log(`    `);
+  console.log(`\u001b[37m`, `SupportBot proudly created by Emerald Services`);
+  console.log(`    `);
+  console.log(`\u001b[31m`, `――――――――――――――――――――――――――――――――――――――――――――`);
+
+  if (panelconfig.TicketPanel) {
+    let chan1 = client.channels.cache.find(
+      (channel) => channel.name === panelconfig.Channel
+    );
+
+    if (!chan1) {
+      console.log(
+        "\u001b[33m",
+        "[WARN] Ticket reaction panel is not setup, You can do so via the configuration file!"
+      );
+      return false;
+    }
+
+    const panelid = JSON.parse(
+      fs.readFileSync("./Data/ticket-panel-id.json", "utf8")
+    );
+
+    chan1.messages.fetch(panelid.TicketPanelID).catch(async (r) => {
+      let embed = new Discord.MessageEmbed()
+        .setTitle(`${panelconfig.PanelTitle}`)
+        .setColor(supportbot.SuccessColour)
+        .setFooter(supportbot.EmbedFooter);
+
+      if (panelconfig.TicketPanel_Description) {
+        embed.setDescription(panelconfig.PanelMessage);
+      }
+
+      if (panelconfig.TicketPanel_Thumbnail) {
+        embed.setThumbnail(panelconfig.PanelThumbnail);
+      }
+
+      if (panelconfig.TicketPanel_Image) {
+        embed.setImage(panelconfig.PanelImage);
+      }
+
+      let button = new Discord.MessageButton()
+        .setLabel(panelconfig.ButtonLabel)
+        .setCustomId("openticket")
+        .setStyle(panelconfig.ButtonColour);
+
+      let row = new Discord.MessageActionRow().addComponents(button);
+
+      await chan1
+        .send({
+          embeds: [embed],
+          components: [row],
+        })
+        .then((r) => {
+          let data = {
+            TicketPanelID: `${r.id}`,
+          };
+          fs.writeFileSync(
+            "./Data/ticket-panel-id.json",
+            JSON.stringify(data),
+            "utf8"
+          );
+        })
+        .catch((e) => {
+          console.log("Raw" + e);
+        });
+    });
+  }
+});

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 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
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.md

@@ -1,10 +1,13 @@
-  > #### SupportBot
+![imgur](https://i.imgur.com/TQj40Mt.png)
->
+
-> - SupportBot is a free to use discord ticket system that is highly customisable to your own brand, 
+## What is SupportBot?
-Why use a branded ticket bot when you have the ability to match your ticket bot with your servers name. 
+
->
+SupportBot is an open-sourced support system for discord. It's completely free to use with high amounts of customisation to match your own brand.
-> - Our Support team is over at [Discord](https://discord.com/invite/jspKFcE) ready to assist with any questions, concerns or setup information regarding SupportBot.
+
->
+## Quick Links
-> - [Download via Polymart](https://polymart.org/resource/supportbot-1-discord-ticket-bot.518)
+
-> - [Download via MC-Market](https://www.mc-market.org/resources/8940/)
+**|** [Discord](https://emeraldsrv.dev/discord) **|**
-
+[Hosting](https://emeraldsrv.dev/hosting) **|**
+[Documentation](https://docs.emeraldsrv.dev) **|**
+[Download via Polymart](https://polymart.org/resource/supportbot-1-discord-ticket-bot.518) **|**
+[Download via MC-Market](https://www.mc-market.org/resources/8940/) **|**

Structures/Addons.js

@@ -0,0 +1,25 @@
+// SupportBot | Emerald Services
+// Addon Structure
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+
+function RunFunction(interaction) {}
+
+class Addon {
+  constructor(options) {
+    this.name = options.name;
+    this.description = options.description;
+    this.permission = options.permission;
+    this.slashCommandOptions = options.slashCommandOptions || [];
+    this.run = options.run;
+  }
+}
+
+module.exports = Addon;

Structures/Client.js

@@ -0,0 +1,125 @@
+// SupportBot | Emerald Services
+// Client Structure
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const Command = require("./Command.js");
+const Event = require("./Event.js");
+const intents = new Discord.Intents(32767);
+
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+
+class Client extends Discord.Client {
+  constructor() {
+    super({ intents });
+
+    this.commands = new Discord.Collection();
+  }
+
+  start(token) {
+    const commandFiles = fs
+      .readdirSync("./Commands")
+      .filter((file) => file.endsWith(".js"));
+
+    const addonFiles = fs
+      .readdirSync("./Addons")
+      .filter((file) => file.endsWith(".js"));
+
+    const addons = addonFiles.map((file) => require(`../Addons/${file}`));
+
+    const commands = commandFiles.map((file) => require(`../Commands/${file}`));
+
+    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Commands ▬▬▬▬▬▬▬");
+
+    commands.forEach((cmd) => {
+      console.log(`\u001b[31;1m`, `${cmd.name}`, `\u001b[32;1m`, "Loaded");
+      this.commands.set(cmd.name, cmd);
+    });
+
+    addons.forEach((addon) => {
+      console.log(
+        `\u001b[33m`,
+        `[ADDON]`,
+        `\u001b[31;1m`,
+        `${addon.name}`,
+        `\u001b[32;1m`,
+        "Loaded"
+      );
+      this.commands.set(addon.name, addon);
+    });
+
+    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Commands ▬▬▬▬▬▬▬");
+
+    // Slash Commands
+
+    const slashCommands = commands.map((cmd) => ({
+      name: cmd.name.toLowerCase(),
+      description: cmd.description,
+      permissions: [],
+      options: cmd.slashCommandOptions,
+      defaultPermission: true,
+    }));
+
+    const slashCommands1 = addons.map((addon) => ({
+      name: addon.name.toLowerCase(),
+      description: addon.description,
+      permissions: [],
+      options: addon.slashCommandOptions,
+      defaultPermission: true,
+    }));
+
+    this.removeAllListeners();
+
+    this.on("ready", async () => {
+      const allCommands = slashCommands.concat(slashCommands1);
+      await this.application?.commands.set(allCommands);
+
+      console.log("   ");
+      console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Slash Command ▬▬▬▬▬▬▬"),
+        console.log("   ");
+
+      slashCommands.forEach((cmd) =>
+        console.log(
+          `\u001b[31;1m`,
+          `${cmd.name}`,
+          `\u001b[32;1m`,
+          `| Slash Command Registered`
+        )
+      );
+
+      slashCommands1.forEach((addon) =>
+        console.log(
+          `\u001b[33m`,
+          `[ADDON]`,
+          `\u001b[31;1m`,
+          `${addon.name}`,
+          `\u001b[32;1m`,
+          `| Slash Command Registered`
+        )
+      );
+    });
+
+    console.log("   ");
+    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
+
+    fs.readdirSync("./Events")
+      .filter((file) => file.endsWith(".js"))
+      .forEach((file) => {
+        const event = require(`../Events/${file}`);
+        console.log(`\u001b[31;1m`, `${event.event}`, `\u001b[32;1m`, "Loaded");
+
+        this.on(event.event, event.run.bind(null, this));
+      });
+
+    console.log(`\u001b[34;1m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
+    console.log("   ");
+
+    this.login(token);
+  }
+}
+
+module.exports = Client;

Structures/Command.js

@@ -0,0 +1,25 @@
+// SupportBot | Emerald Services
+// Command Structure
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+
+function RunFunction(interaction) {}
+
+class Command {
+  constructor(options) {
+    this.name = options.name;
+    this.description = options.description;
+    this.permission = options.permission;
+    this.slashCommandOptions = options.slashCommandOptions || [];
+    this.run = options.run;
+  }
+}
+
+module.exports = Command;

Structures/Event.js

@@ -0,0 +1,22 @@
+// SupportBot | Emerald Services
+// Event Structure
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+
+function RunFunction(client, ...eventArgs) {}
+
+class Event {
+  constructor(event, runFunction) {
+    this.event = event;
+    this.run = runFunction;
+  }
+}
+
+module.exports = Event;

Structures/TicketID.js

@@ -0,0 +1,92 @@
+// SupportBot | Emerald Services
+// Ticket ID Structure
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const Command = require("./Command.js");
+const Client = require("./Client.js");
+const Event = require("./Event.js");
+
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+
+class TicketNumberID {
+  static pad(guildId) {
+    let n = this.get(guildId) + "";
+    let z = "0";
+    let width = 4;
+    setTimeout(() => {
+      this.set(guildId, this.get(guildId) + 1);
+    }, 50);
+    return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
+  }
+
+  static get(guildId) {
+    let ticketnumberID = JSON.parse(
+      fs.readFileSync("./Data/TicketData.json", "utf8")
+    );
+
+    if (!ticketnumberID[guildId]) {
+      ticketnumberID[guildId] = {
+        id: 0,
+      };
+
+      fs.writeFileSync(
+        "./Data/TicketData.json",
+        JSON.stringify(ticketnumberID, null, 4),
+        (err) => {
+          if (err) console.log(err);
+        }
+      );
+
+      return 0;
+    } else {
+      return ticketnumberID[guildId].id;
+    }
+  }
+
+  static set(guildId, value) {
+    let ticketnumberID = JSON.parse(
+      fs.readFileSync("./Data/TicketData.json", "utf8")
+    );
+
+    ticketnumberID[guildId] = {
+      id: value,
+    };
+
+    fs.writeFileSync(
+      "./Data/TicketData.json",
+      JSON.stringify(ticketnumberID, null, 4),
+      (err) => {
+        if (err) console.log(err);
+      }
+    );
+
+    return value;
+  }
+
+  static reset(guildId) {
+    let ticketnumberID = JSON.parse(
+      fs.readFileSync("./Data/TicketData.json", "utf8")
+    );
+
+    ticketnumberID[guildId] = {
+      id: 0,
+    };
+
+    fs.writeFileSync(
+      "./Data/TicketData.json",
+      JSON.stringify(ticketnumberID, null, 4),
+      (err) => {
+        if (err) console.log(err);
+      }
+    );
+
+    return 0;
+  }
+}
+
+module.exports = TicketNumberID;

addons/addon-example.js

@@ -1,20 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Help Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-
-// location for the addons configuration, to keep it simple we generate a settings folder within the addons directory.
-const example = yaml.load(fs.readFileSync('./addons/settings/exampleaddon.yml', 'utf8'));
-
-module.exports = {
-    name: example.ExampleAddonCommand,
-    description: example.ExampleAddonDesc,
-
-    execute(message, args) {
-        if (supportbot.DeleteMessages == "true") message.delete();
-        message.channel.send(example.ExampleAddonMessage)
-    }
-};

addons/settings/exampleaddon.yml

@@ -1,9 +0,0 @@
-#
-# SupportBot, Created by Emerald Services
-# Example Addon
-#
-
-ExampleAddonCommand: "exampleaddon"
-ExampleAddonDesc: "This is the default/example addon for SupportBot."
-
-ExampleAddonMessage: "> :white_check_mark: This is the **default** addon for SupportBot. You can download addons from our website, https://emeraldservices.xyz/"

commands/addUser.js

@@ -1,65 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Add User
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.AddUser,
-    description: supportbot.AddUserDesc,
-
-    execute(message, args) {
-        if (supportbot.DeleteMessages == "true") message.delete();
-        console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `${message.author.tag} has executed ${supportbot.Prefix}${supportbot.AddUser}!`);
-
-        let SupportStaff = message.guild.roles.cache.find(SupportTeam => SupportTeam.name === supportbot.Staff)
-        let Admins = message.guild.roles.cache.find(AdminUser => AdminUser.name === supportbot.Admin)
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (message.member.roles.cache.has(SupportStaff.id) || message.member.roles.cache.has(Admins.id)) {
-                if (!message.channel.name.startsWith( `${supportbot.TicketChannel}-` )) {
-                    const Exists = new Discord.MessageEmbed()
-                        .setTitle("No Ticket Found!")
-                        .setDescription(`${supportbot.NoValidTicket}`)
-                        .setColor(supportbot.WarningColour);
-                    message.channel.send({ embed: Exists });
-        
-                    return;
-                }
-        
-                let rUser = message.guild.member(message.mentions.users.first() || message.guild.members.cache.get(args[0]));
-                    const UserNotExist = new Discord.MessageEmbed()
-                        .setTitle("User Not Found!")
-                        .setDescription(`${supportbot.UserNotFound}\n\nTry Again:\`${supportbot.Prefix}${supportbot.AddUser} <user#0000>\``)
-                        .setColor(supportbot.ErrorColour)
-        
-                    if (!rUser) return message.channel.send({ embed: UserNotExist });
-                
-                        message.channel.updateOverwrite(rUser, {
-                            VIEW_CHANNEL: true,
-                            CREATE_INVITE: false,
-                            SEND_MESSAGES: true,
-                            READ_MESSAGES: true
-                        });
-                
-                    const Complete = new Discord.MessageEmbed()
-                        .setTitle("User Added!")
-                        .setDescription(supportbot.AddedUser.replace(/%user%/g, rUser.id))
-                        .setTimestamp()
-                        .setColor(supportbot.EmbedColour)
-                   message.channel.send({ embed: Complete });
-            } else {
-                
-                return message.channel.send({ embed: NoPerms });
-
-            }
-
-    }
-};

commands/announce.js

@@ -1,73 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Announce
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.AnnounceCommand,
-    description: supportbot.AnnounceDesc,
-
-    execute(message, args) {
-	    
-	if (supportbot.DeleteMessages == "true") message.delete();
-	    
-        let locateChannel = message.guild.channels.cache.find(AnnouncementChannel => AnnouncementChannel.name === supportbot.AnnouncementChannel);
-
-        console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `${message.author.tag} has executed ${supportbot.Prefix}${supportbot.AnnounceCommand}!`);
-
-        const errornochannel = new Discord.MessageEmbed()
-            .setTitle("Invalid Channel")
-            .setDescription(`${supportbot.InvalidChannel}\n\nChannel Required: \`${supportbot.AnnouncementChannel}`)
-            .setColor(supportbot.ErrorColour);
-
-        if(!locateChannel) return message.channel.send({ embed: errornochannel });
-
-        let Admins = message.guild.roles.cache.find(adminRole => adminRole.name === supportbot.Admin);
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${Admins.name}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (!message.member.roles.cache.has(Admins.id)) 
-                return message.channel.send({ embed: NoPerms });
-
-
-            const embed = new Discord.MessageEmbed()
-                .setDescription(`> **${supportbot.AnnouncementStarter}**`)
-	            .setColor(supportbot.EmbedColour)
-            message.channel.send({ embed: embed });
-
-            let announcement = []
-            message.channel.awaitMessages(response => response.content.length > 2, {
-                max: 1,
-                time: 500000,
-                errors: ['time'],
-            }).then((collected) => {
-                announcement.push(collected.map(r => r.content));
-
-                locateChannel.send('@everyone')
-                const AnnouncementEmbed = new Discord.MessageEmbed()
-                    .setTitle(supportbot.AnnouncementTitle)
-                    .setThumbnail(supportbot.AnnouncementIcon)
-                    .setDescription(announcement)
-                    .setColor(supportbot.EmbedColour)
-                    .setFooter(supportbot.EmbedFooter, message.author.displayAvatarURL());
-                
-                locateChannel.send({ embed: AnnouncementEmbed }).then(async function(msg) {
-                    const AnnouncementComplete = new Discord.MessageEmbed()
-                        .setColor(supportbot.SuccessColour)
-                        .setDescription(`:white_check_mark: You have successfully created an announcement. <#${locateChannel.id}>`)
-                    message.channel.send({ embed: AnnouncementComplete })
-                })
-
-            });
-
-    }
-    
-};

commands/botSay.js

@@ -1,53 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Say Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.BotSay,
-    description: supportbot.BotSayDesc,
-
-    execute(message, args) {
-	if (supportbot.DeleteMessages == "true") message.delete();
-	    
-        let SupportStaff = message.guild.roles.cache.find(adminRole => adminRole.name === supportbot.Staff);
-
-        console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `${message.author.tag} has executed ${supportbot.Prefix}${supportbot.BotSay}!`);
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${SupportStaff.name}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (!message.member.roles.cache.has(SupportStaff.id)) 
-                return message.channel.send({ embed: NoPerms });
-
-
-            const embed = new Discord.MessageEmbed()
-                .setDescription(`> **What would you like me to say!**`)
-	            .setColor(supportbot.EmbedColour)
-            message.channel.send({ embed: embed });
-
-            let announcement = []
-            message.channel.awaitMessages(response => response.content.length > 2, {
-                max: 1,
-                time: 500000,
-                errors: ['time'],
-            }).then((collected) => {
-                announcement.push(collected.map(r => r.content));
-
-                const AnnouncementEmbed = new Discord.MessageEmbed()
-                    .setDescription(announcement)
-                    .setColor(supportbot.EmbedColour)
-                
-                message.channel.send({ embed: AnnouncementEmbed })
-        })
-
-    } 
-    
-};

commands/close.js

@@ -1,149 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Close Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.CloseTicket,
-    description: supportbot.CloseTicketDesc,
-
-    execute(message, args) {
-        if (supportbot.DeleteMessages == "true") message.delete();
-        
-        console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `${message.author.tag} has executed ${supportbot.Prefix}${supportbot.CloseTicket}!`);
-
-        if (!message.channel.name.startsWith( `${supportbot.TicketChannel}-` )) {
-            const Exists = new Discord.MessageEmbed()
-                .setTitle("No Ticket Found!")
-                .setDescription(`${supportbot.NoValidTicket}`)
-                .setColor(supportbot.WarningColour);
-            message.channel.send({ embed: Exists });
-
-            return;
-
-        }
-
-        if (supportbot.CloseConfirmation === "true") {
-            const CloseTicketRequest = new Discord.MessageEmbed()
-                .setTitle(`**${supportbot.ClosingTicket}**`)
-                .setDescription(`Please confirm by repeating the following word.. \`${supportbot.ClosingConfirmation_Word}\` `)
-                .setColor(supportbot.EmbedColour);
-
-            message.channel.send(CloseTicketRequest).then(m => {
-                message.channel.awaitMessages( response => response.content.toLowerCase() === supportbot.ClosingConfirmation_Word, {
-                    max: 1,
-                    time: 20000,
-                    errors: [ 'time' ],
-
-                    
-                }).then( collected => {
-                    let logChannel = message.guild.channels.cache.find(channel => channel.name === supportbot.TranscriptLog);
-                    let user = message.author;
-                    let reason = args.join(" ") || "No Reason Provided.";
-
-                    let name = message.channel.name;
-                    let ticketChannel = message.channel;
-
-                    message.channel.send(`**${supportbot.ClosingTicket}**`)
-
-                    .then(() => {
-                        const logEmbed = new Discord.MessageEmbed()
-                            .setTitle(supportbot.TranscriptTitle)
-                            .setColor(supportbot.EmbedColour)
-                            .setFooter(supportbot.EmbedFooter)
-                            .addField("Closed By", message.author.tag)
-                            .addField("Reason", reason);
-
-                        message.channel.messages.fetch({ limit: 100 }).then( msgs => {
-                            let txt = '';
-
-                            msgs = msgs.sort( ( a, b ) => a.createdTimestamp - b.createdTimestamp );
-                            txt += `${message.guild.name}\n`;
-                            txt += `#${ticketChannel.name}\n`;
-                            txt += `${msgs.size} messages\n\n\n`;
-
-                            msgs.forEach( msg => {
-                                if ( msg.content ) {
-                                    txt += `----- ${msg.author.tag} at ${msg.createdAt}\n`;
-                                    txt += `${msg.content}\n`;
-                                    txt += `-----\n\n`;
-                                }
-                            });
-
-                            logChannel.send(logEmbed).catch(err => {
-                                message.reply(err)
-                            })
-
-                            logChannel.send( new Discord.MessageAttachment( Buffer.from( txt ), `${name}.txt` ) );
-
-                            message.channel.delete();
-
-                        })
-                    })
-
-                })
-
-            }).catch( () => {
-                m.edit('The request to close the ticket has timed out.').then( m2 => m2.delete( 3000 ) );
-            });
-
-        }
-
-        if (supportbot.CloseConfirmation === "false") {
-
-                    let logChannel = message.guild.channels.cache.find(channel => channel.name === supportbot.TranscriptLog);
-                    let user = message.author;
-                    let reason = args.join(" ") || "No Reason Provided.";
-
-                    let name = message.channel.name;
-                    let ticketChannel = message.channel;
-
-                    message.channel.send(`**${supportbot.ClosingTicket}**`)
-
-                    .then(() => {
-                        const logEmbed = new Discord.MessageEmbed()
-                            .setTitle(supportbot.TranscriptTitle)
-                            .setColor(supportbot.EmbedColour)
-                            .setFooter(supportbot.EmbedFooter)
-                            .addField("Closed By", message.author.tag)
-                            .addField("Reason", reason);
-
-                        message.channel.messages.fetch({ limit: 100 }).then( msgs => {
-                            let txt = '';
-
-                            msgs = msgs.sort( ( a, b ) => a.createdTimestamp - b.createdTimestamp );
-                            txt += `${message.guild.name}\n`;
-                            txt += `#${ticketChannel.name}\n`;
-                            txt += `${msgs.size} messages\n\n\n`;
-
-                            msgs.forEach( msg => {
-                                if ( msg.content ) {
-                                    txt += `----- ${msg.author.tag} at ${msg.createdAt}\n`;
-                                    txt += `${msg.content}\n`;
-                                    txt += `-----\n\n`;
-                                }
-                            });
-
-                            logChannel.send(logEmbed).catch(err => {
-                                message.reply(err)
-                            })
-
-                            logChannel.send( new Discord.MessageAttachment( Buffer.from( txt ), `${name}.txt` ) );
-
-                            message.channel.delete();
-
-                        })
-
-                    }).catch( () => {
-                        m.edit('The request to close the ticket has timed out.').then( m2 => m2.delete( 3000 ) );
-                    });
-
-        }
-
-    }
-};

commands/help.js

@@ -1,55 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Help Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.HelpCommand,
-    description: supportbot.HelpDesc,
-
-    execute(message, args) {
-	if (supportbot.DeleteMessages == "true") message.delete();
-        
-    console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `${message.author.tag} has executed ${supportbot.Prefix}${supportbot.HelpCommand}!`);
-
-        let generalCommands = "";
-            generalCommands += `**${supportbot.Prefix}${supportbot.HelpCommand}** ${supportbot.HelpDesc}\n`;
-            generalCommands += `**${supportbot.Prefix}${supportbot.LinksCommand}** ${supportbot.LinkDesc}\n`;
-            generalCommands += `**${supportbot.Prefix}${supportbot.SuggestCommand}** ${supportbot.SuggestionDesc}\n`;
-            generalCommands += `**${supportbot.Prefix}${supportbot.PingCommand}** ${supportbot.PingDesc}\n`;
-        
-        let supportCommands = "";
-            supportCommands += `**${supportbot.Prefix}${supportbot.NewTicket} [reason]** ${supportbot.NewTicketDesc}\n`
-            supportCommands += `**${supportbot.Prefix}${supportbot.CloseTicket} [reason]** ${supportbot.CloseTicketDesc}\n`
-        
-        let staffCommands = "";
-            staffCommands += `**${supportbot.Prefix}${supportbot.AddUser} <user#0000>** ${supportbot.AddUserDesc}\n`
-            staffCommands += `**${supportbot.Prefix}${supportbot.RemoveUser} <user#0000>** ${supportbot.RemoveUserDesc}\n`
-            staffCommands += `**${supportbot.Prefix}${supportbot.BotSay}** ${supportbot.BotSayDesc}\n` 
-            staffCommands += `**${supportbot.Prefix}${supportbot.AnnounceCommand}** ${supportbot.AnnounceDesc}\n` 
-            
-        const HelpCommandEmbed = new Discord.MessageEmbed()
-            .setTitle(supportbot.Bot_Name)
-            .setThumbnail(message.author.displayAvatarURL())
-
-            .addFields(
-                { name: '🖥️ General Commands', value: `${generalCommands}\n`, inline: false },
-                { name: '🎫 Support Commands', value: `${supportCommands}\n`, inline: false },
-            )
-
-            .setColor(supportbot.EmbedColour)
-            .setFooter(supportbot.EmbedFooter, message.author.displayAvatarURL());
-
-            if (message.member.roles.cache.some(role => role.name === supportbot.Staff || supportbot.Admin)) {
-                HelpCommandEmbed.addFields(
-                    { name: '🔐 Staff Commands', value: `${staffCommands}\n`, inline: false },
-                )
-            }
-
-	    message.channel.send({ embed: HelpCommandEmbed });
-    }
-};

commands/links.js

@@ -1,36 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Links Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.LinksCommand,
-    description: supportbot.LinksDesc,
-
-    execute(message, args) {
-        if (supportbot.DeleteMessages == "true") message.delete();
-        
-        console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `${message.author.tag} has executed ${supportbot.Prefix}${supportbot.LinksCommand}!`);
-
-        const LinksEmbed = new Discord.MessageEmbed()
-            .setColor(supportbot.EmbedColour)
-
-        let botLinks = supportbot.LINKS;
-        
-        let links = '';
-        
-        for ( let name in botLinks ) {
-            links += `[${name}](${botLinks[ name ]})\n`;
-        };
-
-        LinksEmbed.addField(supportbot.LinksTitle, links)
-
-        message.channel.send({ embed: LinksEmbed });
-
-    }
-};

commands/newticket.js

@@ -1,272 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Ticket Command
-
-
-const Discord = require("discord.js");
-const bot = new Discord.Client()
-
-const fs = require("fs")
-const yaml = require('js-yaml');
-
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-const TicketNumberID = require('../utils/TicketNumber.js');
-
-const reacted = [];
-
-module.exports = {
-    name: supportbot.NewTicket,
-    description: supportbot.NewTicketDesc,
-
-    execute(message, args) {
-      if (!message.channel.name === supportbot.ReactionChannel) {
-        if (supportbot.DeleteMessages == "true") message.delete();
-      }
-        
-      console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `${message.author.tag} has executed ${supportbot.Prefix}${supportbot.NewTicket}!`);
-
-      // Ticket ID
-      let ticketNumberID = TicketNumberID.pad(message.guild.id);
-
-      // Ticket Subject
-      const TicketSubject = args || supportbot.NoTicketSubject;
-
-      // Ticket Exists
-      const TicketExists = new Discord.MessageEmbed()
-        .setTitle("Ticket Exists!")
-        .setDescription(`${supportbot.TicketExists}`)
-        .setColor(supportbot.WarningColour)
-
-      if (message.guild.channels.cache.find(SupportTicket => SupportTicket.name === `${supportbot.TicketChannel}-${ticketNumberID}`)) 
-      return message.channel.send({ embed: TicketExists });
-
-      message.guild.channels.create(`${supportbot.TicketChannel}-${ticketNumberID}`, {
-        type: "text",
-      }).then(SupportTicket => {
-
-        let AllUsers = message.guild.roles.cache.find(everyone => everyone.name === '@everyone')
-        let SupportStaff = message.guild.roles.cache.find(SupportTeam => SupportTeam.name === supportbot.Staff)
-        let Admins = message.guild.roles.cache.find(AdminUser => AdminUser.name === supportbot.Admin)
-
-        let DeptRole1 = message.guild.roles.cache.find(DepartmentRole => DepartmentRole.name === `${supportbot.DepartmentRole_1}`)
-        let DeptRole2 = message.guild.roles.cache.find(DepartmentRole => DepartmentRole.name === `${supportbot.DepartmentRole_2}`)
-        let DeptRole3 = message.guild.roles.cache.find(DepartmentRole => DepartmentRole.name === `${supportbot.DepartmentRole_3}`)
-        
-        SupportTicket.updateOverwrite(AllUsers, {
-          VIEW_CHANNEL: false,
-          READ_MESSAGES: false,
-          SEND_MESSAGES: false,
-        })
-          
-        SupportTicket.updateOverwrite(message.author, {
-          VIEW_CHANNEL: true,
-          READ_MESSAGES: true,
-          SEND_MESSAGES: true,
-        })
-
-        SupportTicket.updateOverwrite(SupportStaff, {
-          VIEW_CHANNEL: true,
-          READ_MESSAGES: true,
-          SEND_MESSAGES: true,
-        })
-
-        SupportTicket.updateOverwrite(Admins, {
-          VIEW_CHANNEL: true,
-          READ_MESSAGES: true,
-          SEND_MESSAGES: true,
-        })
-
-        // Ticket Category
-        let TicketCategory = message.guild.channels.cache.find(category => category.name === supportbot.TicketCategory)
-
-        if (TicketCategory) {
-          SupportTicket.setParent(TicketCategory.id)
-        } else {
-          if (message.guild.channels.cache.get(supportbot.TicketCategory)) {
-            SupportTicket.setParent(message.guild.channels.cache.get(supportbot.TicketCategory).id);
-          }
-        }
-
-        // Ticket Created, Message Sent
-
-        if (supportbot.AllowTicketMentions === "true") {
-          SupportTicket.send(`<@${message.author.id}>`)
-        }
-
-        const TicketMessage = new Discord.MessageEmbed()
-          .setTitle(supportbot.Ticket_Title.replace(/%ticketauthor%/g, message.author.id).replace(/%ticketid%/g, SupportTicket.id).replace(/%ticketusername%/g, message.author.username))
-          .setDescription(supportbot.TicketMessage.replace(/%ticketauthor%/g, message.author.id).replace(/%ticketid%/g, SupportTicket.id).replace(/%ticketusername%/g, message.author.username))
-          .setColor(supportbot.EmbedColour)
-
-        if (supportbot.TicketSubject === "embed") {
-
-          if (TicketSubject != 'No Reason Provided.') {
-            TicketMessage.addFields({ name: 'Reason', value: TicketSubject })
-          }
-          
-        }
-
-        if (supportbot.TicketSubject === "description") {
-
-          if (TicketSubject != 'No Reason Provided.') {
-            SupportTicket.setTopic(`Reason: ${TicketSubject}  -  User ID: ${message.author.id}  -  Ticket: ${SupportTicket.name}`)
-          }
-          
-        }
-
-        if (supportbot.TicketDepartments === "true") {
-          TicketMessage.addFields({ name: 'Departments', value: `${supportbot.DepartmentEmoji_1} **${supportbot.DepartmentTitle_1}**\n${supportbot.DepartmentEmoji_2} **${supportbot.DepartmentTitle_2}**\n${supportbot.DepartmentEmoji_3} **${supportbot.DepartmentTitle_3}**` })
-        }
-
-        SupportTicket.send({ embed: TicketMessage }).then( async function(msg) {
-        
-          const Emoji_1 = supportbot.DepartmentEmoji_1;
-          const Emoji_2 = supportbot.DepartmentEmoji_2;
-          const Emoji_3 = supportbot.DepartmentEmoji_3;
-
-          reacted[ticketNumberID] = false;
-
-          if (supportbot.TicketDepartments === "true") {
-            await msg.react(Emoji_1);
-            await msg.react(Emoji_2);
-            await msg.react(Emoji_3);
-            let filter = (reaction, user) => {
-              if (user.id !== message.author.id) return;
-              if (typeof reacted[ticketNumberID] !== "boolean") return;
-              delete reacted[ticketNumberID];
-              if (reaction.emoji.name === Emoji_1) {
-                SupportTicket.updateOverwrite(message.author.id, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                SupportTicket.updateOverwrite(Admins, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                SupportTicket.updateOverwrite(DeptRole1, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-          
-                if (supportbot.AllowStaff === "true") {
-                  SupportTicket.updateOverwrite(SupportStaff, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                }
-          
-                if (supportbot.AllowStaff === "false") {
-                  SupportTicket.updateOverwrite(SupportStaff, { VIEW_CHANNEL: false, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                }
-
-                const Department1 = new Discord.MessageEmbed()
-                  .setTitle(`> Thank for reaching out to the **${supportbot.DepartmentTitle_1} Department**. Please provide us information regarding your query.`)
-                  .setColor(supportbot.EmbedColour)
-                SupportTicket.send({ embed: Department1 });
-
-                if (supportbot.AllowTicketMentions === "true") {
-                  SupportTicket.send(`@here`)
-                }
-          
-              }
-          
-              if (reaction.emoji.name === Emoji_2) {
-                SupportTicket.updateOverwrite(message.author.id, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                SupportTicket.updateOverwrite(Admins, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                SupportTicket.updateOverwrite(DeptRole2, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-          
-                if (supportbot.AllowStaff === "true") {
-                  SupportTicket.updateOverwrite(SupportStaff, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                }
-
-                if (supportbot.AllowStaff === "false") {
-                  SupportTicket.updateOverwrite(SupportStaff, { VIEW_CHANNEL: false, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                }
-          
-                const Department2 = new Discord.MessageEmbed()
-                  .setTitle(`> Thank for reaching out to the **${supportbot.DepartmentTitle_2} Department**. Please provide us information regarding your query.`)
-                  .setColor(supportbot.EmbedColour)
-                SupportTicket.send({ embed: Department2 });
-
-                if (supportbot.AllowTicketMentions === "true") {
-                  SupportTicket.send(`@here`)
-                }
-          
-              }
-          
-              if (reaction.emoji.name === `${Emoji_3}`) {
-                SupportTicket.updateOverwrite(message.author.id, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                SupportTicket.updateOverwrite(Admins, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                SupportTicket.updateOverwrite(DeptRole3, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                SupportTicket.updateOverwrite(SupportStaff, { VIEW_CHANNEL: false, READ_MESSAGES: true, SEND_MESSAGES: true, })
-          
-                if (supportbot.AllowStaff === "true") {
-                  SupportTicket.updateOverwrite(SupportStaff, { VIEW_CHANNEL: true, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                }
-
-                if (supportbot.AllowStaff === "false") {
-                  SupportTicket.updateOverwrite(SupportStaff, { VIEW_CHANNEL: false, READ_MESSAGES: true, SEND_MESSAGES: true, })
-                }
-          
-                const Department3 = new Discord.MessageEmbed()
-                .setTitle(`> Thank for reaching out to the **${supportbot.DepartmentTitle_3} Department**. Please provide us information regarding your query.`)
-                  .setColor(supportbot.EmbedColour)
-                SupportTicket.send({ embed: Department3 });
-
-                if (supportbot.AllowTicketMentions === "true") {
-                  SupportTicket.send(`@here`)
-                }
-
-              }
-              return [Emoji_1, Emoji_2, Emoji_3].includes(reaction.emoji.name) && user.id !== message.author.id;
-            }
-            msg.awaitReactions(filter, { 
-              max: 4, 
-              time: 60000, 
-              errors: ['time'] 
-            }).then(async collected => {
-            });
-
-            setTimeout(async function() {
-              if (typeof reacted[ticketNumberID] == "boolean") {
-                delete reacted[ticketNumberID];
-                //delete channel because didn't react in a minute
-              }
-            }, 60000);
-
-          }
-  
-        });
-
-        if (message.channel.name === supportbot.ReactionChannel) {
-          const CreatedTicket = new Discord.MessageEmbed()
-              .setDescription(supportbot.TicketCreatedAlert.replace(/%ticketauthor%/g, message.author.id).replace(/%ticketid%/g, SupportTicket.id).replace(/%ticketusername%/g, message.author.username))
-              .setColor(supportbot.EmbedColour)
-          message.channel.send({embed: CreatedTicket}).then((r) => {
-            r.delete({ timeout:5000 })
-          })
-        } else {
-          const CreatedTicket = new Discord.MessageEmbed()
-              .setDescription(supportbot.TicketCreatedAlert.replace(/%ticketauthor%/g, message.author.id).replace(/%ticketid%/g, SupportTicket.id).replace(/%ticketusername%/g, message.author.username))
-              .setColor(supportbot.EmbedColour)
-          message.channel.send({embed: CreatedTicket});
-        }
-        fs.writeFileSync("./storage/SupportTickets.json", '{\n    "ticket": "' + SupportTicket.name + '", \n    "id":' + message.author.id + "\n}", (err) => {
-          if (!err) return;
-          console.error(err)
-      })
-
-        // Ticket Logs
-
-        const errornochannel = new Discord.MessageEmbed()
-          .setTitle("SupportBot Error!")
-          .setDescription(`:x: **Error!** Channel not Found, This command cannot be executed proberbly as their is no channel within this server.\nThis is configurable via **supportbot-config.yml**\n\nChannel Required: \`${supportbot.TicketLog}\`\n\nError Code: \`SB-03\``)
-          .setColor(supportbot.ErrorColour);
-
-        const TicketLogs = new Discord.MessageEmbed()
-          .setTitle("Ticket Log")
-          .setThumbnail(supportbot.Ticket_Thumbnail)
-          .addFields(
-            { name: 'Ticket', value: `<#${SupportTicket.id}>` },
-            { name: 'User', value: `<@${message.author.id}>` },
-          )
-          .setColor(supportbot.EmbedColour)
-          .setFooter(supportbot.EmbedFooter)
-
-        let locateChannel = message.guild.channels.cache.find(LocateChannel => LocateChannel.name === supportbot.TicketLog)
-
-        if(!locateChannel) return message.channel.send({ embed: errornochannel });
-
-        locateChannel.send({ embed: TicketLogs });
-      })
-
-    }
-
-};

commands/ping.js

@@ -1,27 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Ping Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.PingCommand,
-    description: supportbot.PingDesc,
-
-    execute(message, args) {        
-	if (supportbot.DeleteMessages == "true") message.delete();
-        
-    console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `${message.author.tag} has executed ${supportbot.Prefix}${supportbot.PingCommand}!`)
-
-        let ping = Date.now() - message.createdTimestamp + " ms";
-        
-        const PingCommandEmbed = new Discord.MessageEmbed()
-            .setDescription(`🏓 **Pong!** \`${Date.now() - message.createdTimestamp}ms\``)
-            .setColor(supportbot.EmbedColour)
-
-	    message.channel.send({ embed: PingCommandEmbed });
-    }
-};

commands/removeUser.js

@@ -1,64 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Remove User
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.RemoveUser,
-    description: supportbot.RemoveUserDesc,
-
-    execute(message, args) {        
-        if (supportbot.DeleteMessages == "true") message.delete();
-        
-        console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `${message.author.tag} has executed ${supportbot.Prefix}${supportbot.RemoveUser}!`);
-
-        let SupportStaff = message.guild.roles.cache.find(SupportTeam => SupportTeam.name === supportbot.Staff)
-        let Admins = message.guild.roles.cache.find(AdminUser => AdminUser.name === supportbot.Admin)
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (message.member.roles.cache.has(SupportStaff.id) || message.member.roles.cache.has(Admins.id)) {
-                if (!message.channel.name.startsWith( `${supportbot.TicketChannel}-` )) {
-                    const Exists = new Discord.MessageEmbed()
-                        .setTitle("No Ticket Found!")
-                        .setDescription(`${supportbot.NoValidTicket}`)
-                        .setColor(supportbot.WarningColour);
-                    message.channel.send({ embed: Exists });
-        
-                    return;
-                }
-        
-                let rUser = message.guild.member(message.mentions.users.first() || message.guild.members.cache.get(args[0]));
-                    const UserNotExist = new Discord.MessageEmbed()
-                        .setTitle("User Not Found!")
-                        .setDescription(`${supportbot.UserNotFound}\n\nTry Again:\`${supportbot.Prefix}${supportbot.RemoveUser} <user#0000>\``)
-                        .setColor(supportbot.ErrorColour)
-        
-                    if (!rUser) return message.channel.send({ embed: UserNotExist });
-                
-                        message.channel.updateOverwrite(rUser, {
-                            VIEW_CHANNEL: false,
-                            CREATE_INVITE: false,
-                            SEND_MESSAGES: false,
-                            READ_MESSAGES: false
-                        });
-                
-                    const Complete = new Discord.MessageEmbed()
-                        .setTitle("User Removed!")
-                        .setDescription(supportbot.RemovedUser.replace(/%user%/g, rUser.id))
-                        .setTimestamp()
-                        .setColor(supportbot.EmbedColour)
-                   message.channel.send({ embed: Complete });
-            } else {
-                return message.channel.send({ embed: NoPerms });
-            }
-
-    }
-};

commands/suggest.js

@@ -1,62 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Suggest Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.SuggestCommand,
-    description: supportbot.SuggestionDesc,
-
-    execute(message, args) {
-	if (supportbot.DeleteMessages == "true") message.delete();
-	    
-        let locateChannel = message.guild.channels.cache.find(SuggestionChannel => SuggestionChannel.name === supportbot.SuggestionChannel);
-
-        console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `${message.author.tag} has executed ${supportbot.Prefix}${supportbot.SuggestCommand}!`);
-
-        const errornochannel = new Discord.MessageEmbed()
-            .setTitle("Invalid Channel")
-            .setDescription(`${supportbot.InvalidChannel}\n\nChannel Required: \`${supportbot.SuggestionChannel}\``)
-            .setColor(supportbot.ErrorColour);
-
-        if(!locateChannel) return message.channel.send({ embed: errornochannel });
-
-        const embed = new Discord.MessageEmbed()
-            .setDescription(`> **${supportbot.SuggestionStarter}**`)
-	        .setColor(supportbot.EmbedColour)
-        message.channel.send({ embed: embed });
-
-        let suggestion = []
-        message.channel.awaitMessages(response => response.content.length > 2, {
-            max: 1,
-            time: 500000,
-            errors: ['time'],
-        }).then((collected) => {
-            suggestion.push(collected.map(r => r.content));
-
-            const SuggestionMessage = new Discord.MessageEmbed()
-                .setColor(supportbot.EmbedColour)
-                .setFooter(supportbot.EmbedFooter)
-
-                .setTitle(supportbot.SuggestionTitle)
-                .setDescription(`\`\`\`${suggestion}\`\`\``)
-
-                .addFields( { name: "From", value: `<@${message.author.id}>`, inline: false }, )
-
-            locateChannel.send({ embed: SuggestionMessage }).then(async function(msg) {
-                msg.react(supportbot.SuggestReact_1).then(() => msg.react(supportbot.SuggestReact_2));
-            });
-
-            const SuggestionComplete = new Discord.MessageEmbed()
-                .setColor(supportbot.SuccessColour)
-                .setDescription(`:white_check_mark: Your suggestion has been successfully created. <#${locateChannel.id}>`)
-            message.channel.send({ embed: SuggestionComplete })
-
-        });
-    
-    }
-};

events/guildMemberAdd.js

@@ -1,49 +0,0 @@
-// SupportBot 6.0, Created by Emerald Services
-// Ready Event
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = async (bot, member) => {
-
-  if (supportbot.SystemMessages === "true") {
-    const SystemChannel = member.guild.channels.cache.find(channel => channel.name === supportbot.SystemMessage_Channel)
-    
-    if (!SystemChannel) return;
-    
-    console.log(`[${supportbot.Bot_Name}]: ${member.user.username} has joined ${member.guild.name}!`)
-    console.log(supportbot.AutoRole_Role)
-
-    if (supportbot.SystemMessage_Type === "embed") {
-      const GuildAddMember = new Discord.MessageEmbed()
-        .setTitle(supportbot.Welcome_Title)
-        .setDescription(supportbot.WelcomeMessage.replace(/%member%/g, member.user.username).replace(/%guildname%/g, member.guild.name))
-        .setColor(supportbot.EmbedColour)
-
-        if (supportbot.SystemMessage_Icon === "BOT") {
-            GuildAddMember.setThumbnail(bot.user.displayAvatarURL())
-        }
-
-        if (supportbot.SystemMessage_Icon === "USER") {
-            GuildAddMember.setThumbnail(member.user.displayAvatarURL())
-        }
-
-
-        if (supportbot.SystemMessage_EmbedFooter === "true") {
-            GuildAddMember.setFooter(supportbot.EmbedFooter)
-        }
-
-    SystemChannel.send({ embed: GuildAddMember });
-        
-    }
-
-    if (supportbot.SystemMessage_Type === "normal") {
-        SystemChannel.send(supportbot.WelcomeMessage.replace(/%member%/g, member.user.username).replace(/%guildname%/g, member.guild.name))
-
-    }
-
-  }
-};

events/guildMemberRemove.js

@@ -1,48 +0,0 @@
-// SupportBot 6.0, Created by Emerald Services
-// Ready Event
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = async (bot, member) => {
-
-  if (supportbot.SystemMessages === "true") {
-    const SystemChannel = member.guild.channels.cache.find(channel => channel.name === supportbot.SystemMessage_Channel)
-    
-    if (!SystemChannel) return;
-    
-    console.log(`[${supportbot.Bot_Name}]: ${member.user.username} has left ${member.guild.name}!`)
-
-    if (supportbot.SystemMessage_Type === "embed") {
-      const GuildRemoveMember = new Discord.MessageEmbed()
-        .setTitle(supportbot.Leave_Title)
-        .setDescription(supportbot.LeaveMessage.replace(/%member%/g, member.user.username).replace(/%guildname%/g, member.guild.name))
-        .setColor(supportbot.EmbedColour)
-
-        if (supportbot.SystemMessage_Icon === "BOT") {
-          GuildRemoveMember.setThumbnail(bot.user.displayAvatarURL())
-        }
-
-        if (supportbot.SystemMessage_Icon === "USER") {
-          GuildRemoveMember.setThumbnail(member.user.displayAvatarURL())
-        }
-
-
-        if (supportbot.SystemMessage_EmbedFooter === "true") {
-          GuildRemoveMember.setFooter(supportbot.EmbedFooter)
-        }
-
-    SystemChannel.send({ embed: GuildRemoveMember });
-        
-    }
-
-    if (supportbot.SystemMessage_Type === "normal") {
-        SystemChannel.send(supportbot.LeaveMessage.replace(/%member%/g, member.user.username).replace(/%guildname%/g, member.guild.name))
-
-    }
-
-  }
-};

events/message.js

@@ -1,22 +0,0 @@
-// SupportBot 6.0, Created by Emerald Services
-// Message Event
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = async (bot, message) => {
-	if(message.author.bot) return;
-  	if(message.channel.type === "dm") return;
-  	if (message.content.indexOf(supportbot.Prefix) !== 0) return;
-
-  	let messageArray = message.content.split(" ");
-  	const args = message.content.slice(supportbot.Prefix.length).trim().split(/ +/g);
-  	const command = args.shift().toLowerCase();
-
-  	const cmd = bot.commands.get(command);
-  	if(!cmd) return;
-  	cmd.execute(message, args);
-};

events/messageReactionAdd.js

@@ -1,36 +0,0 @@
-// SupportBot 6.0, Created by Emerald Services
-// Message Reaction Event
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-const tickets = yaml.load(fs.readFileSync('./storage/ticketreaction.yml', 'utf8'));
-
-module.exports = async (client, reaction, user) => {
-
-    let message = {
-        guild: reaction.message.channel.guild,
-        author: user,
-        content: "Not available",
-        channel: reaction.message.channel
-    }
-
-    if (supportbot.ReactionTickets === "true") {
-        if (reaction.message.id === tickets.ReactionMessage_ID) {
-            if (reaction.emoji.name == supportbot.ReactionEmoji || reaction.emoji.id == supportbot.ReactionEmoji) {
-                await reaction.users.remove(user.id)
-
-            	try {
-            	    const cmd = client.commands.get("ticket");
-            	    if(!cmd) return;
-            	    
-            	    cmd.execute(message, "undefined");
-            	} catch (error) {
-            	    console.error(error);
-            	}
-            }
-        }
-    }
-};

events/ready.js

@@ -1,54 +0,0 @@
-// SupportBot 6.0, Created by Emerald Services
-// Ready Event
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-const tickets = yaml.load(fs.readFileSync('./storage/ticketreaction.yml', 'utf8'));
-
-  
-module.exports = async (bot) => {
-    bot.user.setActivity(supportbot.BotActivity, {
-        type: supportbot.ActivityType, 
-        url: supportbot.StreamingURL
-        
-    });
-    
-    console.log(`\u001b[32m`, `―――――――――――――――――― SupportBot ――――――――――――――――――`)
-    console.log(`\u001b[37m`, `${supportbot.Bot_Name} has successfully connected to discord`)
-    console.log(`\u001b[32m`, `―――――――――――――――――― SupportBot ――――――――――――――――――`)
-
-    if (supportbot.ReactionTickets === "true") {
-        let chan1 = bot.channels.cache.find(channel => channel.name === supportbot.ReactionChannel)
-
-        if (!chan1) {
-            console.log('\u001b[33m', "[WARN] Ticket reaction panel is not setup, You can do so via the configuration file!")
-            return false;
-        }
-
-        chan1.messages.fetch(tickets.ReactionMessage_ID).catch(r => {
-            let embed = new Discord.MessageEmbed()
-                .setTitle(supportbot.ReactionMessage.replace(/%reaction_emoji%/g, supportbot.ReactionEmoji))
-                .setColor(supportbot.SuccessColour)
-                .setFooter(supportbot.EmbedFooter);
-
-            bot.channels.cache.find(channel => channel.name === supportbot.ReactionChannel).send({ 
-                embed: embed 
-            }).then(r => {
-                let data = {
-                    "ReactionMessage_ID": `${r.id}`
-                }
-                let yamlStr = yaml.dump(data);
-                fs.writeFileSync('./storage/ticketreaction.yml', yamlStr, 'utf8');
-                
-                r.react(supportbot.ReactionEmoji);
-            }).catch(e => {
-                console.log(e)
-            })
-        })
-    }
-
-
-};

index.js

@@ -1,92 +1,24 @@
-//        _________                                  __ __________        __   
+//      ___                            _    ___        _
-//       /   _____/__ ________ ______   ____________/  |\______   \ _____/  |_ 
+//    / __> _ _  ___  ___  ___  _ _ _| |_ | . > ___ _| |_
-//       \_____  \|  |  \____ \\____ \ /  _ \_  __ \   __\    |  _//  _ \   __\
+//     \__ \| | || . \| . \/ . \| '_> | |  | . \/ . \ | |
-//       /        \  |  /  |_> >  |_> >  <_> )  | \/|  | |    |   (  <_> )  |  
+//     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|
-//      /_______  /____/|   __/|   __/ \____/|__|   |__| |______  /\____/|__|  
+//                |_|  |_|
-//              \/      |__|   |__|                             \/             
 //
-//                      SupportBot version 6.1
+//           SupportBot created by Emerald Services
-//                      Created by Emerald Services
+//           Installed with MIT License
-//                      Installed with MIT License
 //
-//                      Support Server: discord.gg/jspKFcE
+//           Discord Support: https://emeraldsrv.dev/discord
+//           Community Resources: https://emeraldsrv.dev/resources
+
+const fs = require("fs");
 
 const Discord = require("discord.js");
-const fs = require("fs");
+const yaml = require("js-yaml");
-const bot = new Discord.Client();
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
 
-bot.commands = new Discord.Collection();
+const Client = require("./Structures/Client.js");
+const client = new Client({});
 
-const yaml = require('js-yaml');
+client.start(supportbot.Token);
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-const { promisify } = require("util");
-const readdir = promisify(require("fs").readdir);
-
-String.prototype.toProperCase = function () {
-    return this.replace(
-        /([^\W_]+[^\s-]*) */g,
-        (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()
-    );
-};
-
-const init = async () => {
-    const evtFiles = await readdir("./events/");
-    
-    evtFiles.forEach((file, i) => {
-        const eventName = file.split(".")[0];
-        const event = require(`./events/${file}`);
-        
-        console.info(`\u001b[37m`, `[${supportbot.Bot_Name}]:`, `\u001b[31m`, `#${i + 1} Event Loaded: ${eventName.toProperCase()} `);
-        
-        bot.on(eventName, event.bind(null, bot));
-        delete require.cache[require.resolve(`./events/${file}`)];
-    });
-
-    console.info(`\u001b[37m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `Successfully loaded ${evtFiles.length} events.`);
-    console.info(`\u001b[37m`, "-----------------------------------------------------------------------------");
-};
-
-init();
-
-fs.readdir("./commands/", (err, files) => {
-    if (err) console.info(err, "error");
-    
-    let jsfiles = files.filter((f) => f.split(".").pop() === "js");
-
-    if (jsfiles.length <= 0) {
-        console.log(`[${supportbot.Bot_Name}]: No commands found. Try to Re-download the resource`);
-        return;
-    }
-  
-    jsfiles.forEach((f, i) => {
-        let props = require(`./commands/${f}`);
-        console.info(`\u001b[37m`, `[${supportbot.Bot_Name}]:`, `\u001b[31m`, `#${i + 1} Command Loaded: ${props.name.toProperCase()}`);
-        bot.commands.set(props.name, props);
-    });
-
-    console.info(`\u001b[37m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `Loaded ${jsfiles.length} commands!`);
-    console.info(`\u001b[37m`, "-----------------------------------------------------------------------------");
-});
-
-fs.readdir("./addons/", (err, files) => {
-    if (err) console.info(err, "error");
-    
-    let jsfiles = files.filter((f) => f.split(".").pop() === "js");
-
-    if (jsfiles.length <= 0) {
-        console.log(`[${supportbot.Bot_Name}]: No addons found. You can download addons from https://emeraldservices.xyz`);
-        return;
-    }
-  
-    jsfiles.forEach((f, i) => {
-        let props = require(`./addons/${f}`);
-        console.info(`\u001b[37m`, `[${supportbot.Bot_Name}]:`, `\u001b[31m`, `#${i + 1} Command Loaded: ${props.name.toProperCase()}`);
-        bot.commands.set(props.name, props);
-    });
-
-    console.info(`\u001b[37m`, `[${supportbot.Bot_Name}]:`, `\u001b[32m`, `Loaded ${jsfiles.length} commands!`);
-    console.info(`\u001b[37m`, "-----------------------------------------------------------------------------");
-});
-
-bot.login(supportbot.Token);

package.json

@@ -1,27 +1,23 @@
 {
   "name": "supportbot",
-  "version": "6.1",
+  "version": "7.3.0",
-  "description": "SupportBot | #1 Self-Hosted Ticket Bot",
+  "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",
-  "dependencies": {
-    "discord.js": "^12.5.1",
-    "javascript-obfuscator": "^2.9.4",
-    "js-yaml": "^3.14.0"
-  },
-  "devDependencies": {
-    "node-fetch": ">=2.6.1"
-  },
   "scripts": {
-    "test": "help"
+    "start": "npm i && node index.js"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/1tzemerald/SupportBot.git"
+    "url": "git+https://github.com/Emerald-Services/SupportBot.git"
   },
   "author": "Emerald Services",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/1tzemerald/SupportBot/issues"
+    "url": "https://github.com/Emerald-Services/SupportBot/issues"
   },
-  "homepage": "https://emeraldsrv.dev"
+  "homepage": "https://github.com/Emerald-Services/SupportBot#readme",
+  "dependencies": {
+    "discord.js": "^13.2.0",
+    "js-yaml": "^4.1.0"
+  }
 }

storage/SupportTickets.json

@@ -1,4 +0,0 @@
-{
-    "ticket": "ticket-0012", 
-    "id":419821884431925260
-}

storage/TicketID.json

@@ -1,8 +0,0 @@
-{
-    "716992597377286145": {
-        "id": 65
-    },
-    "805909541979029524": {
-        "id": 13
-    }
-}

storage/ticketreaction.yml

@@ -1 +0,0 @@
-ReactionMessage_ID: ''

supportbot-config.yml

@@ -1,195 +0,0 @@
-#        _________                                  __ __________        __   
-#       /   _____/__ ________ ______   ____________/  |\______   \ _____/  |_ 
-#       \_____  \|  |  \____ \\____ \ /  _ \_  __ \   __\    |  _//  _ \   __\
-#       /        \  |  /  |_> >  |_> >  <_> )  | \/|  | |    |   (  <_> )  |  
-#      /_______  /____/|   __/|   __/ \____/|__|   |__| |______  /\____/|__|  
-#              \/      |__|   |__|                             \/             
-#
-#                      SupportBot version 6.1
-#                      Created by Emerald Services
-#                      Installed with MIT License
-#
-#                      Support Server: discord.gg/jspKFcE
-
-# General Bot Configuration
-
-Token: "BOT_TOKEN_HERE"
-Prefix: "-"
-Bot_Name: "SupportBot"
-
-BotActivity: "-help | SupportBot"
-StreamingURL: "https://www.twitch.tv/YOUR_TWITCH_NAME"
-# Must set ActivityType to STREAMING in order for Streaming URL to work in the bots status.
-
-ActivityType: "PLAYING"
-# Activity status can either be PLAYING, WATCHING, LISTENING or STREAMING.
-
-DeleteMessages: "true"
-
-# Embed Configuration
-
-EmbedColour: "#04b545"
-EmbedFooter: "SupportBot | The #1 Supportive Discord Bot"
-
-ErrorColour: "#d12519"
-SuccessColour: "#04b545"
-WarningColour: "#fca117" 
-
-# Role Configuration
-
-AutoRole: "true"
-# By setting "AutoRole to 'true' the bot will automatically apply the role below when members joins. Set to 'false' to disable this feature.
-AutoRole_Role: "Member"
-LockdownRole: "@everyone"
-
-Staff: "Staff"
-Admin: "Admin"
-
-# Ticket Configuration
-
-TicketChannel: "ticket"
-TicketCategory: "Tickets"
-TicketLog: "ticket-logs"
-TranscriptLog: "transcripts"
-TicketSubject: "description"
-# TicketSubject: "description" means that the subject (reason) of the ticket will be displayed upon the channel description if set to "embed" it will be displayed within the embed.
-
-AllowTicketMentions: "true"
-# Set to "true" to allow the ticket to mention the author and the support team.
-# Set to "false" to dis-allow mentions within tickets.
-
-
-# Ticket Panel (Ticket Reaction Create)
-
-ReactionTickets: "true"
-ReactionMessage: "React with %reaction_emoji% to create a Support Ticket!"
-ReactionChannel: "create-ticket"
-ReactionEmoji: "📩"
-# Custom Emojis: <:test:EMOJI_ID>
-
-Ticket_Thumbnail: "https://images.emojiterra.com/google/android-pie/512px/1f39f.png"
-Ticket_Title: "Server Support | %ticketusername%"
-TicketMessage: "Hello <@%ticketauthor%>, Thank you for creating a support ticket\nPlease wait patiently whilst a member of our team reaches out to you."
-NoTicketSubject: "No Reason Provided!"
-TicketCreatedAlert: ":ticket: Your support ticket has been created: <#%ticketid%>"
-TranscriptTitle: "Ticket Transcript"
-
-AddedUser: "👍 <@%user%> has been added to this ticket"
-RemovedUser: "👍 <@%user%> has been removed from this ticket"
-
-ClosingTicket: ":warning: You have requested to close your support ticket."
-ClosingConfirmation_Word: "confirm"
-CloseConfirmation: "true"
-# CloseConfirmation to true will make users confirm that they want to close a their ticket, settings to false will just close the ticket.
-
-# Ticket Department Configuration
-
-TicketDepartments: "true"
-# This option enable or disable the ticket departments. If set false Ticket Departments will not work
-
-AllowStaff: "true"
-# AllowStaff is an option to whether or not you want the users with the "Staff" role to be able to view inside tickets. If set false "Staff" will not view tickets.
-
-DepartmentEmoji_1: "🙋"
-DepartmentEmoji_2: "💸"
-DepartmentEmoji_3: "📗"
-# Ticket emojis, the emojis are what users will need to react with inorder to proceed furthur if departments are enabled.
-
-DepartmentTitle_1: "Support"
-DepartmentTitle_2: "Billing"
-DepartmentTitle_3: "Other"
-# Ticket department title, This is the title for a ticket department to help users know what is available.
-
-DepartmentRole_1: "Support"
-DepartmentRole_2: "Admin"
-DepartmentRole_3: "Support"
-# Ticket roles are the roles that will be able to gain access to tickets depending on what department has been choosen. 
-
-# System Message Configuration
-
-SystemMessages: "true"
-
-SystemMessage_Channel: "system-messages"
-SystemMessage_Type: "embed"
-# There are 2 types of how you can send system messages, 'normal' or 'embed'
-SystemMessage_Icon: "USER"
-
-Welcome_Title: "User Joined!"
-WelcomeMessage: "Hello %member%, Welcome to %guildname%!"
-# %member% define the user who joined and %guildnamne% defines the server name.
-
-Leave_Title: "User Left!"
-LeaveMessage: "Goodbye %member%, Thank you for visting %guildname%!"
-# %member% define the user who left and %guildnamne% defines the server name.
-
-SystemMessage_EmbedFooter: "false"
-
-# LINKS Configuration
-
-LinksTitle: "Quick Links"
-
-LINKS:
-  "Website": "https://www.example.com"
-  "Store": "https://store.example.com"
-  "Discord": "https://discord.gg/example"
-# "Twitter": "https://twitter.com/example"
-
-# Suggestions Configuration
-
-SuggestionChannel: "suggestions"
-SuggestionTitle: "Suggestion"
-SuggestionStarter: "What would you like to suggest?"
-SuggestReact_1: 👍
-SuggestReact_2: 👎
-
-# Announcement Configuration
-
-AnnouncementChannel: "announcements"
-AnnouncementTitle: "Servername Announcement"
-AnnouncementIcon: "https://i.imgur.com/HbkZyB7.png"
-
-AnnouncementStarter: "What would you like to announce?"
-
-# General Command Configuration
-
-HelpCommand: "help"
-LinksCommand: "links"
-PingCommand: "ping"
-SuggestCommand: "suggest"
-
-# Support Command Configuration
-
-NewTicket: "ticket"
-CloseTicket: "close"
-AddUser: "add"
-RemoveUser: "remove"
-RenameTicket: "rename"
-
-# Staff Command Configuration
-
-BotSay: "say"
-
-# Admin Command Configuration
-
-AnnounceCommand: "announce"
-
-# Commmand Descriptions
-
-NewTicketDesc: "Create a new support ticket"
-AnnounceDesc: "Create a server announcement"
-CloseTicketDesc: "Close your support ticket"
-LinksDesc: "View some important links"
-PingDesc: "Get the bot's latency"
-HelpDesc: "Get a list of all the commands"
-RemoveUserDesc: "Remove a user from a support ticket"
-AddUserDesc: "Add a user to a support ticket"
-SuggestionDesc: "Create a server suggestion"
-BotSayDesc: "Say something with the bot"
-
-# Error / Warining Messages
-
-IncorrectPerms: ":x: **Err!** You do not have the correct permissions to use this command."
-InvalidChannel: ":x: **Err!** Channel not found. Please create it!"
-UserNotFound: ":x: **Err!** This user doesn't exist, Are they in this server?"
-NoValidTicket: ":warning: You cannot execute this command here. This command is used when closing a ticket."
-TicketExists: ":warning: This ticket cannot be opened, It already exists!"

utils/TicketNumber.js

@@ -1,72 +0,0 @@
-// SupportBot Utils
-// Ticket Numbers
-
-const discord = require("discord.js")
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-class TicketNumberID {
-    
-        static pad(guildId) {
-            let n = this.get(guildId) + '';
-            let z = '0';
-            let width = 4;
-            setTimeout(() => {
-                this.set(guildId, this.get(guildId) + 1);
-            }, 50);
-            return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
-    }
-    
-    static get(guildId) {
-    
-        let ticketnumberID = JSON.parse(fs.readFileSync("./storage/TicketID.json", "utf8"));
-
-        if (!ticketnumberID[guildId]) {
-            ticketnumberID[guildId] = {
-                id: 0
-            }
-
-            fs.writeFileSync("./storage/TicketID.json", JSON.stringify(ticketnumberID, null, 4), err => {
-                if (err) console.log(err);
-            });
-
-            return 0;
-    
-            
-        } else {
-            return ticketnumberID[guildId].id;
-        }
-    }
-    
-    static set(guildId, value) {
-        let ticketnumberID = JSON.parse(fs.readFileSync("./storage/TicketID.json", "utf8"));
-        
-        ticketnumberID[guildId] = {
-            id: value
-        }
-
-        fs.writeFileSync("./storage/TicketID.json", JSON.stringify(ticketnumberID, null, 4), err => {
-            if (err) console.log(err);
-        });
-
-        return value;
-    }
-    
-    static reset(guildId) {
-        let ticketnumberID = JSON.parse(fs.readFileSync("./storage/TicketID.json", "utf8"));
-        
-        ticketnumberID[guildId] = {
-            id: 0
-        }
-
-        fs.writeFileSync("./storage/TicketID.json", JSON.stringify(ticketnumberID, null, 4), err => {
-            if (err) console.log(err);
-        });
-
-        return 0;
-    }
-}
-
-module.exports = TicketNumberID;