feat: leveling system

internal/commands/commands.go

@@ -14,6 +14,7 @@ var AllCommands = []*discordgo.ApplicationCommand{
 	cmdlevel.LevelConfigCommand,
 	cmdlevel.RankCommand,
 	cmdlevel.LeaderboardCommand,
+	cmdlevel.RewardsCommand,
 }
 
 var handlers = map[string]func(s *discordgo.Session, i *discordgo.InteractionCreate){
@@ -22,6 +23,7 @@ var handlers = map[string]func(s *discordgo.Session, i *discordgo.InteractionCre
 	"slvl": cmdlevel.HandleLevelConfig,
 	"rank": cmdlevel.HandleRank,
 	"leaderboard": cmdlevel.HandleLeaderboard,
+	"rewards":     cmdlevel.HandleRewards,
 }
 
 func HandleInteraction(s *discordgo.Session, i *discordgo.InteractionCreate) {

internal/commands/level/helpers.go

@@ -0,0 +1,95 @@
+package level
+
+import (
+	"context"
+	"strconv"
+
+	"velox-bot/internal/db/services"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+func respondEphemeral(s *discordgo.Session, i *discordgo.InteractionCreate, msg string) {
+	_ = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Content: msg,
+			Flags:   discordgo.MessageFlagsEphemeral,
+		},
+	})
+}
+
+func requireGuild(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
+	if i.GuildID == "" {
+		respondEphemeral(s, i, "This command can only be used in a server.")
+		return false
+	}
+	return true
+}
+
+func requireManageGuild(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
+	if i.Member == nil || (i.Member.Permissions&discordgo.PermissionManageGuild) == 0 {
+		respondEphemeral(s, i, "You don't have permission to manage leveling settings.")
+		return false
+	}
+	return true
+}
+
+func requireLevelServices(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
+	if services.Global == nil || services.Global.Level == nil || services.Global.LevelSettings == nil {
+		respondEphemeral(s, i, "Leveling service is not available.")
+		return false
+	}
+	return true
+}
+
+func requireLevelSettingsService(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
+	if services.Global == nil || services.Global.LevelSettings == nil {
+		respondEphemeral(s, i, "Leveling service is not available.")
+		return false
+	}
+	return true
+}
+
+func parseGuildID(s *discordgo.Session, i *discordgo.InteractionCreate) (int64, bool) {
+	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
+	if err != nil {
+		respondEphemeral(s, i, "Invalid guild ID.")
+		return 0, false
+	}
+	return guildID, true
+}
+
+func requireLevelSystemEnabled(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
+	if !requireLevelSettingsService(s, i) {
+		return false
+	}
+	guildID, ok := parseGuildID(s, i)
+	if !ok {
+		return false
+	}
+	enabled, err := services.Global.LevelSettings.IsLevelSystemEnabled(context.Background(), guildID)
+	if err != nil {
+		respondEphemeral(s, i, "Failed to load leveling settings.")
+		return false
+	}
+	if !enabled {
+		respondEphemeral(s, i, "Leveling system is disabled on this server. Use /slvl toggle to enable it.")
+		return false
+	}
+	return true
+}
+
+func subcommandOptionMap(i *discordgo.InteractionCreate) map[string]*discordgo.ApplicationCommandInteractionDataOption {
+	data := i.ApplicationCommandData()
+	if len(data.Options) == 0 {
+		return map[string]*discordgo.ApplicationCommandInteractionDataOption{}
+	}
+	opts := data.Options[0].Options
+	m := make(map[string]*discordgo.ApplicationCommandInteractionDataOption, len(opts))
+	for _, opt := range opts {
+		m[opt.Name] = opt
+	}
+	return m
+}
+

internal/commands/level/level.go

@@ -30,15 +30,18 @@ var LeaderboardCommand = &discordgo.ApplicationCommand{
 	Description: "Top 10 levels in this server",
 }
 
+var RewardsCommand = &discordgo.ApplicationCommand{
+	Name:        "rewards",
+	Description: "View level rewards in this server",
+}
+
 func HandleRank(s *discordgo.Session, i *discordgo.InteractionCreate) {
-	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 !requireLevelServices(s, i) {
+		return
+	}
+
+	if i.GuildID != "" && !requireLevelSystemEnabled(s, i) {
+		respondEphemeral(s, i, "Leveling system is disabled on this server.")
 		return
 	}
 
@@ -58,18 +61,20 @@ func HandleRank(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		return
 	}
 
-	guildID, err := strconv.ParseInt(i.GuildID, 10, 64)
-	if err != nil {
+	guildID, ok := parseGuildID(s, i)
+	if !ok {
 		return
 	}
 	userID, err := strconv.ParseInt(target.ID, 10, 64)
 	if err != nil {
+		respondEphemeral(s, i, "Invalid user ID.")
 		return
 	}
 
 	ctx := context.Background()
 	lvl, err := services.Global.Level.GetLevel(ctx, guildID, userID)
 	if err != nil {
+		respondEphemeral(s, i, "Failed to load level.")
 		return
 	}
 
@@ -84,13 +89,7 @@ func HandleRank(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		Avatar:  avatarURL,
 	})
 	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Failed to render rank card.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Failed to render rank card.")
 		return
 	}
 
