refactor(commands): deploy when flag is given

5 files changed, 90 insertions, 89 deletions

diff --git a/commands/deploy.go b/commands/deploy.go
new file mode 100644
index 0000000..4974d50
--- /dev/null
+++ b/commands/deploy.go
@@ -0,0 +1,77 @@
+package commands
+
+import (
+	"context"
+
+	"git.anhgelus.world/anhgelus/les-copaings-bot/common"
+	"github.com/nyttikord/gokord/bot"
+	"github.com/nyttikord/gokord/discord"
+	"github.com/nyttikord/gokord/discord/types"
+	"github.com/nyttikord/gokord/interaction"
+)
+
+var commands []*interaction.Command
+
+func newCmd(name, description string) *interaction.Command {
+	return &interaction.Command{
+		Type:             types.CommandChat,
+		Name:             name,
+		Description:      description,
+		Contexts:         &[]types.InteractionContext{types.InteractionContextGuild},
+		IntegrationTypes: &[]types.IntegrationInstall{types.IntegrationInstallGuild},
+	}
+}
+
+func newOption(tp types.CommandOption, name, description string) *interaction.CommandOption {
+	return &interaction.CommandOption{
+		Type:        tp,
+		Name:        name,
+		Description: description,
+	}
+}
+
+func init() {
+	adm := int64(discord.PermissionManageGuild)
+
+	rank := newCmd("rank", "Affiche le niveau d'un copaing")
+	rank.Options = append(rank.Options, newOption(types.CommandOptionUser, "copaing", "Le niveau du Copaing que vous souhaitez obtenir"))
+
+	cfg := newCmd("config", "Modifie la config")
+	cfg.DefaultMemberPermissions = &adm
+
+	top := newCmd("top", "Copaings les plus actifs")
+
+	reset := newCmd("reset", "Reset l'xp")
+	reset.DefaultMemberPermissions = &adm
+
+	resetUser := newCmd("reset-user", "Reset l'xp d'un utilisation")
+	resetUser.DefaultMemberPermissions = &adm
+	resetUser.Options = append(resetUser.Options, newOption(types.CommandOptionUser, "copaing", "Copaing à reset"))
+
+	credits := newCmd("credits", "Affiche les crédits du bot")
+
+	stats := newCmd("stats", "Affiche des stats :D")
+	stats.Options = append(stats.Options,
+		newOption(types.CommandOptionInteger, "jours", "Nombre de jours à afficher dans le graphique"),
+		newOption(types.CommandOptionUser, "copaing", "Copaing à inspecter"),
+	)
+
+	rolereact := newCmd("rolereact", "Envoie un message permettant de récupérer des rôles grâce à des réactions")
+	rolereact.DefaultMemberPermissions = &adm
+	rolereact.Options = append(rolereact.Options, newOption(types.CommandOptionChannel, "salon", "Salon de destination du message"))
+
+	modify := newCmd("Modifier", "")
+	modify.DefaultMemberPermissions = &adm
+	modify.Type = types.CommandMessage
+
+	commands = []*interaction.Command{rank, cfg, top, reset, resetUser, credits, stats, rolereact, modify}
+}
+
+func Deploy(ctx context.Context, dg bot.Session) error {
+	guildID := ""
+	if common.IsDebug(ctx) {
+		guildID = dg.GuildAPI().State.Guilds()[0]
+	}
+	_, err := dg.InteractionAPI().CommandBulkOverwrite(dg.SessionState().Application().ID, guildID, commands).Do(ctx)
+	return err
+}
diff --git a/commands/reset.go b/commands/reset.go
index d1e04ea..85f8f0d 100644
--- a/commands/reset.go
+++ b/commands/reset.go
@@ -29,7 +29,7 @@ func ResetUser(ctx context.Context, dg bot.Session, i *interaction.ApplicationCo
 		}
 	}()
 	opts := i.OptionMap()
