add "не начат" tag to tags preset

client/discord/discord.go

@@ -20,9 +20,7 @@ var (
 	projectRepo string = "project_repo"
 	buildRepo   string = "build_repo"
 	nameOption  string = "repo_name"
-)
+	tagsPreset         = [3]discordgo.ForumTag{
-
-var tags = []discordgo.ForumTag{
 		{
 			Name:      "В работе",
 			Moderated: true,
@@ -33,9 +31,13 @@ var tags = []discordgo.ForumTag{
 			Moderated: true,
 			EmojiName: "✅",
 		},
+		{
+			Name:      "Не начат",
+			Moderated: true,
+			EmojiName: "🚧",
+		},
 	}
-
+	commands = []discordgo.ApplicationCommand{
-var commands = []discordgo.ApplicationCommand{
 		{
 			Name:        "ping",
 			Description: "pongs in a reply",
@@ -113,6 +115,7 @@ var commands = []discordgo.ApplicationCommand{
 			},
 		},
 	}
+)
 
 func initBotWith(token string) *discordgo.Session {
 	discord, err := discordgo.New("Bot " + token)
@@ -128,87 +131,122 @@ type DiscordOptions struct {
 	Controller *controller.WorkflowController
 }
 
-func Run(conf domain.Config, opts DiscordOptions) error {
+// Моментальный ответ для избежания столкновения с протуханием токена
+func initialResponse(s *discordgo.Session, i *discordgo.InteractionCreate) {
 
-	s := initBotWith(conf.Discord.Token)
+	initialResponse := discordgo.InteractionResponse{
-
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
-	h := discord_handler.New(
+		Data: &discordgo.InteractionResponseData{
-		opts.Controller,
+			Flags:   discordgo.MessageFlagsEphemeral,
-		&conf.Discord,
+			Content: "👩‍🍳 Cooking your query..",
-		services.NewDummyClient(conf.Telegram),
+		},
-		tags,
-	)
-
-	commandHandlers := map[string]func(s *discordgo.Session, i *discordgo.InteractionCreate){}
-
-	for _, cmd := range commands {
-		var f func(s *discordgo.Session, i *discordgo.InteractionCreate)
-
-		switch cmd.Name {
-		case "ping":
-			f = h.Ping
-		case "project":
-			f = h.CreateTicket
-		case "info":
-			f = h.ProjectInfo
-		case "repo":
-			f = h.CreateGit
-		case "folder":
-			f = h.CreateFolder
-		case "init_project":
-			f = h.InitChannelAsProject
-		}
-		commandHandlers[cmd.Name] = f
 	}
 
-	componentsHandlers := map[string]func(s *discordgo.Session, i *discordgo.InteractionCreate){
+	s.InteractionRespond(i.Interaction, &initialResponse)
-		"task_start": h.HandleTaskButtons,
-		"task_close": h.HandleTaskButtons,
 }
 
-	s.AddHandler(h.ListenPosts)
+// Определяем канал и реджектим запрос, если пишут в лс:
+func isRejected(s *discordgo.Session, i *discordgo.InteractionCreate) bool {
 
-	s.AddHandler(func(s *discordgo.Session, i *discordgo.InteractionCreate) {
+	dchan, err := s.Channel(i.ChannelID)
-		h.AllInteractions(s, i)
+	if err != nil {
+		return true
+	}
 
+	if dchan.Type == discordgo.ChannelTypeDM {
+		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+			Type: discordgo.InteractionResponseChannelMessageWithSource,
+			Data: &discordgo.InteractionResponseData{
+				Content: "Yo, fella! I'm not working in private!",
+			},
+		})
+		return true
+	}
+	return false
+}
+
+func route(s *discordgo.Session, i *discordgo.InteractionCreate, h discord_handler.Handler) {
+	initialResponse(s, i)
+
+	if isRejected(s, i) {
+		return
+	}
+
+	// Определяем тип взаимодействия и хэндлим правильной функцией:
 	switch i.Type {
 	case discordgo.InteractionApplicationCommand:
-			if h, ok := commandHandlers[i.ApplicationCommandData().Name]; ok {
+		cmd := i.ApplicationCommandData().Name
-				h(s, i)
+
+		switch cmd {
+		case "ping":
+			h.Ping(s, i)
+		case "project":
+			h.CreateProject(s, i)
+		case "info":
+			h.ProjectInfo(s, i)
+		case "repo":
+			h.CreateGit(s, i)
+		case "folder":
+			h.CreateFolder(s, i)
+		case "init_project":
+			h.InitChannelAsProject(s, i)
 		}
 	case discordgo.InteractionMessageComponent:
-			if h, ok := componentsHandlers[i.MessageComponentData().CustomID]; ok {
+		c := i.MessageComponentData().CustomID
-				h(s, i)
+		switch c {
+		case "task_start":
+			h.HandleTaskButtons(s, i)
+		case "task_close":
+			h.HandleTaskButtons(s, i)
 		}
 	}
-	})
-
-	if err := s.Open(); err != nil {
-		return fmt.Errorf("cannot open the session: %v", err)
 }
 
-	// UPDATE FORUM IF NEEDED:
+func updateForum(conf *domain.Config, s *discordgo.Session) ([]discordgo.ForumTag, error) {
 
+	log.Println("Updating forum chan...")
+
+	// Get tasks channel instance:
 	forum, err := s.Channel(conf.Discord.IsTaskForum)
 	if err != nil {
-		log.Print(err)
+		return nil, err
+	}
+
+	// Map all pre-set tags
+	var tagsMap = map[string]discordgo.ForumTag{}
+	for _, t := range forum.AvailableTags {
+		tagsMap[t.Name] = t
+	}
+
+	// Result tags array
+	tags := forum.AvailableTags
+
+	// Check if preset tag exists into current channel
+	for i := 0; i < len(tagsPreset); i++ {
+		_, ok := tagsMap[tagsPreset[i].Name]
+		if !ok {
+			tags = append(tags, tagsPreset[i])
+		}
 	}
 
 	dchan, err := s.ChannelEditComplex(forum.ID, &discordgo.ChannelEdit{
 		AvailableTags: &tags,
 	})
 	if err != nil {
-		log.Fatal(err)
+		return nil, err
 	}
 
 	log.Printf("Channel %s with ID %s propagated by tags:", dchan.Name, dchan.ID)
 	for _, t := range dchan.AvailableTags {
-		log.Printf("N: %s, ID: %s", t.Name, t.ID)
+		fmt.Printf("N: %s, ID: %s", t.Name, t.ID)
 	}
 
+	return dchan.AvailableTags, nil
+}
+
+func commandRegistration(s *discordgo.Session, commands []discordgo.ApplicationCommand) []*discordgo.ApplicationCommand {
 	log.Println("Adding commands...")
 	var cmds []*discordgo.ApplicationCommand
-
 	for _, cmd := range commands {
 		cmd, err := s.ApplicationCommandCreate(s.State.User.ID, "", &cmd)
 		if err != nil {
@@ -217,7 +255,48 @@ func Run(conf domain.Config, opts DiscordOptions) error {
 		cmds = append(cmds, cmd)
 		log.Println(cmd.Name + " command added")
 	}
+	return cmds
+}
 
+func Run(conf *domain.Config, opts DiscordOptions) error {
+
+	// bot init
+	s := initBotWith(conf.Discord.Token)
+
+	// Init new handler
+	h := discord_handler.New(
+		opts.Controller,
+		&conf.Discord,
+		services.NewDummyClient(conf.Telegram),
+	)
+
+	// Add posts listener
+	s.AddHandler(h.ListenPosts)
+
+	// Add interactions handlers
+	s.AddHandler(func(s *discordgo.Session, i *discordgo.InteractionCreate) {
+
+		route(s, i, *h)
+	})
+
+	// session opening
+	if err := s.Open(); err != nil {
+		return fmt.Errorf("cannot open the session: %v", err)
+	}
+
+	// Forum update
+	tags, err := updateForum(conf, s)
+	if err != nil {
+		log.Println(err.Error())
+	}
+
+	//Update handler with tags:
+	h.SetAvailableTags(tags)
+
+	// commands registration
+	cmds := commandRegistration(s, commands)
+
+	// gracefull shutdown
 	defer s.Close()
 	stop := make(chan os.Signal, 1)
 	signal.Notify(stop, os.Interrupt)