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

4 files changed, 457 insertions, 277 deletions

diff --git a/config/channel.go b/config/channel.go
index 537d586..0c25b25 100644
--- a/config/channel.go
+++ b/config/channel.go
@@ -4,14 +4,14 @@ import (
 	"strings"
 
 	"github.com/anhgelus/gokord/cmd"
-	"github.com/anhgelus/gokord/component"
-	"github.com/anhgelus/gokord/logger"
-	discordgo "github.com/nyttikord/gokord"
+	"github.com/nyttikord/gokord/bot"
+	"github.com/nyttikord/gokord/event"
+
+	"github.com/nyttikord/gokord/interaction"
 )
 
 const (
 	ModifyFallbackChannel = "fallback_channel"
-	FallbackChannelSet    = "fallback_channel_set"
 
 	ModifyDisChannel = "disabled_channel"
 	DisChannelAdd    = "disabled_channel_add"
@@ -20,108 +20,28 @@ const (
 	DisChannelDelSet = "disabled_channel_del_set"
 )
 
-func HandleModifyFallbackChannel(_ *discordgo.Session, _ *discordgo.InteractionCreate, _ discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	err := resp.IsEphemeral().SetComponents(component.New().Add(component.NewActionRow().Add(
-		component.NewChannelSelect(FallbackChannelSet).AddChannelType(discordgo.ChannelTypeGuildText),
-	))).Send()
-	if err != nil {
-		logger.Alert("config/channel.go - Sending channel list for fallback", err.Error())
-	}
-}
-
-func HandleFallbackChannelSet(_ *discordgo.Session, i *discordgo.InteractionCreate, data discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	resp.IsEphemeral()
-
+func HandleModifyFallbackChannel(s bot.Session, i *event.InteractionCreate, data *interaction.MessageComponentData, _ *cmd.ResponseBuilder) bool {
 	cfg := GetGuildConfig(i.GuildID)
-	channelID := data.Values[0]
-
+	var channelID string
+	if len(data.Values) > 0 {
+		channelID = data.Values[0]
+	}
 	cfg.FallbackChannel = channelID
 	err := cfg.Save()
 	if err != nil {
-		logger.Alert("config/channel.go - Saving fallback channel", err.Error())
-		if err = resp.SetMessage("Erreur lors de la sauvegarde du salon").Send(); err != nil {
-			logger.Alert("config/channel.go - Sending error while saving channel", err.Error())
-		}
-		return
-	}
-	if err = resp.SetMessage("Salon sauvegardé.").Send(); err != nil {
-		logger.Alert("config/channel.go - Sending channel saved", err.Error())
-	}
-}
-
-func HandleModifyDisChannel(_ *discordgo.Session, _ *discordgo.InteractionCreate, _ discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	err := resp.IsEphemeral().SetComponents(component.New().Add(component.NewActionRow().
-		Add(
-			component.NewButton(DisChannelAdd, discordgo.PrimaryButton).
-				SetLabel("Désactiver un salon").
-				SetEmoji(&discordgo.ComponentEmoji{Name: "⬇️"}),
-		).
-		Add(
-			component.NewButton(DisChannelDel, discordgo.DangerButton).
-				SetLabel("Réactiver un salon").
-				SetEmoji(&discordgo.ComponentEmoji{Name: "⬆️"}),
-		),
-	)).Send()
-	if err != nil {
-		logger.Alert("config/channel.go - Sending action type", err.Error())
-	}
-}
-
-func HandleDisChannel(_ *discordgo.Session, _ *discordgo.InteractionCreate, data discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	resp.IsEphemeral().SetMessage("Salon à désactiver...")
-	cID := DisChannelAddSet
-	if data.CustomID == DisChannelDel {
-		resp.SetMessage("Salon à réactiver...")
-		cID = DisChannelDelSet
-	}
-	err := resp.SetComponents(component.New().Add(component.NewActionRow().Add(component.NewChannelSelect(cID)))).Send()
-	if err != nil {
-		logger.Alert("config/channel.go - Sending channel list for disable", err.Error())
-	}
-}
-
-func HandleDisChannelAddSet(_ *discordgo.Session, i *discordgo.InteractionCreate, data discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	resp.IsEphemeral()
-	cfg := GetGuildConfig(i.GuildID)
-	id := data.Values[0]
-	if strings.Contains(cfg.DisabledChannels, id) {
-		err := resp.SetMessage("Le salon est déjà dans la liste des salons désactivés").Send()
-		if err != nil {
-			logger.Alert("commands/config.go - Channel already disabled", err.Error())
-		}
-		return
-	}
-	cfg.DisabledChannels += id + ";"
-	if err := cfg.Save(); err != nil {
-		logger.Alert("commands/config.go - Saving config disable add", err.Error())
-		if err = resp.SetMessage("Il y a eu une erreur lors de la modification de de la base de données.").Send(); err != nil {
-			logger.Alert("config/channel.go - Sending error while saving config", err.Error())
-		}
-	}
-	if err := resp.SetMessage("Modification sauvegardé.").Send(); err != nil {
-		logger.Alert("commands/config.go - Modification saved message disable add", err.Error())
+		s.Logger().Error("saving fallback channel", "error", err)
+		return false
 	}
+	return true
 }
 
-func HandleDisChannelDelSet(_ *discordgo.Session, i *discordgo.InteractionCreate, data discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	resp.IsEphemeral()
+func HandleModifyDisChannel(s bot.Session, i *event.InteractionCreate, data *interaction.MessageComponentData, _ *cmd.ResponseBuilder) bool {
 	cfg := GetGuildConfig(i.GuildID)
-	id := data.Values[0]
-	if !strings.Contains(cfg.DisabledChannels, id) {
-		err := resp.SetMessage("Le salon n'est pas désactivé").Send()
-		if err != nil {
-			logger.Alert("commands/config.go - Channel not disabled", err.Error())
-		}
-		return
-	}
-	cfg.DisabledChannels = strings.ReplaceAll(cfg.DisabledChannels, id+";", "")
-	if err := cfg.Save(); err != nil {
-		logger.Alert("commands/config.go - Saving config disable del", err.Error())
-		if err = resp.SetMessage("Il y a eu une erreur lors de la modification de de la base de données.").Send(); err != nil {
-			logger.Alert("config/channel.go - Sending error while saving config", err.Error())
-		}
-	}
-	if err := resp.SetMessage("Modification sauvegardé.").Send(); err != nil {
-		logger.Alert("commands/config.go - Modification saved message disable del", err.Error())
+	cfg.DisabledChannels = strings.Join(data.Values, ";")
+	err := cfg.Save()
+	if err != nil {
+		s.Logger().Error("unable to save disabled channel", "error", err)
+		return false
 	}
+	return true
 }
diff --git a/config/guild.go b/config/guild.go
index 971470d..c2a1636 100644
--- a/config/guild.go
+++ b/config/guild.go
@@ -4,6 +4,7 @@ import (
 	"strings"
 
 	"github.com/anhgelus/gokord"
+	"github.com/nyttikord/gokord/bot"
 )
 
 type GuildConfig struct {
@@ -46,8 +47,30 @@ func (cfg *GuildConfig) Save() error {
 	return gokord.DB.Save(cfg).Error
 }
 
-func (cfg *GuildConfig) IsDisabled(channelID string) bool {
-	return strings.Contains(cfg.DisabledChannels, channelID)
+func (cfg *GuildConfig) IsDisabled(s bot.Session, channelID string) bool {
+	ok := true
+	for channelID != "" && ok {
+		ok = !strings.Contains(cfg.DisabledChannels, channelID)
+		c, err := s.ChannelAPI().State.Channel(channelID)
+		if err != nil {
+			s.Logger().Error("unable to find channel %s in state", "error", err, "channel", c)
+			c, err = s.ChannelAPI().Channel(channelID)
+			if err == nil {
+				err = s.ChannelAPI().State.ChannelAdd(c)
+				if err != nil {
+					s.Logger().Error("unable to add channel to state", "error", err, "channel", c)
+				}
+			} else {
+				s.Logger().Error("unable to fetch channel", "error", err, "channel", c)
+				return false
+			}
+		}
+		if err != nil {
+			return false
+		}
+		channelID = c.ParentID
+	}
+	return !ok
 }
 
 func (cfg *GuildConfig) FindXpRole(roleID string) (int, *XpRole) {
@@ -58,3 +81,12 @@ func (cfg *GuildConfig) FindXpRole(roleID string) (int, *XpRole) {
 	}
 	return 0, nil
 }
+
+func (cfg *GuildConfig) FindXpRoleID(ID uint) (int, *XpRole) {
+	for i, r := range cfg.XpRoles {
+		if r.ID == ID {
+			return i, &r
+		}
+	}
+	return -1, nil
+}
diff --git a/config/xp_reduce.go b/config/xp_reduce.go
index defc54b..389043d 100644
--- a/config/xp_reduce.go
+++ b/config/xp_reduce.go
@@ -1,12 +1,15 @@
 package config
 
 import (
+	"fmt"
 	"strconv"
 
 	"github.com/anhgelus/gokord/cmd"
-	"github.com/anhgelus/gokord/component"
-	"github.com/anhgelus/gokord/logger"
-	discordgo "github.com/nyttikord/gokord"
+	"github.com/nyttikord/gokord/bot"
+	"github.com/nyttikord/gokord/component"
+	"github.com/nyttikord/gokord/discord/types"
+	"github.com/nyttikord/gokord/event"
+	"github.com/nyttikord/gokord/interaction"
 )
 
 const (
@@ -14,47 +17,61 @@ const (
 	TimeReduceSet    = "time_reduce_set"
 )
 
-func HandleModifyPeriodicReduce(_ *discordgo.Session, _ *discordgo.InteractionCreate, _ discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	err := resp.IsModal().
-		SetCustomID(TimeReduceSet).
-		SetComponents(component.New().ForModal().Add(component.NewActionRow().ForModal().Add(
-			component.NewTextInput(TimeReduceSet, "Jours avant la réduction", discordgo.TextInputShort).
-				SetMinLength(1).
-				SetMaxLength(3),
-		))).Send()
+func HandleModifyPeriodicReduceCommand(s bot.Session, i *event.InteractionCreate, _ *interaction.MessageComponentData, _ *cmd.ResponseBuilder) {
+	cfg := GetGuildConfig(i.GuildID)
+	response := interaction.Response{
+		Type: types.InteractionResponseModal,
+		Data: &interaction.ResponseData{
+			CustomID: TimeReduceSet,
+			Title:    "Modifier la durée de l'expérience",
+			Components: []component.Component{
+				// TODO: When gokord supports it, enable this description again
+				// &component.TextDisplay{
+				// 	Content: "Seul l'expérience gagnée sur cette période sera comptabilisée dans le niveau par défaut",
+				// },
+				&component.Label{
+					Label: "Durée en jours",
+					Component: &component.TextInput{
+						CustomID:    TimeReduceSet,
+						MinLength:   1,
+						MaxLength:   3,
+						Style:       component.TextInputShort,
+						Placeholder: "Durée en jours",
+						Value:       fmt.Sprintf("%d", cfg.DaysXPRemains),
+					},
+				},
+			},
+		},
+	}
+	err := s.InteractionAPI().Respond(i.Interaction, &response)
 	if err != nil {
-		logger.Alert("config/xp_reduce.go - Sending modal for periodic reduce", err.Error())
+		s.Logger().Error("sending xp reduce modal", "error", err)
 	}
 }
 
-func HandleTimeReduceSet(_ *discordgo.Session, i *discordgo.InteractionCreate, data discordgo.ModalSubmitInteractionData, resp *cmd.ResponseBuilder) {
-	resp.IsEphemeral()
-	v := data.Components[0].(*discordgo.ActionsRow).Components[0].(*discordgo.TextInput).Value
+func HandleTimeReduceSet(s bot.Session, i *event.InteractionCreate, data *interaction.ModalSubmitData, resp *cmd.ResponseBuilder) bool {
+	v := data.Components[0].(*component.Label).Component.(*component.TextInput).Value
 	days, err := strconv.Atoi(v)
 	if err != nil {
-		logger.Debug(err.Error())
-		if err = resp.SetMessage("Nombres de jours invalides. Merci de mettre un entier.").Send(); err != nil {
-			logger.Alert("config/xp_reduce.go - Sending bad input", err.Error())
+		err = resp.IsEphemeral().SetMessage(fmt.Sprintf("La valeur indiquée, `%s`, c'est pas un entier.", v)).Send()
+		if err != nil {
+			s.Logger().Error("sending bad input message", "error", err)
 		}
-		return
+		return false
 	}
 	if days < 30 {
-		err = resp.SetMessage("Le nombre de jours est inférieur à 30.").Send()
+		err = resp.IsEphemeral().SetMessage("Le nombre de jours doit être suppérieur à 30.").Send()
 		if err != nil {
-			logger.Alert("config/xp_reduce.go - Days < 30 (fallback)", err.Error())
+			s.Logger().Error("sending less than 30 days message", "error", err)
 		}
-		return
+		return false
 	}
 	cfg := GetGuildConfig(i.GuildID)
 	cfg.DaysXPRemains = uint(days)
-	if err = cfg.Save(); err != nil {
-		logger.Alert("config/channel.go - Saving days xp remains", err.Error())
-		if err = resp.SetMessage("Erreur lors de la sauvegarde du salon").Send(); err != nil {
-			logger.Alert("config/xp_reduce.go - Sending error while saving days xp remains", err.Error())
-		}
-		return
-	}
-	if err = resp.SetMessage("Modification sauvegardée.").Send(); err != nil {
-		logger.Alert("config/xp_reduce.go - Sending days saved", err.Error())
+	err = cfg.Save()
+	if err != nil {
+		s.Logger().Error("saving DaysXPRemains configuration", "error", err)
+		return false
 	}
+	return true
 }
diff --git a/config/xp_role.go b/config/xp_role.go
index 6ea89e2..8ea9d1e 100644
--- a/config/xp_role.go
+++ b/config/xp_role.go
@@ -2,208 +2,419 @@ package config
 
 import (
 	"fmt"
+	"slices"
 	"strconv"
-	"time"
 
 	"git.anhgelus.world/anhgelus/les-copaings-bot/exp"
 	"github.com/anhgelus/gokord"
 	"github.com/anhgelus/gokord/cmd"
-	"github.com/anhgelus/gokord/component"
-	"github.com/anhgelus/gokord/logger"
-	discordgo "github.com/nyttikord/gokord"
+	"github.com/nyttikord/gokord/bot"
+	"github.com/nyttikord/gokord/channel"
+	"github.com/nyttikord/gokord/component"
+	"github.com/nyttikord/gokord/discord/types"
+	"github.com/nyttikord/gokord/event"
+	"github.com/nyttikord/gokord/interaction"
 )
 
 const (
-	ModifyXpRole    = "xp_role"
-	XpRoleAdd       = "xp_role_add"
-	XpRoleAddLevel  = "xp_role_add_level"
-	XpRoleAddRole   = "xp_role_add_role"
-	XpRoleDel       = "xp_role_del"
-	XpRoleDelRole   = "xp_role_del_role"
-	XpRoleEdit      = "xp_role_edit"
-	XpRoleEditLevel = "xp_role_edit_level"
-	XpRoleEditRole  = "xp_role_edit_role"
+	ModifyXpRole                = "xp_role"
+	XpRoleNew                   = "xp_role_add"
+	XpRoleAdd                   = "xp_role_add_level"
+	XpRoleEditPattern           = `^xp_role_edit_(\d+)$`
+	XpRoleEditLevelPattern      = `^xp_role_edit_level_(\d+)$`
+	XpRoleEditLevelStartPattern = `^xp_role_edit_level_start_(\d+)$`
+	XpRoleEditRolePattern       = `^xp_role_edit_role_(\d+)$`
+	XpRoleDel                   = `^xp_role_del_(\d+)$`
 )
 
-var (
-	configModifyMap = map[string]uint{}
-)
+func HandleXpRole(
+	s bot.Session,
+	i *event.InteractionCreate,
+	_ *interaction.MessageComponentData,
+	_ *cmd.ResponseBuilder,
+) {
+	cfg := GetGuildConfig(i.GuildID)
+	container := component.Container{
+		Components: []component.Message{
+			&component.TextDisplay{Content: "## Configuration / Rôles de niveaux"},
+			&component.TextDisplay{Content: "Ces rôles seront donnés et retirés en fonction du niveau de chacun"},
+			&component.Separator{},
+		},
+	}
+	slices.SortFunc(cfg.XpRoles, func(xp1, xp2 XpRole) int {
+		return int(xp2.XP) - int(xp1.XP)
+	})
+	for _, r := range cfg.XpRoles {
+		container.Components = append(container.Components, &component.Section{
+			Components: []component.Message{
+				&component.TextDisplay{
+					Content: fmt.Sprintf("<@&%s> - Niveau %d", r.RoleID, exp.Level(r.XP)),
+				},
+			},
+			Accessory: &component.Button{
+				CustomID: fmt.Sprintf("xp_role_edit_%d", r.ID),
+				Style:    component.ButtonStyleSecondary,
+				Label:    "Modifier",
+			},
+		})
+	}
+	container.Components = append(container.Components,
+		&component.ActionsRow{
+			Components: []component.Message{
+				&component.Button{
+					CustomID: XpRoleNew,
+					Style:    component.ButtonStylePrimary,
+					Label:    "Nouveau rôle",
+				},
+			},
+		},
+		&component.Separator{},
+		&component.ActionsRow{
+			Components: []component.Message{
+				&component.Button{CustomID: "config", Style: component.ButtonStyleSecondary, Label: "Retour"},
+			},
+		},
+	)
 
-func HandleModifyXpRole(_ *discordgo.Session, _ *discordgo.InteractionCreate, _ discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	err := resp.IsEphemeral().
-		SetMessage("Action à réaliser").
-		SetComponents(component.New().Add(component.NewActionRow().
-			Add(component.NewButton(XpRoleAdd, discordgo.PrimaryButton).
-				SetLabel("Ajouter").
-				SetEmoji(&discordgo.ComponentEmoji{Name: "⬆️"}),
-			).
-			Add(component.NewButton(XpRoleEdit, discordgo.SecondaryButton).
-				SetLabel("Modifier").
-				SetEmoji(&discordgo.ComponentEmoji{Name: "📝"}),
-			).
-			Add(component.NewButton(XpRoleDel, discordgo.DangerButton).
-				SetLabel("Supprimer").
-				SetEmoji(&discordgo.ComponentEmoji{Name: "❌"}),
-			),
-		)).Send()
+	response := &interaction.Response{
+		Type: types.InteractionResponseUpdateMessage,
+		Data: &interaction.ResponseData{
+			Components: []component.Component{&container},
+			Flags:      channel.MessageFlagsIsComponentsV2,
+		},
+	}
+	err := s.InteractionAPI().Respond(i.Interaction, response)
 	if err != nil {
-		logger.Alert("config/xp_reduce.go - Sending config", err.Error())
+		s.Logger().Error("sending config", "error", err)
 	}
 }
 
-func HandleXpRoleAddEdit(_ *discordgo.Session, _ *discordgo.InteractionCreate, data discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	cID := XpRoleAddLevel
-	if data.CustomID == XpRoleEdit {
-		cID = XpRoleEditLevel
-	}
-	err := resp.IsModal().
-		SetTitle("Role").
-		SetCustomID(cID).
-		SetComponents(component.New().ForModal().Add(component.NewActionRow().ForModal().Add(
-			component.NewTextInput(cID, "Niveau", discordgo.TextInputShort).
-				SetPlaceholder("5").
-				IsRequired().
-				SetMinLength(0).
-				SetMaxLength(5),
-		))).
-		Send()
+func HandleXpRoleNew(
+	s bot.Session,
+	i *event.InteractionCreate,
+	_ *interaction.MessageComponentData,
+	_ *cmd.ResponseBuilder,
+) {
+	one := 1
+	response := &interaction.Response{
+		Type: types.InteractionResponseModal,
+		Data: &interaction.ResponseData{
+			Title:    "Nouveau rôle de niveau",
+			CustomID: XpRoleAdd,
+			Components: []component.Component{
+				&component.Label{
+					Label: "Niveau",
+					Component: &component.TextInput{
+						CustomID:    "level",
+						Style:       component.TextInputShort,
+						Placeholder: "5",
+						MinLength:   1,
+						MaxLength:   5,
+						Required:    true,
+					},
+				},
+				&component.Label{
+					Label: "Rôle",
+					Component: &component.SelectMenu{
+						MenuType:  types.SelectMenuRole,
+						CustomID:  "role",
+						MinValues: &one,
+						MaxValues: one,
+					},
+				},
+			},
+		},
+	}
+	err := s.InteractionAPI().Respond(i.Interaction, response)
 	if err != nil {
-		logger.Alert("config/xp_reduce.go - Sending modal to add/edit", err.Error())
+		s.Logger().Error("sending modal to add", "error", err)
 	}
 }
 
-func HandleXpRoleAddRole(_ *discordgo.Session, i *discordgo.InteractionCreate, data discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	resp.IsEphemeral()
+func HandleXpRoleEdit(
+	s bot.Session,
+	i *event.InteractionCreate,
+	_ *interaction.MessageComponentData,
+	parameters []string, resp *cmd.ResponseBuilder,
+) {
+	config := GetGuildConfig(i.GuildID)
+	id, err := getRoleLevelID(parameters)
+	if err != nil {
+		s.Logger().Error("reading dynamic CustomID", "error", err)
+		return
+	}
+	_, role := config.FindXpRoleID(id)
+	if role == nil {
+		HandleXpRole(s, i, &interaction.MessageComponentData{}, resp)
+		return
+	}
+
+	roleSelect := &component.SelectMenu{
+		MenuType: types.SelectMenuRole,
+		CustomID: fmt.Sprintf("xp_role_edit_role_%d", id),
+		DefaultValues: []component.SelectMenuDefaultValue{
+			{ID: role.RoleID, Type: types.SelectMenuDefaultValueRole},
+		},
+	}
+
+	container := &component.Container{
+		Components: []component.Message{
+			&component.TextDisplay{Content: "## Configuration / Rôles de niveaux"},
+			&component.Separator{},
+			&component.Section{
+				Components: []component.Message{
+					&component.TextDisplay{Content: fmt.Sprintf("Niveau **%d**", exp.Level(role.XP))},
+				},
+				Accessory: &component.Button{
+					CustomID: fmt.Sprintf("xp_role_edit_level_start_%d", id),
+					Style:    component.ButtonStyleSecondary,
+					Label:    "Modifier",
+				},
+			},
+			&component.ActionsRow{Components: []component.Message{roleSelect}},
+			&component.ActionsRow{Components: []component.Message{
+				&component.Button{CustomID: fmt.Sprintf("xp_role_del_%d", id), Style: component.ButtonStyleDanger, Label: "Supprimer"},
+			}},
+			&component.Separator{},
+			&component.ActionsRow{Components: []component.Message{
+				&component.Button{Label: "Retour", CustomID: ModifyXpRole, Style: component.ButtonStyleSecondary},
+			}},
+		},
+	}
+
+	response := &interaction.Response{
+		Type: types.InteractionResponseUpdateMessage,
+		Data: &interaction.ResponseData{
+			Components: []component.Component{container},
+			Flags:      channel.MessageFlagsIsComponentsV2,
+		},
+	}
+
+	err = s.InteractionAPI().Respond(i.Interaction, response)
+	if err != nil {
+		s.Logger().Error("sending xp_role config", "error", err)
+	}
+}
+
+func HandleXpRoleEditRole(
+	s bot.Session,
+	i *event.InteractionCreate,
+	data *interaction.MessageComponentData,
+	parameters []string, resp *cmd.ResponseBuilder,
+) {
+	id, err := getRoleLevelID(parameters)
+	if err != nil {
+		s.Logger().Error("reading dynamic CustomID", "error", err)
+		return
+	}
+	role := data.Values[0]
 	cfg := GetGuildConfig(i.GuildID)
-	roleId := data.Values[0]
-	for _, r := range cfg.XpRoles {
-		if r.RoleID == roleId {
-			err := resp.SetMessage("Le rôle est déjà présent dans la config").Send()
-			if err != nil {
-				logger.Alert("config/xp_role.go - Role already in config", err.Error())
-			}
-			return
+	_, xpRole := cfg.FindXpRoleID(id)
+	if xpRole == nil {
+		err = s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+			Type: types.InteractionResponseChannelMessageWithSource,
+			Data: &interaction.ResponseData{
+				Flags:   channel.MessageFlagsEphemeral,
+				Content: "Impossible de modifier le rôle. Peut-être a-t-il été supprimé ?",
+			},
+		})
+		if err != nil {
+			s.Logger().Error("sending unable to get role message", "error", err)
 		}
+		return
 	}
-	cfg.XpRoles = append(cfg.XpRoles, XpRole{
-		XP:     configModifyMap[getKeyConfigRole(i)],
-		RoleID: roleId,
-	})
-	err := cfg.Save()
+	xpRole.RoleID = role
+	err = gokord.DB.Save(xpRole).Error
 	if err != nil {
-		logger.Alert(
-			"config/xp_role.go - Saving config",
-			err.Error(),
-			"guild_id", i.GuildID,
-			"role_id", roleId,
-			"type", "add",
-		)
-	}
-	if err = resp.SetMessage("Rôle ajouté.").Send(); err != nil {
-		logger.Alert("config/xp_role.go - Sending success", err.Error())
+		s.Logger().Error("saving config", "error", err, "guild", i.GuildID, "id", id, "type", "add")
 	}
+	HandleXpRoleEdit(s, i, &interaction.MessageComponentData{}, parameters, resp)
 }
 
-func HandleXpRoleEditRole(_ *discordgo.Session, i *discordgo.InteractionCreate, data discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	resp.IsEphemeral()
+func HandleXpRoleEditLevelStart(
+	s bot.Session,
+	i *event.InteractionCreate,
+	_ *interaction.MessageComponentData,
+	parameters []string,
+	_ *cmd.ResponseBuilder,
+) {
+	id, err := getRoleLevelID(parameters)
+	if err != nil {
+		s.Logger().Error("reading dynamic CustomID", "error", err)
+		return
+	}
 	cfg := GetGuildConfig(i.GuildID)
-	roleId := data.Values[0]
-	_, r := cfg.FindXpRole(roleId)
-	if r == nil {
-		err := resp.SetMessage("Le rôle n'a pas été trouvé dans la config.").Send()
+	_, xpRole := cfg.FindXpRoleID(id)
+	if xpRole == nil {
+		err = s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+			Type: types.InteractionResponseChannelMessageWithSource,
+			Data: &interaction.ResponseData{
+				Flags:   channel.MessageFlagsEphemeral,
+				Content: "Impossible de trouver le rôle. Peut-être a-t-il été supprimé ?",
+			},
+		})
 		if err != nil {
-			logger.Alert("config/xp_role.go - Role not found (edit)", err.Error())
+			s.Logger().Error("sending unable to get role message", "error", err)
 		}
 		return
 	}
-	r.XP = configModifyMap[getKeyConfigRole(i)]
-	err := gokord.DB.Save(r).Error
-	if err != nil {
-		logger.Alert(
-			"config/xp_role.go - Saving config",
-			err.Error(),
-			"guild_id", i.GuildID,
-			"role_id", roleId,
-			"type", "edit",
-		)
+	response := &interaction.Response{
+		Type: types.InteractionResponseModal,
+		Data: &interaction.ResponseData{
+			Title:    "Modification du niveau lié au rôle",
+			CustomID: fmt.Sprintf("xp_role_edit_level_%d", id),
+			Components: []component.Component{
+				&component.Label{
+					Label: "Nouveau niveau",
+					Component: &component.TextInput{
+						Style:       component.TextInputShort,
+						Required:    true,
+						CustomID:    "level",
+						MinLength:   1,
+						MaxLength:   5,
+						Placeholder: "5",
+						Value:       strconv.FormatUint(uint64(exp.Level(xpRole.XP)), 10),
+					},
+				},
+			},
+		},
 	}
-	if err = resp.SetMessage("Rôle modifié.").Send(); err != nil {
-		logger.Alert("config/xp_role.go - Sending success", err.Error())
+	err = s.InteractionAPI().Respond(i.Interaction, response)
+	if err != nil {
+		s.Logger().Error("sending edit level modal", "error", err)
 	}
 }
 
-func HandleXpRoleDel(_ *discordgo.Session, _ *discordgo.InteractionCreate, _ discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	err := resp.IsEphemeral().
-		SetMessage("Rôle à supprimer").
-		SetComponents(component.New().Add(component.NewActionRow().Add(component.NewRoleSelect(XpRoleDelRole)))).
-		Send()
+func HandleXpRoleEditLevel(
+	s bot.Session,
+	i *event.InteractionCreate,
+	data *interaction.ModalSubmitData,
+	parameters []string,
+	resp *cmd.ResponseBuilder,
+) {
+	id, err := getRoleLevelID(parameters)
 	if err != nil {
-		logger.Alert("config/xp_reduce.go - Sending response to del", err.Error())
+		s.Logger().Error("reading dynamic CustomID", "error", err)
+		return
 	}
-}
 
-func HandleXpRoleDelRole(_ *discordgo.Session, i *discordgo.InteractionCreate, data discordgo.MessageComponentInteractionData, resp *cmd.ResponseBuilder) {
-	resp.IsEphemeral()
+	fmt.Printf("Alors?... %#v", data.Components)
+	levelInput := data.Components[0].(*component.Label).Component.(*component.TextInput)
+	level, err := strconv.Atoi(levelInput.Value)
+	if err != nil || level < 0 {
+		err = resp.IsEphemeral().
+			SetMessage(
+				fmt.Sprintf("Le niveau doit être un nombre entier positif.\n-# Trouvé : %s", levelInput.Value),
+			).
+			Send()
+		if err != nil {
+			s.Logger().Error("sending bad number warning message", "error", err)
+		}
+		return
+	}
+	xp := exp.LevelXP(uint(level))
+
 	cfg := GetGuildConfig(i.GuildID)
-	roleId := data.Values[0]
-	_, r := cfg.FindXpRole(roleId)
-	if r == nil {
-		err := resp.SetMessage("Le rôle n'a pas été trouvé dans la config.").Send()
+	_, xpRole := cfg.FindXpRoleID(id)
+	if xpRole == nil {
+		err = s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+			Type: types.InteractionResponseChannelMessageWithSource,
+			Data: &interaction.ResponseData{
+				Flags:   channel.MessageFlagsEphemeral,
+				Content: "Impossible de modifier le rôle. Peut-être a-t-il été supprimé ?",
+			},
+		})
 		if err != nil {
-			logger.Alert("config/xp_role.go - Sending role not found (del)", err.Error())
+			s.Logger().Error("sending unable to modify role message", "error", err)
 		}
 		return
 	}
-	err := gokord.DB.Delete(r).Error
+	xpRole.XP = xp
+	err = gokord.DB.Save(xpRole).Error
 	if err != nil {
-		logger.Alert(
-			"config/xp_role.go - Deleting entry",
-			err.Error(),
-			"guild_id", i.GuildID,
-			"role_id", roleId,
-			"type", "del",
-		)
+		s.Logger().Error("saving config", "guild", i.GuildID, "id", id, "type", "edit")
+	}
+	HandleXpRoleEdit(s, i, &interaction.MessageComponentData{}, parameters, resp)
+}
+
+func HandleXpRoleDel(
+	s bot.Session,
+	i *event.InteractionCreate,
+	_ *interaction.MessageComponentData,
+	dynamicValues []string,
+	resp *cmd.ResponseBuilder,
+) {
+	id, err := getRoleLevelID(dynamicValues)
+	if err != nil {
+		s.Logger().Error("reading dynamic CustomID", "error", err)
+		return
+	}
+	cfg := GetGuildConfig(i.GuildID)
+	_, role := cfg.FindXpRoleID(id)
+	if role == nil {
+		err = s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+			Type: types.InteractionResponseChannelMessageWithSource,
+			Data: &interaction.ResponseData{
+				Content: "Rôle introuvable. Peut-être a-t-il déjà été supprimé ?",
+				Flags:   channel.MessageFlagsEphemeral,
+			},
+		})
+		if err != nil {
+			s.Logger().Error("sending role not found message", "error", err)
+		}
+		return
 	}
-	if err = resp.SetMessage("Rôle supprimé.").Send(); err != nil {
-		logger.Alert("config/xp_role.go - Sending success", err.Error())
+	err = gokord.DB.Delete(role).Error
+	if err != nil {
+		s.Logger().Error("deleting entry", "error", err, "guild", i.GuildID, "id", id, "type", "del")
 	}
+
+	HandleXpRole(s, i, &interaction.MessageComponentData{}, resp)
 }
 
-func HandleXpRoleLevel(_ *discordgo.Session, i *discordgo.InteractionCreate, data discordgo.ModalSubmitInteractionData, resp *cmd.ResponseBuilder) {
-	resp.IsEphemeral()
-	input := data.Components[0].(*discordgo.ActionsRow).Components[0].(*discordgo.TextInput)
+func HandleXpRoleAdd(
+	s bot.Session,
+	i *event.InteractionCreate,
+	data *interaction.ModalSubmitData,
+	resp *cmd.ResponseBuilder,
+) {
+	levelInput := data.Components[0].(*component.Label).Component.(*component.TextInput)
 
-	k := getKeyConfigRole(i)
-	in, err := strconv.Atoi(input.Value)
+	in, err := strconv.Atoi(levelInput.Value)
 	if err != nil || in < 0 {
-		if err = resp.
-			SetMessage("Impossible de lire le nombre. Il doit s'agit d'un nombre entier positif.").
-			Send(); err != nil {
-			logger.Alert("command/config.go - Sending bad number", err.Error())
+		err = resp.IsEphemeral().
+			SetMessage(
+				fmt.Sprintf("Le niveau doit être un nombre entier positif.\n-# Trouvé : %s", levelInput.Value),
+			).
+			Send()
+		if err != nil {
+			s.Logger().Error("sending bad number warning message", "error", err)
 		}
 		return
 	}
-	configModifyMap[k] = exp.LevelXP(uint(in))
-	go func(i *discordgo.InteractionCreate, k string) {
-		time.Sleep(5 * time.Minute)
-		delete(configModifyMap, k)
-	}(i, k)
+	xp := exp.LevelXP(uint(in))
 
-	cID := XpRoleAddRole
-	resp.SetMessage("Rôle à ajouter")
-	if data.CustomID == XpRoleEditLevel {
-		cID = XpRoleEditRole
-		resp.SetMessage("Rôle à modifier")
-	}
+	roleId := data.Components[1].(*component.Label).Component.(*component.SelectMenu).Values[0]
 
-	err = resp.
-		SetComponents(component.New().Add(component.NewActionRow().Add(component.NewRoleSelect(cID)))).
-		Send()
+	cfg := GetGuildConfig(i.GuildID)
+	cfg.XpRoles = append(cfg.XpRoles, XpRole{
+		XP:     xp,
+		RoleID: roleId,
+	})
+	err = cfg.Save()
 	if err != nil {
-		logger.Alert("config/xp_reduce.go - Sending response to add/edit", err.Error())
+		s.Logger().Error("saving config", "error", err, "role", roleId, "guild", i.GuildID)
+		return
 	}
+
+	HandleXpRole(s, i, &interaction.MessageComponentData{}, resp)
 }
 
-func getKeyConfigRole(i *discordgo.InteractionCreate) string {
-	return fmt.Sprintf("r:%s:%s", i.GuildID, i.Member.User.ID)
+func getRoleLevelID(dynamic []string) (uint, error) {
+	id64, err := strconv.ParseUint(dynamic[0], 10, 0)
+	if err != nil {
+		return 0, err
+	}
+
+	return uint(id64), nil
 }