feat(send): convert tg.Message to Bot API Message

convertMessage resolves the chat and sender via the peer manager and fills the
core Message fields: text, entities, reply target, author signature, edit date
and inline reply markup. Pure helpers userFromTgUser, chatFromPeer and
inlineKeyboardFromTg do the field-level translation. Richer media mapping
follows with the media work.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ernado

convert.go

@@ -0,0 +1,170 @@
+package botapi
+
+import (
+	"context"
+
+	"github.com/gotd/td/telegram/peers"
+	"github.com/gotd/td/tg"
+)
+
+// userFromTgUser converts a raw tg.User into a Bot API User. Pure: optional
+// fields are taken as their zero values when absent.
+func userFromTgUser(u *tg.User) User {
+	return User{
+		ID:           u.ID,
+		IsBot:        u.Bot,
+		FirstName:    u.FirstName,
+		LastName:     u.LastName,
+		Username:     u.Username,
+		LanguageCode: u.LangCode,
+		IsPremium:    u.Premium,
+	}
+}
+
+// chatFromPeer builds a Bot API Chat from a resolved gotd peer.
+//
+// The default arm keeps the switch closed against future peer kinds
+// (default-signifies-exhaustive).
+func chatFromPeer(p peers.Peer) Chat {
+	switch p := p.(type) {
+	case peers.User:
+		c := Chat{ID: int64(p.TDLibPeerID()), Type: ChatTypePrivate}
+		if v, ok := p.Username(); ok {
+			c.Username = v
+		}
+		if v, ok := p.FirstName(); ok {
+			c.FirstName = v
+		}
+		if v, ok := p.LastName(); ok {
+			c.LastName = v
+		}
+		return c
+	case peers.Channel:
+		c := Chat{ID: int64(p.TDLibPeerID()), Title: p.VisibleName(), Type: ChatTypeSupergroup}
+		if _, ok := p.ToBroadcast(); ok {
+			c.Type = ChatTypeChannel
+		}
+		if v, ok := p.Username(); ok {
+			c.Username = v
+		}
+		return c
+	case peers.Chat:
+		return Chat{ID: int64(p.TDLibPeerID()), Type: ChatTypeGroup, Title: p.VisibleName()}
+	default:
+		return Chat{ID: int64(p.TDLibPeerID())}
+	}
+}
+
+// inlineKeyboardFromTg converts an MTProto inline markup back into a Bot API
+// InlineKeyboardMarkup. Pure.
+func inlineKeyboardFromTg(mkp *tg.ReplyInlineMarkup) *InlineKeyboardMarkup {
+	rows := make([][]InlineKeyboardButton, len(mkp.Rows))
+	for i, row := range mkp.Rows {
+		buttons := make([]InlineKeyboardButton, len(row.Buttons))
+		for j, b := range row.Buttons {
+			btn := InlineKeyboardButton{Text: b.GetText()}
+			switch b := b.(type) {
+			case *tg.KeyboardButtonURL:
+				btn.URL = b.URL
+			case *tg.KeyboardButtonCallback:
+				btn.CallbackData = string(b.Data)
+			case *tg.KeyboardButtonBuy:
+				btn.Pay = true
+			case *tg.KeyboardButtonSwitchInline:
+				q := b.Query
+				if b.SamePeer {
+					btn.SwitchInlineQueryCurrentChat = &q
+				} else {
+					btn.SwitchInlineQuery = &q
+				}
+			case *tg.KeyboardButtonURLAuth:
+				// login_url buttons are represented as ordinary url buttons.
+				btn.URL = b.URL
+			}
+			buttons[j] = btn
+		}
+		rows[i] = buttons
+	}
+	return &InlineKeyboardMarkup{InlineKeyboard: rows}
+}
+
+// chatByPeer resolves a tg.PeerClass to a Bot API Chat via the peer manager.
+func (b *Bot) chatByPeer(ctx context.Context, p tg.PeerClass) (Chat, error) {
+	peer, err := b.peers.ResolvePeer(ctx, p)
+	if err != nil {
+		return Chat{}, asAPIError(err)
+	}
+	return chatFromPeer(peer), nil
+}
+
+// fillFrom sets Message.From (for users) or Message.SenderChat (for chats and
+// channels) from a tg sender peer.
+func (b *Bot) fillFrom(ctx context.Context, from tg.PeerClass, m *Message) error {
+	switch from := from.(type) {
+	case *tg.PeerUser:
+		u, err := b.peers.GetUser(ctx, &tg.InputUser{UserID: from.UserID})
+		if err != nil {
+			return asAPIError(err)
+		}
+		user := userFromTgUser(u.Raw())
+		m.From = &user
+	case *tg.PeerChat, *tg.PeerChannel:
+		chat, err := b.chatByPeer(ctx, from)
+		if err != nil {
+			return err
+		}
+		m.SenderChat = &chat
+	}
+	return nil
+}
+
+// convertMessage translates a tg.Message into a Bot API Message, resolving the
+// chat and sender via the peer manager. It fills the core fields (text,
+// entities, reply target, inline markup); richer media mapping arrives with the
+// media send/receive work.
+func (b *Bot) convertMessage(ctx context.Context, m *tg.Message) (*Message, error) {
+	chat, err := b.chatByPeer(ctx, m.PeerID)
+	if err != nil {
+		return nil, err
+	}
+
+	r := &Message{
+		MessageID:           m.ID,
+		Date:                m.Date,
+		Chat:                chat,
+		HasProtectedContent: m.Noforwards,
+	}
+	if v, ok := m.GetEditDate(); ok {
+		r.EditDate = v
+	}
+	if v, ok := m.GetPostAuthor(); ok {
+		r.AuthorSignature = v
+	}
+
+	if m.Out {
+		if self, selfErr := b.peers.Self(ctx); selfErr == nil {
+			user := userFromTgUser(self.Raw())
+			r.From = &user
+		}
+	} else if from, ok := m.GetFromID(); ok {
+		if err := b.fillFrom(ctx, from, r); err != nil {
+			return nil, err
+		}
+	}
+
+	if rh, ok := m.ReplyTo.(*tg.MessageReplyHeader); ok && rh.ReplyToMsgID != 0 {
+		r.ReplyToMessage = &Message{MessageID: rh.ReplyToMsgID}
+	}
+
+	if m.Message != "" {
+		r.Text = m.Message
+	}
+	if len(m.Entities) > 0 {
+		r.Entities = entitiesFromTg(m.Entities)
+	}
+	if mkp, ok := m.ReplyMarkup.(*tg.ReplyInlineMarkup); ok {
+		r.ReplyMarkup = inlineKeyboardFromTg(mkp)
+	}
+
+	return r, nil
+}

