Code refactor

src/discord/MembershipScreening.ts

@@ -1,50 +1,51 @@
-import { GuildChannel, GuildMember, Message, Permissions, TextChannel, MessageActionRow, MessageButton, Interaction, CommandInteraction, Role, ThreadChannel } from "discord.js";
+import DiscordModule, { HybridInteractionMessage } from "../utils/DiscordModule";
+
+import { GuildChannel, GuildMember, Message, Permissions, TextChannel, MessageActionRow, MessageButton, Interaction, CommandInteraction, Role, ThreadChannel, ButtonInteraction } from "discord.js";
 import App from "..";
-import { makeSuccessEmbed, makeInfoEmbed, makeErrorEmbed, sendMessageOrInteractionResponse } from "../utils/DiscordMessage";
-import Logger from "../libs/Logger";
+import { makeSuccessEmbed, makeInfoEmbed, makeErrorEmbed, sendHybridInteractionMessageResponse, sendMessage } from "../utils/DiscordMessage";
 import DiscordProvider from "../providers/Discord";
 import Prisma from "../providers/Prisma";
 
 const EMBEDS = {
     NO_PERMISSION: (data: Message | Interaction) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'You need ``ADMINISTRATOR`` permission on this guild!',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     NO_PARAMETER: (data: Message | Interaction) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'Missing parameter',
             description: `You must define membership screening channel and role to enable this feature`,
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     NO_ROLE_MENTIONED: (data: Message | Interaction) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'No role mentioned',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     NO_ROLE_FOUND: (data: Message | Interaction) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'Cannot find that role',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     NO_CHANNEL_MENTIONED: (data: Message | Interaction) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'No channel mentioned',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     NO_CHANNEL_FOUND: (data: Message | Interaction) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'Cannot find that channel',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
-    MSINFO:(data: Message | Interaction) => {
-        return makeInfoEmbed ({
+    MSINFO: (data: Message | Interaction) => {
+        return makeInfoEmbed({
             title: 'Membership Screening',
             description: `Membership Screening is a feature to prevent unwanted people to join your guild, similar to whitelist feature. Moderators can approve or deny join request`,
             fields: [
@@ -57,99 +58,105 @@ const EMBEDS = {
         });
     },
     ALREADY_ENABLED: (data: Message | Interaction) => {
-        return makeInfoEmbed ({
+        return makeInfoEmbed({
             title: 'Membership Screening is already enabled',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
+    MESSAGE_CREATED: (data: Message | Interaction) => {
+        return makeSuccessEmbed({
+            title: 'Membership Screening message created',
+            user: (data instanceof Interaction) ? data.user : data.author
+        });
+    },
     ALREADY_DISABLED: (data: Message | Interaction) => {
-        return makeInfoEmbed ({
+        return makeInfoEmbed({
             title: 'Membership Screening is already disabled',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     ENABLED: (data: Message | Interaction) => {
-        return makeSuccessEmbed ({
+        return makeSuccessEmbed({
             title: 'Enabled Membership Screening',
             description: `All new member join request will be sent in your defined channel`,
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     DISABLED: (data: Message | Interaction) => {
-        return makeSuccessEmbed ({
+        return makeSuccessEmbed({
             title: 'Disabled Membership Screening',
             description: `No longer accepting request, all new member can join directly`,
             user: (data instanceof Interaction) ? data.user : data.author
         })
     },
     MANAGED_ROLE: (data: Message | Interaction, role: Role) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'You cannot use this role',
-            description: '``' + role.name +'``' + ' is managed by external service and cannot be used',
+            description: '``' + role.name + '``' + ' is managed by external service and cannot be used',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     CONFIGURED_ROLE: (data: Message | Interaction, role: Role) => {
-        return makeSuccessEmbed ({
+        return makeSuccessEmbed({
             title: 'Configured Membership Screening Role',
-            description: 'New member will be given a ' + '``' + role.name +'``' + ' role after approval',
+            description: 'New member will be given a ' + '``' + role.name + '``' + ' role after approval',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     CONFIGURED_CHANNEL: (data: Message | Interaction, channel: GuildChannel) => {
-        return makeSuccessEmbed ({
+        return makeSuccessEmbed({
             title: 'Configured Membership Screening Channel',
-            description: 'Anyone with ``VIEW_CHANNEL`` permission in ' + '``' + channel.name +'``' + ' can approve or deny request',
+            description: 'Anyone with ``VIEW_CHANNEL`` permission in ' + '``' + channel.name + '``' + ' can approve or deny request',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     INVALID_CHANNEL: (data: Message | Interaction, channel: GuildChannel) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'Invalid channel type, only TextChannel is supported',
-            description: '``' + channel.name +'``' + ' is not a text channel',
+            description: '``' + channel.name + '``' + ' is not a text channel',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     INVALID_CHANNEL_THREAD: (data: Message | Interaction, channel: GuildChannel | ThreadChannel) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'Thread channel is not supported',
-            description: '``' + channel.name +'``' + ' is a thread channel. Please use a regular text channel',
+            description: '``' + channel.name + '``' + ' is a thread channel. Please use a regular text channel',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     BOT_NO_PERMISSION: (data: Message | Interaction, channel: GuildChannel) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: `I don't have permission`,
-            description: 'I cannot access/send message in ' + '``' + channel.name +'``',
+            description: 'I cannot access/send message in ' + '``' + channel.name + '``',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     NO_LONGER_VALID_ROLE: (data: Message | Interaction) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'The configured role is no longer valid. Please update the role in configuration',
             user: (data instanceof Interaction) ? data.user : data.author
         })
     },
     CANNOT_PERFORM_ASSIGN_ROLE: (data: Message | Interaction) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'Cannot grant the role to user, make sure I have permission to do that',
             user: (data instanceof Interaction) ? data.user : data.author
         });
     },
     CANNOT_PERFORM_ASSIGN_KICK: (data: Message | Interaction) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'Cannot kick the user, make sure I have permission to do that',
             user: (data instanceof Interaction) ? data.user : data.author
         })
     },
     CANNOT_PERFORM_ASSIGN_BAN: (data: Message | Interaction) => {
-        return makeErrorEmbed ({
+        return makeErrorEmbed({
             title: 'Cannot ban the user, make sure I have permission to do that',
             user: (data instanceof Interaction) ? data.user : data.author
         })
     },
     CREATE_MESSAGE: () => {
-        return makeInfoEmbed ({
+        return makeInfoEmbed({
             icon: '👋',
             title: 'Welcome to this server!',
             description: `This server have membership screening enabled, **you'll have access to the server when the moderators let you in**.\n\nAlso please make sure that you acknowledged the common rules that everyone should be doing no matter where, Discord ToS (https://discordapp.com/terms)`,
@@ -158,139 +165,234 @@ const EMBEDS = {
     }
 }
 
-export default class MembershipScreening {
+export default class MembershipScreening extends DiscordModule {
 
-    async onCommand(command: string, args: any, message: Message) {
-        
-        if(command.toLowerCase() !== 'membershipscreening' && command.toLowerCase() !== 'ms') return;
-        await this.process(message, args);
+    public id = "Discord_MembershipScreening";
+    public commands = ["membershipscreening", "ms"];
+    public commandInteractionName = "membershipscreening";
+
+    async GuildOnModuleCommand(args: any, message: Message) {
+        await this.run(new HybridInteractionMessage(message), args);
     }
 
-    async process(data: Interaction | Message, args: any) {
-        
-        const isSlashCommand = data instanceof CommandInteraction && data.isCommand();
-        const isMessage = data instanceof Message;
+    async GuildModuleCommandInteractionCreate(interaction: CommandInteraction) {
+        await this.run(new HybridInteractionMessage(interaction), interaction.options);
+    }
 
-        if(!isSlashCommand && !isMessage) return;
+    async GuildButtonInteractionCreate(interaction: ButtonInteraction) {
 
-        if(data.guild === null || data.guildId === null) return;
-        
-        const Guild = await Prisma.client.guild.findFirst({ where: { id: data.guildId }})
+        const hybridData = new HybridInteractionMessage(interaction);
+        const guild = hybridData.getGuild();
+        const user = hybridData.getUser();
+        const channel = hybridData.getChannel();
+
+        if(!guild || !user || !channel) return;
+
+        if (!this.isJsonValid(interaction.customId)) return;
+        const payload = JSON.parse(interaction.customId);
+
+        if (typeof payload.m === 'undefined' ||
+            typeof payload.a === 'undefined' ||
+            payload.m !== 'MembershipScreening') return;
+
+        const message = await channel.messages.fetch(interaction.message.id);
+        if (!message) return;
+
+        const embed = message.embeds;
+        if (!embed || embed.length === 0) return;
+
+        const PrismaGuild = await Prisma.client.guild.findFirst({ where: { id: guild.id } });
+        if (!PrismaGuild) return;
+
+        if (!PrismaGuild.MembershipScreening_Enabled ||
+            PrismaGuild.MembershipScreening_ApprovalChannel === null ||
+            PrismaGuild.MembershipScreening_GivenRole === null) return;
+
+        embed[0].footer = {
+            text: `${interaction.user.username}  |  v${App.version}`,
+            iconURL: interaction.user.avatarURL() || ''
+        }
+
+        if (['approve', 'deny', 'ban'].includes(payload.a)) {
+
+            if (!payload.d.requester) return;
+
+            const role = (await guild.roles.fetch()).find(role => role.id === PrismaGuild.MembershipScreening_GivenRole);
+            const requesterMember = (await guild.members.fetch()).find(member => member.id === payload.d.requester);
+
+            if (!role)
+                return await interaction.reply({ ephemeral: true, embeds: [EMBEDS.NO_LONGER_VALID_ROLE(interaction)] });
+
+            if (!requesterMember) {
+                embed[0].addField("❌ Invalid", `Unable to find the user. User left already?`);
+                return await message.edit({ components: [], embeds: embed });
+            }
+
+            if (requesterMember.roles.cache.has(PrismaGuild.MembershipScreening_GivenRole)) {
+                embed[0].addField("✅ Approved", `By: Unknown (User already obtained the role by other means)`);
+                return await message.edit({ components: [], embeds: embed });
+            }
+
+            if (payload.a === 'approve') {
+                try {
+                    await requesterMember.roles.add(role);
+                    embed[0].addField("✅ Approved", `By: ${interaction.user.username}#${interaction.user.discriminator} (${interaction.user.id})`);
+                    await message.edit({ components: [], embeds: embed });
+                }
+                catch (err) {
+                    return interaction.reply({ ephemeral: true, embeds: [EMBEDS.CANNOT_PERFORM_ASSIGN_ROLE(message)] });
+                }
+            }
+
+            else if (payload.a === 'deny') {
+                try {
+                    await requesterMember.kick();
+                    embed[0].addField("❌ Denied", `By: ${interaction.user.username}#${interaction.user.discriminator} (${interaction.user.id})`);
+                    await message.edit({ components: [], embeds: embed });
+                }
+                catch (err) {
+                    return interaction.reply({ ephemeral: true, embeds: [EMBEDS.CANNOT_PERFORM_ASSIGN_KICK(message)] });
+                }
+            }
+
+            else if (payload.a === 'ban') {
+                try {
+                    await requesterMember.ban({
+                        reason: `Membership Screening, action issued by ${interaction.user.username}#${interaction.user.discriminator} (${interaction.user.id})`
+                    });
+                    embed[0].addField("🔪 Banned", `By: ${interaction.user.username}#${interaction.user.discriminator} (${interaction.user.id})`);
+                    await message.edit({ components: [], embeds: embed });
+                }
+                catch (err) {
+                    return interaction.reply({ ephemeral: true, embeds: [EMBEDS.CANNOT_PERFORM_ASSIGN_BAN(message)] });
+                }
+            }
+
+        }
+    }
+
+    async run(data: HybridInteractionMessage, args: any) {
+
+        const guild = data.getGuild();
+        const user = data.getUser();
+        const member = data.getMember();
+        const channel = data.getChannel();
+
+        if (!guild || !user || !member || !channel) return;
+
+        const PrismaGuild = await Prisma.client.guild.findFirst({ where: { id: guild.id } })
+        if (!PrismaGuild) return;
 
-        // TODO: Handle if guild is not found
-        if(!Guild) throw new Error('Guild not found');
-        
 
         const funct = {
-            enable: async(data: Message | Interaction)=> {
-                if(!Guild.MembershipScreening_Enabled) {
+            enable: async (data: HybridInteractionMessage) => {
+                if (!PrismaGuild.MembershipScreening_Enabled) {
 
-                    if(Guild.MembershipScreening_GivenRole === null || Guild.MembershipScreening_ApprovalChannel == null)
-                        return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.NO_PARAMETER(data)] });
-    
-                    await Prisma.client.guild.update({ where: { id: data.guildId! }, data: { MembershipScreening_Enabled: true }});
-    
-                    return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.ENABLED(data)] });
+                    if (PrismaGuild.MembershipScreening_GivenRole === null || PrismaGuild.MembershipScreening_ApprovalChannel == null)
+                        return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.NO_PARAMETER(data.getRaw())] });
+
+                    await Prisma.client.guild.update({ where: { id: guild.id }, data: { MembershipScreening_Enabled: true } });
+
+                    return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.ENABLED(data.getRaw())] });
                 }
-    
+
                 else
-                    return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.ALREADY_ENABLED(data)] });
+                    return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.ALREADY_ENABLED(data.getRaw())] });
             },
-            disable: async(data: Message | Interaction) => {
-                if(Guild.MembershipScreening_Enabled) {
-                    await Prisma.client.guild.update({ 
-                        where: {id: data.guildId! },
-                        data: {MembershipScreening_Enabled: false}
+            disable: async (data: HybridInteractionMessage) => {
+                if (PrismaGuild.MembershipScreening_Enabled) {
+                    await Prisma.client.guild.update({
+                        where: { id: guild.id },
+                        data: { MembershipScreening_Enabled: false }
                     });
-    
-                    return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.DISABLED(data)] });
+
+                    return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.DISABLED(data.getRaw())] });
                 }
                 else
-                    return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.ALREADY_DISABLED(data)] });
+                    return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.ALREADY_DISABLED(data.getRaw())] });
             },
-            setRole: async(data: Message | Interaction) => {
-                
+            setRole: async (data: HybridInteractionMessage) => {
+
                 let role: Role | undefined;
 
-                if(data instanceof Message) {
+                if (data.isMessage()) {
                     let _name: string;
-                    if(typeof args[1] === 'undefined')
-                        return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.NO_ROLE_MENTIONED(data)] });
+                    if (typeof args[1] === 'undefined')
+                        return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.NO_ROLE_MENTIONED(data.getRaw())] });
 
                     let __name = args;
                     __name.shift();
                     _name = __name.join(" ");
-                    role = data.mentions.roles.first() || data.guild!.roles.cache.find(role => role.name === _name);
+
+                    role = data.getMessage().mentions.roles.first() || guild.roles.cache.find(role => role.name === _name);
                 }
-                else if(data instanceof CommandInteraction)
-                    role = data.guild!.roles.cache.find(role => role.id === data.options.getRole('role')?.id);
+                else if (data.isSlashCommand())
+                    role = guild.roles.cache.find(role => role.id === data.getSlashCommand().options.getRole('role')?.id);
 
-                
-                if(typeof role === 'undefined' || !role)
-                    return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.NO_ROLE_FOUND(data)] });
+                if (!role)
+                    return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.NO_ROLE_FOUND(data.getRaw())] });
 
-                await Prisma.client.guild.update({ where: {id: data.guildId! }, data: {MembershipScreening_GivenRole: role.id}});
+                if (role.managed)
+                    return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.MANAGED_ROLE(data.getRaw(), role)] });
 
