aboutsummaryrefslogtreecommitdiff
path: root/rolereact/rolereact.go
diff options
context:
space:
mode:
Diffstat (limited to 'rolereact/rolereact.go')
-rw-r--r--rolereact/rolereact.go302
1 files changed, 114 insertions, 188 deletions
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)
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-03 13:38:58 +0000