refactor(commands): use new handlers

6 files changed, 179 insertions, 180 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)
 	}
 }