-                if(role.managed)
-                    return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.MANAGED_ROLE(data, role)] });
+                await Prisma.client.guild.update({ where: { id: guild.id }, data: { MembershipScreening_GivenRole: role.id } });
 
-                return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.CONFIGURED_ROLE(data, role)] });
+                return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.CONFIGURED_ROLE(data.getRaw(), role)] });
             },
-            setChannel: async(data: Message | CommandInteraction) => {
-            
-                let channel;
-                if(data instanceof Message) {
-                    if(typeof args[1] === 'undefined')
-                        return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.NO_CHANNEL_MENTIONED(data)] });
-                    channel = data.mentions.channels.first();
+            setChannel: async (data: HybridInteractionMessage) => {
+
+                let mentionChannel;
+                if (data.isMessage()) {
+                    if (!args[1])
+                        return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.NO_CHANNEL_MENTIONED(data.getRaw())] });
+                    mentionChannel = data.getMessage().mentions.channels.first();
                 }
-                else if(data instanceof CommandInteraction)
-                    channel = data.options.getChannel('channel');
+                else if (data.isSlashCommand())
+                    mentionChannel = data.getSlashCommand().options.getChannel('channel');
 
-                if(!channel)
-                    return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.NO_CHANNEL_FOUND(data)] });
-                
-                let TargetChannel = data.guild!.channels.cache.get(channel.id);
-                if(typeof TargetChannel === 'undefined') return;
+                if (!mentionChannel)
+                    return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.NO_CHANNEL_FOUND(data.getRaw())] });
 
