494 lines
19 KiB
Go
494 lines
19 KiB
Go
package postgres
|
||
|
||
import (
|
||
"context"
|
||
"database/sql"
|
||
"errors"
|
||
"fmt"
|
||
"github.com/jackc/pgx/v5"
|
||
"strings"
|
||
"telesrv/internal/domain"
|
||
)
|
||
|
||
func (s *ChannelStore) SendChannelMessage(ctx context.Context, req domain.SendChannelMessageRequest) (domain.SendChannelMessageResult, error) {
|
||
if req.UserID == 0 || req.ChannelID == 0 || (strings.TrimSpace(req.Message) == "" && req.Action == nil && req.Media.IsZero()) {
|
||
return domain.SendChannelMessageResult{}, domain.ErrChannelInvalid
|
||
}
|
||
if req.Date == 0 {
|
||
req.Date = nowUnix()
|
||
}
|
||
var lastErr error
|
||
for attempt := 0; attempt < retryableChannelTxAttempts; attempt++ {
|
||
res, err := s.sendChannelMessageOnce(ctx, req)
|
||
if err == nil || !isRetryablePostgresTxError(err) || ctx.Err() != nil {
|
||
return res, err
|
||
}
|
||
lastErr = err
|
||
}
|
||
return domain.SendChannelMessageResult{}, lastErr
|
||
}
|
||
|
||
func (s *ChannelStore) sendChannelMessageOnce(ctx context.Context, req domain.SendChannelMessageRequest) (domain.SendChannelMessageResult, error) {
|
||
if req.RandomID != 0 {
|
||
if dup, found, err := s.duplicateChannelMessage(ctx, req.ChannelID, req.UserID, req.RandomID); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
} else if found {
|
||
return dup, nil
|
||
}
|
||
}
|
||
beginner, ok := s.db.(txBeginner)
|
||
if !ok {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("send channel message: db does not support transactions")
|
||
}
|
||
tx, err := beginner.Begin(ctx)
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("begin send channel: %w", err)
|
||
}
|
||
committed := false
|
||
defer func() {
|
||
if !committed {
|
||
_ = tx.Rollback(ctx)
|
||
}
|
||
}()
|
||
channel, member, err := s.getChannelForMember(ctx, tx, req.UserID, req.ChannelID)
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
fromBoostsApplied := 0
|
||
if channel.Megagroup {
|
||
fromBoostsApplied, err = countActiveUserBoostsForPeer(ctx, tx, req.UserID, domain.Peer{Type: domain.PeerTypeChannel, ID: req.ChannelID}, req.Date)
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
}
|
||
if domain.ChannelBannedRightsBlockMessage(req, channel, member, fromBoostsApplied) {
|
||
return domain.SendChannelMessageResult{}, domain.ErrChannelWriteForbidden
|
||
}
|
||
if !canSendChannelMessageWithBoost(channel, member, fromBoostsApplied) {
|
||
return domain.SendChannelMessageResult{}, domain.ErrChannelWriteForbidden
|
||
}
|
||
replyTo, err := s.resolveChannelReply(ctx, tx, req, member, channel, fromBoostsApplied)
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
if _, err := messageMetadataParamsFrom(req.Silent, req.NoForwards, replyTo, req.Forward); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
if wait := channelSlowModeWait(channel, member, req.Date); wait > 0 {
|
||
return domain.SendChannelMessageResult{}, domain.NewSlowModeWaitError(wait)
|
||
}
|
||
ttlPeriod := req.TTLPeriod
|
||
if ttlPeriod == 0 && req.Action == nil {
|
||
ttlPeriod = channel.TTLPeriod
|
||
}
|
||
expiresAt := 0
|
||
if ttlPeriod > 0 && req.Action == nil {
|
||
expiresAt = req.Date + ttlPeriod
|
||
}
|
||
var sendAs *domain.Peer
|
||
if req.SendAs != nil {
|
||
p := *req.SendAs
|
||
sendAs = &p
|
||
}
|
||
msgID, err := s.msgIDs.NextChannelMessageID(ctx, req.ChannelID)
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("allocate channel message id: %w", err)
|
||
}
|
||
pts, err := s.reserveChannelPts(ctx, tx, req.ChannelID)
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("allocate channel pts: %w", err)
|
||
}
|
||
var discussion *domain.SendChannelDiscussionResult
|
||
var discussionRef *domain.ChannelDiscussionRef
|
||
if channel.Broadcast && channel.LinkedChatID != 0 {
|
||
linked, err := getChannelByID(ctx, tx, channel.LinkedChatID)
|
||
if err == nil && !linked.Deleted && linked.Megagroup {
|
||
discussionMsgID, err := s.msgIDs.NextChannelMessageID(ctx, linked.ID)
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("allocate discussion message id: %w", err)
|
||
}
|
||
discussionPts, err := s.reserveChannelPts(ctx, tx, linked.ID)
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("allocate discussion pts: %w", err)
|
||
}
|
||
discussionRef = &domain.ChannelDiscussionRef{ChannelID: linked.ID, MessageID: discussionMsgID}
|
||
discussionMsg := domain.ChannelMessage{
|
||
ChannelID: linked.ID,
|
||
ID: discussionMsgID,
|
||
SenderUserID: req.UserID,
|
||
From: domain.Peer{Type: domain.PeerTypeChannel, ID: channel.ID},
|
||
Date: req.Date,
|
||
Silent: req.Silent,
|
||
NoForwards: req.NoForwards || channel.NoForwards || linked.NoForwards,
|
||
Body: req.Message,
|
||
Entities: append([]domain.MessageEntity(nil), req.Entities...),
|
||
Media: req.Media,
|
||
ViaBotID: req.ViaBotID,
|
||
GroupedID: req.GroupedID,
|
||
ReplyMarkup: req.ReplyMarkup,
|
||
TTLPeriod: ttlPeriod,
|
||
ExpiresAt: expiresAt,
|
||
Forward: &domain.MessageForward{From: domain.Peer{Type: domain.PeerTypeChannel, ID: channel.ID}, Date: req.Date, ChannelPost: msgID, SavedFrom: domain.Peer{Type: domain.PeerTypeChannel, ID: channel.ID}, SavedFromMsgID: msgID},
|
||
Pts: discussionPts,
|
||
}
|
||
discussionEvent := domain.ChannelUpdateEvent{
|
||
ChannelID: linked.ID,
|
||
Type: domain.ChannelUpdateNewMessage,
|
||
Pts: discussionPts,
|
||
PtsCount: 1,
|
||
Date: req.Date,
|
||
Message: discussionMsg,
|
||
}
|
||
if err := insertChannelMessageTx(ctx, tx, discussionMsg); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
if err := insertChannelEventTx(ctx, tx, discussionEvent); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
if err := insertChannelUnreadMentionsTx(ctx, tx, linked.ID, discussionMsg, req.UserID, req.MentionUserIDs); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
if _, err := tx.Exec(ctx, `UPDATE channels SET top_message_id = $2, pts = $3, updated_at = now() WHERE id = $1`, linked.ID, discussionMsgID, discussionPts); err != nil {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("update discussion channel top: %w", err)
|
||
}
|
||
linked.TopMessageID = discussionMsgID
|
||
linked.Pts = discussionPts
|
||
if err := upsertChannelDialogsForMessageTx(ctx, tx, linked, discussionMsg, 0); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
discussion = &domain.SendChannelDiscussionResult{
|
||
Channel: linked,
|
||
Message: discussionMsg,
|
||
Event: discussionEvent,
|
||
MentionUserIDs: append([]int64(nil), req.MentionUserIDs...),
|
||
}
|
||
} else if err != nil && !errors.Is(err, domain.ErrChannelInvalid) {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
}
|
||
msg := domain.ChannelMessage{
|
||
ChannelID: req.ChannelID,
|
||
ID: msgID,
|
||
RandomID: req.RandomID,
|
||
SenderUserID: req.UserID,
|
||
From: domain.Peer{Type: domain.PeerTypeUser, ID: req.UserID},
|
||
Date: req.Date,
|
||
Post: channel.Broadcast,
|
||
PostAuthor: channelPostAuthor(channel, req.PostAuthor),
|
||
Silent: req.Silent,
|
||
NoForwards: req.NoForwards || channel.NoForwards,
|
||
Body: req.Message,
|
||
Entities: append([]domain.MessageEntity(nil), req.Entities...),
|
||
Media: req.Media,
|
||
ViaBotID: req.ViaBotID,
|
||
GroupedID: req.GroupedID,
|
||
ReplyMarkup: req.ReplyMarkup,
|
||
TTLPeriod: ttlPeriod,
|
||
ExpiresAt: expiresAt,
|
||
ReplyTo: replyTo,
|
||
Forward: cloneMessageForward(req.Forward),
|
||
SendAs: sendAs,
|
||
Discussion: discussionRef,
|
||
Action: cloneChannelMessageAction(req.Action),
|
||
FromBoostsApplied: fromBoostsApplied,
|
||
Pts: pts,
|
||
}
|
||
if discussionRef != nil {
|
||
msg.Replies = &domain.ChannelMessageReplies{Comments: true, ChannelID: discussionRef.ChannelID, RepliesPts: discussion.Event.Pts}
|
||
}
|
||
event := domain.ChannelUpdateEvent{
|
||
ChannelID: req.ChannelID,
|
||
Type: domain.ChannelUpdateNewMessage,
|
||
Pts: pts,
|
||
PtsCount: 1,
|
||
Date: req.Date,
|
||
Message: msg,
|
||
SenderUserID: req.UserID,
|
||
}
|
||
if err := insertChannelMessageTx(ctx, tx, msg); err != nil {
|
||
if isUniqueViolation(err) {
|
||
dup, found, dupErr := s.duplicateChannelMessage(ctx, req.ChannelID, req.UserID, req.RandomID)
|
||
if dupErr != nil || !found {
|
||
return domain.SendChannelMessageResult{}, dupErr
|
||
}
|
||
dup.Duplicate = true
|
||
return dup, nil
|
||
}
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
if err := insertChannelEventTx(ctx, tx, event); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
mentionTargets := req.MentionUserIDs
|
||
// 回复某人 = 隐式 mention 该消息作者（官方语义：被回复者收到 @ 角标
|
||
// 且通知穿透群静音）。
|
||
if replyTo != nil && replyTo.MessageID > 0 {
|
||
if target, err := s.getChannelMessage(ctx, tx, req.ChannelID, replyTo.MessageID); err == nil &&
|
||
target.SenderUserID != 0 && target.SenderUserID != req.UserID {
|
||
mentionTargets = append(append([]int64(nil), mentionTargets...), target.SenderUserID)
|
||
}
|
||
}
|
||
if channel.Broadcast && !channel.Megagroup {
|
||
// broadcast 没有 @ 角标/readMentions UI，写入只会造成永远清不掉的
|
||
// 提及角标；讨论组联动消息走 megagroup 路径。
|
||
mentionTargets = nil
|
||
}
|
||
if err := insertChannelUnreadMentionsTx(ctx, tx, req.ChannelID, msg, req.UserID, mentionTargets); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
if err := updateForumTopicTopMessageTx(ctx, tx, req.ChannelID, msg); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
if _, err := tx.Exec(ctx, `UPDATE channels SET top_message_id = $2, pts = $3, updated_at = now() WHERE id = $1`, req.ChannelID, msgID, pts); err != nil {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("update channel top: %w", err)
|
||
}
|
||
channel.TopMessageID = msgID
|
||
channel.Pts = pts
|
||
if _, err := tx.Exec(ctx, `
|
||
UPDATE channel_members
|
||
SET slowmode_last_send_date = $3,
|
||
read_inbox_max_id = GREATEST(read_inbox_max_id, $4),
|
||
unread_mark = false,
|
||
updated_at = now()
|
||
WHERE channel_id = $1 AND user_id = $2`, req.ChannelID, req.UserID, req.Date, msgID); err != nil {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("update channel member slowmode send date: %w", err)
|
||
}
|
||
// channel_dialogs.unread_mark 非 NULL 时会在读取路径遮蔽 members 的值
|
||
// （COALESCE(d.unread_mark, m.unread_mark)），发送清除必须双表同步。
|
||
if _, err := tx.Exec(ctx, `
|
||
UPDATE channel_dialogs
|
||
SET unread_mark = false, updated_at = now()
|
||
WHERE channel_id = $1 AND user_id = $2 AND unread_mark`, req.ChannelID, req.UserID); err != nil {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("clear channel dialog unread mark on send: %w", err)
|
||
}
|
||
if err := upsertChannelDialogsForMessageTx(ctx, tx, channel, msg, req.UserID, req.SkipDeliveryUserIDs); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
if channel.Broadcast {
|
||
if err := s.insertChannelAdminLogTx(ctx, tx, domain.ChannelAdminLogEvent{
|
||
ChannelID: req.ChannelID,
|
||
UserID: req.UserID,
|
||
Date: req.Date,
|
||
Type: domain.ChannelAdminLogSendMessage,
|
||
Message: &msg,
|
||
Query: msg.Body,
|
||
}); err != nil {
|
||
return domain.SendChannelMessageResult{}, err
|
||
}
|
||
}
|
||
if err := tx.Commit(ctx); err != nil {
|
||
return domain.SendChannelMessageResult{}, fmt.Errorf("commit send channel: %w", err)
|
||
}
|
||
committed = true
|
||
var recipients []int64
|
||
if !req.SkipRecipientLookup {
|
||
recipients, _ = s.ListActiveChannelMemberIDs(ctx, req.UserID, req.ChannelID, 0)
|
||
recipients = filterSkippedChannelRecipients(recipients, channelDeliverySkipSet(req.SkipDeliveryUserIDs))
|
||
if discussion != nil {
|
||
discussion.Recipients, _ = s.ListActiveChannelMemberIDs(ctx, req.UserID, discussion.Channel.ID, 0)
|
||
}
|
||
}
|
||
return domain.SendChannelMessageResult{Channel: channel, Message: msg, Event: event, Recipients: recipients, Discussion: discussion, MentionUserIDs: append([]int64(nil), req.MentionUserIDs...), SkipDeliveryUserIDs: append([]int64(nil), req.SkipDeliveryUserIDs...)}, nil
|
||
}
|
||
|
||
func channelDeliverySkipSet(ids []int64) map[int64]struct{} {
|
||
if len(ids) == 0 {
|
||
return nil
|
||
}
|
||
out := make(map[int64]struct{}, len(ids))
|
||
for _, id := range ids {
|
||
if id != 0 {
|
||
out[id] = struct{}{}
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func filterSkippedChannelRecipients(recipients []int64, skip map[int64]struct{}) []int64 {
|
||
if len(recipients) == 0 || len(skip) == 0 {
|
||
return recipients
|
||
}
|
||
out := recipients[:0]
|
||
for _, id := range recipients {
|
||
if _, hidden := skip[id]; hidden {
|
||
continue
|
||
}
|
||
out = append(out, id)
|
||
}
|
||
return out
|
||
}
|
||
|
||
func (s *ChannelStore) duplicateChannelMessage(ctx context.Context, channelID, userID, randomID int64) (domain.SendChannelMessageResult, bool, error) {
|
||
row := s.db.QueryRow(ctx, `SELECT `+channelMessageColumns+` FROM channel_messages WHERE channel_id = $1 AND sender_user_id = $2 AND random_id = $3`, channelID, userID, randomID)
|
||
msg, err := scanChannelMessage(row)
|
||
if errors.Is(err, pgx.ErrNoRows) {
|
||
return domain.SendChannelMessageResult{}, false, nil
|
||
}
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, false, err
|
||
}
|
||
channel, err := getChannelByID(ctx, s.db, channelID)
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, false, err
|
||
}
|
||
event, err := s.eventForChannelMessage(ctx, channelID, msg.ID)
|
||
if err != nil {
|
||
return domain.SendChannelMessageResult{}, false, err
|
||
}
|
||
if event.Message.ID != 0 {
|
||
msg = event.Message
|
||
}
|
||
return domain.SendChannelMessageResult{Channel: channel, Message: msg, Event: event, Duplicate: true}, true, nil
|
||
}
|
||
|
||
func (s *ChannelStore) insertServiceMessage(ctx context.Context, tx pgx.Tx, channel domain.Channel, senderUserID int64, date int, action domain.ChannelMessageAction) (domain.ChannelMessage, domain.ChannelUpdateEvent, error) {
|
||
msgID, err := s.msgIDs.NextChannelMessageID(ctx, channel.ID)
|
||
if err != nil {
|
||
return domain.ChannelMessage{}, domain.ChannelUpdateEvent{}, fmt.Errorf("allocate channel service message id: %w", err)
|
||
}
|
||
action = channelServiceActionForMessage(channel.ID, msgID, action)
|
||
pts, err := s.reserveChannelPts(ctx, tx, channel.ID)
|
||
if err != nil {
|
||
return domain.ChannelMessage{}, domain.ChannelUpdateEvent{}, fmt.Errorf("allocate channel service pts: %w", err)
|
||
}
|
||
msg := domain.ChannelMessage{
|
||
ChannelID: channel.ID,
|
||
ID: msgID,
|
||
SenderUserID: senderUserID,
|
||
From: domain.Peer{Type: domain.PeerTypeUser, ID: senderUserID},
|
||
Date: date,
|
||
Post: channel.Broadcast,
|
||
Action: &action,
|
||
Pts: pts,
|
||
}
|
||
event := domain.ChannelUpdateEvent{
|
||
ChannelID: channel.ID,
|
||
Type: domain.ChannelUpdateNewMessage,
|
||
Pts: pts,
|
||
PtsCount: 1,
|
||
Date: date,
|
||
Message: msg,
|
||
SenderUserID: senderUserID,
|
||
UserIDs: append([]int64(nil), action.UserIDs...),
|
||
}
|
||
if err := insertChannelMessageTx(ctx, tx, msg); err != nil {
|
||
return domain.ChannelMessage{}, domain.ChannelUpdateEvent{}, err
|
||
}
|
||
if err := insertChannelEventTx(ctx, tx, event); err != nil {
|
||
return domain.ChannelMessage{}, domain.ChannelUpdateEvent{}, err
|
||
}
|
||
if _, err := tx.Exec(ctx, `UPDATE channels SET top_message_id = $2, pts = $3, updated_at = now() WHERE id = $1`, channel.ID, msgID, pts); err != nil {
|
||
return domain.ChannelMessage{}, domain.ChannelUpdateEvent{}, fmt.Errorf("update channel service top: %w", err)
|
||
}
|
||
return msg, event, nil
|
||
}
|
||
|
||
func channelServiceActionForMessage(channelID int64, msgID int, action domain.ChannelMessageAction) domain.ChannelMessageAction {
|
||
if action.Type == domain.ChannelActionStarGift && action.StarGift != nil {
|
||
g := *action.StarGift
|
||
if g.PeerChannelID == 0 {
|
||
g.PeerChannelID = channelID
|
||
}
|
||
if g.SavedID == 0 {
|
||
g.SavedID = int64(msgID)
|
||
}
|
||
action.StarGift = &g
|
||
}
|
||
return action
|
||
}
|
||
|
||
func insertChannelMessageTx(ctx context.Context, tx pgx.Tx, msg domain.ChannelMessage) error {
|
||
entities, err := encodeMessageEntities(msg.Entities)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
reply, err := marshalJSON(msg.ReplyTo, "{}")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
forward, err := marshalJSON(msg.Forward, "{}")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
action, err := marshalJSON(msg.Action, "{}")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
media, err := encodeMessageMedia(msg.Media)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
replyMarkup, err := encodeReplyMarkup(msg.ReplyMarkup)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
var sendAsType sql.NullString
|
||
var sendAsID sql.NullInt64
|
||
if msg.SendAs != nil && msg.SendAs.ID != 0 {
|
||
sendAsType = sql.NullString{String: string(msg.SendAs.Type), Valid: true}
|
||
sendAsID = sql.NullInt64{Int64: msg.SendAs.ID, Valid: true}
|
||
}
|
||
if msg.From.Type == "" {
|
||
msg.From = domain.Peer{Type: domain.PeerTypeUser, ID: msg.SenderUserID}
|
||
}
|
||
replyMsgID, replyTopID := 0, 0
|
||
replyPeerType := ""
|
||
replyPeerID := int64(0)
|
||
if msg.ReplyTo != nil {
|
||
replyMsgID = msg.ReplyTo.MessageID
|
||
replyTopID = msg.ReplyTo.TopMessageID
|
||
replyPeerType = string(msg.ReplyTo.Peer.Type)
|
||
replyPeerID = msg.ReplyTo.Peer.ID
|
||
}
|
||
discussionChannelID, discussionMessageID := int64(0), 0
|
||
if msg.Discussion != nil {
|
||
discussionChannelID = msg.Discussion.ChannelID
|
||
discussionMessageID = msg.Discussion.MessageID
|
||
}
|
||
if _, err := tx.Exec(ctx, `
|
||
INSERT INTO channel_messages (
|
||
channel_id, id, random_id, sender_user_id, from_peer_type, from_peer_id,
|
||
send_as_peer_type, send_as_peer_id, message_date, edit_date, post, silent, noforwards,
|
||
body, entities, reply_to, reply_to_msg_id, reply_to_peer_type, reply_to_peer_id, reply_to_top_id,
|
||
fwd_from, discussion_channel_id, discussion_message_id, action, pts, deleted, media, reply_markup, ttl_period, expires_at, post_author, via_bot_id, from_boosts_applied, grouped_id, saved_peer_type, saved_peer_id
|
||
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36)`,
|
||
msg.ChannelID, msg.ID, msg.RandomID, msg.SenderUserID, string(msg.From.Type), msg.From.ID,
|
||
sendAsType, sendAsID, msg.Date, msg.EditDate, msg.Post, msg.Silent, msg.NoForwards,
|
||
msg.Body, entities, reply, replyMsgID, replyPeerType, replyPeerID, replyTopID,
|
||
forward, discussionChannelID, discussionMessageID, action, msg.Pts, msg.Deleted, media, replyMarkup, msg.TTLPeriod, msg.ExpiresAt, msg.PostAuthor, msg.ViaBotID, msg.FromBoostsApplied, msg.GroupedID, string(msg.SavedPeer.Type), msg.SavedPeer.ID); err != nil {
|
||
return fmt.Errorf("insert channel message: %w", err)
|
||
}
|
||
// 共享媒体索引(迁移 0118):创建即按媒体类别建索引行,供 messages.search 媒体标签页。
|
||
if err := insertChannelMediaIndexTx(ctx, tx, msg.ChannelID, msg.ID, msg.Date, msg.Media, msg.Entities); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// channelPostAuthor 仅在 signatures 开启的 broadcast post 上保留作者签名。
|
||
func channelPostAuthor(channel domain.Channel, author string) string {
|
||
if !channel.Broadcast || !channel.Signatures {
|
||
return ""
|
||
}
|
||
return author
|
||
}
|
||
|
||
func canSendChannelMessage(channel domain.Channel, member domain.ChannelMember) bool {
|
||
return canSendChannelMessageWithBoost(channel, member, 0)
|
||
}
|
||
|
||
func canSendChannelMessageWithBoost(channel domain.Channel, member domain.ChannelMember, selfBoostsApplied int) bool {
|
||
if channel.Broadcast {
|
||
return canPostChannel(member)
|
||
}
|
||
if member.Role == domain.ChannelRoleCreator || member.Role == domain.ChannelRoleAdmin {
|
||
return true
|
||
}
|
||
if member.BannedRights.SendMessages {
|
||
return false
|
||
}
|
||
if !channel.DefaultBannedRights.SendMessages {
|
||
return true
|
||
}
|
||
return channel.BoostsUnrestrict > 0 && selfBoostsApplied >= channel.BoostsUnrestrict
|
||
}
|