refactor(events): use new handlers

3 files changed, 152 insertions, 231 deletions

diff --git a/rolereact/manager.go b/rolereact/manager.go
index 1288b33..ab268f2 100644
--- a/rolereact/manager.go
+++ b/rolereact/manager.go
@@ -13,6 +13,7 @@ import (
 	"github.com/nyttikord/gokord/channel"
 	"github.com/nyttikord/gokord/emoji"
 	"github.com/nyttikord/gokord/event"
+	"github.com/nyttikord/gokord/interaction"
 )
 
 func MessageContent(message *config.RoleReactMessage) string {
@@ -31,34 +32,28 @@ func MessageContent(message *config.RoleReactMessage) string {
 	return content
 }
 
-func ApplyMessageChange(s bot.Session, i *event.InteractionCreate, message *config.RoleReactMessage) string {
+func ApplyMessageChange(ctx context.Context, s bot.Session, i *interaction.Interaction, message *config.RoleReactMessage) string {
 	messageContent := MessageContent(message)
-	_, err := s.ChannelAPI().MessageEditComplex(
-		&channel.MessageEdit{
-			Content:         &messageContent,
-			AllowedMentions: &channel.MessageAllowedMentions{},
-			Channel:         message.ChannelID,
-			ID:              message.MessageID,
-		},
-	)
+	_, err := s.ChannelAPI().MessageEditComplex(&channel.MessageEdit{
+		Content:         &messageContent,
+		AllowedMentions: &channel.MessageAllowedMentions{},
+		Channel:         message.ChannelID,
+		ID:              message.MessageID,
+	}).Do(ctx)
 	if err != nil {
-		s.Logger().Error("unable to update rolereact message", "error", err)
+		bot.Logger(ctx).Error("unable to update rolereact message", "error", err)
 		return "Impossible de mettre à jour le message."
 	}
 	for _, role := range message.Roles {
 		if role.Reaction != "" && role.RoleID != "" && err == nil {
-			err = s.ChannelAPI().MessageReactionAdd(
-				message.ChannelID,
-				message.MessageID,
-				role.Reaction,
-			)
+			err = s.ChannelAPI().MessageReactionAdd(message.ChannelID, message.MessageID, role.Reaction).Do(ctx)
 		}
 	}
 	if err != nil {
-		s.Logger().Error("unable to update reactions on rolereact message", "error", err)
+		bot.Logger(ctx).Error("unable to update reactions on rolereact message", "error", err)
 		return "Impossible de mettre à jour le message."
 	}
-	cfg := GetGuildConfigPreloaded(i.GuildID)
+	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]
@@ -71,7 +66,7 @@ func ApplyMessageChange(s bot.Session, i *event.InteractionCreate, message *conf
 			if !ok {
 				err := oldGokord.DB.Delete(role).Error
 				if err != nil {
-					s.Logger().Error("unable to delete reaction role from database", "error", err)
+					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."
 				}
 			}
@@ -79,13 +74,13 @@ func ApplyMessageChange(s bot.Session, i *event.InteractionCreate, message *conf
 		cfg.RrMessages[messageIndex] = *message
 		err := oldGokord.DB.Save(cfg.RrMessages[messageIndex]).Error
 		if err != nil {
-			s.Logger().Error("unable to save rolereaction message in database", "error", err)
+			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 = oldGokord.DB.Save(role).Error
 			if err != nil {
-				s.Logger().Error("unable to save rolereaction role 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."
 			}
 		}
@@ -93,8 +88,8 @@ func ApplyMessageChange(s bot.Session, i *event.InteractionCreate, message *conf
 	return "Message de réaction mis à jour avec succès !"
 }
 
-func WaitForEmoji(s bot.Session, userID string, messageID string) (string, bool) {
-	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
+func WaitForEmoji(ctx context.Context, s bot.Session, userID string, messageID string) (string, bool) {
+	ctx, cancel := context.WithTimeout(ctx, 1*time.Minute)
 	defer cancel()
 
 	emojiChann := make(chan emoji.Emoji)
@@ -115,7 +110,7 @@ func WaitForEmoji(s bot.Session, userID string, messageID string) (string, bool)
 	}
 }
 
-func GetMessageFromEditID(i *event.InteractionCreate, editID uint) (*config.RoleReactMessage, bool) {
+func GetMessageFromEditID(i *interaction.Interaction, editID uint) (*config.RoleReactMessage, bool) {
 	cfg := config.GetGuildConfig(i.GuildID)
 	m, ok := messageEdits[editID]
 	if !ok || m.GuildConfigID != cfg.ID {
@@ -124,7 +119,7 @@ func GetMessageFromEditID(i *event.InteractionCreate, editID uint) (*config.Role
 	return m, true
 }
 
-func GetGuildConfigPreloaded(guildID string) *config.GuildConfig {
+func GetGuildConfigPreloaded(ctx context.Context, guildID string) *config.GuildConfig {
 	cfg := config.GuildConfig{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
diff --git a/rolereact/rolereact.go b/rolereact/rolereact.go
index 6cb3b5c..2830ab4 100644
--- a/rolereact/rolereact.go
+++ b/rolereact/rolereact.go
@@ -7,12 +7,10 @@ import (
 
 	"git.anhgelus.world/anhgelus/les-copaings-bot/config"
 	"git.anhgelus.world/anhgelus/les-copaings-bot/dynamicid"
-	"github.com/anhgelus/gokord/cmd"
 	"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"
 )
 
@@ -44,22 +42,18 @@ var (
 	messageEdits   map[uint]*config.RoleReactMessage = make(map[uint]*config.RoleReactMessage)
 )
 
-func HandleCommand(
-	s bot.Session,
-	i *event.InteractionCreate,
-	o cmd.OptionMap,
-	resp *cmd.ResponseBuilder,
-) {
-	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
+func HandleCommand(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
+	err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseDeferredChannelMessageWithSource,
 		Data: &interaction.ResponseData{
 			Flags: channel.MessageFlagsEphemeral,
 		},
-	})
+	}).Do(ctx)
 	if err != nil {
-		s.Logger().Error("unable to defer interaction", "error", err)
+		bot.Logger(ctx).Error("unable to defer interaction", "error", err)
 		return
 	}
+	o := i.OptionMap()
 	c := o["salon"]
 	var channelID string
 	if c != nil {
@@ -73,36 +67,35 @@ func HandleCommand(
 		GuildID:   i.GuildID,
 	}
 	messageContent := MessageContent(&message)
-	m, err := s.ChannelAPI().MessageSendComplex(
-		channelID, &channel.MessageSend{
-			Content:         messageContent,
-			AllowedMentions: &channel.MessageAllowedMentions{},
-		},
-	)
+	m, err := dg.ChannelAPI().MessageSendComplex(channelID, &channel.MessageSend{
+		Content:         messageContent,
+		AllowedMentions: &channel.MessageAllowedMentions{},
+	},
+	).Do(ctx)
 	if err != nil {
-		_, err := s.InteractionAPI().FollowupMessageCreate(i.Interaction, false, &channel.WebhookParams{
+		_, 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())}},
-		})
+		}).Do(ctx)
 		if err != nil {
-			s.Logger().Error("Unable to send message", "error", err)
+			bot.Logger(ctx).Error("Unable to send message", "error", err)
 		}
 		return
 	}
 	message.MessageID = m.ID
-	cfg := GetGuildConfigPreloaded(i.GuildID)
+	cfg := GetGuildConfigPreloaded(ctx, i.GuildID)
 	cfg.RrMessages = append(cfg.RrMessages, message)
 	err = cfg.Save()
 	if err != nil {
-		s.Logger().Error("Unable to save rolereact message in database", "error", err)
-		_, err := s.InteractionAPI().FollowupMessageCreate(i.Interaction, false, &channel.WebhookParams{
+		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{
 				&component.TextDisplay{Content: "Impossible d'enregistrer le message dans la base de données. Merci de contacter l'administrateur du bot."},
 			},
-		})
+		}).Do(ctx)
 		if err != nil {
-			s.Logger().Error("unable to send message", "error", err)
+			bot.Logger(ctx).Error("unable to send message", "error", err)
 		}
 		return
 	}
@@ -111,27 +104,23 @@ func HandleCommand(
 	editID := messageCounter
 	messageCounter++
 
-	components := MessageModifyComponents(i, &EditID{MessageEditID: editID})
+	components := MessageModifyComponents(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...
-	_, err = s.InteractionAPI().FollowupMessageCreate(i.Interaction, false, &channel.WebhookParams{
+	_, err = dg.InteractionAPI().FollowupMessageCreate(i.Interaction, false, &channel.WebhookParams{
 		Flags:      channel.MessageFlagsIsComponentsV2,
 		Components: components,
-	})
+	}).Do(ctx)
 	if err != nil {
-		s.Logger().Error("Unable to send edit rolereact message", "error", err)
+		bot.Logger(ctx).Error("Unable to send edit rolereact message", "error", err)
 	}
 }
 
-func HandleModifyCommand(
-	ctx context.Context,
-	s bot.Session,
-	cmd *interaction.ApplicationCommand,
-) {
+func HandleModifyCommand(ctx context.Context, dg bot.Session, i *interaction.ApplicationCommand) {
 	logger := bot.Logger(ctx)
-	messageId := cmd.Data.TargetID
-	cfg := GetGuildConfigPreloaded(cmd.GuildID)
+	messageId := i.Data.TargetID
+	cfg := GetGuildConfigPreloaded(ctx, i.GuildID)
 	var target *config.RoleReactMessage
 	var targetEditID uint
 	for editID, message := range messageEdits {
@@ -147,7 +136,7 @@ func HandleModifyCommand(
 			}
 		}
 		if target == nil {
-			err := s.InteractionAPI().Respond(cmd.Interaction, &interaction.Response{
+			err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 				Type: types.InteractionResponseChannelMessageWithSource,
 				Data: &interaction.ResponseData{
 					Flags:   channel.MessageFlagsEphemeral,
@@ -163,39 +152,27 @@ func HandleModifyCommand(
 		targetEditID = messageCounter
 		messageCounter++
 	}
-	err := s.InteractionAPI().Respond(cmd.Interaction, &interaction.Response{
+	err := dg.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseChannelMessageWithSource,
-		Data: MessageModifyData(cmd, &EditID{MessageEditID: targetEditID}),
+		Data: MessageModifyData(ctx, i.Interaction, &EditID{MessageEditID: targetEditID}),
 	}).Do(ctx)
 	if err != nil {
 		logger.Error("Unable to send modify rolereact message", "error", err)
 	}
 }
 
-func HandleModifyComponent(
-	s bot.Session,
-	i *event.InteractionCreate,
-	data *interaction.MessageComponentData,
-	parameters *EditID,
-	resp *cmd.ResponseBuilder,
-) {
+func HandleModifyComponent(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditID) {
 	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
-		Data: MessageModifyData(i, parameters),
-	})
+		Data: MessageModifyData(ctx, i.Interaction, params),
+	}).Do(ctx)
 	if err != nil {
-		s.Logger().Error("Unable to send modify rolereact message", "error", err)
+		bot.Logger(ctx).Error("Unable to send modify rolereact message", "error", err)
 	}
 }
 
-func HandleResetMessage(
-	s bot.Session,
-	i *event.InteractionCreate,
-	data *interaction.MessageComponentData,
-	parameters *EditID,
-	resp *cmd.ResponseBuilder,
-) {
-	message, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func HandleResetMessage(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditID) {
+	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
 	var responseData interaction.ResponseData
 	if !ok {
 		responseData = interaction.ResponseData{
@@ -205,31 +182,25 @@ func HandleResetMessage(
 			},
 		}
 	} else {
-		cfg := GetGuildConfigPreloaded(i.GuildID)
+		cfg := GetGuildConfigPreloaded(ctx, i.GuildID)
 		for _, m := range cfg.RrMessages {
 			if m.ID == message.ID {
-				messageEdits[parameters.MessageEditID] = &m
+				messageEdits[params.MessageEditID] = &m
 			}
 		}
-		responseData = *MessageModifyData(i, parameters)
+		responseData = *MessageModifyData(ctx, i.Interaction, params)
 	}
 	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: &responseData,
 	})
 	if err != nil {
-		s.Logger().Error("Unable to send reset message message", "error", err)
+		bot.Logger(ctx).Error("Unable to send reset message message", "error", err)
 	}
 }
 
-func HandleStartSetNote(
-	s bot.Session,
-	i *event.InteractionCreate,
-	data *interaction.MessageComponentData,
-	parameters *EditID,
-	resp *cmd.ResponseBuilder,
-) {
-	message, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func HandleStartSetNote(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditID) {
+	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
 	if !ok {
 		err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseUpdateMessage,
@@ -241,42 +212,32 @@ func HandleStartSetNote(
 			},
 		})
 		if err != nil {
-			s.Logger().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
 	}
-	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
-		Type: types.InteractionResponseModal,
-		Data: &interaction.ResponseData{
-			Title:    "Changer la description",
-			CustomID: dynamicid.FormatCustomID(SetNote, *parameters),
-			Components: []component.Component{
-				&component.Label{
-					Label:       "Nouvelle description",
-					Description: "Description affichée sur votre message de réaction",
-					Component: &component.TextInput{
-						Style:     component.TextInputParagraph,
-						MaxLength: 2000,
-						CustomID:  "note",
-						Value:     message.Note,
-					},
-				},
+	resp := interaction.NewModalResponse().
+		Title("Changer la description").
+		CustomID(dynamicid.FormatCustomID(SetNote, *params)).
+		AddComponent(&component.Label{
+			Label:       "Nouvelle description",
+			Description: "Description affichée sur votre message de réaction",
+			Component: &component.TextInput{
+				Style:     component.TextInputParagraph,
+				MaxLength: 2000,
+				CustomID:  "note",
+				Value:     message.Note,
 			},
-		},
-	})
+		}).
+		Response()
+	err := s.InteractionAPI().Respond(i.Interaction, resp).Do(ctx)
 	if err != nil {
-		s.Logger().Error("Unable to send edit note modal", "error", err)
+		bot.Logger(ctx).Error("Unable to send edit note modal", "error", err)
 	}
 }
 
-func HandleSetNote(
-	s bot.Session,
-	i *event.InteractionCreate,
-	data *interaction.ModalSubmitData,
-	parameters *EditID,
-	resp *cmd.ResponseBuilder,
-) {
-	message, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func HandleSetNote(ctx context.Context, s bot.Session, i *interaction.ModalSubmit, params *EditID) {
+	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
 	if !ok {
 		err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 			Type: types.InteractionResponseUpdateMessage,
@@ -288,28 +249,22 @@ func HandleSetNote(
 			},
 		})
 		if err != nil {
-			s.Logger().Error("unable to send set note error message", "error", err)
+			bot.Logger(ctx).Error("unable to send set note error message", "error", err)
 		}
 		return
 	}
-	message.Note = data.Components[0].(*component.Label).Component.(*component.TextInput).Value
+	message.Note = i.Data.Components[0].(*component.Label).Component.(*component.TextInput).Value
 	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
-		Data: MessageModifyData(i, parameters),
+		Data: MessageModifyData(ctx, i.Interaction, params),
 	})
 	if err != nil {
-		s.Logger().Error("Unable to send updated note message", "error", err)
+		bot.Logger(ctx).Error("Unable to send updated note message", "error", err)
 	}
 }
 
-func HandleApplyMessage(
-	s bot.Session,
-	i *event.InteractionCreate,
-	data *interaction.MessageComponentData,
-	parameters *EditID,
-	resp *cmd.ResponseBuilder,
-) {
-	message, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func HandleApplyMessage(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditID) {
+	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
 	var responseData interaction.ResponseData
 	if !ok {
 		responseData = interaction.ResponseData{
@@ -323,35 +278,29 @@ func HandleApplyMessage(
 			Data: &responseData,
 		})
 		if err != nil {
-			s.Logger().Error("unable to send apply message error message", "error", err)
+			bot.Logger(ctx).Error("unable to send apply message error message", "error", err)
 		}
 		return
 	}
 	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseDeferredChannelMessageWithSource,
 		Data: &interaction.ResponseData{Flags: channel.MessageFlagsEphemeral},
-	})
+	}).Do(ctx)
 	if err != nil {
-		s.Logger().Error("Unable to defer interaction", "error", err)
+		bot.Logger(ctx).Error("Unable to defer interaction", "error", err)
 		return
 	}