-                if(TargetChannel instanceof ThreadChannel || TargetChannel.isThread())
-                    return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.INVALID_CHANNEL_THREAD(data, TargetChannel)] });
+                let TargetChannel = guild.channels.cache.get(mentionChannel.id);
+                if (!TargetChannel) return;
 
-                if(!TargetChannel.isText())
-                    return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.INVALID_CHANNEL(data, TargetChannel)] });
+                if (TargetChannel instanceof ThreadChannel || TargetChannel.isThread())
+                    return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.INVALID_CHANNEL_THREAD(data.getRaw(), TargetChannel)] });
 
-                if(!(data!.guild!.me?.permissionsIn(TargetChannel).has([Permissions.FLAGS.SEND_MESSAGES, Permissions.FLAGS.VIEW_CHANNEL])))
-                    return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.BOT_NO_PERMISSION(data, TargetChannel)] });
+                if (!TargetChannel.isText())
+                    return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.INVALID_CHANNEL(data.getRaw(), TargetChannel)] });
 
-                await Prisma.client.guild.update({ where: {id: data.guildId! }, data: { MembershipScreening_ApprovalChannel: channel.id }});
-                return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.CONFIGURED_CHANNEL(data, TargetChannel)] }); 
+                if (!(guild.me!.permissionsIn(TargetChannel).has([Permissions.FLAGS.SEND_MESSAGES, Permissions.FLAGS.VIEW_CHANNEL])))
+                    return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.BOT_NO_PERMISSION(data.getRaw(), TargetChannel)] });
+
+                await Prisma.client.guild.update({ where: { id: guild.id }, data: { MembershipScreening_ApprovalChannel: mentionChannel.id } });
+                return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.CONFIGURED_CHANNEL(data.getRaw(), TargetChannel)] });
             },
