470 lines
14 KiB
Go
470 lines
14 KiB
Go
package handler
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/db/model"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/handler/iface"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/handler/store"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/handler/util"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/integration"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/locale"
|
|
"github.com/mymmrac/telego"
|
|
tu "github.com/mymmrac/telego/telegoutil"
|
|
"strings"
|
|
)
|
|
|
|
type CallbackQueryHandler struct {
|
|
iface.Base
|
|
}
|
|
|
|
func NewCallbackQueryHandler(app iface.App) Handler {
|
|
return &CallbackQueryHandler{iface.NewBase(app, 0, 0)}
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) Handle(wh telego.Update) error {
|
|
cq := wh.CallbackQuery
|
|
if cq.Message.GetChat().Type == telego.ChatTypePrivate {
|
|
user, err := h.App.DB().ForUser().ByTelegramID(cq.From.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if user != nil && user.ID > 0 {
|
|
return h.handleSetupKey(cq, user)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
var pl util.Payload
|
|
if err := json.Unmarshal([]byte(cq.Data), &pl); err != nil {
|
|
return err
|
|
}
|
|
chat, err := h.App.DB().ForChat().ByTelegramID(pl.Chat)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
user, err := h.App.DB().ForUser().ByID(chat.UserID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
loc := h.Localizer(user.Language)
|
|
switch pl.Action {
|
|
case util.PayloadActionVote:
|
|
poll, found, err := h.findPollByMessage(cq.Message, loc)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !found {
|
|
return nil
|
|
}
|
|
return h.handleVote(cq.From, chat, cq.Message, poll, pl, loc)
|
|
case util.PayloadActionVoteFinish:
|
|
poll, found, err := h.findPollByMessage(cq.Message, loc)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !found {
|
|
return nil
|
|
}
|
|
return h.handleVoteFinish(cq.From, chat, cq.Message, poll, pl, loc)
|
|
case util.PayloadActionVoteSendRedmine:
|
|
poll, found, err := h.findPollByMessage(cq.Message, loc)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !found {
|
|
return nil
|
|
}
|
|
return h.handleVoteSendRedmine(cq.From, chat, cq.Message, poll, pl, loc)
|
|
default:
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) handleVoteFinish(from telego.User, chat *model.Chat,
|
|
msg telego.MaybeInaccessibleMessage, poll store.PollState, pl util.Payload, loc locale.Localizer) error {
|
|
dotOrColon := "."
|
|
if poll.Subject != "" {
|
|
dotOrColon = ": "
|
|
}
|
|
if len(poll.Votes) == 0 {
|
|
store.Polls.Delete(msg.GetMessageID())
|
|
_, err := h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(pl.Chat),
|
|
MessageID: msg.GetMessageID(),
|
|
Text: fmt.Sprintf("%s\n%s\n%s",
|
|
loc.Template("poker_start", map[string]interface{}{
|
|
"Name": poll.Initiator,
|
|
"DotOrColon": dotOrColon,
|
|
"Subject": poll.Subject,
|
|
}),
|
|
loc.Template("poker_ended", map[string]interface{}{"Name": from.Username}),
|
|
loc.Message("poker_ended_no_results"),
|
|
),
|
|
ParseMode: telego.ModeMarkdown,
|
|
})
|
|
h.App.Log().Debugf("finished poll: %#v", poll)
|
|
return err
|
|
}
|
|
|
|
poll.Calculate()
|
|
store.Polls.Set(msg.GetMessageID(), poll)
|
|
_, err := h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(pl.Chat),
|
|
MessageID: msg.GetMessageID(),
|
|
Text: fmt.Sprintf("%s\n%s\n\n%s\n%s\n\n%s",
|
|
loc.Template("poker_start", map[string]interface{}{
|
|
"Name": poll.Initiator,
|
|
"DotOrColon": dotOrColon,
|
|
"Subject": poll.Subject,
|
|
}),
|
|
loc.Template("poker_ended", map[string]interface{}{"Name": from.Username}),
|
|
loc.Message("voted"),
|
|
h.voters(poll.Votes, loc),
|
|
loc.Template("poker_results", poll.Result),
|
|
),
|
|
ParseMode: telego.ModeMarkdown,
|
|
ReplyMarkup: h.getPollAfterEndKeyboard(chat, poll, loc),
|
|
})
|
|
h.App.Log().Debugf("finished poll: %#v", poll)
|
|
return err
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) handleVoteSendRedmine(from telego.User, chat *model.Chat,
|
|
msg telego.MaybeInaccessibleMessage, poll store.PollState, pl util.Payload, loc locale.Localizer) error {
|
|
dotOrColon := "."
|
|
if poll.Subject != "" {
|
|
dotOrColon = ": "
|
|
}
|
|
updateMessage := func(tag string) error {
|
|
_, err := h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(pl.Chat),
|
|
MessageID: msg.GetMessageID(),
|
|
Text: fmt.Sprintf("%s\n%s\n\n%s\n%s\n\n%s\n\n%s",
|
|
loc.Template("poker_start", map[string]interface{}{
|
|
"Name": poll.Initiator,
|
|
"DotOrColon": dotOrColon,
|
|
"Subject": poll.Subject,
|
|
}),
|
|
loc.Template("poker_ended", map[string]interface{}{"Name": from.Username}),
|
|
loc.Message("voted"),
|
|
h.voters(poll.Votes, loc),
|
|
loc.Template("poker_results", poll.Result),
|
|
loc.Message(tag),
|
|
),
|
|
ParseMode: telego.ModeMarkdown,
|
|
})
|
|
return err
|
|
}
|
|
|
|
h.App.Log().Debugf("received vote send for poll: %#v", poll)
|
|
if !poll.CanRedmine || poll.TaskID == 0 {
|
|
store.Polls.Delete(msg.GetMessageID())
|
|
h.App.Log().Errorf("cannot send info to Redmine for %d: CanRedmine: %t", poll.TaskID, poll.CanRedmine)
|
|
return updateMessage("poker_redmine_cannot_send")
|
|
}
|
|
integrationData, err := h.App.DB().ForIntegration().LoadForChatAndType(chat.ID, model.RedmineIntegration)
|
|
if err != nil {
|
|
store.Polls.Delete(msg.GetMessageID())
|
|
h.App.Log().Errorf("cannot send info to Redmine for %d: %s", poll.TaskID, err)
|
|
return updateMessage("poker_redmine_cannot_send")
|
|
}
|
|
|
|
err = integration.New(*integrationData, h.App.Log()).PushVoteResult(poll.TaskID, poll.Result.RoundHalf)
|
|
if err != nil {
|
|
store.Polls.Delete(msg.GetMessageID())
|
|
h.App.Log().Errorf("cannot send info to Redmine for %d: %s", poll.TaskID, err)
|
|
return updateMessage("poker_redmine_cannot_send")
|
|
}
|
|
|
|
return updateMessage("poker_redmine_sent")
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) handleVote(from telego.User, chat *model.Chat,
|
|
msg telego.MaybeInaccessibleMessage, poll store.PollState, pl util.Payload, loc locale.Localizer) error {
|
|
var found bool
|
|
for i, storedVote := range poll.Votes {
|
|
if storedVote.ID == from.ID {
|
|
storedVote.Name = h.pollMemberName(&from)
|
|
storedVote.Vote = pl.Vote().Vote
|
|
poll.Votes[i] = storedVote
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
poll.Votes = append(poll.Votes, store.MemberVote{
|
|
Member: util.Member{
|
|
ID: from.ID,
|
|
Name: h.pollMemberName(&from),
|
|
},
|
|
Vote: pl.Vote().Vote,
|
|
})
|
|
}
|
|
store.Polls.Set(msg.GetMessageID(), poll)
|
|
|
|
h.App.Log().Debugf("processed vote %#v for poll: %#v", pl.Vote(), poll)
|
|
dotOrColon := "."
|
|
if poll.Subject != "" {
|
|
dotOrColon = ": "
|
|
}
|
|
_, err := h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(pl.Chat),
|
|
MessageID: msg.GetMessageID(),
|
|
Text: fmt.Sprintf("%s\n%s\n%s",
|
|
loc.Template("poker_start", map[string]interface{}{
|
|
"Name": poll.Initiator,
|
|
"DotOrColon": dotOrColon,
|
|
"Subject": poll.Subject,
|
|
}),
|
|
loc.Message("voted"),
|
|
h.votersWithoutVotes(poll.Votes, loc),
|
|
),
|
|
ReplyMarkup: h.getPollKeyboard(chat, loc),
|
|
ParseMode: telego.ModeMarkdown,
|
|
})
|
|
return err
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) pollMemberName(user *telego.User) string {
|
|
return fmt.Sprintf("%s (@%s)", strings.TrimRight(user.FirstName+" "+user.LastName, " "), user.Username)
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) voters(votes []store.MemberVote, loc locale.Localizer) string {
|
|
var sb strings.Builder
|
|
sb.Grow(20 * len(votes))
|
|
for _, vote := range votes {
|
|
sb.WriteString(loc.Template("vote_result", map[string]interface{}{
|
|
"Name": vote.Name,
|
|
"Vote": vote.Vote,
|
|
}) + "\n")
|
|
}
|
|
return strings.TrimRight(sb.String(), "\n")
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) votersWithoutVotes(votes []store.MemberVote, loc locale.Localizer) string {
|
|
var sb strings.Builder
|
|
sb.Grow(20 * len(votes))
|
|
for _, vote := range votes {
|
|
sb.WriteString(loc.Template("voter", map[string]interface{}{"Name": vote.Name}) + "\n")
|
|
}
|
|
return strings.TrimRight(sb.String(), "\n")
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) getPollKeyboard(chat *model.Chat, loc locale.Localizer) *telego.InlineKeyboardMarkup {
|
|
switch chat.KeyboardType {
|
|
case model.StandardKeyboard:
|
|
return util.StandardVoteKeyboard(chat.TelegramID, loc)
|
|
case model.StoryPointsKeyboard:
|
|
return util.StoryPointsVoteKeyboard(chat.TelegramID, loc)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) getPollAfterEndKeyboard(chat *model.Chat, poll store.PollState, loc locale.Localizer) *telego.InlineKeyboardMarkup {
|
|
rm, err := h.App.DB().ForIntegration().LoadForChatAndType(chat.ID, model.RedmineIntegration)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
if rm != nil && rm.ID > 0 && poll.CanRedmine && poll.TaskID > 0 {
|
|
return util.SendRedmineKeyboard(chat.TelegramID, poll.Result.RoundHalf, loc)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) findPollByMessage(msg telego.MaybeInaccessibleMessage, loc locale.Localizer) (store.PollState, bool, error) {
|
|
poll, found := store.Polls.Get(msg.GetMessageID())
|
|
if !found {
|
|
_, err := h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(msg.GetChat().ID),
|
|
MessageID: msg.GetMessageID(),
|
|
Text: loc.Message("cannot_find_poll"),
|
|
})
|
|
return store.PollState{}, false, err
|
|
}
|
|
return poll, true, nil
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) handleSetupKey(cq *telego.CallbackQuery, user *model.User) error {
|
|
var pl util.Payload
|
|
if err := json.Unmarshal([]byte(cq.Data), &pl); err != nil {
|
|
return err
|
|
}
|
|
switch pl.Action {
|
|
case util.PayloadActionChooseKeyboard:
|
|
return h.handleChooseKeyboard(pl, cq.Message.GetMessageID(), user)
|
|
case util.PayloadActionYesNo:
|
|
answer := pl.YesNoAnswer()
|
|
switch answer.Type {
|
|
case util.QuestionTypeRedmine:
|
|
return h.handleAnswerRedmine(answer, pl.Chat, cq.Message.GetMessageID(), user)
|
|
case util.QuestionTypeRedmineHours:
|
|
return h.handleAnswerRedmineHours(answer, pl.Chat, cq.Message.GetMessageID(), user)
|
|
case util.QuestionTypeRedmineSendResult:
|
|
return h.handleAnswerRedmineSendResults(answer, cq.Message.GetMessageID(), user)
|
|
}
|
|
default:
|
|
return nil
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) handleChooseKeyboard(pl util.Payload, msgID int, user *model.User) error {
|
|
cr := h.App.DB().ForChat()
|
|
result := pl.KeyboardChoice()
|
|
if pl.User != user.TelegramID {
|
|
return nil
|
|
}
|
|
chat, err := cr.ByTelegramID(pl.Chat)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if chat == nil || chat.ID == 0 {
|
|
return nil
|
|
}
|
|
chat.KeyboardType = model.KeyboardType(result.Type)
|
|
if err := cr.Save(chat); err != nil {
|
|
return err
|
|
}
|
|
|
|
kbTypeName := "standard_vote_keyboard"
|
|
if model.KeyboardType(result.Type) == model.StoryPointsKeyboard {
|
|
kbTypeName = "sp_vote_keyboard"
|
|
}
|
|
loc := h.Localizer(user.Language)
|
|
_, _ = h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(user.ChatID),
|
|
MessageID: msgID,
|
|
Text: loc.Template("chosen_keyboard", map[string]interface{}{"Name": loc.Message(kbTypeName)}),
|
|
})
|
|
_, err = h.App.TG().SendMessage(&telego.SendMessageParams{
|
|
ChatID: tu.ID(user.ChatID),
|
|
Text: loc.Message("ask_for_redmine"),
|
|
ParseMode: telego.ModeMarkdown,
|
|
ReplyMarkup: &telego.InlineKeyboardMarkup{InlineKeyboard: [][]telego.InlineKeyboardButton{
|
|
{
|
|
{
|
|
Text: loc.Message("yes"),
|
|
CallbackData: util.NewRedmineQuestionPayload(user.TelegramID, chat.TelegramID, true).String(),
|
|
},
|
|
{
|
|
Text: loc.Message("no"),
|
|
CallbackData: util.NewRedmineQuestionPayload(user.TelegramID, chat.TelegramID, false).String(),
|
|
},
|
|
},
|
|
}},
|
|
})
|
|
return err
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) handleAnswerRedmine(answer util.Answer, chatID int64, msgID int, user *model.User) error {
|
|
loc := h.Localizer(user.Language)
|
|
if !answer.Result {
|
|
_, _ = h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(user.ChatID),
|
|
MessageID: msgID,
|
|
Text: loc.Message("redmine_will_not_be_configured"),
|
|
})
|
|
return util.SendSetupDone(h.App.TG(), user.ChatID, loc)
|
|
}
|
|
_, err := h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(user.ChatID),
|
|
MessageID: msgID,
|
|
Text: loc.Message("please_send_redmine_url"),
|
|
})
|
|
store.RedmineSetups.Set(user.ChatID, &store.RedmineSetup{Chat: chatID})
|
|
return err
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) handleAnswerRedmineHours(answer util.Answer, chatID int64, msgID int, user *model.User) error {
|
|
loc := h.Localizer(user.Language)
|
|
message := "redmine_hours_will_not_be_configured"
|
|
if answer.Result {
|
|
message = "redmine_hours_will_be_configured"
|
|
}
|
|
|
|
_, _ = h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(user.ChatID),
|
|
MessageID: msgID,
|
|
Text: loc.Message(message),
|
|
})
|
|
|
|
rs, found := store.RedmineSetups.Get(user.ChatID)
|
|
if found {
|
|
rs.SaveHours = answer.Result
|
|
if err := h.updateRedmineIntegration(rs, loc, user); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
_, err := h.App.TG().SendMessage(&telego.SendMessageParams{
|
|
ChatID: tu.ID(user.ChatID),
|
|
Text: loc.Message("should_send_poker_to_redmine"),
|
|
ParseMode: telego.ModeMarkdown,
|
|
ReplyMarkup: &telego.InlineKeyboardMarkup{InlineKeyboard: [][]telego.InlineKeyboardButton{
|
|
{
|
|
{
|
|
Text: loc.Message("yes"),
|
|
CallbackData: util.NewRedmineSendResultQuestionPayload(user.TelegramID, chatID, true).String(),
|
|
},
|
|
{
|
|
Text: loc.Message("no"),
|
|
CallbackData: util.NewRedmineSendResultQuestionPayload(user.TelegramID, chatID, false).String(),
|
|
},
|
|
},
|
|
}},
|
|
})
|
|
|
|
return err
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) handleAnswerRedmineSendResults(answer util.Answer, msgID int, user *model.User) error {
|
|
loc := h.Localizer(user.Language)
|
|
if !answer.Result {
|
|
_, _ = h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(user.ChatID),
|
|
MessageID: msgID,
|
|
Text: loc.Message("redmine_poker_will_not_be_configured"),
|
|
})
|
|
return util.SendSetupDone(h.App.TG(), user.ChatID, loc)
|
|
}
|
|
_, err := h.App.TG().EditMessageText(&telego.EditMessageTextParams{
|
|
ChatID: tu.ID(user.ChatID),
|
|
MessageID: msgID,
|
|
Text: loc.Message("specify_result_field"),
|
|
})
|
|
rs, _ := store.RedmineSetups.Get(user.ChatID)
|
|
rs.WaitingForSPField = true
|
|
return err
|
|
}
|
|
|
|
func (h *CallbackQueryHandler) updateRedmineIntegration(rs *store.RedmineSetup, loc locale.Localizer, user *model.User) error {
|
|
dbChat, err := h.App.DB().ForChat().ByTelegramID(rs.Chat)
|
|
if dbChat == nil || dbChat.ID == 0 {
|
|
_ = util.SendInternalError(h.App.TG(), user.ChatID, loc)
|
|
return err
|
|
}
|
|
savedRedmine, err := h.App.DB().ForIntegration().LoadForChatAndType(dbChat.ID, model.RedmineIntegration)
|
|
if savedRedmine == nil || savedRedmine.ID == 0 {
|
|
_ = util.SendInternalError(h.App.TG(), user.ChatID, loc)
|
|
return err
|
|
}
|
|
var shouldUpdate bool
|
|
savedRS := savedRedmine.LoadRedmine()
|
|
if savedRS.SaveHours != rs.SaveHours {
|
|
savedRS.SaveHours = rs.SaveHours
|
|
shouldUpdate = true
|
|
}
|
|
if savedRS.SPFieldName != rs.SPFieldName {
|
|
savedRS.SPFieldName = rs.SPFieldName
|
|
shouldUpdate = true
|
|
}
|
|
if shouldUpdate {
|
|
savedRedmine.StoreRedmine(savedRS)
|
|
return h.App.DB().ForIntegration().Save(savedRedmine)
|
|
}
|
|
return nil
|
|
}
|