Clean up code, and listeners

Author: Allybe

readme.md

@@ -12,46 +12,46 @@ It's about the same for listeners, just add the Javascript file into a ``listene
 ## Commands to add
 
 ### Moderation
--[x] Mutes
+- [x] Mutes
 
--[x] Temp Mutes
+- [x] Temp Mutes
 
--[x] Unmute
+- [x] Unmute
 
--[x] Ban (Done)
+- [x] Ban (Done)
 
--[x] Unban
+- [x] Unban
 
--[ ] Warns
+- [ ] Warns
 
--[ ] Lock channel
+- [ ] Lock channel
 
--[ ] Unlock channel
+- [ ] Unlock channel
 
--[ ] Help command
+- [ ] Help command
 
  ### Admin 
 
--[x] Welcome messages
+- [x] Welcome messages
 
--[ ] Ticket System
+- [ ] Ticket System
 
--[ ] Verification System
+- [ ] Verification System
 
--[ ] Polls
+- [ ] Polls
 
--[ ] Giveaways
+- [ ] Giveaways
 
 ### Music
 
--[ ] Play song
+- [ ] Play song
 
--[ ] View Queue
+- [ ] View Queue
 
--[ ] Skip current song
+- [ ] Skip current song
 
--[ ] Shuffle
+- [ ] Shuffle
 
--[ ] Clear Queue
+- [ ] Clear Queue
 
--[ ] Remove
+- [ ] Remove song

src/baseBot.ts

@@ -2,14 +2,15 @@ import { AllyClient } from "./interfaces/AllyClient.js";
 import { config } from "./config.js"; // Not ready to do this yet
 
 import {
-  GatewayIntentBits,
-  Partials,
-  Collection,
-  Interaction,
-  CacheType,
+    GatewayIntentBits,
+    Partials,
+    Collection,
+    Interaction
 } from "discord.js";
 import * as fs from "fs";
 import { Sequelize } from "sequelize";