-	v, ok := opts["user"]
+	v, ok := opts["copaing"]
 	if !ok {
 		resp.Message("Le copaing n'a pas été renseigné.")
 		return
diff --git a/commands/stats.go b/commands/stats.go
index e74f3e1..017cfc6 100644
--- a/commands/stats.go
+++ b/commands/stats.go
@@ -62,7 +62,7 @@ func Stats(ctx context.Context, dg bot.Session, i *interaction.ApplicationComman
 	}()
 
 	opts := i.OptionMap()
-	if v, ok := opts["days"]; ok {
+	if v, ok := opts["jours"]; ok {
 		in := v.IntValue()
 		if in < 1 || uint(in) > cfg.DaysXPRemains {
 			msg := fmt.Sprintf("Nombre de jours invalide. Il doit être strictement positif et inférieur à %d", cfg.DaysXPRemains)
@@ -76,7 +76,7 @@ func Stats(ctx context.Context, dg bot.Session, i *interaction.ApplicationComman
 		bot.Logger(ctx).Error("sending deferred", "error", err)
 	}
 	var w io.WriterTo
-	if v, ok := opts["user"]; ok {
+	if v, ok := opts["copaing"]; ok {
 		w, err = statsMember(ctx, dg, i, days, v.UserValue(ctx).ID)
 	} else {
 		w, err = statsAll(ctx, dg, i, days)
diff --git a/events.go b/events.go
index 4e9278d..1d53f11 100644
--- a/events.go
+++ b/events.go
@@ -70,7 +70,7 @@ func genMapKey(guildID string, userID string) string {
 	return fmt.Sprintf("%s:%s", guildID, userID)
 }
 
-func onConnection(ctx context.Context, dg bot.Session, e *event.VoiceStateUpdate) {
+func onConnection(ctx context.Context, _ bot.Session, e *event.VoiceStateUpdate) {
 	bot.Logger(ctx).Debug("user connected", "user", e.Member.DisplayName())
 	connectedSince[genMapKey(e.GuildID, e.UserID)] = time.Now().Unix()
 }
diff --git a/main.go b/main.go
index 3967bc4..179df39 100644
--- a/main.go
+++ b/main.go
@@ -35,7 +35,8 @@ const Version = "3.4.0"
 var (
 	token   string
 	cfgPath string = "config.toml"
-	verbose bool
+	deploy  bool   = false
+	verbose bool   = false
 )
 
 // Cancel timers
@@ -52,6 +53,7 @@ func init() {
 	flag.StringVar(&token, "token", os.Getenv("TOKEN"), "token of the bot")
 	flag.StringVar(&cfgPath, "config", cfgPath, "config's path")
 	flag.BoolVar(&verbose, "v", verbose, "verbose")
+	flag.BoolVar(&deploy, "deploy", deploy, "deploy commands")
 
 	// Use a nicer font
 	fontTTF, err := opentype.Parse(interTTF)
@@ -84,66 +86,11 @@ func main() {
 		panic(err)
 	}
 
-	//adm := int64(discord.PermissionManageGuild)
-
 	ctx := user.SetState(context.Background(), user.NewState(db))
 	ctx = common.SetDB(ctx, db)
 	ctx = common.SetDebug(ctx, cfg.Debug)
 	ctx = common.SetAuthor(ctx, cfg.Author)
 
-	/*rankCmd := cmd.New("rank", "Affiche le niveau d'un copaing").
-		AddOption(cmd.NewOption(
-			types.CommandOptionUser,
-			"copaing",
-			"Le niveau du Copaing que vous souhaitez obtenir",
-		)).
-		SetHandler(commands.Rank(ctx))
-
-	configCmd := cmd.New("config", "Modifie la config").
-		SetPermission(&adm).
-		SetHandler(commands.ConfigCommand)
-
-	topCmd := cmd.New("top", "Copaings les plus actifs").
-		SetHandler(commands.Top(ctx))
-
-	resetCmd := cmd.New("reset", "Reset l'xp").
-		SetHandler(commands.Reset).
-		SetPermission(&adm)
-
-	resetUserCmd := cmd.New("reset-user", "Reset l'xp d'un utilisation").
-		AddOption(cmd.NewOption(
-			types.CommandOptionUser,
-			"user",
-			"Copaing a reset",
-		).IsRequired()).
-		SetHandler(commands.ResetUser(ctx)).
-		SetPermission(&adm)
-
-	creditsCmd := cmd.New("credits", "Crédits").
-		SetHandler(commands.Credits)
-
-	statsCmd := cmd.New("stats", "Affiche des stats :D").
-		AddOption(cmd.NewOption(
-			types.CommandOptionInteger,
-			"days",
-			"Nombre de jours à afficher dans le graphique",
-		)).
-		AddOption(cmd.NewOption(
-			types.CommandOptionUser,
-			"user",
-			"Utilisateur à inspecter",
-		)).
-		SetHandler(commands.Stats(ctx))
-
-	rolereactCmd := cmd.New("rolereact", "Envoie un message permettant de récupérer des rôles grâce à des réactions").
-		SetPermission(&adm).
-		AddOption(cmd.NewOption(
-			types.CommandOptionChannel,
-			"salon",
-			"Destination du message",
-		)).
-		SetHandler(rolereact.HandleCommand)*/
-
 	logLevel := slog.LevelInfo
 	if verbose {
 		logLevel = slog.LevelDebug
@@ -158,35 +105,6 @@ func main() {
 	intrs := dg.InteractionManager()
 	events.AddHandler(ready)
 
-	// related to rolereact
-	// TEMP BECAUSE (OLD) GOKORD DOES NOT SUPPORT COMMAND MESSAGE
-	/*events.AddHandler(func(ctx context.Context, dg bot.Session, e *event.Ready) {
-		guildID := ""
-		logger := bot.Logger(ctx)
-		if common.IsDebug(ctx) {
-			gs, err := dg.GuildAPI().UserGuilds(1, "", "", false).Do(ctx)
-			if err != nil {
-				logger.Error("fetching guilds for debug", "error", err)
-				return
-			} else {
-				guildID = gs[0].ID
-			}
-		}
-
-		handleRolereactionMessageCmd := interaction.Command{
-			Type:                     types.CommandMessage,
-			Name:                     "Modifier",
-			DefaultMemberPermissions: &adm,
-		}
-		c, err := dg.InteractionAPI().
-			CommandCreate(dg.SessionState().User().ID, guildID, &handleRolereactionMessageCmd).
-			Do(ctx)
-		if err != nil {
-			logger.Error("unable to push rolereaction message command", "error", err)
-			return
-		}
-		logger.Debug("pushed rolereaction message command", "CommandID", c.ID)
-	})*/
 	events.AddHandler(func(ct context.Context, dg bot.Session, _ *event.Disconnect) {
 		user.PeriodicSaver(ctx, dg)
 	})
@@ -320,6 +238,12 @@ var statuses = []func(context.Context, bot.Session) error{
 func ready(ctx context.Context, dg bot.Session, _ *event.Ready) {
 	logger := bot.Logger(ctx)
 	logger.Info("bot started", "as", dg.SessionState().User().Username)
+	if deploy || common.IsDebug(ctx) {
+		err := commands.Deploy(ctx, dg)
+		if err != nil {
+			logger.Error("deploying commands", "error", err)
+		}
+	}
 	now := time.Now().Unix()
 	rd := rand.New(rand.NewPCG(uint64(now), uint64(len(statuses))))
 	stopStatus = common.NewTimer(ctx, 30*time.Second, func(ctx context.Context, _ context.CancelFunc) {