feat: Add slash command support & Add dataLength command

commands/dataLength.go

@@ -0,0 +1,205 @@
+package commands
+
+import (
+	"context"
+	"log"
+	"strconv"
+
+	"git.wh64.net/muffin/goMuffin/databases"
+	"git.wh64.net/muffin/goMuffin/utils"
+	"github.com/bwmarrin/discordgo"
+	"go.mongodb.org/mongo-driver/v2/bson"
+)
+
+type chStruct struct {
+	name   lenType
+	length int
+}
+
+type lenType int
+
+const (
+	text lenType = iota
+	muffin
+	nsfw
+	learn
+	userLearn
+)
+
+var DataLengthCommand Command = Command{
+	ApplicationCommand: &discordgo.ApplicationCommand{
+		Type:        discordgo.ChatApplicationCommand,
+		Name:        "데이터학습량",
+		Description: "봇이 학습한 데ㅇ이터량을 보여줘요.",
+	},
+	Aliases: []string{"학습데이터량", "데이터량", "학습량"},
+	DetailedDescription: DetailedDescription{
+		Usage: "머핀아 학습데이터량",
+	},
+}
+
+func (c *Command) dataLengthRun(s *discordgo.Session, m interface{}) {
+	var i *discordgo.Interaction
+	var referance *discordgo.MessageReference
+	var username, userId, channelId string
+	var textLength,
+		muffinLength,
+		nsfwLength,
+		learnLength,
+		userLearnLength int
+
+	ch := make(chan chStruct)
+
+	switch m := m.(type) {
+	case *discordgo.MessageCreate:
+		username = m.Author.Username
+		userId = m.Author.ID
+		channelId = m.ChannelID
+		referance = m.Reference()
+	case *discordgo.InteractionCreate:
+		username = m.Member.User.Username
+		userId = m.Member.User.ID
+		channelId = m.ChannelID
+		i = m.Interaction
+		s.InteractionRespond(i,
+			&discordgo.InteractionResponse{
+				Type: discordgo.InteractionResponseDeferredChannelMessageWithSource,
+				Data: &discordgo.InteractionResponseData{
+					Flags: discordgo.MessageFlagsEphemeral,
+				},
+			})
+	}
+
+	go func() {
+		var datas []databases.Text
+
+		cur, err := databases.Texts.Find(context.TODO(), bson.D{{}})
+		if err != nil {
+			log.Fatalln(err)
+		}
+		cur.All(context.TODO(), &datas)
+		ch <- chStruct{name: text, length: len(datas)}
+
+	}()
+
+	go func() {
+		var datas []databases.Text
+
+		cur, err := databases.Texts.Find(context.TODO(), bson.D{{Key: "persona", Value: "muffin"}})
+		if err != nil {
+			log.Fatalln(err)
+		}
+		cur.All(context.TODO(), &datas)
+		ch <- chStruct{name: muffin, length: len(datas)}
+	}()
+
+	go func() {
+		var datas []databases.Text
+
+		cur, err := databases.Texts.Find(context.TODO(), bson.D{
+			{
+				Key: "persona",
+				Value: bson.M{
+					"$regex": "^user",
+				},
+			},
+		})
+		if err != nil {
+			log.Fatalln(err)
+		}
+		cur.All(context.TODO(), &datas)
+		ch <- chStruct{name: nsfw, length: len(datas)}
+	}()
+
+	go func() {
+		var datas []databases.Learn
+
+		cur, err := databases.Learns.Find(context.TODO(), bson.D{{}})
+		if err != nil {
+			log.Fatalln(err)
+		}
+		cur.All(context.TODO(), &datas)
+		ch <- chStruct{name: learn, length: len(datas)}
+	}()
+
+	go func() {
+		var datas []databases.Learn
+
+		cur, err := databases.Learns.Find(context.TODO(), bson.D{{Key: "user_id", Value: userId}})
+		if err != nil {
+			log.Fatalln(err)
+		}
+
+		cur.All(context.TODO(), &datas)
+		ch <- chStruct{name: userLearn, length: len(datas)}
+	}()
+
+	for i := 0; i < 5; i++ {
+		resp := <-ch
+		switch lenType(resp.name) {
+		case text:
+			textLength = resp.length
+		case muffin:
+			muffinLength = resp.length
+		case nsfw:
+			nsfwLength = resp.length
+		case learn:
+			learnLength = resp.length
+		case userLearn:
+			userLearnLength = resp.length
+		}
+	}
+
+	sum := textLength + learnLength
+
+	// 나중에 djs처럼 Embed 만들어 주는 함수 만들어야겠다
+	// 지금은 임시방편
+	embed := &discordgo.MessageEmbed{
+		Title:       "저장된 데이터량",
+		Description: "총합: " + utils.InlineCode(strconv.Itoa(sum)) + "개",
+		Color:       int(utils.EDefault),
+		Fields: []*discordgo.MessageEmbedField{
+			{
+				Name:   "총 채팅 데이터량",
+				Value:  utils.InlineCode(strconv.Itoa(textLength)) + "개",
+				Inline: true,
+			},
+			{
+				Name:   "총 지식 데이터량",
+				Value:  utils.InlineCode(strconv.Itoa(learnLength)) + "개",
+				Inline: true,
+			},
+			{
+				Name:  "머핀 데이터량",
+				Value: utils.InlineCode(strconv.Itoa(muffinLength)) + "개",
+			},
+			{
+				Name:   "nsfw 데이터량",
+				Value:  utils.InlineCode(strconv.Itoa(nsfwLength)) + "개",
+				Inline: true,
+			},
+			{
+				Name:   username + "님이 가르쳐준 데이터량",
+				Value:  utils.InlineCode(strconv.Itoa(userLearnLength)) + "개",
+				Inline: true,
+			},
+		},
+	}
+
+	switch m.(type) {
+	case *discordgo.MessageCreate:
+		s.ChannelMessageSendEmbedReply(channelId, embed, referance)
+	case *discordgo.InteractionCreate:
+		s.InteractionResponseEdit(i, &discordgo.WebhookEdit{
+			Embeds: &[]*discordgo.MessageEmbed{embed},
+		})
+	}
+}
+
+func (c *Command) dataLengthMessageRun(s *discordgo.Session, m *discordgo.MessageCreate) {
+	c.dataLengthRun(s, m)
+}
+
+func (c *Command) dataLenghChatInputRun(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	c.dataLengthRun(s, i)
+}

