feat: add reactions, join requests and sender-chat ban

SetMessageReaction (messages.sendReaction), ApproveChatJoinRequest /
DeclineChatJoinRequest (messages.hideChatJoinRequest), and
BanChatSenderChat / UnbanChatSenderChat (channels.editBanned).

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

Author: ernado

chat_join.go

@@ -0,0 +1,42 @@
+package botapi
+
+import (
+	"context"
+
+	"github.com/gotd/td/tg"
+)
+
+// hideJoinRequest approves or declines a pending join request for a chat.
+func (b *Bot) hideJoinRequest(ctx context.Context, chat ChatID, userID int64, approved bool) error {
+	peer, err := b.resolveInputPeer(ctx, chat)
+	if err != nil {
+		return err
+	}
+
+	user, err := b.resolveInputUser(ctx, userID)
+	if err != nil {
+		return err
+	}
+
+	if _, err := b.raw.MessagesHideChatJoinRequest(ctx, &tg.MessagesHideChatJoinRequestRequest{
+		Approved: approved,
+		Peer:     peer,
+		UserID:   user,
+	}); err != nil {
+		return asAPIError(err)
+	}
+
+	return nil
+}
+
+// ApproveChatJoinRequest approves a chat join request. The bot must be an
+// administrator with the can_invite_users right.
+func (b *Bot) ApproveChatJoinRequest(ctx context.Context, chat ChatID, userID int64) error {
+	return b.hideJoinRequest(ctx, chat, userID, true)
+}
+
+// DeclineChatJoinRequest declines a chat join request. The bot must be an
+// administrator with the can_invite_users right.
+func (b *Bot) DeclineChatJoinRequest(ctx context.Context, chat ChatID, userID int64) error {
+	return b.hideJoinRequest(ctx, chat, userID, false)
+}

chat_sender.go

@@ -0,0 +1,45 @@
+package botapi
+
+import (
+	"context"
+
+	"github.com/gotd/td/tg"
+)
+
+// BanChatSenderChat bans a channel chat from posting in a supergroup or channel
+// on behalf of any of its sender chats. The bot must be an administrator with
+// the appropriate rights. The ban is permanent until lifted with
+// UnbanChatSenderChat.
+func (b *Bot) BanChatSenderChat(ctx context.Context, chat ChatID, senderChatID int64) error {
+	return b.editSenderChatBan(ctx, chat, senderChatID, tg.ChatBannedRights{ViewMessages: true})
+}
+
+// UnbanChatSenderChat lifts a previously set sender-chat ban in a supergroup or
+// channel.
+func (b *Bot) UnbanChatSenderChat(ctx context.Context, chat ChatID, senderChatID int64) error {
+	return b.editSenderChatBan(ctx, chat, senderChatID, tg.ChatBannedRights{})
+}
+
+// editSenderChatban sets the banned rights of a sender chat (channel or user
+// peer) within a supergroup or channel. Empty rights clear the ban.
+func (b *Bot) editSenderChatBan(ctx context.Context, chat ChatID, senderChatID int64, rights tg.ChatBannedRights) error {
+	channel, err := b.resolveChannel(ctx, chat)
+	if err != nil {
+		return err
+	}
+
+	sender, err := b.resolveInputPeer(ctx, ID(senderChatID))
+	if err != nil {
+		return err
+	}
+
+	if _, err := b.raw.ChannelsEditBanned(ctx, &tg.ChannelsEditBannedRequest{
+		Channel:      channel,
+		Participant:  sender,
+		BannedRights: rights,
+	}); err != nil {
+		return asAPIError(err)
+	}
+
+	return nil
+}

reactions.go

@@ -0,0 +1,79 @@
+package botapi
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/gotd/td/tg"
+)
+
+// reactionToTg converts a Bot API reaction type to the MTProto representation.
+//
+// The switch over the sealed ReactionType union is exhaustive (gochecksumtype).
+func reactionToTg(r ReactionType) (tg.ReactionClass, error) {
+	switch v := r.(type) {
+	case ReactionTypeEmoji:
+		return &tg.ReactionEmoji{Emoticon: v.Emoji}, nil
+	case ReactionTypeCustomEmoji:
+		id, err := strconv.ParseInt(v.CustomEmojiID, 10, 64)
+		if err != nil {
+			return nil, &Error{Code: 400, Description: "Bad Request: invalid custom_emoji_id"}
+		}
+
+		return &tg.ReactionCustomEmoji{DocumentID: id}, nil
+	case ReactionTypePaid:
+		return &tg.ReactionPaid{}, nil
+	default:
+		return nil, &Error{Code: 400, Description: "Bad Request: invalid reaction type"}
+	}
+}
+
+// ReactionOption configures a SetMessageReaction call.
+type ReactionOption func(*reactionConfig)
+
+type reactionConfig struct {
+	big bool
+}
+
+// WithBigReaction shows the reaction with a big, animated effect.
+func WithBigReaction() ReactionOption {
+	return func(c *reactionConfig) { c.big = true }
+}
+
+// SetMessageReaction sets the bot's reactions on a message. Passing an empty
+// reactions slice removes the bot's reaction. As a non-premium user a bot can
+// set at most one reaction per message.
+func (b *Bot) SetMessageReaction(ctx context.Context, chat ChatID, messageID int, reactions []ReactionType, opts ...ReactionOption) error {
+	var cfg reactionConfig
+
+	for _, o := range opts {
+		o(&cfg)
+	}
+
+	peer, err := b.resolveInputPeer(ctx, chat)
+	if err != nil {
+		return err
+	}
+
+	tgReactions := make([]tg.ReactionClass, 0, len(reactions))
+
+	for _, r := range reactions {
+		converted, err := reactionToTg(r)
+		if err != nil {
+			return err
+		}
+
+		tgReactions = append(tgReactions, converted)
+	}
+
+	if _, err := b.raw.MessagesSendReaction(ctx, &tg.MessagesSendReactionRequest{
+		Big:      cfg.big,
+		Peer:     peer,
+		MsgID:    messageID,
+		Reaction: tgReactions,
+	}); err != nil {
+		return asAPIError(err)
+	}
+
+	return nil
+}