-	m := ApplyMessageChange(s, i, message)
+	m := ApplyMessageChange(ctx, s, i.Interaction, message)
 	_, err = s.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
 		Content: &m,
-	})
+	}).Do(ctx)
 	if err != nil {
-		s.Logger().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(
-	s bot.Session,
-	i *event.InteractionCreate,
-	data *interaction.MessageComponentData,
-	parameters *EditID,
-	resp *cmd.ResponseBuilder,
-) {
-	message, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func HandleNewRole(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditID) {
+	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
 	var responseData interaction.ResponseData
 	if !ok {
 		responseData = interaction.ResponseData{
@@ -362,7 +311,7 @@ func HandleNewRole(
 		}
 	} else {
 		message.Roles = append(message.Roles, &config.RoleReact{CounterID: roleCounter})
-		responseData = MessageModifyRoleData(i, &EditIDWithRole{MessageEditID: parameters.MessageEditID, RoleCounterID: roleCounter}, "")
+		responseData = MessageModifyRoleData(i.Interaction, &EditIDWithRole{MessageEditID: params.MessageEditID, RoleCounterID: roleCounter}, "")
 		roleCounter++
 	}
 	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
@@ -370,18 +319,12 @@ func HandleNewRole(
 		Data: &responseData,
 	})
 	if err != nil {
-		s.Logger().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(
-	s bot.Session,
-	i *event.InteractionCreate,
-	data *interaction.MessageComponentData,
-	parameters *EditIDWithRole,
-	resp *cmd.ResponseBuilder,
-) {
-	_, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func HandleOpenRole(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
+	_, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
 	var responseData interaction.ResponseData
 	if !ok {
 		responseData = interaction.ResponseData{
@@ -391,29 +334,23 @@ func HandleOpenRole(
 			},
 		}
 	} else {
-		responseData = MessageModifyRoleData(i, parameters, "")
+		responseData = MessageModifyRoleData(i.Interaction, params, "")
 	}
 	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: &responseData,
 	})
 	if err != nil {
-		s.Logger().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(
-	s bot.Session,
-	i *event.InteractionCreate,
-	data *interaction.MessageComponentData,
-	parameters *EditIDWithRole,
-	resp *cmd.ResponseBuilder,
-) {
-	message, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func HandleSetRole(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
+	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
 	var responseData interaction.ResponseData
 	var role *config.RoleReact
 	if ok {
-		roleIndex := slices.IndexFunc(message.Roles, func(role *config.RoleReact) bool { return role.CounterID == parameters.RoleCounterID })
+		roleIndex := slices.IndexFunc(message.Roles, func(role *config.RoleReact) bool { return role.CounterID == params.RoleCounterID })
 		if roleIndex != -1 {
 			role = message.Roles[roleIndex]
 		}
@@ -426,29 +363,23 @@ func HandleSetRole(
 			},
 		}
 	} else {
-		role.RoleID = data.Values[0]
-		responseData = MessageModifyRoleData(i, parameters, "")
+		role.RoleID = i.Data.Values[0]
+		responseData = MessageModifyRoleData(i.Interaction, params, "")
 	}
 	err := s.InteractionAPI().Respond(i.Interaction, &interaction.Response{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: &responseData,
-	})
+	}).Do(ctx)
 	if err != nil {
-		s.Logger().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(
-	s bot.Session,
-	i *event.InteractionCreate,
-	data *interaction.MessageComponentData,
-	parameters *EditIDWithRole,
-	resp *cmd.ResponseBuilder,
-) {
-	message, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func HandleSetReaction(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
+	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
 	var role *config.RoleReact
 	if ok {
-		roleIndex := slices.IndexFunc(message.Roles, func(role *config.RoleReact) bool { return role.CounterID == parameters.RoleCounterID })
+		roleIndex := slices.IndexFunc(message.Roles, func(role *config.RoleReact) bool { return role.CounterID == params.RoleCounterID })
 		if roleIndex != -1 {
 			role = message.Roles[roleIndex]
 		}
@@ -462,66 +393,61 @@ func HandleSetReaction(
 					&component.TextDisplay{Content: "Impossible de trouver la modification de message. Veuillez réessayer."},
 				},
 			},
-		})
+		}).Do(ctx)
 		if err != nil {
-			s.Logger().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, parameters, "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(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{
 		Type: types.InteractionResponseUpdateMessage,
 		Data: &responseData,
-	})
-	emojiName, ok := WaitForEmoji(s, i.Member.User.ID, message.MessageID)
+	}).Do(ctx)
+	emojiName, ok := WaitForEmoji(ctx, s, i.Member.User.ID, message.MessageID)
 	if !ok {
-		editResponseComponents := MessageModifyRoleComponents(i, parameters, "Le temps d'attente a été dépassé")
+		editResponseComponents := MessageModifyRoleComponents(i.Interaction, params, "Le temps d'attente a été dépassé")
 		_, err := s.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
 			Components: &editResponseComponents,
-		})
+		}).Do(ctx)
 		if err != nil {
-			s.Logger().Error("unable to send timed out reaction message", "error", err)
+			bot.Logger(ctx).Error("unable to send timed out reaction message", "error", err)
 		}
 		return
 	}
 
