Slash Commands
Comandos de Golpe são a nova e emocionante maneira de construir e interagir com bots no Discord. Com Slash Commands, tudo que você tem que fazer é
digitar /
e você estará pronto para utilizar seu bot favorito. Você pode ver facilmente todos os comandos que um bot tem, e a validação e a manipulação de erros ajudam
você a obter o comando corretamente na primeira vez.
Comandos Globais
Comandos globais são armazenados em cache por uma hora. Novos comandos globais vão se espalhar lentamente em todas as guildas e só será garantido que serão atualizados após uma hora. Comandos de servidor atualizam instantaneamente. Com isso, recomendamos que você use comandos baseados a servidores durante o desenvolvimento e publique eles como comandos globais quando eles estiverem prontos para o uso do público.
Crie o arquivo app.commands.ts
e adicione um método com o decorador SlashCommand
.
import { Injectable } from '@nestjs/common';
import { Context, SlashCommand, SlashCommandContext } from 'necord';
@Injectable()
export class AppCommands {
@SlashCommand({
name: 'ping',
description: 'Comando Ping-Pong'
})
public async onPing(@Context() [interaction]: SlashCommandContext) {
return interaction.reply({ content: 'Pong!' });
}
}
Comandos de Servidor
Se você quer ter comandos específicos de um servidor, use a propriedade guilds
no decorador SlashCommand
import { Injectable } from '@nestjs/common';
import { Context, SlashCommand, SlashCommandContext } from 'necord';
@Injectable()
export class AppCommands {
@SlashCommand({
name: 'ping',
description: 'Comando Ping-Pong',
guilds: [process.env.DEV_GUILD]
})
public async onPing(@Context() [interaction]: SlashCommandContext) {
return interaction.reply({ content: 'Pong!' });
}
}
Você pode usar decoradores em classes e métodos.
Opções
Use o decorador de opção para definir um parâmetro em um slash command, vamos criar a classe LengthDto
:
import { StringOption } from 'necord';
export class TextDto {
@StringOption({
name: 'text',
description: 'Seu texto',
required: true
})
text: string;
}
Tem apenas uma propriedade básica. Então, nós podemos usar o recém-criado DTO dentro do AppCommands
:
import { Injectable } from '@nestjs/common';
import { Context, SlashCommand, Options, SlashCommandContext } from 'necord';
import { TextDto } from './length.dto';
@Injectable()
export class AppCommands {
@SlashCommand({
name: 'tamanho',
description: 'Consiga o tamanho de um texto'
})
public async onLength(@Context() [interaction]: SlashCommandContext, @Options() { text }: TextDto) {
return interaction.reply({content: `Tamanho do seu texto ${text.length}`});
}
}
Lista de todos os decoradores de opção incorporados:
Decorador | Tipo | Descrição |
---|---|---|
StringOption | string | Uma opção de texto |
NumberOption | number | Uma opção numérica |
IntegerOption | number | Uma opção de inteiro |
BooleanOption | boolean | Uma opção booleana |
UserOption | User | Uma opção de usuário |
MemberOption | GuildMember | Uma opção de membro |
ChannelOption | GuildChannel | Uma opção de canal |
RoleOption | Role | Uma opção de cargo |
MentionableOption | GuildMember | Role | User | Uma opção mencionável |
AttachmentOption | Attachment | Uma opção de anexo |
Autocompletar
Para adicionar autocompletar ao seu slash command você precisará de um interceptor primeiro. Esta classe interceptará todas as solicitações do usuário depois de digitar o campo de opção de preenchimento automático
import { Injectable } from '@nestjs/common';
import { AutocompleteInteraction } from 'discord.js';
import { AutocompleteInterceptor } from 'necord';
@Injectable()
export class AnimeAutocompleteInterceptor extends AutocompleteInterceptor {
public transformOptions(interaction: AutocompleteInteraction) {
const focused = interaction.options.getFocused(true);
let choices: string[];
if (focused.name === 'anime') {
choices = ['Hunter x Hunter', 'Naruto', 'One Piece'];
}
return interaction.respond(
choices
.filter(choice => choice.startsWith(focused.value.toString()))
.map(choice => ({ name: choice, value: choice }))
);
}
}
Você terá que adicionar autoComplete: true
para sua classe de opções:
importar { StringOption } de 'necord';
export class AnimeDto {
@StringOption({
name: 'anime',
description: 'O anime para procurar',
autocomplete: true,
required: true
})
anime: string;
}
E por último, mas não menos importante, aplicar o interceptor ao seu slash command
import { Injectable, UseInterceptors } from '@nestjs/common';
import { Context, SlashCommand, Options, SlashCommandContext } from 'necord';
import { AnimeDto } from '/anime.dto';
import { AnimeAutocompleteInterceptor } from './anime.interceptor';
@Injectable()
export class AnimeCommands {
@UseInterceptors(AnimeAutocompleteInterceptor)
@SlashCommand({
name: 'anime',
description: 'Procura informações sobre um anime'
})
public async onSearch(@Context() [interaction]: SlashCommandContext, @Options() { anime }: AnimeDto) {
return interaction.reply({content: `Eu encontrei o anime ${anime}`});
}
}
Grupos
Para esses desenvolvedores que desejam fazer grupos de comandos mais organizados e complexos, procure apenas subgrupos e grupos.
Use decoradores SlashGroup
em nível de classe (Grupo)
e nível método (Subgrupo)
:
import { createCommandGroupDecorator, Subcommand } from 'necord';
export const UtilsCommandDecorator = createCommandGroupDecorator({
name: 'utilidades',
description: 'Grupo de utilidades',
});
@UtilsCommandDecorator()
export class UtilsCommands {
@Subcommand({
name: 'ping',
description: 'Comando Ping-pong'
})
public async onPing(...) {
...
}
}
@UtilsCommandDecorator({
name: 'texto',
descriptionn: 'Comandos de utilidade de texto'
})
export class UtilsStringCommands {
@Subcommand({
name: 'tamanho',
description: 'Comando de tamanho de texto'
})
public async onLength(...) {
...
}
}
Após os comandos serem registrados, o bot irá processar os comandos /utilidades ping
e /utilidades texto tamanho
, como aqui:
Você pode ver um exemplo funcional aqui.