-            createMessage: async(data: Message | CommandInteraction) => {
-                return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.CREATE_MESSAGE()] });
+            createMessage: async (data: HybridInteractionMessage) => {
+                if(data.isMessage())
+                    return await sendMessage(channel, undefined, { embeds: [EMBEDS.CREATE_MESSAGE()] });
+                else if(data.isSlashCommand()) {
+                    await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.MESSAGE_CREATED(data.getRaw())] });
+                    return await sendMessage(channel, undefined, { embeds: [EMBEDS.CREATE_MESSAGE()] });
+                }
             }
         }
 
         let query;
 
-        if(isMessage) {
-            if(data === null || !data.guildId || data.member === null || data.guild === null) return;
-            if (!data.member.permissions.has([Permissions.FLAGS.ADMINISTRATOR]))
-                return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.NO_PERMISSION(data)] });
+        if (!member.permissions.has([Permissions.FLAGS.ADMINISTRATOR]))
+                return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.NO_PERMISSION(data.getRaw())] });
 
-            if(args.length === 0) {
-                return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.MSINFO(data)] });
-            }
+        if (data.isMessage()) {
+            if (args.length === 0)
+                return await sendHybridInteractionMessageResponse(data, { embeds: [EMBEDS.MSINFO(data.getRaw())] });
+            
             query = args[0].toLowerCase();
-
         }
