320 lines
9.6 KiB
Go
320 lines
9.6 KiB
Go
package rpc
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"github.com/iamxvbaba/td/tg"
|
||
"telesrv/internal/domain"
|
||
)
|
||
|
||
func (r *Router) onMessagesReadMessageContents(ctx context.Context, ids []int) (*tg.MessagesAffectedMessages, error) {
|
||
id, _ := AuthKeyIDFrom(ctx)
|
||
sessionID, _ := SessionIDFrom(ctx)
|
||
userID, _, err := r.currentUserID(ctx)
|
||
if err != nil {
|
||
return nil, internalErr()
|
||
}
|
||
if len(ids) > maxGetMessagesIDs {
|
||
return nil, limitInvalidErr()
|
||
}
|
||
for _, msgID := range ids {
|
||
if msgID <= 0 || msgID > domain.MaxMessageBoxID {
|
||
return nil, messageIDInvalidErr()
|
||
}
|
||
}
|
||
read := domain.ReadMessageContentsResult{OwnerUserID: userID}
|
||
if r.deps.Messages != nil {
|
||
read, err = r.deps.Messages.ReadMessageContents(ctx, userID, domain.ReadMessageContentsRequest{
|
||
OwnerUserID: userID,
|
||
IDs: ids,
|
||
Date: int(r.clock.Now().Unix()),
|
||
OriginAuthKeyID: rawAuthKeyIDForOrigin(ctx),
|
||
OriginSessionID: sessionID,
|
||
})
|
||
if err != nil {
|
||
if errors.Is(err, domain.ErrMessageIDInvalid) {
|
||
return nil, messageIDInvalidErr()
|
||
}
|
||
return nil, internalErr()
|
||
}
|
||
}
|
||
affected := &tg.MessagesAffectedMessages{Pts: read.Event.Pts, PtsCount: read.Event.PtsCount}
|
||
if read.Event.Pts == 0 {
|
||
affected, err = r.affectedMessages(ctx, id, userID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
now := int(r.clock.Now().Unix())
|
||
if contentIDs := readMessageContentIDs(read.MessageIDs); len(contentIDs) > 0 {
|
||
contents := &tg.UpdateReadMessagesContents{
|
||
Messages: contentIDs,
|
||
Pts: affected.Pts,
|
||
PtsCount: affected.PtsCount,
|
||
}
|
||
contents.SetDate(now)
|
||
r.pushUserUpdatesIfNoReliableDispatch(ctx, userID, &tg.Updates{
|
||
Updates: []tg.UpdateClass{contents},
|
||
Date: now,
|
||
Seq: 0,
|
||
})
|
||
}
|
||
// voice/round 的对端发送者收到自己视角 box id 的内容已读回执，
|
||
// 让 sender 端的"未听"蓝点消失；reliable outbox 部署下由 worker 投递。
|
||
for _, event := range read.SenderEvents {
|
||
if update := tgOtherUpdateFromEvent(event); update != nil {
|
||
r.pushUserUpdatesIfNoReliableDispatch(ctx, event.UserID, &tg.Updates{
|
||
Updates: []tg.UpdateClass{update},
|
||
Date: now,
|
||
Seq: 0,
|
||
})
|
||
}
|
||
}
|
||
return affected, nil
|
||
}
|
||
|
||
func readMessageContentIDs(ids []int) []int {
|
||
if len(ids) == 0 {
|
||
return nil
|
||
}
|
||
out := make([]int, 0, len(ids))
|
||
seen := make(map[int]struct{}, len(ids))
|
||
for _, id := range ids {
|
||
if id <= 0 {
|
||
continue
|
||
}
|
||
if _, ok := seen[id]; ok {
|
||
continue
|
||
}
|
||
seen[id] = struct{}{}
|
||
out = append(out, id)
|
||
}
|
||
return out
|
||
}
|
||
|
||
func (r *Router) onMessagesGetUnreadMentions(ctx context.Context, req *tg.MessagesGetUnreadMentionsRequest) (tg.MessagesMessagesClass, error) {
|
||
userID, _, err := r.currentUserID(ctx)
|
||
if err != nil {
|
||
return nil, internalErr()
|
||
}
|
||
if req.Limit < 0 || req.Limit > domain.MaxChannelUnreadMentionsLimit {
|
||
return nil, limitInvalidErr()
|
||
}
|
||
if req.TopMsgID < 0 || req.TopMsgID > domain.MaxMessageBoxID ||
|
||
req.OffsetID < 0 || req.OffsetID > domain.MaxMessageBoxID ||
|
||
req.MaxID < 0 || req.MaxID > domain.MaxMessageBoxID ||
|
||
req.MinID < 0 || req.MinID > domain.MaxMessageBoxID {
|
||
return nil, messageIDInvalidErr()
|
||
}
|
||
peer, err := r.checkedDomainPeerFromInputPeer(ctx, userID, req.Peer)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if peer.Type == domain.PeerTypeChannel && r.deps.Channels != nil {
|
||
history, err := r.deps.Channels.GetUnreadMentions(ctx, userID, domain.ChannelUnreadMentionsFilter{
|
||
ChannelID: peer.ID,
|
||
TopMsgID: req.TopMsgID,
|
||
OffsetID: req.OffsetID,
|
||
AddOffset: req.AddOffset,
|
||
Limit: req.Limit,
|
||
MaxID: req.MaxID,
|
||
MinID: req.MinID,
|
||
})
|
||
if err != nil {
|
||
return nil, channelInvalidErr(err)
|
||
}
|
||
return r.tgChannelHistoryMessages(ctx, userID, r.enrichChannelHistory(ctx, userID, history)), nil
|
||
}
|
||
out := &tg.MessagesMessages{
|
||
Messages: []tg.MessageClass{},
|
||
Chats: r.chatsForInputPeer(ctx, userID, req.Peer),
|
||
Users: []tg.UserClass{},
|
||
}
|
||
r.applyPeerReadModelsToMessages(ctx, userID, out)
|
||
return out, nil
|
||
}
|
||
|
||
func (r *Router) onMessagesReadMentions(ctx context.Context, req *tg.MessagesReadMentionsRequest) (*tg.MessagesAffectedHistory, error) {
|
||
id, _ := AuthKeyIDFrom(ctx)
|
||
userID, _, err := r.currentUserID(ctx)
|
||
if err != nil {
|
||
return nil, internalErr()
|
||
}
|
||
if req.TopMsgID < 0 || req.TopMsgID > domain.MaxMessageBoxID {
|
||
return nil, messageIDInvalidErr()
|
||
}
|
||
peer, err := r.checkedDomainPeerFromInputPeer(ctx, userID, req.Peer)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if peer.Type == domain.PeerTypeChannel && r.deps.Channels != nil {
|
||
res, err := r.deps.Channels.ReadMentions(ctx, userID, domain.ReadChannelMentionsRequest{
|
||
UserID: userID,
|
||
ChannelID: peer.ID,
|
||
TopMsgID: req.TopMsgID,
|
||
Limit: domain.MaxChannelReadMentionsBatch,
|
||
})
|
||
if err != nil {
|
||
return nil, channelInvalidErr(err)
|
||
}
|
||
return &tg.MessagesAffectedHistory{Pts: res.ChannelPts, PtsCount: 0, Offset: res.Offset}, nil
|
||
}
|
||
return r.affectedHistory(ctx, id, userID, 0)
|
||
}
|
||
|
||
func (r *Router) affectedMessages(ctx context.Context, authKeyID [8]byte, userID int64) (*tg.MessagesAffectedMessages, error) {
|
||
st := domain.UpdateState{Date: int(r.clock.Now().Unix())}
|
||
if r.deps.Updates != nil {
|
||
var err error
|
||
st, err = r.deps.Updates.GetState(ctx, authKeyID, userID)
|
||
if err != nil {
|
||
return nil, internalErr()
|
||
}
|
||
}
|
||
return &tg.MessagesAffectedMessages{Pts: st.Pts, PtsCount: 0}, nil
|
||
}
|
||
|
||
func (r *Router) affectedHistory(ctx context.Context, authKeyID [8]byte, userID int64, offset int) (*tg.MessagesAffectedHistory, error) {
|
||
st := domain.UpdateState{Date: int(r.clock.Now().Unix())}
|
||
if r.deps.Updates != nil {
|
||
var err error
|
||
st, err = r.deps.Updates.GetState(ctx, authKeyID, userID)
|
||
if err != nil {
|
||
return nil, internalErr()
|
||
}
|
||
}
|
||
return &tg.MessagesAffectedHistory{Pts: st.Pts, PtsCount: 0, Offset: offset}, nil
|
||
}
|
||
|
||
func (r *Router) pushReadHistoryEvent(ctx context.Context, userID int64, event domain.UpdateEvent) {
|
||
if r.hasReliableUpdateDispatch() {
|
||
return
|
||
}
|
||
if r.deps.Sessions == nil || userID == 0 {
|
||
return
|
||
}
|
||
var update tg.UpdateClass
|
||
switch event.Type {
|
||
case domain.UpdateEventReadHistoryInbox:
|
||
update = tgReadHistoryInboxUpdate(event)
|
||
case domain.UpdateEventReadHistoryOutbox:
|
||
update = tgReadHistoryOutboxUpdate(event)
|
||
case domain.UpdateEventReadChannelDiscussionInbox:
|
||
if event.Peer.ID != 0 {
|
||
update = &tg.UpdateReadChannelDiscussionInbox{ChannelID: event.Peer.ID, TopMsgID: event.TopMsgID, ReadMaxID: event.MaxID}
|
||
}
|
||
}
|
||
if update == nil {
|
||
return
|
||
}
|
||
updates := &tg.Updates{
|
||
Updates: appendAuxPtsBookkeeping([]tg.UpdateClass{update}, event),
|
||
Date: event.Date,
|
||
Seq: 0,
|
||
}
|
||
r.pushUserMessage(ctx, userID, "push read history", updates)
|
||
}
|
||
|
||
func (r *Router) pushCurrentReadHistoryEvent(ctx context.Context, event domain.UpdateEvent) {
|
||
var update tg.UpdateClass
|
||
switch event.Type {
|
||
case domain.UpdateEventReadHistoryInbox:
|
||
update = tgReadHistoryInboxUpdate(event)
|
||
case domain.UpdateEventReadHistoryOutbox:
|
||
update = tgReadHistoryOutboxUpdate(event)
|
||
case domain.UpdateEventReadChannelDiscussionInbox:
|
||
if event.Peer.ID != 0 {
|
||
update = &tg.UpdateReadChannelDiscussionInbox{ChannelID: event.Peer.ID, TopMsgID: event.TopMsgID, ReadMaxID: event.MaxID}
|
||
}
|
||
}
|
||
if update == nil {
|
||
return
|
||
}
|
||
r.pushCurrentSessionMessage(ctx, "push current read history", &tg.Updates{
|
||
Updates: appendAuxPtsBookkeeping([]tg.UpdateClass{update}, event),
|
||
Date: event.Date,
|
||
Seq: 0,
|
||
})
|
||
}
|
||
|
||
// bookkeepAuxPtsForCurrentSession 把 aux 事件占用的账号 pts 同步给发起
|
||
// session：可靠 outbox 投递排除了当前 session，而这些 RPC 的响应多为
|
||
// Bool/无 pts 容器，不补这一条当前设备的水位会落后并误判后续空洞。
|
||
func (r *Router) bookkeepAuxPtsForCurrentSession(ctx context.Context, events ...domain.UpdateEvent) {
|
||
updates := make([]tg.UpdateClass, 0, len(events))
|
||
date := 0
|
||
for _, event := range events {
|
||
before := len(updates)
|
||
updates = appendAuxPtsBookkeeping(updates, event)
|
||
if len(updates) > before && date == 0 {
|
||
date = event.Date
|
||
}
|
||
}
|
||
if len(updates) == 0 {
|
||
return
|
||
}
|
||
if date == 0 {
|
||
date = int(r.clock.Now().Unix())
|
||
}
|
||
r.pushCurrentSessionMessage(ctx, "aux pts bookkeeping", &tg.Updates{
|
||
Updates: updates,
|
||
Date: date,
|
||
Seq: 0,
|
||
})
|
||
}
|
||
|
||
func tgReadHistoryInbox(event domain.UpdateEvent) *tg.UpdateReadHistoryInbox {
|
||
peer := tgPeer(event.Peer)
|
||
if peer == nil {
|
||
return nil
|
||
}
|
||
return &tg.UpdateReadHistoryInbox{
|
||
Peer: peer,
|
||
MaxID: event.MaxID,
|
||
StillUnreadCount: event.StillUnreadCount,
|
||
Pts: event.Pts,
|
||
PtsCount: event.PtsCount,
|
||
}
|
||
}
|
||
|
||
func tgReadHistoryInboxUpdate(event domain.UpdateEvent) tg.UpdateClass {
|
||
if event.Peer.Type == domain.PeerTypeChannel && event.Peer.ID != 0 {
|
||
// updateReadChannelInbox.pts 只能是 channel pts；账号 pts 在这里
|
||
// 是错误语义（TDesktop 拿它与本地 channel pts 比较），缺失时宁可
|
||
// 填 0 让客户端回退本地估算。
|
||
update := &tg.UpdateReadChannelInbox{
|
||
ChannelID: event.Peer.ID,
|
||
MaxID: event.MaxID,
|
||
StillUnreadCount: event.StillUnreadCount,
|
||
Pts: event.ChannelPts,
|
||
}
|
||
if event.FolderID > 0 {
|
||
update.SetFolderID(event.FolderID)
|
||
}
|
||
return update
|
||
}
|
||
return tgReadHistoryInbox(event)
|
||
}
|
||
|
||
func tgReadHistoryOutbox(event domain.UpdateEvent) *tg.UpdateReadHistoryOutbox {
|
||
peer := tgPeer(event.Peer)
|
||
if peer == nil {
|
||
return nil
|
||
}
|
||
return &tg.UpdateReadHistoryOutbox{
|
||
Peer: peer,
|
||
MaxID: event.MaxID,
|
||
Pts: event.Pts,
|
||
PtsCount: event.PtsCount,
|
||
}
|
||
}
|
||
|
||
func tgReadHistoryOutboxUpdate(event domain.UpdateEvent) tg.UpdateClass {
|
||
if event.Peer.Type == domain.PeerTypeChannel && event.Peer.ID != 0 {
|
||
return &tg.UpdateReadChannelOutbox{
|
||
ChannelID: event.Peer.ID,
|
||
MaxID: event.MaxID,
|
||
}
|
||
}
|
||
return tgReadHistoryOutbox(event)
|
||
}
|