-
Notifications
You must be signed in to change notification settings - Fork 5
/
context.go
122 lines (97 loc) · 3.79 KB
/
context.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package disgolf
import (
"fmt"
"github.com/bwmarrin/discordgo"
)
// OptionsMap is an alias for map of discordgo.ApplicationCommandInteractionDataOption
type OptionsMap = map[string]*discordgo.ApplicationCommandInteractionDataOption
// Ctx is a context provided to a command. It embeds session for easier use,
// and contains interaction and preprocessed options.
type Ctx struct {
*discordgo.Session `json:"-"`
Caller *Command `json:"caller"`
Interaction *discordgo.Interaction `json:"interaction"`
Options OptionsMap `json:"options"`
OptionsRaw []*discordgo.ApplicationCommandInteractionDataOption `json:"options_raw"`
remainingHandlers []Handler
}
// Respond is a wrapper for ctx.Session.InteractionRespond
func (ctx *Ctx) Respond(response *discordgo.InteractionResponse) error {
return ctx.Session.InteractionRespond(ctx.Interaction, response)
}
func (ctx *Ctx) Next() {
if len(ctx.remainingHandlers) == 0 {
return
}
handler := ctx.remainingHandlers[0]
ctx.remainingHandlers = ctx.remainingHandlers[1:]
handler.HandleCommand(ctx)
}
func (ctx *Ctx) String() string {
return fmt.Sprintf(`caller: %s guild: %s options: %v`, ctx.Caller.Name, ctx.Interaction.GuildID, ctx.Options)
}
// NewCtx constructs ctx from given parameters.
func NewCtx(s *discordgo.Session, caller *Command, i *discordgo.Interaction, parent *discordgo.ApplicationCommandInteractionDataOption, handlers []Handler) *Ctx {
options := i.ApplicationCommandData().Options
if parent != nil {
options = parent.Options
}
return &Ctx{
Session: s,
Caller: caller,
Interaction: i,
Options: makeOptionMap(options),
OptionsRaw: options,
remainingHandlers: handlers,
}
}
func makeOptionMap(options []*discordgo.ApplicationCommandInteractionDataOption) (m OptionsMap) {
m = make(OptionsMap, len(options))
for _, option := range options {
m[option.Name] = option
}
return
}
// MessageCtx is a context provided to message command handler. It contains the message
type MessageCtx struct {
*discordgo.Session
Caller *Command
Message *discordgo.Message
Arguments []string
remainingHandlers []MessageHandler
}
// Next calls the next middleware / command handler.
func (ctx *MessageCtx) Next() {
if len(ctx.remainingHandlers) == 0 {
return
}
handler := ctx.remainingHandlers[0]
ctx.remainingHandlers = ctx.remainingHandlers[1:]
handler.HandleMessageCommand(ctx)
}
// Reply sends and returns a simple (content-only) message replying to the command message. If mention is true the command author is mentioned in the reply.
// It is a wrapper for discordgo.Session.ChannelMessageSendReply.
func (ctx *MessageCtx) Reply(content string, mention bool) (*discordgo.Message, error) {
return ctx.ReplyComplex(&discordgo.MessageSend{
Content: content,
}, mention)
}
// ReplyComplex sends and returns a complex (with embds, attachments, etc) message replying to the command message.
// If mention is true the command author is mentioned in the reply. It is a wrapper for discordgo.Session.ChannelMessageSendComplex
func (ctx *MessageCtx) ReplyComplex(message *discordgo.MessageSend, mention bool) (*discordgo.Message, error) {
message.Reference = ctx.Message.Reference()
// TODO: https://github.com/bwmarrin/discordgo/pull/1009
// message.AllowedMentions.RepliedUser = mention
return ctx.Session.ChannelMessageSendComplex(ctx.Message.ChannelID, message)
}
// NewMessageCtx constructs context from a message.
// If argdelim is not empty it is a delimiter for the arguments, otherwise the arguments are split by a space.
func NewMessageCtx(s *discordgo.Session, caller *Command, m *discordgo.Message, arguments []string, handlers []MessageHandler) *MessageCtx {
return &MessageCtx{
Session: s,
Caller: caller,
Message: m,
Arguments: arguments,
remainingHandlers: handlers,
}
}