759 lines
24 KiB
Go
759 lines
24 KiB
Go
package memory
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"sort"
|
||
"strings"
|
||
"telesrv/internal/domain"
|
||
)
|
||
|
||
func (s *ChannelStore) ListChannelHistory(_ context.Context, viewerUserID int64, filter domain.ChannelHistoryFilter) (domain.ChannelHistory, error) {
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
channel, member, _, err := s.channelForViewerLocked(viewerUserID, filter.ChannelID)
|
||
if err != nil {
|
||
return domain.ChannelHistory{}, err
|
||
}
|
||
limit := filter.Limit
|
||
if limit <= 0 || limit > 100 {
|
||
limit = 100
|
||
}
|
||
items := append([]domain.ChannelMessage(nil), s.messages[filter.ChannelID]...)
|
||
sort.Slice(items, func(i, j int) bool { return items[i].ID > items[j].ID })
|
||
// 静态过滤（不含 offset 锚点的方向条件），结果保持 id 降序。
|
||
query := strings.ToLower(strings.TrimSpace(filter.Query))
|
||
matched := make([]domain.ChannelMessage, 0, len(items))
|
||
monoforumUserView := channel.Monoforum && !member.CanManageDirectMessages()
|
||
anchorID := 0
|
||
if filter.IncludeHistoryClearAnchor &&
|
||
member.HistoryClearAnchorID > 0 &&
|
||
member.HistoryClearAnchorID == member.AvailableMinID {
|
||
anchorID = member.HistoryClearAnchorID
|
||
}
|
||
anchorSeen := false
|
||
for _, msg := range items {
|
||
isAnchor := anchorID > 0 && msg.ID == anchorID
|
||
if msg.Deleted && !isAnchor {
|
||
continue
|
||
}
|
||
if channel.Monoforum {
|
||
if monoforumUserView && msg.SavedPeer != (domain.Peer{Type: domain.PeerTypeUser, ID: viewerUserID}) {
|
||
continue
|
||
}
|
||
if !monoforumUserView && msg.SavedPeer.ID != 0 {
|
||
continue
|
||
}
|
||
}
|
||
if msg.ID < member.AvailableMinID || (msg.ID == member.AvailableMinID && !isAnchor) {
|
||
continue
|
||
}
|
||
if isAnchor {
|
||
msg = domain.ProjectChannelHistoryClearMessage(
|
||
msg,
|
||
filter.ChannelID,
|
||
member.HistoryClearAnchorID,
|
||
member.HistoryClearAnchorDate,
|
||
)
|
||
anchorSeen = true
|
||
}
|
||
if filter.PinnedOnly && !msg.Pinned {
|
||
continue
|
||
}
|
||
if filter.MusicOnly && !msg.Media.IsMusic() {
|
||
continue
|
||
}
|
||
if query != "" && !strings.Contains(strings.ToLower(msg.Body), query) {
|
||
continue
|
||
}
|
||
if filter.SenderUserID != 0 && msg.SenderUserID != filter.SenderUserID {
|
||
continue
|
||
}
|
||
if filter.MinDate > 0 && msg.Date <= filter.MinDate {
|
||
continue
|
||
}
|
||
if filter.MaxDate > 0 && msg.Date >= filter.MaxDate {
|
||
continue
|
||
}
|
||
if filter.MaxID > 0 && msg.ID > filter.MaxID {
|
||
continue
|
||
}
|
||
if filter.MinID > 0 && msg.ID <= filter.MinID {
|
||
continue
|
||
}
|
||
matched = append(matched, msg)
|
||
}
|
||
if anchorID > 0 && !anchorSeen {
|
||
msg := domain.ProjectChannelHistoryClearMessage(
|
||
domain.ChannelMessage{},
|
||
filter.ChannelID,
|
||
member.HistoryClearAnchorID,
|
||
member.HistoryClearAnchorDate,
|
||
)
|
||
if (filter.MinDate <= 0 || msg.Date > filter.MinDate) &&
|
||
(filter.MaxDate <= 0 || msg.Date < filter.MaxDate) &&
|
||
(filter.MaxID <= 0 || msg.ID <= filter.MaxID) &&
|
||
(filter.MinID <= 0 || msg.ID > filter.MinID) &&
|
||
!filter.PinnedOnly &&
|
||
!filter.MusicOnly &&
|
||
query == "" &&
|
||
filter.SenderUserID == 0 {
|
||
matched = append(matched, msg)
|
||
}
|
||
}
|
||
extraChannels := []domain.Channel(nil)
|
||
if channel.Monoforum && channel.LinkedMonoforumID != 0 {
|
||
if parent, ok := s.channels[channel.LinkedMonoforumID]; ok && !parent.Deleted {
|
||
extraChannels = append(extraChannels, cloneChannel(parent))
|
||
}
|
||
}
|
||
if filter.CountOnly {
|
||
return domain.ChannelHistory{
|
||
Channel: channel,
|
||
Self: member,
|
||
Channels: extraChannels,
|
||
Count: len(matched),
|
||
}, nil
|
||
}
|
||
// add_offset 决定加载方向（对齐 postgres ListChannelHistory）：
|
||
// >= 0 backward：锚点更旧方向（不含锚点），先跳过 add_offset 条
|
||
// < 0 且 +limit>0 around：以锚点为中心，向更新取 -add_offset 条 + 向更旧（含锚点）取 limit+add_offset 条
|
||
// 否则 forward：仅锚点更新方向
|
||
newerThanAnchor := func(msg domain.ChannelMessage) bool {
|
||
if filter.OffsetDate > 0 {
|
||
return msg.Date >= filter.OffsetDate
|
||
}
|
||
if filter.OffsetID > 0 {
|
||
return msg.ID > filter.OffsetID
|
||
}
|
||
return false
|
||
}
|
||
olderThanAnchor := func(msg domain.ChannelMessage, includeAnchor bool) bool {
|
||
if filter.OffsetDate > 0 {
|
||
return msg.Date < filter.OffsetDate
|
||
}
|
||
if filter.OffsetID > 0 {
|
||
if includeAnchor {
|
||
return msg.ID <= filter.OffsetID
|
||
}
|
||
return msg.ID < filter.OffsetID
|
||
}
|
||
return true
|
||
}
|
||
takeNewer := func(limit int) []domain.ChannelMessage {
|
||
if limit <= 0 {
|
||
return nil
|
||
}
|
||
// 升序收集锚点更新方向最近的 limit 条，再反转回降序。
|
||
asc := make([]domain.ChannelMessage, 0, limit)
|
||
for i := len(matched) - 1; i >= 0; i-- {
|
||
if !newerThanAnchor(matched[i]) {
|
||
continue
|
||
}
|
||
asc = append(asc, matched[i])
|
||
if len(asc) == limit {
|
||
break
|
||
}
|
||
}
|
||
out := make([]domain.ChannelMessage, 0, len(asc))
|
||
for i := len(asc) - 1; i >= 0; i-- {
|
||
out = append(out, asc[i])
|
||
}
|
||
return out
|
||
}
|
||
takeOlder := func(skip, limit int, includeAnchor bool) ([]domain.ChannelMessage, bool) {
|
||
if limit <= 0 {
|
||
return nil, false
|
||
}
|
||
out := make([]domain.ChannelMessage, 0, limit)
|
||
skipped := 0
|
||
for _, msg := range matched {
|
||
if !olderThanAnchor(msg, includeAnchor) {
|
||
continue
|
||
}
|
||
if skipped < skip {
|
||
skipped++
|
||
continue
|
||
}
|
||
if len(out) == limit {
|
||
return out, true
|
||
}
|
||
out = append(out, msg)
|
||
}
|
||
return out, false
|
||
}
|
||
addOffset := filter.AddOffset
|
||
var page []domain.ChannelMessage
|
||
hasMoreOlder := false
|
||
switch {
|
||
case addOffset < 0 && addOffset+limit > 0:
|
||
fwdLimit := -addOffset
|
||
if fwdLimit > limit {
|
||
fwdLimit = limit
|
||
}
|
||
bwdLimit := limit + addOffset
|
||
page = takeNewer(fwdLimit)
|
||
older, more := takeOlder(0, bwdLimit, true)
|
||
page = append(page, older...)
|
||
hasMoreOlder = more
|
||
case addOffset < 0:
|
||
page = takeNewer(limit)
|
||
default:
|
||
page, hasMoreOlder = takeOlder(addOffset, limit, false)
|
||
}
|
||
out := make([]domain.ChannelMessage, 0, len(page))
|
||
for _, msg := range page {
|
||
out = append(out, cloneChannelMessage(msg))
|
||
}
|
||
count := len(out)
|
||
if hasMoreOlder {
|
||
count = len(out) + 1
|
||
}
|
||
if filter.NeedTotalCount {
|
||
count = len(matched)
|
||
}
|
||
s.populateChannelMessageRepliesLocked(viewerUserID, filter.ChannelID, out)
|
||
s.populateChannelMessageReactionsLocked(viewerUserID, channel, out)
|
||
projectMemoryChannelHistoryClearMessages(channel.ID, member, out)
|
||
return domain.ChannelHistory{
|
||
Channel: channel,
|
||
Self: member,
|
||
Channels: extraChannels,
|
||
Messages: out,
|
||
Count: count,
|
||
}, nil
|
||
}
|
||
|
||
func (s *ChannelStore) SearchJoinedMessages(_ context.Context, viewerUserID int64, req domain.ChannelGlobalSearchRequest) (domain.ChannelHistory, error) {
|
||
query := strings.ToLower(strings.TrimSpace(req.Query))
|
||
if viewerUserID == 0 || (query == "" && !req.MusicOnly) {
|
||
return domain.ChannelHistory{}, domain.ErrChannelInvalid
|
||
}
|
||
if req.Limit <= 0 || req.Limit > domain.MaxChannelGlobalSearchLimit {
|
||
req.Limit = domain.MaxChannelGlobalSearchLimit
|
||
}
|
||
type hit struct {
|
||
channel domain.Channel
|
||
message domain.ChannelMessage
|
||
}
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
hits := make([]hit, 0, req.Limit+1)
|
||
channelIDs := make(map[int64]struct{}, len(req.ChannelIDs))
|
||
for _, id := range req.ChannelIDs {
|
||
channelIDs[id] = struct{}{}
|
||
}
|
||
for channelID, channel := range s.channels {
|
||
if req.RestrictChannelIDs {
|
||
if _, ok := channelIDs[channelID]; !ok {
|
||
continue
|
||
}
|
||
}
|
||
if channel.Deleted {
|
||
continue
|
||
}
|
||
if req.BroadcastsOnly && (!channel.Broadcast || channel.Megagroup) {
|
||
continue
|
||
}
|
||
if req.GroupsOnly && !channel.Megagroup {
|
||
continue
|
||
}
|
||
member, ok := s.members[channelID][viewerUserID]
|
||
joined := ok && member.Status == domain.ChannelMemberActive && !member.BannedRights.ViewMessages
|
||
publicPreview := req.AllowPublicPreview && s.publicPreviewableChannelLocked(channel) &&
|
||
(!ok || member.Status != domain.ChannelMemberKicked && !member.BannedRights.ViewMessages)
|
||
if !joined && !publicPreview {
|
||
continue
|
||
}
|
||
if req.HasFolderID {
|
||
dialog, ok := s.dialogs[viewerUserID][channelID]
|
||
if !ok || dialog.FolderID != req.FolderID {
|
||
continue
|
||
}
|
||
}
|
||
for _, msg := range s.messages[channelID] {
|
||
if msg.Deleted {
|
||
continue
|
||
}
|
||
if query == "" && !req.MusicOnly || query != "" && strings.TrimSpace(msg.Body) == "" {
|
||
continue
|
||
}
|
||
if joined && member.AvailableMinID > 0 && msg.ID <= member.AvailableMinID {
|
||
continue
|
||
}
|
||
if req.MinDate > 0 && msg.Date <= req.MinDate {
|
||
continue
|
||
}
|
||
if req.MaxDate > 0 && msg.Date >= req.MaxDate {
|
||
continue
|
||
}
|
||
if !channelGlobalSearchAfterCursor(msg, req) {
|
||
continue
|
||
}
|
||
if req.MusicOnly && !msg.Media.IsMusic() {
|
||
continue
|
||
}
|
||
if query != "" && !strings.Contains(strings.ToLower(msg.Body), query) {
|
||
continue
|
||
}
|
||
hits = append(hits, hit{channel: channel, message: cloneChannelMessage(msg)})
|
||
}
|
||
}
|
||
sort.Slice(hits, func(i, j int) bool {
|
||
a, b := hits[i].message, hits[j].message
|
||
if a.Date != b.Date {
|
||
return a.Date > b.Date
|
||
}
|
||
if a.ChannelID != b.ChannelID {
|
||
return a.ChannelID > b.ChannelID
|
||
}
|
||
return a.ID > b.ID
|
||
})
|
||
out := domain.ChannelHistory{Count: len(hits)}
|
||
if out.Count > req.Limit {
|
||
out.Count = req.Limit + 1
|
||
hits = hits[:req.Limit]
|
||
}
|
||
channelSeen := make(map[int64]struct{}, len(hits))
|
||
for _, h := range hits {
|
||
out.Messages = append(out.Messages, h.message)
|
||
if _, ok := channelSeen[h.channel.ID]; ok {
|
||
continue
|
||
}
|
||
channelSeen[h.channel.ID] = struct{}{}
|
||
out.Channels = append(out.Channels, h.channel)
|
||
}
|
||
s.populateChannelMessagesReactionsLocked(viewerUserID, out.Channels, out.Messages)
|
||
return out, nil
|
||
}
|
||
|
||
func (s *ChannelStore) GetChannelMessages(_ context.Context, viewerUserID, channelID int64, ids []int) (domain.ChannelHistory, error) {
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
// viewer 口径：公开频道非成员可预览读取(与 ListChannelHistory 一致 + 与 PG 实现对齐)，
|
||
// 否则查看他人公开「个人频道」时 channels.getMessages 被拒、资料页整块不显示。
|
||
channel, member, _, err := s.channelForViewerLocked(viewerUserID, channelID)
|
||
if err != nil {
|
||
return domain.ChannelHistory{}, err
|
||
}
|
||
if len(ids) == 0 {
|
||
return domain.ChannelHistory{Channel: channel, Self: member}, nil
|
||
}
|
||
if len(ids) > domain.MaxGetMessageIDs {
|
||
return domain.ChannelHistory{}, domain.ErrChannelInvalid
|
||
}
|
||
wanted := make(map[int]struct{}, len(ids))
|
||
for _, id := range ids {
|
||
if id <= 0 || id > domain.MaxMessageBoxID {
|
||
return domain.ChannelHistory{}, domain.ErrMessageIDInvalid
|
||
}
|
||
wanted[id] = struct{}{}
|
||
}
|
||
messages := make([]domain.ChannelMessage, 0, len(wanted))
|
||
for _, msg := range s.messages[channelID] {
|
||
if _, ok := wanted[msg.ID]; !ok {
|
||
continue
|
||
}
|
||
if msg.ID == member.HistoryClearAnchorID &&
|
||
member.HistoryClearAnchorID == member.AvailableMinID {
|
||
messages = append(messages, domain.ProjectChannelHistoryClearMessage(
|
||
msg,
|
||
channelID,
|
||
member.HistoryClearAnchorID,
|
||
member.HistoryClearAnchorDate,
|
||
))
|
||
delete(wanted, msg.ID)
|
||
continue
|
||
}
|
||
if msg.Deleted || msg.ID <= member.AvailableMinID {
|
||
continue
|
||
}
|
||
if !channelMessageVisibleToViewerLocked(channel, member, viewerUserID, msg) {
|
||
continue
|
||
}
|
||
messages = append(messages, cloneChannelMessage(msg))
|
||
delete(wanted, msg.ID)
|
||
}
|
||
if member.HistoryClearAnchorID > 0 &&
|
||
member.HistoryClearAnchorID == member.AvailableMinID {
|
||
if _, ok := wanted[member.HistoryClearAnchorID]; ok {
|
||
messages = append(messages, domain.ProjectChannelHistoryClearMessage(
|
||
domain.ChannelMessage{},
|
||
channelID,
|
||
member.HistoryClearAnchorID,
|
||
member.HistoryClearAnchorDate,
|
||
))
|
||
}
|
||
}
|
||
sort.Slice(messages, func(i, j int) bool { return messages[i].ID > messages[j].ID })
|
||
s.populateChannelMessageRepliesLocked(viewerUserID, channelID, messages)
|
||
s.populateChannelMessageReactionsLocked(viewerUserID, channel, messages)
|
||
projectMemoryChannelHistoryClearMessages(channelID, member, messages)
|
||
return domain.ChannelHistory{Channel: channel, Self: member, Messages: messages, Count: len(messages)}, nil
|
||
}
|
||
|
||
func projectMemoryChannelHistoryClearMessages(channelID int64, member domain.ChannelMember, messages []domain.ChannelMessage) {
|
||
if member.HistoryClearAnchorID <= 0 ||
|
||
member.HistoryClearAnchorID != member.AvailableMinID {
|
||
return
|
||
}
|
||
for i := range messages {
|
||
if messages[i].ID != member.HistoryClearAnchorID {
|
||
continue
|
||
}
|
||
messages[i] = domain.ProjectChannelHistoryClearMessage(
|
||
messages[i],
|
||
channelID,
|
||
member.HistoryClearAnchorID,
|
||
member.HistoryClearAnchorDate,
|
||
)
|
||
}
|
||
}
|
||
|
||
func (s *ChannelStore) ListStoryMessageForwards(_ context.Context, req domain.StoryMessageForwardListRequest) (domain.StoryMessageForwardList, error) {
|
||
if req.ViewerUserID == 0 || req.Owner.ID == 0 || req.StoryID <= 0 || req.StoryID > domain.MaxStoryID {
|
||
return domain.StoryMessageForwardList{}, domain.ErrStoryIDInvalid
|
||
}
|
||
if req.Owner.Type != domain.PeerTypeUser && req.Owner.Type != domain.PeerTypeChannel {
|
||
return domain.StoryMessageForwardList{}, domain.ErrStoryPeerInvalid
|
||
}
|
||
if err := domain.ValidateStoryInteractionOffset(req.Offset, false); err != nil {
|
||
return domain.StoryMessageForwardList{}, err
|
||
}
|
||
limit := clampStoryInteractionLimit(req.Limit)
|
||
cursor := parseStoryInteractionCursor(req.Offset)
|
||
s.mu.RLock()
|
||
views := make([]domain.StoryView, 0)
|
||
for channelID, channel := range s.channels {
|
||
if channel.Deleted || strings.TrimSpace(channel.Username) == "" || (!channel.Broadcast && !channel.Megagroup) {
|
||
continue
|
||
}
|
||
for _, msg := range s.messages[channelID] {
|
||
if !messageSharesStory(msg, req.Owner, req.StoryID) {
|
||
continue
|
||
}
|
||
views = append(views, domain.StoryView{
|
||
Owner: req.Owner,
|
||
StoryID: req.StoryID,
|
||
Date: msg.Date,
|
||
PublicForward: &domain.StoryPublicForward{
|
||
Message: cloneChannelMessage(msg),
|
||
},
|
||
})
|
||
}
|
||
}
|
||
s.mu.RUnlock()
|
||
sortStoryViewsForList(views, req.ReactionsFirst, req.ForwardsFirst)
|
||
page, nextOffset := pageStoryViews(views, limit, cursor, req.ReactionsFirst, req.ForwardsFirst)
|
||
return domain.StoryMessageForwardList{Count: len(views), Forwards: page, NextOffset: nextOffset}, nil
|
||
}
|
||
|
||
func messageSharesStory(msg domain.ChannelMessage, owner domain.Peer, storyID int) bool {
|
||
return !msg.Deleted &&
|
||
msg.Media != nil &&
|
||
msg.Media.Kind == domain.MessageMediaKindStory &&
|
||
msg.Media.Story != nil &&
|
||
msg.Media.Story.Peer == owner &&
|
||
msg.Media.Story.ID == storyID
|
||
}
|
||
|
||
func (s *ChannelStore) GetChannelMessageForInlineBot(_ context.Context, botID, channelID int64, id int) (domain.Channel, domain.ChannelMessage, bool, error) {
|
||
if botID == 0 || channelID == 0 || id <= 0 || id > domain.MaxMessageBoxID {
|
||
return domain.Channel{}, domain.ChannelMessage{}, false, nil
|
||
}
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
channel, ok := s.channels[channelID]
|
||
if !ok || channel.Deleted {
|
||
return domain.Channel{}, domain.ChannelMessage{}, false, nil
|
||
}
|
||
msg, ok := s.findMessageLocked(channelID, id)
|
||
if !ok || msg.Deleted || msg.Action != nil || msg.ViaBotID != botID {
|
||
return domain.Channel{}, domain.ChannelMessage{}, false, nil
|
||
}
|
||
return channel, cloneChannelMessage(msg), true, nil
|
||
}
|
||
|
||
func (s *ChannelStore) GetDiscussionMessage(_ context.Context, viewerUserID, channelID int64, msgID int) (domain.ChannelDiscussionMessage, error) {
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
source, member, err := s.channelAndMemberLocked(viewerUserID, channelID)
|
||
if err != nil {
|
||
return domain.ChannelDiscussionMessage{}, err
|
||
}
|
||
msg, ok := s.findMessageLocked(channelID, msgID)
|
||
if !ok || msg.Deleted || msg.ID <= member.AvailableMinID {
|
||
return domain.ChannelDiscussionMessage{}, domain.ErrMessageIDInvalid
|
||
}
|
||
result := domain.ChannelDiscussionMessage{PostChannel: source, DiscussionChannel: source, Channels: []domain.Channel{source}}
|
||
targetChannel := source
|
||
targetMsg := msg
|
||
targetMember := member
|
||
if source.Broadcast {
|
||
if msg.Discussion == nil || msg.Discussion.ChannelID == 0 || msg.Discussion.MessageID == 0 {
|
||
return result, nil
|
||
}
|
||
linked, ok := s.channels[msg.Discussion.ChannelID]
|
||
if !ok || linked.Deleted {
|
||
return result, nil
|
||
}
|
||
linkedMsg, ok := s.findMessageLocked(linked.ID, msg.Discussion.MessageID)
|
||
if !ok || linkedMsg.Deleted {
|
||
return result, nil
|
||
}
|
||
targetChannel = linked
|
||
targetMsg = linkedMsg
|
||
if linkedMember, ok := s.members[linked.ID][viewerUserID]; ok {
|
||
targetMember = linkedMember
|
||
} else {
|
||
targetMember = domain.ChannelMember{}
|
||
}
|
||
result.DiscussionChannel = linked
|
||
result.Channels = []domain.Channel{source, linked}
|
||
}
|
||
items := []domain.ChannelMessage{cloneChannelMessage(targetMsg)}
|
||
s.populateChannelMessageRepliesLocked(viewerUserID, targetChannel.ID, items)
|
||
s.populateChannelMessageReactionsLocked(viewerUserID, targetChannel, items)
|
||
if stats := s.channelMessageRepliesLocked(viewerUserID, targetChannel.ID, targetMsg); stats != nil {
|
||
result.MaxID = stats.MaxID
|
||
}
|
||
result.ReadInboxMaxID = targetMember.ReadInboxMaxID
|
||
result.ReadOutboxMaxID = targetMember.ReadOutboxMaxID
|
||
result.UnreadCount = s.channelThreadUnreadCountLocked(viewerUserID, targetChannel.ID, targetMsg.ID, targetMember.ReadInboxMaxID)
|
||
result.Messages = items
|
||
return result, nil
|
||
}
|
||
|
||
// ResolveDiscussionReadTarget returns the minimal linked-thread mapping and
|
||
// current read boundary without building reply/reaction aggregates.
|
||
func (s *ChannelStore) ResolveDiscussionReadTarget(_ context.Context, viewerUserID, sourceChannelID int64, sourceMessageID, readMaxID int) (domain.ChannelDiscussionReadTarget, error) {
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
source, sourceMember, err := s.channelAndMemberOrLinkedGuestLocked(viewerUserID, sourceChannelID)
|
||
if err != nil {
|
||
return domain.ChannelDiscussionReadTarget{}, err
|
||
}
|
||
msg, ok := s.findMessageLocked(sourceChannelID, sourceMessageID)
|
||
if !ok || msg.Deleted || msg.ID <= sourceMember.AvailableMinID {
|
||
return domain.ChannelDiscussionReadTarget{}, domain.ErrMessageIDInvalid
|
||
}
|
||
targetChannelID, rootID := sourceChannelID, sourceMessageID
|
||
if source.Broadcast && msg.Discussion != nil {
|
||
if msg.Discussion.ChannelID == 0 || msg.Discussion.MessageID == 0 {
|
||
return domain.ChannelDiscussionReadTarget{}, domain.ErrMessageIDInvalid
|
||
}
|
||
linked, exists := s.channels[msg.Discussion.ChannelID]
|
||
root, rootExists := s.findMessageLocked(msg.Discussion.ChannelID, msg.Discussion.MessageID)
|
||
if !exists || linked.Deleted || !linked.Megagroup || linked.Broadcast || !rootExists || root.Deleted {
|
||
return domain.ChannelDiscussionReadTarget{}, domain.ErrMessageIDInvalid
|
||
}
|
||
targetChannelID, rootID = linked.ID, root.ID
|
||
}
|
||
targetMember := sourceMember
|
||
if targetChannelID != sourceChannelID {
|
||
_, targetMember, err = s.channelAndMemberLocked(viewerUserID, targetChannelID)
|
||
if errors.Is(err, domain.ErrChannelPrivate) {
|
||
guestMember, allowed, guestErr := s.linkedDiscussionGuestLocked(viewerUserID, s.channels[targetChannelID])
|
||
switch {
|
||
case guestErr != nil:
|
||
err = guestErr
|
||
case allowed:
|
||
targetMember = guestMember
|
||
err = nil
|
||
default:
|
||
err = domain.ErrChannelPrivate
|
||
}
|
||
}
|
||
}
|
||
if err != nil {
|
||
return domain.ChannelDiscussionReadTarget{}, err
|
||
}
|
||
effectiveMaxID := readMaxID
|
||
if target := s.channels[targetChannelID]; effectiveMaxID <= 0 || effectiveMaxID > target.TopMessageID {
|
||
effectiveMaxID = target.TopMessageID
|
||
}
|
||
return domain.ChannelDiscussionReadTarget{
|
||
ChannelID: targetChannelID,
|
||
RootID: rootID,
|
||
AlreadyRead: effectiveMaxID <= targetMember.ReadInboxMaxID && !targetMember.UnreadMark,
|
||
Guest: targetMember.Guest,
|
||
}, nil
|
||
}
|
||
|
||
func (s *ChannelStore) findMessageLocked(channelID int64, id int) (domain.ChannelMessage, bool) {
|
||
for _, msg := range s.messages[channelID] {
|
||
if msg.ID == id {
|
||
return msg, true
|
||
}
|
||
}
|
||
return domain.ChannelMessage{}, false
|
||
}
|
||
|
||
func (s *ChannelStore) findMessageIndexLocked(channelID int64, id int) (int, bool) {
|
||
for i, msg := range s.messages[channelID] {
|
||
if msg.ID == id {
|
||
return i, true
|
||
}
|
||
}
|
||
return 0, false
|
||
}
|
||
|
||
func pageChannelMessageHistory(base []domain.ChannelMessage, filter domain.ChannelRepliesFilter, limit int) []domain.ChannelMessage {
|
||
if limit <= 0 || len(base) == 0 {
|
||
return nil
|
||
}
|
||
switch messageHistoryLoadType(filter.AddOffset, limit) {
|
||
case messageHistoryLoadForward:
|
||
return forwardChannelMessageHistory(base, filter, limit)
|
||
case messageHistoryLoadAround:
|
||
forwardLimit := -filter.AddOffset
|
||
if forwardLimit > limit {
|
||
forwardLimit = limit
|
||
}
|
||
backwardLimit := limit + filter.AddOffset
|
||
if backwardLimit < 0 {
|
||
backwardLimit = 0
|
||
}
|
||
page := make([]domain.ChannelMessage, 0, limit)
|
||
page = append(page, forwardChannelMessageHistory(base, filter, forwardLimit)...)
|
||
page = append(page, backwardChannelMessageHistory(base, filter, backwardLimit, true)...)
|
||
sort.SliceStable(page, func(i, j int) bool { return channelMessageLess(page[i], page[j]) })
|
||
return page
|
||
default:
|
||
start := filter.AddOffset
|
||
if start < 0 {
|
||
start = 0
|
||
}
|
||
candidates := backwardChannelMessageHistory(base, filter, limit+start, false)
|
||
if start >= len(candidates) {
|
||
return nil
|
||
}
|
||
return candidates[start:]
|
||
}
|
||
}
|
||
|
||
func backwardChannelMessageHistory(base []domain.ChannelMessage, filter domain.ChannelRepliesFilter, limit int, includeOffset bool) []domain.ChannelMessage {
|
||
if limit <= 0 {
|
||
return nil
|
||
}
|
||
out := make([]domain.ChannelMessage, 0, limit)
|
||
for _, msg := range base {
|
||
if !channelMessageBeforeHistoryOffset(msg, filter, includeOffset) {
|
||
continue
|
||
}
|
||
out = append(out, msg)
|
||
if len(out) == limit {
|
||
break
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func forwardChannelMessageHistory(base []domain.ChannelMessage, filter domain.ChannelRepliesFilter, limit int) []domain.ChannelMessage {
|
||
if limit <= 0 {
|
||
return nil
|
||
}
|
||
out := make([]domain.ChannelMessage, 0, limit)
|
||
for i := len(base) - 1; i >= 0; i-- {
|
||
msg := base[i]
|
||
if !channelMessageAfterHistoryOffset(msg, filter) {
|
||
continue
|
||
}
|
||
out = append(out, msg)
|
||
if len(out) == limit {
|
||
break
|
||
}
|
||
}
|
||
sort.SliceStable(out, func(i, j int) bool { return channelMessageLess(out[i], out[j]) })
|
||
return out
|
||
}
|
||
|
||
func channelMessageBeforeHistoryOffset(msg domain.ChannelMessage, filter domain.ChannelRepliesFilter, includeOffset bool) bool {
|
||
if filter.OffsetDate > 0 {
|
||
if includeOffset {
|
||
return msg.Date <= filter.OffsetDate
|
||
}
|
||
return msg.Date < filter.OffsetDate
|
||
}
|
||
if filter.OffsetID <= 0 {
|
||
return true
|
||
}
|
||
if includeOffset {
|
||
return msg.ID <= filter.OffsetID
|
||
}
|
||
return msg.ID < filter.OffsetID
|
||
}
|
||
|
||
func channelMessageAfterHistoryOffset(msg domain.ChannelMessage, filter domain.ChannelRepliesFilter) bool {
|
||
if filter.OffsetDate > 0 {
|
||
return msg.Date >= filter.OffsetDate
|
||
}
|
||
if filter.OffsetID <= 0 {
|
||
return false
|
||
}
|
||
return msg.ID > filter.OffsetID
|
||
}
|
||
|
||
func channelMessageLess(a, b domain.ChannelMessage) bool {
|
||
if a.Date != b.Date {
|
||
return a.Date > b.Date
|
||
}
|
||
return a.ID > b.ID
|
||
}
|
||
|
||
func (s *ChannelStore) visibleTopMessageIDLocked(userID int64, channel domain.Channel) int {
|
||
return s.visibleTopMessageIDForMemberLocked(channel, s.members[channel.ID][userID])
|
||
}
|
||
|
||
func (s *ChannelStore) visibleTopMessageIDForMemberLocked(channel domain.Channel, member domain.ChannelMember) int {
|
||
for i := len(s.messages[channel.ID]) - 1; i >= 0; i-- {
|
||
msg := s.messages[channel.ID][i]
|
||
if !msg.Deleted && msg.ID > member.AvailableMinID {
|
||
return msg.ID
|
||
}
|
||
}
|
||
if member.HistoryClearAnchorID > 0 &&
|
||
member.HistoryClearAnchorID == member.AvailableMinID {
|
||
return member.HistoryClearAnchorID
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (s *ChannelStore) channelMessageForMemberLocked(userID, channelID int64, messageID int) (domain.ChannelMessage, bool) {
|
||
member, ok := s.members[channelID][userID]
|
||
if !ok {
|
||
msg, found := s.findMessageLocked(channelID, messageID)
|
||
if !found || msg.Deleted {
|
||
return domain.ChannelMessage{}, false
|
||
}
|
||
return cloneChannelMessage(msg), true
|
||
}
|
||
if member.HistoryClearAnchorID > 0 &&
|
||
member.HistoryClearAnchorID == member.AvailableMinID &&
|
||
messageID == member.HistoryClearAnchorID {
|
||
source, _ := s.findMessageLocked(channelID, messageID)
|
||
return domain.ProjectChannelHistoryClearMessage(
|
||
source,
|
||
channelID,
|
||
member.HistoryClearAnchorID,
|
||
member.HistoryClearAnchorDate,
|
||
), true
|
||
}
|
||
msg, ok := s.findMessageLocked(channelID, messageID)
|
||
if !ok || msg.Deleted || msg.ID <= member.AvailableMinID {
|
||
return domain.ChannelMessage{}, false
|
||
}
|
||
return cloneChannelMessage(msg), true
|
||
}
|
||
|
||
func (s *ChannelStore) topicHasVisibleMessagesLocked(channelID int64, topicID int) bool {
|
||
for _, msg := range s.messages[channelID] {
|
||
if msg.Deleted {
|
||
continue
|
||
}
|
||
if msg.ID == topicID || (msg.ReplyTo != nil && msg.ReplyTo.TopMessageID == topicID) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|