feat(config): preload role reactfeat/leave-gorm

11 files changed, 233 insertions, 116 deletions

diff --git a/commands/config.go b/commands/config.go
index 4535203..867aec1 100644
--- a/commands/config.go
+++ b/commands/config.go
@@ -25,7 +25,7 @@ func ConfigResponse(ctx context.Context, guildID uint64) *interaction.Response {
 	cfg := config.GetGuild(ctx, guildID)
 	roles := ""
 	l := len(cfg.XpRoles) - 1
-	slices.SortFunc(cfg.XpRoles, func(xp1, xp2 config.XpRole) int {
+	slices.SortFunc(cfg.XpRoles, func(xp1, xp2 *config.XpRole) int {
 		return int(xp2.XP) - int(xp1.XP)
 	})
 	for i, r := range cfg.XpRoles {
diff --git a/common/db.go b/common/db.go
index 76e39a2..992ca37 100644
--- a/common/db.go
+++ b/common/db.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"database/sql"
 	"embed"
+	"errors"
 	"fmt"
 	"log/slog"
 	"path"
@@ -55,3 +56,32 @@ func Migrate(ctx context.Context, log *slog.Logger, db *sql.DB, migrations embed
 	}
 	return nil
 }
+
+type Loadable interface {
+	Load(context.Context, *sql.DB, *sql.Rows) error
+}
+
+func GetValues[T Loadable](ctx context.Context, db *sql.DB, table, data, where string, args ...any) ([]T, error) {
+	arr := make([]T, 0)
+	rows, err := db.QueryContext(
+		ctx,
+		fmt.Sprintf(`SELECT %s FROM %s WHERE %s`, data, table, where),
+		args...,
+	)
+	if err != nil {
+		if !errors.Is(err, sql.ErrNoRows) {
+			return arr, err
+		}
+	} else {
+		defer rows.Close()
+		for rows.Next() {
+			var v T
+			err = v.Load(ctx, db, rows)
+			if err != nil {
+				return nil, err
+			}
+			arr = append(arr, v)
+		}
+	}
+	return arr, nil
+}
diff --git a/config/channel.go b/config/channel.go
index a015aef..6a16e71 100644
--- a/config/channel.go
+++ b/config/channel.go
@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"strings"
 
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"github.com/nyttikord/gokord/bot"
 
 	"github.com/nyttikord/gokord/interaction"
@@ -31,7 +32,7 @@ func HandleModifyFallbackChannel(ctx context.Context, dg bot.Session, i *interac
 		}
 	}
 	cfg.FallbackChannel = channelID
-	err := cfg.Save(ctx)
+	err := cfg.Save(ctx, common.GetDB(ctx))
 	if err != nil {
 		bot.Logger(ctx).Error("saving fallback channel", "error", err)
 		return false
@@ -42,7 +43,7 @@ func HandleModifyFallbackChannel(ctx context.Context, dg bot.Session, i *interac
 func HandleModifyDisChannel(ctx context.Context, dg bot.Session, i *interaction.MessageComponent) bool {
 	cfg := GetGuild(ctx, i.GuildID)
 	cfg.DisabledChannels = strings.Join(i.Data.Values, ";")
-	err := cfg.Save(ctx)
+	err := cfg.Save(ctx, common.GetDB(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 aec78ed..10e30ff 100644
--- a/config/guild.go
+++ b/config/guild.go
@@ -15,40 +15,22 @@ import (
 
 type Guild struct {
 	ID               uint64
-	XpRoles          []XpRole
+	XpRoles          []*XpRole
 	DisabledChannels string
 	FallbackChannel  uint64
 	DaysXPRemains    uint
-	RrMessages       []RoleReactMessage
-}
-
-type RoleReactMessage struct {
-	ID        uint   `gorm:"primarykey"`
-	MessageID uint64 `gorm:"not null;unique"`
-	ChannelID uint64
-	GuildID   uint64
-	Note      string
-	Roles     []*RoleReact
-}
-
-type RoleReact struct {
-	ID                 uint `gorm:"primarykey"`
-	Reaction           string
-	RoleID             uint64
-	RoleReactMessageID uint
-	CounterID          uint `gorm:"-"`
+	RrMessages       []*RoleReactMessage
 }
 
 func GetGuild(ctx context.Context, guildID uint64) *Guild {
 	cfg := Guild{ID: guildID}
-	if err := cfg.Load(ctx); err != nil {
+	if err := cfg.load(ctx, common.GetDB(ctx)); err != nil {
 		panic(err)
 	}
 	return &cfg
 }
 
-func (g *Guild) Load(ctx context.Context) error {
-	db := common.GetDB(ctx)
+func (g *Guild) load(ctx context.Context, db *sql.DB) error {
 	row := db.QueryRowContext(
 		ctx,
 		`SELECT disabled_channels, fallback_channel, days_xp_remains FROM guilds WHERE id = ?`,
@@ -72,12 +54,15 @@ func (g *Guild) Load(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	g.XpRoles, err = getXpRoles(ctx, g.ID)
+	g.XpRoles, err = getXpRoles(ctx, db, g.ID)
+	if err != nil {
+		return err
+	}
+	g.RrMessages, err = getRoleReactMessages(ctx, db, g.ID)
 	return err
 }
 
-func (g *Guild) Save(ctx context.Context) error {
-	db := common.GetDB(ctx)
+func (g *Guild) Save(ctx context.Context, db *sql.DB) error {
 	_, err := db.ExecContext(
 		ctx,
 		`UPDATE guilds SET disabled_channels = ?, fallback_channel = ?, days_xp_remains = ? WHERE id = ?`,
@@ -86,19 +71,19 @@ func (g *Guild) Save(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	savedRoles, err := getXpRoles(ctx, g.ID)
+	savedRoles, err := getXpRoles(ctx, db, g.ID)
 	if err != nil {
 		return err
 	}
-	roleEqual := func(base XpRole) func(XpRole) bool {
-		return func(v XpRole) bool {
+	roleEqual := func(base *XpRole) func(*XpRole) bool {
+		return func(v *XpRole) bool {
 			return v.GuildID == base.GuildID && v.RoleID == base.RoleID && v.XP == base.XP
 		}
 	}
 	// super slow code, but I don't want to implement a data structure to optimize this
 	for _, role := range g.XpRoles {
 		if !slices.ContainsFunc(savedRoles, roleEqual(role)) {
-			err = role.Save(ctx)
+			err = role.Save(ctx, db)
 			if err != nil {
 				return err
 			}
@@ -106,7 +91,7 @@ func (g *Guild) Save(ctx context.Context) error {
 	}
 	for _, role := range savedRoles {
 		if !slices.ContainsFunc(g.XpRoles, roleEqual(role)) {
-			err = role.Delete(ctx)
+			err = role.Delete(ctx, db)
 			if err != nil {
 				return err
 			}
@@ -133,37 +118,11 @@ func (g *Guild) IsDisabled(ctx context.Context, dg bot.Session, channelID uint64
 	return !ok
 }
 
-func (g *Guild) FindXpRole(roleID uint64) (int, *XpRole) {
-	for i, r := range g.XpRoles {
+func (g *Guild) FindXpRole(roleID uint64) *XpRole {
+	for _, r := range g.XpRoles {
 		if r.RoleID == roleID {
-			return i, &r
-		}
-	}
-	return 0, nil
-}
-
-func getXpRoles(ctx context.Context, gID uint64) ([]XpRole, error) {
-	roles := make([]XpRole, 0)
-	rows, err := common.GetDB(ctx).QueryContext(
-		ctx,
-		`SELECT xp, role FROM xp_roles WHERE guild_id = ?`,
-		gID,
-	)
-	if err == nil {
-		defer rows.Close()
-		for rows.Next() {
-			var role XpRole
-			err = rows.Scan(&role.XP, &role.RoleID)
-			if err != nil {
-				return roles, err
-			}
-			role.GuildID = gID
-			roles = append(roles, role)
-		}
-	} else {
-		if !errors.Is(err, sql.ErrNoRows) {
-			return roles, err
+			return r
 		}
 	}
-	return roles, nil
+	return nil
 }
diff --git a/config/role_react.go b/config/role_react.go
new file mode 100644
index 0000000..70e6cb0
--- /dev/null
+++ b/config/role_react.go
@@ -0,0 +1,124 @@
+package config
+
+import (
+	"context"
+	"database/sql"
+
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
+)
+
+type RoleReactMessage struct {
+	MessageID uint64
+	ChannelID uint64
+	GuildID   uint64
+	Note      string
+	Roles     []*RoleReact
+}
+
+func (rrm *RoleReactMessage) Load(ctx context.Context, db *sql.DB, rows *sql.Rows) error {
+	err := rows.Scan(&rrm.MessageID, &rrm.ChannelID, &rrm.GuildID, &rrm.Note)
+	if err != nil {
+		return err
+	}
+	rrm.Roles, err = getRoleReacts(ctx, db, rrm.MessageID)
+	return err
+}
+
+func (rrm *RoleReactMessage) Save(ctx context.Context, db *sql.DB) error {
+	_, err := db.ExecContext(
+		ctx,
+		`INSERT INTO role_react_messages (message_id, channel_id, guild_id, note) VALUES (?, ?, ?, ?)`,
+		rrm.MessageID, rrm.ChannelID, rrm.GuildID, rrm.Note,
+	)
+	return err
+}
+
+func (rrm *RoleReactMessage) Delete(ctx context.Context, db *sql.DB) error {
+	_, err := db.ExecContext(
+		ctx,
+		`DELETE FROM role_react_messages WHERE message_id = ?`,
+		rrm.MessageID,
+	)
+	return err
+}
+
+func getRoleReactMessages(ctx context.Context, db *sql.DB, gID uint64) ([]*RoleReactMessage, error) {
+	return common.GetValues[*RoleReactMessage](
+		ctx,
+		db,
+		`role_react_messages`,
+		`message_id, channel_id, guild_id, note`,
+		`guild_id = ?`, gID,
+	)
+}
+
+type RoleReact struct {
+	ID        uint
+	Reaction  string
+	RoleID    uint64
+	MessageID uint
+	CounterID uint
+}
+
+/*func (rr *RoleReact) Load(ctx context.Context, db *sql.DB) error {
+	row := db.QueryRowContext(
+		ctx,
+		`SELECT role, message_id, reaction FROM role_reacts WHERE id = ?`,
+		rr.ID,
+	)
+	err := row.Err()
+
+	if err == nil {
+		return row.Scan(&rr.RoleID, &rr.MessageID, &rr.Reaction)
+	}
+
+	if !errors.Is(err, sql.ErrNoRows) {
+		return err
+	}
+	res, err := db.ExecContext(
+		ctx,
+		`INSERT INTO role_reacts (role, message_id, reaction) VALUES (?, ?, ?)`,
+		rr.RoleID, rr.MessageID, rr.Reaction,
+	)
+	if err != nil {
+		return err
+	}
+	idr, err := res.LastInsertId()
+	if err != nil {
+		return err
+	}
+	rr.ID = uint(idr)
+	return nil
+}*/
+
+func (rr *RoleReact) Save(ctx context.Context, db *sql.DB) error {
+	_, err := db.ExecContext(
+		ctx,
+		`UPDATE role_reacts SET role = ?, reaction = ? VALUES (?, ?) WHERE id = ?`,
+		rr.RoleID, rr.Reaction, rr.ID,
+	)
+	return err
+}
+
+func (rr *RoleReact) Delete(ctx context.Context, db *sql.DB) error {
+	_, err := db.ExecContext(
+		ctx,
+		`DELETE FROM role_reacts WHERE id = ?`,
+		rr.ID,
+	)
+	return err
+}
+
+func (rr *RoleReact) Load(_ context.Context, _ *sql.DB, rows *sql.Rows) error {
+	return rows.Scan(&rr.ID, &rr.MessageID, &rr.Reaction, &rr.RoleID)
+}
+
+func getRoleReacts(ctx context.Context, db *sql.DB, mID uint64) ([]*RoleReact, error) {
+	return common.GetValues[*RoleReact](
+		ctx,
+		db,
+		`role_reacts`,
+		`id, message_id, reaction, role_id`,
+		`message_id = ?`, mID,
+	)
+}
diff --git a/config/xp_reduce.go b/config/xp_reduce.go
index baa4586..51607b1 100644
--- a/config/xp_reduce.go
+++ b/config/xp_reduce.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"strconv"
 
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/component"
 	"github.com/nyttikord/gokord/interaction"
@@ -68,7 +69,7 @@ func HandleTimeReduceSet(ctx context.Context, dg bot.Session, i *interaction.Mod
 	}
 	cfg := GetGuild(ctx, i.GuildID)
 	cfg.DaysXPRemains = uint(days)
-	err = cfg.Save(ctx)
+	err = cfg.Save(ctx, common.GetDB(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 f0d57c8..ab684c5 100644
--- a/config/xp_role.go
+++ b/config/xp_role.go
@@ -2,6 +2,7 @@ package config
 
 import (
 	"context"
+	"database/sql"
 
 	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 )
@@ -12,8 +13,12 @@ type XpRole struct {
 	GuildID uint64
 }
 
-func (xp XpRole) Save(ctx context.Context) error {
-	_, err := common.GetDB(ctx).ExecContext(
+func (xp *XpRole) Load(_ context.Context, _ *sql.DB, rows *sql.Rows) error {
+	return rows.Scan(&xp.XP, &xp.RoleID, &xp.GuildID)
+}
+
+func (xp *XpRole) Save(ctx context.Context, db *sql.DB) error {
+	_, err := db.ExecContext(
 		ctx,
 		`INSERT INTO xp_roles (xp, role, guild_id) VALUES (?, ?, ?)`,
 		xp.XP, xp.RoleID, xp.GuildID,
@@ -21,11 +26,21 @@ func (xp XpRole) Save(ctx context.Context) error {
 	return err
 }
 
-func (xp XpRole) Delete(ctx context.Context) error {
-	_, err := common.GetDB(ctx).ExecContext(
+func (xp *XpRole) Delete(ctx context.Context, db *sql.DB) error {
+	_, err := db.ExecContext(
 		ctx,
 		`DELETE FROM xp_roles WHERE xp = ? AND role = ? AND guild_id = ?`,
 		xp.XP, xp.RoleID, xp.GuildID,
 	)
 	return err
 }
+
+func getXpRoles(ctx context.Context, db *sql.DB, gID uint64) ([]*XpRole, error) {
+	return common.GetValues[*XpRole](
+		ctx,
+		db,
+		`xp_roles`,
+		`xp, role, guild_id`,
+		`guild_id = ?`, gID,
+	)
+}
diff --git a/config/xp_role_events.go b/config/xp_role_events.go
index cda90d5..47026b5 100644
--- a/config/xp_role_events.go
+++ b/config/xp_role_events.go
@@ -6,6 +6,7 @@ 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/nyttikord/gokord/bot"
@@ -39,7 +40,7 @@ func HandleXpRole(ctx context.Context, dg bot.Session, i *interaction.Interactio
 			&component.Separator{},
 		},
 	}
-	slices.SortFunc(cfg.XpRoles, func(xp1, xp2 XpRole) int {
+	slices.SortFunc(cfg.XpRoles, func(xp1, xp2 *XpRole) int {
 		return int(xp2.XP) - int(xp1.XP)
 	})
 	for _, r := range cfg.XpRoles {
@@ -122,7 +123,7 @@ func HandleXpRoleNew(ctx context.Context, dg bot.Session, i *interaction.Message
 func HandleXpRoleEdit(ctx context.Context, dg bot.Session, i *interaction.Interaction, params *XpRoleId) {
 	config := GetGuild(ctx, i.GuildID)
 	id := params.ID
-	_, role := config.FindXpRole(id)
+	role := config.FindXpRole(id)
 	if role == nil {
 		HandleXpRole(ctx, dg, i)
 		return
@@ -187,7 +188,7 @@ func HandleXpRoleEditRole(ctx context.Context, dg bot.Session, i *interaction.Me
 		panic(err)
 	}
 	cfg := GetGuild(ctx, i.GuildID)
-	_, xpRole := cfg.FindXpRole(id)
+	xpRole := cfg.FindXpRole(id)
 	if xpRole == nil {
 		err := interaction.Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseChannelMessageWithSource,
@@ -202,7 +203,7 @@ func HandleXpRoleEditRole(ctx context.Context, dg bot.Session, i *interaction.Me
 		return
 	}
 	xpRole.RoleID = role
-	err = xpRole.Save(ctx)
+	err = xpRole.Save(ctx, common.GetDB(ctx))
 	if err != nil {
 		bot.Logger(ctx).Error("saving config", "error", err, "guild", i.GuildID, "id", id, "type", "add")
 	}
@@ -212,7 +213,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 := GetGuild(ctx, i.GuildID)
-	_, xpRole := cfg.FindXpRole(id)
+	xpRole := cfg.FindXpRole(id)
 	if xpRole == nil {
 		err := interaction.Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseChannelMessageWithSource,
@@ -272,7 +273,7 @@ func HandleXpRoleEditLevel(ctx context.Context, dg bot.Session, i *interaction.M
 	xp := exp.LevelXP(uint(level))
 
 	cfg := GetGuild(ctx, i.GuildID)
-	_, xpRole := cfg.FindXpRole(id)
+	xpRole := cfg.FindXpRole(id)
 	if xpRole == nil {
 		err = interaction.Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseChannelMessageWithSource,
@@ -287,7 +288,7 @@ func HandleXpRoleEditLevel(ctx context.Context, dg bot.Session, i *interaction.M
 		return
 	}
 	xpRole.XP = xp
-	err = xpRole.Save(ctx)
+	err = xpRole.Save(ctx, common.GetDB(ctx))
 	if err != nil {
 		bot.Logger(ctx).Error("saving config", "guild", i.GuildID, "id", id, "type", "edit")
 	}
@@ -297,7 +298,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 := GetGuild(ctx, i.GuildID)
-	_, role := cfg.FindXpRole(id)
+	role := cfg.FindXpRole(id)
 	if role == nil {
 		err := interaction.Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseChannelMessageWithSource,
@@ -311,7 +312,7 @@ func HandleXpRoleDel(ctx context.Context, dg bot.Session, i *interaction.Message
 		}
 		return
 	}
-	err := role.Delete(ctx)
+	err := role.Delete(ctx, common.GetDB(ctx))
 	if err != nil {
 		bot.Logger(ctx).Error("deleting entry", "error", err, "guild", i.GuildID, "id", id, "type", "del")
 	}
@@ -344,11 +345,11 @@ func HandleXpRoleAdd(ctx context.Context, dg bot.Session, i *interaction.ModalSu
 	}
 
 	cfg := GetGuild(ctx, i.GuildID)
-	cfg.XpRoles = append(cfg.XpRoles, XpRole{
+	cfg.XpRoles = append(cfg.XpRoles, &XpRole{
 		XP:     xp,
 		RoleID: roleId,
 	})
-	err = cfg.Save(ctx)
+	err = cfg.Save(ctx, common.GetDB(ctx))
 	if err != nil {
 		bot.Logger(ctx).Error("saving config", "error", err, "role", roleId, "guild", i.GuildID)
 		return
diff --git a/migrations/000-leave-gorm.sql b/migrations/000-leave-gorm.sql
index e3aa71a..a6391a4 100644
--- a/migrations/000-leave-gorm.sql
+++ b/migrations/000-leave-gorm.sql
@@ -30,16 +30,15 @@ CREATE TABLE IF NOT EXISTS xp_roles (
 );
 
 CREATE TABLE IF NOT EXISTS role_react_messages (
-    id SERIAL PRIMARY KEY,
-    message_id snowflake UNIQUE,
+    message_id snowflake PRIMARY KEY,
     channel_id snowflake,
     guild_id snowflake REFERENCES guilds(id) ON DELETE CASCADE,
     note TEXT
 );
 
 CREATE TABLE IF NOT EXISTS role_reacts (
+    id SERIAL PRIMARY KEY,
     role snowflake,
-    message_id INTEGER REFERENCES role_react_messages(id) ON DELETE CASCADE,
-    reaction TEXT,
-    PRIMARY KEY(role, message_id, reaction)
+    message_id INTEGER REFERENCES role_react_messages(message_id) ON DELETE CASCADE,
+    reaction TEXT
 );
diff --git a/rolereact/manager.go b/rolereact/manager.go
index a55aa5f..3e01017 100644
--- a/rolereact/manager.go
+++ b/rolereact/manager.go
@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/config"
 	"github.com/nyttikord/gokord/bot"
 	"github.com/nyttikord/gokord/channel"
@@ -52,8 +53,10 @@ func ApplyMessageChange(ctx context.Context, dg bot.Session, i *interaction.Inte
 		bot.Logger(ctx).Error("unable to update reactions on rolereact message", "error", err)
 		return "Impossible de mettre à jour le message."
 	}
-	cfg := GetGuildConfigPreloaded(ctx, i.GuildID)
-	messageIndex := slices.IndexFunc(cfg.RrMessages, func(m config.RoleReactMessage) bool { return m.ID == message.ID })
+	cfg := config.GetGuild(ctx, i.GuildID)
+	messageIndex := slices.IndexFunc(cfg.RrMessages, func(m *config.RoleReactMessage) bool {
+		return m.MessageID == message.MessageID
+	})
 	if messageIndex == -1 {
 		// should log it?
 		return "Impossible de mmettre à jour le message."
@@ -63,26 +66,19 @@ func ApplyMessageChange(ctx context.Context, dg bot.Session, i *interaction.Inte
 	for _, role := range message.Roles {
 		roles[role.ID] = *role
 	}
-	//db := common.GetDB(ctx)
+	db := common.GetDB(ctx)
 	for _, role := range oldMessage.Roles {
 		_, ok := roles[role.ID]
 		if !ok {
-			err = nil //db.Delete(role).Error
+			err = role.Delete(ctx, db)
 			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 = nil //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 {
-		println(role.ID)
-		err = nil //db.Save(role).Error
+	for _, role := range message.Roles {
+		err = role.Save(ctx, common.GetDB(ctx))
 		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."
@@ -122,16 +118,6 @@ func GetMessageFromEditID(ctx context.Context, i *interaction.Interaction, editI
 	return m, true
 }
 
-func GetGuildConfigPreloaded(ctx context.Context, guildID uint64) *config.Guild {
-	cfg := config.Guild{ID: guildID}
-	// err := oldGokord.DB.Where("guild_id = ?", cfg.GuildID).Preload("XpRoles").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)
-	}*/
-	return &cfg
-}
-
 func FormatEmoji(apiName string) string {
 	if strings.Contains(apiName, ":") {
 		return fmt.Sprintf("<:%s>", apiName)
diff --git a/rolereact/rolereact.go b/rolereact/rolereact.go
index 44aad2a..756cf36 100644
--- a/rolereact/rolereact.go
+++ b/rolereact/rolereact.go
@@ -5,6 +5,7 @@ import (
 	"slices"
 	"strconv"
 
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/config"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/dynamicid"
 	"github.com/nyttikord/gokord/bot"
@@ -83,9 +84,9 @@ func HandleCommand(ctx context.Context, dg bot.Session, i *interaction.Applicati
 		return
 	}
 	message.MessageID = m.ID
-	cfg := GetGuildConfigPreloaded(ctx, i.GuildID)
-	cfg.RrMessages = append(cfg.RrMessages, message)
-	err = cfg.Save(ctx)
+	cfg := config.GetGuild(ctx, i.GuildID)
+	cfg.RrMessages = append(cfg.RrMessages, &message)
+	err = cfg.Save(ctx, common.GetDB(ctx))
 	if err != nil {
 		bot.Logger(ctx).Error("unable to save rolereact message in database", "error", err)
 		_, err := interaction.CreateFollowupMessage(i.Interaction, false, &channel.WebhookParams{
@@ -100,7 +101,7 @@ func HandleCommand(ctx context.Context, dg bot.Session, i *interaction.Applicati
 		return
 	}
 
-	messageEdits[messageCounter] = &cfg.RrMessages[len(cfg.RrMessages)-1]
+	messageEdits[messageCounter] = cfg.RrMessages[len(cfg.RrMessages)-1]
 	editID := messageCounter
 	messageCounter++
 
@@ -120,7 +121,7 @@ func HandleCommand(ctx context.Context, dg bot.Session, i *interaction.Applicati
 func HandleModifyCommand(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
 	logger := bot.Logger(ctx)
 	messageId := i.Data.TargetID
-	cfg := GetGuildConfigPreloaded(ctx, i.GuildID)
+	cfg := config.GetGuild(ctx, i.GuildID)
 	var target *config.RoleReactMessage
 	var targetEditID uint
 	for editID, message := range messageEdits {
@@ -132,7 +133,7 @@ func HandleModifyCommand(ctx context.Context, dg bot.Session, i *interaction.App
 	if targetEditID == 0 {
 		for _, message := range cfg.RrMessages {
 			if message.MessageID == messageId {
-				target = &message
+				target = message
 			}
 		}
 		if target == nil {
@@ -182,10 +183,10 @@ func HandleResetMessage(ctx context.Context, dg bot.Session, i *interaction.Mess
 			},
 		}
 	} else {
-		cfg := GetGuildConfigPreloaded(ctx, i.GuildID)
+		cfg := config.GetGuild(ctx, i.GuildID)
 		for _, m := range cfg.RrMessages {
-			if m.ID == message.ID {
-				messageEdits[params.MessageEditID] = &m
+			if m.MessageID == message.MessageID {
+				messageEdits[params.MessageEditID] = m
 			}
 		}
 		responseData = *MessageModifyData(ctx, i.Interaction, params)