-	err := s.ChannelAPI().MessageReactionAdd(message.ChannelID, message.MessageID, emojiName)
+	err := s.ChannelAPI().MessageReactionAdd(message.ChannelID, message.MessageID, emojiName).Do(ctx)
 	if err != nil {
-		editResponseComponents := MessageModifyRoleComponents(i, parameters, "La réaction n'est pas utilisable. Cela peut être résolu en l'ajoutant à ce serveur")
+		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{
 			Components: &editResponseComponents,
-		})
+		}).Do(ctx)
 		if err != nil {
-			s.Logger().Error("unable to send unusable reaction message", "error", err)
+			bot.Logger(ctx).Error("unable to send unusable reaction message", "error", err)
 		}
 		return
 	}
-	err = s.ChannelAPI().MessageReactionRemove(message.ChannelID, message.MessageID, emojiName, i.Member.User.ID)
+	err = s.ChannelAPI().MessageReactionRemove(message.ChannelID, message.MessageID, emojiName, i.Member.User.ID).Do(ctx)
 	if err != nil {
-		s.Logger().Warn("unable to remove author reaction from message", "error", err)
+		bot.Logger(ctx).Warn("unable to remove author reaction from message", "error", err)
 	}
 	role.Reaction = emojiName
-	components := MessageModifyRoleComponents(i, parameters, "")
+	components := MessageModifyRoleComponents(i.Interaction, params, "")
 	_, err = s.InteractionAPI().ResponseEdit(i.Interaction, &channel.WebhookEdit{
 		Flags:      channel.MessageFlagsIsComponentsV2 | channel.MessageFlagsEphemeral,
 		Components: &components,
-	})
+	}).Do(ctx)
 	if err != nil {
-		s.Logger().Error("Unable to edit original response", "error", err)
+		bot.Logger(ctx).Error("Unable to edit original response", "error", err)
 	}
 }
 
