finished farm tasks; added new post listener;

This commit is contained in:
naudachu 2023-11-17 13:47:21 +05:00
parent c0e7a3918a
commit 972e6564ea
1 changed files with 143 additions and 89 deletions

View File

@ -1,12 +1,15 @@
package handler package handler
import ( import (
"context"
"fmt"
"log" "log"
"ticket-pimp/internal/domain"
"github.com/bwmarrin/discordgo" "github.com/bwmarrin/discordgo"
) )
func (h *router) setFlag(s *discordgo.Session, i *discordgo.InteractionCreate, tag *discordgo.ForumTag) error { func (c *client) setFlag(s *discordgo.Session, i *discordgo.InteractionCreate, tag *discordgo.ForumTag) error {
th, err := s.Channel(i.ChannelID) th, err := s.Channel(i.ChannelID)
if err != nil { if err != nil {
@ -22,11 +25,12 @@ func (h *router) setFlag(s *discordgo.Session, i *discordgo.InteractionCreate, t
if len(forum.AvailableTags) != 0 { if len(forum.AvailableTags) != 0 {
for _, some := range forum.AvailableTags { for _, some := range forum.AvailableTags {
if some.Name == tag.Name { if some.Name == tag.Name {
log.Print(tag.Name) _, err := s.ChannelEditComplex(i.ChannelID, &discordgo.ChannelEdit{
thE, err := s.ChannelEditComplex(i.ChannelID, &discordgo.ChannelEdit{
AppliedTags: &[]string{some.ID}, AppliedTags: &[]string{some.ID},
}) })
_, _ = thE, err if err != nil {
return err
}
} }
} }
} }
@ -34,105 +38,155 @@ func (h *router) setFlag(s *discordgo.Session, i *discordgo.InteractionCreate, t
return nil return nil
} }
func (h *router) CreateExternalTask() CommandRoute { func (c *client) ListenPosts(s *discordgo.Session, th *discordgo.ThreadCreate) {
return CommandRoute{
Command: discordgo.ApplicationCommand{ // Check if thread starter is not a bot, and thread started at the tasks channel;
Name: "test", if th.ParentID != c.conf.IsTaskForum || th.OwnerID == s.State.User.ID {
Description: "Buttons test", return
},
Handler: func(s *discordgo.Session, i *discordgo.InteractionCreate) {
// Моментальный ответ для избежания столкновения с протуханием токена
initialResponse := discordgo.InteractionResponse{
Type: discordgo.InteractionResponseChannelMessageWithSource,
Data: &discordgo.InteractionResponseData{
Flags: discordgo.MessageFlagsEphemeral,
Content: "👩‍🍳 Cooking your query..",
},
}
s.InteractionRespond(i.Interaction, &initialResponse)
// go func() {
// h.controller.InitTask("something like a default description")
// }()
},
} }
}
func (h *router) StartTask() ComponentRoute { msgs, _ := s.ChannelMessages(th.ID, 1, "", "", "")
return ComponentRoute{
Handler: func(s *discordgo.Session, i *discordgo.InteractionCreate) {
user := i.Member.User.Mention() msg, _ := s.ChannelMessage(th.ID, msgs[0].ID)
convertable, err := h.controller.UpdateTask(i.Message.ID, 0, user) if msg.Author.ID == s.State.User.ID {
if err != nil { return
}
} content := th.Name
content += "\n" + msg.Content
newContent := convertable.ExtractDomain().StartedMessage() user, _ := s.GuildMember(th.GuildID, msg.Author.ID)
if err != nil {
newContent += "\n `In progress` action produced with error:" + err.Error()
}
newMsg := discordgo.MessageEdit{ t, err := c.controller.WriteTaskToDB(&domain.Task{
Content: &newContent, Description: content,
Channel: i.ChannelID, Creator: user.User.Mention(),
ID: i.Message.ID, })
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{ Components: []discordgo.MessageComponent{
discordgo.ActionsRow{ discordgo.Button{
Components: []discordgo.MessageComponent{ Label: "Start",
discordgo.Button{ Style: discordgo.SuccessButton,
Label: "Close", Disabled: false,
Style: discordgo.DangerButton, CustomID: "task_start",
Disabled: false, },
CustomID: "task_close", discordgo.Button{
}, Label: "Close",
}, Style: discordgo.DangerButton,
Disabled: true,
CustomID: "task_close",
}, },
}, },
} },
h.setFlag(s, i, &h.Tags[0])
_, err = s.ChannelMessageEditComplex(&newMsg)
if err != nil {
log.Println("edition NOT complete, ", err)
}
}, },
})
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 (h *router) CloseTask() ComponentRoute { func (c *client) HandleTaskButtons() Component {
return ComponentRoute{ return Component{
Handler: func(s *discordgo.Session, i *discordgo.InteractionCreate) { Handler: c.handleTaskButton,
}
user := i.Member.User.Mention() }
convertable, err := h.controller.UpdateTask(i.Message.ID, 1, user)
func (c *client) handleTaskButton(s *discordgo.Session, i *discordgo.InteractionCreate) {
newContent := convertable.ExtractDomain().ClosedMessage()
if err != nil { // Send an empty interaction response; ----------------------------------------------------------------
newContent += "\n `Close` action produced with error:" + err.Error() s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
} Type: discordgo.InteractionResponseUpdateMessage,
Data: &discordgo.InteractionResponseData{},
newMsg := discordgo.MessageEdit{ })
Content: &newContent,
Channel: i.ChannelID, // Get assignee value; ---------------------------------------------------------------------------------
ID: i.Message.ID, user := i.Member.User.Mention()
Components: []discordgo.MessageComponent{},
} var (
opt int = -1
msgE, err := s.ChannelMessageEditComplex(&newMsg) doneButtonIsDisabled bool = false
if err != nil { state domain.TaskState = domain.NewTaskState()
log.Println("edition NOT complete, ", err) )
}
// Check what flow was touched: -------------------------------------------------------------------------
_ = msgE switch i.Interaction.MessageComponentData().CustomID {
h.setFlag(s, i, &h.Tags[1]) case "task_start":
opt = 0
}, doneButtonIsDisabled = false
state = domain.InrpogressTaskState()
case "task_close":
opt = 1
doneButtonIsDisabled = true
state = domain.DoneTaskState()
}
// 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: -------------------------------------------------------------------
newContent := convertable.
ExtractDomain().
DiscordMessage(state)
// 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)
} }
} }