refactor(): completely remove old gokord and finish to update everything to use contexts

26 files changed, 286 insertions, 305 deletions

diff --git a/README.md b/README.md
index 6355f32..31d37dc 100644
--- a/README.md
+++ b/README.md
@@ -86,7 +86,7 @@ in `.env`)
 ## Technologies
 
 - Go 1.24
-- anhgelus/gokord
+- nyttikord/gokord
 
 ## License
 
diff --git a/commands/config.go b/commands/config.go
index 12d1c4d..d9b04ec 100644
--- a/commands/config.go
+++ b/commands/config.go
@@ -20,8 +20,8 @@ const (
 	OpenConfig   = "config"
 )
 
-func ConfigResponse(guildID string) *interaction.Response {
-	cfg := config.GetGuildConfig(guildID)
+func ConfigResponse(ctx context.Context, guildID string) *interaction.Response {
+	cfg := config.GetGuildConfig(ctx, guildID)
 	roles := ""
 	l := len(cfg.XpRoles) - 1
 	slices.SortFunc(cfg.XpRoles, func(xp1, xp2 config.XpRole) int {
@@ -121,14 +121,14 @@ 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)).Do(ctx)
+	err := dg.InteractionAPI().Respond(i.Interaction, ConfigResponse(ctx, i.GuildID)).Do(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("sending config", "error", err)
 	}
 }
 
 func ConfigMessageComponent(ctx context.Context, dg bot.Session, i *interaction.MessageComponent) {
-	response := ConfigResponse(i.GuildID)
+	response := ConfigResponse(ctx, i.GuildID)
 	response.Type = types.InteractionResponseUpdateMessage
 
 	err := dg.InteractionAPI().Respond(i.Interaction, response).Do(ctx)
@@ -138,7 +138,7 @@ 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 := ConfigResponse(ctx, i.GuildID)
 	response.Type = types.InteractionResponseUpdateMessage
 
 	err := dg.InteractionAPI().Respond(i.Interaction, response).Do(ctx)
diff --git a/commands/credits.go b/commands/credits.go
index 21dd8c7..a27d2cc 100644
--- a/commands/credits.go
+++ b/commands/credits.go
@@ -3,7 +3,7 @@ package commands
 import (
 	"context"
 
-	"github.com/anhgelus/gokord"
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/interaction"
 )
@@ -11,8 +11,8 @@ import (
 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 += "Host du bot : " + common.GetAuthor(ctx) + ".\n\n"
+	msg += "Utilise :\n- [nyttikord/gokord](<https://github.com/nyttikord/gokord>)\n"
 	msg += "- [Inter](<https://github.com/rsms/inter>)"
 	resp := interaction.NewMessageResponse().Message(msg).Response()
 	err := dg.InteractionAPI().Respond(i.Interaction, resp).Do(ctx)
diff --git a/commands/rank.go b/commands/rank.go
index 53e4724..07bbe75 100644
--- a/commands/rank.go
+++ b/commands/rank.go
@@ -15,9 +15,9 @@ func Rank(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand
 	msg := "Votre niveau"
 	m := i.Member
 	opts := i.OptionMap()
-	var resp *interaction.Response
+	resp := interaction.NewMessageResponse()
 	defer func() {
-		err := dg.InteractionAPI().Respond(i.Interaction, resp).Do(ctx)
+		err := dg.InteractionAPI().Respond(i.Interaction, resp.Response()).Do(ctx)
 		if err != nil {
 			bot.Logger(ctx).Error("replying to interaction", "error", err)
 		}
@@ -26,19 +26,13 @@ func Rank(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand
 	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()
+			resp.IsEphemeral().Message("Imagine si les bots avaient un niveau :rolling_eyes:")
 			return
 		}
 		m, err = dg.GuildAPI().Member(i.GuildID, u.ID).Do(ctx)
 		if err != nil {
 			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()
+			resp.IsEphemeral().Message("Erreur : impossible de récupérer le membre")
 			return
 		}
 		c = user.GetCopaing(ctx, u.ID, i.GuildID) // current user = member targeted by member who wrote /rank
@@ -47,8 +41,8 @@ func Rank(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand
 	xp := c.XP
 	lvl := exp.Level(xp)
 	nxtLvlXP := exp.LevelXP(lvl + 1)
-	resp = interaction.NewMessageResponse().Message(fmt.Sprintf(
+	resp.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 9f2debc..d1e04ea 100644
--- a/commands/reset.go
+++ b/commands/reset.go
@@ -3,8 +3,8 @@ package commands
 import (
 	"context"
 
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/user"
-	"github.com/anhgelus/gokord"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/interaction"
 )
@@ -12,7 +12,7 @@ import (
 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)
+	common.GetDB(ctx).Where("guild_id = ?", i.GuildID).Delete(&copaings)
 	resp := interaction.NewMessageResponse().IsEphemeral().Message("L'XP a été reset.").Response()
 	err := dg.InteractionAPI().Respond(i.Interaction, resp).Do(ctx)
 	if err != nil {
@@ -31,7 +31,7 @@ func ResetUser(ctx context.Context, dg bot.Session, i *interaction.ApplicationCo
 	opts := i.OptionMap()
 	v, ok := opts["user"]
 	if !ok {
-		resp.Message("Le user n'a pas été renseigné.")
+		resp.Message("Le copaing n'a pas été renseigné.")
 		return
 	}
 	m := v.UserValue(ctx)
@@ -42,8 +42,8 @@ func ResetUser(ctx context.Context, dg bot.Session, i *interaction.ApplicationCo
 	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")
+		resp.Message("Erreur : impossible de reset le copaing")
 		return
 	}
-	resp.Message("Le user bien été reset.")
+	resp.Message("Le copaing bien été reset.")
 }
diff --git a/commands/stats.go b/commands/stats.go
index 92402c8..e74f3e1 100644
--- a/commands/stats.go
+++ b/commands/stats.go
@@ -15,7 +15,6 @@ 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"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/discord/request"
@@ -48,7 +47,7 @@ var colors = []color.RGBA{
 }
 
 func Stats(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
-	cfg := config.GetGuildConfig(i.GuildID)
+	cfg := config.GetGuildConfig(ctx, i.GuildID)
 	days := 15
 	if common.IsDebug(ctx) {
 		days = 90
@@ -103,7 +102,10 @@ func Stats(ctx context.Context, dg bot.Session, i *interaction.ApplicationComman
 
 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)))
+		return common.GetDB(ctx).Raw(
+			before+"WHERE guild_id = ? and created_at > ?"+after,
+			i.GuildID, exp.TimeStampNDaysBefore(ctx, uint(days)),
+		)
 	})
 }
 
@@ -113,9 +115,9 @@ func statsMember(ctx context.Context, dg bot.Session, i *interaction.Application
 		return nil, err
 	}
 	return stats(ctx, dg, i, days, func(before, after string) *gorm.DB {
-		return gokord.DB.Raw(
+		return common.GetDB(ctx).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,
+			i.GuildID, exp.TimeStampNDaysBefore(ctx, uint(days)), user.GetCopaing(ctx, discordID, i.GuildID).ID,
 		)
 	})
 }
@@ -161,7 +163,7 @@ func stats(ctx context.Context, dg bot.Session, i *interaction.ApplicationComman
 		_, ok := copaings[raw.CopaingID]
 		if !ok {
 			var cp user.Copaing
-			if err := gokord.DB.First(&cp, raw.CopaingID).Error; err != nil {
+			if err := common.GetDB(ctx).First(&cp, raw.CopaingID).Error; err != nil {
 				if !errors.Is(err, gorm.ErrRecordNotFound) {
 					bot.Logger(ctx).Error("finding copaing", "error", err, "copaing", raw.CopaingID)
 					return nil, err
@@ -213,7 +215,7 @@ func generatePlot(ctx context.Context, dg bot.Session, i *interaction.Applicatio
 	// set scales
 	p.Title.Text = "XP gagnées"
 	p.X.Label.Text = "Jours"
-	if gokord.Debug {
+	if common.IsDebug(ctx) {
 		p.X.Label.Text = fmt.Sprintf("%d secondes", exp.DebugFactor)
 	}
 	p.Y.Label.Text = "XP"
diff --git a/commands/top.go b/commands/top.go
index 867cf26..7b57d8f 100644
--- a/commands/top.go
+++ b/commands/top.go
@@ -26,7 +26,7 @@ func Top(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand)
 		}
 	}
 
-	cfg := config.GetGuildConfig(i.GuildID)
+	cfg := config.GetGuildConfig(ctx, i.GuildID)
 	if cfg.DaysXPRemains > 30 {
 		wg.Go(func() {
 			fn(fmt.Sprintf("Top %d jours", cfg.DaysXPRemains), 10, -1, 0)
diff --git a/common/context.go b/common/context.go
index 3a79264..065a994 100644
--- a/common/context.go
+++ b/common/context.go
@@ -6,12 +6,13 @@ import (
 	"gorm.io/gorm"
 )
 
-type key uint8
+type Key uint8
 
 const (
-	keyDB     key = 0
-	keyDebug  key = 1
-	keyAuthor key = 2
+	keyDB           Key = 0
+	keyDebug        Key = 1
+	keyAuthor       Key = 2
+	KeyCopaingState Key = 3
 )
 
 func SetDB(ctx context.Context, db *gorm.DB) context.Context {
diff --git a/config/channel.go b/config/channel.go
index 6086f09..4650e15 100644
--- a/config/channel.go
+++ b/config/channel.go
@@ -20,13 +20,13 @@ const (
 )
 
 func HandleModifyFallbackChannel(ctx context.Context, dg bot.Session, i *interaction.MessageComponent) bool {
-	cfg := GetGuildConfig(i.GuildID)
+	cfg := GetGuildConfig(ctx, i.GuildID)
 	var channelID string
 	if len(i.Data.Values) > 0 {
 		channelID = i.Data.Values[0]
 	}
 	cfg.FallbackChannel = channelID
-	err := cfg.Save()
+	err := cfg.Save(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("saving fallback channel", "error", err)
 		return false
@@ -35,9 +35,9 @@ func HandleModifyFallbackChannel(ctx context.Context, dg bot.Session, i *interac
 }
 
 func HandleModifyDisChannel(ctx context.Context, dg bot.Session, i *interaction.MessageComponent) bool {
-	cfg := GetGuildConfig(i.GuildID)
+	cfg := GetGuildConfig(ctx, i.GuildID)
 	cfg.DisabledChannels = strings.Join(i.Data.Values, ";")
-	err := cfg.Save()
+	err := cfg.Save(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("unable to save disabled channel", "error", err)
 		return false
diff --git a/config/guild.go b/config/guild.go
index c1df2c9..756c0a4 100644
--- a/config/guild.go
+++ b/config/guild.go
@@ -4,11 +4,11 @@ import (
 	"context"
 	"strings"
 
-	"github.com/anhgelus/gokord"
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"github.com/nyttikord/gokord/bot"
 )
 
-type GuildConfig struct {
+type Guild struct {
 	ID               uint   `gorm:"primarykey"`
 	GuildID          string `gorm:"not null;unique"`
 	XpRoles          []XpRole
@@ -36,36 +36,31 @@ type RoleReact struct {
 	CounterID          uint `gorm:"-"`
 }
 
-func GetGuildConfig(guildID string) *GuildConfig {
-	cfg := GuildConfig{GuildID: guildID}
-	if err := cfg.Load(); err != nil {
+func GetGuildConfig(ctx context.Context, guildID string) *Guild {
+	cfg := Guild{GuildID: guildID}
+	if err := cfg.Load(ctx); err != nil {
 		panic(err)
 	}
 	return &cfg
 }
 
-func (cfg *GuildConfig) Load() error {
-	return gokord.DB.Where("guild_id = ?", cfg.GuildID).Preload("XpRoles").FirstOrCreate(cfg).Error
+func (cfg *Guild) Load(ctx context.Context) error {
+	return common.GetDB(ctx).Where("guild_id = ?", cfg.GuildID).Preload("XpRoles").FirstOrCreate(cfg).Error
 }
 
-func (cfg *GuildConfig) Save() error {
-	return gokord.DB.Save(cfg).Error
+func (cfg *Guild) Save(ctx context.Context) error {
+	return common.GetDB(ctx).Save(cfg).Error
 }
 
-func (cfg *GuildConfig) IsDisabled(ctx context.Context, s bot.Session, channelID string) bool {
+func (cfg *Guild) IsDisabled(ctx context.Context, dg bot.Session, channelID string) bool {
 	ok := true
 	for channelID != "" && ok {
 		ok = !strings.Contains(cfg.DisabledChannels, channelID)
-		c, err := s.ChannelAPI().State.Channel(channelID)
+		c, err := dg.ChannelAPI().State.Channel(channelID)
 		if err != nil {
 			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 {
-					bot.Logger(ctx).Error("unable to add channel to state", "error", err, "channel", c)
-				}
-			} else {
+			c, err = dg.ChannelAPI().Channel(channelID).Do(ctx)
+			if err != nil {
 				bot.Logger(ctx).Error("unable to fetch channel", "error", err, "channel", c)
 				return false
 			}
@@ -78,7 +73,7 @@ func (cfg *GuildConfig) IsDisabled(ctx context.Context, s bot.Session, channelID
 	return !ok
 }
 
-func (cfg *GuildConfig) FindXpRole(roleID string) (int, *XpRole) {
+func (cfg *Guild) FindXpRole(roleID string) (int, *XpRole) {
 	for i, r := range cfg.XpRoles {
 		if r.RoleID == roleID {
 			return i, &r
@@ -87,7 +82,7 @@ func (cfg *GuildConfig) FindXpRole(roleID string) (int, *XpRole) {
 	return 0, nil
 }
 
-func (cfg *GuildConfig) FindXpRoleID(ID uint) (int, *XpRole) {
+func (cfg *Guild) FindXpRoleID(ID uint) (int, *XpRole) {
 	for i, r := range cfg.XpRoles {
 		if r.ID == ID {
 			return i, &r
diff --git a/config/xp_reduce.go b/config/xp_reduce.go
index f8f8d95..aa2c540 100644
--- a/config/xp_reduce.go
+++ b/config/xp_reduce.go
@@ -16,7 +16,7 @@ const (
 )
 
 func HandleModifyPeriodicReduceCommand(ctx context.Context, dg bot.Session, i *interaction.MessageComponent) {
-	cfg := GetGuildConfig(i.GuildID)
+	cfg := GetGuildConfig(ctx, i.GuildID)
 	resp := interaction.NewModalResponse().
 		CustomID(TimeReduceSet).
 		Title("Modifier la durée de l'expérience").
@@ -66,9 +66,9 @@ func HandleTimeReduceSet(ctx context.Context, dg bot.Session, i *interaction.Mod
 		}
 		return false
 	}
-	cfg := GetGuildConfig(i.GuildID)
+	cfg := GetGuildConfig(ctx, i.GuildID)
 	cfg.DaysXPRemains = uint(days)
-	err = cfg.Save()
+	err = cfg.Save(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("saving DaysXPRemains configuration", "error", err)
 		return false
diff --git a/config/xp_role.go b/config/xp_role.go
index 76389c9..edf5f61 100644
--- a/config/xp_role.go
+++ b/config/xp_role.go
@@ -6,9 +6,9 @@ import (
 	"slices"
 	"strconv"
 
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/dynamicid"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/exp"
-	"github.com/anhgelus/gokord"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/channel"
 	"github.com/nyttikord/gokord/component"
@@ -39,7 +39,7 @@ const (
 )
 
 func HandleXpRole(ctx context.Context, dg bot.Session, i *interaction.Interaction) {
-	cfg := GetGuildConfig(i.GuildID)
+	cfg := GetGuildConfig(ctx, i.GuildID)
 	container := component.Container{
 		Components: []component.Message{
 			&component.TextDisplay{Content: "## Configuration / Rôles de niveaux"},
@@ -121,14 +121,14 @@ func HandleXpRoleNew(ctx context.Context, dg bot.Session, i *interaction.Message
 			},
 		}).
 		Response()
-	err := dg.InteractionAPI().Respond(i.Interaction, resp)
+	err := dg.InteractionAPI().Respond(i.Interaction, resp).Do(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("sending modal to add", "error", err)
 	}
 }
 
 func HandleXpRoleEdit(ctx context.Context, dg bot.Session, i *interaction.Interaction, params *XpRoleId) {
-	config := GetGuildConfig(i.GuildID)
+	config := GetGuildConfig(ctx, i.GuildID)
 	id := params.ID
 	_, role := config.FindXpRoleID(id)
 	if role == nil {
@@ -181,7 +181,7 @@ func HandleXpRoleEdit(ctx context.Context, dg bot.Session, i *interaction.Intera
 		},
 	}
 
-	err := dg.InteractionAPI().Respond(i, response)
+	err := dg.InteractionAPI().Respond(i, response).Do(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("sending xp_role config", "error", err)
 	}
@@ -190,7 +190,7 @@ func HandleXpRoleEdit(ctx context.Context, dg bot.Session, i *interaction.Intera
 func HandleXpRoleEditRole(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *XpRoleId) {
 	id := params.ID
 	role := i.Data.Values[0]
-	cfg := GetGuildConfig(i.GuildID)
+	cfg := GetGuildConfig(ctx, i.GuildID)
 	_, xpRole := cfg.FindXpRoleID(id)
 	if xpRole == nil {
 		err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
@@ -199,14 +199,14 @@ func HandleXpRoleEditRole(ctx context.Context, dg bot.Session, i *interaction.Me
 				Flags:   channel.MessageFlagsEphemeral,
 				Content: "Impossible de modifier le rôle. Peut-être a-t-il été supprimé ?",
 			},
-		})
+		}).Do(ctx)
 		if err != nil {
 			bot.Logger(ctx).Error("sending unable to get role message", "error", err)
 		}
 		return
 	}
 	xpRole.RoleID = role
-	err := gokord.DB.Save(xpRole).Error
+	err := common.GetDB(ctx).Save(xpRole).Error
 	if err != nil {
 		bot.Logger(ctx).Error("saving config", "error", err, "guild", i.GuildID, "id", id, "type", "add")
 	}
@@ -215,7 +215,7 @@ func HandleXpRoleEditRole(ctx context.Context, dg bot.Session, i *interaction.Me
 
 func HandleXpRoleEditLevelStart(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *XpRoleId) {
 	id := params.ID
-	cfg := GetGuildConfig(i.GuildID)
+	cfg := GetGuildConfig(ctx, i.GuildID)
 	_, xpRole := cfg.FindXpRoleID(id)
 	if xpRole == nil {
 		err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
@@ -224,7 +224,7 @@ func HandleXpRoleEditLevelStart(ctx context.Context, dg bot.Session, i *interact
 				Flags:   channel.MessageFlagsEphemeral,
 				Content: "Impossible de trouver le rôle. Peut-être a-t-il été supprimé ?",
 			},
-		})
+		}).Do(ctx)
 		if err != nil {
 			bot.Logger(ctx).Error("sending unable to get role message", "error", err)
 		}
@@ -251,7 +251,7 @@ func HandleXpRoleEditLevelStart(ctx context.Context, dg bot.Session, i *interact
 			},
 		},
 	}
-	err := dg.InteractionAPI().Respond(i.Interaction, response)
+	err := dg.InteractionAPI().Respond(i.Interaction, response).Do(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("sending edit level modal", "error", err)
 	}
@@ -275,7 +275,7 @@ func HandleXpRoleEditLevel(ctx context.Context, dg bot.Session, i *interaction.M
 	}
 	xp := exp.LevelXP(uint(level))
 
-	cfg := GetGuildConfig(i.GuildID)
+	cfg := GetGuildConfig(ctx, i.GuildID)
 	_, xpRole := cfg.FindXpRoleID(id)
 	if xpRole == nil {
 		err = dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
@@ -291,7 +291,7 @@ func HandleXpRoleEditLevel(ctx context.Context, dg bot.Session, i *interaction.M
 		return
 	}
 	xpRole.XP = xp
-	err = gokord.DB.Save(xpRole).Error
+	err = common.GetDB(ctx).Save(xpRole).Error
 	if err != nil {
 		bot.Logger(ctx).Error("saving config", "guild", i.GuildID, "id", id, "type", "edit")
 	}
@@ -300,7 +300,7 @@ func HandleXpRoleEditLevel(ctx context.Context, dg bot.Session, i *interaction.M
 
 func HandleXpRoleDel(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, parameters *XpRoleId) {
 	id := parameters.ID
-	cfg := GetGuildConfig(i.GuildID)
+	cfg := GetGuildConfig(ctx, i.GuildID)
 	_, role := cfg.FindXpRoleID(id)
 	if role == nil {
 		err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
@@ -309,13 +309,13 @@ func HandleXpRoleDel(ctx context.Context, dg bot.Session, i *interaction.Message
 				Content: "Rôle introuvable. Peut-être a-t-il déjà été supprimé ?",
 				Flags:   channel.MessageFlagsEphemeral,
 			},
-		})
+		}).Do(ctx)
 		if err != nil {
 			bot.Logger(ctx).Error("sending role not found message", "error", err)
 		}
 		return
 	}
-	err := gokord.DB.Delete(role).Error
+	err := common.GetDB(ctx).Delete(role).Error
 	if err != nil {
 		bot.Logger(ctx).Error("deleting entry", "error", err, "guild", i.GuildID, "id", id, "type", "del")
 	}
@@ -342,12 +342,12 @@ func HandleXpRoleAdd(ctx context.Context, dg bot.Session, i *interaction.ModalSu
 
 	roleId := i.Data.Components[1].(*component.Label).Component.(*component.SelectMenu).Values[0]
 
-	cfg := GetGuildConfig(i.GuildID)
+	cfg := GetGuildConfig(ctx, i.GuildID)
 	cfg.XpRoles = append(cfg.XpRoles, XpRole{
 		XP:     xp,
 		RoleID: roleId,
 	})
-	err = cfg.Save()
+	err = cfg.Save(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("saving config", "error", err, "role", roleId, "guild", i.GuildID)
 		return
diff --git a/dynamicid/encoding.go b/dynamicid/encoding.go
index 23d00db..2dd216d 100644
--- a/dynamicid/encoding.go
+++ b/dynamicid/encoding.go
@@ -9,10 +9,10 @@ import (
 )
 
 var (
-	stringReflectType = reflect.TypeOf(string(""))
-	intReflectType    = reflect.TypeOf(int(0))
-	uintReflectType   = reflect.TypeOf(uint(0))
-	boolReflectType   = reflect.TypeOf(bool(false))
+	stringReflectType = reflect.TypeFor[string]()
+	intReflectType    = reflect.TypeFor[int]()
+	uintReflectType   = reflect.TypeFor[uint]()
+	boolReflectType   = reflect.TypeFor[bool]()
 )
 
 // UnmarshallCSV record into a struct in-place
diff --git a/events.go b/events.go
index eaed31e..4e9278d 100644
--- a/events.go
+++ b/events.go
@@ -23,12 +23,12 @@ var (
 	connectedSince = map[string]int64{}
 )
 
-func OnMessage(ctx context.Context, s bot.Session, m *event.MessageCreate) {
+func OnMessage(ctx context.Context, dg bot.Session, m *event.MessageCreate) {
 	if m.Author.Bot {
 		return
 	}
-	cfg := config.GetGuildConfig(m.GuildID)
-	if cfg.IsDisabled(ctx, s, m.ChannelID) {
+	cfg := config.GetGuildConfig(ctx, m.GuildID)
+	if cfg.IsDisabled(ctx, dg, m.ChannelID) {
 		return
 	}
 	cc := user.GetCopaing(ctx, m.Author.ID, m.GuildID)
@@ -37,34 +37,32 @@ func OnMessage(ctx context.Context, s bot.Session, m *event.MessageCreate) {
 	m.Member.User = m.Author
 	m.Member.GuildID = m.GuildID
 	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 {
+	cc.AddXP(ctx, dg, m.Member, xp, func(_ uint, _ uint) {
+		if err := dg.ChannelAPI().MessageReactionAdd(m.ChannelID, m.Message.ID, "⬆").Do(ctx); err != nil {
 			bot.Logger(ctx).Error(
 				"add reaction for new level",
-				"error", err,
-				"channel", m.ChannelID,
-				"message", m.Message.ID,
+				"error", err, "channel", m.ChannelID, "message", m.Message.ID,
 			)
 		}
 	})
 }
 
-func OnVoiceUpdate(ctx context.Context, s bot.Session, e *event.VoiceStateUpdate) {
+func OnVoiceUpdate(ctx context.Context, dg bot.Session, e *event.VoiceStateUpdate) {
 	if e.Member.User.Bot {
 		return
 	}
-	cfg := config.GetGuildConfig(e.GuildID)
-	dis := cfg.IsDisabled(ctx, s, e.BeforeUpdate.ChannelID)
+	cfg := config.GetGuildConfig(ctx, e.GuildID)
+	dis := cfg.IsDisabled(ctx, dg, e.BeforeUpdate.ChannelID)
 	if (e.BeforeUpdate == nil || dis) && e.ChannelID != "" {
 		if dis {
 			return
 		}
-		onConnection(ctx, s, e)
+		onConnection(ctx, dg, e)
 	} else if e.BeforeUpdate != nil && (e.ChannelID == "" || dis) {
 		if dis {
 			return
 		}
-		onDisconnect(ctx, s, e)
+		onDisconnect(ctx, dg, e)
 	}
 }
 
@@ -72,12 +70,12 @@ func genMapKey(guildID string, userID string) string {
 	return fmt.Sprintf("%s:%s", guildID, userID)
 }
 
-func onConnection(ctx context.Context, s bot.Session, e *event.VoiceStateUpdate) {
+func onConnection(ctx context.Context, dg bot.Session, e *event.VoiceStateUpdate) {
 	bot.Logger(ctx).Debug("user connected", "user", e.Member.DisplayName())
 	connectedSince[genMapKey(e.GuildID, e.UserID)] = time.Now().Unix()
 }
 
-func onDisconnect(ctx context.Context, s bot.Session, e *event.VoiceStateUpdate) {
+func onDisconnect(ctx context.Context, dg bot.Session, e *event.VoiceStateUpdate) {
 	now := time.Now().Unix()
 	cc := user.GetCopaing(ctx, e.UserID, e.GuildID)
 	// check the validity of user
@@ -99,12 +97,12 @@ func onDisconnect(ctx context.Context, s bot.Session, e *event.VoiceStateUpdate)
 	}
 	timeInVocal = min(timeInVocal, MaxTimeInVocal)
 	e.Member.GuildID = e.GuildID
-	cc.AddXP(ctx, s, e.Member, exp.VocalXP(uint(timeInVocal)), func(_ uint, newLevel uint) {
-		cfg := config.GetGuildConfig(e.GuildID)
+	cc.AddXP(ctx, dg, e.Member, exp.VocalXP(uint(timeInVocal)), func(_ uint, newLevel uint) {
+		cfg := config.GetGuildConfig(ctx, e.GuildID)
 		if len(cfg.FallbackChannel) == 0 {
 			return
 		}
-		_, err := s.ChannelAPI().MessageSend(cfg.FallbackChannel, fmt.Sprintf(
+		_, err := dg.ChannelAPI().MessageSend(cfg.FallbackChannel, fmt.Sprintf(
 			"%s est maintenant niveau %d", e.Member.Mention(), newLevel,
 		)).Do(ctx)
 		if err != nil {
@@ -113,7 +111,7 @@ func onDisconnect(ctx context.Context, s bot.Session, e *event.VoiceStateUpdate)
 	})
 }
 
-func OnLeave(ctx context.Context, s bot.Session, e *event.GuildMemberRemove) {
+func OnLeave(ctx context.Context, dg bot.Session, e *event.GuildMemberRemove) {
 	bot.Logger(ctx).Debug("leave event", "user", e.User.Username)
 	if e.User.Bot {
 		return
diff --git a/exp/functions.go b/exp/functions.go
index 681c135..8d5b3af 100644
--- a/exp/functions.go
+++ b/exp/functions.go
@@ -1,6 +1,7 @@
 package exp
 
 import (
+	"context"
 	"fmt"
 	"math"
 	"regexp"
@@ -8,7 +9,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/anhgelus/gokord"
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 )
 
 const DebugFactor = 30
@@ -66,9 +67,9 @@ func LevelXP(level uint) uint {
 }
 
 // TimeStampNDaysBefore returns the timestamp (year-month-day) n days before today
-func TimeStampNDaysBefore(n uint) string {
+func TimeStampNDaysBefore(ctx context.Context, n uint) string {
 	var unix time.Time
-	if gokord.Debug {
+	if common.IsDebug(ctx) {
 		unix = time.Unix(time.Now().Unix()-int64(DebugFactor*n), 0) // reduce time for debug
 	} else {
 		unix = time.Unix(time.Now().Unix()-int64(n*24*60*60), 0)
diff --git a/go.mod b/go.mod
index 3ef6124..f7e0c2f 100644
--- a/go.mod
+++ b/go.mod
@@ -3,7 +3,6 @@ module git.anhgelus.world/anhgelus/les-copaings-bot
 go 1.25.0
 
 require (
-	github.com/anhgelus/gokord v0.13.2-0.20251025205525-12213d3f60bc
 	github.com/jackc/pgx/v5 v5.7.5
 	github.com/joho/godotenv v1.5.1
 	github.com/nyttikord/gokord v0.33.1
diff --git a/go.sum b/go.sum
index bf2dec9..a89e73d 100644
--- a/go.sum
+++ b/go.sum
@@ -17,8 +17,6 @@ github.com/ajstarks/deck v0.0.0-20200831202436-30c9fc6549a9/go.mod h1:JynElWSGnm
 github.com/ajstarks/deck/generate v0.0.0-20210309230005-c3f852c02e19/go.mod h1:T13YZdzov6OU0A1+RfKZiZN9ca6VeKdBdyDV+BY97Tk=
 github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b h1:slYM766cy2nI3BwyRiyQj/Ud48djTMtMebDqepE95rw=
 github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b/go.mod h1:1KcenG0jGWcpt8ov532z81sp/kMMUG485J2InIOyADM=
-github.com/anhgelus/gokord v0.13.2-0.20251025205525-12213d3f60bc h1:pZHCOh4uGzjta371cNT8RDDPXgBE5udXLX3JyclFwiM=
-github.com/anhgelus/gokord v0.13.2-0.20251025205525-12213d3f60bc/go.mod h1:KOIi7EH/DzM9yUOTpuUHxPungpZYp7OLbwVyjQm3m2w=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
diff --git a/main.go b/main.go
index 3cfc289..3967bc4 100644
--- a/main.go
+++ b/main.go
@@ -22,7 +22,6 @@ import (
 	"github.com/nyttikord/gokord"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/discord"
-	"github.com/nyttikord/gokord/discord/types"
 	"github.com/nyttikord/gokord/event"
 	"github.com/nyttikord/gokord/interaction"
 	"golang.org/x/image/font/opentype"
@@ -80,14 +79,14 @@ func main() {
 		panic(err)
 	}
 
-	err = db.AutoMigrate(&user.Copaing{}, &config.GuildConfig{}, &config.XpRole{}, &user.CopaingXP{}, &config.RoleReactMessage{}, &config.RoleReact{})
+	err = db.AutoMigrate(&user.Copaing{}, &config.Guild{}, &config.XpRole{}, &user.CopaingXP{}, &config.RoleReactMessage{}, &config.RoleReact{})
 	if err != nil {
 		panic(err)
 	}
 
-	adm := int64(discord.PermissionManageGuild)
+	//adm := int64(discord.PermissionManageGuild)
 
-	ctx := user.SetState(context.Background(), user.NewState())
+	ctx := user.SetState(context.Background(), user.NewState(db))
 	ctx = common.SetDB(ctx, db)
 	ctx = common.SetDebug(ctx, cfg.Debug)
 	ctx = common.SetAuthor(ctx, cfg.Author)
@@ -161,11 +160,11 @@ func main() {
 
 	// related to rolereact
 	// TEMP BECAUSE (OLD) GOKORD DOES NOT SUPPORT COMMAND MESSAGE
-	events.AddHandler(func(ctx context.Context, s bot.Session, e *event.Ready) {
+	/*events.AddHandler(func(ctx context.Context, dg bot.Session, e *event.Ready) {
 		guildID := ""
 		logger := bot.Logger(ctx)
 		if common.IsDebug(ctx) {
-			gs, err := s.GuildAPI().UserGuilds(1, "", "", false).Do(ctx)
+			gs, err := dg.GuildAPI().UserGuilds(1, "", "", false).Do(ctx)
 			if err != nil {
 				logger.Error("fetching guilds for debug", "error", err)
 				return
@@ -179,26 +178,17 @@ func main() {
 			Name:                     "Modifier",
 			DefaultMemberPermissions: &adm,
 		}
-		c, err := s.InteractionAPI().
-			CommandCreate(s.SessionState().User().ID, guildID, &handleRolereactionMessageCmd).
+		c, err := dg.InteractionAPI().
+			CommandCreate(dg.SessionState().User().ID, guildID, &handleRolereactionMessageCmd).
 			Do(ctx)
 		if err != nil {
 			logger.Error("unable to push rolereaction message command", "error", err)
 			return
 		}
 		logger.Debug("pushed rolereaction message command", "CommandID", c.ID)
-	})
-	events.AddHandler(func(ct context.Context, s bot.Session, _ *event.Disconnect) {
-		user.PeriodicSaver(ctx, s)
-	})
-	events.AddHandler(func(ctx context.Context, s bot.Session, i *event.InteractionCreate) {
-		if i.Type != types.InteractionApplicationCommand {
-			return
-		}
-		cmd := i.Command()
-		if cmd.Data.Name == "Modifier" && cmd.Data.CommandType == types.CommandMessage {
-			rolereact.HandleModifyCommand(ctx, s, cmd)
-		}
+	})*/
+	events.AddHandler(func(ct context.Context, dg bot.Session, _ *event.Disconnect) {
+		user.PeriodicSaver(ctx, dg)
 	})
 	events.AddHandler(rolereact.HandleReactionAdd)
 	events.AddHandler(rolereact.HandleReactionRemove)
@@ -221,6 +211,7 @@ func main() {
 	intrs.HandleCommand("reset-user", commands.ResetUser)
 	intrs.HandleCommand("credits", commands.Credits)
 	intrs.HandleCommand("rolereact", rolereact.HandleCommand)
+	intrs.HandleCommand("Modifier", rolereact.HandleModifyCommand)
 
 	// interaction: /config
 	intrs.HandleMessageComponent(commands.OpenConfig, commands.ConfigMessageComponent)
diff --git a/rolereact/events.go b/rolereact/events.go
index 090b924..190c0d8 100644
--- a/rolereact/events.go
+++ b/rolereact/events.go
@@ -3,8 +3,8 @@ package rolereact
 import (
 	"context"
 
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/config"
-	oldGokord "github.com/anhgelus/gokord"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/event"
 )
@@ -13,28 +13,28 @@ type RoleReact struct {
 	RoleID string
 }
 
-func HandleReactionAdd(ctx context.Context, s bot.Session, e *event.MessageReactionAdd) {
+func HandleReactionAdd(ctx context.Context, dg bot.Session, e *event.MessageReactionAdd) {
 	results := []RoleReact{}
-	oldGokord.DB.Model(&config.RoleReact{}).
+	common.GetDB(ctx).Model(&config.RoleReact{}).
 		Joins("JOIN role_react_messages ON role_reacts.role_react_message_id = role_react_messages.id").
 		Where("role_react_messages.message_id = ? AND role_reacts.reaction = ?", e.MessageID, e.MessageReaction.Emoji.APIName()).
 		Scan(&results)
 	for _, role := range results {
-		err := s.GuildAPI().MemberRoleAdd(e.GuildID, e.UserID, role.RoleID)
+		err := dg.GuildAPI().MemberRoleAdd(e.GuildID, e.UserID, role.RoleID).Do(ctx)
 		if err != nil {
 			bot.Logger(ctx).Error("Unable to add role after member added reaction", "error", err)
 		}
 	}
 }
 
-func HandleReactionRemove(ctx context.Context, s bot.Session, e *event.MessageReactionRemove) {
+func HandleReactionRemove(ctx context.Context, dg bot.Session, e *event.MessageReactionRemove) {
 	results := []RoleReact{}
-	oldGokord.DB.Model(&config.RoleReact{}).
+	common.GetDB(ctx).Model(&config.RoleReact{}).
 		Joins("JOIN role_react_messages ON role_reacts.role_react_message_id = role_react_messages.id").
 		Where("role_react_messages.message_id = ? AND role_reacts.reaction = ?", e.MessageID, e.MessageReaction.Emoji.APIName()).
 		Scan(&results)
 	for _, role := range results {
-		err := s.GuildAPI().MemberRoleRemove(e.GuildID, e.UserID, role.RoleID)
+		err := dg.GuildAPI().MemberRoleRemove(e.GuildID, e.UserID, role.RoleID).Do(ctx)
 		if err != nil {
 			bot.Logger(ctx).Error("Unable to remove role after member removed reaction", "error", err)
 		}
diff --git a/rolereact/manager.go b/rolereact/manager.go
index ab268f2..1deee14 100644
--- a/rolereact/manager.go
+++ b/rolereact/manager.go
@@ -7,8 +7,8 @@ import (
 	"strings"
 	"time"
 
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/config"
-	oldGokord "github.com/anhgelus/gokord"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/channel"
 	"github.com/nyttikord/gokord/emoji"
@@ -32,9 +32,9 @@ func MessageContent(message *config.RoleReactMessage) string {
 	return content
 }
 
-func ApplyMessageChange(ctx context.Context, s bot.Session, i *interaction.Interaction, message *config.RoleReactMessage) string {
+func ApplyMessageChange(ctx context.Context, dg bot.Session, i *interaction.Interaction, message *config.RoleReactMessage) string {
 	messageContent := MessageContent(message)
-	_, err := s.ChannelAPI().MessageEditComplex(&channel.MessageEdit{
+	_, err := dg.ChannelAPI().MessageEditComplex(&channel.MessageEdit{
 		Content:         &messageContent,
 		AllowedMentions: &channel.MessageAllowedMentions{},
 		Channel:         message.ChannelID,
@@ -46,7 +46,7 @@ func ApplyMessageChange(ctx context.Context, s bot.Session, i *interaction.Inter
 	}
 	for _, role := range message.Roles {
 		if role.Reaction != "" && role.RoleID != "" && err == nil {
-			err = s.ChannelAPI().MessageReactionAdd(message.ChannelID, message.MessageID, role.Reaction).Do(ctx)
+			err = dg.ChannelAPI().MessageReactionAdd(message.ChannelID, message.MessageID, role.Reaction).Do(ctx)
 		}
 	}
 	if err != nil {
@@ -55,46 +55,49 @@ func ApplyMessageChange(ctx context.Context, s bot.Session, i *interaction.Inter
 	}
 	cfg := GetGuildConfigPreloaded(ctx, i.GuildID)
 	messageIndex := slices.IndexFunc(cfg.RrMessages, func(m config.RoleReactMessage) bool { return m.ID == message.ID })
-	if messageIndex != -1 {
-		oldMessage := cfg.RrMessages[messageIndex]
-		roles := make(map[uint]config.RoleReact, len(message.Roles))
-		for _, role := range message.Roles {
-			roles[role.ID] = *role
-		}
-		for _, role := range oldMessage.Roles {
-			_, ok := roles[role.ID]
-			if !ok {
-				err := oldGokord.DB.Delete(role).Error
-				if err != nil {
-					bot.Logger(ctx).Error("unable to delete reaction role from database", "error", err)
-					return "Impossible de sauvegarder le message de rôle. Merci de contacter l'administrateur du bot."
-				}
+	if messageIndex == -1 {
+		// should log it?
+		return "Impossible de mmettre à jour le message."
+	}
+	oldMessage := cfg.RrMessages[messageIndex]
+	roles := make(map[uint]config.RoleReact, len(message.Roles))
+	for _, role := range message.Roles {
+		roles[role.ID] = *role
+	}
+	db := common.GetDB(ctx)
+	for _, role := range oldMessage.Roles {
+		_, ok := roles[role.ID]
+		if !ok {
+			err := db.Delete(role).Error
+			if err != nil {
+				bot.Logger(ctx).Error("unable to delete reaction role from database", "error", err)
+				return "Impossible de sauvegarder le message de rôle. Merci de contacter l'administrateur du bot."
 			}
 		}
-		cfg.RrMessages[messageIndex] = *message
-		err := oldGokord.DB.Save(cfg.RrMessages[messageIndex]).Error
+	}
+	cfg.RrMessages[messageIndex] = *message
+	err = db.Save(cfg.RrMessages[messageIndex]).Error
+	if err != nil {
+		bot.Logger(ctx).Error("unable to save rolereaction message in database", "error", err)
+		return "Impossible de sauvegarder le message de rôle. Merci de contacter l'administrateur du bot."
+	}
+	for _, role := range cfg.RrMessages[messageIndex].Roles {
+		err = db.Save(role).Error
 		if err != nil {
-			bot.Logger(ctx).Error("unable to save rolereaction message in database", "error", err)
+			bot.Logger(ctx).Error("unable to save rolereaction role in database", "error", err)
 			return "Impossible de sauvegarder le message de rôle. Merci de contacter l'administrateur du bot."
 		}
-		for _, role := range cfg.RrMessages[messageIndex].Roles {
-			err = oldGokord.DB.Save(role).Error
-			if err != nil {
-				bot.Logger(ctx).Error("unable to save rolereaction role in database", "error", err)
-				return "Impossible de sauvegarder le message de rôle. Merci de contacter l'administrateur du bot."
-			}
-		}
 	}
 	return "Message de réaction mis à jour avec succès !"
 }
 
-func WaitForEmoji(ctx context.Context, s bot.Session, userID string, messageID string) (string, bool) {
+func WaitForEmoji(ctx context.Context, dg bot.Session, userID string, messageID string) (string, bool) {
 	ctx, cancel := context.WithTimeout(ctx, 1*time.Minute)
 	defer cancel()
 
 	emojiChann := make(chan emoji.Emoji)
 
-	cancelHandler := s.EventManager().AddHandler(func(s bot.Session, e *event.MessageReactionAdd) {
+	cancelHandler := dg.EventManager().AddHandler(func(_ bot.Session, e *event.MessageReactionAdd) {
 		if e.MessageID == messageID && e.UserID == userID {
 			emojiChann <- e.Emoji
 		}
@@ -110,8 +113,8 @@ func WaitForEmoji(ctx context.Context, s bot.Session, userID string, messageID s
 	}
 }
 
-func GetMessageFromEditID(i *interaction.Interaction, editID uint) (*config.RoleReactMessage, bool) {
-	cfg := config.GetGuildConfig(i.GuildID)
+func GetMessageFromEditID(ctx context.Context, i *interaction.Interaction, editID uint) (*config.RoleReactMessage, bool) {
+	cfg := config.GetGuildConfig(ctx, i.GuildID)
 	m, ok := messageEdits[editID]
 	if !ok || m.GuildConfigID != cfg.ID {
 		return &config.RoleReactMessage{}, false
@@ -119,10 +122,10 @@ func GetMessageFromEditID(i *interaction.Interaction, editID uint) (*config.Role
 	return m, true
 }
 
-func GetGuildConfigPreloaded(ctx context.Context, guildID string) *config.GuildConfig {
-	cfg := config.GuildConfig{GuildID: guildID}
+func GetGuildConfigPreloaded(ctx context.Context, guildID string) *config.Guild {
+	cfg := config.Guild{GuildID: guildID}
 	// err := oldGokord.DB.Where("guild_id = ?", cfg.GuildID).Preload("XpRoles").Preload("RrMessages.Roles").FirstOrCreate(cfg).Error
-	err := oldGokord.DB.Where("guild_id = ?", cfg.GuildID).Preload("RrMessages.Roles").FirstOrCreate(&cfg).Error
+	err := common.GetDB(ctx).Where("guild_id = ?", cfg.GuildID).Preload("RrMessages.Roles").FirstOrCreate(&cfg).Error
 	if err != nil {
 		panic(err)
 	}
diff --git a/rolereact/rolereact.go b/rolereact/rolereact.go
index 2830ab4..aef5fd3 100644
--- a/rolereact/rolereact.go
+++ b/rolereact/rolereact.go
@@ -2,7 +2,6 @@ package rolereact
 
 import (
 	"context"
-	"fmt"
 	"slices"
 
 	"git.anhgelus.world/anhgelus/les-copaings-bot/config"
@@ -70,24 +69,24 @@ func HandleCommand(ctx context.Context, dg bot.Session, i *interaction.Applicati
 	m, err := dg.ChannelAPI().MessageSendComplex(channelID, &channel.MessageSend{
 		Content:         messageContent,
 		AllowedMentions: &channel.MessageAllowedMentions{},
-	},
-	).Do(ctx)
+	}).Do(ctx)
 	if err != nil {
+		bot.Logger(ctx).Error("sending message", "error", err)
 		_, err := dg.InteractionAPI().FollowupMessageCreate(i.Interaction, false, &channel.WebhookParams{
 			Flags:      channel.MessageFlagsIsComponentsV2,
-			Components: []component.Message{&component.TextDisplay{Content: fmt.Sprintf("Impossible d'envoyer le message : %s", err.Error())}},
+			Components: []component.Message{&component.TextDisplay{Content: "Impossible d'envoyer le message"}},
 		}).Do(ctx)
 		if err != nil {
-			bot.Logger(ctx).Error("Unable to send message", "error", err)
+			bot.Logger(ctx).Error("unable to send message", "error", err)
 		}
 		return
 	}
 	message.MessageID = m.ID
 	cfg := GetGuildConfigPreloaded(ctx, i.GuildID)
 	cfg.RrMessages = append(cfg.RrMessages, message)
-	err = cfg.Save()
+	err = cfg.Save(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to save rolereact message in database", "error", err)
+		bot.Logger(ctx).Error("unable to save rolereact message in database", "error", err)
 		_, err := dg.InteractionAPI().FollowupMessageCreate(i.Interaction, false, &channel.WebhookParams{
 			Flags: channel.MessageFlagsIsComponentsV2,
 			Components: []component.Message{
@@ -104,7 +103,7 @@ func HandleCommand(ctx context.Context, dg bot.Session, i *interaction.Applicati
 	editID := messageCounter
 	messageCounter++
 
-	components := MessageModifyComponents(i.Interaction, &EditID{MessageEditID: editID})
+	components := MessageModifyComponents(ctx, i.Interaction, &EditID{MessageEditID: editID})
 	// Using this function here is deprecated as per discord documentation.
 	// That said, using the recommended EditResponse endpoint does not allow the use of
 	// version 2 components...
@@ -113,7 +112,7 @@ func HandleCommand(ctx context.Context, dg bot.Session, i *interaction.Applicati
 		Components: components,
 	}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to send edit rolereact message", "error", err)
+		bot.Logger(ctx).Error("unable to send edit rolereact message", "error", err)
 	}
 }
 
@@ -144,7 +143,7 @@ func HandleModifyCommand(ctx context.Context, dg bot.Session, i *interaction.App
 				},
 			}).Do(ctx)
 			if err != nil {
-				logger.Error("Unable to send rolereact message not found", "error", err)
+				logger.Error("unable to send rolereact message not found", "error", err)
 			}
 			return
 		}
@@ -157,22 +156,22 @@ func HandleModifyCommand(ctx context.Context, dg bot.Session, i *interaction.App
 		Data: MessageModifyData(ctx, i.Interaction, &EditID{MessageEditID: targetEditID}),
 	}).Do(ctx)
 	if err != nil {
-		logger.Error("Unable to send modify rolereact message", "error", err)
+		logger.Error("unable to send modify rolereact message", "error", err)
 	}
 }
 
-func HandleModifyComponent(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditID) {
-	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+func HandleModifyComponent(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *EditID) {
+	err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: MessageModifyData(ctx, i.Interaction, params),
 	}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to send modify rolereact message", "error", err)
+		bot.Logger(ctx).Error("unable to send modify rolereact message", "error", err)
 	}
 }
 
-func HandleResetMessage(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditID) {
-	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
+func HandleResetMessage(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *EditID) {
+	message, ok := GetMessageFromEditID(ctx, i.Interaction, params.MessageEditID)
 	var responseData interaction.ResponseData
 	if !ok {
 		responseData = interaction.ResponseData{
@@ -190,19 +189,19 @@ func HandleResetMessage(ctx context.Context, s bot.Session, i *interaction.Messa
 		}
 		responseData = *MessageModifyData(ctx, i.Interaction, params)
 	}
-	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+	err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: &responseData,
-	})
+	}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to send reset message message", "error", err)
+		bot.Logger(ctx).Error("unable to send reset message message", "error", err)
 	}
 }
 
-func HandleStartSetNote(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditID) {
-	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
+func HandleStartSetNote(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *EditID) {
+	message, ok := GetMessageFromEditID(ctx, i.Interaction, params.MessageEditID)
 	if !ok {
-		err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+		err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseUpdateMessage,
 			Data: &interaction.ResponseData{
 				Flags: channel.MessageFlagsEphemeral | channel.MessageFlagsIsComponentsV2,
@@ -210,9 +209,9 @@ func HandleStartSetNote(ctx context.Context, s bot.Session, i *interaction.Messa
 					&component.TextDisplay{Content: "Impossible de trouver la modification de message. Veuillez réessayer."},
 				},
 			},
-		})
+		}).Do(ctx)
 		if err != nil {
-			bot.Logger(ctx).Error("Unable to send message edit not found message", "error", err)
+			bot.Logger(ctx).Error("unable to send message edit not found message", "error", err)
 		}
 		return
 	}
@@ -230,16 +229,16 @@ func HandleStartSetNote(ctx context.Context, s bot.Session, i *interaction.Messa
 			},
 		}).
 		Response()
-	err := s.InteractionAPI().Respond(i.Interaction, resp).Do(ctx)
+	err := dg.InteractionAPI().Respond(i.Interaction, resp).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to send edit note modal", "error", err)
+		bot.Logger(ctx).Error("unable to send edit note modal", "error", err)
 	}
 }
 
-func HandleSetNote(ctx context.Context, s bot.Session, i *interaction.ModalSubmit, params *EditID) {
-	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
+func HandleSetNote(ctx context.Context, dg bot.Session, i *interaction.ModalSubmit, params *EditID) {
+	message, ok := GetMessageFromEditID(ctx, i.Interaction, params.MessageEditID)
 	if !ok {
-		err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+		err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseUpdateMessage,
 			Data: &interaction.ResponseData{
 				Flags: channel.MessageFlagsEphemeral | channel.MessageFlagsIsComponentsV2,
@@ -247,24 +246,24 @@ func HandleSetNote(ctx context.Context, s bot.Session, i *interaction.ModalSubmi
 					&component.TextDisplay{Content: "Impossible de trouver la modification de message. Veuillez réessayer."},
 				},
 			},
-		})
+		}).Do(ctx)
 		if err != nil {
 			bot.Logger(ctx).Error("unable to send set note error message", "error", err)
 		}
 		return
 	}
 	message.Note = i.Data.Components[0].(*component.Label).Component.(*component.TextInput).Value
-	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+	err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: MessageModifyData(ctx, i.Interaction, params),
-	})
+	}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to send updated note message", "error", err)
+		bot.Logger(ctx).Error("unable to send updated note message", "error", err)
 	}
 }
 
-func HandleApplyMessage(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditID) {
-	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
+func HandleApplyMessage(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *EditID) {
+	message, ok := GetMessageFromEditID(ctx, i.Interaction, params.MessageEditID)
 	var responseData interaction.ResponseData
 	if !ok {
 		responseData = interaction.ResponseData{
@@ -273,34 +272,34 @@ func HandleApplyMessage(ctx context.Context, s bot.Session, i *interaction.Messa
 				&component.TextDisplay{Content: "Impossible de trouver la modification de message. Veuillez réessayer."},
 			},
 		}
-		err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+		err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseUpdateMessage,
 			Data: &responseData,
-		})
+		}).Do(ctx)
 		if err != nil {
 			bot.Logger(ctx).Error("unable to send apply message error message", "error", err)
 		}
 		return
 	}
-	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+	err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseDeferredChannelMessageWithSource,
 		Data: &interaction.ResponseData{Flags: channel.MessageFlagsEphemeral},
 	}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to defer interaction", "error", err)
+		bot.Logger(ctx).Error("unable to defer interaction", "error", err)
 		return
 	}
-	m := ApplyMessageChange(ctx, s, i.Interaction, message)
-	_, err = s.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
+	m := ApplyMessageChange(ctx, dg, i.Interaction, message)
+	_, err = dg.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
 		Content: &m,
 	}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to send apply rolereaction message changes", "error", err)
+		bot.Logger(ctx).Error("unable to send apply rolereaction message changes", "error", err)
 	}
 }
 
-func HandleNewRole(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditID) {
-	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
+func HandleNewRole(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *EditID) {
+	message, ok := GetMessageFromEditID(ctx, i.Interaction, params.MessageEditID)
 	var responseData interaction.ResponseData
 	if !ok {
 		responseData = interaction.ResponseData{
@@ -311,20 +310,20 @@ func HandleNewRole(ctx context.Context, s bot.Session, i *interaction.MessageCom
 		}
 	} else {
 		message.Roles = append(message.Roles, &config.RoleReact{CounterID: roleCounter})
-		responseData = MessageModifyRoleData(i.Interaction, &EditIDWithRole{MessageEditID: params.MessageEditID, RoleCounterID: roleCounter}, "")
+		responseData = MessageModifyRoleData(ctx, i.Interaction, &EditIDWithRole{MessageEditID: params.MessageEditID, RoleCounterID: roleCounter}, "")
 		roleCounter++
 	}
-	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+	err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: &responseData,
-	})
+	}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to send modify reaction role message", "error", err)
+		bot.Logger(ctx).Error("unable to send modify reaction role message", "error", err)
 	}
 }
 
-func HandleOpenRole(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
-	_, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
+func HandleOpenRole(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
+	_, ok := GetMessageFromEditID(ctx, i.Interaction, params.MessageEditID)
 	var responseData interaction.ResponseData
 	if !ok {
 		responseData = interaction.ResponseData{
@@ -334,19 +333,19 @@ func HandleOpenRole(ctx context.Context, s bot.Session, i *interaction.MessageCo
 			},
 		}
 	} else {
-		responseData = MessageModifyRoleData(i.Interaction, params, "")
+		responseData = MessageModifyRoleData(ctx, i.Interaction, params, "")
 	}
-	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+	err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: &responseData,
-	})
+	}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to send open reaction role message", "error", err)
+		bot.Logger(ctx).Error("unable to send open reaction role message", "error", err)
 	}
 }
 
-func HandleSetRole(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
-	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
+func HandleSetRole(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
+	message, ok := GetMessageFromEditID(ctx, i.Interaction, params.MessageEditID)
 	var responseData interaction.ResponseData
 	var role *config.RoleReact
 	if ok {
@@ -364,19 +363,19 @@ func HandleSetRole(ctx context.Context, s bot.Session, i *interaction.MessageCom
 		}
 	} else {
 		role.RoleID = i.Data.Values[0]
-		responseData = MessageModifyRoleData(i.Interaction, params, "")
+		responseData = MessageModifyRoleData(ctx, i.Interaction, params, "")
 	}
-	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+	err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: &responseData,
 	}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to send open reaction role message", "error", err)
+		bot.Logger(ctx).Error("unable to send open reaction role message", "error", err)
 	}
 }
 
-func HandleSetReaction(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
-	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
+func HandleSetReaction(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
+	message, ok := GetMessageFromEditID(ctx, i.Interaction, params.MessageEditID)
 	var role *config.RoleReact
 	if ok {
 		roleIndex := slices.IndexFunc(message.Roles, func(role *config.RoleReact) bool { return role.CounterID == params.RoleCounterID })
@@ -385,7 +384,7 @@ func HandleSetReaction(ctx context.Context, s bot.Session, i *interaction.Messag
 		}
 	}
 	if !ok || role == nil {
-		err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+		err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseUpdateMessage,
 			Data: &interaction.ResponseData{
 				Flags: channel.MessageFlagsEphemeral | channel.MessageFlagsIsComponentsV2,
@@ -395,20 +394,20 @@ func HandleSetReaction(ctx context.Context, s bot.Session, i *interaction.Messag
 			},
 		}).Do(ctx)
 		if err != nil {
-			bot.Logger(ctx).Error("Unable to send open reaction role message", "error", err)
+			bot.Logger(ctx).Error("unable to send open reaction role message", "error", err)
 		}
 		return
 	}
-	responseData := MessageModifyRoleData(i.Interaction, params, "Ajoute la réaction que tu veux choisir au message de rôle de réaction (tu peux y accéder avec le bouton ci-dessous)")
+	responseData := MessageModifyRoleData(ctx, i.Interaction, params, "Ajoute la réaction que tu veux choisir au message de rôle de réaction (tu peux y accéder avec le bouton ci-dessous)")
 	//TODO: handle errors here
-	s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+	dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: &responseData,
 	}).Do(ctx)
-	emojiName, ok := WaitForEmoji(ctx, s, i.Member.User.ID, message.MessageID)
+	emojiName, ok := WaitForEmoji(ctx, dg, i.Member.User.ID, message.MessageID)
 	if !ok {
-		editResponseComponents := MessageModifyRoleComponents(i.Interaction, params, "Le temps d'attente a été dépassé")
-		_, err := s.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
+		editResponseComponents := MessageModifyRoleComponents(ctx, i.Interaction, params, "Le temps d'attente a été dépassé")
+		_, err := dg.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
 			Components: &editResponseComponents,
 		}).Do(ctx)
 		if err != nil {
@@ -417,10 +416,10 @@ func HandleSetReaction(ctx context.Context, s bot.Session, i *interaction.Messag
 		return
 	}
 
-	err := s.ChannelAPI().MessageReactionAdd(message.ChannelID, message.MessageID, emojiName).Do(ctx)
+	err := dg.ChannelAPI().MessageReactionAdd(message.ChannelID, message.MessageID, emojiName).Do(ctx)
 	if err != nil {
-		editResponseComponents := MessageModifyRoleComponents(i.Interaction, params, "La réaction n'est pas utilisable. Cela peut être résolu en l'ajoutant à ce serveur")
-		_, err := s.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
+		editResponseComponents := MessageModifyRoleComponents(ctx, i.Interaction, params, "La réaction n'est pas utilisable. Cela peut être résolu en l'ajoutant à ce serveur")
+		_, err := dg.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
 			Components: &editResponseComponents,
 		}).Do(ctx)
 		if err != nil {
@@ -428,29 +427,29 @@ func HandleSetReaction(ctx context.Context, s bot.Session, i *interaction.Messag
 		}
 		return
 	}
-	err = s.ChannelAPI().MessageReactionRemove(message.ChannelID, message.MessageID, emojiName, i.Member.User.ID).Do(ctx)
+	err = dg.ChannelAPI().MessageReactionRemove(message.ChannelID, message.MessageID, emojiName, i.Member.User.ID).Do(ctx)
 	if err != nil {
 		bot.Logger(ctx).Warn("unable to remove author reaction from message", "error", err)
 	}
 	role.Reaction = emojiName
-	components := MessageModifyRoleComponents(i.Interaction, params, "")
-	_, err = s.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
+	components := MessageModifyRoleComponents(ctx, i.Interaction, params, "")
+	_, err = dg.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
 		Flags:      channel.MessageFlagsIsComponentsV2 | channel.MessageFlagsEphemeral,
 		Components: &components,
 	}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to edit original response", "error", err)
+		bot.Logger(ctx).Error("unable to edit original response", "error", err)
 	}
 }
 
-func HandleDelRole(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
-	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
+func HandleDelRole(ctx context.Context, dg bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
+	message, ok := GetMessageFromEditID(ctx, i.Interaction, params.MessageEditID)
 	roleIndex := -1
 	if ok {
 		roleIndex = slices.IndexFunc(message.Roles, func(role *config.RoleReact) bool { return role.CounterID == params.RoleCounterID })
 	}
 	if !ok || roleIndex == -1 {
-		err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+		err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseUpdateMessage,
 			Data: &interaction.ResponseData{
 				Flags: channel.MessageFlagsEphemeral | channel.MessageFlagsIsComponentsV2,
@@ -460,19 +459,19 @@ func HandleDelRole(ctx context.Context, s bot.Session, i *interaction.MessageCom
 			},
 		}).Do(ctx)
 		if err != nil {
-			bot.Logger(ctx).Error("Unable to send open reaction role message", "error", err)
+			bot.Logger(ctx).Error("unable to send open reaction role message", "error", err)
 		}
 		return
 	}
 	message.Roles = append(message.Roles[:roleIndex],
 		message.Roles[roleIndex+1:]...,
 	)
-	err := s.InteractionAPI().Respond(i.Interaction,
+	err := dg.InteractionAPI().Respond(i.Interaction,
 		&interaction.Response{
 			Type: types.InteractionResponseUpdateMessage,
 			Data: MessageModifyData(ctx, i.Interaction, &EditID{MessageEditID: params.MessageEditID}),
 		}).Do(ctx)
 	if err != nil {
-		bot.Logger(ctx).Error("Unable to send modify message message", "error", err)
+		bot.Logger(ctx).Error("unable to send modify message message", "error", err)
 	}
 }
diff --git a/rolereact/views.go b/rolereact/views.go
index 7b31ec4..47aa4f6 100644
--- a/rolereact/views.go
+++ b/rolereact/views.go
@@ -13,8 +13,8 @@ import (
 	"github.com/nyttikord/gokord/interaction"
 )
 
-func MessageModifyComponents(i *interaction.Interaction, params *EditID) []component.Message {
-	message, ok := GetMessageFromEditID(i, params.MessageEditID)
+func MessageModifyComponents(ctx context.Context, i *interaction.Interaction, params *EditID) []component.Message {
+	message, ok := GetMessageFromEditID(ctx, i, params.MessageEditID)
 	if !ok {
 		return []component.Message{
 			&component.TextDisplay{Content: "Cette modification est trop vieille et a été oubliée."},
@@ -110,7 +110,7 @@ func MessageModifyComponents(i *interaction.Interaction, params *EditID) []compo
 
 func MessageModifyData(ctx context.Context, i *interaction.Interaction, params *EditID) *interaction.ResponseData {
 	components := []component.Component{}
-	for _, component := range MessageModifyComponents(i, params) {
+	for _, component := range MessageModifyComponents(ctx, i, params) {
 		components = append(components, component)
 	}
 	responseData := &interaction.ResponseData{
@@ -120,8 +120,8 @@ func MessageModifyData(ctx context.Context, i *interaction.Interaction, params *
 	return responseData
 }
 
-func MessageModifyRoleComponents(i *interaction.Interaction, params *EditIDWithRole, emojiMessage string) []component.Message {
-	message, ok := GetMessageFromEditID(i, params.MessageEditID)
+func MessageModifyRoleComponents(ctx context.Context, i *interaction.Interaction, params *EditIDWithRole, emojiMessage string) []component.Message {
+	message, ok := GetMessageFromEditID(ctx, i, params.MessageEditID)
 	var role *config.RoleReact
 	if ok {
 		roleIndex := slices.IndexFunc(message.Roles, func(role *config.RoleReact) bool { return role.CounterID == params.RoleCounterID })
@@ -205,9 +205,9 @@ func MessageModifyRoleComponents(i *interaction.Interaction, params *EditIDWithR
 	}}
 }
 
-func MessageModifyRoleData(i *interaction.Interaction, params *EditIDWithRole, emojiMessage string) interaction.ResponseData {
+func MessageModifyRoleData(ctx context.Context, i *interaction.Interaction, params *EditIDWithRole, emojiMessage string) interaction.ResponseData {
 	components := []component.Component{}
-	for _, component := range MessageModifyRoleComponents(i, params, emojiMessage) {
+	for _, component := range MessageModifyRoleComponents(ctx, i, params, emojiMessage) {
 		components = append(components, component)
 	}
 	return interaction.ResponseData{
diff --git a/user/level.go b/user/level.go
index feec35b..0b839d1 100644
--- a/user/level.go
+++ b/user/level.go
@@ -6,20 +6,20 @@ import (
 	"sync"
 	"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"
-	"github.com/anhgelus/gokord"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/user"
 )
 
-func onNewLevel(ctx context.Context, s bot.Session, m *user.Member, level uint) {
-	cfg := config.GetGuildConfig(m.GuildID)
+func onNewLevel(ctx context.Context, dg bot.Session, m *user.Member, level uint) {
+	cfg := config.GetGuildConfig(ctx, m.GuildID)
 	xpForLevel := exp.LevelXP(level)
 	for _, role := range cfg.XpRoles {
 		if role.XP <= xpForLevel && !slices.Contains(m.Roles, role.RoleID) {
 			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)
+			err := dg.GuildAPI().MemberRoleAdd(m.GuildID, m.User.ID, role.RoleID).Do(ctx)
 			if err != nil {
 				bot.Logger(ctx).Error(
 					"adding role",
@@ -28,7 +28,7 @@ func onNewLevel(ctx context.Context, s bot.Session, m *user.Member, level uint)
 			}
 		} else if role.XP > xpForLevel && slices.Contains(m.Roles, role.RoleID) {
 			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)
+			err := dg.GuildAPI().MemberRoleRemove(m.GuildID, m.User.ID, role.RoleID).Do(ctx)
 			if err != nil {
 				bot.Logger(ctx).Error(
 					"removing role",
@@ -39,17 +39,17 @@ func onNewLevel(ctx context.Context, s bot.Session, m *user.Member, level uint)
 	}
 }
 
-func (c *CopaingCached) onNewLevel(ctx context.Context, s bot.Session, level uint) {
-	m, err := s.GuildAPI().Member(c.GuildID, c.DiscordID).Do(ctx)
+func (c *CopaingCached) onNewLevel(ctx context.Context, dg bot.Session, level uint) {
+	m, err := dg.GuildAPI().Member(c.GuildID, c.DiscordID).Do(ctx)
 	if err != nil {
 		bot.Logger(ctx).Error("getting member for new level", "error", err, "user", c.DiscordID, "guild", c.GuildID)
 		return
 	}
-	onNewLevel(ctx, s, m, level)
+	onNewLevel(ctx, dg, m, level)
 }
 
-func PeriodicReducer(ctx context.Context, s bot.Session) {
-	PeriodicSaver(ctx, s)
+func PeriodicReducer(ctx context.Context, dg bot.Session) {
+	PeriodicSaver(ctx, dg)
 
 	logger := bot.Logger(ctx)
 	logger.Debug("periodic reducer")
@@ -58,12 +58,12 @@ func PeriodicReducer(ctx context.Context, s bot.Session) {
 
 	n := 0
 	var wg sync.WaitGroup
-	for _, g := range s.GuildAPI().State.Guilds() {
+	for _, g := range dg.GuildAPI().State.Guilds() {
 		n++
-		cfg := config.GetGuildConfig(g)
-		res := gokord.DB.
+		cfg := config.GetGuildConfig(ctx, g)
+		res := common.GetDB(ctx).
 			Model(&CopaingXP{}).
-			Where("guild_id = ? and created_at < ?", g, exp.TimeStampNDaysBefore(cfg.DaysXPRemains)).
+			Where("guild_id = ? and created_at < ?", g, exp.TimeStampNDaysBefore(ctx, cfg.DaysXPRemains)).
 			Delete(&CopaingXP{})
 		if res.Error != nil {
 			logger.Error("removing old xp", "error", res.Error, "guild", g)
@@ -72,7 +72,7 @@ func PeriodicReducer(ctx context.Context, s bot.Session) {
 		logger.Debug("guild cleaned", "guild", g, "rows affected", res.RowsAffected)
 
 		wg.Go(func() {
-			syncCopaings(ctx, s, state.Copaings(g))
+			syncCopaings(ctx, dg, state.Copaings(g))
 		})
 	}
 
@@ -81,7 +81,7 @@ func PeriodicReducer(ctx context.Context, s bot.Session) {
 	logger.Debug("periodic reduce finished", "guilds affected", n)
 }
 
-func syncCopaings(ctx context.Context, s bot.Session, ccs []CopaingCached) {
+func syncCopaings(ctx context.Context, dg bot.Session, ccs []CopaingCached) {
 	logger := bot.Logger(ctx)
 	for i, cc := range ccs {
 		if i%50 == 49 {
@@ -96,12 +96,12 @@ func syncCopaings(ctx context.Context, s bot.Session, ccs []CopaingCached) {
 		}
 		xp := cc.XP
 		if exp.Level(oldXp) != exp.Level(xp) {
-			cc.onNewLevel(ctx, s, exp.Level(xp))
+			cc.onNewLevel(ctx, dg, exp.Level(xp))
 		}
 	}
 }
 
-func PeriodicSaver(ctx context.Context, s bot.Session) {
+func PeriodicSaver(ctx context.Context, dg bot.Session) {
 	logger := bot.Logger(ctx)
 	logger.Debug("saving state in DB")
 	err := saveStateInDB(ctx)
diff --git a/user/member.go b/user/member.go
index 4969f8a..e3a1d30 100644
--- a/user/member.go
+++ b/user/member.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"github.com/anhgelus/gokord"
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 )
 
 type Copaing struct {
@@ -32,7 +32,7 @@ func GetCopaing(ctx context.Context, discordID string, guildID string) *CopaingC
 	cc, err := state.Copaing(guildID, discordID)
 	if err != nil {
 		c := Copaing{DiscordID: discordID, GuildID: guildID}
-		if err := c.load(); err != nil {
+		if err := c.load(ctx); err != nil {
 			panic(err)
 		}
 		cc = FromCopaing(&c)
@@ -40,8 +40,8 @@ func GetCopaing(ctx context.Context, discordID string, guildID string) *CopaingC
 	return cc
 }
 
-func (c *Copaing) load() error {
-	err := gokord.DB.
+func (c *Copaing) load(ctx context.Context) error {
+	err := common.GetDB(ctx).
 		Where("discord_id = ? and guild_id = ?", c.DiscordID, c.GuildID).
 		Preload("CopaingXPs").
 		FirstOrCreate(c).
@@ -52,17 +52,18 @@ func (c *Copaing) load() error {
 	return err
 }
 
-func (c *Copaing) Save() error {
-	return gokord.DB.Save(c).Error
+func (c *Copaing) Save(ctx context.Context) error {
+	return common.GetDB(ctx).Save(c).Error
 }
 
-func (c *Copaing) Delete() error {
-	err := gokord.DB.
+func (c *Copaing) Delete(ctx context.Context) error {
+	db := common.GetDB(ctx)
+	err := db.
 		Where("copaing_id = ? and guild_id = ?", c.ID, c.GuildID).
 		Delete(&CopaingXP{}).
 		Error
 	if err != nil {
 		return err
 	}
-	return gokord.DB.Where("guild_id = ? AND discord_id = ?", c.GuildID, c.DiscordID).Delete(c).Error
+	return db.Where("guild_id = ? AND discord_id = ?", c.GuildID, c.DiscordID).Delete(c).Error
 }
diff --git a/user/state.go b/user/state.go
index 2c27fef..12b1de3 100644
--- a/user/state.go
+++ b/user/state.go
@@ -7,8 +7,9 @@ import (
 	"sync"
 	"time"
 
-	"github.com/anhgelus/gokord"
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"github.com/nyttikord/gokord/state"
+	"gorm.io/gorm"
 )
 
 var ErrSyncingUnsavedData = errors.New("trying to sync unsaved data")
@@ -33,9 +34,9 @@ type CopaingCached struct {
 // - save the copaing in the database, use CopaingCached.SaveInDB for that;
 // - sync the copaing cached, use CopaingCached.Sync for that.
 // TL;DR: don't use this method, unless you know what are you doing.
-func (cc *CopaingCached) copaing() *Copaing {
+func (cc *CopaingCached) copaing(ctx context.Context) *Copaing {
 	c := &Copaing{DiscordID: cc.DiscordID, GuildID: cc.GuildID}
-	if err := c.load(); err != nil {
+	if err := c.load(ctx); err != nil {
 		panic(err)
 	}
 	return c
@@ -45,7 +46,7 @@ func (cc *CopaingCached) Sync(ctx context.Context) error {
 	if cc.mustSave() {
 		return ErrSyncingUnsavedData
 	}
-	synced := FromCopaing(cc.copaing())
+	synced := FromCopaing(cc.copaing(ctx))
 	synced.XP += cc.XPToAdd
 	synced.XPToAdd = cc.XPToAdd
 	err := synced.Save(ctx)
@@ -66,9 +67,9 @@ func (cc *CopaingCached) Save(ctx context.Context) error {
 }
 
 func (cc *CopaingCached) SaveInDB(ctx context.Context) error {
-	c := cc.copaing()
+	c := cc.copaing(ctx)
 	c.CopaingXPs = append(c.CopaingXPs, CopaingXP{CopaingID: c.ID, XP: cc.XPToAdd, GuildID: c.GuildID})
-	err := c.Save()
+	err := c.Save(ctx)
 	if err != nil {
 		return err
 	}
@@ -77,8 +78,8 @@ func (cc *CopaingCached) SaveInDB(ctx context.Context) error {
 }
 
 func (cc *CopaingCached) Delete(ctx context.Context) error {
-	c := cc.copaing()
-	err := c.Delete()
+	c := cc.copaing(ctx)
+	err := c.Delete(ctx)
 	if err != nil {
 		return err
 	}
@@ -138,12 +139,12 @@ type State struct {
 	storage  state.MapStorage[CopaingCached]
 }
 
-func NewState() *State {
+func NewState(db *gorm.DB) *State {
 	state := &State{
 		storage: state.MapStorage[CopaingCached]{},
 	}
 	var cs []*Copaing
-	err := gokord.DB.Find(&cs).Error
+	err := db.Find(&cs).Error
 	if err != nil {
 		panic(err)
 	}
@@ -153,14 +154,12 @@ func NewState() *State {
 	return state
 }
 
-const ContextKeyState = "state"
-
 func GetState(ctx context.Context) *State {
-	return ctx.Value(ContextKeyState).(*State)
+	return ctx.Value(common.KeyCopaingState).(*State)
 }
 
 func SetState(ctx context.Context, state *State) context.Context {
-	return context.WithValue(ctx, ContextKeyState, state)
+	return context.WithValue(ctx, common.KeyCopaingState, state)
 }
 
 func deepCopy(src CopaingCached) CopaingCached {
diff --git a/user/xp.go b/user/xp.go
index ca08258..d2b7ca6 100644
--- a/user/xp.go
+++ b/user/xp.go
@@ -23,7 +23,7 @@ func (c *cXP) GetXP() uint {
 	return c.Cxp
 }
 
-func (cc *CopaingCached) AddXP(ctx context.Context, s bot.Session, m *user.Member, xp uint, fn func(uint, uint)) {
+func (cc *CopaingCached) AddXP(ctx context.Context, dg bot.Session, m *user.Member, xp uint, fn func(uint, uint)) {
 	old := cc.XP
 	pastLevel := exp.Level(old)
 	bot.Logger(ctx).Debug("adding xp", "user", m.DisplayName(), "old", old, "to add", xp)
@@ -39,7 +39,7 @@ func (cc *CopaingCached) AddXP(ctx context.Context, s bot.Session, m *user.Membe
 	newLevel := exp.Level(old + xp)
 	if newLevel > pastLevel {
 		fn(old+xp, newLevel)
-		onNewLevel(ctx, s, m, newLevel)
+		onNewLevel(ctx, dg, m, newLevel)
 	}
 }