3
0
Fork 0
mirror of https://github.com/ZeppelinBot/Zeppelin.git synced 2025-03-18 15:00:00 +00:00
zeppelin/backend/src/commandTypes.ts

117 lines
3.9 KiB
TypeScript
Raw Normal View History

import { GuildChannel, GuildMember, Snowflake, Util, User } from "discord.js";
import { baseCommandParameterTypeHelpers, baseTypeConverters, CommandContext, TypeConversionError } from "knub";
import { createTypeHelper } from "knub-command-manager";
import {
channelMentionRegex,
convertDelayStringToMS,
isValidSnowflake,
resolveMember,
resolveUser,
resolveUserId,
roleMentionRegex,
UnknownUser,
} from "./utils";
import { isValidTimezone } from "./utils/isValidTimezone";
2020-08-06 01:10:40 +03:00
import { MessageTarget, resolveMessageTarget } from "./utils/resolveMessageTarget";
2020-08-10 01:09:45 +03:00
import { inputPatternToRegExp } from "./validatorUtils";
export const commandTypes = {
...baseTypeConverters,
delay(value) {
const result = convertDelayStringToMS(value);
if (result == null) {
throw new TypeConversionError(`Could not convert ${value} to a delay`);
}
return result;
},
async resolvedUser(value, context: CommandContext<any>) {
const result = await resolveUser(context.pluginData.client, value);
if (result == null || result instanceof UnknownUser) {
throw new TypeConversionError(`User \`${Util.escapeCodeBlock(value)}\` was not found`);
}
return result;
},
async resolvedUserLoose(value, context: CommandContext<any>) {
const result = await resolveUser(context.pluginData.client, value);
if (result == null) {
throw new TypeConversionError(`Invalid user: \`${Util.escapeCodeBlock(value)}\``);
}
return result;
},
async resolvedMember(value, context: CommandContext<any>) {
if (!(context.message.channel instanceof GuildChannel)) {
throw new TypeConversionError(`Cannot resolve member for non-guild channels`);
}
const result = await resolveMember(context.pluginData.client, context.message.channel.guild, value);
if (result == null) {
throw new TypeConversionError(
`Member \`${Util.escapeCodeBlock(value)}\` was not found or they have left the server`,
);
}
return result;
},
async messageTarget(value: string, context: CommandContext<any>) {
value = String(value).trim();
2020-08-06 01:10:40 +03:00
const result = await resolveMessageTarget(context.pluginData, value);
if (!result) {
throw new TypeConversionError(`Unknown message \`${Util.escapeInlineCode(value)}\``);
}
2020-08-06 01:10:40 +03:00
return result;
},
2020-08-09 17:28:21 +03:00
async anyId(value: string, context: CommandContext<any>) {
const userId = resolveUserId(context.pluginData.client, value);
if (userId) return userId as Snowflake;
2020-08-09 17:28:21 +03:00
const channelIdMatch = value.match(channelMentionRegex);
if (channelIdMatch) return channelIdMatch[1] as Snowflake;
2020-08-09 17:28:21 +03:00
const roleIdMatch = value.match(roleMentionRegex);
if (roleIdMatch) return roleIdMatch[1] as Snowflake;
2020-08-09 17:28:21 +03:00
if (isValidSnowflake(value)) {
return value as Snowflake;
2020-08-09 17:28:21 +03:00
}
throw new TypeConversionError(`Could not parse ID: \`${Util.escapeInlineCode(value)}\``);
2020-08-09 17:28:21 +03:00
},
2020-08-10 01:09:45 +03:00
regex(value: string, context: CommandContext<any>): RegExp {
try {
return inputPatternToRegExp(value);
} catch (e) {
throw new TypeConversionError(`Could not parse RegExp: \`${Util.escapeInlineCode(e.message)}\``);
2020-08-10 01:09:45 +03:00
}
},
timezone(value: string) {
if (!isValidTimezone(value)) {
throw new TypeConversionError(`Invalid timezone: ${Util.escapeInlineCode(value)}`);
}
return value;
},
};
export const commandTypeHelpers = {
...baseCommandParameterTypeHelpers,
delay: createTypeHelper<number>(commandTypes.delay),
resolvedUser: createTypeHelper<Promise<User>>(commandTypes.resolvedUser),
resolvedUserLoose: createTypeHelper<Promise<User | UnknownUser>>(commandTypes.resolvedUserLoose),
2021-05-31 21:12:24 +02:00
resolvedMember: createTypeHelper<Promise<GuildMember>>(commandTypes.resolvedMember),
messageTarget: createTypeHelper<Promise<MessageTarget>>(commandTypes.messageTarget),
anyId: createTypeHelper<Promise<Snowflake>>(commandTypes.anyId),
2020-08-10 01:09:45 +03:00
regex: createTypeHelper<RegExp>(commandTypes.regex),
timezone: createTypeHelper<string>(commandTypes.timezone),
};