twitch-bot/internal/actors/punish/actor.go

347 lines
8.8 KiB
Go
Raw Normal View History

package punish
import (
"encoding/json"
"math"
"strconv"
"strings"
"sync"
"time"
"github.com/Luzifer/twitch-bot/plugins"
"github.com/go-irc/irc"
"github.com/pkg/errors"
)
const (
actorNamePunish = "punish"
actorNameResetPunish = "reset-punish"
moduleUUID = "44ab4646-ce50-4e16-9353-c1f0eb68962b"
oneWeek = 168 * time.Hour
)
var (
formatMessage plugins.MsgFormatter
ptrDefaultCooldown = func(v time.Duration) *time.Duration { return &v }(oneWeek)
ptrStringEmpty = func(v string) *string { return &v }("")
store plugins.StorageManager
storedObject = newStorage()
)
func Register(args plugins.RegistrationArguments) error {
formatMessage = args.FormatMessage
store = args.GetStorageManager()
args.RegisterActor(actorNamePunish, func() plugins.Actor { return &actorPunish{} })
args.RegisterActor(actorNameResetPunish, func() plugins.Actor { return &actorResetPunish{} })
args.RegisterActorDocumentation(plugins.ActionDocumentation{
Description: "Apply increasing punishments to user",
Name: "Punish User",
Type: actorNamePunish,
Fields: []plugins.ActionDocumentationField{
{
Default: "168h",
Description: "When to lower the punishment level after the last punishment",
Key: "cooldown",
Name: "Cooldown",
Optional: true,
SupportTemplate: false,
Type: plugins.ActionDocumentationFieldTypeDuration,
},
{
Default: "",
Description: "Actions for each punishment level (ban, delete, duration-value i.e. 1m)",
Key: "levels",
Name: "Levels",
Optional: false,
SupportTemplate: false,
Type: plugins.ActionDocumentationFieldTypeStringSlice,
},
{
Default: "",
Description: "Reason why the user was banned / timeouted",
Key: "reason",
Name: "Reason",
Optional: true,
SupportTemplate: false,
Type: plugins.ActionDocumentationFieldTypeString,
},
{
Default: "",
Description: "User to apply the action to",
Key: "user",
Name: "User",
Optional: false,
SupportTemplate: true,
Type: plugins.ActionDocumentationFieldTypeString,
},
{
Default: "",
Description: "Unique identifier for this punishment to differentiate between punishments in the same channel",
Key: "uuid",
Name: "UUID",
Optional: true,
SupportTemplate: false,
Type: plugins.ActionDocumentationFieldTypeString,
},
},
})
args.RegisterActorDocumentation(plugins.ActionDocumentation{
Description: "Reset punishment level for user",
Name: "Reset User Punishment",
Type: actorNameResetPunish,
Fields: []plugins.ActionDocumentationField{
{
Default: "",
Description: "User to reset the level for",
Key: "user",
Name: "User",
Optional: false,
SupportTemplate: true,
Type: plugins.ActionDocumentationFieldTypeString,
},
{
Default: "",
Description: "Unique identifier for this punishment to differentiate between punishments in the same channel",
Key: "uuid",
Name: "UUID",
Optional: true,
SupportTemplate: false,
Type: plugins.ActionDocumentationFieldTypeString,
},
},
})
return errors.Wrap(
store.GetModuleStore(moduleUUID, storedObject),
"loading module storage",
)
}
type (
actorPunish struct{}
actorResetPunish struct{}
levelConfig struct {
LastLevel int `json:"last_level"`
Executed time.Time `json:"executed"`
Cooldown time.Duration `json:"cooldown"`
}
storage struct {
ActiveLevels map[string]*levelConfig `json:"active_levels"`
lock sync.Mutex
}
)
// Punish
func (a actorPunish) Execute(c *irc.Client, m *irc.Message, r *plugins.Rule, eventData *plugins.FieldCollection, attrs *plugins.FieldCollection) (preventCooldown bool, err error) {
var (
cooldown = attrs.MustDuration("cooldown", ptrDefaultCooldown)
reason = attrs.MustString("reason", ptrStringEmpty)
user = attrs.MustString("user", nil)
uuid = attrs.MustString("uuid", ptrStringEmpty)
)
levels, err := attrs.StringSlice("levels")
if err != nil {
return false, errors.Wrap(err, "getting level config")
}
if user, err = formatMessage(user, m, r, eventData); err != nil {
return false, errors.Wrap(err, "preparing user")
}
lvl := storedObject.GetPunishment(plugins.DeriveChannel(m, eventData), user, uuid)
nLvl := int(math.Min(float64(len(levels)-1), float64(lvl.LastLevel+1)))
var cmd []string
switch lt := levels[nLvl]; lt {
case "ban":
cmd = []string{"/ban", strings.TrimLeft(user, "@")}
if reason != "" {
cmd = append(cmd, reason)
}
case "delete":
msgID, ok := m.Tags.GetTag("id")
if !ok || msgID == "" {
return false, errors.New("found no mesage id")
}
cmd = []string{"/delete", msgID}
default:
to, err := time.ParseDuration(lt)
if err != nil {
return false, errors.Wrap(err, "parsing punishment level")
}
cmd = []string{"/timeout", strings.TrimLeft(user, "@"), strconv.FormatInt(int64(to/time.Second), 10)}
if reason != "" {
cmd = append(cmd, reason)
}
}
if err := c.WriteMessage(&irc.Message{
Command: "PRIVMSG",
Params: []string{
plugins.DeriveChannel(m, eventData),
strings.Join(cmd, " "),
},
}); err != nil {
return false, errors.Wrap(err, "sending command")
}
lvl.Cooldown = cooldown
lvl.Executed = time.Now()
lvl.LastLevel = nLvl
return false, errors.Wrap(
store.SetModuleStore(moduleUUID, storedObject),
"storing punishment level",
)
}
func (a actorPunish) IsAsync() bool { return false }
func (a actorPunish) Name() string { return actorNamePunish }
func (a actorPunish) Validate(attrs *plugins.FieldCollection) (err error) {
if v, err := attrs.String("user"); err != nil || v == "" {
return errors.New("user must be non-empty string")
}
if v, err := attrs.StringSlice("levels"); err != nil || len(v) == 0 {
return errors.New("levels must be slice of strings with length > 0")
}
return nil
}
// Reset
func (a actorResetPunish) Execute(c *irc.Client, m *irc.Message, r *plugins.Rule, eventData *plugins.FieldCollection, attrs *plugins.FieldCollection) (preventCooldown bool, err error) {
var (
user = attrs.MustString("user", nil)
uuid = attrs.MustString("uuid", ptrStringEmpty)
)
if user, err = formatMessage(user, m, r, eventData); err != nil {
return false, errors.Wrap(err, "preparing user")
}
storedObject.ResetLevel(plugins.DeriveChannel(m, eventData), user, uuid)
return false, errors.Wrap(
store.SetModuleStore(moduleUUID, storedObject),
"resetting punishment level",
)
}
func (a actorResetPunish) IsAsync() bool { return false }
func (a actorResetPunish) Name() string { return actorNameResetPunish }
func (a actorResetPunish) Validate(attrs *plugins.FieldCollection) (err error) {
if v, err := attrs.String("user"); err != nil || v == "" {
return errors.New("user must be non-empty string")
}
return nil
}
// Storage
func newStorage() *storage {
return &storage{
ActiveLevels: make(map[string]*levelConfig),
}
}
func (s *storage) GetPunishment(channel, user, uuid string) *levelConfig {
s.lock.Lock()
defer s.lock.Unlock()
// Ensure old state is cleared
s.calculateCooldowns()
var (
id = s.getCacheKey(channel, user, uuid)
lvl = s.ActiveLevels[id]
)
if lvl == nil {
// Initialize a non-triggered state
lvl = &levelConfig{LastLevel: -1}
s.ActiveLevels[id] = lvl
}
return lvl
}
func (s *storage) ResetLevel(channel, user, uuid string) {
s.lock.Lock()
defer s.lock.Unlock()
delete(s.ActiveLevels, s.getCacheKey(channel, user, uuid))
}
func (s *storage) getCacheKey(channel, user, uuid string) string {
return strings.Join([]string{channel, user, uuid}, "::")
}
func (s *storage) calculateCooldowns() {
// This MUST NOT be locked, the lock MUST be set by calling method
var clear []string
for id, lvl := range s.ActiveLevels {
for {
cooldownTime := lvl.Executed.Add(lvl.Cooldown)
if cooldownTime.After(time.Now()) {
break
}
lvl.Executed = cooldownTime
lvl.LastLevel--
}
// Level 0 is the first punishment level, so only remove if it drops below 0
if lvl.LastLevel < 0 {
clear = append(clear, id)
}
}
for _, id := range clear {
delete(s.ActiveLevels, id)
}
}
// Implement marshaller interfaces
func (s *storage) MarshalStoredObject() ([]byte, error) {
s.lock.Lock()
defer s.lock.Unlock()
s.calculateCooldowns()
return json.Marshal(s)
}
func (s *storage) UnmarshalStoredObject(data []byte) error {
if data == nil {
// No data set yet, don't try to unmarshal
return nil
}
s.lock.Lock()
defer s.lock.Unlock()
return json.Unmarshal(data, s)
}