2016-01-17 18:00:44 +00:00
|
|
|
// © 2013 the CatBase Authors under the WTFPL. See AUTHORS for the list of authors.
|
2013-12-10 23:37:07 +00:00
|
|
|
|
2016-03-24 17:32:40 +00:00
|
|
|
package first
|
2013-01-25 21:33:41 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
2021-12-20 17:40:10 +00:00
|
|
|
bh "github.com/timshannon/bolthold"
|
2016-01-15 06:12:26 +00:00
|
|
|
"regexp"
|
2013-01-25 21:33:41 +00:00
|
|
|
"strings"
|
|
|
|
"time"
|
2016-01-15 06:12:26 +00:00
|
|
|
|
2019-03-07 16:35:42 +00:00
|
|
|
"github.com/rs/zerolog/log"
|
2021-07-03 17:07:03 +00:00
|
|
|
"github.com/velour/catbase/config"
|
2021-02-04 01:35:56 +00:00
|
|
|
|
2016-01-17 18:00:44 +00:00
|
|
|
"github.com/velour/catbase/bot"
|
2016-04-01 14:20:03 +00:00
|
|
|
"github.com/velour/catbase/bot/msg"
|
2013-01-25 21:33:41 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// This is a first plugin to serve as an example and quick copy/paste for new plugins.
|
|
|
|
|
|
|
|
type FirstPlugin struct {
|
2021-02-04 01:35:56 +00:00
|
|
|
bot bot.Bot
|
2021-07-03 17:07:03 +00:00
|
|
|
config *config.Config
|
2021-12-20 17:40:10 +00:00
|
|
|
store *bh.Store
|
2021-02-04 01:35:56 +00:00
|
|
|
handlers bot.HandlerTable
|
|
|
|
enabled bool
|
2013-01-25 21:33:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type FirstEntry struct {
|
2021-12-21 04:31:19 +00:00
|
|
|
ID uint64 `boltholdKey:"ID"`
|
|
|
|
Day time.Time
|
|
|
|
Time time.Time
|
|
|
|
Channel string
|
|
|
|
Body string
|
|
|
|
Nick string
|
|
|
|
Saved bool
|
2016-01-15 16:54:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Insert or update the first entry
|
2021-12-20 17:40:10 +00:00
|
|
|
func (fe *FirstEntry) save(store *bh.Store) error {
|
|
|
|
return store.Insert(bh.NextSequence(), fe)
|
2013-01-25 21:33:41 +00:00
|
|
|
}
|
|
|
|
|
2021-12-20 17:40:10 +00:00
|
|
|
func (fe *FirstEntry) delete(store *bh.Store) error {
|
2021-12-21 04:31:19 +00:00
|
|
|
return store.Delete(fe.ID, FirstEntry{})
|
2021-02-04 01:35:56 +00:00
|
|
|
}
|
|
|
|
|
2013-01-25 21:33:41 +00:00
|
|
|
// NewFirstPlugin creates a new FirstPlugin with the Plugin interface
|
2016-03-30 14:00:20 +00:00
|
|
|
func New(b bot.Bot) *FirstPlugin {
|
2021-12-21 04:31:19 +00:00
|
|
|
log.Info().Msgf("First plugin initialized with Day: %s",
|
2021-04-27 16:36:34 +00:00
|
|
|
Midnight(time.Now()))
|
2016-01-15 16:54:09 +00:00
|
|
|
|
2019-02-05 19:41:38 +00:00
|
|
|
fp := &FirstPlugin{
|
2021-02-04 01:35:56 +00:00
|
|
|
bot: b,
|
2021-07-03 17:07:03 +00:00
|
|
|
config: b.Config(),
|
2021-12-20 17:40:10 +00:00
|
|
|
store: b.Store(),
|
2021-02-04 01:35:56 +00:00
|
|
|
enabled: true,
|
2013-01-25 21:33:41 +00:00
|
|
|
}
|
2021-02-04 01:35:56 +00:00
|
|
|
fp.register()
|
2019-02-05 19:41:38 +00:00
|
|
|
b.Register(fp, bot.Help, fp.help)
|
|
|
|
return fp
|
2013-01-25 21:33:41 +00:00
|
|
|
}
|
|
|
|
|
2021-12-20 17:40:10 +00:00
|
|
|
func getLastFirst(store *bh.Store, channel string) (*FirstEntry, error) {
|
|
|
|
fe := &FirstEntry{}
|
2021-12-21 19:08:20 +00:00
|
|
|
err := store.FindOne(fe, bh.Where("Channel").Eq(channel).SortBy("Day").Reverse())
|
2021-12-20 17:40:10 +00:00
|
|
|
if err != nil {
|
2018-06-22 18:31:33 +00:00
|
|
|
return nil, err
|
2016-01-15 16:54:09 +00:00
|
|
|
}
|
2021-12-21 19:08:20 +00:00
|
|
|
log.Debug().Msgf("getLastFirst: %+v", fe)
|
2021-12-20 17:40:10 +00:00
|
|
|
return fe, nil
|
2016-01-15 16:54:09 +00:00
|
|
|
}
|
|
|
|
|
2021-04-27 16:36:34 +00:00
|
|
|
func Midnight(t time.Time) time.Time {
|
2013-01-25 21:33:41 +00:00
|
|
|
y, m, d := t.Date()
|
2021-04-27 16:36:34 +00:00
|
|
|
return time.Date(y, m, d, 0, 0, 0, 0, time.Local)
|
2013-01-25 21:33:41 +00:00
|
|
|
}
|
|
|
|
|
2021-07-03 17:07:03 +00:00
|
|
|
func (p *FirstPlugin) isNotToday(f *FirstEntry) bool {
|
2019-06-06 14:33:50 +00:00
|
|
|
if f == nil {
|
|
|
|
return true
|
|
|
|
}
|
2021-12-21 04:31:19 +00:00
|
|
|
t := f.Time
|
2021-04-27 16:36:34 +00:00
|
|
|
t0 := Midnight(t)
|
2021-07-03 17:07:03 +00:00
|
|
|
jitter := time.Duration(p.config.GetInt("first.jitter", 0))
|
2021-07-21 13:54:29 +00:00
|
|
|
t0 = t0.Add(jitter * time.Millisecond)
|
2021-04-27 16:36:34 +00:00
|
|
|
return t0.Before(Midnight(time.Now()))
|
2013-01-25 21:33:41 +00:00
|
|
|
}
|
|
|
|
|
2021-02-04 01:35:56 +00:00
|
|
|
func (p *FirstPlugin) register() {
|
|
|
|
p.handlers = []bot.HandlerSpec{
|
|
|
|
{Kind: bot.Message, IsCmd: false,
|
|
|
|
Regex: regexp.MustCompile(`(?i)^who'?s on first the most.?$`),
|
|
|
|
Handler: func(r bot.Request) bool {
|
2021-12-20 17:40:10 +00:00
|
|
|
first, err := getLastFirst(p.store, r.Msg.Channel)
|
2021-02-04 01:35:56 +00:00
|
|
|
if first != nil && err == nil {
|
|
|
|
p.leaderboard(r.Conn, r.Msg.Channel)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}},
|
|
|
|
{Kind: bot.Message, IsCmd: false,
|
|
|
|
Regex: regexp.MustCompile(`(?i)^who'?s on first.?$`),
|
|
|
|
Handler: func(r bot.Request) bool {
|
2021-12-20 17:40:10 +00:00
|
|
|
first, err := getLastFirst(p.store, r.Msg.Channel)
|
2021-02-04 01:35:56 +00:00
|
|
|
if first != nil && err == nil {
|
|
|
|
p.announceFirst(r.Conn, first)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}},
|
|
|
|
{Kind: bot.Message, IsCmd: true,
|
|
|
|
Regex: regexp.MustCompile(`(?i)^clear first$`),
|
|
|
|
Handler: func(r bot.Request) bool {
|
|
|
|
if !p.bot.CheckAdmin(r.Msg.User.Name) {
|
|
|
|
p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "You are not authorized to do that.")
|
|
|
|
return true
|
|
|
|
}
|
2021-12-20 17:40:10 +00:00
|
|
|
fe, err := getLastFirst(p.store, r.Msg.Channel)
|
2021-02-04 01:35:56 +00:00
|
|
|
if err != nil {
|
|
|
|
p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "Could not find a first entry.")
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
p.enabled = false
|
2021-12-20 17:40:10 +00:00
|
|
|
err = fe.delete(p.store)
|
2021-02-04 01:35:56 +00:00
|
|
|
if err != nil {
|
|
|
|
p.bot.Send(r.Conn, bot.Message, r.Msg.Channel,
|
|
|
|
fmt.Sprintf("Could not delete first entry: %s", err))
|
|
|
|
p.enabled = true
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
d := p.bot.Config().GetInt("first.maxregen", 300)
|
|
|
|
log.Debug().Msgf("Setting first timer for %d seconds", d)
|
|
|
|
timer := time.NewTimer(time.Duration(d) * time.Second)
|
|
|
|
go func() {
|
|
|
|
<-timer.C
|
|
|
|
p.enabled = true
|
|
|
|
log.Debug().Msgf("Re-enabled first")
|
|
|
|
}()
|
|
|
|
p.bot.Send(r.Conn, bot.Message, r.Msg.Channel,
|
2021-12-21 04:31:19 +00:00
|
|
|
fmt.Sprintf("Deleted first entry: '%s' and set a random timer for when first will happen next.", fe.Body))
|
2021-02-04 01:35:56 +00:00
|
|
|
return true
|
|
|
|
}},
|
|
|
|
{Kind: bot.Message, IsCmd: false,
|
|
|
|
Regex: regexp.MustCompile(`.*`),
|
|
|
|
Handler: func(r bot.Request) bool {
|
2021-08-26 14:03:22 +00:00
|
|
|
if r.Msg.IsIM || !p.enabled || !p.enabled_channel(r) {
|
2021-02-04 01:35:56 +00:00
|
|
|
return false
|
|
|
|
}
|
2019-06-06 14:33:50 +00:00
|
|
|
|
2021-12-20 17:40:10 +00:00
|
|
|
first, err := getLastFirst(p.store, r.Msg.Channel)
|
2021-02-04 01:35:56 +00:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Err(err).
|
|
|
|
Msg("Error getting last first")
|
|
|
|
}
|
2019-06-06 14:33:50 +00:00
|
|
|
|
2021-02-04 01:35:56 +00:00
|
|
|
log.Debug().Bool("first == nil", first == nil).Msg("Is first nil?")
|
2021-07-03 17:07:03 +00:00
|
|
|
log.Debug().Bool("first == nil || isNotToday()", p.isNotToday(first)).Msg("Is it today?")
|
2021-02-04 01:35:56 +00:00
|
|
|
log.Debug().Bool("p.allowed", p.allowed(r.Msg)).Msg("Allowed?")
|
2013-01-25 21:33:41 +00:00
|
|
|
|
2021-07-03 17:07:03 +00:00
|
|
|
if (first == nil || p.isNotToday(first)) && p.allowed(r.Msg) {
|
2021-02-04 01:35:56 +00:00
|
|
|
log.Debug().
|
2021-12-21 04:31:19 +00:00
|
|
|
Str("Body", r.Msg.Body).
|
2021-02-04 01:35:56 +00:00
|
|
|
Interface("t0", first).
|
|
|
|
Time("t1", time.Now()).
|
|
|
|
Msg("Recording first")
|
|
|
|
p.recordFirst(r.Conn, r.Msg)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}},
|
2019-10-26 15:26:31 +00:00
|
|
|
}
|
2021-02-04 01:35:56 +00:00
|
|
|
p.bot.RegisterTable(p, p.handlers)
|
2013-01-25 21:33:41 +00:00
|
|
|
}
|
|
|
|
|
2021-08-26 14:03:22 +00:00
|
|
|
func (p *FirstPlugin) enabled_channel(r bot.Request) bool {
|
|
|
|
chs := p.config.GetArray("first.channels", []string{})
|
|
|
|
for _, ch := range chs {
|
|
|
|
if r.Msg.Channel == ch {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2016-04-01 14:20:03 +00:00
|
|
|
func (p *FirstPlugin) allowed(message msg.Message) bool {
|
2020-10-20 01:28:13 +00:00
|
|
|
if message.Body == "" {
|
|
|
|
return false
|
|
|
|
}
|
2021-02-04 01:35:56 +00:00
|
|
|
for _, m := range p.bot.Config().GetArray("Bad.Msgs", []string{}) {
|
2019-06-06 14:33:50 +00:00
|
|
|
match, err := regexp.MatchString(m, strings.ToLower(message.Body))
|
2016-01-15 06:12:26 +00:00
|
|
|
if err != nil {
|
2019-03-07 16:35:42 +00:00
|
|
|
log.Error().Err(err).Msg("Bad regexp")
|
2016-01-15 06:12:26 +00:00
|
|
|
}
|
|
|
|
if match {
|
2019-03-07 16:35:42 +00:00
|
|
|
log.Info().
|
|
|
|
Str("user", message.User.Name).
|
2021-12-21 04:31:19 +00:00
|
|
|
Str("Body", message.Body).
|
2019-03-07 16:35:42 +00:00
|
|
|
Msg("Disallowing first")
|
2013-03-30 11:12:27 +00:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
2021-02-04 01:35:56 +00:00
|
|
|
for _, host := range p.bot.Config().GetArray("Bad.Hosts", []string{}) {
|
2013-04-21 20:49:00 +00:00
|
|
|
if host == message.Host {
|
2019-03-07 16:35:42 +00:00
|
|
|
log.Info().
|
|
|
|
Str("user", message.User.Name).
|
2021-12-21 04:31:19 +00:00
|
|
|
Str("Body", message.Body).
|
2019-03-07 16:35:42 +00:00
|
|
|
Msg("Disallowing first")
|
2013-04-21 20:49:00 +00:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
2021-02-04 01:35:56 +00:00
|
|
|
for _, nick := range p.bot.Config().GetArray("Bad.Nicks", []string{}) {
|
2013-04-21 20:49:00 +00:00
|
|
|
if nick == message.User.Name {
|
2019-03-07 16:35:42 +00:00
|
|
|
log.Info().
|
|
|
|
Str("user", message.User.Name).
|
2021-12-21 04:31:19 +00:00
|
|
|
Str("Body", message.Body).
|
2019-03-07 16:35:42 +00:00
|
|
|
Msg("Disallowing first")
|
2013-04-21 20:49:00 +00:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
2013-03-30 11:12:27 +00:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2019-05-27 23:21:53 +00:00
|
|
|
func (p *FirstPlugin) recordFirst(c bot.Connector, message msg.Message) {
|
2019-03-07 16:35:42 +00:00
|
|
|
log.Info().
|
2021-12-21 04:31:19 +00:00
|
|
|
Str("Channel", message.Channel).
|
2019-03-07 16:35:42 +00:00
|
|
|
Str("user", message.User.Name).
|
2021-12-21 04:31:19 +00:00
|
|
|
Str("Body", message.Body).
|
2019-03-07 16:35:42 +00:00
|
|
|
Msg("Recording first")
|
2019-06-06 14:33:50 +00:00
|
|
|
first := &FirstEntry{
|
2021-12-21 04:31:19 +00:00
|
|
|
Day: Midnight(time.Now()),
|
|
|
|
Time: time.Now(),
|
|
|
|
Channel: message.Channel,
|
|
|
|
Body: message.Body,
|
|
|
|
Nick: message.User.Name,
|
2016-01-15 16:54:09 +00:00
|
|
|
}
|
2021-12-21 04:31:19 +00:00
|
|
|
log.Info().Msgf("recordFirst: %+v", first.Day)
|
2021-12-20 17:40:10 +00:00
|
|
|
err := first.save(p.store)
|
2016-01-15 16:54:09 +00:00
|
|
|
if err != nil {
|
2019-03-07 16:35:42 +00:00
|
|
|
log.Error().Err(err).Msg("Error saving first entry")
|
2016-01-15 16:54:09 +00:00
|
|
|
return
|
2013-01-25 21:33:41 +00:00
|
|
|
}
|
2019-06-06 14:33:50 +00:00
|
|
|
p.announceFirst(c, first)
|
2013-01-25 21:33:41 +00:00
|
|
|
}
|
|
|
|
|
2019-10-26 15:26:31 +00:00
|
|
|
func (p *FirstPlugin) leaderboard(c bot.Connector, ch string) error {
|
2021-12-20 17:40:10 +00:00
|
|
|
// todo: remove this once we verify stuff
|
2021-12-21 04:31:19 +00:00
|
|
|
//q := `select max(Channel) Channel, max(Nick) Nick, count(ID) count
|
2021-12-20 17:40:10 +00:00
|
|
|
// from first
|
2021-12-21 04:31:19 +00:00
|
|
|
// group by Channel, Nick
|
|
|
|
// having Channel = ?
|
2021-12-20 17:40:10 +00:00
|
|
|
// order by count desc
|
|
|
|
// limit 3`
|
2021-12-21 04:31:19 +00:00
|
|
|
groups, err := p.store.FindAggregate(FirstEntry{}, bh.Where("Channel").Eq(ch), "Channel", "Nick")
|
2019-10-26 15:26:31 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2021-12-20 17:40:10 +00:00
|
|
|
if len(groups) != 1 {
|
|
|
|
return fmt.Errorf("found %d groups but expected 1", len(groups))
|
2019-10-26 15:26:31 +00:00
|
|
|
}
|
2021-12-20 17:40:10 +00:00
|
|
|
//res := groups[0]
|
|
|
|
//talismans := []string{":gold-trophy:", ":silver-trophy:", ":bronze-trophy:"}
|
|
|
|
//msg := "First leaderboard:\n"
|
|
|
|
//n := res.Count()
|
|
|
|
//fe := FirstEntry{}
|
|
|
|
//
|
|
|
|
//for i, e := range res {
|
|
|
|
// msg += fmt.Sprintf("%s %d %s\n", talismans[i], e.Count, e.Nick)
|
|
|
|
//}
|
|
|
|
//p.bot.Send(c, bot.Message, ch, msg)
|
|
|
|
// todo: care about this
|
2019-10-26 15:26:31 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-06 14:33:50 +00:00
|
|
|
func (p *FirstPlugin) announceFirst(c bot.Connector, first *FirstEntry) {
|
2021-12-21 04:31:19 +00:00
|
|
|
ch := first.Channel
|
2021-02-04 01:35:56 +00:00
|
|
|
p.bot.Send(c, bot.Message, ch, fmt.Sprintf("%s had first at %s with the message: \"%s\"",
|
2021-12-21 04:31:19 +00:00
|
|
|
first.Nick, first.Time.Format("15:04"), first.Body))
|
2013-01-25 21:33:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Help responds to help requests. Every plugin must implement a help function.
|
2019-05-27 23:21:53 +00:00
|
|
|
func (p *FirstPlugin) help(c bot.Connector, kind bot.Kind, message msg.Message, args ...interface{}) bool {
|
2021-02-04 01:35:56 +00:00
|
|
|
p.bot.Send(c, bot.Message, message.Channel, "You can ask 'who's on first?' to find out.")
|
2019-02-05 19:41:38 +00:00
|
|
|
return true
|
2013-05-08 00:08:18 +00:00
|
|
|
}
|