-func HandleDelRole(
-	s bot.Session,
-	i *event.InteractionCreate,
-	data *interaction.MessageComponentData,
-	parameters *EditIDWithRole,
-	resp *cmd.ResponseBuilder,
-) {
-	message, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func HandleDelRole(ctx context.Context, s bot.Session, i *interaction.MessageComponent, params *EditIDWithRole) {
+	message, ok := GetMessageFromEditID(i.Interaction, params.MessageEditID)
 	roleIndex := -1
 	if ok {
-		roleIndex = slices.IndexFunc(message.Roles, func(role *config.RoleReact) bool { return role.CounterID == parameters.RoleCounterID })
+		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{
@@ -532,9 +458,9 @@ func HandleDelRole(
 					&component.TextDisplay{Content: "Impossible de trouver la modification de message. Veuillez réessayer."},
 				},
 			},
-		})
+		}).Do(ctx)
 		if err != nil {
-			s.Logger().Error("Unable to send open reaction role message", "error", err)
+			bot.Logger(ctx).Error("Unable to send open reaction role message", "error", err)
 		}
 		return
 	}
@@ -544,9 +470,9 @@ func HandleDelRole(
 	err := s.InteractionAPI().Respond(i.Interaction,
 		&interaction.Response{
 			Type: types.InteractionResponseUpdateMessage,
-			Data: MessageModifyData(i, &EditID{MessageEditID: parameters.MessageEditID}),
-		})
+			Data: MessageModifyData(ctx, i.Interaction, &EditID{MessageEditID: params.MessageEditID}),
+		}).Do(ctx)
 	if err != nil {
-		s.Logger().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 3ecfe13..7b31ec4 100644
--- a/rolereact/views.go
+++ b/rolereact/views.go
@@ -1,6 +1,7 @@
 package rolereact
 
 import (
+	"context"
 	"fmt"
 	"slices"
 
@@ -9,12 +10,11 @@ import (
 	"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"
 )
 
-func MessageModifyComponents(i *event.InteractionCreate, parameters *EditID) []component.Message {
-	message, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func MessageModifyComponents(i *interaction.Interaction, params *EditID) []component.Message {
+	message, ok := GetMessageFromEditID(i, params.MessageEditID)
 	if !ok {
 		return []component.Message{
 			&component.TextDisplay{Content: "Cette modification est trop vieille et a été oubliée."},
@@ -34,7 +34,7 @@ func MessageModifyComponents(i *event.InteractionCreate, parameters *EditID) []c
 			Accessory: &component.Button{
 				Label:    "Modifier",
 				Style:    component.ButtonStyleSecondary,
-				CustomID: dynamicid.FormatCustomID(SetNote, *parameters),
+				CustomID: dynamicid.FormatCustomID(SetNote, *params),
 			},
 		},
 		&component.Separator{},
@@ -61,7 +61,7 @@ func MessageModifyComponents(i *event.InteractionCreate, parameters *EditID) []c
 			Accessory: &component.Button{
 				Label:    "Modifier",
 				Style:    component.ButtonStyleSecondary,
-				CustomID: dynamicid.FormatCustomID(OpenRole, EditIDWithRole{parameters.MessageEditID, role.CounterID}),
+				CustomID: dynamicid.FormatCustomID(OpenRole, EditIDWithRole{params.MessageEditID, role.CounterID}),
 			},
 		})
 	}
@@ -76,7 +76,7 @@ func MessageModifyComponents(i *event.InteractionCreate, parameters *EditID) []c
 				&component.Button{
 					Style:    component.ButtonStylePrimary,
 					Label:    "Ajouter",
-					CustomID: dynamicid.FormatCustomID(NewRole, EditID{MessageEditID: parameters.MessageEditID}),
+					CustomID: dynamicid.FormatCustomID(NewRole, EditID{MessageEditID: params.MessageEditID}),
 					Disabled: len(message.Roles) >= 20,
 				},
 			},
@@ -87,12 +87,12 @@ func MessageModifyComponents(i *event.InteractionCreate, parameters *EditID) []c
 				&component.Button{
 					Label:    "Appliquer",
 					Style:    component.ButtonStylePrimary,
-					CustomID: dynamicid.FormatCustomID(ApplyMessage, EditID{MessageEditID: parameters.MessageEditID}),
+					CustomID: dynamicid.FormatCustomID(ApplyMessage, EditID{MessageEditID: params.MessageEditID}),
 				},
 				&component.Button{
 					Label:    "Réinitialiser",
 					Style:    component.ButtonStyleDanger,
-					CustomID: dynamicid.FormatCustomID(ResetMessage, *parameters),
+					CustomID: dynamicid.FormatCustomID(ResetMessage, *params),
 				},
 				&component.Button{
 					Label: "Message",
@@ -108,9 +108,9 @@ func MessageModifyComponents(i *event.InteractionCreate, parameters *EditID) []c
 	}
 }
 
