utils/structures/BaseCommand.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* SudoBot is free software; you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by 
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* 
* SudoBot is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License 
* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
*/

import { ModalSubmitInteraction } from 'discord-modals';
import { PermissionResolvable, AutocompleteInteraction, CommandInteraction, ContextMenuInteraction, Interaction, Message, MessageEditOptions, MessageOptions, MessagePayload, WebhookEditMessageOptions, GuildMember } from 'discord.js';
import DiscordClient from '../../client/Client';
import AutoCompleteOptions from '../../types/AutoCompleteOptions';
import CommandOptions from '../../types/CommandOptions';
import InteractionOptions from '../../types/InteractionOptions';

export default abstract class BaseCommand {
    supportsInteractions: boolean = false;
    supportsLegacy: boolean = true;
    supportsContextMenu: boolean = false;
    coolDown?: number;
    ownerOnly: boolean = false;
    permissions: PermissionResolvable[] = [];
    
    protected name: string = "";
    protected category: string = "";
    protected aliases: Array<string> = [];
    
    constructor(name?: string, category?: string, aliases?: Array<string>) {
        if (name)
            this.name = name;

        if (category)
            this.category = category;

        if (aliases)
            this.aliases = aliases;
    }
    
    getName(): string { 
        return this.name; 
    }
    
    getCategory(): string { 
        return this.category; 
    }
    
    getAliases(): Array<string> { 
        return this.aliases; 
    }
    
    async permissionValidation(client: DiscordClient, member: GuildMember): Promise <boolean> {
        return true;
    }

    async autoComplete(client: DiscordClient, interaction: AutocompleteInteraction, options: AutoCompleteOptions): Promise <void> {

    }

    async default(client: DiscordClient, interaction: Interaction): Promise <void> {
        
    }

    async modalSubmit(client: DiscordClient, interaction: ModalSubmitInteraction): Promise <void> {
        
    }

    async deferReply(msg: Message | CommandInteraction | ContextMenuInteraction, options: MessageOptions | string | MessagePayload | WebhookEditMessageOptions, edit: boolean = false): Promise<Message> {
        if (msg instanceof Message) {
            return await msg[edit ? 'edit' : 'reply'](options as (MessageOptions & MessageEditOptions));
        }
        
        return (await msg.editReply(options as string | MessagePayload | WebhookEditMessageOptions)) as Message;
    }

    async perms(client: DiscordClient, message: Message | Interaction) {
        if (client.config.props.global.owners.includes(message.member!.user.id)) {
            return true;
        }

        let member: GuildMember | null = null;

        if (message.member && !(message.member instanceof GuildMember)) {
            try {
                member = (await message.guild?.members.fetch(message.member!.user.id)) ?? null;
            }
            catch (e) {
                console.log(e);
                return false;
            }
        }
        else {
            member = message.member;
        }

        for await (let permission of this.permissions) {
            if (!member?.permissions.has(permission, true)) {                
                if (message instanceof Interaction && !message.isRepliable())
                    return; 
    
                await message.reply({
                    embeds: [
                        {
                            description: ":x: You don't have enough permissions to run this command.",
                            color: 0xf14a60
                        }
                    ]
                });
    
                return false;
            }
        }

        if (!(await this.permissionValidation(client, member!))) {
            if (message instanceof Interaction && !message.isRepliable())
                return; 
            
            await message.reply({
                embeds: [
                    {
                        description: ":x: You don't have enough permissions to run this command.",
                        color: 0xf14a60
                    }
                ]
            });

            return false;
        }

        return true;
    }

    async execute(client: DiscordClient, message: Message | Interaction, options: CommandOptions | InteractionOptions) {
        if (!(await this.perms(client, message))) {
            return;
        } 

        await this.run(client, message, options);
    }

