Pular para o conteúdo
Documentação DiscordKit

08 · Teste e opere o bot

Avaliação, exportação, tratamento de falhas, backup e hospedagem.

Abrir texto

Ative a etapa 6. /ticket rate e /ticket export completam o fluxo. O laboratório também fica disponível, mas não é necessário para atender chamados.

A nota é lida por RequireInt. O store exige que o chamado esteja encerrado e que o ator seja o autor. Um atendente não pode avaliar o próprio trabalho em nome de outra pessoa.

A exportação serializa Store.List(actor, ""), nunca o arquivo bruto do banco. Assim, um usuário recebe apenas seus dados; a equipe recebe os do servidor. O limite conservador de 7 MiB evita tentar enviar arquivos grandes; o limite efetivo de upload ainda depende do Discord.

Defer(true) reconhece a operação. Primeiro Edit conclui a espera; depois Followup envia o arquivo privado. File("attachment://tickets.json") referencia exatamente o nome em Files. FollowupEdit adiciona os detalhes finais, preservando os attachments recebidos. O botão de ocultar reconhece o clique com DeferUpdate e apaga a resposta associada ao componente com DeleteResponse.

Baixar uma exportação cria outra cópia dos dados. Ocultar a mensagem não revoga arquivos já baixados e não exclui chamados do store.

internal/bot/operations.go
package bot
import (
"bytes"
"encoding/json"
"fmt"
"github.com/bwmarrin/discordgo"
dk "github.com/freitaseric/discordkit"
)
func (b *Bot) registerOperations(r *dk.Router) func() error {
return func() error {
if err := r.Autocomplete("ticket rate", "id", b.completeTicket); err != nil {
return err
}
if err := r.Command("ticket rate", func(c *dk.Context) error {
id, err := c.RequireString("id")
if err != nil {
return err
}
score, err := c.RequireInt("score")
if err != nil {
return err
}
if err = c.Defer(true); err != nil {
return err
}
t, err := b.Store.Change(actor(c), id, "rate", int(score))
if err != nil {
return finish(c, dk.MessageSpec{}, err)
}
return finish(c, ticketView(t), nil)
}); err != nil {
return err
}
if err := r.Component("/export/dismiss", func(c *dk.Context) error {
if err := c.DeferUpdate(); err != nil {
return err
}
return c.DeleteResponse()
}); err != nil {
return err
}
return r.Command("ticket export", b.export)
}
}
func (b *Bot) export(c *dk.Context) error {
if err := c.Defer(true); err != nil {
return err
}
raw, err := json.MarshalIndent(b.Store.List(actor(c), ""), "", " ")
if err != nil {
return finish(c, dk.MessageSpec{}, err)
}
if len(raw) > 7*1024*1024 {
return finish(c, message(dk.Text("Exportação muito grande. Solicite um backup ao operador.")), nil)
}
// Complete the deferred response before creating an additional private message.
if err = finish(c, message(dk.Text("Exportação preparada.")), nil); err != nil {
return err
}
spec := message(dk.Text("## Exportação de chamados"), dk.File("attachment://tickets.json"), dk.Row(dk.Button("Ocultar exportação", "/export/dismiss").Secondary()))
spec.Ephemeral = true
spec.Files = []*discordgo.File{{Name: "tickets.json", ContentType: "application/json", Reader: bytes.NewReader(raw)}}
sent, err := c.Followup(spec)
if err != nil {
return err
}
// Edit the same followup while retaining its attachment and controls.
spec.Components = dk.Components(dk.Text(fmt.Sprintf("## Exportação pronta\n%d bytes · somente chamados autorizados.", len(raw))), dk.File("attachment://tickets.json"), dk.Row(dk.Button("Ocultar exportação", "/export/dismiss").Secondary()))
spec.Ephemeral = false // Editing does not change the existing message visibility.
spec.Files = nil
spec.Attachments = sent.Attachments
_, err = c.FollowupEdit(sent.ID, spec)
return err
}
Janela do terminal
go test ./...
go test -race ./...
go vet ./...

Os testes do store cobrem políticas e persistência. Os testes de bot montam rotas de todas as etapas, validam layouts e usam um transporte HTTP falso para verificar o envio de formulário: defer privado, edição e registro em disco. Nenhum teste precisa de token real.

Isso não substitui testar no Discord. API remota, permissões de canal, instalação e comportamento do cliente dependem de uma aplicação real. Execute esta aceitação no seu servidor:

Cenário Resultado esperado
Abrir pelo painel ou /ticket new Formulário, resposta privada e registro persistido
Terceiro consulta um ID conhecido Recusa sem conteúdo do chamado
Atendente assume; outro tenta assumir Primeiro mantém a atribuição
Autor encerra e avalia Estado fechado e nota persistida
Terceiro/equipe tenta avaliar pelo autor Recusa
Reiniciar e consultar Mesmos registros e estados
Exportar como membro comum Somente seus chamados no arquivo
Ocultar exportação Mensagem some; chamado permanece

Depois de estudar, copie cmd, internal, .gitignore e .env.example para uma pasta nova. Use um nome real para seu módulo e substitua apenas os imports locais:

Janela do terminal
mkdir meu-bot
cp -R cmd internal .gitignore .env.example meu-bot/
cd meu-bot
go mod init example.com/meu-bot

Nos arquivos Go copiados, troque github.com/freitaseric/discordkit/examples/community-bot/internal/ por example.com/meu-bot/internal/. Mantenha os imports da biblioteca github.com/freitaseric/discordkit. A partir da raiz do clone original, descubra a revisão testada com git rev-parse HEAD; na pasta nova, instale essa revisão usando go get github.com/freitaseric/discordkit@REVISAO e execute go mod tidy, go test ./... e go run ./cmd/bot.

Não copie data ou um token para o novo repositório. Fixar a revisão evita que uma alteração futura na branch mude o tutorial durante sua reconstrução.

A Vercel hospeda esta documentação. O bot usa Gateway e requer um processo Go continuamente ativo: uma VM, container ou serviço de workers com volume persistente. Uma função HTTP efêmera não mantém essa conexão nem esse arquivo.

Compile go build -o bot ./cmd/bot. Defina BOT_DATA_FILE como um caminho absoluto em volume persistente e configure o supervisor com uma única réplica. Mantenha as variáveis no ambiente do serviço; nunca em argumentos de linha de comando com o token. Confira o guia de hospedagem para o ciclo de vida básico.

Backups: pare o serviço, copie o JSON para um local protegido com data no nome e reinicie. Para restaurar, pare, preserve uma cópia do arquivo atual, reponha o backup, mantenha o mesmo proprietário/permissões e inicie. Confirme no log que o banco abriu e consulte um ID conhecido. Um arquivo corrompido deve bloquear o início; não o substitua automaticamente por {}.

O exemplo não inclui antispam, retenção automática, fila de trabalhos ou drenagem completa de handlers. Antes de abrir para um servidor grande, adicione limites por usuário, política de retenção, monitoramento e um banco adequado ao volume. Não prometa armazenamento ilimitado em um JSON que é reescrito inteiro.

Exercício final: apague sua cópia de teste somente depois de guardar um backup, restaure e execute toda a aceitação. Você deve conseguir explicar o caminho completo: evento → router → ator → store → MessageSpec → Discord.

Próximo: laboratório das APIs complementares.


← Anterior: 07 · Filtros, páginas e autocomplete · Próximo →: 09 · Explore o restante da API