keanucode
/
TravBot-v3
mirror of https://github.com/keanuplayz/TravBot-v3.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Attempted guild/DM channel feature that turned out to not be worth it

This commit is contained in:
WatDuhHekBro 2021-03-31 09:08:53 -05:00
parent 0d0d134415
commit fb76f3cb84
1 changed files with 117 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
src/core/command.ts
View File

@ -3,23 +3,49 @@ import {Collection, Client, Message, TextChannel, DMChannel, NewsChannel, Guild,
import {getPrefix} from "../core/structures"; import {getPrefix} from "../core/structures";
import glob from "glob"; import glob from "glob";
interface CommandMenu { export enum CHANNEL_TYPE {
BOTH,
GUILD,
DM
}
// **Notice**
// Now that I've tried it out, this turned out to be a pretty bad idea in the amount of time spent, the decrease of flexibility, and the maintainability of the code. It's not even worth doing this.
interface CommandMenuBase {
args: any[]; args: any[];
client: Client; client: Client;
message: Message; message: Message;
channel: TextChannel | DMChannel | NewsChannel;
guild: Guild | null;
author: User; author: User;
// According to the documentation, a message can be part of a guild while also not having a
// member object for the author. This will happen if the author of a message left the guild.
member: GuildMember | null; member: GuildMember | null;
} }
interface CommandOptions { interface CommandMenuBoth extends CommandMenuBase {
channel: TextChannel | DMChannel | NewsChannel;
guild: Guild | null;
}
interface CommandMenuGuild extends CommandMenuBase {
channel: TextChannel | NewsChannel;
guild: Guild;
}
// If it's a DM, the guild must be null and the channel type must be DM (single user). Although there is a Group DM type on Discord's API, it will always be invalid for bots. It can never be a group DM because you need to be friends with a user to add them to a group DM and you cannot friend bots.
interface CommandMenuDM extends CommandMenuBase {
channel: DMChannel;
guild: null;
}
type CommandMenu = CommandMenuBoth | CommandMenuGuild | CommandMenuDM;
interface CommandOptionsBase {
description?: string; description?: string;
endpoint?: boolean; endpoint?: boolean;
usage?: string; usage?: string;
permission?: number; permission?: number;
aliases?: string[]; aliases?: string[];
run?: (($: CommandMenu) => Promise<any>) | string;
subcommands?: {[key: string]: Command}; subcommands?: {[key: string]: Command};
channel?: Command; channel?: Command;
role?: Command; role?: Command;
@ -31,6 +57,23 @@ interface CommandOptions {
any?: Command; any?: Command;
} }
interface CommandOptionsBoth extends CommandOptionsBase {
channelType: CHANNEL_TYPE.BOTH;
run?: (($: CommandMenuBoth) => Promise<any>) | string;
}
interface CommandOptionsGuild extends CommandOptionsBase {
channelType: CHANNEL_TYPE.GUILD;
run?: (($: CommandMenuGuild) => Promise<any>) | string;
}
interface CommandOptionsDM extends CommandOptionsBase {
channelType: CHANNEL_TYPE.DM;
run?: (($: CommandMenuDM) => Promise<any>) | string;
}
type CommandOptions = CommandOptionsBoth | CommandOptionsGuild | CommandOptionsDM;
export enum TYPES { export enum TYPES {
SUBCOMMAND, // Any specifically-defined keywords / string literals. SUBCOMMAND, // Any specifically-defined keywords / string literals.
CHANNEL, // <#...> CHANNEL, // <#...>
@ -51,7 +94,12 @@ export default class Command {
public readonly permission: number; // -1 (default) indicates to inherit, 0 is the lowest rank, 1 is second lowest rank, and so on. public readonly permission: number; // -1 (default) indicates to inherit, 0 is the lowest rank, 1 is second lowest rank, and so on.
public readonly aliases: string[]; // This is to keep the array intact for parent Command instances to use. It'll also be used when loading top-level aliases. public readonly aliases: string[]; // This is to keep the array intact for parent Command instances to use. It'll also be used when loading top-level aliases.
public originalCommandName: string | null; // If the command is an alias, what's the original name? public originalCommandName: string | null; // If the command is an alias, what's the original name?
public run: (($: CommandMenu) => Promise<any>) | string; // I'm going to trust that the code knows which one to execute.
private runAnywhere?: ($: CommandMenuBoth) => Promise<any>;
private runGuild?: ($: CommandMenuGuild) => Promise<any>;
private runDM?: ($: CommandMenuDM) => Promise<any>;
private runMessage?: string;
private runType: keyof typeof CHANNEL_TYPE | "TEXT";
public readonly subcommands: Collection<string, Command>; // This is the final data structure you'll actually use to work with the commands the aliases point to. public readonly subcommands: Collection<string, Command>; // This is the final data structure you'll actually use to work with the commands the aliases point to.
public channel: Command | null; public channel: Command | null;
public role: Command | null; public role: Command | null;
@ -62,24 +110,45 @@ export default class Command {
public number: Command | null; public number: Command | null;
public any: Command | null; public any: Command | null;
constructor(options?: CommandOptions) { constructor(options: CommandOptions) {
this.description = options?.description || "No description."; this.description = options.description || "No description.";
this.endpoint = options?.endpoint || false; this.endpoint = options.endpoint || false;
this.usage = options?.usage || ""; this.usage = options.usage || "";
this.permission = options?.permission ?? -1; this.permission = options.permission ?? -1;
this.aliases = options?.aliases ?? []; this.aliases = options.aliases ?? [];
this.originalCommandName = null; this.originalCommandName = null;
this.run = options?.run || "No action was set on this command!";
this.subcommands = new Collection(); // Populate this collection after setting subcommands. this.subcommands = new Collection(); // Populate this collection after setting subcommands.
this.channel = options?.channel || null; this.channel = options.channel || null;
this.role = options?.role || null; this.role = options.role || null;
this.emote = options?.emote || null; this.emote = options.emote || null;
this.message = options?.message || null; this.message = options.message || null;
this.user = options?.user || null; this.user = options.user || null;
this.number = options?.number || null; this.number = options.number || null;
this.any = options?.any || null; this.any = options.any || null;
switch (options?.id) { if (typeof options.run === "string") {
this.runMessage = options.run;
this.runType = "TEXT";
} else if (options.run === undefined) {
this.runMessage = "No action was set on this command!";
this.runType = "TEXT";
} else {
switch (options.channelType) {
case CHANNEL_TYPE.BOTH:
this.runAnywhere = options.run;
this.runType = "BOTH";
break;
case CHANNEL_TYPE.GUILD:
this.runGuild = options.run;
this.runType = "GUILD";
break;
case CHANNEL_TYPE.DM:
this.runDM = options.run;
this.runType = "DM";
}
}
switch (options.id) {
case "channel": case "channel":
this.id = this.channel; this.id = this.channel;
break; break;
@ -100,7 +169,7 @@ export default class Command {
break; break;
} }
if (options?.subcommands) { if (options.subcommands) {
const baseSubcommands = Object.keys(options.subcommands); const baseSubcommands = Object.keys(options.subcommands);
// Loop once to set the base subcommands. // Loop once to set the base subcommands.
@ -152,18 +221,32 @@ export default class Command {
} }
public execute($: CommandMenu) { public execute($: CommandMenu) {
if (typeof this.run === "string") { switch (this.runType) {
$.channel.send( case "BOTH":
parseVars( this.runAnywhere!($).catch(handler.bind($));
this.run, break;
{ case "GUILD":
author: $.author.toString(), if ($.guild !== null && $.channel.type !== "dm")
prefix: getPrefix($.guild) this.runGuild!($ as CommandMenuGuild).catch(handler.bind($));
}, else $.channel.send("You must use this command in a guild!");
"???" break;
) case "DM":
); if ($.guild === null && $.channel.type === "dm") this.runDM!($ as CommandMenuDM).catch(handler.bind($));
} else this.run($).catch(handler.bind($)); else $.channel.send("You can't use this command in a guild!");
break;
case "TEXT":
$.channel.send(
parseVars(
this.runMessage!,
{
author: $.author.toString(),
prefix: getPrefix($.guild)
},
"???"
)
);
break;
}
} }
public resolve(param: string): TYPES { public resolve(param: string): TYPES {