+import {Listeners} from "./interfaces/Listeners";
+import path from "path";
 
 const client = new AllyClient({
   intents: config.intents as GatewayIntentBits[],
@@ -19,70 +20,80 @@ const client = new AllyClient({
 client.commands = new Collection();
 client.DB = new Sequelize("sqlite::memory");
 
-fs.readdir(
-  "./dist/commands",
-  async (err: NodeJS.ErrnoException | null, items: string[]) => {
-    if (err) throw err;
-    var baseFiles = items.filter((files) => files.split(".").pop() === "js");
-    var folders = items.filter((files) => files.split(".").pop() != "js");
+const commandsDirectory = path.join(__dirname, "commands");
 
-    // Load all commands from the base commands folder
-     baseFiles.forEach((fileName) => {
-      import(`./commands/${fileName}`).then((properties) => {
-        let commandName = properties.SlashCommand.name.toLowerCase();
+fs.readdir(commandsDirectory, async (err: NodeJS.ErrnoException | null, items: string[]) => {
+    if (err) throw err;
+    const baseFiles = filterNonJsFiles(items);
+    const folders = items.filter((files) => files.split(".").pop() != "js");
 
-        client.commands.set(commandName, properties.SlashCommand);
+    loadCommands(baseFiles, commandsDirectory);
 
-        console.log(`${fileName} command loaded`);
-      });
-    });
-
-    // Load all commands from the subfolders
-     folders.forEach((folderName) => {
-      fs.readdir(
-        `./dist/commands/${folderName}`,
-        async (err: NodeJS.ErrnoException | null, subfolderItems: string[]) => {
+    folders.forEach((folderName) => {
+      fs.readdir(path.join(commandsDirectory, folderName), async (err: NodeJS.ErrnoException | null, subFolderItems: string[]) => {
           if (err) throw err;
-          var Files = subfolderItems.filter(
-            (files) => files.split(".").pop() === "js"
-          );
-
-          Files.forEach((fileName) => {
-            import(`./commands/${folderName}/${fileName}`).then(
-              (properties) => {
-                let commandName: String =
-                  properties.SlashCommand.name.toLowerCase();
-
-                client.commands.set(commandName, properties.SlashCommand);
-
-                console.log(`${fileName} command loaded`);
-              }
-            );
-          });
+          const Files = filterNonJsFiles(subFolderItems);
+
+          loadCommands(Files, path.join(commandsDirectory, folderName));
         }
       );
     });
   }
 );
 
+const listenersDirectory = path.join(__dirname, "listeners");
+
+fs.readdir(listenersDirectory, async (err: NodeJS.ErrnoException | null, items: string[]) => {
+    if (err) throw err;
+    const listeners = items.filter((files) => files.split(".").pop() === "js");
+
+    listeners.forEach((fileName: string) => {
+        import(path.join(listenersDirectory, fileName)).then((properties) => {
+            let listener:Listeners<any> = properties.Listener;
+
+            client.on(listener.event, (args) => {
+                listener.run(client, args);
+            });
+            console.log(`${listener.purpose} listener was loaded`);
+        });
+    });
+});
+
 client.on("ready", () => {
   console.log(`Logged in as ${client.user?.tag}!`);
 });
 
-client.on("interactionCreate", (interaction: Interaction<CacheType>) => {
+client.on("interactionCreate", (interaction: Interaction) => {
   if (!interaction.isCommand()) return;
 
   let commandFile = client.commands.get(interaction.commandName);
 
   if (commandFile) commandFile.run(client, interaction);
 });
 
-client.on("interactionCreate", (interaction: Interaction<CacheType>) => {
+client.on("interactionCreate", (interaction: Interaction) => {
   if (!interaction.isButton()) return;
 
   let buttonFollowUp = client.commands.get(interaction.customId.split(".")[0]);
 
   if (buttonFollowUp) buttonFollowUp.followup(client, interaction);
 });
 
+
 client.login(config.token);
+
+const loadCommands = (files: string[], location: string) => {
+    files.forEach((fileName) => {
+        import(path.join(location, fileName)).then((properties) => {
+            let commandName = properties.SlashCommand.name.toLowerCase();
+
+            client.commands.set(commandName, properties.SlashCommand);
+
+            console.log(`${fileName} command loaded`);
+        });
+    });
+};
+
+const filterNonJsFiles = (items: string[]) => {
+    return items.filter((files) => files.split(".").pop() === "js");
+};

src/interfaces/Listeners.ts

@@ -1,7 +1,8 @@
 import {AllyClient} from "./AllyClient";
+import {Awaitable, ClientEvents} from "discord.js";
 
-export interface Listeners {
-    event: String;
+export interface Listeners<Event extends keyof ClientEvents> {
+    event: Event;
     purpose: String;
-    run: (client: AllyClient, listener: any) => void;
+    run: (client: AllyClient, ...args: ClientEvents[Event]) => Awaitable<void>;
 }

src/modules/admin/listeners/WelcomeMessage.ts

@@ -1,10 +1,19 @@
 import {Listeners} from "../../../interfaces/Listeners";
 import {AllyClient} from "../../../interfaces/AllyClient";
+import {Events, GuildMember, TextBasedChannel} from "discord.js";
 
-export const Listener: Listeners = {
-    event: "guildMemberAdd",
+export const Listener: Listeners<Events.GuildMemberAdd> = {
+    event: Events.GuildMemberAdd,
     purpose: "Welcome message",
-    run(client: AllyClient, listener: any): void {
+    run(client: AllyClient, listener: GuildMember): void {
+        const welcomeChannelId = listener.guild.systemChannelId; //Add ability to change channel to send to
+        listener.guild.channels.fetch(welcomeChannelId).then((channel) => {
+            if (channel.isTextBased) {
+                let welcomeChannel = channel as TextBasedChannel;
+                let messageContent = `Hello ${listener.displayName}!`;
 
+                welcomeChannel.send(messageContent);
+            }
+        });
     }
 };

src/modules/moderation/commands/ban.ts

@@ -44,6 +44,7 @@ export const SlashCommand: Command = {
           option
               .setName('reason')
               .setDescription('Ban reason')
+              .setRequired(true)
       )
     .setDefaultMemberPermissions(
       PermissionFlagsBits.BanMembers

src/modules/moderation/commands/mute.ts

@@ -16,9 +16,9 @@ export const SlashCommand: Command = {
   run: (client: AllyClient, interaction: CommandInteraction) => {
     const embed = new EmbedBuilder();
 
-    var mentionedUser = interaction.options.getUser("user");
-    var time = interaction.options.get("time", true).value as number;
-    var guild = interaction.guild;
+    const mentionedUser = interaction.options.getUser("user");
+    const time = interaction.options.get("time", true).value as number;
+    const guild = interaction.guild;
 
     if (time >= MAX_TIME) {
       embed