-        else if(isSlashCommand) {
-            if(!data.guild.members.cache.get(data.user.id)?.permissions.has([Permissions.FLAGS.ADMINISTRATOR]))
-                return await sendMessageOrInteractionResponse(data, { embeds: [EMBEDS.NO_PERMISSION(data)] });
-
+        else if (data.isSlashCommand())
             query = args.getSubcommand();
-        }
 
-        switch(query) {
+        switch (query) {
             case "enable":
             case "on":
                 return await funct.enable(data);
@@ -300,121 +402,23 @@ export default class MembershipScreening {
             case "setrole":
                 return await funct.setRole(data);
             case "setchannel":
-                return await funct.setChannel(data as CommandInteraction);
+                return await funct.setChannel(data);
             case "createmessage":
-                return await funct.createMessage(data as CommandInteraction);
+                return await funct.createMessage(data);
         }
 
     }
 
-    async interactionCreate(interaction: Interaction) {
+    async GuildMemberAdd(member: GuildMember) {
 
-        if (interaction.isButton()) {
-
-            if(!interaction.guild || !interaction.guildId) return;
-            if(!(interaction.channel instanceof TextChannel)) return;
-            if(!this.tryParseJSONObject(interaction.customId)) return;
-
-            Logger.log('debug', `${interaction.user.username}#${interaction.user.discriminator} (UserID: ${interaction.user.id}) (InteractionID: ${interaction.id}) executed button interaction ${interaction.customId}`);
-
-            let payload = JSON.parse(interaction.customId);
-
-            if( typeof payload.m === 'undefined' ||
-                typeof payload.a === 'undefined' ||
-                payload.m !== 'MembershipScreening') return;
-
-            const message = await interaction.channel.messages.fetch(interaction.message.id);
-            if(typeof message === 'undefined') return;
-
-            const embed = message.embeds;
-            if(typeof embed === 'undefined' || embed.length === 0) return;
-
-            const Guild = await Prisma.client.guild.findFirst({ where: { id: interaction.guildId } });
-            if(!Guild) throw new Error('TODO: Handle if guild is not found');
-    
-            if(!Guild.MembershipScreening_Enabled ||
-                Guild.MembershipScreening_ApprovalChannel === null ||
-                Guild.MembershipScreening_GivenRole === null) return;
-
-            embed[0].footer = {
-                text: `${interaction.user.username}  |  v${App.version}`,
-                iconURL: interaction.user.avatarURL() || ''
-            }
-
-            if(['approve', 'deny', 'ban'].includes(payload.a)) {
-                
-                if(!payload.d.requester) return;
-                let role = (await interaction.guild.roles.fetch()).find(role => role.id === Guild.MembershipScreening_GivenRole);
-                let member = (await interaction.guild.members.fetch()).find(member => member.id === payload.d.requester);
-
-                if(!role)
-                    return await interaction.reply({ ephemeral: true, embeds: [EMBEDS.NO_LONGER_VALID_ROLE(interaction)]});
-
-                if(!member) {
-                    embed[0].addField("❌ Invalid", `Unable to find the user. User left already?`);
-                    return await message.edit({ components: [], embeds: embed });
-                }
-
-                if(member.roles.cache.has(Guild.MembershipScreening_GivenRole)) {
-                    embed[0].addField("✅ Approved", `By: Unknown (User already obtained the role by other means)`);
-                    return await message.edit({ components: [], embeds: embed });
-                }
-
-                if(payload.a === 'approve') {
-                    try {
-                        await member.roles.add(role);
-                        embed[0].addField("✅ Approved", `By: ${interaction.user.username}#${interaction.user.discriminator} (${interaction.user.id})`);
-                        await message.edit({ components: [], embeds: embed });
-                    }
-                    catch(err) {
-                        return interaction.reply({ ephemeral: true, embeds: [EMBEDS.CANNOT_PERFORM_ASSIGN_ROLE(message)]});
-                    }
-                }
-
-                else if(payload.a === 'deny') { 
-                    try { 
-                        await member.kick(); 
-                        embed[0].addField("❌ Denied", `By: ${interaction.user.username}#${interaction.user.discriminator} (${interaction.user.id})`);
-                        await message.edit({ components: [], embeds: embed });
-                    } 
-                    catch(err) {
-                        return interaction.reply({ ephemeral: true, embeds: [EMBEDS.CANNOT_PERFORM_ASSIGN_KICK(message)]});
-                    }
-                }
-
-                else if(payload.a === 'ban') {
-                    try {
-                        await member.ban({
-                            reason: `Membership Screening, action issued by ${interaction.user.username}#${interaction.user.discriminator} (${interaction.user.id})`
-                        });
-                        embed[0].addField("🔪 Banned", `By: ${interaction.user.username}#${interaction.user.discriminator} (${interaction.user.id})`);
-                        await message.edit({ components: [], embeds: embed });
-                    }
-                    catch(err) {
-                        return interaction.reply({ ephemeral: true, embeds: [EMBEDS.CANNOT_PERFORM_ASSIGN_BAN(message)]});
-                    }
-                }
-
-            }
-        }
-
-        else if(interaction.isCommand()) {
-            if(typeof interaction.commandName === 'undefined') return;
-            if((interaction.commandName).toLowerCase() !== 'membershipscreening') return;
-            await this.process(interaction, interaction.options);
-        }
-    }
-
-    async guildMemberAdd(member: GuildMember) {
-
-        if(member.user.bot) return;
+        if (member.user.bot) return;
 
         const Guild = await Prisma.client.guild.findFirst({ where: { id: member.guild.id } });
-        if(!Guild) return;
+        if (!Guild) return;
 
-        if(!Guild.MembershipScreening_Enabled) return;
-        if(Guild.MembershipScreening_ApprovalChannel === null) return;
-        if(Guild.MembershipScreening_GivenRole === null) return;
+        if (!Guild.MembershipScreening_Enabled) return;
+        if (Guild.MembershipScreening_ApprovalChannel === null) return;
+        if (Guild.MembershipScreening_GivenRole === null) return;
 
         let channel = undefined;
         try {
@@ -423,9 +427,9 @@ export default class MembershipScreening {
             // TODO: Handle channel not found error
             return;
         }
-        if(!channel) return;
+        if (!channel) return;
 
-        const embed = makeInfoEmbed ({
+        const embed = makeInfoEmbed({
             title: 'New member joined!',
             description: `${member.user.username}#${member.user.discriminator} (${member.user.id})`,
             fields: [
@@ -437,7 +441,7 @@ export default class MembershipScreening {
         });
 
         embed.setThumbnail(member.user.avatarURL() || '');
-    
+
         const row = new MessageActionRow()
             .addComponents(
                 new MessageButton()
@@ -482,7 +486,7 @@ export default class MembershipScreening {
         await channel.send({ content: '\u200b', embeds: [embed], components: [row] });
     }
 
-    tryParseJSONObject(jsonString: string) {
+    private isJsonValid(jsonString: string) {
         try {
             let o = JSON.parse(jsonString);
             if (o && typeof o === "object") {
@@ -491,7 +495,7 @@ export default class MembershipScreening {
             }
         }
         catch (e) { }
-    
+
         return false;
     }
 }