625 lines
21 KiB
Go
625 lines
21 KiB
Go
package rpc
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"strings"
|
||
|
||
"github.com/iamxvbaba/td/tg"
|
||
"github.com/iamxvbaba/td/tgerr"
|
||
|
||
"telesrv/internal/domain"
|
||
)
|
||
|
||
// validateReplyMarkupForPeer enforces the Bot API/TL boundary that reply keyboards control
|
||
// a chat input field and are not supported in broadcast channels. Inline keyboards remain
|
||
// valid in both megagroups and broadcasts.
|
||
func (r *Router) validateReplyMarkupForPeer(ctx context.Context, userID int64, peer domain.Peer, markup *domain.MessageReplyMarkup) error {
|
||
if err := r.prepareTelegramLoginMarkup(ctx, userID, markup); err != nil {
|
||
return replyMarkupErr(err)
|
||
}
|
||
if markup == nil || !markup.IsReplyKeyboardFamily() || peer.Type != domain.PeerTypeChannel {
|
||
return nil
|
||
}
|
||
if r == nil || r.deps.Channels == nil {
|
||
return channelInvalidErr(domain.ErrChannelInvalid)
|
||
}
|
||
view, err := r.deps.Channels.ResolveChannel(ctx, userID, peer.ID)
|
||
if err != nil {
|
||
return channelInvalidErr(err)
|
||
}
|
||
if view.Channel.Broadcast && !view.Channel.Megagroup {
|
||
return replyMarkupInvalidErr()
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// prepareTelegramLoginMarkup resolves every login_url target and validates its
|
||
// linked web origin before persistence. It mutates only the freshly parsed
|
||
// request DTO and assigns a deterministic flattened button id, which is later
|
||
// re-read by messages.requestUrlAuth.
|
||
func (r *Router) prepareTelegramLoginMarkup(ctx context.Context, senderBotID int64, markup *domain.MessageReplyMarkup) error {
|
||
if markup == nil || markup.Kind() != domain.MessageReplyMarkupInline {
|
||
return nil
|
||
}
|
||
hasLoginButton := false
|
||
for rowIndex := range markup.Inline {
|
||
for buttonIndex := range markup.Inline[rowIndex] {
|
||
if markup.Inline[rowIndex][buttonIndex].Type == domain.MarkupButtonLoginURL {
|
||
hasLoginButton = true
|
||
break
|
||
}
|
||
}
|
||
if hasLoginButton {
|
||
break
|
||
}
|
||
}
|
||
if !hasLoginButton {
|
||
return nil
|
||
}
|
||
if r == nil || r.deps.TelegramLogin == nil || r.deps.Users == nil || senderBotID <= 0 {
|
||
return domain.ErrButtonTypeInvalid
|
||
}
|
||
sender, found, err := r.deps.Users.ByID(ctx, senderBotID, senderBotID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if !found || !sender.Bot || sender.Deleted {
|
||
return domain.ErrButtonTypeInvalid
|
||
}
|
||
flatID := 0
|
||
for rowIndex := range markup.Inline {
|
||
for buttonIndex := range markup.Inline[rowIndex] {
|
||
button := &markup.Inline[rowIndex][buttonIndex]
|
||
if button.Type != domain.MarkupButtonLoginURL {
|
||
flatID++
|
||
continue
|
||
}
|
||
botID := button.LoginBotUserID
|
||
if button.LoginBotUsername != "" {
|
||
resolver, ok := r.deps.Users.(UserIdentityService)
|
||
if !ok {
|
||
return domain.ErrButtonInvalid
|
||
}
|
||
bot, found, err := resolver.ResolveUsername(ctx, senderBotID, strings.TrimPrefix(button.LoginBotUsername, "@"))
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if !found || !bot.Bot || bot.Deleted {
|
||
return domain.ErrButtonInvalid
|
||
}
|
||
botID = bot.ID
|
||
}
|
||
if botID == 0 {
|
||
botID = senderBotID
|
||
}
|
||
bot, found, err := r.deps.Users.ByID(ctx, senderBotID, botID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if !found || !bot.Bot || bot.Deleted {
|
||
return domain.ErrButtonInvalid
|
||
}
|
||
normalized, _, err := r.deps.TelegramLogin.ValidateMessageButton(ctx, botID, button.URL)
|
||
if err != nil {
|
||
if errors.Is(err, domain.ErrTelegramLoginURLInvalid) || errors.Is(err, domain.ErrTelegramLoginOriginNotAllowed) {
|
||
return domain.ErrButtonURLInvalid
|
||
}
|
||
if errors.Is(err, domain.ErrTelegramLoginClientDisabled) {
|
||
return domain.ErrButtonInvalid
|
||
}
|
||
return err
|
||
}
|
||
button.URL = normalized
|
||
button.LoginBotUserID = botID
|
||
button.LoginBotUsername = ""
|
||
button.ButtonID = flatID
|
||
flatID++
|
||
}
|
||
}
|
||
return domain.ValidateReplyMarkup(markup)
|
||
}
|
||
|
||
// P3 reply_markup 错误码（对齐官方）。
|
||
func buttonDataInvalidErr() error { return tgerr.New(400, "BUTTON_DATA_INVALID") }
|
||
func buttonInvalidErr() error { return tgerr.New(400, "BUTTON_INVALID") }
|
||
func buttonTypeInvalidErr() error { return tgerr.New(400, "BUTTON_TYPE_INVALID") }
|
||
func buttonURLInvalidErr() error { return tgerr.New(400, "BUTTON_URL_INVALID") }
|
||
|
||
// replyMarkupErr 把 domain 校验错误映射为客户端错误码。
|
||
func replyMarkupErr(err error) error {
|
||
switch {
|
||
case errors.Is(err, domain.ErrButtonDataInvalid):
|
||
return buttonDataInvalidErr()
|
||
case errors.Is(err, domain.ErrButtonURLInvalid):
|
||
return buttonURLInvalidErr()
|
||
case errors.Is(err, domain.ErrButtonTypeInvalid):
|
||
return buttonTypeInvalidErr()
|
||
case errors.Is(err, domain.ErrButtonInvalid):
|
||
return buttonInvalidErr()
|
||
default:
|
||
return replyMarkupInvalidErr()
|
||
}
|
||
}
|
||
|
||
// domainReplyMarkupForSender 解析只能携带 inline keyboard 的入站 reply_markup（inline
|
||
// result / edit 路径）。普通消息发送使用 domainOutgoingReplyMarkupForSender。
|
||
// 语义：
|
||
// - 仅 bot 账号下发的 markup 被接受；非 bot 一律丢弃（返回 nil，不报错——对齐
|
||
// 官方「普通用户 markup 无效」，I1）。
|
||
// - 仅 ReplyInlineMarkup 被处理；bot 的 reply keyboard 家族在这些上下文中显式拒绝。
|
||
// - inline 行内按钮仅 callback / url；其它按钮类型（webview/game/url_auth/
|
||
// request_* 等）→ ErrButtonTypeInvalid（拒绝整条发送，绝不半实现下发）。
|
||
// - data≤64B、行/按钮上限、url https 由 domain.ValidateReplyMarkup 校验。
|
||
func domainReplyMarkupForSender(markup tg.ReplyMarkupClass, senderIsBot bool) (*domain.MessageReplyMarkup, error) {
|
||
if markup == nil || !senderIsBot {
|
||
return nil, nil
|
||
}
|
||
inline, ok := markup.(*tg.ReplyInlineMarkup)
|
||
if !ok {
|
||
return nil, domain.ErrButtonTypeInvalid
|
||
}
|
||
parsed, err := domainInlineMarkup(inline)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if parsed.IsZero() {
|
||
return nil, nil
|
||
}
|
||
if err := domain.ValidateReplyMarkup(parsed); err != nil {
|
||
return nil, err
|
||
}
|
||
return parsed, nil
|
||
}
|
||
|
||
// domainOutgoingReplyMarkupForSender 解析普通 sendMessage/sendMedia 的完整 reply markup。
|
||
// 非 bot 携带 markup 仍按官方权限边界静默丢弃；bot 的未知/未实现按钮则拒绝整条消息，
|
||
// 避免客户端看到一个被服务端悄悄改形的键盘。
|
||
func domainOutgoingReplyMarkupForSender(markup tg.ReplyMarkupClass, senderIsBot bool) (*domain.MessageReplyMarkup, error) {
|
||
if markup == nil || !senderIsBot {
|
||
return nil, nil
|
||
}
|
||
switch v := markup.(type) {
|
||
case *tg.ReplyInlineMarkup:
|
||
return domainReplyMarkupForSender(v, true)
|
||
case *tg.ReplyKeyboardMarkup:
|
||
out := &domain.MessageReplyMarkup{
|
||
Type: domain.MessageReplyMarkupKeyboard,
|
||
Keyboard: make([][]domain.MarkupButton, 0, len(v.Rows)),
|
||
Resize: v.Resize,
|
||
SingleUse: v.SingleUse,
|
||
Selective: v.Selective,
|
||
Persistent: v.Persistent,
|
||
Placeholder: v.Placeholder,
|
||
}
|
||
for _, row := range v.Rows {
|
||
domainRow := make([]domain.MarkupButton, 0, len(row.Buttons))
|
||
for _, button := range row.Buttons {
|
||
parsed, err := domainReplyKeyboardButton(button)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
domainRow = append(domainRow, parsed)
|
||
}
|
||
out.Keyboard = append(out.Keyboard, domainRow)
|
||
}
|
||
if err := domain.ValidateReplyMarkup(out); err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
case *tg.ReplyKeyboardHide:
|
||
out := &domain.MessageReplyMarkup{Type: domain.MessageReplyMarkupHide, Selective: v.Selective}
|
||
if err := domain.ValidateReplyMarkup(out); err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
case *tg.ReplyKeyboardForceReply:
|
||
out := &domain.MessageReplyMarkup{
|
||
Type: domain.MessageReplyMarkupForceReply,
|
||
SingleUse: v.SingleUse,
|
||
Selective: v.Selective,
|
||
Placeholder: v.Placeholder,
|
||
}
|
||
if err := domain.ValidateReplyMarkup(out); err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
default:
|
||
return nil, domain.ErrButtonTypeInvalid
|
||
}
|
||
}
|
||
|
||
func domainReplyKeyboardButton(button tg.KeyboardButton) (domain.MarkupButton, error) {
|
||
style, icon, err := domainMarkupButtonStyle(&button)
|
||
if err != nil {
|
||
return domain.MarkupButton{}, err
|
||
}
|
||
base := domain.MarkupButton{Text: button.Text, Style: style, IconCustomEmojiID: icon}
|
||
switch b := button.Type.(type) {
|
||
case *tg.ButtonTypeDefault:
|
||
base.Type = domain.MarkupButtonText
|
||
case *tg.ButtonTypeRequestPhone:
|
||
base.Type = domain.MarkupButtonRequestPhone
|
||
case *tg.ButtonTypeRequestGeoLocation:
|
||
base.Type = domain.MarkupButtonRequestLocation
|
||
case *tg.ButtonTypeRequestPoll:
|
||
base.Type = domain.MarkupButtonRequestPoll
|
||
if quiz, ok := b.GetQuiz(); ok {
|
||
if quiz {
|
||
base.PollType = "quiz"
|
||
} else {
|
||
base.PollType = "regular"
|
||
}
|
||
}
|
||
case *tg.ButtonTypeRequestPeer:
|
||
base.Type = domain.MarkupButtonRequestPeer
|
||
base.ButtonID, base.MaxQuantity = b.ButtonID, b.MaxQuantity
|
||
base.RequestPeerType, base.RequestPeerFilter = domainRequestPeerFilter(b.PeerType)
|
||
case *tg.ButtonTypeSimpleWebView:
|
||
base.Type, base.URL = domain.MarkupButtonSimpleWebView, b.URL
|
||
default:
|
||
return domain.MarkupButton{}, domain.ErrButtonTypeInvalid
|
||
}
|
||
return base, nil
|
||
}
|
||
|
||
func domainInlineMarkup(inline *tg.ReplyInlineMarkup) (*domain.MessageReplyMarkup, error) {
|
||
out := &domain.MessageReplyMarkup{Type: domain.MessageReplyMarkupInline, Inline: make([][]domain.MarkupButton, 0, len(inline.Rows))}
|
||
buttonID := 0
|
||
for _, row := range inline.Rows {
|
||
domainRow := make([]domain.MarkupButton, 0, len(row.Buttons))
|
||
for _, btn := range row.Buttons {
|
||
db, err := domainMarkupButton(btn, buttonID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
domainRow = append(domainRow, db)
|
||
buttonID++
|
||
}
|
||
out.Inline = append(out.Inline, domainRow)
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func domainMarkupButton(btn tg.KeyboardInlineButton, buttonID int) (domain.MarkupButton, error) {
|
||
style, icon, err := domainMarkupButtonStyle(&btn)
|
||
if err != nil {
|
||
return domain.MarkupButton{}, err
|
||
}
|
||
switch b := btn.Type.(type) {
|
||
case *tg.InlineButtonTypeCallback:
|
||
return domain.MarkupButton{
|
||
Type: domain.MarkupButtonCallback,
|
||
Text: btn.Text,
|
||
Style: style,
|
||
IconCustomEmojiID: icon,
|
||
Data: append([]byte(nil), b.Data...),
|
||
RequiresPassword: b.RequiresPassword,
|
||
}, nil
|
||
case *tg.InlineButtonTypeURL:
|
||
return domain.MarkupButton{
|
||
Type: domain.MarkupButtonURL, Text: btn.Text, URL: b.URL,
|
||
Style: style, IconCustomEmojiID: icon,
|
||
}, nil
|
||
case *tg.InputInlineButtonTypeURLAuth:
|
||
botUserID := int64(0)
|
||
switch bot := b.Bot.(type) {
|
||
case nil, *tg.InputUserEmpty, *tg.InputUserSelf:
|
||
case *tg.InputUser:
|
||
botUserID = bot.UserID
|
||
default:
|
||
return domain.MarkupButton{}, domain.ErrButtonInvalid
|
||
}
|
||
return domain.MarkupButton{
|
||
Type: domain.MarkupButtonLoginURL, Text: btn.Text, URL: b.URL,
|
||
ForwardText: b.FwdText, ButtonID: buttonID, LoginBotUserID: botUserID,
|
||
RequestWriteAccess: b.RequestWriteAccess, Style: style, IconCustomEmojiID: icon,
|
||
}, nil
|
||
case *tg.InlineButtonTypeURLAuth:
|
||
return domain.MarkupButton{
|
||
Type: domain.MarkupButtonLoginURL, Text: btn.Text, URL: b.URL,
|
||
ForwardText: b.FwdText, ButtonID: b.ButtonID,
|
||
Style: style, IconCustomEmojiID: icon,
|
||
}, nil
|
||
case *tg.InlineButtonTypeWebView:
|
||
return domain.MarkupButton{Type: domain.MarkupButtonWebView, Text: btn.Text, URL: b.URL, Style: style, IconCustomEmojiID: icon}, nil
|
||
case *tg.InlineButtonTypeSwitchInline:
|
||
peerTypes, err := preparedInlinePeerTypesFromTG(b.PeerTypes)
|
||
if err != nil {
|
||
return domain.MarkupButton{}, domain.ErrButtonInvalid
|
||
}
|
||
return domain.MarkupButton{Type: domain.MarkupButtonSwitchInline, Text: btn.Text, Query: b.Query, SamePeer: b.SamePeer, PeerTypes: peerTypes, Style: style, IconCustomEmojiID: icon}, nil
|
||
case *tg.InlineButtonTypeCopy:
|
||
return domain.MarkupButton{Type: domain.MarkupButtonCopy, Text: btn.Text, CopyText: b.CopyText, Style: style, IconCustomEmojiID: icon}, nil
|
||
default:
|
||
// webview/game/url_auth/request_*/switch_inline/buy 等 P3 未实现按钮类型。
|
||
return domain.MarkupButton{}, domain.ErrButtonTypeInvalid
|
||
}
|
||
}
|
||
|
||
func domainMarkupButtonStyle(btn interface {
|
||
GetStyle() (tg.KeyboardButtonStyle, bool)
|
||
}) (domain.MarkupButtonStyle, int64, error) {
|
||
style, ok := btn.GetStyle()
|
||
if !ok {
|
||
return "", 0, nil
|
||
}
|
||
colors := 0
|
||
var out domain.MarkupButtonStyle
|
||
if style.GetBgPrimary() {
|
||
colors++
|
||
out = domain.MarkupButtonStylePrimary
|
||
}
|
||
if style.GetBgDanger() {
|
||
colors++
|
||
out = domain.MarkupButtonStyleDanger
|
||
}
|
||
if style.GetBgSuccess() {
|
||
colors++
|
||
out = domain.MarkupButtonStyleSuccess
|
||
}
|
||
icon, hasIcon := style.GetIcon()
|
||
if colors > 1 || (hasIcon && icon <= 0) || (colors == 0 && !hasIcon) {
|
||
return "", 0, domain.ErrButtonInvalid
|
||
}
|
||
return out, icon, nil
|
||
}
|
||
|
||
func tgMarkupButtonStyle(btn domain.MarkupButton) (tg.KeyboardButtonStyle, bool) {
|
||
var out tg.KeyboardButtonStyle
|
||
switch btn.Style {
|
||
case domain.MarkupButtonStylePrimary:
|
||
out.SetBgPrimary(true)
|
||
case domain.MarkupButtonStyleDanger:
|
||
out.SetBgDanger(true)
|
||
case domain.MarkupButtonStyleSuccess:
|
||
out.SetBgSuccess(true)
|
||
}
|
||
if btn.IconCustomEmojiID > 0 {
|
||
out.SetIcon(btn.IconCustomEmojiID)
|
||
}
|
||
return out, btn.Style != "" || btn.IconCustomEmojiID > 0
|
||
}
|
||
|
||
// tgReplyMarkup 把存储的协议中立快照还原为对应 ReplyMarkup constructor。
|
||
func tgReplyMarkup(m *domain.MessageReplyMarkup) tg.ReplyMarkupClass {
|
||
if m.IsZero() {
|
||
return nil
|
||
}
|
||
switch m.Kind() {
|
||
case domain.MessageReplyMarkupKeyboard:
|
||
rows := make([]tg.KeyboardButtonRow, 0, len(m.Keyboard))
|
||
for _, row := range m.Keyboard {
|
||
buttons := make([]tg.KeyboardButton, 0, len(row))
|
||
for _, btn := range row {
|
||
buttons = append(buttons, tgReplyKeyboardButton(btn))
|
||
}
|
||
rows = append(rows, tg.KeyboardButtonRow{Buttons: buttons})
|
||
}
|
||
return &tg.ReplyKeyboardMarkup{
|
||
Resize: m.Resize,
|
||
SingleUse: m.SingleUse,
|
||
Selective: m.Selective,
|
||
Persistent: m.Persistent,
|
||
Rows: rows,
|
||
Placeholder: m.Placeholder,
|
||
}
|
||
case domain.MessageReplyMarkupHide:
|
||
return &tg.ReplyKeyboardHide{Selective: m.Selective}
|
||
case domain.MessageReplyMarkupForceReply:
|
||
return &tg.ReplyKeyboardForceReply{
|
||
SingleUse: m.SingleUse,
|
||
Selective: m.Selective,
|
||
Placeholder: m.Placeholder,
|
||
}
|
||
case domain.MessageReplyMarkupInline:
|
||
// Continue below.
|
||
default:
|
||
return nil
|
||
}
|
||
rows := make([]tg.KeyboardInlineButtonRow, 0, len(m.Inline))
|
||
for _, row := range m.Inline {
|
||
buttons := make([]tg.KeyboardInlineButton, 0, len(row))
|
||
for _, btn := range row {
|
||
buttons = append(buttons, tgMarkupButton(btn))
|
||
}
|
||
rows = append(rows, tg.KeyboardInlineButtonRow{Buttons: buttons})
|
||
}
|
||
return &tg.ReplyInlineMarkup{Rows: rows}
|
||
}
|
||
|
||
func tgMarkupButton(btn domain.MarkupButton) tg.KeyboardInlineButton {
|
||
out := tg.KeyboardInlineButton{Text: btn.Text}
|
||
switch btn.Type {
|
||
case domain.MarkupButtonURL:
|
||
out.Type = &tg.InlineButtonTypeURL{URL: btn.URL}
|
||
case domain.MarkupButtonLoginURL:
|
||
buttonType := &tg.InlineButtonTypeURLAuth{URL: btn.URL, ButtonID: btn.ButtonID}
|
||
if btn.ForwardText != "" {
|
||
buttonType.SetFwdText(btn.ForwardText)
|
||
}
|
||
out.Type = buttonType
|
||
case domain.MarkupButtonWebView:
|
||
out.Type = &tg.InlineButtonTypeWebView{URL: btn.URL}
|
||
case domain.MarkupButtonSwitchInline:
|
||
buttonType := &tg.InlineButtonTypeSwitchInline{Query: btn.Query, SamePeer: btn.SamePeer}
|
||
if len(btn.PeerTypes) > 0 {
|
||
buttonType.SetPeerTypes(tgPreparedInlinePeerTypes(btn.PeerTypes))
|
||
}
|
||
out.Type = buttonType
|
||
case domain.MarkupButtonCopy:
|
||
out.Type = &tg.InlineButtonTypeCopy{CopyText: btn.CopyText}
|
||
case domain.MarkupButtonBuy:
|
||
out.Type = &tg.InlineButtonTypeBuy{}
|
||
default: // callback
|
||
buttonType := &tg.InlineButtonTypeCallback{Data: btn.Data}
|
||
if btn.RequiresPassword {
|
||
buttonType.SetRequiresPassword(true)
|
||
}
|
||
out.Type = buttonType
|
||
}
|
||
if style, ok := tgMarkupButtonStyle(btn); ok {
|
||
out.SetStyle(style)
|
||
}
|
||
return out
|
||
}
|
||
|
||
func tgReplyKeyboardButton(btn domain.MarkupButton) tg.KeyboardButton {
|
||
out := tg.KeyboardButton{Text: btn.Text}
|
||
switch btn.Type {
|
||
case domain.MarkupButtonRequestPhone:
|
||
out.Type = &tg.ButtonTypeRequestPhone{}
|
||
case domain.MarkupButtonRequestLocation:
|
||
out.Type = &tg.ButtonTypeRequestGeoLocation{}
|
||
case domain.MarkupButtonRequestPoll:
|
||
button := &tg.ButtonTypeRequestPoll{}
|
||
if btn.PollType == "quiz" {
|
||
button.SetQuiz(true)
|
||
} else if btn.PollType == "regular" {
|
||
button.SetQuiz(false)
|
||
}
|
||
out.Type = button
|
||
case domain.MarkupButtonRequestPeer:
|
||
out.Type = &tg.ButtonTypeRequestPeer{ButtonID: btn.ButtonID, PeerType: tgRequestPeerTypeWithFilter(btn.RequestPeerType, btn.RequestPeerFilter), MaxQuantity: btn.MaxQuantity}
|
||
case domain.MarkupButtonSimpleWebView:
|
||
out.Type = &tg.ButtonTypeSimpleWebView{URL: btn.URL}
|
||
default:
|
||
out.Type = &tg.ButtonTypeDefault{}
|
||
}
|
||
if style, ok := tgMarkupButtonStyle(btn); ok {
|
||
out.SetStyle(style)
|
||
}
|
||
return out
|
||
}
|
||
|
||
func domainRequestPeerFilter(peerType tg.RequestPeerTypeClass) (string, *domain.BotRequestPeerFilter) {
|
||
filter := &domain.BotRequestPeerFilter{}
|
||
switch v := peerType.(type) {
|
||
case *tg.RequestPeerTypeUser:
|
||
if value, ok := v.GetBot(); ok {
|
||
filter.UserIsBotSet, filter.UserIsBot = true, value
|
||
}
|
||
if value, ok := v.GetPremium(); ok {
|
||
filter.UserIsPremiumSet, filter.UserIsPremium = true, value
|
||
}
|
||
if !filter.UserIsBotSet && !filter.UserIsPremiumSet {
|
||
return "user", nil
|
||
}
|
||
return "user", filter
|
||
case *tg.RequestPeerTypeChat:
|
||
filter.ChatIsCreated, filter.BotIsMember = v.Creator, v.BotParticipant
|
||
if value, ok := v.GetHasUsername(); ok {
|
||
filter.ChatHasUsernameSet, filter.ChatHasUsername = true, value
|
||
}
|
||
if value, ok := v.GetForum(); ok {
|
||
filter.ChatIsForumSet, filter.ChatIsForum = true, value
|
||
}
|
||
if rights, ok := v.GetUserAdminRights(); ok {
|
||
mapped := domainBotRequestAdminRights(rights)
|
||
filter.UserAdminRights = &mapped
|
||
}
|
||
if rights, ok := v.GetBotAdminRights(); ok {
|
||
mapped := domainBotRequestAdminRights(rights)
|
||
filter.BotAdminRights = &mapped
|
||
}
|
||
if botRequestPeerFilterZero(filter) {
|
||
return "chat", nil
|
||
}
|
||
return "chat", filter
|
||
case *tg.RequestPeerTypeBroadcast:
|
||
filter.ChatIsCreated = v.Creator
|
||
if value, ok := v.GetHasUsername(); ok {
|
||
filter.ChatHasUsernameSet, filter.ChatHasUsername = true, value
|
||
}
|
||
if rights, ok := v.GetUserAdminRights(); ok {
|
||
mapped := domainBotRequestAdminRights(rights)
|
||
filter.UserAdminRights = &mapped
|
||
}
|
||
if rights, ok := v.GetBotAdminRights(); ok {
|
||
mapped := domainBotRequestAdminRights(rights)
|
||
filter.BotAdminRights = &mapped
|
||
}
|
||
if botRequestPeerFilterZero(filter) {
|
||
return "broadcast", nil
|
||
}
|
||
return "broadcast", filter
|
||
default:
|
||
return "", nil
|
||
}
|
||
}
|
||
|
||
func botRequestPeerFilterZero(filter *domain.BotRequestPeerFilter) bool {
|
||
return filter == nil || (!filter.UserIsBotSet && !filter.UserIsPremiumSet && !filter.ChatHasUsernameSet &&
|
||
!filter.ChatIsForumSet && !filter.ChatIsCreated && !filter.BotIsMember && filter.UserAdminRights == nil && filter.BotAdminRights == nil)
|
||
}
|
||
|
||
func tgRequestPeerTypeWithFilter(kind string, filter *domain.BotRequestPeerFilter) tg.RequestPeerTypeClass {
|
||
switch kind {
|
||
case "chat":
|
||
out := &tg.RequestPeerTypeChat{}
|
||
if filter != nil {
|
||
out.Creator, out.BotParticipant = filter.ChatIsCreated, filter.BotIsMember
|
||
if filter.ChatHasUsernameSet {
|
||
out.SetHasUsername(filter.ChatHasUsername)
|
||
}
|
||
if filter.ChatIsForumSet {
|
||
out.SetForum(filter.ChatIsForum)
|
||
}
|
||
if filter.UserAdminRights != nil {
|
||
out.SetUserAdminRights(tgBotRequestAdminRights(*filter.UserAdminRights))
|
||
}
|
||
if filter.BotAdminRights != nil {
|
||
out.SetBotAdminRights(tgBotRequestAdminRights(*filter.BotAdminRights))
|
||
}
|
||
}
|
||
return out
|
||
case "broadcast":
|
||
out := &tg.RequestPeerTypeBroadcast{}
|
||
if filter != nil {
|
||
out.Creator = filter.ChatIsCreated
|
||
if filter.ChatHasUsernameSet {
|
||
out.SetHasUsername(filter.ChatHasUsername)
|
||
}
|
||
if filter.UserAdminRights != nil {
|
||
out.SetUserAdminRights(tgBotRequestAdminRights(*filter.UserAdminRights))
|
||
}
|
||
if filter.BotAdminRights != nil {
|
||
out.SetBotAdminRights(tgBotRequestAdminRights(*filter.BotAdminRights))
|
||
}
|
||
}
|
||
return out
|
||
default:
|
||
out := &tg.RequestPeerTypeUser{}
|
||
if filter != nil {
|
||
if filter.UserIsBotSet {
|
||
out.SetBot(filter.UserIsBot)
|
||
}
|
||
if filter.UserIsPremiumSet {
|
||
out.SetPremium(filter.UserIsPremium)
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
}
|
||
|
||
func domainBotRequestAdminRights(rights tg.ChatAdminRights) domain.BotRequestAdminRights {
|
||
return domain.BotRequestAdminRights{
|
||
Anonymous: rights.Anonymous, ManageChat: rights.Other, DeleteMessages: rights.DeleteMessages,
|
||
ManageVideoChats: rights.ManageCall, RestrictMembers: rights.BanUsers, PromoteMembers: rights.AddAdmins,
|
||
ChangeInfo: rights.ChangeInfo, InviteUsers: rights.InviteUsers, PostStories: rights.PostStories,
|
||
EditStories: rights.EditStories, DeleteStories: rights.DeleteStories, PostMessages: rights.PostMessages,
|
||
EditMessages: rights.EditMessages, PinMessages: rights.PinMessages, ManageTopics: rights.ManageTopics,
|
||
ManageDirectMessages: rights.ManageDirectMessages,
|
||
}
|
||
}
|
||
|
||
func tgBotRequestAdminRights(rights domain.BotRequestAdminRights) tg.ChatAdminRights {
|
||
return tg.ChatAdminRights{
|
||
Anonymous: rights.Anonymous, Other: rights.ManageChat, DeleteMessages: rights.DeleteMessages,
|
||
ManageCall: rights.ManageVideoChats, BanUsers: rights.RestrictMembers, AddAdmins: rights.PromoteMembers,
|
||
ChangeInfo: rights.ChangeInfo, InviteUsers: rights.InviteUsers, PostStories: rights.PostStories,
|
||
EditStories: rights.EditStories, DeleteStories: rights.DeleteStories, PostMessages: rights.PostMessages,
|
||
EditMessages: rights.EditMessages, PinMessages: rights.PinMessages, ManageTopics: rights.ManageTopics,
|
||
ManageDirectMessages: rights.ManageDirectMessages,
|
||
}
|
||
}
|