@@ -108,61 +107,31 @@ func HandleRank(s *discordgo.Session, i *discordgo.InteractionCreate) {
 }
 
 func HandleLeaderboard(s *discordgo.Session, i *discordgo.InteractionCreate) {
-	if i.GuildID == "" {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "This command can only be used in a server.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+	if !requireGuild(s, i) {
 		return
 	}
 
-	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 !requireLevelServices(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
 	}
 
 	ctx := context.Background()
+	if !requireLevelSystemEnabled(s, i) {
+		return
+	}
 	top, err := services.Global.Level.TopLevels(ctx, guildID, 10)
 	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Failed to load leaderboard.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "Failed to load leaderboard.")
 		return
 	}
 
 	if len(top) == 0 {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "No leaderboard data yet.",
-				Flags:   discordgo.MessageFlagsEphemeral,
-			},
-		})
+		respondEphemeral(s, i, "No leaderboard data yet.")
 		return
 	}
 
@@ -194,3 +163,56 @@ func HandleLeaderboard(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		},
 	})
 }
+
+func HandleRewards(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	if !requireGuild(s, i) {
+		return
+	}
+
+	if !requireLevelSettingsService(s, i) {
+		return
+	}
+
+	guildID, ok := parseGuildID(s, i)
+	if !ok {
+		return
+	}
+
+	ctx := context.Background()
+	if !requireLevelSystemEnabled(s, i) {
+		return
+	}
+	rewards, err := services.Global.LevelSettings.ListRoleRewards(ctx, guildID, 25)
+	if err != nil {
+		respondEphemeral(s, i, "Failed to load rewards.")
+		return
+	}
+
+	if len(rewards) == 0 {
+		respondEphemeral(s, i, "No rewards configured yet.")
+		return
+	}
+
+	fields := make([]*discordgo.MessageEmbedField, 0, len(rewards))
+	for _, r := range rewards {
+		fields = append(fields, &discordgo.MessageEmbedField{
+			Name:   fmt.Sprintf("Level %d", r.Level),
+			Value:  fmt.Sprintf("<@&%d>", r.RoleID),
+			Inline: true,
+		})
+	}
+
+	embed := &discordgo.MessageEmbed{
+		Title:       "Level Rewards",
+		Description: "Roles granted when you reach a level.",
+		Fields:      fields,
+		Color:       0xF59E0B,
+	}
+
+	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Embeds: []*discordgo.MessageEmbed{embed},
+		},
+	})
+}

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())
 }

internal/db/repos/levelrepo/repo.go

@@ -56,9 +56,9 @@ func (r *Repo) UpsertLevel(ctx context.Context, lvl *Level) error {
 func (r *Repo) SetLevel(ctx context.Context, guildID, userID int64, level int) error {
 	const q = `
 		INSERT INTO levels (guild, user_id, level, xp)
-		VALUES ($1, $2, $3, 99)
+		VALUES ($1, $2, $3, 0)
 		ON CONFLICT (guild, user_id)
-		DO UPDATE SET level = EXCLUDED.level, xp = 99
+		DO UPDATE SET level = EXCLUDED.level, xp = 0
 	`
 	_, err := r.db.ExecContext(ctx, q, guildID, userID, level)
 	return err

internal/db/repos/settingsrepo/repo.go

@@ -9,6 +9,12 @@ type Repo struct {
 	db *sql.DB
 }
 
+type LevelReward struct {
+	GuildID int64
+	Level   int
+	RoleID  int64
+}
+
 func NewRepo(db *sql.DB) *Repo {
 	return &Repo{db: db}
 }
@@ -95,6 +101,34 @@ func (r *Repo) SetRoleRewardForLevel(ctx context.Context, guildID int64, level i
 	return err
 }
 
+func (r *Repo) ListRoleRewards(ctx context.Context, guildID int64, limit int) ([]*LevelReward, error) {
+	const q = `
+		SELECT levelreq, role
+		FROM levelrewards
+		WHERE guild_id = $1
+		ORDER BY levelreq ASC
+		LIMIT $2
+	`
+	rows, err := r.db.QueryContext(ctx, q, guildID, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	out := make([]*LevelReward, 0, limit)
+	for rows.Next() {
+		rw := &LevelReward{GuildID: guildID}
+		if err := rows.Scan(&rw.Level, &rw.RoleID); err != nil {
+			return nil, err
+		}
+		out = append(out, rw)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (r *Repo) SetLevelUpChannel(ctx context.Context, guildID int64, channelID int64) error {
 	const q = `
 		INSERT INTO levelup (guild_id, levelup_channel_id)

internal/db/services/levelsettings/service.go

@@ -47,3 +47,11 @@ func (s *Service) GetLevelUpMessage(ctx context.Context, guildID int64) (string,
 func (s *Service) SetRoleRewardForLevel(ctx context.Context, guildID int64, level int, roleID int64) error {
 	return s.settings.SetRoleRewardForLevel(ctx, guildID, level, roleID)
 }
+
+func (s *Service) ListRoleRewards(ctx context.Context, guildID int64, limit int) ([]*settingsrepo.LevelReward, error) {
+	return s.settings.ListRoleRewards(ctx, guildID, limit)
+}
+
+func (s *Service) IsLevelSystemEnabled(ctx context.Context, guildID int64) (bool, error) {
+	return s.settings.IsLevelSystemEnabled(ctx, guildID)
+}

tmp/build-errors.log

@@ -1 +1 @@
-exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1
+exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1exit status 1