reactions_test.go

@@ -0,0 +1,145 @@
+package botapi
+
+import (
+	"context"
+	"testing"
+
+	"github.com/gotd/td/constant"
+	"github.com/gotd/td/tg"
+)
+
+func TestSetMessageReaction(t *testing.T) {
+	inv := newMockInvoker()
+	inv.reply(tg.MessagesSendReactionRequestTypeID, okUpdates())
+
+	b := newMockBot(inv)
+
+	reactions := []ReactionType{Emoji("👍")}
+	if err := b.SetMessageReaction(context.Background(), userRef(10, 1), 42, reactions, WithBigReaction()); err != nil {
+		t.Fatalf("SetMessageReaction: %v", err)
+	}
+
+	var req tg.MessagesSendReactionRequest
+
+	inv.decode(t, tg.MessagesSendReactionRequestTypeID, &req)
+
+	if req.MsgID != 42 || !req.Big {
+		t.Fatalf("req = %#v", req)
+	}
+
+	if len(req.Reaction) != 1 {
+		t.Fatalf("reactions = %#v", req.Reaction)
+	}
+
+	emoji, ok := req.Reaction[0].(*tg.ReactionEmoji)
+	if !ok || emoji.Emoticon != "👍" {
+		t.Fatalf("reaction = %#v", req.Reaction[0])
+	}
+}
+
+func TestSetMessageReactionEmptyClears(t *testing.T) {
+	inv := newMockInvoker()
+	inv.reply(tg.MessagesSendReactionRequestTypeID, okUpdates())
+
+	if err := newMockBot(inv).SetMessageReaction(context.Background(), userRef(10, 1), 1, nil); err != nil {
+		t.Fatalf("SetMessageReaction: %v", err)
+	}
+
+	var req tg.MessagesSendReactionRequest
+
+	inv.decode(t, tg.MessagesSendReactionRequestTypeID, &req)
+
+	if len(req.Reaction) != 0 {
+		t.Fatalf("reactions = %#v, want empty", req.Reaction)
+	}
+}
+
+func TestReactionToTgCustomEmoji(t *testing.T) {
+	got, err := reactionToTg(CustomEmoji("12345"))
+	if err != nil {
+		t.Fatalf("reactionToTg: %v", err)
+	}
+
+	custom, ok := got.(*tg.ReactionCustomEmoji)
+	if !ok || custom.DocumentID != 12345 {
+		t.Fatalf("reaction = %#v", got)
+	}
+
+	if _, err := reactionToTg(CustomEmoji("notanumber")); err == nil {
+		t.Fatal("expected error for invalid custom_emoji_id")
+	}
+}
+
+func TestChatJoinRequests(t *testing.T) {
+	for _, c := range []struct {
+		name     string
+		call     func(*Bot) error
+		approved bool
+	}{
+		{"approve", func(b *Bot) error {
+			return b.ApproveChatJoinRequest(context.Background(), tdlibChannel(50), 99)
+		}, true},
+		{"decline", func(b *Bot) error {
+			return b.DeclineChatJoinRequest(context.Background(), tdlibChannel(50), 99)
+		}, false},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			inv := newMockInvoker()
+			inv.reply(tg.MessagesHideChatJoinRequestRequestTypeID, okUpdates())
+
+			if err := c.call(newMockBot(inv)); err != nil {
+				t.Fatalf("call: %v", err)
+			}
+
+			var req tg.MessagesHideChatJoinRequestRequest
+
+			inv.decode(t, tg.MessagesHideChatJoinRequestRequestTypeID, &req)
+
+			if req.Approved != c.approved {
+				t.Fatalf("approved = %v, want %v", req.Approved, c.approved)
+			}
+		})
+	}
+}
+
+func TestBanUnbanChatSenderChat(t *testing.T) {
+	var p constant.TDLibPeerID
+
+	p.Channel(60)
+
+	senderID := int64(p)
+
+	for _, c := range []struct {
+		name string
+		call func(*Bot) error
+		view bool
+	}{
+		{"ban", func(b *Bot) error {
+			return b.BanChatSenderChat(context.Background(), tdlibChannel(50), senderID)
+		}, true},
+		{"unban", func(b *Bot) error {
+			return b.UnbanChatSenderChat(context.Background(), tdlibChannel(50), senderID)
+		}, false},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			inv := newMockInvoker()
+			inv.reply(tg.ChannelsEditBannedRequestTypeID, okUpdates())
+
+			if err := c.call(newMockBot(inv)); err != nil {
+				t.Fatalf("call: %v", err)
+			}
+
+			var req tg.ChannelsEditBannedRequest
+
+			inv.decode(t, tg.ChannelsEditBannedRequestTypeID, &req)
+
+			if _, ok := req.Participant.(*tg.InputPeerChannel); !ok {
+				t.Fatalf("participant = %#v, want channel", req.Participant)
+			}
+
+			if req.BannedRights.ViewMessages != c.view {
+				t.Fatalf("ViewMessages = %v, want %v", req.BannedRights.ViewMessages, c.view)
+			}
+		})
+	}
+}