Merge branch 'main' into feat/xp-boostfeat/xp-boost

3 files changed, 61 insertions, 64 deletions

diff --git a/user/level.go b/user/level.go
index be7d212..4303b47 100644
--- a/user/level.go
+++ b/user/level.go
@@ -8,71 +8,70 @@ import (
 	"git.anhgelus.world/anhgelus/les-copaings-bot/config"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/exp"
 	"github.com/anhgelus/gokord"
-	"github.com/anhgelus/gokord/logger"
 	discordgo "github.com/nyttikord/gokord"
+	"github.com/nyttikord/gokord/bot"
+	"github.com/nyttikord/gokord/user"
 )
 
-func onNewLevel(dg *discordgo.Session, m *discordgo.Member, level uint) {
+func onNewLevel(s bot.Session, m *user.Member, level uint) {
 	cfg := config.GetGuildConfig(m.GuildID)
 	xpForLevel := exp.LevelXP(level)
 	for _, role := range cfg.XpRoles {
 		if role.XP <= xpForLevel && !slices.Contains(m.Roles, role.RoleID) {
-			logger.Debug(
-				"Add role",
-				"role_id", role.RoleID,
-				"user_id", m.User.ID,
-				"guild_id", m.GuildID,
-			)
-			err := dg.GuildMemberRoleAdd(m.GuildID, m.User.ID, role.RoleID)
+			s.Logger().Debug("add role", "role", role.RoleID, "user", m.DisplayName(), "guild", m.GuildID)
+			err := s.GuildAPI().MemberRoleAdd(m.GuildID, m.User.ID, role.RoleID)
 			if err != nil {
-				logger.Alert("user/level.go - Adding role", err.Error(), "role_id", role.RoleID)
+				s.Logger().Error(
+					"adding role",
+					"error", err,
+					"role", role.RoleID,
+					"user", m.DisplayName(),
+					"guild", m.GuildID,
+				)
 			}
 		} else if role.XP > xpForLevel && slices.Contains(m.Roles, role.RoleID) {
-			logger.Debug(
-				"Remove role",
-				"role_id", role.RoleID,
-				"user_id", m.User.ID,
-				"guild_id", m.GuildID,
-			)
-			err := dg.GuildMemberRoleRemove(m.GuildID, m.User.ID, role.RoleID)
+			s.Logger().Debug("remove role", "role", role.RoleID, "user", m.DisplayName(), "guild", m.GuildID)
+			err := s.GuildAPI().MemberRoleRemove(m.GuildID, m.User.ID, role.RoleID)
 			if err != nil {
-				logger.Alert("user/level.go - Removing role", err.Error(), "role_id", role.RoleID)
+				s.Logger().Error(
+					"removing role",
+					"error", err,
+					"role", role.RoleID,
+					"user", m.DisplayName(),
+					"guild", m.GuildID,
+				)
 			}
 		}
 	}
 }
 
-func (c *Copaing) OnNewLevel(dg *discordgo.Session, level uint) {
-	m, err := dg.GuildMember(c.GuildID, c.DiscordID)
+func (c *Copaing) OnNewLevel(s *discordgo.Session, level uint) {
+	m, err := s.GuildAPI().Member(c.GuildID, c.DiscordID)
 	if err != nil {
-		logger.Alert(
-			"user/level.go - Getting member for new level", err.Error(),
-			"discord_id", c.DiscordID,
-			"guild_id", c.GuildID,
-		)
+		s.Logger().Error("getting member for new level", "error", err, "user", c.DiscordID, "guild", c.GuildID)
 		return
 	}
-	onNewLevel(dg, m, level)
+	onNewLevel(s, m, level)
 }
 
-func PeriodicReducer(dg *discordgo.Session) {
+func PeriodicReducer(s *discordgo.Session) {
 	wg := &sync.WaitGroup{}
 	var cs []*Copaing
 	if err := gokord.DB.Find(&cs).Error; err != nil {
-		logger.Alert("user/level.go - Fetching all copaings", err.Error())
+		s.Logger().Error("fetching all copaings", "error", err)
 		return
 	}
 	cxps := make([]*cXP, len(cs))
 	for i, c := range cs {
-		if i%10 == 9 {
+		if i%25 == 24 {
 			wg.Wait() // prevents spamming the DB
 		}
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			xp, err := c.GetXP()
+			xp, err := c.GetXP(s.Logger())
 			if err != nil {
-				logger.Alert("user/level.go - Getting XP", err.Error(), "copaing_id", c.ID, "guild_id", c.GuildID)
+				s.Logger().Error("getting xp", "error", err, "copaing", c.ID, "guild", c.GuildID)
 				xp = 0
 			}
 			cxps[i] = &cXP{
@@ -82,7 +81,9 @@ func PeriodicReducer(dg *discordgo.Session) {
 		}()
 	}
 	wg.Wait()
-	for _, g := range dg.State.Guilds {
+	i := 0
+	for g := range s.GuildAPI().State.Guilds() {
+		i++
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
@@ -92,26 +93,26 @@ func PeriodicReducer(dg *discordgo.Session) {
 				Where("guild_id = ? and created_at < ?", g.ID, exp.TimeStampNDaysBefore(cfg.DaysXPRemains)).
 				Delete(&CopaingXP{})
 			if res.Error != nil {
-				logger.Alert("user/level.go - Removing old XP", res.Error.Error(), "guild_id", g.ID)
+				s.Logger().Error("removing old xp", "error", res.Error, "guild", g.ID)
 			}
-			logger.Debug("Guild cleaned", "guild", g.Name, "rows affected", res.RowsAffected)
+			s.Logger().Debug("guild cleaned", "guild", g.Name, "rows affected", res.RowsAffected)
 		}()
 	}
 	wg.Wait()
 	for i, c := range cxps {
 		if i%50 == 49 {
-			logger.Debug("Sleeping...")
+			s.Logger().Debug("sleeping...")
 			time.Sleep(15 * time.Second) // prevents spamming the API
 		}
 		oldXp := c.GetXP()
-		xp, err := c.ToCopaing().GetXP()
+		xp, err := c.ToCopaing().GetXP(s.Logger())
 		if err != nil {
-			logger.Alert("user/level.go - Getting XP", err.Error(), "guild_id", c.ID, "discord_id", c.DiscordID)
+			s.Logger().Error("getting xp of copaing", "error", err, "copaing", c.ID, "guild", c.GuildID)
 			continue
 		}
 		if exp.Level(oldXp) != exp.Level(xp) {
-			c.OnNewLevel(dg, exp.Level(xp))
+			c.OnNewLevel(s, exp.Level(xp))
 		}
 	}
-	logger.Debug("Periodic reduce finished", "len(guilds)", len(dg.State.Guilds))
+	s.Logger().Debug("periodic reduce finished", "guilds affected", i)
 }
diff --git a/user/member.go b/user/member.go
index ad8762f..9068a6f 100644
--- a/user/member.go
+++ b/user/member.go
@@ -26,11 +26,6 @@ type CopaingAccess interface {
 	GetXP() uint
 }
 
-const (
-	LastEvent      = "last_event"
-	AlreadyRemoved = "already_removed"
-)
-
 func GetCopaing(discordID string, guildID string) *Copaing {
 	c := Copaing{DiscordID: discordID, GuildID: guildID}
 	if err := c.Load(); err != nil {
diff --git a/user/xp.go b/user/xp.go
index 606598c..6b0f6cc 100644
--- a/user/xp.go
+++ b/user/xp.go
@@ -1,6 +1,7 @@
 package user
 
 import (
+	"log/slog"
 	"math"
 	"slices"
 	"sync"
@@ -8,8 +9,8 @@ import (
 	"git.anhgelus.world/anhgelus/les-copaings-bot/config"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/exp"
 	"github.com/anhgelus/gokord"
-	"github.com/anhgelus/gokord/logger"
-	discordgo "github.com/nyttikord/gokord"
+	"github.com/nyttikord/gokord/bot"
+	"github.com/nyttikord/gokord/user"
 )
 
 type cXP struct {
@@ -25,19 +26,19 @@ func (c *cXP) GetXP() uint {
 	return c.Cxp
 }
 
-func (c *Copaing) AddXP(s *discordgo.Session, m *discordgo.Member, xp uint, fn func(uint, uint)) {
-	old, err := c.GetXP()
+func (c *Copaing) AddXP(s bot.Session, m *user.Member, xp uint, fn func(uint, uint)) {
+	old, err := c.GetXP(s.Logger())
 	if err != nil {
-		logger.Alert("user/xp.go - Getting xp", err.Error(), "discord_id", c.DiscordID, "guild_id", c.GuildID)
+		s.Logger().Error("getting xp", "error", err, "user", m.DisplayName(), "guild", c.GuildID)
 		return
 	}
 	pastLevel := exp.Level(old)
-	logger.Debug("Adding xp", "member", m.DisplayName(), "old xp", old, "xp to add", xp, "old level", pastLevel)
+	s.Logger().Debug("adding xp", "member", m.DisplayName(), "old xp", old, "xp to add", xp, "old level", pastLevel)
 	c.CopaingXPs = append(c.CopaingXPs, CopaingXP{CopaingID: c.ID, XP: uint(math.Floor(float64(xp) * c.GetBoost(m))), GuildID: c.GuildID})
 	if err = c.Save(); err != nil {
-		logger.Alert(
-			"user/xp.go - Saving user",
-			err.Error(),
+		s.Logger().Error(
+			"saving user",
+			"error", err.Error(),
 			"xp", c.CopaingXPs,
 			"discord_id", c.DiscordID,
 			"guild_id", c.GuildID,
@@ -51,12 +52,12 @@ func (c *Copaing) AddXP(s *discordgo.Session, m *discordgo.Member, xp uint, fn f
 	}
 }
 
-func (c *Copaing) GetXP() (uint, error) {
+func (c *Copaing) GetXP(logger *slog.Logger) (uint, error) {
 	cfg := config.GetGuildConfig(c.GuildID)
-	return c.GetXPForDays(cfg.DaysXPRemains)
+	return c.GetXPForDays(logger, cfg.DaysXPRemains)
 }
 
-func (c *Copaing) GetXPForDays(n uint) (uint, error) {
+func (c *Copaing) GetXPForDays(logger *slog.Logger, n uint) (uint, error) {
 	xp := uint(0)
 	rows, err := gokord.DB.
 		Model(&CopaingXP{}).
@@ -67,15 +68,15 @@ func (c *Copaing) GetXPForDays(n uint) (uint, error) {
 			c.ID,
 		).
 		Rows()
-	defer rows.Close()
 	if err != nil {
 		return 0, err
 	}
+	defer rows.Close()
 	for rows.Next() {
 		var cxp CopaingXP
 		err = gokord.DB.ScanRows(rows, &cxp)
 		if err != nil {
-			logger.Alert("user/xp.go - Scanning rows", err.Error(), "copaing_id", c.ID, "guild_id", c.GuildID)
+			logger.Error("scanning rows", "error", err, "copaing", c.ID, "guild", c.GuildID)
 			continue
 		}
 		xp += cxp.XP
@@ -83,7 +84,7 @@ func (c *Copaing) GetXPForDays(n uint) (uint, error) {
 	return xp, nil
 }
 
-func (c *Copaing) GetBoost(m *discordgo.Member) float64 {
+func (c *Copaing) GetBoost(m *user.Member) float64 {
 	boost := 1.0
 	if m.PremiumSince != nil {
 		boost = max(boost, 2.0)
@@ -103,31 +104,31 @@ func (c *Copaing) GetBoost(m *discordgo.Member) float64 {
 // GetBestXP returns n Copaing with the best XP within d days (d <= cfg.DaysXPRemain; d < 0 <=> d = cfg.DaysXPRemain)
 //
 // This function is slow
-func GetBestXP(guildId string, n uint, d int) ([]CopaingAccess, error) {
+func GetBestXP(logger *slog.Logger, guildId string, n uint, d int) ([]CopaingAccess, error) {
 	if d < 0 {
 		cfg := config.GetGuildConfig(guildId)
 		d = int(cfg.DaysXPRemains)
 	}
 	rows, err := gokord.DB.Model(&Copaing{}).Where("guild_id = ?", guildId).Rows()
-	defer rows.Close()
 	if err != nil {
 		return nil, err
 	}
+	defer rows.Close()
 	var l []*cXP
 	wg := sync.WaitGroup{}
 	for rows.Next() {
 		var c Copaing
 		err = gokord.DB.ScanRows(rows, &c)
 		if err != nil {
-			logger.Alert("user/xp.go - Scanning rows", err.Error(), "guild_id", guildId)
+			logger.Error("scanning rows", "error", err, "copaing", c.ID, "guild", c.GuildID)
 			continue
 		}
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			xp, err := c.GetXPForDays(uint(d))
+			xp, err := c.GetXPForDays(logger, uint(d))
 			if err != nil {
-				logger.Alert("user/xp.go - Fetching xp", err.Error(), "discord_id", c.DiscordID, "guild_id", guildId)
+				logger.Error("fetching xp", "error", err, "copaing", c.ID, "guild", c.GuildID)
 				return
 			}
 			l = append(l, &cXP{Cxp: xp, Copaing: &c})