harmony/src/models/command.ts

429 lines
13 KiB
TypeScript
Raw Normal View History

2020-12-01 08:24:49 +00:00
import { Guild } from '../structures/guild.ts'
import { Message } from '../structures/message.ts'
import { TextChannel } from '../structures/textChannel.ts'
import { User } from '../structures/user.ts'
import { Collection } from '../utils/collection.ts'
import { CommandClient } from './commandClient.ts'
import { Extension } from './extensions.ts'
2020-12-01 08:24:49 +00:00
export interface CommandContext {
/** The Client object */
client: CommandClient
/** Message which was parsed for Command */
message: Message
/** The Author of the Message */
author: User
/** The Channel in which Command was used */
channel: TextChannel
/** Prefix which was used */
prefix: string
/** Oject of Command which was used */
command: Command
/** Name of Command which was used */
name: string
/** Array of Arguments used with Command */
args: string[]
/** Complete Raw String of Arguments */
argString: string
/** Guild which the command has called */
guild?: Guild
}
export class Command {
/** Name of the Command */
name: string = ''
/** Description of the Command */
description?: string
/** Category of the Command */
category?: string
2020-12-01 08:24:49 +00:00
/** Array of Aliases of Command, or only string */
aliases?: string | string[]
/** Extension (Parent) of the Command */
extension?: Extension
/** Usage of Command, only Argument Names */
usage?: string | string[]
/** Usage Example of Command, only Arguments (without Prefix and Name) */
examples?: string | string[]
/** Does the Command take Arguments? Maybe number of required arguments? Or list of arguments? */
args?: number | boolean | string[]
/** Permissions(s) required by both User and Bot in order to use Command */
2020-12-01 08:24:49 +00:00
permissions?: string | string[]
/** Permission(s) required for using Command */
userPermissions?: string | string[]
2020-12-01 08:24:49 +00:00
/** Permission(s) bot will need in order to execute Command */
botPermissions?: string | string[]
/** Role(s) user will require in order to use Command. List or one of ID or name */
roles?: string | string[]
/** Whitelisted Guilds. Only these Guild(s) can execute Command. (List or one of IDs) */
whitelistedGuilds?: string | string[]
/** Whitelisted Channels. Command can be executed only in these channels. (List or one of IDs) */
whitelistedChannels?: string | string[]
/** Whitelisted Users. Command can be executed only by these Users (List or one of IDs) */
whitelistedUsers?: string | string[]
/** Whether the Command can only be used in Guild (if allowed in DMs) */
guildOnly?: boolean
/** Whether the Command can only be used in Bot's DMs (if allowed) */
dmOnly?: boolean
/** Whether the Command can only be used by Bot Owners */
ownerOnly?: boolean
/** Method executed before executing actual command. Returns bool value - whether to continue or not (optional) */
beforeExecute(ctx: CommandContext): boolean | Promise<boolean> {
return true
}
2020-12-01 08:24:49 +00:00
/** Actual command code, which is executed when all checks have passed. */
execute(ctx: CommandContext): any {}
2020-12-01 08:24:49 +00:00
/** Method executed after executing command, passes on CommandContext and the value returned by execute too. (optional) */
afterExecute(ctx: CommandContext, executeResult: any): any {}
2020-12-01 08:24:49 +00:00
toString(): string {
return `Command: ${this.name}${
this.extension !== undefined
? ` [${this.extension.name}]`
: this.category !== undefined
? ` [${this.category}]`
: ''
}`
}
}
export class CommandCategory {
/** Name of the Category. */
name: string = ''
/** Permissions(s) required by both User and Bot in order to use Category Commands */
permissions?: string | string[]
/** Permission(s) required for using Category Commands */
userPermissions?: string | string[]
/** Permission(s) bot will need in order to execute Category Commands */
botPermissions?: string | string[]
/** Role(s) user will require in order to use Category Commands. List or one of ID or name */
roles?: string | string[]
/** Whitelisted Guilds. Only these Guild(s) can execute Category Commands. (List or one of IDs) */
whitelistedGuilds?: string | string[]
/** Whitelisted Channels. Category Commands can be executed only in these channels. (List or one of IDs) */
whitelistedChannels?: string | string[]
/** Whitelisted Users. Category Commands can be executed only by these Users (List or one of IDs) */
whitelistedUsers?: string | string[]
/** Whether the Category Commands can only be used in Guild (if allowed in DMs) */
guildOnly?: boolean
/** Whether the Category Commands can only be used in Bot's DMs (if allowed) */
dmOnly?: boolean
/** Whether the Category Commands can only be used by Bot Owners */
ownerOnly?: boolean
}
export class CommandBuilder extends Command {
setName(name: string): CommandBuilder {
this.name = name
return this
}
setDescription(description?: string): CommandBuilder {
this.description = description
return this
}
setCategory(category?: string): CommandBuilder {
this.category = category
return this
}
setAlias(alias: string | string[]): CommandBuilder {
this.aliases = alias
return this
}
addAlias(alias: string | string[]): CommandBuilder {
if (this.aliases === undefined) this.aliases = []
if (typeof this.aliases === 'string') this.aliases = [this.aliases]
this.aliases = [
...new Set(
...this.aliases,
...(typeof alias === 'string' ? [alias] : alias)
),
]
return this
}
setExtension(extension?: Extension): CommandBuilder {
this.extension = extension
return this
}
setUsage(usage: string | string[]): CommandBuilder {
this.usage = usage
return this
}
addUsage(usage: string | string[]): CommandBuilder {
if (this.usage === undefined) this.usage = []
if (typeof this.usage === 'string') this.usage = [this.usage]
this.aliases = [
...new Set(
...this.usage,
...(typeof usage === 'string' ? [usage] : usage)
),
]
return this
}
setExample(examples: string | string[]): CommandBuilder {
this.examples = examples
return this
}
addExample(examples: string | string[]): CommandBuilder {
if (this.examples === undefined) this.examples = []
if (typeof this.examples === 'string') this.examples = [this.examples]
this.examples = [
...new Set(
...this.examples,
...(typeof examples === 'string' ? [examples] : examples)
),
]
return this
}
setPermissions(perms?: string | string[]): CommandBuilder {
this.permissions = perms
return this
}
setUserPermissions(perms?: string | string[]): CommandBuilder {
this.userPermissions = perms
return this
}
setBotPermissions(perms?: string | string[]): CommandBuilder {
this.botPermissions = perms
return this
}
setRoles(roles: string | string[]): CommandBuilder {
this.roles = roles
return this
}
setWhitelistedGuilds(list: string | string[]): CommandBuilder {
this.whitelistedGuilds = list
return this
}
setWhitelistedUsers(list: string | string[]): CommandBuilder {
this.whitelistedUsers = list
return this
}
setWhitelistedChannels(list: string | string[]): CommandBuilder {
this.whitelistedChannels = list
return this
}
setGuildOnly(value: boolean = true): CommandBuilder {
this.guildOnly = value
return this
}
setOwnerOnly(value: boolean = true): CommandBuilder {
this.ownerOnly = value
return this
}
onBeforeExecute(fn: (ctx: CommandContext) => boolean | any): CommandBuilder {
this.beforeExecute = fn
return this
}
onExecute(fn: (ctx: CommandContext) => any): CommandBuilder {
this.execute = fn
return this
}
onAfterExecute(
fn: (ctx: CommandContext, executeResult?: any) => any
): CommandBuilder {
this.afterExecute = fn
return this
2020-12-01 08:24:49 +00:00
}
}
export class CommandsManager {
client: CommandClient
list: Collection<string, Command> = new Collection()
disabled: Set<string> = new Set()
constructor(client: CommandClient) {
this.client = client
}
/** Number of loaded Commands */
get count(): number {
return this.list.size
}
2020-12-01 08:24:49 +00:00
/** Find a Command by name/alias */
find(search: string): Command | undefined {
if (this.client.caseSensitive === false) search = search.toLowerCase()
return this.list.find((cmd: Command): boolean => {
const name =
this.client.caseSensitive === true ? cmd.name : cmd.name.toLowerCase()
if (name === search) return true
else if (cmd.aliases !== undefined) {
let aliases: string[]
if (typeof cmd.aliases === 'string') aliases = [cmd.aliases]
else aliases = cmd.aliases
if (this.client.caseSensitive === false)
aliases = aliases.map((e) => e.toLowerCase())
2020-12-01 08:24:49 +00:00
return aliases.includes(search)
} else return false
})
}
/** Fetch a Command including disable checks */
fetch(name: string, bypassDisable?: boolean): Command | undefined {
const cmd = this.find(name)
if (cmd === undefined) return
if (this.isDisabled(cmd) && bypassDisable !== true) return
return cmd
}
/** Check whether a Command exists or not */
exists(search: Command | string): boolean {
let exists = false
if (typeof search === 'string') return this.find(search) !== undefined
else {
exists = this.find(search.name) !== undefined
if (search.aliases !== undefined) {
const aliases: string[] =
typeof search.aliases === 'string' ? [search.aliases] : search.aliases
exists =
aliases
.map((alias) => this.find(alias) !== undefined)
.find((e) => e) ?? false
2020-12-01 08:24:49 +00:00
}
return exists
}
}
/** Add a Command */
add(cmd: Command | typeof Command): boolean {
// eslint-disable-next-line new-cap
if (!(cmd instanceof Command)) cmd = new cmd()
if (this.exists(cmd))
throw new Error(
`Failed to add Command '${cmd.toString()}' with name/alias already exists.`
)
2020-12-01 08:24:49 +00:00
this.list.set(cmd.name, cmd)
return true
}
/** Delete a Command */
delete(cmd: string | Command): boolean {
const find = typeof cmd === 'string' ? this.find(cmd) : cmd
if (find === undefined) return false
else return this.list.delete(find.name)
}
/** Check whether a Command is disabled or not */
isDisabled(name: string | Command): boolean {
const cmd = typeof name === 'string' ? this.find(name) : name
2020-12-01 08:24:49 +00:00
if (cmd === undefined) return false
const exists = this.exists(name)
if (!exists) return false
return this.disabled.has(cmd.name)
}
/** Disable a Command */
disable(name: string | Command): boolean {
const cmd = typeof name === 'string' ? this.find(name) : name
2020-12-01 08:24:49 +00:00
if (cmd === undefined) return false
if (this.isDisabled(cmd)) return false
this.disabled.add(cmd.name)
return true
}
/** Get all commands of a Category */
category(category: string): Collection<string, Command> {
return this.list.filter(
(cmd) => cmd.category !== undefined && cmd.category === category
)
}
}
export class CategoriesManager {
client: CommandClient
list: Collection<string, CommandCategory> = new Collection()
constructor(client: CommandClient) {
this.client = client
}
/** Get a Collection of Categories */
all(): Collection<string, CommandCategory> {
return this.list
}
/** Get a list of names of Categories added */
names(): string[] {
return [...this.list.keys()]
}
/** Check if a Category exists or not */
has(category: string | CommandCategory): boolean {
return this.list.has(
typeof category === 'string' ? category : category.name
)
}
/** Get a Category by name */
get(name: string): CommandCategory | undefined {
return this.list.get(name)
}
/** Add a Category to the Manager */
add(category: CommandCategory): CategoriesManager {
if (this.has(category))
throw new Error(`Category ${category.name} already exists`)
this.list.set(category.name, category)
return this
}
/** Remove a Category from the Manager */
remove(category: string | CommandCategory): boolean {
if (!this.has(category)) return false
this.list.delete(typeof category === 'string' ? category : category.name)
return true
}
2020-12-01 08:24:49 +00:00
}
export interface ParsedCommand {
name: string
args: string[]
argString: string
}
export const parseCommand = (
client: CommandClient,
msg: Message,
prefix: string
): ParsedCommand => {
let content = msg.content.slice(prefix.length)
if (client.spacesAfterPrefix === true) content = content.trim()
const args = content.split(client.betterArgs === true ? /[\S\s]*/ : / +/)
const name = args.shift() as string
const argString = content.slice(name.length).trim()
return {
name,
args,
argString,
2020-12-01 08:24:49 +00:00
}
}