usememos/memos
1
1
Fork 0
mirror of https://github.com/usememos/memos.git synced 2025-09-13 01:05:27 +08:00
Code Issues Projects Releases Packages Wiki Activity

feat: set memo visibility in telegram (#1824)

Browse source 
* Add telegram.Bot in MessageHandler

* Change single message handler like group messages

* Move message notify wrapper from plugin to server

* Add keyboard buttons on Telegram reply message

* Add support to telegram CallbackQuery update

* Set visibility in callbackQuery

* Change original reply message after callbackQuery

---------

Co-authored-by: Athurg Feng <athurg@gooth.org>
This commit is contained in:
Athurg Gooth 2023-06-14 22:10:01 +08:00 • committed by GitHub
parent 8f7001cd9f
commit 4d59689126
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 177 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
plugin/telegram/api_answer_callback_query.go Normal file
View file

@ -0,0 +1,21 @@
package telegram
import (
"context"
"net/url"
)
// AnswerCallbackQuery make an answerCallbackQuery api request.
func (b *Bot) AnswerCallbackQuery(ctx context.Context, callbackQueryID, text string) error {
formData := url.Values{
"callback_query_id": {callbackQueryID},
"text": {text},
}
err := b.postForm(ctx, "/answerCallbackQuery", formData, nil)
if err != nil {
return err
}
return nil
}

16
plugin/telegram/api_edit_message.go
View file

@ -2,18 +2,32 @@ package telegram
import (
"context"
"encoding/json"
"fmt"
"net/url"
"strconv"
)
// EditMessage make an editMessageText api request.
func (b *Bot) EditMessage(ctx context.Context, chatID, messageID int, text string) (*Message, error) {
func (b *Bot) EditMessage(ctx context.Context, chatID, messageID int, text string, inlineKeyboards [][]InlineKeyboardButton) (*Message, error) {
formData := url.Values{
"message_id": {strconv.Itoa(messageID)},
"chat_id": {strconv.Itoa(chatID)},
"text": {text},
}
if len(inlineKeyboards) > 0 {
var markup struct {
InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard"`
}
markup.InlineKeyboard = inlineKeyboards
data, err := json.Marshal(markup)
if err != nil {
return nil, fmt.Errorf("fail to encode inlineKeyboard: %s", err)
}
formData.Set("reply_markup", string(data))
}
var result Message
err := b.postForm(ctx, "/editMessageText", formData, &result)
if err != nil {

49
plugin/telegram/bot.go
View file

@ -13,7 +13,8 @@ import (
type Handler interface {
BotToken(ctx context.Context) string
MessageHandle(ctx context.Context, message Message, blobs map[string][]byte) error
MessageHandle(ctx context.Context, bot *Bot, message Message, blobs map[string][]byte) error
CallbackQueryHandle(ctx context.Context, bot *Bot, callbackQuery CallbackQuery) error
}
type Bot struct {
@ -44,37 +45,51 @@ func (b *Bot) Start(ctx context.Context) {
continue
}
singleMessages := make([]Message, 0, len(updates))
groupMessages := make([]Message, 0, len(updates))
for _, update := range updates {
offset = update.UpdateID + 1
if update.Message == nil {
continue
}
message := *update.Message
// skip message other than text or photo
if message.Text == nil && message.Photo == nil {
_, err := b.SendReplyMessage(ctx, message.Chat.ID, message.MessageID, "Only text or photo message be supported")
// handle CallbackQuery update
if update.CallbackQuery != nil {
err := b.handler.CallbackQueryHandle(ctx, b, *update.CallbackQuery)
if err != nil {
log.Error(fmt.Sprintf("fail to telegram.SendReplyMessage for messageID=%d", message.MessageID), zap.Error(err))
log.Error("fail to handle CallbackQuery", zap.Error(err))
}
continue
}
// Group message need do more
if message.MediaGroupID != nil {
groupMessages = append(groupMessages, message)
continue
}
// handle Message update
if update.Message != nil {
message := *update.Message
err = b.handleSingleMessage(ctx, message)
if err != nil {
log.Error(fmt.Sprintf("fail to handleSingleMessage for messageID=%d", message.MessageID), zap.Error(err))
// skip message other than text or photo
if message.Text == nil && message.Photo == nil {
_, err := b.SendReplyMessage(ctx, message.Chat.ID, message.MessageID, "Only text or photo message be supported")
if err != nil {
log.Error(fmt.Sprintf("fail to telegram.SendReplyMessage for messageID=%d", message.MessageID), zap.Error(err))
}
continue
}
// Group message need do more
if message.MediaGroupID != nil {
groupMessages = append(groupMessages, message)
continue
}
singleMessages = append(singleMessages, message)
continue
}
}
err = b.handleSingleMessages(ctx, singleMessages)
if err != nil {
log.Error("fail to handle singleMessage", zap.Error(err))
}
err = b.handleGroupMessages(ctx, groupMessages)
if err != nil {
log.Error("fail to handle plain text message", zap.Error(err))

11
plugin/telegram/callback_query.go Normal file
View file

@ -0,0 +1,11 @@
package telegram
type CallbackQuery struct {
ID string `json:"id"`
From User `json:"from"`
Message *Message `json:"message"`
InlineMessageID string `json:"inline_message_id"`
ChatInstance string `json:"chat_instance"`
Data string `json:"data"`
GameShortName string `json:"game_short_name"`
}

65
plugin/telegram/handle.go
View file

@ -3,50 +3,26 @@ package telegram
import (
"context"
"fmt"
"github.com/usememos/memos/common/log"
"go.uber.org/zap"
)
// notice message send to telegram.
const (
workingMessage = "Working on send your memo..."
successMessage = "Success"
)
// handleSingleMessages handle single messages not belongs to group.
func (b *Bot) handleSingleMessages(ctx context.Context, messages []Message) error {
for _, message := range messages {
var blobs map[string][]byte
// handleSingleMessage handle a message not belongs to group.
func (b *Bot) handleSingleMessage(ctx context.Context, message Message) error {
reply, err := b.SendReplyMessage(ctx, message.Chat.ID, message.MessageID, workingMessage)
if err != nil {
return fmt.Errorf("fail to SendReplyMessage: %s", err)
}
var blobs map[string][]byte
// download blob if need
if len(message.Photo) > 0 {
filepath, blob, err := b.downloadFileID(ctx, message.GetMaxPhotoFileID())
if err != nil {
log.Error("fail to downloadFileID", zap.Error(err))
_, err = b.EditMessage(ctx, message.Chat.ID, reply.MessageID, err.Error())
// download blob if provided
if len(message.Photo) > 0 {
filepath, blob, err := b.downloadFileID(ctx, message.GetMaxPhotoFileID())
if err != nil {
return fmt.Errorf("fail to EditMessage: %s", err)
return err
}
return fmt.Errorf("fail to downloadFileID: %s", err)
blobs = map[string][]byte{filepath: blob}
}
blobs = map[string][]byte{filepath: blob}
}
err = b.handler.MessageHandle(ctx, message, blobs)
if err != nil {
if _, err := b.EditMessage(ctx, message.Chat.ID, reply.MessageID, err.Error()); err != nil {
return fmt.Errorf("fail to EditMessage: %s", err)
err := b.handler.MessageHandle(ctx, b, message, blobs)
if err != nil {
return err
}
return fmt.Errorf("fail to MessageHandle: %s", err)
}
if _, err := b.EditMessage(ctx, message.Chat.ID, reply.MessageID, successMessage); err != nil {
return fmt.Errorf("fail to EditMessage: %s", err)
}
return nil
@ -80,23 +56,12 @@ func (b *Bot) handleGroupMessages(ctx context.Context, groupMessages []Message)
// Handle each group message
for groupID, message := range messages {
reply, err := b.SendReplyMessage(ctx, message.Chat.ID, message.MessageID, workingMessage)
if err != nil {
return fmt.Errorf("fail to SendReplyMessage: %s", err)
}
// replace Caption with all Caption in the group
caption := captions[groupID]
message.Caption = &caption
if err := b.handler.MessageHandle(ctx, message, blobs[groupID]); err != nil {
if _, err = b.EditMessage(ctx, message.Chat.ID, reply.MessageID, err.Error()); err != nil {
return fmt.Errorf("fail to EditMessage: %s", err)
}
return fmt.Errorf("fail to MessageHandle: %s", err)
}
if _, err := b.EditMessage(ctx, message.Chat.ID, reply.MessageID, successMessage); err != nil {
return fmt.Errorf("fail to EditMessage: %s", err)
err := b.handler.MessageHandle(ctx, b, message, blobs[groupID])
if err != nil {
return err
}
}

6
plugin/telegram/inline_keyboard_button.go Normal file
View file

@ -0,0 +1,6 @@
package telegram
type InlineKeyboardButton struct {
Text string `json:"text"`
CallbackData string `json:"callback_data"`
}

5
plugin/telegram/update.go
View file

@ -1,6 +1,7 @@
package telegram
type Update struct {
UpdateID int `json:"update_id"`
Message *Message `json:"message"`
UpdateID int `json:"update_id"`
Message *Message `json:"message"`
CallbackQuery *CallbackQuery `json:"callback_query"`
}

83
server/telegram.go
View file

@ -25,13 +25,24 @@ func (t *telegramHandler) BotToken(ctx context.Context) string {
return t.store.GetSystemSettingValueOrDefault(&ctx, api.SystemSettingTelegramBotTokenName, "")
}
func (t *telegramHandler) MessageHandle(ctx context.Context, message telegram.Message, blobs map[string][]byte) error {
const (
workingMessage = "Working on send your memo..."
successMessage = "Success"
)
func (t *telegramHandler) MessageHandle(ctx context.Context, bot *telegram.Bot, message telegram.Message, blobs map[string][]byte) error {
reply, err := bot.SendReplyMessage(ctx, message.Chat.ID, message.MessageID, workingMessage)
if err != nil {
return fmt.Errorf("fail to SendReplyMessage: %s", err)
}
var creatorID int
userSettingList, err := t.store.FindUserSettingList(ctx, &api.UserSettingFind{
Key: api.UserSettingTelegramUserIDKey,
})
if err != nil {
return fmt.Errorf("Fail to find memo user: %s", err)
_, err := bot.EditMessage(ctx, message.Chat.ID, reply.MessageID, fmt.Sprintf("Fail to find memo user: %s", err), nil)
return err
}
for _, userSetting := range userSettingList {
var value string
@ -45,7 +56,8 @@ func (t *telegramHandler) MessageHandle(ctx context.Context, message telegram.Me
}
if creatorID == 0 {
return fmt.Errorf("Please set your telegram userid %d in UserSetting of Memos", message.From.ID)
_, err := bot.EditMessage(ctx, message.Chat.ID, reply.MessageID, fmt.Sprintf("Please set your telegram userid %d in UserSetting of Memos", message.From.ID), nil)
return err
}
// create memo
@ -63,11 +75,13 @@ func (t *telegramHandler) MessageHandle(ctx context.Context, message telegram.Me
memoMessage, err := t.store.CreateMemo(ctx, convertCreateMemoRequestToMemoMessage(&memoCreate))
if err != nil {
return fmt.Errorf("failed to CreateMemo: %s", err)
_, err := bot.EditMessage(ctx, message.Chat.ID, reply.MessageID, fmt.Sprintf("failed to CreateMemo: %s", err), nil)
return err
}
if err := createMemoCreateActivity(ctx, t.store, memoMessage); err != nil {
return fmt.Errorf("failed to createMemoCreateActivity: %s", err)
_, err := bot.EditMessage(ctx, message.Chat.ID, reply.MessageID, fmt.Sprintf("failed to createMemoCreateActivity: %s", err), nil)
return err
}
// create resources
@ -90,10 +104,12 @@ func (t *telegramHandler) MessageHandle(ctx context.Context, message telegram.Me
}
resource, err := t.store.CreateResource(ctx, &resourceCreate)
if err != nil {
return fmt.Errorf("failed to CreateResource: %s", err)
_, err := bot.EditMessage(ctx, message.Chat.ID, reply.MessageID, fmt.Sprintf("failed to CreateResource: %s", err), nil)
return err
}
if err := createResourceCreateActivity(ctx, t.store, resource); err != nil {
return fmt.Errorf("failed to createResourceCreateActivity: %s", err)
_, err := bot.EditMessage(ctx, message.Chat.ID, reply.MessageID, fmt.Sprintf("failed to createResourceCreateActivity: %s", err), nil)
return err
}
_, err = t.store.UpsertMemoResource(ctx, &api.MemoResourceUpsert{
@ -101,8 +117,57 @@ func (t *telegramHandler) MessageHandle(ctx context.Context, message telegram.Me
ResourceID: resource.ID,
})
if err != nil {
return fmt.Errorf("failed to UpsertMemoResource: %s", err)
_, err := bot.EditMessage(ctx, message.Chat.ID, reply.MessageID, fmt.Sprintf("failed to UpsertMemoResource: %s", err), nil)
return err
}
}
return nil
keyboard := generateKeyboardForMemoID(memoMessage.ID)
_, err = bot.EditMessage(ctx, message.Chat.ID, reply.MessageID, fmt.Sprintf("Saved as %s Memo %d", memoMessage.Visibility, memoMessage.ID), keyboard)
return err
}
func (t *telegramHandler) CallbackQueryHandle(ctx context.Context, bot *telegram.Bot, callbackQuery telegram.CallbackQuery) error {
var memoID int
var visibility store.Visibility
n, err := fmt.Sscanf(callbackQuery.Data, "%s %d", &visibility, &memoID)
if err != nil || n != 2 {
return bot.AnswerCallbackQuery(ctx, callbackQuery.ID, fmt.Sprintf("fail to parse callbackQuery.Data %s", callbackQuery.Data))
}
update := store.UpdateMemoMessage{
ID: memoID,
Visibility: &visibility,
}
err = t.store.UpdateMemo(ctx, &update)
if err != nil {
return bot.AnswerCallbackQuery(ctx, callbackQuery.ID, fmt.Sprintf("fail to call UpdateMemo %s", err))
}
keyboard := generateKeyboardForMemoID(memoID)
_, err = bot.EditMessage(ctx, callbackQuery.Message.Chat.ID, callbackQuery.Message.MessageID, fmt.Sprintf("Saved as %s Memo %d", visibility, memoID), keyboard)
if err != nil {
return bot.AnswerCallbackQuery(ctx, callbackQuery.ID, fmt.Sprintf("fail to EditMessage %s", err))
}
return bot.AnswerCallbackQuery(ctx, callbackQuery.ID, fmt.Sprintf("Success change Memo %d to %s", memoID, visibility))
}
func generateKeyboardForMemoID(id int) [][]telegram.InlineKeyboardButton {
allVisibility := []store.Visibility{
store.Public,
store.Protected,
store.Private,
}
buttons := make([]telegram.InlineKeyboardButton, 0, len(allVisibility))
for _, v := range allVisibility {
button := telegram.InlineKeyboardButton{
Text: v.String(),
CallbackData: fmt.Sprintf("%s %d", v, id),
}
buttons = append(buttons, button)
}
return [][]telegram.InlineKeyboardButton{buttons}
}