    abstract run(client: DiscordClient, message: Message | Interaction, options: CommandOptions | InteractionOptions): Promise<void>;
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2022 OSN Inc.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import { ModalSubmitInteraction } from 'discord-modals';
21			import { PermissionResolvable, AutocompleteInteraction, CommandInteraction, ContextMenuInteraction, Interaction, Message, MessageEditOptions, MessageOptions, MessagePayload, WebhookEditMessageOptions, GuildMember } from 'discord.js';
22			import DiscordClient from '../../client/Client';
23			import AutoCompleteOptions from '../../types/AutoCompleteOptions';
24			import CommandOptions from '../../types/CommandOptions';
25			import InteractionOptions from '../../types/InteractionOptions';
26
27			export default abstract class BaseCommand {
28			supportsInteractions: boolean = false;
29			supportsLegacy: boolean = true;
30			supportsContextMenu: boolean = false;
31			coolDown?: number;
32			ownerOnly: boolean = false;
33			permissions: PermissionResolvable[] = [];
34
35			protected name: string = "";
36			protected category: string = "";
37			protected aliases: Array<string> = [];
38
39			constructor(name?: string, category?: string, aliases?: Array<string>) {
40			if (name)
41			this.name = name;
42
43			if (category)
44			this.category = category;
45
46			if (aliases)
47			this.aliases = aliases;
48			}
49
50			getName(): string {
51			return this.name;
52			}
53
54			getCategory(): string {
55			return this.category;
56			}
57
58			getAliases(): Array<string> {
59			return this.aliases;
60			}
61
62			async permissionValidation(client: DiscordClient, member: GuildMember): Promise <boolean> {
63			return true;
64			}
65
66			async autoComplete(client: DiscordClient, interaction: AutocompleteInteraction, options: AutoCompleteOptions): Promise <void> {
67
68			}
69
70			async default(client: DiscordClient, interaction: Interaction): Promise <void> {
71
72			}
73
74			async modalSubmit(client: DiscordClient, interaction: ModalSubmitInteraction): Promise <void> {
75
76			}
77
78			async deferReply(msg: Message \| CommandInteraction \| ContextMenuInteraction, options: MessageOptions \| string \| MessagePayload \| WebhookEditMessageOptions, edit: boolean = false): Promise<Message> {
79			if (msg instanceof Message) {
80			return await msg[edit ? 'edit' : 'reply'](options as (MessageOptions & MessageEditOptions));
81			}
82
83			return (await msg.editReply(options as string \| MessagePayload \| WebhookEditMessageOptions)) as Message;
84			}
85
86			async perms(client: DiscordClient, message: Message \| Interaction) {
87			if (client.config.props.global.owners.includes(message.member!.user.id)) {
88			return true;
89			}
90
91			let member: GuildMember \| null = null;
92
93			if (message.member && !(message.member instanceof GuildMember)) {
94			try {
95			member = (await message.guild?.members.fetch(message.member!.user.id)) ?? null;
96			}
97			catch (e) {
98			console.log(e);
99			return false;
100			}
101			}
102			else {
103			member = message.member;
104			}
105
106			for await (let permission of this.permissions) {
107			if (!member?.permissions.has(permission, true)) {
108			if (message instanceof Interaction && !message.isRepliable())
109			return;
110
111			await message.reply({
112			embeds: [
113			{
114			description: ":x: You don't have enough permissions to run this command.",
115			color: 0xf14a60
116			}
117			]
118			});
119
120			return false;
121			}
122			}
123
124			if (!(await this.permissionValidation(client, member!))) {
125			if (message instanceof Interaction && !message.isRepliable())
126			return;
127
128			await message.reply({
129			embeds: [
130			{
131			description: ":x: You don't have enough permissions to run this command.",
132			color: 0xf14a60
133			}
134			]
135			});
136
137			return false;
138			}
139
140			return true;
141			}
142
143			async execute(client: DiscordClient, message: Message \| Interaction, options: CommandOptions \| InteractionOptions) {
144			if (!(await this.perms(client, message))) {
145			return;
146			}
147
148			await this.run(client, message, options);
149			}
150
151			abstract run(client: DiscordClient, message: Message \| Interaction, options: CommandOptions \| InteractionOptions): Promise<void>;
152			}