convert_test.go

@@ -0,0 +1,37 @@
+package botapi
+
+import (
+	"testing"
+
+	"github.com/gotd/td/tg"
+)
+
+func TestUserFromTgUser(t *testing.T) {
+	u := &tg.User{ID: 42, Bot: true, FirstName: "Ada", LastName: "L", Username: "ada", LangCode: "en"}
+	u.SetPremium(true)
+	got := userFromTgUser(u)
+	want := User{ID: 42, IsBot: true, FirstName: "Ada", LastName: "L", Username: "ada", LanguageCode: "en", IsPremium: true}
+	if got != want {
+		t.Fatalf("got %+v want %+v", got, want)
+	}
+}
+
+func TestInlineKeyboardFromTg(t *testing.T) {
+	mkp := &tg.ReplyInlineMarkup{Rows: []tg.KeyboardButtonRow{{Buttons: []tg.KeyboardButtonClass{
+		&tg.KeyboardButtonURL{Text: "site", URL: "https://example.com"},
+		&tg.KeyboardButtonCallback{Text: "ok", Data: []byte("ok:1")},
+		&tg.KeyboardButtonSwitchInline{Text: "here", Query: "q", SamePeer: true},
+	}}}}
+
+	got := inlineKeyboardFromTg(mkp)
+	if len(got.InlineKeyboard) != 1 || len(got.InlineKeyboard[0]) != 3 {
+		t.Fatalf("unexpected shape: %+v", got.InlineKeyboard)
+	}
+	row := got.InlineKeyboard[0]
+	if row[0].URL != "https://example.com" || row[1].CallbackData != "ok:1" {
+		t.Fatalf("url/callback lost: %+v", row)
+	}
+	if row[2].SwitchInlineQueryCurrentChat == nil || *row[2].SwitchInlineQueryCurrentChat != "q" {
+		t.Fatalf("same-peer switch-inline lost: %+v", row[2])
+	}
+}