ryanc/bb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactored handlers and command handlers

Browse Source
This commit is contained in:
Ryan Cavicchioni 2022-09-24 21:43:10 -05:00
parent 7a0c90a5f7
commit 39fec05ff4
Signed by: ryanc
GPG Key ID: 877EEDAF9245103D
25 changed files with 474 additions and 466 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
bot/bot.go
View File

@ -7,7 +7,9 @@ import (
"os/signal"
"syscall"
"git.kill0.net/chill9/beepboop/command"
"git.kill0.net/chill9/beepboop/config"
"git.kill0.net/chill9/beepboop/handler"
"git.kill0.net/chill9/beepboop/lib"
"github.com/bwmarrin/discordgo"
log "github.com/sirupsen/logrus"
@ -19,10 +21,19 @@ var C *config.Config
type (
Bot struct {
Session *discordgo.Session
Config *config.Config
config *config.Config
session *discordgo.Session
commands map[string]*Command
}
Command struct {
Name string
Func CommandFunc
NArgs int
}
CommandFunc func(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error
MessageHandler func(s *discordgo.Session, m *discordgo.MessageCreate)
)
@ -33,60 +44,110 @@ func init() {
viper.BindPFlags(pflag.CommandLine)
}
func NewBot(s *discordgo.Session, config *config.Config) *Bot {
return &Bot{Session: s, Config: config}
func NewBot(config *config.Config, s *discordgo.Session) *Bot {
return &Bot{
session: s,
commands: make(map[string]*Command),
}
}
func (b *Bot) RegisterCommands() {
AddCommand(&Command{
func (b *Bot) AddHandler(handler interface{}) func() {
return b.session.AddHandler(handler)
}
func (b *Bot) AddCommand(cmd *Command) {
b.commands[cmd.Name] = cmd
}
func (b *Bot) GetCommand(name string) (*Command, bool) {
cmd, ok := b.commands[name]
return cmd, ok
}
func (b *Bot) CommandHandler(s *discordgo.Session, m *discordgo.MessageCreate) {
if m.Author.ID == s.State.User.ID {
return
}
if !lib.HasCommand(m.Content, b.config.Prefix) {
return
}
cmdName, arg := lib.SplitCommandAndArg(m.Content, b.config.Prefix)
cmd, ok := b.GetCommand(cmdName)
if !ok {
return
}
args := lib.SplitArgs(arg, cmd.NArgs)
if ok {
log.Debugf("command: %v, args: %v, nargs: %d", cmd.Name, args, len(args))
if err := cmd.Func(args, s, m); err != nil {
log.Errorf("failed to execute command: %s", err)
}
return
}
log.Warnf("unknown command: %v, args: %v, nargs: %d", cmdName, args, len(args))
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("unknown command: %s", cmdName))
}
func (b *Bot) Init(h *handler.Handlers, ch *command.Handlers) {
// Register handlers
b.AddHandler(h.Reaction)
// Register commands
b.AddCommand(&Command{
Name: "coin",
Func: b.CoinCommand(),
Func: ch.Coin,
})
AddCommand(&Command{
b.AddCommand(&Command{
Name: "deal",
Func: b.DealCommand(),
Func: ch.Deal,
NArgs: 1,
})
AddCommand(&Command{
b.AddCommand(&Command{
Name: "ping",
Func: b.PingCommand(),
Func: ch.Ping,
})
AddCommand(&Command{
b.AddCommand(&Command{
Name: "roll",
Func: b.RollCommand(),
Func: ch.Roll,
NArgs: 1,
})
AddCommand(&Command{
b.AddCommand(&Command{
Name: "roulette",
Func: ch.Roulette,
})
b.AddCommand(&Command{
Name: "rps",
Func: b.RpsCommand(),
Func: ch.Rps,
NArgs: 1,
})
AddCommand(&Command{
b.AddCommand(&Command{
Name: "rpsls",
Func: b.RpslsCommand(),
Func: ch.Rpsls,
NArgs: 1,
})
AddCommand(&Command{
b.AddCommand(&Command{
Name: "time",
Func: b.TimeCommand(),
Func: ch.Time,
NArgs: 1,
})
AddCommand(&Command{
b.AddCommand(&Command{
Name: "version",
Func: b.VersionCommand(),
Func: ch.Version,
})
AddCommand(&Command{
b.AddCommand(&Command{
Name: "weather",
Func: b.WeatherCommand(),
Func: ch.Weather,
NArgs: 1,
})
}
func (b *Bot) RegisterHandlers() {
b.Session.AddHandler(b.CommandHandler())
b.Session.AddHandler(b.ReactionHandler())
}
func Run() error {
initConfig()
go reloadConfig()
@ -104,9 +165,8 @@ func Run() error {
return fmt.Errorf("error creating discord session: %v", err)
}
b := NewBot(dg, C)
b.RegisterHandlers()
b.RegisterCommands()
b := NewBot(C, dg)
b.Init(handler.NewHandlers(C), command.NewHandlers(C))
dg.Identify.Intents = discordgo.IntentsGuildMessages | discordgo.IntentsDirectMessages

31
bot/coin.go
View File

@ -1,31 +0,0 @@
package bot
import (
"git.kill0.net/chill9/beepboop/lib"
"github.com/bwmarrin/discordgo"
)
type Coin bool
func (c *Coin) Flip() bool {
*c = Coin(lib.Itob(lib.RandInt(0, 1)))
return bool(*c)
}
func (b *Bot) CoinCommand() CommandFunc {
return func(args []string, m *discordgo.MessageCreate) error {
var (
c Coin
msg string
)
if c.Flip() {
msg = "heads"
} else {
msg = "tails"
}
b.Session.ChannelMessageSend(m.ChannelID, msg)
return nil
}
}

91
bot/command.go
View File

@ -1,91 +0,0 @@
package bot
import (
"fmt"
"git.kill0.net/chill9/beepboop/config"
"git.kill0.net/chill9/beepboop/lib"
"github.com/bwmarrin/discordgo"
log "github.com/sirupsen/logrus"
)
var (
DefaultCommander *Commander
)
type (
Commander struct {
commands map[string]*Command
}
Command struct {
Name string
Config *config.Config
Func CommandFunc
NArgs int
}
CommandFunc func(args []string, m *discordgo.MessageCreate) error
)
func init() {
DefaultCommander = NewCommander()
}
func NewCommander() *Commander {
cmdr := new(Commander)
cmdr.commands = make(map[string]*Command)
return cmdr
}
func (cmdr *Commander) AddCommand(cmd *Command) {
cmdr.commands[cmd.Name] = cmd
}
func (cmdr *Commander) GetCommand(name string) (*Command, bool) {
cmd, ok := cmdr.commands[name]
return cmd, ok
}
func AddCommand(cmd *Command) {
DefaultCommander.AddCommand(cmd)
}
func GetCommand(name string) (*Command, bool) {
cmd, ok := DefaultCommander.GetCommand(name)
return cmd, ok
}
func (b *Bot) CommandHandler() func(*discordgo.Session, *discordgo.MessageCreate) {
return func(s *discordgo.Session, m *discordgo.MessageCreate) {
var cmd *Command
if m.Author.ID == s.State.User.ID {
return
}
if !lib.HasCommand(m.Content, b.Config.Prefix) {
return
}
cmdName, arg := lib.SplitCommandAndArg(m.Content, b.Config.Prefix)
cmd, ok := GetCommand(cmdName)
args := lib.SplitArgs(arg, cmd.NArgs)
if ok {
cmd.Config = b.Config
log.Debugf("command: %v, args: %v, nargs: %d", cmd.Name, args, len(args))
if err := cmd.Func(args, m); err != nil {
log.Errorf("failed to execute command: %s", err)
}
return
}
log.Warnf("unknown command: %v, args: %v, nargs: %d", cmdName, args, len(args))
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("unknown command: %s", cmdName))
}
}

12
bot/ping.go
View File

@ -1,12 +0,0 @@
package bot
import (
"github.com/bwmarrin/discordgo"
)
func (b *Bot) PingCommand() CommandFunc {
return func(args []string, m *discordgo.MessageCreate) error {
b.Session.ChannelMessageSend(m.ChannelID, "pong")
return nil
}
}

52
bot/reaction.go
View File

@ -1,52 +0,0 @@
package bot
import (
"math/rand"
"strings"
"git.kill0.net/chill9/beepboop/lib"
"github.com/bwmarrin/discordgo"
log "github.com/sirupsen/logrus"
)
func (b *Bot) ReactionHandler() func(*discordgo.Session, *discordgo.MessageCreate) {
return func(s *discordgo.Session, m *discordgo.MessageCreate) {
if m.Author.ID == s.State.User.ID {
return
}
emojis := b.Config.Handler.Reaction.Emojis
channels := b.Config.Handler.Reaction.Channels
if len(emojis) == 0 {
log.Warning("emoji list is empty")
return
}
channel, err := s.Channel(m.ChannelID)
if err != nil {
log.Fatalf("unable to get channel name: %v", err)
}
if len(channels) > 0 && !lib.Contains(channels, channel.Name) {
return
}
for _, a := range m.Attachments {
if strings.HasPrefix(a.ContentType, "image/") {
for i := 1; i <= lib.RandInt(1, len(emojis)); i++ {
r := emojis[rand.Intn(len(emojis))]
s.MessageReactionAdd(m.ChannelID, m.ID, r)
}
}
}
for range m.Embeds {
for i := 1; i <= lib.RandInt(1, len(emojis)); i++ {
r := emojis[rand.Intn(len(emojis))]
s.MessageReactionAdd(m.ChannelID, m.ID, r)
}
}
}
}

36
bot/rps.go
View File

@ -1,36 +0,0 @@
package bot
import (
"strings"
"git.kill0.net/chill9/beepboop/lib/rps"
"github.com/bwmarrin/discordgo"
)
func (b *Bot) RpsCommand() CommandFunc {
return func(args []string, m *discordgo.MessageCreate) error {
if len(args) != 1 {
b.Session.ChannelMessageSend(
m.ChannelID, "help: `!rps (rock | paper | scissors)`",
)
return nil
}
pc := strings.ToLower(args[0]) // player's choice
g := rps.NewGame(rps.RulesRps, rps.EmojiMapRps)
bc := g.Rand() // bot's choice
s, err := g.Play(bc, pc)
if _, ok := err.(rps.InvalidChoiceError); ok {
b.Session.ChannelMessageSend(
m.ChannelID, "help: `!rps (rock | paper | scissors)`",
)
}
b.Session.ChannelMessageSend(m.ChannelID, s)
return nil
}
}

36
bot/rpsls.go
View File

@ -1,36 +0,0 @@
package bot
import (
"strings"
"git.kill0.net/chill9/beepboop/lib/rps"
"github.com/bwmarrin/discordgo"
)
func (b *Bot) RpslsCommand() CommandFunc {
return func(args []string, m *discordgo.MessageCreate) error {
if len(args) != 1 {
b.Session.ChannelMessageSend(
m.ChannelID, "help: `!rps (rock | paper | scissors | lizard | spock)`",
)
return nil
}
pc := strings.ToLower(args[0]) // player's choice
g := rps.NewGame(rps.RulesRpsls, rps.EmojiMapRpsls)
bc := g.Rand() // bot's choice
s, err := g.Play(bc, pc)
if _, ok := err.(rps.InvalidChoiceError); ok {
b.Session.ChannelMessageSend(
m.ChannelID, "help: `!rps (rock | paper | scissors | lizard | spock)`",
)
}
b.Session.ChannelMessageSend(m.ChannelID, s)
return nil
}
}

36
bot/time.go
View File

@ -1,36 +0,0 @@
package bot
import (
"fmt"
"time"
"github.com/bwmarrin/discordgo"
log "github.com/sirupsen/logrus"
)
func (b *Bot) TimeCommand() CommandFunc {
return func(args []string, m *discordgo.MessageCreate) error {
var (
t time.Time
tz string
)
now := time.Now()
if len(args) == 1 {
tz = args[0]
loc, err := time.LoadLocation(tz)
if err != nil {
log.Warnf("failed to load location: %s", err)
b.Session.ChannelMessageSend(m.ChannelID, err.Error())
return nil
}
t = now.In(loc)
} else {
t = now
}
b.Session.ChannelMessageSend(m.ChannelID, fmt.Sprint(t))
return nil
}
}

25
bot/version.go
View File

@ -1,25 +0,0 @@
package bot
import (
"fmt"
"runtime"
"github.com/bwmarrin/discordgo"
)
const (
SourceURI = "https://git.kill0.net/chill9/bb"
)
func (b *Bot) VersionCommand() CommandFunc {
return func(args []string, m *discordgo.MessageCreate) error {
b.Session.ChannelMessageSend(m.ChannelID, fmt.Sprintf(
"go version: %s\nplatform: %s\nos: %s\nsource: %s\n",
runtime.Version(),
runtime.GOARCH,
runtime.GOOS,
SourceURI,
))
return nil
}
}

56
bot/weather.go
View File

@ -1,56 +0,0 @@
package bot
import (
"fmt"
"git.kill0.net/chill9/beepboop/lib/weather"
"github.com/bwmarrin/discordgo"
log "github.com/sirupsen/logrus"
)
func (b *Bot) WeatherCommand() CommandFunc {
return func(args []string, m *discordgo.MessageCreate) error {
var (
err error
loc string
w weather.Weather
)
if len(args) != 1 {
b.Session.ChannelMessageSend(m.ChannelID, "help: `!weather <CITY>,<STATE>,<COUNTRY>`")
return nil
}
loc = args[0]
if b.Config.OpenWeatherMapToken == "" {
log.Error("OpenWeather token is not set")
return nil
}
wc := weather.NewClient(b.Config.OpenWeatherMapToken)
log.Debugf("weather requested for '%s'", loc)
w, err = wc.Get(loc)
if err != nil {
log.Errorf("weather client error: %v", err)
return nil
}
log.Debugf("weather returned for '%s': %+v", loc, w)
b.Session.ChannelMessageSend(m.ChannelID, fmt.Sprintf(
"%s (%.1f, %.1f) — C:%.1f F:%.1f K:%.1f",
loc,
w.Coord.Lat,
w.Coord.Lon,
w.Main.Temp.Celcius(),
w.Main.Temp.Fahrenheit(),
w.Main.Temp.Kelvin(),
))
return nil
}
}

29
command/coin.go Normal file
View File

@ -0,0 +1,29 @@
package command
import (
"git.kill0.net/chill9/beepboop/lib"
"github.com/bwmarrin/discordgo"
)
type Coin bool
func (c *Coin) Flip() bool {
*c = Coin(lib.Itob(lib.RandInt(0, 1)))
return bool(*c)
}
func (h *Handlers) Coin(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
var (
c Coin
msg string
)
if c.Flip() {
msg = "heads"
} else {
msg = "tails"
}
s.ChannelMessageSend(m.ChannelID, msg)
return nil
}

11
command/commands.go Normal file
View File

@ -0,0 +1,11 @@
package command
import "git.kill0.net/chill9/beepboop/config"
type Handlers struct {
config *config.Config
}
func NewHandlers(config *config.Config) *Handlers {
return &Handlers{config: config}
}

12
bot/deal.go → command/deal.go
View File

@ -1,4 +1,4 @@
package bot
package command
import (
"errors"
@ -45,8 +45,7 @@ func (d *Deck) Deal(n int) ([]Card, error) {
return hand, err
}
func (b *Bot) DealCommand() CommandFunc {
return func(args []string, m *discordgo.MessageCreate) error {
func (h *Handlers) Deal(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
rand.Shuffle(len(deck), func(i, j int) {
deck[i], deck[j] = deck[j], deck[i]
})
@ -54,7 +53,7 @@ func (b *Bot) DealCommand() CommandFunc {
log.Debugf("%+v", deck)
if len(args) != 1 {
b.Session.ChannelMessageSend(m.ChannelID, "help: `!deal <n>`")
s.ChannelMessageSend(m.ChannelID, "help: `!deal <n>`")
return nil
}
@ -65,13 +64,12 @@ func (b *Bot) DealCommand() CommandFunc {
hand, err := deck.Deal(n)
if err != nil {
b.Session.ChannelMessageSend(m.ChannelID, fmt.Sprintf("error: %s\n", err))
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("error: %s\n", err))
return nil
}
b.Session.ChannelMessageSend(m.ChannelID, JoinCards(hand, " "))
s.ChannelMessageSend(m.ChannelID, JoinCards(hand, " "))
return nil
}
}
func JoinCards(h []Card, sep string) string {

10
bot/dice.go → command/dice.go
View File

@ -1,4 +1,4 @@
package bot
package command
import (
"errors"
@ -78,8 +78,7 @@ func (r *Roll) RollDice() {
}
}
func (b *Bot) RollCommand() CommandFunc {
return func(args []string, m *discordgo.MessageCreate) error {
func (h *Handlers) Roll(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
var (
err error
msg, roll string
@ -90,7 +89,7 @@ func (b *Bot) RollCommand() CommandFunc {
r, err = ParseRoll(roll)
if err != nil {
b.Session.ChannelMessageSend(m.ChannelID, err.Error())
s.ChannelMessageSend(m.ChannelID, err.Error())
return nil
}
@ -99,7 +98,6 @@ func (b *Bot) RollCommand() CommandFunc {
msg = fmt.Sprintf("🎲 %s = %d", lib.JoinInt(r.Rolls, " + "), r.Sum)
b.Session.ChannelMessageSend(m.ChannelID, msg)
s.ChannelMessageSend(m.ChannelID, msg)
return nil
}
}

10
command/ping.go Normal file
View File

@ -0,0 +1,10 @@
package command
import (
"github.com/bwmarrin/discordgo"
)
func (h *Handlers) Ping(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
s.ChannelMessageSend(m.ChannelID, "pong")
return nil
}

10
bot/roulette.go → command/roulette.go
View File

@ -1,4 +1,4 @@
package bot
package command
import (
"git.kill0.net/chill9/beepboop/lib"
@ -66,8 +66,7 @@ func (g *Gun) IsEmpty() bool {
return true
}
func (b *Bot) RouletteCommand() CommandFunc {
return func(args []string, m *discordgo.MessageCreate) error {
func (h *Handlers) Roulette(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
if gun.IsEmpty() {
gun.Load(Bullets)
log.Debugf("reloading gun: %+v\n", gun)
@ -75,10 +74,9 @@ func (b *Bot) RouletteCommand() CommandFunc {
log.Debugf("firing gun: %+v\n", gun)
if gun.Fire() {
b.Session.ChannelMessageSend(m.ChannelID, GunFireMessage)
s.ChannelMessageSend(m.ChannelID, GunFireMessage)
} else {
b.Session.ChannelMessageSend(m.ChannelID, GunClickMessage)
s.ChannelMessageSend(m.ChannelID, GunClickMessage)
}
return nil
}
}

34
command/router.go Normal file
View File

@ -0,0 +1,34 @@
package command
import (
"github.com/bwmarrin/discordgo"
)
type (
Router struct {
commands map[string]*Command
}
Command struct {
Name string
Func CommandFunc
NArgs int
}
CommandFunc func(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error
)
func NewRouter() *Router {
r := new(Router)
r.commands = make(map[string]*Command)
return r
}
func (r *Router) AddCommand(cmd *Command) {
r.commands[cmd.Name] = cmd
}
func (r *Router) GetCommand(name string) (*Command, bool) {
cmd, ok := r.commands[name]
return cmd, ok
}

34
command/rps.go Normal file
View File

@ -0,0 +1,34 @@
package command
import (
"strings"
"git.kill0.net/chill9/beepboop/lib/rps"
"github.com/bwmarrin/discordgo"
)
func (h *Handlers) Rps(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
if len(args) != 1 {
s.ChannelMessageSend(
m.ChannelID, "help: `!rps (rock | paper | scissors)`",
)
return nil
}
pc := strings.ToLower(args[0]) // player's choice
g := rps.NewGame(rps.RulesRps, rps.EmojiMapRps)
bc := g.Rand() // bot's choice
out, err := g.Play(bc, pc)
if _, ok := err.(rps.InvalidChoiceError); ok {
s.ChannelMessageSend(
m.ChannelID, "help: `!rps (rock | paper | scissors)`",
)
}
s.ChannelMessageSend(m.ChannelID, out)
return nil
}

34
command/rpsls.go Normal file
View File

@ -0,0 +1,34 @@
package command
import (
"strings"
"git.kill0.net/chill9/beepboop/lib/rps"
"github.com/bwmarrin/discordgo"
)
func (h *Handlers) Rpsls(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
if len(args) != 1 {
s.ChannelMessageSend(
m.ChannelID, "help: `!rps (rock | paper | scissors | lizard | spock)`",
)
return nil
}
pc := strings.ToLower(args[0]) // player's choice
g := rps.NewGame(rps.RulesRpsls, rps.EmojiMapRpsls)
bc := g.Rand() // bot's choice
out, err := g.Play(bc, pc)
if _, ok := err.(rps.InvalidChoiceError); ok {
s.ChannelMessageSend(
m.ChannelID, "help: `!rps (rock | paper | scissors | lizard | spock)`",
)
}
s.ChannelMessageSend(m.ChannelID, out)
return nil
}

34
command/time.go Normal file
View File

@ -0,0 +1,34 @@
package command
import (
"fmt"
"time"
"github.com/bwmarrin/discordgo"
log "github.com/sirupsen/logrus"
)
func (h *Handlers) Time(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
var (
t time.Time
tz string
)
now := time.Now()
if len(args) == 1 {
tz = args[0]
loc, err := time.LoadLocation(tz)
if err != nil {
log.Warnf("failed to load location: %s", err)
s.ChannelMessageSend(m.ChannelID, err.Error())
return nil
}
t = now.In(loc)
} else {
t = now
}
s.ChannelMessageSend(m.ChannelID, fmt.Sprint(t))
return nil
}

23
command/version.go Normal file
View File

@ -0,0 +1,23 @@
package command
import (
"fmt"
"runtime"
"github.com/bwmarrin/discordgo"
)
const (
SourceURI = "https://git.kill0.net/chill9/bb"
)
func (h *Handlers) Version(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf(
"go version: %s\nplatform: %s\nos: %s\nsource: %s\n",
runtime.Version(),
runtime.GOARCH,
runtime.GOOS,
SourceURI,
))
return nil
}

54
command/weather.go Normal file
View File

@ -0,0 +1,54 @@
package command
import (
"fmt"
"git.kill0.net/chill9/beepboop/lib/weather"
"github.com/bwmarrin/discordgo"
log "github.com/sirupsen/logrus"
)
func (h *Handlers) Weather(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
var (
err error
loc string
w weather.Weather
)
if len(args) != 1 {
s.ChannelMessageSend(m.ChannelID, "help: `!weather <CITY>,<STATE>,<COUNTRY>`")
return nil
}
loc = args[0]
if h.config.OpenWeatherMapToken == "" {
log.Error("OpenWeather token is not set")
return nil
}
wc := weather.NewClient(h.config.OpenWeatherMapToken)
log.Debugf("weather requested for '%s'", loc)
w, err = wc.Get(loc)
if err != nil {
log.Errorf("weather client error: %v", err)
return nil
}
log.Debugf("weather returned for '%s': %+v", loc, w)
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf(
"%s (%.1f, %.1f) — C:%.1f F:%.1f K:%.1f",
loc,
w.Coord.Lat,
w.Coord.Lon,
w.Main.Temp.Celcius(),
w.Main.Temp.Fahrenheit(),
w.Main.Temp.Kelvin(),
))
return nil
}

1
handler/command.go Normal file
View File

@ -0,0 +1 @@
package handler

15
handler/handlers.go Normal file
View File

@ -0,0 +1,15 @@
package handler
import (
"git.kill0.net/chill9/beepboop/config"
)
type Handlers struct {
config *config.Config
}
func NewHandlers(config *config.Config) *Handlers {
return &Handlers{
config: config,
}
}

50
handler/reaction.go Normal file
View File

@ -0,0 +1,50 @@
package handler
import (
"math/rand"
"strings"
"git.kill0.net/chill9/beepboop/lib"
"github.com/bwmarrin/discordgo"
log "github.com/sirupsen/logrus"
)
func (h *Handlers) Reaction(s *discordgo.Session, m *discordgo.MessageCreate) {
if m.Author.ID == s.State.User.ID {
return
}
emojis := h.config.Handler.Reaction.Emojis
channels := h.config.Handler.Reaction.Channels
if len(emojis) == 0 {
log.Warning("emoji list is empty")
return
}
channel, err := s.Channel(m.ChannelID)
if err != nil {
log.Fatalf("unable to get channel name: %v", err)
}
if len(channels) > 0 && !lib.Contains(channels, channel.Name) {
return
}
for _, a := range m.Attachments {
if strings.HasPrefix(a.ContentType, "image/") {
for i := 1; i <= lib.RandInt(1, len(emojis)); i++ {
r := emojis[rand.Intn(len(emojis))]
s.MessageReactionAdd(m.ChannelID, m.ID, r)
}
}
}
for range m.Embeds {
for i := 1; i <= lib.RandInt(1, len(emojis)); i++ {
r := emojis[rand.Intn(len(emojis))]
s.MessageReactionAdd(m.ChannelID, m.ID, r)
}
}
}