feat: leveling system

internal/commands/level/level_config.go

@@ -102,63 +102,29 @@ func HandleLevelConfig(s *discordgo.Session, i *discordgo.InteractionCreate) {
 	case "set-reward":
 		HandleLevelSetReward(s, i)
 	default:
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid subcommand.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Invalid subcommand.")
 	}
 
 }
 
 func HandleLevelToggle(s *discordgo.Session, i *discordgo.InteractionCreate) {
-	// Basic permission check: require Manage Guild permission
-	if i.Member == nil || (i.Member.Permissions&discordgo.PermissionManageGuild) == 0 {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "You don't have permission to manage leveling settings.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	if !requireManageGuild(s, i) {
 		return
 	}
 
-	if services.Global == nil || services.Global.LevelSettings == nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Leveling service is not available.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	if !requireLevelSettingsService(s, i) {
 		return
 	}
 
 	ctx := context.Background()
-	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
-	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid guild ID.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	guildID, ok := parseGuildID(s, i)
+	if !ok {
 		return
 	}
 
 	enabled, err := services.Global.LevelSettings.ToggleLevelSystem(ctx, guildID)
 	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Failed to toggle leveling system.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Failed to toggle leveling system.")
 		return
 	}
 
@@ -167,294 +133,131 @@ func HandleLevelToggle(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		status = "enabled"
 	}
 
-	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-		Type: discordgo.InteractionResponseChannelMessageWithSource,
-		Data: &discordgo.InteractionResponseData{
-			Content: "Leveling system " + status + " for this server.",
-			Flags:   discordgo.MessageFlagsEphemeral,
-		},
-	})
+	respondEphemeral(s, i, "Leveling system "+status+" for this server.")
 }
 
 func HandleLevelSet(s *discordgo.Session, i *discordgo.InteractionCreate) {
-	// Basic permission check: require Manage Guild permission
-	if i.Member == nil || (i.Member.Permissions&discordgo.PermissionManageGuild) == 0 {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "You don't have permission to manage leveling settings.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	if !requireManageGuild(s, i) || !requireLevelSystemEnabled(s, i) {
 		return
 	}
 
-	// check if the leveling service is available
 	if services.Global == nil || services.Global.Level == nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Leveling service is not available.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Leveling service is not available.")
 		return
 	}
 
-	data := i.ApplicationCommandData()
-	optMap := make(map[string]*discordgo.ApplicationCommandInteractionDataOption, len(data.Options[0].Options))
-	for _, opt := range data.Options[0].Options {
-		optMap[opt.Name] = opt
-	}
+	optMap := subcommandOptionMap(i)
 
 	userOpt, ok := optMap["user"]
 	if !ok {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Missing user option.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Missing user option.")
 		return
 	}
 
 	levelOpt, ok := optMap["level"]
 	if !ok {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Missing level option.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Missing level option.")
 		return
 	}
 
 	targetUser := userOpt.UserValue(s)
 	if targetUser == nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid user.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Invalid user.")
 		return
 	}
 
 	// prevent setting bots (including ourselves)
 	if targetUser.Bot {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "You can't set a bot's level.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "You can't set a bot's level.")
 		return
 	}
 
 	newLevel := int(levelOpt.IntValue())
 
 	ctx := context.Background()
-	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
-	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid guild ID.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	guildID, ok := parseGuildID(s, i)
+	if !ok {
 		return
 	}
 
 	userID, err := strconv.ParseInt(targetUser.ID, 10, 64)
 	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid user ID.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Invalid user ID.")
 		return
 	}
 
 	err = services.Global.Level.SetLevel(ctx, guildID, userID, newLevel)
 	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Failed to set level.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Failed to set level.")
 		return
 	}
 
-	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-		Type: discordgo.InteractionResponseChannelMessageWithSource,
-		Data: &discordgo.InteractionResponseData{
-			Content: "Level set to " + strconv.Itoa(newLevel) + " for " + targetUser.Mention() + ".",
-			Flags:   discordgo.MessageFlagsEphemeral,
-		},
-	})
+	respondEphemeral(s, i, "Level set to "+strconv.Itoa(newLevel)+" for "+targetUser.Mention()+".")
 }
 
 func HandleLevelSetChannel(s *discordgo.Session, i *discordgo.InteractionCreate) {
-	// Basic permission check: require Manage Guild permission
-	if i.Member == nil || (i.Member.Permissions&discordgo.PermissionManageGuild) == 0 {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "You don't have permission to manage leveling settings.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	if !requireManageGuild(s, i) || !requireLevelSystemEnabled(s, i) {
 		return
 	}
 
-	// check if the leveling service is available
-	if services.Global == nil || services.Global.Level == nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Leveling service is not available.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	if !requireLevelSettingsService(s, i) {
 		return
 	}
 
-	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
-	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid guild ID.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	guildID, ok := parseGuildID(s, i)
+	if !ok {
 		return
 	}
 
-	data := i.ApplicationCommandData()
-	optMap := make(map[string]*discordgo.ApplicationCommandInteractionDataOption, len(data.Options[0].Options))
-	for _, opt := range data.Options[0].Options {
-		optMap[opt.Name] = opt
-	}
+	optMap := subcommandOptionMap(i)
 
 	channelOpt, ok := optMap["channel"]
 	if !ok {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Missing channel option.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Missing channel option.")
 		return
 	}
 
 	channelID := channelOpt.ChannelValue(s)
 	if channelID == nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid channel.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Invalid channel.")
 		return
 	}
 
 	ctx := context.Background()
 	channelIDInt, err := strconv.ParseInt(channelID.ID, 10, 64)
 	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid channel ID.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Invalid channel ID.")
 		return
 	}
 
 	err = services.Global.LevelSettings.SetLevelUpChannel(ctx, guildID, channelIDInt)
 	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Failed to set level up channel.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Failed to set level up channel.")
