Add ability for server exclusive commands

src/client/client.ts

@@ -57,10 +57,11 @@ export class CoreClient extends Client {
         this._util.loadEvents(this, this._eventItems);
     }
 
-    public RegisterCommand(name: string, command: Command) {
+    public RegisterCommand(name: string, command: Command, serverId?: string) {
         const item: ICommandItem = {
             Name: name,
             Command: command,
+            ServerId: serverId,
         };
 
         this._commandItems.push(item);

src/client/events.ts

@@ -1,18 +1,8 @@
 import { Message } from "discord.js";
-import { IBaseResponse } from "../contracts/IBaseResponse";
 import ICommandItem from "../contracts/ICommandItem";
 import SettingsHelper from "../helpers/SettingsHelper";
 import { Util } from "./util";
 
-export interface IEventResponse extends IBaseResponse {
-    context?: {
-        prefix: string;
-        name: string;
-        args: string[];
-        message: Message;
-    }
-}
-
 export class Events {
     private _util: Util;
 
@@ -22,58 +12,21 @@ export class Events {
 
     // Emit when a message is sent
     // Used to check for commands
-    public async onMessage(message: Message, commands: ICommandItem[]): Promise<IEventResponse> {
+    public async onMessage(message: Message, commands: ICommandItem[]) {
-        if (!message.guild) return {
+        if (!message.guild) return;
-            valid: false,
+        if (message.author.bot) return;
-            message: "Message was not sent in a guild, ignoring.",
-        };
-
-        if (message.author.bot) return {
-            valid: false,
-            message: "Message was sent by a bot, ignoring.",
-        };
 
         const prefix = await SettingsHelper.GetSetting("bot.prefix", message.guild.id);
 
-        if (!prefix) {
+        if (!prefix) return;
-            return {
-                valid: false,
-                message: "Prefix not found",
-            };
-        }
 
         if (message.content.substring(0, prefix.length).toLowerCase() == prefix.toLowerCase()) {
             const args = message.content.substring(prefix.length).split(" ");
             const name = args.shift();
 
-            if (!name) return {
+            if (!name) return;
-                valid: false,
-                message: "Command name was not found",
-            };
 
-            const res = await this._util.loadCommand(name, args, message, commands);
+            await this._util.loadCommand(name, args, message, commands);
-
-            if (!res.valid) {
-                return {
-                    valid: false,
-                    message: res.message,
-                };
-            }
-
-            return {
-                valid: true,
-                context: {
-                    prefix: prefix,
-                    name: name,
-                    args: args,
-                    message: message,
-                },
-            };
-        }
-
-        return {
-            valid: false,
-            message: "Message was not a command, ignoring.",
         }
     }
 

src/client/util.ts

@@ -1,9 +1,5 @@
 // Required Components
 import { Client, Message } from "discord.js";
-import { readdirSync, existsSync } from "fs";
-import { IBaseResponse } from "../contracts/IBaseResponse";
-import { Command } from "../type/command";
-import { Event } from "../type/event";
 import { ICommandContext } from "../contracts/ICommandContext";
 import ICommandItem from "../contracts/ICommandItem";
 import IEventItem from "../contracts/IEventItem";
@@ -12,53 +8,37 @@ import StringTools from "../helpers/StringTools";
 import { CommandResponse } from "../constants/CommandResponse";
 import ErrorMessages from "../constants/ErrorMessages";
 
-export interface IUtilResponse extends IBaseResponse {
-    context?: {
-        name: string;
-        args: string[];
-        message: Message;
-    }
-}
-
 // Util Class
 export class Util {
-    public async loadCommand(name: string, args: string[], message: Message, commands: ICommandItem[]): Promise<IUtilResponse> {
+    public async loadCommand(name: string, args: string[], message: Message, commands: ICommandItem[]) {
-        if (!message.member) return {
+        if (!message.member) return;
-            valid: false,
+        if (!message.guild) return;
-            message: "Member is not part of message",
-        };
-
-        if (!message.guild) return {
-            valid: false,
-            message: "Message is not part of a guild",
-        };
 
         const disabledCommandsString = await SettingsHelper.GetSetting("commands.disabled", message.guild?.id);
         const disabledCommands = disabledCommandsString?.split(",");
 
         if (disabledCommands?.find(x => x == name)) {
             message.reply(process.env.COMMANDS_DISABLED_MESSAGE || "This command is disabled.");
-
+            return;
-            return {
-                valid: false,
-                message: "Command is disabled",
-            };
         }
 
-        const folder = process.env.FOLDERS_COMMANDS;
+        const item = commands.find(x => x.Name == name && !x.ServerId);
+        const itemForServer = commands.find(x => x.Name == name && x.ServerId == message.guild?.id);
 
-        const item = commands.find(x => x.Name == name);
+        let itemToUse: ICommandItem;
 
-        if (!item) {
+        if (!itemForServer) {
-            message.reply('Command not found');
+            if (!item) {
+                message.reply('Command not found');
+                return;
+            }
 
-            return {
+            itemToUse = item;
-                valid: false,
+        } else {
-                message: "Command not found"
+            itemToUse = itemForServer;
-            };
         }
 
-        const requiredRoles = item.Command._roles;
+        const requiredRoles = itemToUse.Command._roles;
 
         for (const i in requiredRoles) {
             if (message.guild) {
@@ -66,20 +46,12 @@ export class Util {
 
                 if (!setting) {
                     message.reply("Unable to verify if you have this role, please contact your bot administrator");
-
+                    return;
-                    return {
-                        valid: false,
-                        message: "Unable to verify if you have this role, please contact your bot administrator"
-                    };
                 }
 
                 if (!message.member.roles.cache.find(role => role.name == setting)) {
                     message.reply(`You require the \`${StringTools.Capitalise(setting)}\` role to run this command`);
-
+                    return;
-                    return {
-                        valid: false,
-                        message: `You require the \`${StringTools.Capitalise(setting)}\` role to run this command`
-                    };
                 }
             }
         }
@@ -90,39 +62,24 @@ export class Util {
             message: message
         };
 
-        const precheckResponse = item.Command.precheck(context);
+        const precheckResponse = itemToUse.Command.precheck(context);
-        const precheckAsyncResponse = await item.Command.precheckAsync(context);
+        const precheckAsyncResponse = await itemToUse.Command.precheckAsync(context);
 
         if (precheckResponse != CommandResponse.Ok) {
             message.reply(ErrorMessages.GetErrorMessage(precheckResponse));
-
+            return;
-            return {
-                valid: false,
-                message: ErrorMessages.GetErrorMessage(precheckResponse)
-            };
         }
 
         if (precheckAsyncResponse != CommandResponse.Ok) {
             message.reply(ErrorMessages.GetErrorMessage(precheckAsyncResponse));
-
+            return;
-            return {
-                valid: false,
-                message: ErrorMessages.GetErrorMessage(precheckAsyncResponse)
-            };
         }
 
-        item.Command.execute(context);
+        itemToUse.Command.execute(context);
-
-        return {
-            valid: true,
-            context: context
-        }
     }
 
     // Load the events
-    loadEvents(client: Client, events: IEventItem[]): IUtilResponse {
+    loadEvents(client: Client, events: IEventItem[]) {
-        const folder = process.env.FOLDERS_EVENTS;
-
         events.forEach((e) => {
             client.on('channelCreate', e.Event.channelCreate);
             client.on('channelDelete', e.Event.channelDelete);
@@ -138,9 +95,5 @@ export class Util {
             client.on('messageUpdate', e.Event.messageUpdate);
             client.on('ready', e.Event.ready);
         });
-
-        return {
-            valid: true
-        }
     }
 }

src/contracts/ICommandItem.ts

@@ -3,4 +3,5 @@ import { Command } from "../type/command";
 export default interface ICommandItem {
     Name: string,
     Command: Command,
+    ServerId?: string,
 }

src/registry.ts

@@ -35,7 +35,7 @@ export default class Registry {
         client.RegisterCommand("setup", new Setup());
         client.RegisterCommand("config", new Config());
         client.RegisterCommand("code", new Code());
-        client.RegisterCommand("disable", new Disable())
+        client.RegisterCommand("disable", new Disable());
     }
 
     public static RegisterEvents(client: CoreClient) {