refactor(commands): use new handlers

12 files changed, 229 insertions, 230 deletions

diff --git a/commands/config.go b/commands/config.go
index 1878bdb..12d1c4d 100644
--- a/commands/config.go
+++ b/commands/config.go
@@ -121,8 +121,7 @@ func ConfigResponse(guildID string) *interaction.Response {
 }
 
 func ConfigCommand(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
-	err := dg.InteractionAPI().Respond(i.Interaction, ConfigResponse(i.GuildID))
-
+	err := dg.InteractionAPI().Respond(i.Interaction, ConfigResponse(i.GuildID)).Do(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("sending config", "error", err)
 	}
@@ -131,8 +130,8 @@ func ConfigCommand(ctx context.Context, dg bot.Session, i *interaction.Applicati
 func ConfigMessageComponent(ctx context.Context, dg bot.Session, i *interaction.MessageComponent) {
 	response := ConfigResponse(i.GuildID)
 	response.Type = types.InteractionResponseUpdateMessage
-	err := dg.InteractionAPI().Respond(i.Interaction, response)
 
+	err := dg.InteractionAPI().Respond(i.Interaction, response).Do(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("sending config", "error", err)
 	}
@@ -141,8 +140,8 @@ func ConfigMessageComponent(ctx context.Context, dg bot.Session, i *interaction.
 func ConfigModal(ctx context.Context, dg bot.Session, i *interaction.ModalSubmit) {
 	response := ConfigResponse(i.GuildID)
 	response.Type = types.InteractionResponseUpdateMessage
-	err := dg.InteractionAPI().Respond(i.Interaction, response)
 
+	err := dg.InteractionAPI().Respond(i.Interaction, response).Do(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("sending config", "error", err)
 	}
diff --git a/commands/credits.go b/commands/credits.go
index 340ea57..21dd8c7 100644
--- a/commands/credits.go
+++ b/commands/credits.go
@@ -1,20 +1,22 @@
 package commands
 
 import (
+	"context"
+
 	"github.com/anhgelus/gokord"
-	"github.com/anhgelus/gokord/cmd"
 	"github.com/nyttikord/gokord/bot"
-	"github.com/nyttikord/gokord/event"
+	"github.com/nyttikord/gokord/interaction"
 )
 
-func Credits(s bot.Session, _ *event.InteractionCreate, _ cmd.OptionMap, resp *cmd.ResponseBuilder) {
+func Credits(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
 	msg := "**Les Copaings**, le bot gérant les serveurs privés de [anhgelus](<https://anhgelus.world/>).\n"
 	msg += "Code source : <https://git.anhgelus.world/anhgelus/les-copaings-bot>\n\n"
 	msg += "Host du bot : " + gokord.BaseCfg.GetAuthor() + ".\n\n"
 	msg += "Utilise :\n- [anhgelus/gokord](<https://github.com/anhgelus/gokord>)\n"
 	msg += "- [Inter](<https://github.com/rsms/inter>)"
-	err := resp.SetMessage(msg).Send()
+	resp := interaction.NewMessageResponse().Message(msg).Response()
+	err := dg.InteractionAPI().Respond(i.Interaction, resp).Do(ctx)
 	if err != nil {
-		s.Logger().Error("sending credits", "error", err)
+		bot.Logger(ctx).Error("sending credits", "error", err)
 	}
 }
diff --git a/commands/rank.go b/commands/rank.go
index 3a017f6..53e4724 100644
--- a/commands/rank.go
+++ b/commands/rank.go
@@ -6,47 +6,49 @@ import (
 
 	"git.anhgelus.world/anhgelus/les-copaings-bot/exp"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/user"
-	"github.com/anhgelus/gokord/cmd"
 	"github.com/nyttikord/gokord/bot"
-	"github.com/nyttikord/gokord/event"
+	"github.com/nyttikord/gokord/interaction"
 )
 
-func Rank(ctx context.Context) func(s bot.Session, i *event.InteractionCreate, optMap cmd.OptionMap, resp *cmd.ResponseBuilder) {
-	return func(s bot.Session, i *event.InteractionCreate, optMap cmd.OptionMap, resp *cmd.ResponseBuilder) {
-		c := user.GetCopaing(ctx, i.Member.User.ID, i.GuildID) // current user = member who used /rank
-		msg := "Votre niveau"
-		m := i.Member
-		var err error
-		if v, ok := optMap["copaing"]; ok {
-			u := v.UserValue(s.UserAPI())
-			if u.Bot {
-				err = resp.SetMessage("Imagine si les bots avaient un niveau :rolling_eyes:").IsEphemeral().Send()
-				if err != nil {
-					s.Logger().Error("reply error user is a bot", "error", err)
-				}
-				return
-			}
-			m, err = s.GuildAPI().Member(i.GuildID, u.ID)
-			if err != nil {
-				s.Logger().Error("fetching guild member", "error", err, "user", u.Username, "guild", i.GuildID)
-				err = resp.SetMessage("Erreur : impossible de récupérer le membre").IsEphemeral().Send()
-				if err != nil {
-					s.Logger().Error("reply error fetching guild member", "error", err)
-				}
-				return
-			}
-			c = user.GetCopaing(ctx, u.ID, i.GuildID) // current user = member targeted by member who wrote /rank
-			msg = fmt.Sprintf("Le niveau de %s", m.DisplayName())
+func Rank(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
+	c := user.GetCopaing(ctx, i.Member.User.ID, i.GuildID) // current user = member who used /rank
+	msg := "Votre niveau"
+	m := i.Member
+	opts := i.OptionMap()
+	var resp *interaction.Response
+	defer func() {
+		err := dg.InteractionAPI().Respond(i.Interaction, resp).Do(ctx)
+		if err != nil {
+			bot.Logger(ctx).Error("replying to interaction", "error", err)
+		}
+	}()
+	var err error
+	if v, ok := opts["copaing"]; ok {
+		u := v.UserValue(ctx)
+		if u.Bot {
+			resp = interaction.NewMessageResponse().
+				IsEphemeral().
+				Message("Imagine si les bots avaient un niveau :rolling_eyes:").
+				Response()
+			return
 		}
-		xp := c.XP
-		lvl := exp.Level(xp)
-		nxtLvlXP := exp.LevelXP(lvl + 1)
-		err = resp.SetMessage(fmt.Sprintf(
-			"%s : **%d**\n> XP : %d\n> Prochain niveau dans %d XP",
-			msg, lvl, xp, nxtLvlXP-xp,
-		)).Send()
+		m, err = dg.GuildAPI().Member(i.GuildID, u.ID).Do(ctx)
 		if err != nil {
-			s.Logger().Error("sending rank", "error", err)
+			bot.Logger(ctx).Error("fetching guild member", "error", err, "user", u.Username, "guild", i.GuildID)
+			resp = interaction.NewMessageResponse().
+				IsEphemeral().
+				Message("Erreur : impossible de récupérer le membre").
+				Response()
+			return
 		}
+		c = user.GetCopaing(ctx, u.ID, i.GuildID) // current user = member targeted by member who wrote /rank
+		msg = fmt.Sprintf("Le niveau de %s", m.DisplayName())
 	}
+	xp := c.XP
+	lvl := exp.Level(xp)
+	nxtLvlXP := exp.LevelXP(lvl + 1)
+	resp = interaction.NewMessageResponse().Message(fmt.Sprintf(
+		"%s : **%d**\n> XP : %d\n> Prochain niveau dans %d XP",
+		msg, lvl, xp, nxtLvlXP-xp,
+	)).Response()
 }
diff --git a/commands/reset.go b/commands/reset.go
index ae31781..9f2debc 100644
--- a/commands/reset.go
+++ b/commands/reset.go
@@ -5,47 +5,45 @@ import (
 
 	"git.anhgelus.world/anhgelus/les-copaings-bot/user"
 	"github.com/anhgelus/gokord"
-	"github.com/anhgelus/gokord/cmd"
 	"github.com/nyttikord/gokord/bot"
-	"github.com/nyttikord/gokord/event"
+	"github.com/nyttikord/gokord/interaction"
 )
 
-func Reset(s bot.Session, i *event.InteractionCreate, _ cmd.OptionMap, resp *cmd.ResponseBuilder) {
+func Reset(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
 	var copaings []*user.Copaing
 	//TODO: delete everything from cache
 	gokord.DB.Where("guild_id = ?", i.GuildID).Delete(&copaings)
-	if err := resp.IsEphemeral().SetMessage("L'XP a été reset.").Send(); err != nil {
-		s.Logger().Error("sending reset success", "error", err)
+	resp := interaction.NewMessageResponse().IsEphemeral().Message("L'XP a été reset.").Response()
+	err := dg.InteractionAPI().Respond(i.Interaction, resp).Do(ctx)
+	if err != nil {
+		bot.Logger(ctx).Error("sending reset success", "error", err)
 	}
 }
 
-func ResetUser(ctx context.Context) func(s bot.Session, i *event.InteractionCreate, optMap cmd.OptionMap, resp *cmd.ResponseBuilder) {
-	return func(s bot.Session, i *event.InteractionCreate, optMap cmd.OptionMap, resp *cmd.ResponseBuilder) {
-		resp.IsEphemeral()
-		v, ok := optMap["user"]
-		if !ok {
-			if err := resp.SetMessage("Le user n'a pas été renseigné.").Send(); err != nil {
-				s.Logger().Error("sending error copaing not set", "error", err)
-			}
-			return
-		}
-		m := v.UserValue(s.UserAPI())
-		if m.Bot {
-			if err := resp.SetMessage("Les bots n'ont pas de niveau :upside_down:").Send(); err != nil {
-				s.Logger().Error("sending error bot does not have xp", "error", err)
-			}
-			return
-		}
-		err := user.GetCopaing(ctx, m.ID, i.GuildID).Delete(ctx)
+func ResetUser(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
+	resp := interaction.NewMessageResponse().IsEphemeral()
+	defer func() {
+		err := dg.InteractionAPI().Respond(i.Interaction, resp.Response()).Do(ctx)
 		if err != nil {
-			s.Logger().Error("deleting copaing", "error", err, "user", m.Username, "guild", i.GuildID)
-			err = resp.SetMessage("Erreur : impossible de reset l'utilisateur").Send()
-			if err != nil {
-				s.Logger().Error("sending error while deleting", "error", err)
-			}
-		}
-		if err = resp.SetMessage("Le user bien été reset.").Send(); err != nil {
-			s.Logger().Error("sending reset success", "error", err)
+			bot.Logger(ctx).Error("replying to interaction", "error", err)
 		}
+	}()
+	opts := i.OptionMap()
+	v, ok := opts["user"]
+	if !ok {
+		resp.Message("Le user n'a pas été renseigné.")
+		return
+	}
+	m := v.UserValue(ctx)
+	if m.Bot {
+		resp.Message("Les bots n'ont pas de niveau :upside_down:")
+		return
+	}
+	err := user.GetCopaing(ctx, m.ID, i.GuildID).Delete(ctx)
+	if err != nil {
+		bot.Logger(ctx).Error("deleting copaing", "error", err, "user", m.Username, "guild", i.GuildID)
+		resp.Message("Erreur : impossible de reset l'utilisateur")
+		return
 	}
+	resp.Message("Le user bien été reset.")
 }
diff --git a/commands/stats.go b/commands/stats.go
index 716616d..92402c8 100644
--- a/commands/stats.go
+++ b/commands/stats.go
@@ -11,15 +11,15 @@ import (
 	"slices"
 	"time"
 
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/config"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/exp"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/user"
 	"github.com/anhgelus/gokord"
-	"github.com/anhgelus/gokord/cmd"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/nyttikord/gokord/bot"
-	"github.com/nyttikord/gokord/channel"
-	"github.com/nyttikord/gokord/event"
+	"github.com/nyttikord/gokord/discord/request"
+	"github.com/nyttikord/gokord/interaction"
 	"gonum.org/v1/plot"
 	"gonum.org/v1/plot/plotter"
 	"gonum.org/v1/plot/vg"
@@ -47,72 +47,72 @@ var colors = []color.RGBA{
 	{193, 18, 31, 255},
 }
 
-func Stats(ctx context.Context) func(s bot.Session, i *event.InteractionCreate, opt cmd.OptionMap, resp *cmd.ResponseBuilder) {
-	return func(s bot.Session, i *event.InteractionCreate, opt cmd.OptionMap, resp *cmd.ResponseBuilder) {
-		cfg := config.GetGuildConfig(i.GuildID)
-		days := 15
-		if gokord.Debug {
-			days = 90
-		}
-		if v, ok := opt["days"]; ok {
-			in := v.IntValue()
-			if in < 1 || uint(in) > cfg.DaysXPRemains {
-				msg := fmt.Sprintf("Nombre de jours invalide. Il doit être strictement positif et inférieur à %d", cfg.DaysXPRemains)
-				if err := resp.SetMessage(msg).IsEphemeral().Send(); err != nil {
-					s.Logger().Error("sending error invalid days", "error", err)
-				}
-				return
-			}
-			days = int(in)
-		}
-		err := resp.IsDeferred().Send()
+func Stats(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
+	cfg := config.GetGuildConfig(i.GuildID)
+	days := 15
+	if common.IsDebug(ctx) {
+		days = 90
+	}
+
+	resp := interaction.NewMessageResponse()
+	defer func() {
+		err := dg.InteractionAPI().Respond(i.Interaction, resp.Response()).Do(ctx)
 		if err != nil {
-			s.Logger().Error("sending deferred", "error", err)
+			bot.Logger(ctx).Error("replying to interaction", "error", err)
+		}
+	}()
+
+	opts := i.OptionMap()
+	if v, ok := opts["days"]; ok {
+		in := v.IntValue()
+		if in < 1 || uint(in) > cfg.DaysXPRemains {
+			msg := fmt.Sprintf("Nombre de jours invalide. Il doit être strictement positif et inférieur à %d", cfg.DaysXPRemains)
+			resp.Message(msg)
 			return
 		}
-		go func() {
-			var w io.WriterTo
-			if v, ok := opt["user"]; ok {
-				w, err = statsMember(ctx, s, i, days, v.UserValue(s.UserAPI()).ID)
-			} else {
-				w, err = statsAll(s, i, days)
-			}
-			if err != nil {
-				s.Logger().Error("generating stats", "error", err, "guild", i.GuildID)
-				if err = resp.IsEphemeral().SetMessage("Il y a eu une erreur...").Send(); err != nil {
-					s.Logger().Error("sending error occurred", "error", err)
-				}
-				return
-			}
-			b := new(bytes.Buffer)
-			_, err = w.WriteTo(b)
-			if err != nil {
-				s.Logger().Error("writing png", "error", err)
-			}
-			err = resp.AddFile(&channel.File{
-				Name:        "plot.png",
-				ContentType: "image/png",
-				Reader:      b,
-			}).Send()
-			if err != nil {
-				s.Logger().Error("sending stats", "error", err)
-			}
-		}()
+		days = int(in)
+	}
+	err := dg.InteractionAPI().Respond(i.Interaction, interaction.NewDeferredResponse()).Do(ctx)
+	if err != nil {
+		bot.Logger(ctx).Error("sending deferred", "error", err)
 	}
+	var w io.WriterTo
+	if v, ok := opts["user"]; ok {
+		w, err = statsMember(ctx, dg, i, days, v.UserValue(ctx).ID)
+	} else {
+		w, err = statsAll(ctx, dg, i, days)
+	}
+	if err != nil {
+		bot.Logger(ctx).Error("generating stats", "error", err, "guild", i.GuildID)
+		resp.Message("Il y a eu une erreur...")
+		return
+	}
+	b := new(bytes.Buffer)
+	_, err = w.WriteTo(b)
+	if err != nil {
+		bot.Logger(ctx).Error("writing png", "error", err)
+		resp.Message("Il y a eu une erreur...")
+		return
+	}
+	resp.AddFile(&request.File{
+		Name:        "plot.png",
+		ContentType: "image/png",
+		Reader:      b,
+	})
 }
 
-func statsAll(s bot.Session, i *event.InteractionCreate, days int) (io.WriterTo, error) {
-	return stats(s, i, days, func(before, after string) *gorm.DB {
+func statsAll(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand, days int) (io.WriterTo, error) {
+	return stats(ctx, dg, i, days, func(before, after string) *gorm.DB {
 		return gokord.DB.Raw(before+"WHERE guild_id = ? and created_at > ?"+after, i.GuildID, exp.TimeStampNDaysBefore(uint(days)))
 	})
 }
 
-func statsMember(ctx context.Context, s bot.Session, i *event.InteractionCreate, days int, discordID string) (io.WriterTo, error) {
-	_, err := s.GuildAPI().Member(i.GuildID, discordID)
+func statsMember(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand, days int, discordID string) (io.WriterTo, error) {
+	_, err := dg.GuildAPI().Member(i.GuildID, discordID).Do(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return stats(s, i, days, func(before, after string) *gorm.DB {
+	return stats(ctx, dg, i, days, func(before, after string) *gorm.DB {
 		return gokord.DB.Raw(
 			before+"WHERE guild_id = ? and created_at > ? and copaing_id = ?"+after,
 			i.GuildID, exp.TimeStampNDaysBefore(uint(days)), user.GetCopaing(ctx, discordID, i.GuildID).ID,
@@ -120,12 +120,12 @@ func statsMember(ctx context.Context, s bot.Session, i *event.InteractionCreate,
 	})
 }
 
-func stats(s bot.Session, i *event.InteractionCreate, days int, execSql func(before, after string) *gorm.DB) (io.WriterTo, error) {
+func stats(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand, days int, execSql func(before, after string) *gorm.DB) (io.WriterTo, error) {
 	var rawData []*data
-	if gokord.Debug {
+	if common.IsDebug(ctx) {
 		var rawCopaingData []*user.CopaingXP
 		if err := execSql("SELECT * FROM copaing_xps ", "").Scan(&rawCopaingData).Error; err != nil {
-			s.Logger().Error("fetching result", "error", err)
+			bot.Logger(ctx).Error("fetching result", "error", err)
 			return nil, err
 		}
 		rawData = make([]*data, len(rawCopaingData))
@@ -141,7 +141,7 @@ func stats(s bot.Session, i *event.InteractionCreate, days int, execSql func(bef
 		if err := execSql(
 			`SELECT "created_at"::date::text, sum("xp") as xp, "copaing_id" FROM copaing_xps `, ` GROUP BY "created_at"::date, "copaing_id"`,
 		).Scan(&rawDbData).Error; err != nil {
-			s.Logger().Error("fetching result", "error", err)
+			bot.Logger(ctx).Error("fetching result", "error", err)
 			return nil, err
 		}
 		rawData = make([]*data, len(rawDbData))
@@ -163,10 +163,10 @@ func stats(s bot.Session, i *event.InteractionCreate, days int, execSql func(bef
 			var cp user.Copaing
 			if err := gokord.DB.First(&cp, raw.CopaingID).Error; err != nil {
 				if !errors.Is(err, gorm.ErrRecordNotFound) {
-					s.Logger().Error("finding copaing", "error", err, "copaing", raw.CopaingID)
+					bot.Logger(ctx).Error("finding copaing", "error", err, "copaing", raw.CopaingID)
 					return nil, err
 				}
-				s.Logger().Warn("copaing not found, skipping", "copaing", raw.CopaingID)
+				bot.Logger(ctx).Warn("copaing not found, skipping", "copaing", raw.CopaingID)
 				continue
 			}
 			copaings[raw.CopaingID] = &cp
@@ -184,7 +184,7 @@ func stats(s bot.Session, i *event.InteractionCreate, days int, execSql func(bef
 			stats[raw.CopaingID] = pts
 		}
 		t := raw.CreatedAt.Unix() - now
-		if !gokord.Debug {
+		if !common.IsDebug(ctx) {
 			t = int64(math.Ceil(float64(t) / (24 * 60 * 60)))
 		} else {
 			t = int64(math.Ceil(float64(t) / exp.DebugFactor))
@@ -194,10 +194,10 @@ func stats(s bot.Session, i *event.InteractionCreate, days int, execSql func(bef
 			Y: float64(raw.XP),
 		}
 	}
-	return generatePlot(s, i, copaings, stats)
+	return generatePlot(ctx, dg, i, copaings, stats)
 }
 
-func generatePlot(s bot.Session, i *event.InteractionCreate, copaings map[int]*user.Copaing, stats map[int][]plotter.XY) (io.WriterTo, error) {
+func generatePlot(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand, copaings map[int]*user.Copaing, stats map[int][]plotter.XY) (io.WriterTo, error) {
 	p := plot.New()
 	fontSizeTitle := vg.Length(16)
 	fontSize := vg.Length(12)
@@ -223,9 +223,9 @@ func generatePlot(s bot.Session, i *event.InteractionCreate, copaings map[int]*u
 
 	cnt := 0
 	for in, c := range copaings {
-		m, err := s.GuildAPI().Member(i.GuildID, c.DiscordID)
+		m, err := dg.GuildAPI().Member(i.GuildID, c.DiscordID).Do(ctx)
 		if err != nil {
-			s.Logger().Error("fetching guild member", "error", err)
+			bot.Logger(ctx).Error("fetching guild member", "error", err)
 			return nil, err
 		}
 		slices.SortFunc(stats[in], func(a, b plotter.XY) int {
diff --git a/commands/top.go b/commands/top.go
index a6ed992..867cf26 100644
--- a/commands/top.go
+++ b/commands/top.go
@@ -8,53 +8,51 @@ import (
 	"git.anhgelus.world/anhgelus/les-copaings-bot/config"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/exp"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/user"
-	"github.com/anhgelus/gokord/cmd"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/channel"
-	"github.com/nyttikord/gokord/event"
+	"github.com/nyttikord/gokord/interaction"
 )
 
-func Top(ctx context.Context) func(s bot.Session, i *event.InteractionCreate, _ cmd.OptionMap, resp *cmd.ResponseBuilder) {
-	return func(s bot.Session, i *event.InteractionCreate, _ cmd.OptionMap, resp *cmd.ResponseBuilder) {
-		embeds := make([]*channel.MessageEmbed, 3)
-		var wg sync.WaitGroup
+func Top(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
+	embeds := make([]*channel.MessageEmbed, 3)
+	var wg sync.WaitGroup
 
-		fn := func(str string, n uint, d int, id int) {
-			tops := user.GetBestXP(ctx, i.GuildID, n, d)
-			embeds[id] = &channel.MessageEmbed{
-				Title:       str,
-				Description: genTopsMessage(tops),
-				Color:       0x10E6AD,
-			}
-		}
-
-		cfg := config.GetGuildConfig(i.GuildID)
-		if cfg.DaysXPRemains > 30 {
-			wg.Go(func() {
-				fn(fmt.Sprintf("Top %d jours", cfg.DaysXPRemains), 10, -1, 0)
-			})
+	fn := func(str string, n uint, d int, id int) {
+		tops := user.GetBestXP(ctx, i.GuildID, n, d)
+		embeds[id] = &channel.MessageEmbed{
+			Title:       str,
+			Description: genTopsMessage(tops),
+			Color:       0x10E6AD,
 		}
+	}
 
+	cfg := config.GetGuildConfig(i.GuildID)
+	if cfg.DaysXPRemains > 30 {
 		wg.Go(func() {
-			fn("Top 30 jours", 5, 30, 1)
-		})
-		wg.Go(func() {
-			fn("Top 7 jours", 5, 7, 2)
+			fn(fmt.Sprintf("Top %d jours", cfg.DaysXPRemains), 10, -1, 0)
 		})
+	}
 
-		wg.Wait()
-		if cfg.DaysXPRemains > 30 {
-			resp.AddEmbed(embeds[0]).
-				AddEmbed(embeds[1]).
-				AddEmbed(embeds[2])
-		} else {
-			resp.AddEmbed(embeds[1]).
-				AddEmbed(embeds[2])
-		}
-		err := resp.Send()
-		if err != nil {
-			s.Logger().Error("sending response top", "error", err)
-		}
+	wg.Go(func() {
+		fn("Top 30 jours", 5, 30, 1)
+	})
+	wg.Go(func() {
+		fn("Top 7 jours", 5, 7, 2)
+	})
+
+	wg.Wait()
+	resp := interaction.NewMessageResponse()
+	if cfg.DaysXPRemains > 30 {
+		resp.AddEmbed(embeds[0]).
+			AddEmbed(embeds[1]).
+			AddEmbed(embeds[2])
+	} else {
+		resp.AddEmbed(embeds[1]).
+			AddEmbed(embeds[2])
+	}
+	err := dg.InteractionAPI().Respond(i.Interaction, resp.Response()).Do(ctx)
+	if err != nil {
+		bot.Logger(ctx).Error("sending response top", "error", err)
 	}
 }
 
diff --git a/config/guild.go b/config/guild.go
index 8799186..c1df2c9 100644
--- a/config/guild.go
+++ b/config/guild.go
@@ -1,6 +1,7 @@
 package config
 
 import (
+	"context"
 	"strings"
 
 	"github.com/anhgelus/gokord"
@@ -51,21 +52,21 @@ func (cfg *GuildConfig) Save() error {
 	return gokord.DB.Save(cfg).Error
 }
 
-func (cfg *GuildConfig) IsDisabled(s bot.Session, channelID string) bool {
+func (cfg *GuildConfig) IsDisabled(ctx context.Context, s bot.Session, channelID string) bool {
 	ok := true
 	for channelID != "" && ok {
 		ok = !strings.Contains(cfg.DisabledChannels, channelID)
 		c, err := s.ChannelAPI().State.Channel(channelID)
 		if err != nil {
-			s.Logger().Error("unable to find channel %s in state", "error", err, "channel", c)
-			c, err = s.ChannelAPI().Channel(channelID)
+			bot.Logger(ctx).Error("unable to find channel %s in state", "error", err, "channel", c)
+			c, err = s.ChannelAPI().Channel(channelID).Do(ctx)
 			if err == nil {
 				err = s.ChannelAPI().State.ChannelAdd(c)
 				if err != nil {
-					s.Logger().Error("unable to add channel to state", "error", err, "channel", c)
+					bot.Logger(ctx).Error("unable to add channel to state", "error", err, "channel", c)
 				}
 			} else {
-				s.Logger().Error("unable to fetch channel", "error", err, "channel", c)
+				bot.Logger(ctx).Error("unable to fetch channel", "error", err, "channel", c)
 				return false
 			}
 		}
diff --git a/events.go b/events.go
index 839fa6c..eaed31e 100644
--- a/events.go
+++ b/events.go
@@ -28,7 +28,7 @@ func OnMessage(ctx context.Context, s bot.Session, m *event.MessageCreate) {
 		return
 	}
 	cfg := config.GetGuildConfig(m.GuildID)
-	if cfg.IsDisabled(s, m.ChannelID) {
+	if cfg.IsDisabled(ctx, s, m.ChannelID) {
 		return
 	}
 	cc := user.GetCopaing(ctx, m.Author.ID, m.GuildID)
@@ -39,7 +39,7 @@ func OnMessage(ctx context.Context, s bot.Session, m *event.MessageCreate) {
 	xp := min(exp.MessageXP(uint(len(trimmed)), exp.CalcDiversity(trimmed)), MaxXpPerMessage)
 	cc.AddXP(ctx, s, m.Member, xp, func(_ uint, _ uint) {
 		if err := s.ChannelAPI().MessageReactionAdd(m.ChannelID, m.Message.ID, "⬆"); err != nil {
-			s.Logger().Error(
+			bot.Logger(ctx).Error(
 				"add reaction for new level",
 				"error", err,
 				"channel", m.ChannelID,
@@ -54,13 +54,14 @@ func OnVoiceUpdate(ctx context.Context, s bot.Session, e *event.VoiceStateUpdate
 		return
 	}
 	cfg := config.GetGuildConfig(e.GuildID)
-	if (e.BeforeUpdate == nil || cfg.IsDisabled(s, e.BeforeUpdate.ChannelID)) && e.ChannelID != "" {
-		if cfg.IsDisabled(s, e.ChannelID) {
+	dis := cfg.IsDisabled(ctx, s, e.BeforeUpdate.ChannelID)
+	if (e.BeforeUpdate == nil || dis) && e.ChannelID != "" {
+		if dis {
 			return
 		}
-		onConnection(s, e)
-	} else if e.BeforeUpdate != nil && (e.ChannelID == "" || cfg.IsDisabled(s, e.ChannelID)) {
-		if cfg.IsDisabled(s, e.BeforeUpdate.ChannelID) {
+		onConnection(ctx, s, e)
+	} else if e.BeforeUpdate != nil && (e.ChannelID == "" || dis) {
+		if dis {
 			return
 		}
 		onDisconnect(ctx, s, e)
@@ -71,8 +72,8 @@ func genMapKey(guildID string, userID string) string {
 	return fmt.Sprintf("%s:%s", guildID, userID)
 }
 
-func onConnection(s bot.Session, e *event.VoiceStateUpdate) {
-	s.Logger().Debug("user connected", "user", e.Member.DisplayName())
+func onConnection(ctx context.Context, s bot.Session, e *event.VoiceStateUpdate) {
+	bot.Logger(ctx).Debug("user connected", "user", e.Member.DisplayName())
 	connectedSince[genMapKey(e.GuildID, e.UserID)] = time.Now().Unix()
 }
 
@@ -82,18 +83,18 @@ func onDisconnect(ctx context.Context, s bot.Session, e *event.VoiceStateUpdate)
 	// check the validity of user
 	con, ok := connectedSince[genMapKey(e.GuildID, e.UserID)]
 	if !ok || con == NotConnected {
-		s.Logger().Warn(
+		bot.Logger(ctx).Warn(
 			"user disconnect from a vocal but was registered as not connected",
 			"user", e.Member.DisplayName(),
 		)
 		return
 	}
 	timeInVocal := now - con
-	s.Logger().Debug("user disconnected", "user", e.Member.DisplayName(), "time in vocal", timeInVocal)
+	bot.Logger(ctx).Debug("user disconnected", "user", e.Member.DisplayName(), "time in vocal", timeInVocal)
 	connectedSince[genMapKey(e.GuildID, e.UserID)] = NotConnected
 	// add exp
 	if timeInVocal < 0 {
-		s.Logger().Warn("time spent in vocal is negative", "user", e.Member.DisplayName(), "guild", e.GuildID)
+		bot.Logger(ctx).Warn("time spent in vocal is negative", "user", e.Member.DisplayName(), "guild", e.GuildID)
 		return
 	}
 	timeInVocal = min(timeInVocal, MaxTimeInVocal)
@@ -105,20 +106,20 @@ func onDisconnect(ctx context.Context, s bot.Session, e *event.VoiceStateUpdate)
 		}
 		_, err := s.ChannelAPI().MessageSend(cfg.FallbackChannel, fmt.Sprintf(
 			"%s est maintenant niveau %d", e.Member.Mention(), newLevel,
-		))
+		)).Do(ctx)
 		if err != nil {
-			s.Logger().Error("sending new level in fallback channel", "error", err)
+			bot.Logger(ctx).Error("sending new level in fallback channel", "error", err)
 		}
 	})
 }
 
 func OnLeave(ctx context.Context, s bot.Session, e *event.GuildMemberRemove) {
-	s.Logger().Debug("leave event", "user", e.User.Username)
+	bot.Logger(ctx).Debug("leave event", "user", e.User.Username)
 	if e.User.Bot {
 		return
 	}
 	c := user.GetCopaing(ctx, e.User.ID, e.GuildID)
 	if err := c.Delete(ctx); err != nil {
-		s.Logger().Error("deleting user", "user", e.User.Username, "guild", e.GuildID)
+		bot.Logger(ctx).Error("deleting user", "user", e.User.Username, "guild", e.GuildID)
 	}
 }
diff --git a/main.go b/main.go
index 1d70d93..3cfc289 100644
--- a/main.go
+++ b/main.go
@@ -213,6 +213,15 @@ func main() {
 	dynamicid.HandleDynamicMessageComponent(events, rolereact.HandleSetReaction, rolereact.SetRoleReaction)
 	dynamicid.HandleDynamicMessageComponent(events, rolereact.HandleDelRole, rolereact.DelRole)
 
+	// commands
+	intrs.HandleCommand("rank", commands.Rank)
+	intrs.HandleCommand("config", commands.ConfigCommand)
+	intrs.HandleCommand("top", commands.Top)
+	intrs.HandleCommand("reset", commands.Reset)
+	intrs.HandleCommand("reset-user", commands.ResetUser)
+	intrs.HandleCommand("credits", commands.Credits)
+	intrs.HandleCommand("rolereact", rolereact.HandleCommand)
+
 	// interaction: /config
 	intrs.HandleMessageComponent(commands.OpenConfig, commands.ConfigMessageComponent)
 	// xp role related
diff --git a/rolereact/events.go b/rolereact/events.go
index 54400eb..090b924 100644
--- a/rolereact/events.go
+++ b/rolereact/events.go
@@ -13,11 +13,7 @@ type RoleReact struct {
 	RoleID string
 }
 
-func HandleReactionAdd(
-	_ context.Context,
-	s bot.Session,
-	e *event.MessageReactionAdd,
-) {
+func HandleReactionAdd(ctx context.Context, s bot.Session, e *event.MessageReactionAdd) {
 	results := []RoleReact{}
 	oldGokord.DB.Model(&config.RoleReact{}).
 		Joins("JOIN role_react_messages ON role_reacts.role_react_message_id = role_react_messages.id").
@@ -26,16 +22,12 @@ func HandleReactionAdd(
 	for _, role := range results {
 		err := s.GuildAPI().MemberRoleAdd(e.GuildID, e.UserID, role.RoleID)
 		if err != nil {
-			s.Logger().Error("Unable to add role after member added reaction", "error", err)
+			bot.Logger(ctx).Error("Unable to add role after member added reaction", "error", err)
 		}
 	}
 }
 
-func HandleReactionRemove(
-	_ context.Context,
-	s bot.Session,
-	e *event.MessageReactionRemove,
-) {
+func HandleReactionRemove(ctx context.Context, s bot.Session, e *event.MessageReactionRemove) {
 	results := []RoleReact{}
 	oldGokord.DB.Model(&config.RoleReact{}).
 		Joins("JOIN role_react_messages ON role_reacts.role_react_message_id = role_react_messages.id").
@@ -44,7 +36,7 @@ func HandleReactionRemove(
 	for _, role := range results {
 		err := s.GuildAPI().MemberRoleRemove(e.GuildID, e.UserID, role.RoleID)
 		if err != nil {
-			s.Logger().Error("Unable to remove role after member removed reaction", "error", err)
+			bot.Logger(ctx).Error("Unable to remove role after member removed reaction", "error", err)
 		}
 	}
 }
diff --git a/user/level.go b/user/level.go
index 41fb291..feec35b 100644
--- a/user/level.go
+++ b/user/level.go
@@ -13,32 +13,26 @@ import (
 	"github.com/nyttikord/gokord/user"
 )
 
-func onNewLevel(s bot.Session, m *user.Member, level uint) {
+func onNewLevel(ctx context.Context, 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) {
-			s.Logger().Debug("add role", "role", role.RoleID, "user", m.DisplayName(), "guild", m.GuildID)
+			bot.Logger(ctx).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 {
-				s.Logger().Error(
+				bot.Logger(ctx).Error(
 					"adding role",
-					"error", err,
-					"role", role.RoleID,
-					"user", m.DisplayName(),
-					"guild", m.GuildID,
+					"error", err, "role", role.RoleID, "user", m.DisplayName(), "guild", m.GuildID,
 				)
 			}
 		} else if role.XP > xpForLevel && slices.Contains(m.Roles, role.RoleID) {
-			s.Logger().Debug("remove role", "role", role.RoleID, "user", m.DisplayName(), "guild", m.GuildID)
+			bot.Logger(ctx).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 {
-				s.Logger().Error(
+				bot.Logger(ctx).Error(
 					"removing role",
-					"error", err,
-					"role", role.RoleID,
-					"user", m.DisplayName(),
-					"guild", m.GuildID,
+					"error", err, "role", role.RoleID, "user", m.DisplayName(), "guild", m.GuildID,
 				)
 			}
 		}
@@ -51,7 +45,7 @@ func (c *CopaingCached) onNewLevel(ctx context.Context, s bot.Session, level uin
 		bot.Logger(ctx).Error("getting member for new level", "error", err, "user", c.DiscordID, "guild", c.GuildID)
 		return
 	}
-	onNewLevel(s, m, level)
+	onNewLevel(ctx, s, m, level)
 }
 
 func PeriodicReducer(ctx context.Context, s bot.Session) {
diff --git a/user/xp.go b/user/xp.go
index 161a450..ca08258 100644
--- a/user/xp.go
+++ b/user/xp.go
@@ -26,17 +26,20 @@ func (c *cXP) GetXP() uint {
 func (cc *CopaingCached) AddXP(ctx context.Context, s bot.Session, m *user.Member, xp uint, fn func(uint, uint)) {
 	old := cc.XP
 	pastLevel := exp.Level(old)
-	s.Logger().Debug("adding xp", "user", m.DisplayName(), "old", old, "to add", xp)
+	bot.Logger(ctx).Debug("adding xp", "user", m.DisplayName(), "old", old, "to add", xp)
 	cc.XP += xp
 	cc.XPToAdd += xp
 	if err := cc.Save(ctx); err != nil {
-		s.Logger().Error("saving user in state", "error", err, "user", m.DisplayName(), "xp", xp, "guild", cc.GuildID)
+		bot.Logger(ctx).Error(
+			"saving user in state",
+			"error", err, "user", m.DisplayName(), "xp", xp, "guild", cc.GuildID,
+		)
 		return
 	}
 	newLevel := exp.Level(old + xp)
 	if newLevel > pastLevel {
 		fn(old+xp, newLevel)
-		onNewLevel(s, m, newLevel)
+		onNewLevel(ctx, s, m, newLevel)
 	}
 }