+		return
 	}
 
-	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-		Type: discordgo.InteractionResponseChannelMessageWithSource,
-		Data: &discordgo.InteractionResponseData{
-			Content: "Level up channel set to " + channelID.Mention() + ".",
-			Flags:   discordgo.MessageFlagsEphemeral,
-		},
-	})
+	respondEphemeral(s, i, "Level up channel set to "+channelID.Mention()+".")
 }
 
 func HandleLevelSetMessage(s *discordgo.Session, i *discordgo.InteractionCreate) {
-	// Basic permission check: require Manage Guild permission
-	if i.Member == nil || (i.Member.Permissions&discordgo.PermissionManageGuild) == 0 {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "You don't have permission to manage leveling settings.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	if !requireManageGuild(s, i) || !requireLevelSystemEnabled(s, i) {
 		return
 	}
 
-	// check if the leveling service is available
-	if services.Global == nil || services.Global.Level == nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Leveling service is not available.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	if !requireLevelSettingsService(s, i) {
 		return
 	}
 
-	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
-	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid guild ID.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	guildID, ok := parseGuildID(s, i)
+	if !ok {
 		return
 	}
 
-	data := i.ApplicationCommandData()
-	optMap := make(map[string]*discordgo.ApplicationCommandInteractionDataOption, len(data.Options[0].Options))
-	for _, opt := range data.Options[0].Options {
-		optMap[opt.Name] = opt
-	}
+	optMap := subcommandOptionMap(i)
 
 	messageOpt, ok := optMap["message"]
 	if !ok {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Missing message option.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Missing message option.")
 		return
 	}
 
@@ -464,134 +267,60 @@ func HandleLevelSetMessage(s *discordgo.Session, i *discordgo.InteractionCreate)
 	}
 
 	ctx := context.Background()
-	err = services.Global.LevelSettings.SetLevelUpMessage(ctx, guildID, message)
+	err := services.Global.LevelSettings.SetLevelUpMessage(ctx, guildID, message)
 	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Failed to set level up channel.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Failed to set level up message.")
+		return
 	}
 
-	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-		Type: discordgo.InteractionResponseChannelMessageWithSource,
-		Data: &discordgo.InteractionResponseData{
-			Content: "Level up message set to " + message + ".",
-			Flags:   discordgo.MessageFlagsEphemeral,
-		},
-	})
+	respondEphemeral(s, i, "Level up message set.")
 }
 
 func HandleLevelSetReward(s *discordgo.Session, i *discordgo.InteractionCreate) {
-	// Basic permission check: require Manage Guild permission
-	if i.Member == nil || (i.Member.Permissions&discordgo.PermissionManageGuild) == 0 {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "You don't have permission to manage leveling settings.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	if !requireManageGuild(s, i) || !requireLevelSystemEnabled(s, i) {
 		return
 	}
 
-	// check if the leveling service is available
-	if services.Global == nil || services.Global.LevelSettings == nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Leveling service is not available.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	if !requireLevelSettingsService(s, i) {
 		return
 	}
 
-	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
-	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid guild ID.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	guildID, ok := parseGuildID(s, i)
+	if !ok {
 		return
 	}
 
-	data := i.ApplicationCommandData()
-	optMap := make(map[string]*discordgo.ApplicationCommandInteractionDataOption, len(data.Options[0].Options))
-	for _, opt := range data.Options[0].Options {
-		optMap[opt.Name] = opt
-	}
+	optMap := subcommandOptionMap(i)
 
 	levelOpt, ok := optMap["level"]
 	if !ok {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Missing level option.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Missing level option.")
 		return
 	}
 	roleOpt, ok := optMap["role"]
 	if !ok {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Missing role option.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Missing role option.")
 		return
 	}
 
 	level := int(levelOpt.IntValue())
 	role := roleOpt.RoleValue(s, i.GuildID)
 	if role == nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid role.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Invalid role.")
 		return
 	}
 
 	roleID, err := strconv.ParseInt(role.ID, 10, 64)
 	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Invalid role ID.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Invalid role ID.")
 		return
 	}
 
 	ctx := context.Background()
 	if err := services.Global.LevelSettings.SetRoleRewardForLevel(ctx, guildID, level, roleID); err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Failed to set reward.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Failed to set reward.")
 		return
 	}
 
-	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-		Type: discordgo.InteractionResponseChannelMessageWithSource,
-		Data: &discordgo.InteractionResponseData{
-			Content: "Reward set: level " + strconv.Itoa(level) + " -> " + role.Mention(),
-			Flags:   discordgo.MessageFlagsEphemeral,
-		},
-	})
+	respondEphemeral(s, i, "Reward set: level "+strconv.Itoa(level)+" -> "+role.Mention())
 }