commands/discommand.go

@@ -5,6 +5,7 @@ import (
 )
 
 type messageRun func(s *discordgo.Session, m *discordgo.MessageCreate)
+type chatInputRun func(s *discordgo.Session, m *discordgo.InteractionCreate)
 
 type DetailedDescription struct {
 	Usage    string
@@ -12,28 +13,33 @@ type DetailedDescription struct {
 }
 
 type Command struct {
-	Name                string
+	*discordgo.ApplicationCommand
 	Aliases             []string
-	Description         string
 	DetailedDescription DetailedDescription
 }
 
 type DiscommandStruct struct {
-	Commands    map[string]Command
+	Commands      map[string]Command
-	Aliases     map[string]string
+	Aliases       map[string]string
-	messageRuns map[string]interface{}
+	messageRuns   map[string]interface{}
+	chatInputRuns map[string]interface{}
 }
 
 func new() *DiscommandStruct {
 	discommand := DiscommandStruct{
-		Commands:    map[string]Command{},
+		Commands:      map[string]Command{},
-		Aliases:     map[string]string{},
+		Aliases:       map[string]string{},
-		messageRuns: map[string]interface{}{},
+		messageRuns:   map[string]interface{}{},
+		chatInputRuns: map[string]interface{}{},
 	}
 
-	discommand.loadCommands(HelpCommand)
+	go discommand.loadCommands(HelpCommand)
+	go discommand.loadCommands(DataLengthCommand)
 
-	discommand.addMessageRun(HelpCommand.Name, HelpCommand.helpMessageRun)
+	go discommand.addMessageRun(HelpCommand.Name, HelpCommand.helpMessageRun)
+	go discommand.addMessageRun(DataLengthCommand.Name, DataLengthCommand.dataLengthMessageRun)
+
+	go discommand.addChatInputRun(DataLengthCommand.Name, DataLengthCommand.dataLenghChatInputRun)
 	return &discommand
 }
 
@@ -50,9 +56,17 @@ func (d *DiscommandStruct) addMessageRun(name string, run messageRun) {
 	d.messageRuns[name] = run
 }
 
+func (d *DiscommandStruct) addChatInputRun(name string, run chatInputRun) {
+	d.chatInputRuns[name] = run
+}
+
 func (d *DiscommandStruct) MessageRun(command string, s *discordgo.Session, m *discordgo.MessageCreate) {
 	// 더욱 나아진
 	d.messageRuns[command].(messageRun)(s, m)
 }
 
+func (d *DiscommandStruct) ChatInputRun(command string, s *discordgo.Session, i *discordgo.InteractionCreate) {
+	d.chatInputRuns[command].(chatInputRun)(s, i)
+}
+
 var Discommand *DiscommandStruct = new()

commands/help.go

@@ -7,9 +7,12 @@ import (
 )
 
 var HelpCommand Command = Command{
-	Name:        "도움말",
+	ApplicationCommand: &discordgo.ApplicationCommand{
-	Aliases:     []string{"도움", "명령어", "help"},
+		Type:        discordgo.ChatApplicationCommand,
-	Description: "기본적인 사용ㅂ법이에요.",
+		Name:        "도움말",
+		Description: "기본적인 사용ㅂ법이에요.",
+	},
+	Aliases: []string{"도움", "명령어", "help"},
 	DetailedDescription: DetailedDescription{
 		Usage:    "머핀아 도움말 [명령어]",
 		Examples: []string{"머핀아 도움말", "머핀아 도움말 배워"},

configs/config.go

@@ -8,7 +8,7 @@ import (
 	"github.com/joho/godotenv"
 )
 
-var MUFFIN_VERSION = "0.0.0-gopher_canary.250325a"
+var MUFFIN_VERSION = "0.0.0-gopher_canary.250326a"
 
 type botConfig struct {
 	Token  string

handler/interactionCreate.go

@@ -0,0 +1,11 @@
+package handler
+
+import (
+	"git.wh64.net/muffin/goMuffin/commands"
+	"github.com/bwmarrin/discordgo"
+)
+
+func InteractionCreate(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	commands.Discommand.ChatInputRun(i.ApplicationCommandData().Name, s, i)
+	return
+}

main.go

@@ -8,6 +8,7 @@ import (
 	"os/signal"
 	"syscall"
 
+	"git.wh64.net/muffin/goMuffin/commands"
 	"git.wh64.net/muffin/goMuffin/configs"
 	"git.wh64.net/muffin/goMuffin/databases"
 	"git.wh64.net/muffin/goMuffin/handler"
@@ -24,9 +25,14 @@ func main() {
 	}
 
 	dg.AddHandler(handler.MessageCreate)
+	dg.AddHandler(handler.InteractionCreate)
 
 	dg.Open()
 
+	for _, command := range commands.Discommand.Commands {
+		dg.ApplicationCommandCreate(dg.State.User.ID, "", command.ApplicationCommand)
+	}
+
 	defer func() {
 		if err := databases.Client.Disconnect(context.TODO()); err != nil {
 			panic(err)