469 lines
16 KiB
Go
469 lines
16 KiB
Go
package rpc
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"telesrv/internal/domain"
|
|
)
|
|
|
|
var botAPIAuthKeyID = [8]byte{'B', 'O', 'T', 'A', 'P', 'I', 0, 1}
|
|
|
|
const botAPIChannelChatIDBase int64 = 1000000000000
|
|
|
|
// BotAPISelf returns the authenticated bot as a domain user.
|
|
func (r *Router) BotAPISelf(ctx context.Context, botID int64) (domain.User, error) {
|
|
if r == nil || r.deps.Users == nil || botID == 0 {
|
|
return domain.User{}, errors.New("BOT_INVALID")
|
|
}
|
|
u, found, err := r.deps.Users.ByID(ctx, botID, botID)
|
|
if err != nil {
|
|
return domain.User{}, err
|
|
}
|
|
if !found || !u.Bot {
|
|
return domain.User{}, errors.New("BOT_INVALID")
|
|
}
|
|
return u, nil
|
|
}
|
|
|
|
// BotAPIUpdates returns durable update_id based events projected for the HTTP
|
|
// Bot API. New deployments use the dedicated Bot API queue; the legacy
|
|
// user_update_events fallback is kept for tests that have not wired the queue.
|
|
func (r *Router) BotAPIUpdates(ctx context.Context, botID int64, offset int64) ([]domain.UpdateEvent, error) {
|
|
if r == nil || botID == 0 {
|
|
return nil, nil
|
|
}
|
|
if r.deps.BotAPIUpdates != nil {
|
|
return r.botAPIQueuedUpdates(ctx, botID, offset)
|
|
}
|
|
if r.deps.Updates == nil {
|
|
return nil, nil
|
|
}
|
|
fromPts := 0
|
|
if offset > 0 {
|
|
fromPts = int(offset - 1)
|
|
} else if st, found, err := r.deps.Updates.ConfirmedState(ctx, botAPIAuthKeyID, botID); err != nil {
|
|
return nil, err
|
|
} else if found {
|
|
fromPts = st.Pts
|
|
}
|
|
diff, err := r.deps.Updates.GetDifference(ctx, botAPIAuthKeyID, botID, domain.UpdateState{Pts: fromPts})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(diff.Events) == 0 {
|
|
return nil, nil
|
|
}
|
|
return r.enrichUpdateEvents(ctx, botID, diff.Events), nil
|
|
}
|
|
|
|
// BotAPISendMessage sends a text message as a bot through the normal private
|
|
// or channel message state machine. Positive chat_id is a user private chat;
|
|
// -1000000000000-channel_id is a supergroup/channel chat.
|
|
func (r *Router) BotAPISendMessage(ctx context.Context, botID, chatID int64, text string, entities []domain.MessageEntity, replyMarkup *domain.MessageReplyMarkup, disableWebPagePreview, silent bool, replyToMessageID int) (domain.Message, error) {
|
|
if r == nil || botID == 0 {
|
|
return domain.Message{}, errors.New("BOT_INVALID")
|
|
}
|
|
peer, ok := botAPIPeerFromChatID(chatID)
|
|
if !ok {
|
|
return domain.Message{}, errors.New("CHAT_ID_INVALID")
|
|
}
|
|
if text == "" {
|
|
return domain.Message{}, errors.New("MESSAGE_EMPTY")
|
|
}
|
|
if utf8.RuneCountInString(text) > domain.MaxMessageTextLength {
|
|
return domain.Message{}, errors.New("MESSAGE_TOO_LONG")
|
|
}
|
|
var reply *domain.MessageReply
|
|
if replyToMessageID > 0 {
|
|
reply = &domain.MessageReply{Peer: peer, MessageID: replyToMessageID}
|
|
}
|
|
if peer.Type == domain.PeerTypeChannel {
|
|
return r.botAPISendChannelMessage(ctx, botID, peer.ID, text, entities, nil, replyMarkup, silent, reply)
|
|
}
|
|
if r.deps.Messages == nil {
|
|
return domain.Message{}, errors.New("BOT_INVALID")
|
|
}
|
|
if r.deps.Users != nil && peer.ID != botID {
|
|
if _, found, err := r.deps.Users.ByID(ctx, botID, peer.ID); err != nil {
|
|
return domain.Message{}, err
|
|
} else if !found {
|
|
return domain.Message{}, errors.New("CHAT_ID_INVALID")
|
|
}
|
|
}
|
|
res, err := r.deps.Messages.SendPrivateText(ctx, botID, domain.SendPrivateTextRequest{
|
|
SenderUserID: botID,
|
|
RecipientUserID: peer.ID,
|
|
RandomID: randomNonZeroInt64(),
|
|
Message: text,
|
|
Entities: append([]domain.MessageEntity(nil), entities...),
|
|
Silent: silent,
|
|
ReplyTo: reply,
|
|
Date: int(time.Now().Unix()),
|
|
ReplyMarkup: replyMarkup,
|
|
})
|
|
if err != nil {
|
|
return domain.Message{}, err
|
|
}
|
|
return res.SenderMessage, nil
|
|
}
|
|
|
|
// BotAPISendMedia sends a photo/document message through the same files service
|
|
// and private/channel message state machines used by MTProto sendMedia.
|
|
func (r *Router) BotAPISendMedia(ctx context.Context, botID, chatID int64, kind, locationKey, remoteURL, fileName, mimeType string, fileBytes []byte, caption string, entities []domain.MessageEntity, replyMarkup *domain.MessageReplyMarkup, silent bool, replyToMessageID int) (domain.Message, error) {
|
|
if r == nil || r.deps.Files == nil || botID == 0 {
|
|
return domain.Message{}, errors.New("BOT_INVALID")
|
|
}
|
|
peer, ok := botAPIPeerFromChatID(chatID)
|
|
if !ok {
|
|
return domain.Message{}, errors.New("CHAT_ID_INVALID")
|
|
}
|
|
if utf8.RuneCountInString(caption) > domain.MaxMessageTextLength {
|
|
return domain.Message{}, errors.New("MESSAGE_TOO_LONG")
|
|
}
|
|
media, err := r.botAPIMedia(ctx, botID, kind, locationKey, remoteURL, fileName, mimeType, fileBytes)
|
|
if err != nil {
|
|
return domain.Message{}, err
|
|
}
|
|
var reply *domain.MessageReply
|
|
if replyToMessageID > 0 {
|
|
reply = &domain.MessageReply{Peer: peer, MessageID: replyToMessageID}
|
|
}
|
|
if peer.Type == domain.PeerTypeChannel {
|
|
return r.botAPISendChannelMessage(ctx, botID, peer.ID, caption, entities, media, replyMarkup, silent, reply)
|
|
}
|
|
if r.deps.Messages == nil {
|
|
return domain.Message{}, errors.New("BOT_INVALID")
|
|
}
|
|
if r.deps.Users != nil && peer.ID != botID {
|
|
if _, found, err := r.deps.Users.ByID(ctx, botID, peer.ID); err != nil {
|
|
return domain.Message{}, err
|
|
} else if !found {
|
|
return domain.Message{}, errors.New("CHAT_ID_INVALID")
|
|
}
|
|
}
|
|
res, err := r.deps.Messages.SendPrivateText(ctx, botID, domain.SendPrivateTextRequest{
|
|
SenderUserID: botID,
|
|
RecipientUserID: peer.ID,
|
|
RandomID: randomNonZeroInt64(),
|
|
Message: caption,
|
|
Entities: append([]domain.MessageEntity(nil), entities...),
|
|
Media: media,
|
|
Silent: silent,
|
|
ReplyTo: reply,
|
|
Date: int(time.Now().Unix()),
|
|
ReplyMarkup: replyMarkup,
|
|
})
|
|
if err != nil {
|
|
return domain.Message{}, err
|
|
}
|
|
return res.SenderMessage, nil
|
|
}
|
|
|
|
func botAPIPeerFromChatID(chatID int64) (domain.Peer, bool) {
|
|
switch {
|
|
case chatID > 0:
|
|
return domain.Peer{Type: domain.PeerTypeUser, ID: chatID}, true
|
|
case chatID < -botAPIChannelChatIDBase:
|
|
channelID := -botAPIChannelChatIDBase - chatID
|
|
if channelID > 0 {
|
|
return domain.Peer{Type: domain.PeerTypeChannel, ID: channelID}, true
|
|
}
|
|
}
|
|
return domain.Peer{}, false
|
|
}
|
|
|
|
func (r *Router) botAPISendChannelMessage(ctx context.Context, botID, channelID int64, text string, entities []domain.MessageEntity, media *domain.MessageMedia, replyMarkup *domain.MessageReplyMarkup, silent bool, reply *domain.MessageReply) (domain.Message, error) {
|
|
if r.deps.Channels == nil {
|
|
return domain.Message{}, errors.New("CHAT_ID_INVALID")
|
|
}
|
|
mentionUserIDs := r.mentionUserIDsFromDomain(ctx, botID, text, entities)
|
|
res, err := r.deps.Channels.SendMessage(ctx, botID, domain.SendChannelMessageRequest{
|
|
UserID: botID,
|
|
ChannelID: channelID,
|
|
RandomID: randomNonZeroInt64(),
|
|
Message: text,
|
|
Entities: append([]domain.MessageEntity(nil), entities...),
|
|
Media: media,
|
|
MentionUserIDs: mentionUserIDs,
|
|
SkipRecipientLookup: true,
|
|
PostAuthor: r.channelPostAuthorName(ctx, botID),
|
|
Silent: silent,
|
|
ReplyTo: reply,
|
|
ReplyMarkup: replyMarkup,
|
|
Date: int(time.Now().Unix()),
|
|
})
|
|
if err != nil {
|
|
return domain.Message{}, botAPIChannelSendErr(err)
|
|
}
|
|
if !res.Duplicate {
|
|
r.enqueueChannelMessageFanout(ctx, botID, res, nil)
|
|
r.pushChannelDiscussionUpdate(ctx, botID, res.Discussion)
|
|
r.maybeEnqueueWebPageResolve(botID, domain.Peer{Type: domain.PeerTypeChannel, ID: channelID}, res.Message.ID, res.Message.Media)
|
|
}
|
|
return botAPIMessageFromChannel(botID, res.Message), nil
|
|
}
|
|
|
|
func botAPIMessageFromChannel(botID int64, msg domain.ChannelMessage) domain.Message {
|
|
from := msg.From
|
|
if from.Type == "" && msg.SenderUserID != 0 {
|
|
from = domain.Peer{Type: domain.PeerTypeUser, ID: msg.SenderUserID}
|
|
}
|
|
return domain.Message{
|
|
ID: msg.ID,
|
|
RandomID: msg.RandomID,
|
|
OwnerUserID: botID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeChannel, ID: msg.ChannelID},
|
|
From: from,
|
|
Date: msg.Date,
|
|
EditDate: msg.EditDate,
|
|
Out: msg.SenderUserID == botID,
|
|
Silent: msg.Silent,
|
|
NoForwards: msg.NoForwards,
|
|
Body: msg.Body,
|
|
Entities: append([]domain.MessageEntity(nil), msg.Entities...),
|
|
ReplyTo: msg.ReplyTo,
|
|
Forward: msg.Forward,
|
|
Reactions: msg.Reactions,
|
|
Pts: msg.Pts,
|
|
TTLPeriod: msg.TTLPeriod,
|
|
ExpiresAt: msg.ExpiresAt,
|
|
Media: msg.Media,
|
|
MediaUnread: msg.MediaUnread,
|
|
ViaBotID: msg.ViaBotID,
|
|
GroupedID: msg.GroupedID,
|
|
ReplyMarkup: msg.ReplyMarkup,
|
|
RichMessage: msg.RichMessage,
|
|
Pinned: msg.Pinned,
|
|
}
|
|
}
|
|
|
|
func botAPIChannelSendErr(err error) error {
|
|
switch {
|
|
case errors.Is(err, domain.ErrChannelInvalid),
|
|
errors.Is(err, domain.ErrChannelPrivate),
|
|
errors.Is(err, domain.ErrChannelUserBanned):
|
|
return errors.New("CHAT_ID_INVALID")
|
|
case errors.Is(err, domain.ErrChannelWriteForbidden):
|
|
return errors.New("CHAT_WRITE_FORBIDDEN")
|
|
case errors.Is(err, domain.ErrChannelAdminRequired):
|
|
return errors.New("CHAT_ADMIN_REQUIRED")
|
|
case errors.Is(err, domain.ErrReplyMessageIDInvalid):
|
|
return errors.New("REPLY_MESSAGE_ID_INVALID")
|
|
default:
|
|
return channelInvalidErr(err)
|
|
}
|
|
}
|
|
|
|
func (r *Router) botAPIMedia(ctx context.Context, botID int64, kind, locationKey, remoteURL, fileName, mimeType string, fileBytes []byte) (*domain.MessageMedia, error) {
|
|
switch kind {
|
|
case "photo":
|
|
var photo domain.Photo
|
|
var err error
|
|
switch {
|
|
case len(fileBytes) > 0:
|
|
photo, err = r.deps.Files.CreatePhotoFromBytes(ctx, fileBytes)
|
|
case remoteURL != "":
|
|
photo, err = r.deps.Files.CreatePhotoFromURL(ctx, remoteURL)
|
|
case locationKey != "":
|
|
id, ok := botAPIPhotoID(locationKey)
|
|
if !ok {
|
|
return nil, errors.New("FILE_ID_INVALID")
|
|
}
|
|
var found bool
|
|
photo, found, err = r.deps.Files.GetPhoto(ctx, id)
|
|
if err == nil && !found {
|
|
err = errors.New("FILE_ID_INVALID")
|
|
}
|
|
default:
|
|
err = errors.New("FILE_ID_INVALID")
|
|
}
|
|
if err != nil {
|
|
return nil, botAPIMediaErr(err)
|
|
}
|
|
return &domain.MessageMedia{Kind: domain.MessageMediaKindPhoto, Photo: &photo}, nil
|
|
case "document":
|
|
var doc domain.Document
|
|
var err error
|
|
switch {
|
|
case len(fileBytes) > 0:
|
|
doc, err = r.deps.Files.CreateDocumentFromBytes(ctx, fileBytes, domain.DocumentSpec{
|
|
MimeType: mimeType,
|
|
Attributes: botAPIDocumentAttributes(fileName),
|
|
ForceFile: true,
|
|
})
|
|
case remoteURL != "":
|
|
doc, err = r.deps.Files.CreateDocumentFromURL(ctx, remoteURL)
|
|
case locationKey != "":
|
|
id, ok := botAPIDocumentID(locationKey)
|
|
if !ok {
|
|
return nil, errors.New("FILE_ID_INVALID")
|
|
}
|
|
var found bool
|
|
doc, found, err = r.deps.Files.GetDocument(ctx, id)
|
|
if err == nil && !found {
|
|
err = errors.New("FILE_ID_INVALID")
|
|
}
|
|
default:
|
|
err = errors.New("FILE_ID_INVALID")
|
|
}
|
|
if err != nil {
|
|
return nil, botAPIMediaErr(err)
|
|
}
|
|
return &domain.MessageMedia{Kind: domain.MessageMediaKindDocument, Document: &doc}, nil
|
|
default:
|
|
return nil, errors.New("MEDIA_INVALID")
|
|
}
|
|
}
|
|
|
|
func botAPIPhotoID(locationKey string) (int64, bool) {
|
|
if !strings.HasPrefix(locationKey, "photo:") {
|
|
return 0, false
|
|
}
|
|
rest := strings.TrimPrefix(locationKey, "photo:")
|
|
idText, _, ok := strings.Cut(rest, ":")
|
|
if !ok {
|
|
return 0, false
|
|
}
|
|
id, err := strconv.ParseInt(idText, 10, 64)
|
|
return id, err == nil && id > 0
|
|
}
|
|
|
|
func botAPIDocumentID(locationKey string) (int64, bool) {
|
|
if !strings.HasPrefix(locationKey, "doc:") {
|
|
return 0, false
|
|
}
|
|
rest := strings.TrimPrefix(locationKey, "doc:")
|
|
idText, _, _ := strings.Cut(rest, ":")
|
|
id, err := strconv.ParseInt(idText, 10, 64)
|
|
return id, err == nil && id > 0
|
|
}
|
|
|
|
func botAPIDocumentAttributes(fileName string) []domain.DocumentAttribute {
|
|
fileName = strings.TrimSpace(fileName)
|
|
if fileName == "" {
|
|
return nil
|
|
}
|
|
return []domain.DocumentAttribute{{Kind: domain.DocAttrFilename, FileName: fileName}}
|
|
}
|
|
|
|
func botAPIMediaErr(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
if strings.Contains(strings.ToUpper(err.Error()), "FILE_ID_INVALID") {
|
|
return err
|
|
}
|
|
return errors.New("MEDIA_INVALID")
|
|
}
|
|
|
|
// BotAPIEditMessageText edits a bot-owned private text message through the
|
|
// normal durable edit state machine. Positive chat_id is a private user chat.
|
|
func (r *Router) BotAPIEditMessageText(ctx context.Context, botID, chatID int64, messageID int, text string, entities []domain.MessageEntity, setReplyMarkup bool, replyMarkup *domain.MessageReplyMarkup, disableWebPagePreview bool) (domain.Message, error) {
|
|
if r == nil || r.deps.Messages == nil || botID == 0 {
|
|
return domain.Message{}, errors.New("BOT_INVALID")
|
|
}
|
|
if chatID <= 0 {
|
|
return domain.Message{}, errors.New("CHAT_ID_INVALID")
|
|
}
|
|
if messageID <= 0 || messageID > domain.MaxMessageBoxID {
|
|
return domain.Message{}, errors.New("MESSAGE_ID_INVALID")
|
|
}
|
|
if text == "" {
|
|
return domain.Message{}, errors.New("MESSAGE_EMPTY")
|
|
}
|
|
if utf8.RuneCountInString(text) > domain.MaxMessageTextLength {
|
|
return domain.Message{}, errors.New("MESSAGE_TOO_LONG")
|
|
}
|
|
peer := domain.Peer{Type: domain.PeerTypeUser, ID: chatID}
|
|
res, err := r.deps.Messages.EditMessage(ctx, botID, domain.EditMessageRequest{
|
|
OwnerUserID: botID,
|
|
Peer: peer,
|
|
ID: messageID,
|
|
Message: text,
|
|
Entities: append([]domain.MessageEntity(nil), entities...),
|
|
EditDate: int(time.Now().Unix()),
|
|
SetReplyMarkup: setReplyMarkup,
|
|
ReplyMarkup: replyMarkup,
|
|
})
|
|
if err != nil {
|
|
return domain.Message{}, err
|
|
}
|
|
self := res.Self()
|
|
if self.Message.ID == 0 {
|
|
return domain.Message{}, errors.New("MESSAGE_ID_INVALID")
|
|
}
|
|
return self.Message, nil
|
|
}
|
|
|
|
// BotAPIDeleteMessage deletes a bot-owned private message with revoke=true so
|
|
// the target user's MTProto clients observe the normal delete update.
|
|
func (r *Router) BotAPIDeleteMessage(ctx context.Context, botID, chatID int64, messageID int) (bool, error) {
|
|
if r == nil || r.deps.Messages == nil || botID == 0 {
|
|
return false, errors.New("BOT_INVALID")
|
|
}
|
|
if chatID <= 0 {
|
|
return false, errors.New("CHAT_ID_INVALID")
|
|
}
|
|
if messageID <= 0 || messageID > domain.MaxMessageBoxID {
|
|
return false, errors.New("MESSAGE_ID_INVALID")
|
|
}
|
|
_, err := r.deps.Messages.DeleteMessages(ctx, botID, domain.DeleteMessagesRequest{
|
|
OwnerUserID: botID,
|
|
IDs: []int{messageID},
|
|
Revoke: true,
|
|
Date: int(time.Now().Unix()),
|
|
})
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
// BotAPIAnswerCallbackQuery bridges Bot API answerCallbackQuery to the same
|
|
// process-local callback registry used by messages.setBotCallbackAnswer.
|
|
func (r *Router) BotAPIAnswerCallbackQuery(ctx context.Context, botID int64, callbackQueryID, text, url string, showAlert bool, cacheTime int) (bool, error) {
|
|
if r == nil || r.callbacks == nil || botID == 0 {
|
|
return false, errors.New("BOT_INVALID")
|
|
}
|
|
queryID, err := strconv.ParseInt(callbackQueryID, 10, 64)
|
|
if err != nil || queryID == 0 {
|
|
return false, errors.New("QUERY_ID_INVALID")
|
|
}
|
|
if utf8.RuneCountInString(text) > domain.MaxBotCallbackAnswerLen {
|
|
return false, errors.New("MESSAGE_TOO_LONG")
|
|
}
|
|
if cacheTime < 0 {
|
|
cacheTime = 0
|
|
}
|
|
r.callbacks.resolve(botID, queryID, domain.BotCallbackAnswer{
|
|
Alert: showAlert,
|
|
Message: text,
|
|
URL: url,
|
|
CacheTime: cacheTime,
|
|
})
|
|
return true, nil
|
|
}
|
|
|
|
// BotAPIGetFile exposes the existing upload.getFile blob location space to the
|
|
// HTTP file endpoint after the bot token has authenticated the request.
|
|
func (r *Router) BotAPIGetFile(ctx context.Context, botID int64, locationKey string, offset int64, limit int) (domain.FileChunk, bool, error) {
|
|
if r == nil || r.deps.Files == nil || botID == 0 {
|
|
return domain.FileChunk{}, false, nil
|
|
}
|
|
if limit <= 0 || limit > maxUploadGetFileChunkLimit {
|
|
limit = maxUploadGetFileChunkLimit
|
|
}
|
|
if offset < 0 {
|
|
offset = 0
|
|
}
|
|
return r.deps.Files.GetFile(ctx, domain.FileDownloadRequest{
|
|
LocationKey: locationKey,
|
|
Offset: offset,
|
|
Limit: limit,
|
|
})
|
|
}
|