ticket-pimp/client/discord/handler/handle_external_task.go

package handler

import (
	"context"
	"fmt"
	"log"
	"ticket-pimp/internal/domain"

	"github.com/bwmarrin/discordgo"
	"github.com/imroc/req/v3"
)

func (c *client) setFlag(s *discordgo.Session, i *discordgo.InteractionCreate, tag *discordgo.ForumTag) error {

	th, err := s.Channel(i.ChannelID)
	if err != nil {
		return err
	}

	forum, err := s.Channel(th.ParentID)
	if err != nil {
		return err
	}

	// Проверка на существование тега в списке тегов:
	if len(forum.AvailableTags) != 0 {
		for _, some := range forum.AvailableTags {
			if some.Name == tag.Name {
				_, err := s.ChannelEditComplex(i.ChannelID, &discordgo.ChannelEdit{
					AppliedTags: &[]string{some.ID},
				})
				if err != nil {
					return err
				}
			}
		}
	}

	return nil
}

func (c *client) ListenPosts(s *discordgo.Session, th *discordgo.ThreadCreate) {

	// Check if thread starter is not a bot, and thread started at the tasks channel;
	if th.ParentID != c.conf.IsTaskForum || th.OwnerID == s.State.User.ID {
		return
	}

	msgs, _ := s.ChannelMessages(th.ID, 1, "", "", "")

	msg, _ := s.ChannelMessage(th.ID, msgs[0].ID)

	if msg.Author.ID == s.State.User.ID {
		return
	}

	content := th.Name
	content += "\n" + msg.Content

	user, _ := s.GuildMember(th.GuildID, msg.Author.ID)

	t, err := c.controller.WriteTaskToDB(&domain.Task{
		Description: content,
		Creator:     user.User.Mention(),
	})
	if err != nil {
		s.ChannelMessageSend(th.ID, fmt.Sprintf("unable to write task to db, %v", err))
		return
	}

	// [x] -- Отредактировать Thread name как для задачи
	_, err = s.ChannelEditComplex(th.ID, &discordgo.ChannelEdit{
		Name: fmt.Sprintf("Task ID: %d, by %s", t.ID, t.Creator),
	})
	if err != nil {
		log.Printf("th edition is not complete: %v", err)
	}

	// Fix the original task message:
	taskMessage, err := s.ChannelMessageSendComplex(th.ID, &discordgo.MessageSend{
		Content: content,
		Components: []discordgo.MessageComponent{
			discordgo.ActionsRow{
				Components: []discordgo.MessageComponent{
					discordgo.Button{
						Label:    "Start",
						Style:    discordgo.SuccessButton,
						Disabled: false,
						CustomID: "task_start",
					},
					discordgo.Button{
						Label:    "Close",
						Style:    discordgo.DangerButton,
						Disabled: true,
						CustomID: "task_close",
					},
				},
			},
		},
	})
	if err != nil {
		log.Printf("th start message edition is not complete: %v", err)
	}

	err = c.controller.UpdateTasksMessageID(context.TODO(), taskMessage.ID, t.ID)
	if err != nil {
		s.ChannelMessageSend(th.ID, fmt.Sprintf("unable to update task at the db, %v", err))
		return
	}
}

func (c *client) HandleTaskButtons() Component {
	return Component{
		Handler: c.handleTaskButton,
	}
}

func (c *client) handleTaskButton(s *discordgo.Session, i *discordgo.InteractionCreate) {

	// Send an empty interaction response; ----------------------------------------------------------------
	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
		Type: discordgo.InteractionResponseUpdateMessage,
		Data: &discordgo.InteractionResponseData{},
	})

	// Get assignee value; ---------------------------------------------------------------------------------
	user := i.Member.User.Mention()

	var (
		opt                  int              = -1
		doneButtonIsDisabled bool             = false
		state                domain.TaskState = domain.NewTaskState()
		message              string
	)

	// Check what flow was touched: -------------------------------------------------------------------------
	switch i.Interaction.MessageComponentData().CustomID {
	case "task_start":
		opt = 0
		doneButtonIsDisabled = false
		state = domain.InrpogressTaskState()
		message = "взята в работу"
	case "task_close":
		opt = 1
		doneButtonIsDisabled = true
		state = domain.DoneTaskState()
		message = "выполнена"
	}

	// Send the task update to db --------------------------------------------------------------------------
	convertable, err := c.controller.UpdateTask(i.Message.ID, opt, user)
	if err != nil {
		s.ChannelMessageSend(i.ChannelID, fmt.Sprintf("Unable to update task at the db w/ error: %v", err))
		return
	}

	// Map DB's response to domain.Task: -------------------------------------------------------------------
	task := convertable.
		ExtractDomain()

	newContent := task.DiscordMessage(state)

	// Send message to the creator in Telegram: -------------------------------------------------------------

	if task.CreatorLink != "" {
		c.sendTelegramMessageToCreator(
			task.CreatorLink,
			fmt.Sprintf("Task ID: %d %s", task.ID, message))
	}

	// Send a message to the thread about the task was started: ---------------------------------------------
	_, err = s.ChannelMessageSendComplex(i.ChannelID, &discordgo.MessageSend{
		Content: newContent,
	})
	if err != nil {
		log.Printf("error while sending start task message: %v", err)
	}

	// Fix the original task message: ----------------------------------------------------------------------
	_, err = s.ChannelMessageEditComplex(&discordgo.MessageEdit{
		Channel: i.ChannelID,
		ID:      i.Message.ID,
		Components: []discordgo.MessageComponent{
			discordgo.ActionsRow{
				Components: []discordgo.MessageComponent{
					discordgo.Button{
						Label:    "Close",
						Style:    discordgo.DangerButton,
						Disabled: doneButtonIsDisabled,
						CustomID: "task_close",
					},
				},
			},
		},
	})
	if err != nil {
		log.Printf("th start message edition is not complete: %v", err)
	}

	// Устанавливаем тэги статуса на тред ---------------------------------------------------------------------
	err = c.setFlag(s, i, &c.Tags[opt])
	if err != nil {
		log.Printf("error while `start` tag setting: %v", err)
	}
}

type TelegramMessage struct {
	ChatID              string `json:"chat_id"`
	Text                string `json:"text"`
	DisableNotification bool   `json:"disable_notification"`
	ParseMode           string `json:"parse_mode"`
	DisablePreview      bool   `json:"disable_web_page_preview"`
}

func (c *client) sendTelegramMessageToCreator(tgChatID string, text string) {

	http := req.C()
	http.R().
		SetBody(&TelegramMessage{
			ChatID:              tgChatID,
			Text:                text,
			DisableNotification: true,
			ParseMode:           "HTML",
			DisablePreview:      true,
		}).
		Post("https://api.telegram.org/bot" + c.tgConf.Token + "/sendMessage")
	// [HTTP Kit Marlerino]::POST(
	// 	"https://api.telegram.org/bot" + Config.botToken +
	// 	  "/sendMessage",
	// 	"",
	// 	Object(
	// 	  "chat_id",
	// 	  thisRow.[Creator ID].ToText(),
	// 	  "text",
	// 	  Format(
	// 		"<a href='{1}'>{2}</a> взята в работу",
	// 		thisRow.ObjectLink().ToText(),
	// 		"Задача"
	// 	  ),
	// 	  "disable_notification",
	// 	  true,
	// 	  "parse_mode",
	// 	  "HTML",
	// 	  "disable_web_page_preview",
	// 	  true
	// 	)
	//   )

}