-func MessageModifyData(i *event.InteractionCreate, parameters *EditID) *interaction.ResponseData {
+func MessageModifyData(ctx context.Context, i *interaction.Interaction, params *EditID) *interaction.ResponseData {
 	components := []component.Component{}
-	for _, component := range MessageModifyComponents(i, parameters) {
+	for _, component := range MessageModifyComponents(i, params) {
 		components = append(components, component)
 	}
 	responseData := &interaction.ResponseData{
@@ -120,11 +120,11 @@ func MessageModifyData(i *event.InteractionCreate, parameters *EditID) *interact
 	return responseData
 }
 
-func MessageModifyRoleComponents(i *event.InteractionCreate, parameters *EditIDWithRole, emojiMessage string) []component.Message {
-	message, ok := GetMessageFromEditID(i, parameters.MessageEditID)
+func MessageModifyRoleComponents(i *interaction.Interaction, params *EditIDWithRole, emojiMessage string) []component.Message {
+	message, ok := GetMessageFromEditID(i, params.MessageEditID)
 	var role *config.RoleReact
 	if ok {
-		roleIndex := slices.IndexFunc(message.Roles, func(role *config.RoleReact) bool { return role.CounterID == parameters.RoleCounterID })
+		roleIndex := slices.IndexFunc(message.Roles, func(role *config.RoleReact) bool { return role.CounterID == params.RoleCounterID })
 		if roleIndex != -1 {
 			role = message.Roles[roleIndex]
 		}
@@ -145,7 +145,7 @@ func MessageModifyRoleComponents(i *event.InteractionCreate, parameters *EditIDW
 		reactionButton = component.Button{Label: "Ajouter", Style: component.ButtonStylePrimary}
 		disableBack = true
 	}
-	reactionButton.CustomID = dynamicid.FormatCustomID(SetRoleReaction, *parameters)
+	reactionButton.CustomID = dynamicid.FormatCustomID(SetRoleReaction, *params)
 	defaultRoleValues := make([]component.SelectMenuDefaultValue, 0)
 	if role.RoleID != "" {
 		defaultRoleValues = append(defaultRoleValues, component.SelectMenuDefaultValue{
@@ -173,7 +173,7 @@ func MessageModifyRoleComponents(i *event.InteractionCreate, parameters *EditIDW
 			&component.ActionsRow{Components: []component.Message{
 				&component.SelectMenu{
 					MenuType:  types.SelectMenuRole,
-					CustomID:  dynamicid.FormatCustomID(SetRoleRoleID, *parameters),
+					CustomID:  dynamicid.FormatCustomID(SetRoleRoleID, *params),
 					MinValues: &one, MaxValues: 1,
 					Placeholder:   "Sélectionner un rôle",
 					DefaultValues: defaultRoleValues,
@@ -183,7 +183,7 @@ func MessageModifyRoleComponents(i *event.InteractionCreate, parameters *EditIDW
 				&component.Button{
 					Style:    component.ButtonStyleDanger,
 					Label:    "Supprimer",
-					CustomID: dynamicid.FormatCustomID(DelRole, *parameters),
+					CustomID: dynamicid.FormatCustomID(DelRole, *params),
 				},
 			}},
 			&component.Separator{},
@@ -192,7 +192,7 @@ func MessageModifyRoleComponents(i *event.InteractionCreate, parameters *EditIDW
 					Label:    "Retour",
 					Style:    component.ButtonStyleSecondary,
 					Disabled: disableBack,
-					CustomID: dynamicid.FormatCustomID(OpenMessage, EditID{MessageEditID: parameters.MessageEditID}),
+					CustomID: dynamicid.FormatCustomID(OpenMessage, EditID{MessageEditID: params.MessageEditID}),
 				},
 				&component.Button{
 					Label: "Message", Style: component.ButtonStyleLink,
@@ -205,9 +205,9 @@ func MessageModifyRoleComponents(i *event.InteractionCreate, parameters *EditIDW
 	}}
 }
 
-func MessageModifyRoleData(i *event.InteractionCreate, parameters *EditIDWithRole, emojiMessage string) interaction.ResponseData {
+func MessageModifyRoleData(i *interaction.Interaction, params *EditIDWithRole, emojiMessage string) interaction.ResponseData {
 	components := []component.Component{}
-	for _, component := range MessageModifyRoleComponents(i, parameters, emojiMessage) {
+	for _, component := range MessageModifyRoleComponents(i, params, emojiMessage) {
 		components = append(components, component)
 	}
 	return interaction.ResponseData{