3120 lines
86 KiB
Go
3120 lines
86 KiB
Go
// Package memory 提供 store 各接口的内存实现，用作测试替身与本地开发兜底。
|
||
//
|
||
// 与 store/postgres、store/redisstore 对称：store 主包只定义接口与 DTO，
|
||
// 三种后端实现各自独立成包。
|
||
package memory
|
||
|
||
import (
|
||
"context"
|
||
"encoding/binary"
|
||
"fmt"
|
||
"hash"
|
||
"hash/fnv"
|
||
"sort"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"telesrv/internal/domain"
|
||
"telesrv/internal/store"
|
||
)
|
||
|
||
// AuthKeyStore 是 store.AuthKeyStore 的内存实现。
|
||
type AuthKeyStore struct {
|
||
mu sync.RWMutex
|
||
keys map[[8]byte]store.AuthKeyData
|
||
}
|
||
|
||
// NewAuthKeyStore 创建内存 AuthKeyStore。
|
||
func NewAuthKeyStore() *AuthKeyStore {
|
||
return &AuthKeyStore{keys: make(map[[8]byte]store.AuthKeyData)}
|
||
}
|
||
|
||
func (s *AuthKeyStore) Save(_ context.Context, k store.AuthKeyData) error {
|
||
s.mu.Lock()
|
||
s.keys[k.ID] = k
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *AuthKeyStore) Get(_ context.Context, id [8]byte) (store.AuthKeyData, bool, error) {
|
||
s.mu.RLock()
|
||
k, ok := s.keys[id]
|
||
s.mu.RUnlock()
|
||
return k, ok, nil
|
||
}
|
||
|
||
// SessionStore 是 store.SessionStore 的内存实现。
|
||
type SessionStore struct {
|
||
mu sync.RWMutex
|
||
sessions map[int64]store.SessionData
|
||
}
|
||
|
||
// NewSessionStore 创建内存 SessionStore。
|
||
func NewSessionStore() *SessionStore {
|
||
return &SessionStore{sessions: make(map[int64]store.SessionData)}
|
||
}
|
||
|
||
func (s *SessionStore) Save(_ context.Context, d store.SessionData) error {
|
||
s.mu.Lock()
|
||
s.sessions[d.ID] = d
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *SessionStore) Get(_ context.Context, id int64) (store.SessionData, bool, error) {
|
||
s.mu.RLock()
|
||
d, ok := s.sessions[id]
|
||
s.mu.RUnlock()
|
||
return d, ok, nil
|
||
}
|
||
|
||
func (s *SessionStore) Delete(_ context.Context, id int64) error {
|
||
s.mu.Lock()
|
||
delete(s.sessions, id)
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
// UpdateStateStore 是 store.UpdateStateStore 的内存实现。
|
||
type UpdateStateStore struct {
|
||
mu sync.RWMutex
|
||
states map[updateStateKey]domain.UpdateState
|
||
}
|
||
|
||
// UpdateEventStore 是 store.UpdateEventStore 的内存实现。
|
||
type UpdateEventStore struct {
|
||
mu sync.RWMutex
|
||
events map[int64][]domain.UpdateEvent
|
||
}
|
||
|
||
type updateStateKey struct {
|
||
authKeyID [8]byte
|
||
userID int64
|
||
}
|
||
|
||
// NewUpdateEventStore 创建内存 UpdateEventStore。
|
||
func NewUpdateEventStore() *UpdateEventStore {
|
||
return &UpdateEventStore{events: make(map[int64][]domain.UpdateEvent)}
|
||
}
|
||
|
||
func (s *UpdateEventStore) Append(_ context.Context, userID int64, event domain.UpdateEvent) error {
|
||
event.UserID = userID
|
||
event.Message = cloneMessage(event.Message)
|
||
event.MessageIDs = append([]int(nil), event.MessageIDs...)
|
||
event.Peers = append([]domain.Peer(nil), event.Peers...)
|
||
event.Users = append([]domain.User(nil), event.Users...)
|
||
event.Channels = append([]domain.Channel(nil), event.Channels...)
|
||
s.mu.Lock()
|
||
s.events[userID] = append(s.events[userID], event)
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *UpdateEventStore) ListAfter(_ context.Context, userID int64, pts, limit int) ([]domain.UpdateEvent, error) {
|
||
s.mu.RLock()
|
||
items := append([]domain.UpdateEvent(nil), s.events[userID]...)
|
||
s.mu.RUnlock()
|
||
out := make([]domain.UpdateEvent, 0, len(items))
|
||
for _, event := range items {
|
||
if event.Pts <= pts {
|
||
continue
|
||
}
|
||
event.Message = cloneMessage(event.Message)
|
||
event.MessageIDs = append([]int(nil), event.MessageIDs...)
|
||
event.Peers = append([]domain.Peer(nil), event.Peers...)
|
||
event.Users = append([]domain.User(nil), event.Users...)
|
||
event.Channels = append([]domain.Channel(nil), event.Channels...)
|
||
out = append(out, event)
|
||
if limit > 0 && len(out) >= limit {
|
||
break
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *UpdateEventStore) Current(_ context.Context, userID int64) (int, error) {
|
||
s.mu.RLock()
|
||
items := s.events[userID]
|
||
s.mu.RUnlock()
|
||
max := 0
|
||
for _, event := range items {
|
||
if event.Pts > max {
|
||
max = event.Pts
|
||
}
|
||
}
|
||
return max, nil
|
||
}
|
||
|
||
// MaxContiguousPts 返回从 1 起无空洞的最大 pts（内存版按 pts_count 连续扫描）。
|
||
func (s *UpdateEventStore) MaxContiguousPts(_ context.Context, userID int64) (int, error) {
|
||
s.mu.RLock()
|
||
nextByStart := make(map[int]int, len(s.events[userID]))
|
||
for _, event := range s.events[userID] {
|
||
count := event.PtsCount
|
||
if count <= 0 {
|
||
count = 1
|
||
}
|
||
nextByStart[event.Pts-count] = event.Pts
|
||
}
|
||
s.mu.RUnlock()
|
||
contiguous := 0
|
||
for {
|
||
next, ok := nextByStart[contiguous]
|
||
if !ok {
|
||
break
|
||
}
|
||
contiguous = next
|
||
}
|
||
return contiguous, nil
|
||
}
|
||
|
||
func (s *UpdateEventStore) AdvanceContiguousPts(ctx context.Context, userID int64) (int, error) {
|
||
return s.MaxContiguousPts(ctx, userID)
|
||
}
|
||
|
||
// NewUpdateStateStore 创建内存 UpdateStateStore。
|
||
func NewUpdateStateStore() *UpdateStateStore {
|
||
return &UpdateStateStore{states: make(map[updateStateKey]domain.UpdateState)}
|
||
}
|
||
|
||
func (s *UpdateStateStore) Get(_ context.Context, id [8]byte, userID int64) (domain.UpdateState, bool, error) {
|
||
s.mu.RLock()
|
||
st, ok := s.states[updateStateKey{authKeyID: id, userID: userID}]
|
||
s.mu.RUnlock()
|
||
return st, ok, nil
|
||
}
|
||
|
||
func (s *UpdateStateStore) Save(_ context.Context, id [8]byte, userID int64, st domain.UpdateState) error {
|
||
s.mu.Lock()
|
||
s.states[updateStateKey{authKeyID: id, userID: userID}] = st
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *UpdateStateStore) Delete(_ context.Context, id [8]byte, userID int64) error {
|
||
s.mu.Lock()
|
||
delete(s.states, updateStateKey{authKeyID: id, userID: userID})
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *UpdateStateStore) DeleteAuthKey(_ context.Context, id [8]byte) error {
|
||
s.mu.Lock()
|
||
for k := range s.states {
|
||
if k.authKeyID == id {
|
||
delete(s.states, k)
|
||
}
|
||
}
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
// TempAuthKeyBindingStore 是 store.TempAuthKeyBindingStore 的内存实现。
|
||
type TempAuthKeyBindingStore struct {
|
||
mu sync.RWMutex
|
||
m map[[8]byte]domain.TempAuthKeyBinding
|
||
}
|
||
|
||
// NewTempAuthKeyBindingStore 创建内存 TempAuthKeyBindingStore。
|
||
func NewTempAuthKeyBindingStore() *TempAuthKeyBindingStore {
|
||
return &TempAuthKeyBindingStore{m: make(map[[8]byte]domain.TempAuthKeyBinding)}
|
||
}
|
||
|
||
func (s *TempAuthKeyBindingStore) Save(_ context.Context, b domain.TempAuthKeyBinding) error {
|
||
b.EncryptedMessage = append([]byte(nil), b.EncryptedMessage...)
|
||
s.mu.Lock()
|
||
s.m[b.TempAuthKeyID] = b
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *TempAuthKeyBindingStore) GetByTemp(_ context.Context, tempAuthKeyID [8]byte) (domain.TempAuthKeyBinding, bool, error) {
|
||
s.mu.RLock()
|
||
b, ok := s.m[tempAuthKeyID]
|
||
s.mu.RUnlock()
|
||
if !ok {
|
||
return domain.TempAuthKeyBinding{}, false, nil
|
||
}
|
||
b.EncryptedMessage = append([]byte(nil), b.EncryptedMessage...)
|
||
return b, true, nil
|
||
}
|
||
|
||
// ContactStore 是 store.ContactStore 的内存实现。
|
||
type ContactStore struct {
|
||
mu sync.RWMutex
|
||
m map[int64]domain.ContactList
|
||
blocks map[int64]map[int64]domain.BlockedContact
|
||
}
|
||
|
||
// NewContactStore 创建内存 ContactStore。
|
||
func NewContactStore() *ContactStore {
|
||
return &ContactStore{
|
||
m: make(map[int64]domain.ContactList),
|
||
blocks: make(map[int64]map[int64]domain.BlockedContact),
|
||
}
|
||
}
|
||
|
||
func (s *ContactStore) ListByUser(_ context.Context, userID int64) (domain.ContactList, error) {
|
||
s.mu.RLock()
|
||
list := s.m[userID]
|
||
s.mu.RUnlock()
|
||
list.Contacts = cloneContacts(list.Contacts)
|
||
list.Hash = contactListHash(list.Contacts)
|
||
return list, nil
|
||
}
|
||
|
||
func (s *ContactStore) Get(_ context.Context, userID, contactUserID int64) (domain.Contact, bool, error) {
|
||
s.mu.RLock()
|
||
list := s.m[userID]
|
||
s.mu.RUnlock()
|
||
for _, contact := range list.Contacts {
|
||
if contact.User.ID == contactUserID {
|
||
return cloneContact(contact), true, nil
|
||
}
|
||
}
|
||
return domain.Contact{}, false, nil
|
||
}
|
||
|
||
func (s *ContactStore) GetMany(_ context.Context, userID int64, contactUserIDs []int64) (map[int64]domain.Contact, error) {
|
||
out := make(map[int64]domain.Contact, len(contactUserIDs))
|
||
if userID == 0 || len(contactUserIDs) == 0 {
|
||
return out, nil
|
||
}
|
||
want := make(map[int64]struct{}, len(contactUserIDs))
|
||
for _, id := range contactUserIDs {
|
||
if id != 0 {
|
||
want[id] = struct{}{}
|
||
}
|
||
}
|
||
s.mu.RLock()
|
||
list := s.m[userID]
|
||
s.mu.RUnlock()
|
||
for _, contact := range list.Contacts {
|
||
if _, ok := want[contact.User.ID]; ok {
|
||
out[contact.User.ID] = cloneContact(contact)
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *ContactStore) GetReverseContacts(_ context.Context, userID int64, ownerUserIDs []int64) (map[int64]domain.Contact, error) {
|
||
out := make(map[int64]domain.Contact, len(ownerUserIDs))
|
||
if userID == 0 || len(ownerUserIDs) == 0 {
|
||
return out, nil
|
||
}
|
||
want := make(map[int64]struct{}, len(ownerUserIDs))
|
||
for _, id := range ownerUserIDs {
|
||
if id != 0 {
|
||
want[id] = struct{}{}
|
||
}
|
||
}
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
for ownerID := range want {
|
||
for _, contact := range s.m[ownerID].Contacts {
|
||
if contact.User.ID == userID {
|
||
out[ownerID] = cloneContact(contact)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *ContactStore) Upsert(_ context.Context, userID int64, input domain.ContactInput) (domain.Contact, error) {
|
||
contact := domain.Contact{
|
||
User: domain.User{
|
||
ID: input.ContactUserID,
|
||
Phone: input.Phone,
|
||
FirstName: input.FirstName,
|
||
LastName: input.LastName,
|
||
Contact: true,
|
||
},
|
||
FirstName: input.FirstName,
|
||
LastName: input.LastName,
|
||
Phone: input.Phone,
|
||
Note: input.Note,
|
||
NoteEntities: append([]domain.MessageEntity(nil), input.NoteEntities...),
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
reverse := s.m[input.ContactUserID]
|
||
for i := range reverse.Contacts {
|
||
if reverse.Contacts[i].User.ID == userID {
|
||
reverse.Contacts[i].Mutual = true
|
||
reverse.Contacts[i].User.Mutual = true
|
||
contact.Mutual = true
|
||
contact.User.Mutual = true
|
||
s.m[input.ContactUserID] = reverse
|
||
break
|
||
}
|
||
}
|
||
for i, existing := range list.Contacts {
|
||
if existing.User.ID != input.ContactUserID {
|
||
continue
|
||
}
|
||
contact.User.AccessHash = existing.User.AccessHash
|
||
contact.User.Username = existing.User.Username
|
||
contact.User.CountryCode = existing.User.CountryCode
|
||
contact.User.Verified = existing.User.Verified
|
||
contact.User.Support = existing.User.Support
|
||
if contact.Phone == "" {
|
||
contact.User.Phone = existing.User.Phone
|
||
}
|
||
if contact.FirstName == "" {
|
||
contact.User.FirstName = existing.User.FirstName
|
||
}
|
||
if contact.LastName == "" {
|
||
contact.User.LastName = existing.User.LastName
|
||
}
|
||
list.Contacts[i] = contact
|
||
list.Hash = contactListHash(list.Contacts)
|
||
s.m[userID] = list
|
||
return cloneContact(contact), nil
|
||
}
|
||
list.Contacts = append(list.Contacts, contact)
|
||
list.Hash = contactListHash(list.Contacts)
|
||
s.m[userID] = list
|
||
return cloneContact(contact), nil
|
||
}
|
||
|
||
func (s *ContactStore) UpsertMany(ctx context.Context, userID int64, inputs []domain.ContactInput) ([]domain.Contact, error) {
|
||
if len(inputs) == 0 {
|
||
return nil, nil
|
||
}
|
||
out := make([]domain.Contact, 0, len(inputs))
|
||
for _, input := range inputs {
|
||
contact, err := s.Upsert(ctx, userID, input)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
out = append(out, contact)
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *ContactStore) UpdateNote(_ context.Context, userID, contactUserID int64, note string, entities []domain.MessageEntity) (domain.Contact, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
for i := range list.Contacts {
|
||
if list.Contacts[i].User.ID != contactUserID {
|
||
continue
|
||
}
|
||
list.Contacts[i].Note = note
|
||
list.Contacts[i].NoteEntities = append([]domain.MessageEntity(nil), entities...)
|
||
list.Hash = contactListHash(list.Contacts)
|
||
s.m[userID] = list
|
||
return cloneContact(list.Contacts[i]), true, nil
|
||
}
|
||
return domain.Contact{}, false, nil
|
||
}
|
||
|
||
func (s *ContactStore) SetPersonalPhoto(_ context.Context, userID, contactUserID int64, photoID int64, date int) (domain.Contact, bool, error) {
|
||
_ = date
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
for i := range list.Contacts {
|
||
if list.Contacts[i].User.ID != contactUserID {
|
||
continue
|
||
}
|
||
list.Contacts[i].User.PhotoID = photoID
|
||
list.Contacts[i].User.PhotoPersonal = photoID != 0
|
||
list.Hash = contactListHash(list.Contacts)
|
||
s.m[userID] = list
|
||
return cloneContact(list.Contacts[i]), true, nil
|
||
}
|
||
return domain.Contact{}, false, nil
|
||
}
|
||
|
||
func (s *ContactStore) PersonalPhotos(_ context.Context, userID int64, contactUserIDs []int64) (map[int64]domain.ProfilePhotoRef, error) {
|
||
out := make(map[int64]domain.ProfilePhotoRef, len(contactUserIDs))
|
||
if userID == 0 || len(contactUserIDs) == 0 {
|
||
return out, nil
|
||
}
|
||
want := make(map[int64]struct{}, len(contactUserIDs))
|
||
for _, id := range contactUserIDs {
|
||
if id != 0 {
|
||
want[id] = struct{}{}
|
||
}
|
||
}
|
||
s.mu.RLock()
|
||
list := s.m[userID]
|
||
s.mu.RUnlock()
|
||
for _, contact := range list.Contacts {
|
||
if _, ok := want[contact.User.ID]; !ok || contact.User.PhotoID == 0 {
|
||
continue
|
||
}
|
||
out[contact.User.ID] = domain.ProfilePhotoRef{
|
||
PhotoID: contact.User.PhotoID,
|
||
DCID: contact.User.PhotoDCID,
|
||
Stripped: append([]byte(nil), contact.User.PhotoStripped...),
|
||
Personal: true,
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *ContactStore) Delete(_ context.Context, userID int64, contactUserIDs []int64) (int, error) {
|
||
remove := make(map[int64]struct{}, len(contactUserIDs))
|
||
for _, id := range contactUserIDs {
|
||
if id != 0 {
|
||
remove[id] = struct{}{}
|
||
}
|
||
}
|
||
if len(remove) == 0 {
|
||
return 0, nil
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
out := list.Contacts[:0]
|
||
deleted := 0
|
||
for _, contact := range list.Contacts {
|
||
if _, ok := remove[contact.User.ID]; ok {
|
||
deleted++
|
||
if reverse := s.m[contact.User.ID]; len(reverse.Contacts) > 0 {
|
||
for i := range reverse.Contacts {
|
||
if reverse.Contacts[i].User.ID == userID {
|
||
reverse.Contacts[i].Mutual = false
|
||
reverse.Contacts[i].User.Mutual = false
|
||
}
|
||
}
|
||
reverse.Hash = contactListHash(reverse.Contacts)
|
||
s.m[contact.User.ID] = reverse
|
||
}
|
||
continue
|
||
}
|
||
out = append(out, contact)
|
||
}
|
||
list.Contacts = out
|
||
list.Hash = contactListHash(list.Contacts)
|
||
s.m[userID] = list
|
||
return deleted, nil
|
||
}
|
||
|
||
func (s *ContactStore) Block(_ context.Context, userID, blockedUserID int64, date int) (bool, error) {
|
||
if userID == 0 || blockedUserID == 0 || userID == blockedUserID {
|
||
return false, nil
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
if s.blocks[userID] == nil {
|
||
s.blocks[userID] = make(map[int64]domain.BlockedContact)
|
||
}
|
||
_, existed := s.blocks[userID][blockedUserID]
|
||
s.blocks[userID][blockedUserID] = domain.BlockedContact{
|
||
User: domain.User{ID: blockedUserID},
|
||
Date: date,
|
||
}
|
||
return !existed, nil
|
||
}
|
||
|
||
func (s *ContactStore) Unblock(_ context.Context, userID, blockedUserID int64) (bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
if s.blocks[userID] == nil {
|
||
return false, nil
|
||
}
|
||
_, existed := s.blocks[userID][blockedUserID]
|
||
delete(s.blocks[userID], blockedUserID)
|
||
return existed, nil
|
||
}
|
||
|
||
func (s *ContactStore) IsBlocked(_ context.Context, userID, blockedUserID int64) (bool, error) {
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
_, blocked := s.blocks[userID][blockedUserID]
|
||
return blocked, nil
|
||
}
|
||
|
||
func (s *ContactStore) ListBlocked(_ context.Context, userID int64, offset, limit int) (domain.BlockedContactList, error) {
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
items := make([]domain.BlockedContact, 0, len(s.blocks[userID]))
|
||
for _, item := range s.blocks[userID] {
|
||
items = append(items, item)
|
||
}
|
||
sort.Slice(items, func(i, j int) bool {
|
||
if items[i].Date == items[j].Date {
|
||
return items[i].User.ID > items[j].User.ID
|
||
}
|
||
return items[i].Date > items[j].Date
|
||
})
|
||
total := len(items)
|
||
if offset < 0 {
|
||
offset = 0
|
||
}
|
||
if offset >= len(items) {
|
||
return domain.BlockedContactList{Count: total}, nil
|
||
}
|
||
if limit <= 0 || limit > len(items)-offset {
|
||
limit = len(items) - offset
|
||
}
|
||
out := append([]domain.BlockedContact(nil), items[offset:offset+limit]...)
|
||
return domain.BlockedContactList{Blocked: out, Count: total}, nil
|
||
}
|
||
|
||
// SaveList 保存一份用户通讯录，供测试和本地替身使用。
|
||
func (s *ContactStore) SaveList(_ context.Context, userID int64, list domain.ContactList) error {
|
||
list.Contacts = cloneContacts(list.Contacts)
|
||
list.Hash = contactListHash(list.Contacts)
|
||
s.mu.Lock()
|
||
s.m[userID] = list
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
// DialogStore 是 store.DialogStore 的内存实现。
|
||
type DialogStore struct {
|
||
mu sync.RWMutex
|
||
m map[int64]domain.DialogList
|
||
drafts map[int64]map[dialogDraftKey]domain.DialogDraft
|
||
folders map[int64]map[int]domain.DialogFolder
|
||
folderOrder map[int64][]int
|
||
folderTags map[int64]bool
|
||
}
|
||
|
||
type dialogDraftKey struct {
|
||
peerType domain.PeerType
|
||
peerID int64
|
||
topMessageID int
|
||
}
|
||
|
||
// NewDialogStore 创建内存 DialogStore。
|
||
func NewDialogStore() *DialogStore {
|
||
return &DialogStore{
|
||
m: make(map[int64]domain.DialogList),
|
||
drafts: make(map[int64]map[dialogDraftKey]domain.DialogDraft),
|
||
folders: make(map[int64]map[int]domain.DialogFolder),
|
||
folderOrder: make(map[int64][]int),
|
||
folderTags: make(map[int64]bool),
|
||
}
|
||
}
|
||
|
||
func (s *DialogStore) ListByUser(_ context.Context, userID int64, filter domain.DialogFilter) (domain.DialogList, error) {
|
||
s.mu.RLock()
|
||
list := s.m[userID]
|
||
s.mu.RUnlock()
|
||
list.Dialogs = cloneDialogs(list.Dialogs)
|
||
list.Messages = cloneMessages(list.Messages)
|
||
list.Users = append([]domain.User(nil), list.Users...)
|
||
return filterDialogList(list, filter), nil
|
||
}
|
||
|
||
func (s *DialogStore) ListByPeers(_ context.Context, userID int64, peers []domain.Peer) (domain.DialogList, error) {
|
||
s.mu.RLock()
|
||
list := s.m[userID]
|
||
s.mu.RUnlock()
|
||
list.Dialogs = cloneDialogs(list.Dialogs)
|
||
list.Messages = cloneMessages(list.Messages)
|
||
list.Users = append([]domain.User(nil), list.Users...)
|
||
|
||
byPeer := make(map[domain.Peer]domain.Dialog, len(list.Dialogs))
|
||
for _, dialog := range list.Dialogs {
|
||
byPeer[dialog.Peer] = dialog
|
||
}
|
||
out := domain.DialogList{
|
||
Dialogs: make([]domain.Dialog, 0, len(peers)),
|
||
Users: make([]domain.User, 0, len(peers)),
|
||
}
|
||
seenPeers := make(map[domain.Peer]struct{}, len(peers))
|
||
seenUsers := map[int64]struct{}{}
|
||
for _, peer := range peers {
|
||
if _, ok := seenPeers[peer]; ok {
|
||
continue
|
||
}
|
||
seenPeers[peer] = struct{}{}
|
||
dialog := byPeer[peer]
|
||
if dialog.Peer.ID == 0 {
|
||
dialog.Peer = peer
|
||
}
|
||
out.Dialogs = append(out.Dialogs, dialog)
|
||
if peer.Type == domain.PeerTypeUser {
|
||
if user, ok := findDialogUser(list.Users, peer.ID); ok {
|
||
appendDialogUser(&out, seenUsers, user)
|
||
} else if peer.ID == domain.OfficialSystemUserID {
|
||
appendDialogUser(&out, seenUsers, domain.OfficialSystemUser())
|
||
}
|
||
}
|
||
}
|
||
out.Messages = keepDialogMessages(list.Messages, out.Dialogs)
|
||
out.Count = len(out.Dialogs)
|
||
out.Hash = dialogListHash(out.Dialogs)
|
||
return out, nil
|
||
}
|
||
|
||
// SaveList 保存一份用户会话列表，供测试和本地替身使用。
|
||
func (s *DialogStore) SaveList(_ context.Context, userID int64, list domain.DialogList) error {
|
||
list.Dialogs = cloneDialogs(list.Dialogs)
|
||
list.Messages = cloneMessages(list.Messages)
|
||
list.Users = append([]domain.User(nil), list.Users...)
|
||
s.mu.Lock()
|
||
s.m[userID] = list
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *DialogStore) Upsert(_ context.Context, userID int64, dialog domain.Dialog) error {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
for i, existing := range list.Dialogs {
|
||
if existing.Peer == dialog.Peer {
|
||
if dialog.FolderID == domain.DialogMainFolderID && existing.FolderID != domain.DialogMainFolderID {
|
||
dialog.FolderID = existing.FolderID
|
||
}
|
||
list.Dialogs[i] = dialog
|
||
s.m[userID] = list
|
||
return nil
|
||
}
|
||
}
|
||
list.Dialogs = append(list.Dialogs, dialog)
|
||
s.m[userID] = list
|
||
return nil
|
||
}
|
||
|
||
func (s *DialogStore) SaveDraft(_ context.Context, userID int64, draft domain.DialogDraft) error {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
if s.drafts[userID] == nil {
|
||
s.drafts[userID] = make(map[dialogDraftKey]domain.DialogDraft)
|
||
}
|
||
s.drafts[userID][draftKey(draft.Peer, draft.TopMessageID)] = cloneDialogDraft(draft)
|
||
return nil
|
||
}
|
||
|
||
func (s *DialogStore) DeleteDraft(_ context.Context, userID int64, peer domain.Peer, topMessageID int) (bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
items := s.drafts[userID]
|
||
if len(items) == 0 {
|
||
return false, nil
|
||
}
|
||
key := draftKey(peer, topMessageID)
|
||
if _, ok := items[key]; !ok {
|
||
return false, nil
|
||
}
|
||
delete(items, key)
|
||
return true, nil
|
||
}
|
||
|
||
func (s *DialogStore) ListDrafts(_ context.Context, userID int64, limit int) ([]domain.DialogDraft, error) {
|
||
s.mu.RLock()
|
||
items := s.drafts[userID]
|
||
out := make([]domain.DialogDraft, 0, len(items))
|
||
for _, draft := range items {
|
||
out = append(out, cloneDialogDraft(draft))
|
||
}
|
||
s.mu.RUnlock()
|
||
sortDialogDrafts(out)
|
||
if limit <= 0 || limit > domain.MaxDialogDraftsPerUser {
|
||
limit = domain.MaxDialogDraftsPerUser
|
||
}
|
||
if len(out) > limit {
|
||
out = out[:limit]
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *DialogStore) ClearDrafts(_ context.Context, userID int64, limit int) ([]domain.DialogDraft, error) {
|
||
if limit <= 0 || limit > domain.MaxDialogDraftsPerUser {
|
||
limit = domain.MaxDialogDraftsPerUser
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
items := s.drafts[userID]
|
||
if len(items) == 0 {
|
||
return nil, nil
|
||
}
|
||
out := make([]domain.DialogDraft, 0, len(items))
|
||
for _, draft := range items {
|
||
out = append(out, cloneDialogDraft(draft))
|
||
}
|
||
sortDialogDrafts(out)
|
||
if len(out) > limit {
|
||
out = out[:limit]
|
||
}
|
||
for _, draft := range out {
|
||
delete(items, draftKey(draft.Peer, draft.TopMessageID))
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *DialogStore) MarkRead(_ context.Context, userID int64, peer domain.Peer, maxID int) (domain.ReadHistoryResult, error) {
|
||
result := domain.ReadHistoryResult{OwnerUserID: userID, Peer: peer, MaxID: maxID}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
for i, dialog := range list.Dialogs {
|
||
if dialog.Peer != peer {
|
||
continue
|
||
}
|
||
readMax := maxID
|
||
if readMax <= 0 {
|
||
readMax = dialog.TopMessage
|
||
}
|
||
result.MaxID = readMax
|
||
result.Changed = dialog.UnreadCount > 0 || readMax > dialog.ReadInboxMaxID
|
||
if readMax > dialog.ReadInboxMaxID {
|
||
dialog.ReadInboxMaxID = readMax
|
||
}
|
||
dialog.UnreadCount = 0
|
||
dialog.UnreadMentions = 0
|
||
dialog.UnreadReactions = 0
|
||
dialog.UnreadMark = false
|
||
result.StillUnreadCount = dialog.UnreadCount
|
||
list.Dialogs[i] = dialog
|
||
s.m[userID] = list
|
||
return result, nil
|
||
}
|
||
return result, nil
|
||
}
|
||
|
||
func (s *DialogStore) SetPinned(_ context.Context, userID int64, peer domain.Peer, pinned bool) (bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
nextOrder := 1
|
||
for _, dialog := range list.Dialogs {
|
||
if dialog.Pinned && dialog.PinnedOrder >= nextOrder {
|
||
nextOrder = dialog.PinnedOrder + 1
|
||
}
|
||
}
|
||
for i := range list.Dialogs {
|
||
if list.Dialogs[i].Peer != peer {
|
||
continue
|
||
}
|
||
list.Dialogs[i].Pinned = pinned
|
||
if pinned {
|
||
if list.Dialogs[i].PinnedOrder == 0 {
|
||
list.Dialogs[i].PinnedOrder = nextOrder
|
||
}
|
||
} else {
|
||
list.Dialogs[i].PinnedOrder = 0
|
||
}
|
||
s.m[userID] = list
|
||
return true, nil
|
||
}
|
||
return false, nil
|
||
}
|
||
|
||
func (s *DialogStore) ReorderPinned(_ context.Context, userID int64, order []domain.Peer, force bool) error {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
positions := make(map[domain.Peer]int, len(order))
|
||
for i, peer := range order {
|
||
if peer.Type == "" || peer.ID == 0 {
|
||
continue
|
||
}
|
||
if _, ok := positions[peer]; ok {
|
||
continue
|
||
}
|
||
positions[peer] = len(order) - i
|
||
}
|
||
for i := range list.Dialogs {
|
||
pos, ok := positions[list.Dialogs[i].Peer]
|
||
if ok {
|
||
list.Dialogs[i].Pinned = true
|
||
list.Dialogs[i].PinnedOrder = pos
|
||
continue
|
||
}
|
||
if force && list.Dialogs[i].Pinned {
|
||
list.Dialogs[i].Pinned = false
|
||
list.Dialogs[i].PinnedOrder = 0
|
||
}
|
||
}
|
||
s.m[userID] = list
|
||
return nil
|
||
}
|
||
|
||
func (s *DialogStore) SetUnreadMark(_ context.Context, userID int64, peer domain.Peer, unread bool) (bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
for i := range list.Dialogs {
|
||
if list.Dialogs[i].Peer != peer {
|
||
continue
|
||
}
|
||
list.Dialogs[i].UnreadMark = unread
|
||
s.m[userID] = list
|
||
return true, nil
|
||
}
|
||
return false, nil
|
||
}
|
||
|
||
func (s *DialogStore) ListUnreadMarked(_ context.Context, userID int64) ([]domain.Peer, error) {
|
||
s.mu.RLock()
|
||
list := s.m[userID]
|
||
s.mu.RUnlock()
|
||
out := make([]domain.Peer, 0, len(list.Dialogs))
|
||
for _, dialog := range list.Dialogs {
|
||
if dialog.UnreadMark {
|
||
out = append(out, dialog.Peer)
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *DialogStore) SetPeerSettingsBarHidden(_ context.Context, userID int64, peer domain.Peer) (bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
for i := range list.Dialogs {
|
||
if list.Dialogs[i].Peer != peer {
|
||
continue
|
||
}
|
||
list.Dialogs[i].PeerSettingsBarHidden = true
|
||
s.m[userID] = list
|
||
return true, nil
|
||
}
|
||
return false, nil
|
||
}
|
||
|
||
func (s *DialogStore) PeerSettingsBarHidden(_ context.Context, userID int64, peer domain.Peer) (bool, error) {
|
||
s.mu.RLock()
|
||
list := s.m[userID]
|
||
s.mu.RUnlock()
|
||
for _, dialog := range list.Dialogs {
|
||
if dialog.Peer == peer {
|
||
return dialog.PeerSettingsBarHidden, nil
|
||
}
|
||
}
|
||
return false, nil
|
||
}
|
||
|
||
func (s *DialogStore) ListFolders(_ context.Context, userID int64) (domain.DialogFolderList, error) {
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
byID := s.folders[userID]
|
||
order := append([]int(nil), s.folderOrder[userID]...)
|
||
seen := make(map[int]struct{}, len(byID))
|
||
out := domain.DialogFolderList{
|
||
TagsEnabled: s.folderTags[userID],
|
||
Folders: make([]domain.DialogFolder, 0, len(byID)),
|
||
}
|
||
for _, id := range order {
|
||
folder, ok := byID[id]
|
||
if !ok {
|
||
continue
|
||
}
|
||
seen[id] = struct{}{}
|
||
out.Folders = append(out.Folders, cloneDialogFolder(folder))
|
||
}
|
||
remaining := make([]int, 0, len(byID))
|
||
for id := range byID {
|
||
if _, ok := seen[id]; !ok {
|
||
remaining = append(remaining, id)
|
||
}
|
||
}
|
||
sort.Ints(remaining)
|
||
for _, id := range remaining {
|
||
out.Folders = append(out.Folders, cloneDialogFolder(byID[id]))
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *DialogStore) GetFolder(_ context.Context, userID int64, folderID int) (domain.DialogFolder, bool, error) {
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
folder, ok := s.folders[userID][folderID]
|
||
if !ok {
|
||
return domain.DialogFolder{}, false, nil
|
||
}
|
||
return cloneDialogFolder(folder), true, nil
|
||
}
|
||
|
||
func (s *DialogStore) UpsertFolder(_ context.Context, userID int64, folder domain.DialogFolder) error {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
if s.folders[userID] == nil {
|
||
s.folders[userID] = make(map[int]domain.DialogFolder)
|
||
}
|
||
s.folders[userID][folder.ID] = cloneDialogFolder(folder)
|
||
if !containsInt(s.folderOrder[userID], folder.ID) {
|
||
s.folderOrder[userID] = append(s.folderOrder[userID], folder.ID)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (s *DialogStore) DeleteFolder(_ context.Context, userID int64, folderID int) error {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
delete(s.folders[userID], folderID)
|
||
s.folderOrder[userID] = removeInt(s.folderOrder[userID], folderID)
|
||
return nil
|
||
}
|
||
|
||
func (s *DialogStore) ReorderFolders(_ context.Context, userID int64, order []int) error {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
byID := s.folders[userID]
|
||
seen := make(map[int]struct{}, len(order))
|
||
next := make([]int, 0, len(byID))
|
||
for _, id := range order {
|
||
if id < domain.DialogCustomFolderMinID {
|
||
continue
|
||
}
|
||
if _, ok := byID[id]; !ok {
|
||
continue
|
||
}
|
||
if _, ok := seen[id]; ok {
|
||
continue
|
||
}
|
||
seen[id] = struct{}{}
|
||
next = append(next, id)
|
||
}
|
||
remaining := make([]int, 0, len(byID))
|
||
for id := range byID {
|
||
if _, ok := seen[id]; !ok {
|
||
remaining = append(remaining, id)
|
||
}
|
||
}
|
||
sort.Ints(remaining)
|
||
next = append(next, remaining...)
|
||
s.folderOrder[userID] = next
|
||
return nil
|
||
}
|
||
|
||
func (s *DialogStore) SetFolderTagsEnabled(_ context.Context, userID int64, enabled bool) error {
|
||
s.mu.Lock()
|
||
s.folderTags[userID] = enabled
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *DialogStore) EditPeerFolders(_ context.Context, userID int64, peers []domain.FolderPeerUpdate) error {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
list := s.m[userID]
|
||
updates := make(map[domain.Peer]int, len(peers))
|
||
for _, item := range peers {
|
||
if item.Peer.Type == "" || item.Peer.ID == 0 {
|
||
continue
|
||
}
|
||
updates[item.Peer] = item.FolderID
|
||
}
|
||
for i := range list.Dialogs {
|
||
if folderID, ok := updates[list.Dialogs[i].Peer]; ok {
|
||
list.Dialogs[i].FolderID = folderID
|
||
}
|
||
}
|
||
s.m[userID] = list
|
||
return nil
|
||
}
|
||
|
||
// MessageStore 是 store.MessageStore 的内存实现。
|
||
type MessageStore struct {
|
||
mu sync.RWMutex
|
||
m map[int64][]domain.Message
|
||
nextUID int64
|
||
nextBox map[int64]int
|
||
nextPts map[int64]int
|
||
readOutboxDates map[readOutboxDateKey]int
|
||
privateReactions map[int64]map[int64][]domain.ChannelMessagePeerReaction
|
||
dialogs *DialogStore
|
||
}
|
||
|
||
type readOutboxDateKey struct {
|
||
ownerUserID int64
|
||
peerID int64
|
||
msgID int
|
||
}
|
||
|
||
// NewMessageStore 创建内存 MessageStore。
|
||
func NewMessageStore(dialogs ...*DialogStore) *MessageStore {
|
||
s := &MessageStore{
|
||
m: make(map[int64][]domain.Message),
|
||
nextUID: 1,
|
||
nextBox: make(map[int64]int),
|
||
nextPts: make(map[int64]int),
|
||
readOutboxDates: make(map[readOutboxDateKey]int),
|
||
privateReactions: make(map[int64]map[int64][]domain.ChannelMessagePeerReaction),
|
||
}
|
||
if len(dialogs) > 0 {
|
||
s.dialogs = dialogs[0]
|
||
}
|
||
return s
|
||
}
|
||
|
||
func (s *MessageStore) Create(_ context.Context, msg domain.Message) (domain.Message, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
msg.ID = s.nextBoxIDLocked(msg.OwnerUserID)
|
||
msg.UID = s.nextUID
|
||
s.nextUID++
|
||
msg.Entities = append([]domain.MessageEntity(nil), msg.Entities...)
|
||
s.m[msg.OwnerUserID] = append(s.m[msg.OwnerUserID], msg)
|
||
if s.dialogs != nil {
|
||
s.dialogs.mu.Lock()
|
||
list := s.dialogs.m[msg.OwnerUserID]
|
||
list.Messages = append(list.Messages, msg)
|
||
if msg.Peer.Type == domain.PeerTypeUser && msg.Peer.ID == domain.OfficialSystemUserID && !hasUser(list.Users, domain.OfficialSystemUserID) {
|
||
list.Users = append(list.Users, domain.OfficialSystemUser())
|
||
}
|
||
s.dialogs.m[msg.OwnerUserID] = list
|
||
s.dialogs.mu.Unlock()
|
||
}
|
||
return msg, nil
|
||
}
|
||
|
||
func (s *MessageStore) SendPrivateText(_ context.Context, req domain.SendPrivateTextRequest) (domain.SendPrivateTextResult, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
for _, msg := range s.m[req.SenderUserID] {
|
||
if msg.RandomID != 0 && msg.RandomID == req.RandomID {
|
||
recipient := domain.Message{}
|
||
if req.SenderUserID != req.RecipientUserID {
|
||
for _, peerMsg := range s.m[req.RecipientUserID] {
|
||
if peerMsg.UID == msg.UID {
|
||
recipient = peerMsg
|
||
break
|
||
}
|
||
}
|
||
} else {
|
||
recipient = msg
|
||
}
|
||
return domain.SendPrivateTextResult{
|
||
SenderMessage: cloneMessage(msg),
|
||
RecipientMessage: cloneMessage(recipient),
|
||
SenderEvent: newMessageEvent(msg),
|
||
RecipientEvent: newMessageEvent(recipient),
|
||
Duplicate: true,
|
||
}, nil
|
||
}
|
||
}
|
||
if req.Date == 0 {
|
||
req.Date = int(time.Now().Unix())
|
||
}
|
||
senderReply, recipientReply, err := s.resolveMemoryReplyLocked(req)
|
||
if err != nil {
|
||
return domain.SendPrivateTextResult{}, err
|
||
}
|
||
uid := s.nextUID
|
||
s.nextUID++
|
||
sender := domain.Message{
|
||
ID: s.nextBoxIDLocked(req.SenderUserID),
|
||
UID: uid,
|
||
RandomID: req.RandomID,
|
||
OwnerUserID: req.SenderUserID,
|
||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: req.RecipientUserID},
|
||
From: domain.Peer{Type: domain.PeerTypeUser, ID: req.SenderUserID},
|
||
Date: req.Date,
|
||
Out: true,
|
||
Silent: req.Silent,
|
||
NoForwards: req.NoForwards,
|
||
Body: req.Message,
|
||
Entities: append([]domain.MessageEntity(nil), req.Entities...),
|
||
Media: req.Media,
|
||
ReplyTo: cloneMessageReply(senderReply),
|
||
Forward: cloneMessageForward(req.Forward),
|
||
Pts: s.nextPtsLocked(req.SenderUserID),
|
||
}
|
||
recipient := domain.Message{}
|
||
if req.SenderUserID == req.RecipientUserID {
|
||
recipient = sender
|
||
}
|
||
if req.SenderUserID != req.RecipientUserID && !req.RecipientBlocked {
|
||
recipient = sender
|
||
recipient.ID = s.nextBoxIDLocked(req.RecipientUserID)
|
||
recipient.OwnerUserID = req.RecipientUserID
|
||
recipient.Peer = domain.Peer{Type: domain.PeerTypeUser, ID: req.SenderUserID}
|
||
recipient.Out = false
|
||
recipient.ReplyTo = cloneMessageReply(recipientReply)
|
||
recipient.Pts = s.nextPtsLocked(req.RecipientUserID)
|
||
recipient.MediaUnread = !req.Media.IsZero()
|
||
}
|
||
s.m[req.SenderUserID] = append(s.m[req.SenderUserID], sender)
|
||
if req.SenderUserID != req.RecipientUserID && !req.RecipientBlocked {
|
||
s.m[req.RecipientUserID] = append(s.m[req.RecipientUserID], recipient)
|
||
}
|
||
if s.dialogs != nil {
|
||
if recipient.ID != 0 {
|
||
s.upsertMemoryDialogsLocked(sender, recipient)
|
||
} else {
|
||
s.upsertMemoryDialogsLocked(sender, sender)
|
||
}
|
||
}
|
||
return domain.SendPrivateTextResult{
|
||
SenderMessage: cloneMessage(sender),
|
||
RecipientMessage: cloneMessage(recipient),
|
||
SenderEvent: newMessageEvent(sender),
|
||
RecipientEvent: newMessageEvent(recipient),
|
||
}, nil
|
||
}
|
||
|
||
func (s *MessageStore) resolveMemoryReplyLocked(req domain.SendPrivateTextRequest) (*domain.MessageReply, *domain.MessageReply, error) {
|
||
if req.ReplyTo == nil {
|
||
return nil, nil, nil
|
||
}
|
||
if err := domain.ValidateMessageReplyBounds(req.ReplyTo); err != nil {
|
||
return nil, nil, err
|
||
}
|
||
peer := req.ReplyTo.Peer
|
||
if peer.ID == 0 {
|
||
peer = domain.Peer{Type: domain.PeerTypeUser, ID: req.RecipientUserID}
|
||
}
|
||
if peer.Type != domain.PeerTypeUser || peer.ID != req.RecipientUserID {
|
||
return nil, nil, domain.ErrReplyMessageIDInvalid
|
||
}
|
||
var target domain.Message
|
||
for _, msg := range s.m[req.SenderUserID] {
|
||
if msg.Peer == peer && msg.ID == req.ReplyTo.MessageID {
|
||
target = msg
|
||
break
|
||
}
|
||
}
|
||
if target.ID == 0 {
|
||
return nil, nil, domain.ErrReplyMessageIDInvalid
|
||
}
|
||
senderReply := cloneMessageReply(req.ReplyTo)
|
||
senderReply.MessageID = target.ID
|
||
senderReply.Peer = peer
|
||
if req.SenderUserID == req.RecipientUserID {
|
||
return senderReply, cloneMessageReply(senderReply), nil
|
||
}
|
||
for _, msg := range s.m[req.RecipientUserID] {
|
||
if msg.UID == target.UID {
|
||
recipientReply := cloneMessageReply(senderReply)
|
||
recipientReply.MessageID = msg.ID
|
||
recipientReply.Peer = domain.Peer{Type: domain.PeerTypeUser, ID: req.SenderUserID}
|
||
return senderReply, recipientReply, nil
|
||
}
|
||
}
|
||
return senderReply, nil, nil
|
||
}
|
||
|
||
func (s *MessageStore) ForwardPrivateMessages(ctx context.Context, req domain.ForwardPrivateMessagesRequest) (domain.ForwardPrivateMessagesResult, error) {
|
||
res := domain.ForwardPrivateMessagesResult{OwnerUserID: req.OwnerUserID}
|
||
if req.OwnerUserID == 0 || req.ToUserID == 0 || req.FromPeer.Type != domain.PeerTypeUser || req.FromPeer.ID == 0 {
|
||
return res, domain.ErrMessageIDInvalid
|
||
}
|
||
if len(req.MessageIDs) == 0 || len(req.MessageIDs) != len(req.RandomIDs) {
|
||
return res, domain.ErrMessageIDInvalid
|
||
}
|
||
if len(req.MessageIDs) > domain.MaxForwardMessageIDs {
|
||
return res, domain.ErrMessageIDInvalid
|
||
}
|
||
if req.Date == 0 {
|
||
req.Date = int(time.Now().Unix())
|
||
}
|
||
s.mu.RLock()
|
||
sources := make([]domain.Message, 0, len(req.MessageIDs))
|
||
for _, id := range req.MessageIDs {
|
||
if id <= 0 || id > domain.MaxMessageBoxID {
|
||
s.mu.RUnlock()
|
||
return res, domain.ErrMessageIDInvalid
|
||
}
|
||
var source domain.Message
|
||
for _, msg := range s.m[req.OwnerUserID] {
|
||
if msg.Peer == req.FromPeer && msg.ID == id {
|
||
source = cloneMessage(msg)
|
||
break
|
||
}
|
||
}
|
||
if source.ID == 0 {
|
||
s.mu.RUnlock()
|
||
return res, domain.ErrMessageIDInvalid
|
||
}
|
||
if source.NoForwards {
|
||
s.mu.RUnlock()
|
||
return res, domain.ErrChatForwardsRestricted
|
||
}
|
||
sources = append(sources, source)
|
||
}
|
||
s.mu.RUnlock()
|
||
|
||
res.SenderMessages = make([]domain.Message, 0, len(sources))
|
||
res.RecipientMessages = make([]domain.Message, 0, len(sources))
|
||
res.SenderEvents = make([]domain.UpdateEvent, 0, len(sources))
|
||
res.RecipientEvents = make([]domain.UpdateEvent, 0, len(sources))
|
||
res.Duplicates = make([]bool, 0, len(sources))
|
||
for i, source := range sources {
|
||
if req.RandomIDs[i] == 0 {
|
||
return res, domain.ErrMessageIDInvalid
|
||
}
|
||
var forward *domain.MessageForward
|
||
if !req.DropAuthor {
|
||
forward = cloneMessageForward(source.Forward)
|
||
if forward == nil {
|
||
forward = &domain.MessageForward{From: source.From, Date: source.Date}
|
||
}
|
||
}
|
||
sent, err := s.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
||
SenderUserID: req.OwnerUserID,
|
||
RecipientUserID: req.ToUserID,
|
||
RandomID: req.RandomIDs[i],
|
||
Message: source.Body,
|
||
Entities: append([]domain.MessageEntity(nil), source.Entities...),
|
||
Silent: req.Silent,
|
||
NoForwards: req.NoForwards,
|
||
ReplyTo: req.ReplyTo,
|
||
Forward: forward,
|
||
Date: req.Date,
|
||
OriginAuthKeyID: req.OriginAuthKeyID,
|
||
OriginSessionID: req.OriginSessionID,
|
||
RecipientBlocked: req.RecipientBlocked,
|
||
})
|
||
if err != nil {
|
||
return res, err
|
||
}
|
||
res.SenderMessages = append(res.SenderMessages, sent.SenderMessage)
|
||
res.RecipientMessages = append(res.RecipientMessages, sent.RecipientMessage)
|
||
res.SenderEvents = append(res.SenderEvents, sent.SenderEvent)
|
||
res.RecipientEvents = append(res.RecipientEvents, sent.RecipientEvent)
|
||
res.Duplicates = append(res.Duplicates, sent.Duplicate)
|
||
}
|
||
return res, nil
|
||
}
|
||
|
||
func (s *MessageStore) GetByIDs(_ context.Context, userID int64, ids []int) (domain.MessageList, error) {
|
||
if userID == 0 || len(ids) == 0 {
|
||
return domain.MessageList{}, nil
|
||
}
|
||
s.mu.RLock()
|
||
byID := make(map[int]domain.Message, len(s.m[userID]))
|
||
for _, msg := range s.m[userID] {
|
||
item := cloneMessage(msg)
|
||
reactions := s.privateMessageReactionsLocked(item.UID, item.OwnerUserID)
|
||
if len(reactions.Results) > 0 || len(reactions.Recent) > 0 {
|
||
item.Reactions = cloneChannelMessageReactionsPtr(&reactions)
|
||
}
|
||
byID[msg.ID] = item
|
||
}
|
||
s.mu.RUnlock()
|
||
out := domain.MessageList{Messages: make([]domain.Message, 0, len(ids))}
|
||
for _, id := range ids {
|
||
if msg, ok := byID[id]; ok {
|
||
out.Messages = append(out.Messages, msg)
|
||
}
|
||
}
|
||
out.Users = usersForMessages(out.Messages)
|
||
out.Hash = messageListHash(out.Messages)
|
||
return out, nil
|
||
}
|
||
|
||
func (s *MessageStore) ListByUser(_ context.Context, userID int64, filter domain.MessageFilter) (domain.MessageList, error) {
|
||
s.mu.RLock()
|
||
messages := cloneMessages(s.m[userID])
|
||
for i := range messages {
|
||
reactions := s.privateMessageReactionsLocked(messages[i].UID, messages[i].OwnerUserID)
|
||
if len(reactions.Results) > 0 || len(reactions.Recent) > 0 {
|
||
messages[i].Reactions = cloneChannelMessageReactionsPtr(&reactions)
|
||
}
|
||
}
|
||
s.mu.RUnlock()
|
||
return filterMessageList(messages, filter), nil
|
||
}
|
||
|
||
func (s *MessageStore) ReadHistory(_ context.Context, req domain.ReadHistoryRequest) (domain.ReadHistoryResult, error) {
|
||
res := domain.ReadHistoryResult{OwnerUserID: req.OwnerUserID, Peer: req.Peer, MaxID: req.MaxID}
|
||
if req.OwnerUserID == 0 || req.Peer.ID == 0 {
|
||
return res, nil
|
||
}
|
||
if req.Date == 0 {
|
||
req.Date = int(time.Now().Unix())
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
if s.dialogs == nil {
|
||
return res, nil
|
||
}
|
||
s.dialogs.mu.Lock()
|
||
defer s.dialogs.mu.Unlock()
|
||
list := s.dialogs.m[req.OwnerUserID]
|
||
for i, dialog := range list.Dialogs {
|
||
if dialog.Peer != req.Peer {
|
||
continue
|
||
}
|
||
readMax := req.MaxID
|
||
if readMax <= 0 {
|
||
readMax = dialog.TopMessage
|
||
}
|
||
if readMax > domain.MaxMessageBoxID {
|
||
readMax = domain.MaxMessageBoxID
|
||
}
|
||
oldRead := dialog.ReadInboxMaxID
|
||
res.MaxID = readMax
|
||
res.Changed = dialog.UnreadCount > 0 || readMax > oldRead
|
||
if !res.Changed {
|
||
return res, nil
|
||
}
|
||
var latestIncoming domain.Message
|
||
unread := 0
|
||
for _, msg := range s.m[req.OwnerUserID] {
|
||
if msg.Peer != req.Peer || msg.Out {
|
||
continue
|
||
}
|
||
if msg.ID > readMax {
|
||
unread++
|
||
continue
|
||
}
|
||
if msg.ID > oldRead && msg.ID > latestIncoming.ID {
|
||
latestIncoming = msg
|
||
}
|
||
}
|
||
if readMax > dialog.ReadInboxMaxID {
|
||
dialog.ReadInboxMaxID = readMax
|
||
}
|
||
dialog.UnreadCount = unread
|
||
dialog.UnreadMentions = 0
|
||
dialog.UnreadReactions = 0
|
||
dialog.UnreadMark = false
|
||
res.StillUnreadCount = unread
|
||
pts := s.nextPtsLocked(req.OwnerUserID)
|
||
res.InboxEvent = domain.UpdateEvent{
|
||
UserID: req.OwnerUserID,
|
||
Type: domain.UpdateEventReadHistoryInbox,
|
||
Pts: pts,
|
||
PtsCount: 1,
|
||
Date: req.Date,
|
||
Peer: req.Peer,
|
||
MaxID: readMax,
|
||
StillUnreadCount: unread,
|
||
}
|
||
list.Dialogs[i] = dialog
|
||
s.dialogs.m[req.OwnerUserID] = list
|
||
|
||
if latestIncoming.ID != 0 && latestIncoming.From.ID != 0 && latestIncoming.From.ID != req.OwnerUserID {
|
||
senderUserID := latestIncoming.From.ID
|
||
senderBoxID := 0
|
||
for _, msg := range s.m[senderUserID] {
|
||
if msg.UID == latestIncoming.UID && msg.Out {
|
||
senderBoxID = msg.ID
|
||
break
|
||
}
|
||
}
|
||
if senderBoxID > 0 {
|
||
senderList := s.dialogs.m[senderUserID]
|
||
for j, senderDialog := range senderList.Dialogs {
|
||
if senderDialog.Peer != (domain.Peer{Type: domain.PeerTypeUser, ID: req.OwnerUserID}) {
|
||
continue
|
||
}
|
||
if senderBoxID <= senderDialog.ReadOutboxMaxID {
|
||
break
|
||
}
|
||
oldOutbox := senderDialog.ReadOutboxMaxID
|
||
senderDialog.ReadOutboxMaxID = senderBoxID
|
||
senderList.Dialogs[j] = senderDialog
|
||
s.dialogs.m[senderUserID] = senderList
|
||
for _, msg := range s.m[senderUserID] {
|
||
if msg.Peer == (domain.Peer{Type: domain.PeerTypeUser, ID: req.OwnerUserID}) && msg.Out && msg.ID > oldOutbox && msg.ID <= senderBoxID {
|
||
s.readOutboxDates[readOutboxDateKey{ownerUserID: senderUserID, peerID: req.OwnerUserID, msgID: msg.ID}] = req.Date
|
||
}
|
||
}
|
||
outPts := s.nextPtsLocked(senderUserID)
|
||
res.OutboxChanged = true
|
||
res.OutboxUserID = senderUserID
|
||
res.OutboxEvent = domain.UpdateEvent{
|
||
UserID: senderUserID,
|
||
Type: domain.UpdateEventReadHistoryOutbox,
|
||
Pts: outPts,
|
||
PtsCount: 1,
|
||
Date: req.Date,
|
||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: req.OwnerUserID},
|
||
MaxID: senderBoxID,
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
return res, nil
|
||
}
|
||
return res, nil
|
||
}
|
||
|
||
func (s *MessageStore) ReadMessageContents(_ context.Context, req domain.ReadMessageContentsRequest) (domain.ReadMessageContentsResult, error) {
|
||
res := domain.ReadMessageContentsResult{OwnerUserID: req.OwnerUserID}
|
||
if req.OwnerUserID == 0 {
|
||
return res, fmt.Errorf("read message contents: missing owner user id")
|
||
}
|
||
if len(req.IDs) > domain.MaxGetMessageIDs {
|
||
return res, domain.ErrMessageIDInvalid
|
||
}
|
||
wanted := make(map[int]struct{}, len(req.IDs))
|
||
for _, id := range req.IDs {
|
||
if id <= 0 || id > domain.MaxMessageBoxID {
|
||
return res, domain.ErrMessageIDInvalid
|
||
}
|
||
wanted[id] = struct{}{}
|
||
}
|
||
if len(wanted) == 0 {
|
||
return res, nil
|
||
}
|
||
if req.Date == 0 {
|
||
req.Date = int(time.Now().Unix())
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
affectedPeers := make(map[domain.Peer]struct{})
|
||
for i := range s.m[req.OwnerUserID] {
|
||
msg := &s.m[req.OwnerUserID][i]
|
||
if _, ok := wanted[msg.ID]; !ok {
|
||
continue
|
||
}
|
||
if !msg.MediaUnread && !msg.ReactionUnread {
|
||
continue
|
||
}
|
||
if msg.ReactionUnread && msg.Peer.ID != 0 {
|
||
affectedPeers[msg.Peer] = struct{}{}
|
||
}
|
||
msg.MediaUnread = false
|
||
msg.ReactionUnread = false
|
||
res.MessageIDs = append(res.MessageIDs, msg.ID)
|
||
}
|
||
sort.Ints(res.MessageIDs)
|
||
if len(res.MessageIDs) == 0 {
|
||
return res, nil
|
||
}
|
||
if s.dialogs != nil && len(affectedPeers) > 0 {
|
||
s.dialogs.mu.Lock()
|
||
list := s.dialogs.m[req.OwnerUserID]
|
||
for i := range list.Dialogs {
|
||
if _, ok := affectedPeers[list.Dialogs[i].Peer]; !ok {
|
||
continue
|
||
}
|
||
list.Dialogs[i].UnreadReactions = s.countPrivateUnreadReactionsLocked(req.OwnerUserID, list.Dialogs[i].Peer)
|
||
}
|
||
s.dialogs.m[req.OwnerUserID] = list
|
||
s.dialogs.mu.Unlock()
|
||
}
|
||
pts := s.nextPtsNLocked(req.OwnerUserID, len(res.MessageIDs))
|
||
res.Event = domain.UpdateEvent{
|
||
UserID: req.OwnerUserID,
|
||
Type: domain.UpdateEventReadMessageContents,
|
||
Pts: pts,
|
||
PtsCount: len(res.MessageIDs),
|
||
Date: req.Date,
|
||
MessageIDs: append([]int(nil), res.MessageIDs...),
|
||
}
|
||
return res, nil
|
||
}
|
||
|
||
func (s *MessageStore) GetOutboxReadDate(_ context.Context, req domain.OutboxReadDateRequest) (int, error) {
|
||
if req.OwnerUserID == 0 || req.Peer.Type != domain.PeerTypeUser || req.Peer.ID == 0 || req.ID <= 0 || req.ID > domain.MaxMessageBoxID {
|
||
return 0, domain.ErrMessageIDInvalid
|
||
}
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
found := false
|
||
for _, msg := range s.m[req.OwnerUserID] {
|
||
if msg.ID == req.ID && msg.Peer == req.Peer && msg.Out {
|
||
found = true
|
||
break
|
||
}
|
||
}
|
||
if !found {
|
||
return 0, domain.ErrMessageIDInvalid
|
||
}
|
||
date := s.readOutboxDates[readOutboxDateKey{ownerUserID: req.OwnerUserID, peerID: req.Peer.ID, msgID: req.ID}]
|
||
if date == 0 {
|
||
return 0, domain.ErrMessageNotReadYet
|
||
}
|
||
return date, nil
|
||
}
|
||
|
||
func (s *MessageStore) SetMessageReactions(_ context.Context, req domain.SetPrivateMessageReactionsRequest) (domain.PrivateMessageReactionsResult, error) {
|
||
if req.UserID == 0 || req.Peer.Type != domain.PeerTypeUser || req.Peer.ID == 0 || req.MessageID <= 0 || req.MessageID > domain.MaxMessageBoxID {
|
||
return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
|
||
}
|
||
if len(req.Reactions) > domain.MaxChannelMessageReactionsPerUser {
|
||
return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
|
||
}
|
||
if req.Date == 0 {
|
||
req.Date = int(time.Now().Unix())
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
var target domain.Message
|
||
for _, msg := range s.m[req.UserID] {
|
||
if msg.ID == req.MessageID && msg.Peer == req.Peer {
|
||
target = msg
|
||
break
|
||
}
|
||
}
|
||
if target.ID == 0 || target.UID == 0 {
|
||
return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
|
||
}
|
||
if _, ok := s.privateReactions[target.UID]; !ok {
|
||
s.privateReactions[target.UID] = make(map[int64][]domain.ChannelMessagePeerReaction)
|
||
}
|
||
rows := make([]domain.ChannelMessagePeerReaction, 0, len(req.Reactions))
|
||
for i, reaction := range req.Reactions {
|
||
if reaction.Type != domain.MessageReactionEmoji || strings.TrimSpace(reaction.Emoticon) == "" {
|
||
return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
|
||
}
|
||
rows = append(rows, domain.ChannelMessagePeerReaction{
|
||
UserID: req.UserID,
|
||
Reaction: reaction,
|
||
Big: req.Big,
|
||
My: true,
|
||
ChosenOrder: i + 1,
|
||
Date: req.Date,
|
||
})
|
||
}
|
||
if len(rows) == 0 {
|
||
delete(s.privateReactions[target.UID], req.UserID)
|
||
} else {
|
||
s.privateReactions[target.UID][req.UserID] = rows
|
||
}
|
||
if target.From.ID != 0 && target.From.ID != req.UserID {
|
||
for i := range s.m[target.From.ID] {
|
||
if s.m[target.From.ID][i].UID != target.UID {
|
||
continue
|
||
}
|
||
s.m[target.From.ID][i].ReactionUnread = len(rows) > 0
|
||
if s.dialogs != nil {
|
||
s.dialogs.mu.Lock()
|
||
list := s.dialogs.m[target.From.ID]
|
||
peer := domain.Peer{Type: domain.PeerTypeUser, ID: req.UserID}
|
||
for j := range list.Dialogs {
|
||
if list.Dialogs[j].Peer == peer {
|
||
list.Dialogs[j].UnreadReactions = s.countPrivateUnreadReactionsLocked(target.From.ID, peer)
|
||
}
|
||
}
|
||
s.dialogs.m[target.From.ID] = list
|
||
s.dialogs.mu.Unlock()
|
||
}
|
||
break
|
||
}
|
||
}
|
||
return s.privateReactionResultLocked(target.UID), nil
|
||
}
|
||
|
||
func (s *MessageStore) GetMessageReactions(_ context.Context, req domain.PrivateMessageReactionsRequest) (domain.PrivateMessageReactionsResult, error) {
|
||
if req.OwnerUserID == 0 || req.Peer.Type != domain.PeerTypeUser || req.Peer.ID == 0 || len(req.IDs) > domain.MaxGetMessageIDs {
|
||
return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
|
||
}
|
||
ids := make(map[int]struct{}, len(req.IDs))
|
||
for _, id := range req.IDs {
|
||
if id <= 0 || id > domain.MaxMessageBoxID {
|
||
return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
|
||
}
|
||
ids[id] = struct{}{}
|
||
}
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
out := domain.PrivateMessageReactionsResult{}
|
||
for _, msg := range s.m[req.OwnerUserID] {
|
||
if msg.Peer != req.Peer {
|
||
continue
|
||
}
|
||
if _, ok := ids[msg.ID]; !ok {
|
||
continue
|
||
}
|
||
item := cloneMessage(msg)
|
||
reactions := s.privateMessageReactionsLocked(msg.UID, msg.OwnerUserID)
|
||
item.Reactions = cloneChannelMessageReactionsPtr(&reactions)
|
||
out.Messages = append(out.Messages, item)
|
||
if len(out.Reactions.Results) == 0 && len(out.Reactions.Recent) == 0 {
|
||
out.Reactions = reactions
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *MessageStore) privateReactionResultLocked(uid int64) domain.PrivateMessageReactionsResult {
|
||
out := domain.PrivateMessageReactionsResult{}
|
||
for _, messages := range s.m {
|
||
for _, msg := range messages {
|
||
if msg.UID != uid {
|
||
continue
|
||
}
|
||
item := cloneMessage(msg)
|
||
reactions := s.privateMessageReactionsLocked(uid, msg.OwnerUserID)
|
||
item.Reactions = cloneChannelMessageReactionsPtr(&reactions)
|
||
out.Messages = append(out.Messages, item)
|
||
if len(out.Reactions.Results) == 0 && len(out.Reactions.Recent) == 0 {
|
||
out.Reactions = reactions
|
||
}
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func (s *MessageStore) privateMessageReactionsLocked(uid, viewerUserID int64) domain.ChannelMessageReactions {
|
||
byUser := s.privateReactions[uid]
|
||
out := domain.ChannelMessageReactions{CanSeeList: true}
|
||
if len(byUser) == 0 {
|
||
return out
|
||
}
|
||
counts := make(map[string]int)
|
||
recent := make([]domain.ChannelMessagePeerReaction, 0, len(byUser))
|
||
for userID, rows := range byUser {
|
||
for _, row := range rows {
|
||
key := string(row.Reaction.Type) + "\x00" + row.Reaction.Emoticon
|
||
index, ok := counts[key]
|
||
if !ok {
|
||
out.Results = append(out.Results, domain.ChannelMessageReactionCount{Reaction: row.Reaction})
|
||
index = len(out.Results) - 1
|
||
counts[key] = index
|
||
}
|
||
out.Results[index].Count++
|
||
if userID == viewerUserID && (out.Results[index].ChosenOrder == 0 || row.ChosenOrder < out.Results[index].ChosenOrder) {
|
||
out.Results[index].ChosenOrder = row.ChosenOrder
|
||
}
|
||
item := row
|
||
item.UserID = userID
|
||
item.My = userID == viewerUserID
|
||
recent = append(recent, item)
|
||
}
|
||
}
|
||
sort.Slice(out.Results, func(i, j int) bool {
|
||
if out.Results[i].Count != out.Results[j].Count {
|
||
return out.Results[i].Count > out.Results[j].Count
|
||
}
|
||
return out.Results[i].Reaction.Emoticon < out.Results[j].Reaction.Emoticon
|
||
})
|
||
sort.Slice(recent, func(i, j int) bool {
|
||
if recent[i].Date != recent[j].Date {
|
||
return recent[i].Date > recent[j].Date
|
||
}
|
||
return recent[i].UserID < recent[j].UserID
|
||
})
|
||
if len(recent) > domain.MaxChannelMessageReactionRecent {
|
||
recent = recent[:domain.MaxChannelMessageReactionRecent]
|
||
}
|
||
out.Recent = recent
|
||
return out
|
||
}
|
||
|
||
func (s *MessageStore) EditMessage(_ context.Context, req domain.EditMessageRequest) (domain.EditMessageResult, error) {
|
||
res := domain.EditMessageResult{OwnerUserID: req.OwnerUserID}
|
||
if req.OwnerUserID == 0 || req.Peer.ID == 0 || req.ID <= 0 || req.ID > domain.MaxMessageBoxID {
|
||
return res, domain.ErrMessageIDInvalid
|
||
}
|
||
if req.EditDate == 0 {
|
||
req.EditDate = int(time.Now().Unix())
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
targetIndex := -1
|
||
var target domain.Message
|
||
for i, msg := range s.m[req.OwnerUserID] {
|
||
if msg.ID == req.ID && msg.Peer == req.Peer {
|
||
targetIndex = i
|
||
target = msg
|
||
break
|
||
}
|
||
}
|
||
if targetIndex < 0 {
|
||
return res, domain.ErrMessageIDInvalid
|
||
}
|
||
if !target.Out || target.From.ID != req.OwnerUserID {
|
||
return res, domain.ErrMessageAuthorRequired
|
||
}
|
||
if target.Body == req.Message && equalMessageEntities(target.Entities, req.Entities) {
|
||
return res, domain.ErrMessageNotModified
|
||
}
|
||
for userID, messages := range s.m {
|
||
for i, msg := range messages {
|
||
if msg.UID == target.UID && msg.From.ID == req.OwnerUserID {
|
||
msg.Body = req.Message
|
||
msg.Entities = append([]domain.MessageEntity(nil), req.Entities...)
|
||
msg.EditDate = req.EditDate
|
||
msg.Pts = s.nextPtsLocked(userID)
|
||
s.m[userID][i] = msg
|
||
event := editMessageEvent(msg)
|
||
res.Edited = append(res.Edited, domain.EditedMessageForUser{
|
||
UserID: userID,
|
||
Message: cloneMessage(msg),
|
||
Event: event,
|
||
})
|
||
}
|
||
}
|
||
}
|
||
if s.dialogs != nil {
|
||
s.dialogs.mu.Lock()
|
||
for userID := range s.dialogs.m {
|
||
list := s.dialogs.m[userID]
|
||
list.Messages = cloneMessages(s.m[userID])
|
||
s.dialogs.m[userID] = list
|
||
}
|
||
s.dialogs.mu.Unlock()
|
||
}
|
||
sort.Slice(res.Edited, func(i, j int) bool { return res.Edited[i].UserID < res.Edited[j].UserID })
|
||
return res, nil
|
||
}
|
||
|
||
func (s *MessageStore) DeleteMessages(_ context.Context, req domain.DeleteMessagesRequest) (domain.DeleteMessagesResult, error) {
|
||
res := domain.DeleteMessagesResult{OwnerUserID: req.OwnerUserID}
|
||
ids := normalizeMemoryMessageIDs(req.IDs)
|
||
if req.OwnerUserID == 0 || len(ids) == 0 {
|
||
return res, nil
|
||
}
|
||
if len(ids) > domain.MaxDeleteMessageIDs {
|
||
return res, fmt.Errorf("delete messages: too many ids: %d > %d", len(ids), domain.MaxDeleteMessageIDs)
|
||
}
|
||
if req.Date == 0 {
|
||
req.Date = int(time.Now().Unix())
|
||
}
|
||
idSet := make(map[int]struct{}, len(ids))
|
||
for _, id := range ids {
|
||
idSet[id] = struct{}{}
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
deleted, revokeUIDs, _ := s.deleteMemoryMessagesLocked(req.OwnerUserID, 0, func(msg domain.Message) bool {
|
||
_, ok := idSet[msg.ID]
|
||
return ok
|
||
})
|
||
if req.Revoke && len(revokeUIDs) > 0 {
|
||
deleted = append(deleted, s.deleteMemoryMessagesByUIDLocked(revokeUIDs, req.OwnerUserID)...)
|
||
}
|
||
return s.finishMemoryDeleteLocked(res, deleted, req.Date, false), nil
|
||
}
|
||
|
||
func (s *MessageStore) DeleteHistory(_ context.Context, req domain.DeleteHistoryRequest) (domain.DeleteMessagesResult, error) {
|
||
res := domain.DeleteMessagesResult{OwnerUserID: req.OwnerUserID}
|
||
if req.OwnerUserID == 0 || req.Peer.ID == 0 {
|
||
return res, nil
|
||
}
|
||
if req.Date == 0 {
|
||
req.Date = int(time.Now().Unix())
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
deleted, revokeUIDs, more := s.deleteMemoryMessagesLocked(req.OwnerUserID, domain.MaxDeleteHistoryBatch, func(msg domain.Message) bool {
|
||
return msg.Peer == req.Peer && (req.MaxID <= 0 || msg.ID <= req.MaxID)
|
||
})
|
||
if req.Revoke && len(revokeUIDs) > 0 {
|
||
deleted = append(deleted, s.deleteMemoryMessagesByUIDLocked(revokeUIDs, req.OwnerUserID)...)
|
||
}
|
||
res = s.finishMemoryDeleteLocked(res, deleted, req.Date, req.JustClear)
|
||
if more {
|
||
res.Offset = 1
|
||
}
|
||
return res, nil
|
||
}
|
||
|
||
func (s *MessageStore) nextBoxIDLocked(userID int64) int {
|
||
next := s.nextBox[userID] + 1
|
||
s.nextBox[userID] = next
|
||
return next
|
||
}
|
||
|
||
func (s *MessageStore) nextPtsLocked(userID int64) int {
|
||
next := s.nextPts[userID] + 1
|
||
s.nextPts[userID] = next
|
||
return next
|
||
}
|
||
|
||
func (s *MessageStore) nextPtsNLocked(userID int64, count int) int {
|
||
if count <= 0 {
|
||
count = 1
|
||
}
|
||
next := s.nextPts[userID] + count
|
||
s.nextPts[userID] = next
|
||
return next
|
||
}
|
||
|
||
func (s *MessageStore) countPrivateUnreadReactionsLocked(ownerUserID int64, peer domain.Peer) int {
|
||
count := 0
|
||
for _, msg := range s.m[ownerUserID] {
|
||
if msg.Peer == peer && msg.ReactionUnread {
|
||
count++
|
||
}
|
||
}
|
||
return count
|
||
}
|
||
|
||
func (s *MessageStore) upsertMemoryDialogsLocked(sender, recipient domain.Message) {
|
||
s.dialogs.mu.Lock()
|
||
defer s.dialogs.mu.Unlock()
|
||
list := s.dialogs.m[sender.OwnerUserID]
|
||
list = upsertMemoryDialog(list, domain.Dialog{Peer: sender.Peer, TopMessage: sender.ID, TopMessageDate: sender.Date})
|
||
list.Messages = append(list.Messages, sender)
|
||
s.dialogs.m[sender.OwnerUserID] = list
|
||
if recipient.OwnerUserID != sender.OwnerUserID {
|
||
peerList := s.dialogs.m[recipient.OwnerUserID]
|
||
peerList = upsertMemoryDialog(peerList, domain.Dialog{Peer: recipient.Peer, TopMessage: recipient.ID, TopMessageDate: recipient.Date, UnreadCount: 1})
|
||
peerList.Messages = append(peerList.Messages, recipient)
|
||
s.dialogs.m[recipient.OwnerUserID] = peerList
|
||
}
|
||
}
|
||
|
||
func upsertMemoryDialog(list domain.DialogList, dialog domain.Dialog) domain.DialogList {
|
||
for i := range list.Dialogs {
|
||
if list.Dialogs[i].Peer == dialog.Peer {
|
||
if dialog.ReadInboxMaxID == 0 {
|
||
dialog.ReadInboxMaxID = list.Dialogs[i].ReadInboxMaxID
|
||
}
|
||
if dialog.ReadOutboxMaxID == 0 {
|
||
dialog.ReadOutboxMaxID = list.Dialogs[i].ReadOutboxMaxID
|
||
}
|
||
if dialog.FolderID == domain.DialogMainFolderID && list.Dialogs[i].FolderID != domain.DialogMainFolderID {
|
||
dialog.FolderID = list.Dialogs[i].FolderID
|
||
}
|
||
if dialog.UnreadCount != 0 {
|
||
dialog.UnreadCount += list.Dialogs[i].UnreadCount
|
||
}
|
||
list.Dialogs[i] = dialog
|
||
return list
|
||
}
|
||
}
|
||
list.Dialogs = append(list.Dialogs, dialog)
|
||
return list
|
||
}
|
||
|
||
type deletedMemoryMessage struct {
|
||
userID int64
|
||
peer domain.Peer
|
||
id int
|
||
}
|
||
|
||
func (s *MessageStore) deleteMemoryMessagesLocked(userID int64, limit int, match func(domain.Message) bool) ([]deletedMemoryMessage, map[int64]struct{}, bool) {
|
||
messages := s.m[userID]
|
||
kept := messages[:0]
|
||
deleted := make([]deletedMemoryMessage, 0)
|
||
revokeUIDs := make(map[int64]struct{})
|
||
more := false
|
||
for _, msg := range messages {
|
||
if match(msg) {
|
||
if limit > 0 && len(deleted) >= limit {
|
||
kept = append(kept, msg)
|
||
more = true
|
||
continue
|
||
}
|
||
deleted = append(deleted, deletedMemoryMessage{userID: userID, peer: msg.Peer, id: msg.ID})
|
||
if msg.UID != 0 {
|
||
revokeUIDs[msg.UID] = struct{}{}
|
||
}
|
||
continue
|
||
}
|
||
kept = append(kept, msg)
|
||
}
|
||
s.m[userID] = kept
|
||
return deleted, revokeUIDs, more
|
||
}
|
||
|
||
func (s *MessageStore) deleteMemoryMessagesByUIDLocked(uids map[int64]struct{}, excludeUserID int64) []deletedMemoryMessage {
|
||
if len(uids) == 0 {
|
||
return nil
|
||
}
|
||
deleted := make([]deletedMemoryMessage, 0)
|
||
for userID, messages := range s.m {
|
||
if userID == excludeUserID {
|
||
continue
|
||
}
|
||
kept := messages[:0]
|
||
for _, msg := range messages {
|
||
if _, ok := uids[msg.UID]; ok {
|
||
deleted = append(deleted, deletedMemoryMessage{userID: userID, peer: msg.Peer, id: msg.ID})
|
||
continue
|
||
}
|
||
kept = append(kept, msg)
|
||
}
|
||
s.m[userID] = kept
|
||
}
|
||
return deleted
|
||
}
|
||
|
||
func (s *MessageStore) finishMemoryDeleteLocked(res domain.DeleteMessagesResult, deleted []deletedMemoryMessage, date int, preserveEmptyDialogs bool) domain.DeleteMessagesResult {
|
||
if len(deleted) == 0 {
|
||
return res
|
||
}
|
||
idsByOwner := make(map[int64][]int)
|
||
peersByOwner := make(map[int64]map[domain.Peer]struct{})
|
||
for _, row := range deleted {
|
||
idsByOwner[row.userID] = append(idsByOwner[row.userID], row.id)
|
||
if peersByOwner[row.userID] == nil {
|
||
peersByOwner[row.userID] = make(map[domain.Peer]struct{})
|
||
}
|
||
peersByOwner[row.userID][row.peer] = struct{}{}
|
||
}
|
||
if s.dialogs != nil {
|
||
s.dialogs.mu.Lock()
|
||
for userID, peers := range peersByOwner {
|
||
for peer := range peers {
|
||
s.rebuildMemoryDialogLocked(userID, peer, preserveEmptyDialogs)
|
||
}
|
||
}
|
||
s.dialogs.mu.Unlock()
|
||
}
|
||
ownerIDs := make([]int64, 0, len(idsByOwner))
|
||
for userID := range idsByOwner {
|
||
ownerIDs = append(ownerIDs, userID)
|
||
}
|
||
sort.Slice(ownerIDs, func(i, j int) bool { return ownerIDs[i] < ownerIDs[j] })
|
||
for _, userID := range ownerIDs {
|
||
ids := normalizeMemoryMessageIDs(idsByOwner[userID])
|
||
if len(ids) == 0 {
|
||
continue
|
||
}
|
||
pts := s.nextPtsNLocked(userID, len(ids))
|
||
event := domain.UpdateEvent{
|
||
UserID: userID,
|
||
Type: domain.UpdateEventDeleteMessages,
|
||
Pts: pts,
|
||
PtsCount: len(ids),
|
||
Date: date,
|
||
MessageIDs: ids,
|
||
}
|
||
res.Deleted = append(res.Deleted, domain.DeletedMessagesForUser{
|
||
UserID: userID,
|
||
MessageIDs: ids,
|
||
Event: event,
|
||
})
|
||
}
|
||
return res
|
||
}
|
||
|
||
func (s *MessageStore) rebuildMemoryDialogLocked(userID int64, peer domain.Peer, preserveEmpty bool) {
|
||
list := s.dialogs.m[userID]
|
||
topID := 0
|
||
topDate := 0
|
||
unread := 0
|
||
for _, msg := range s.m[userID] {
|
||
if msg.Peer != peer {
|
||
continue
|
||
}
|
||
if msg.ID > topID {
|
||
topID = msg.ID
|
||
topDate = msg.Date
|
||
}
|
||
}
|
||
dialogs := list.Dialogs[:0]
|
||
for _, dialog := range list.Dialogs {
|
||
if dialog.Peer != peer {
|
||
dialogs = append(dialogs, dialog)
|
||
continue
|
||
}
|
||
if topID == 0 {
|
||
if preserveEmpty {
|
||
oldTop := dialog.TopMessage
|
||
dialog.TopMessage = 0
|
||
dialog.TopMessageDate = 0
|
||
if dialog.ReadInboxMaxID < oldTop {
|
||
dialog.ReadInboxMaxID = oldTop
|
||
}
|
||
if dialog.ReadOutboxMaxID < oldTop {
|
||
dialog.ReadOutboxMaxID = oldTop
|
||
}
|
||
dialog.UnreadCount = 0
|
||
dialog.UnreadMark = false
|
||
dialog.UnreadMentions = 0
|
||
dialog.UnreadReactions = 0
|
||
dialogs = append(dialogs, dialog)
|
||
}
|
||
continue
|
||
}
|
||
for _, msg := range s.m[userID] {
|
||
if msg.Peer == peer && !msg.Out && msg.ID > dialog.ReadInboxMaxID {
|
||
unread++
|
||
}
|
||
}
|
||
dialog.TopMessage = topID
|
||
dialog.TopMessageDate = topDate
|
||
dialog.UnreadCount = unread
|
||
dialog.UnreadMentions = 0
|
||
dialog.UnreadReactions = 0
|
||
dialogs = append(dialogs, dialog)
|
||
}
|
||
list.Dialogs = dialogs
|
||
list.Messages = cloneMessages(s.m[userID])
|
||
s.dialogs.m[userID] = list
|
||
}
|
||
|
||
func normalizeMemoryMessageIDs(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 || id > domain.MaxMessageBoxID {
|
||
continue
|
||
}
|
||
if _, ok := seen[id]; ok {
|
||
continue
|
||
}
|
||
seen[id] = struct{}{}
|
||
out = append(out, id)
|
||
}
|
||
sort.Ints(out)
|
||
return out
|
||
}
|
||
|
||
func cloneMessage(msg domain.Message) domain.Message {
|
||
msg.Entities = append([]domain.MessageEntity(nil), msg.Entities...)
|
||
msg.ReplyTo = cloneMessageReply(msg.ReplyTo)
|
||
msg.Forward = cloneMessageForward(msg.Forward)
|
||
msg.Reactions = cloneChannelMessageReactionsPtr(msg.Reactions)
|
||
return msg
|
||
}
|
||
|
||
func cloneMessageReply(reply *domain.MessageReply) *domain.MessageReply {
|
||
if reply == nil {
|
||
return nil
|
||
}
|
||
clone := *reply
|
||
clone.QuoteEntities = append([]domain.MessageEntity(nil), reply.QuoteEntities...)
|
||
return &clone
|
||
}
|
||
|
||
func cloneMessageForward(forward *domain.MessageForward) *domain.MessageForward {
|
||
if forward == nil {
|
||
return nil
|
||
}
|
||
clone := *forward
|
||
return &clone
|
||
}
|
||
|
||
func newMessageEvent(msg domain.Message) domain.UpdateEvent {
|
||
if msg.ID == 0 {
|
||
return domain.UpdateEvent{}
|
||
}
|
||
return domain.UpdateEvent{
|
||
UserID: msg.OwnerUserID,
|
||
Type: domain.UpdateEventNewMessage,
|
||
Pts: msg.Pts,
|
||
PtsCount: 1,
|
||
Date: msg.Date,
|
||
Message: cloneMessage(msg),
|
||
}
|
||
}
|
||
|
||
func editMessageEvent(msg domain.Message) domain.UpdateEvent {
|
||
if msg.ID == 0 {
|
||
return domain.UpdateEvent{}
|
||
}
|
||
return domain.UpdateEvent{
|
||
UserID: msg.OwnerUserID,
|
||
Type: domain.UpdateEventEditMessage,
|
||
Pts: msg.Pts,
|
||
PtsCount: 1,
|
||
Date: msg.EditDate,
|
||
Message: cloneMessage(msg),
|
||
}
|
||
}
|
||
|
||
func equalMessageEntities(a, b []domain.MessageEntity) bool {
|
||
if len(a) != len(b) {
|
||
return false
|
||
}
|
||
for i := range a {
|
||
if a[i] != b[i] {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
func hasUser(users []domain.User, id int64) bool {
|
||
for _, u := range users {
|
||
if u.ID == id {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func filterMessageList(messages []domain.Message, filter domain.MessageFilter) domain.MessageList {
|
||
filter.AddOffset = domain.ClampMessageHistoryAddOffset(filter.AddOffset)
|
||
sort.SliceStable(messages, func(i, j int) bool {
|
||
return messageLess(messages[i], messages[j])
|
||
})
|
||
|
||
query := strings.ToLower(filter.Query)
|
||
base := make([]domain.Message, 0, len(messages))
|
||
for _, msg := range messages {
|
||
if filter.HasPeer && msg.Peer != filter.Peer {
|
||
continue
|
||
}
|
||
if query != "" && !strings.Contains(strings.ToLower(msg.Body), query) {
|
||
continue
|
||
}
|
||
if filter.MaxID > 0 && msg.ID >= filter.MaxID {
|
||
continue
|
||
}
|
||
if filter.MinID > 0 && msg.ID <= filter.MinID {
|
||
continue
|
||
}
|
||
base = append(base, msg)
|
||
}
|
||
|
||
limit := filter.Limit
|
||
if limit <= 0 {
|
||
limit = 100
|
||
}
|
||
if limit > 500 {
|
||
limit = 500
|
||
}
|
||
page := pageMessageHistory(base, filter, limit)
|
||
return domain.MessageList{
|
||
Messages: page,
|
||
Users: usersForMessages(page),
|
||
Count: len(base),
|
||
Hash: messageListHash(base),
|
||
}
|
||
}
|
||
|
||
func pageMessageHistory(base []domain.Message, filter domain.MessageFilter, limit int) []domain.Message {
|
||
if limit <= 0 || len(base) == 0 {
|
||
return nil
|
||
}
|
||
switch messageHistoryLoadType(filter.AddOffset, limit) {
|
||
case messageHistoryLoadForward:
|
||
return cloneMessages(forwardMessageHistory(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.Message, 0, limit)
|
||
page = append(page, forwardMessageHistory(base, filter, forwardLimit)...)
|
||
page = append(page, backwardMessageHistory(base, filter, backwardLimit, true)...)
|
||
sort.SliceStable(page, func(i, j int) bool {
|
||
return messageLess(page[i], page[j])
|
||
})
|
||
return cloneMessages(page)
|
||
default:
|
||
start := filter.AddOffset
|
||
if start < 0 {
|
||
start = 0
|
||
}
|
||
candidates := backwardMessageHistory(base, filter, limit+start, false)
|
||
if start >= len(candidates) {
|
||
return nil
|
||
}
|
||
return cloneMessages(candidates[start:])
|
||
}
|
||
}
|
||
|
||
type messageHistoryLoad int
|
||
|
||
const (
|
||
messageHistoryLoadBackward messageHistoryLoad = iota
|
||
messageHistoryLoadForward
|
||
messageHistoryLoadAround
|
||
)
|
||
|
||
func messageHistoryLoadType(addOffset, limit int) messageHistoryLoad {
|
||
if addOffset >= 0 {
|
||
return messageHistoryLoadBackward
|
||
}
|
||
if addOffset+limit > 0 {
|
||
return messageHistoryLoadAround
|
||
}
|
||
return messageHistoryLoadForward
|
||
}
|
||
|
||
func backwardMessageHistory(base []domain.Message, filter domain.MessageFilter, limit int, includeOffset bool) []domain.Message {
|
||
if limit <= 0 {
|
||
return nil
|
||
}
|
||
out := make([]domain.Message, 0, limit)
|
||
for _, msg := range base {
|
||
if !messageBeforeHistoryOffset(msg, filter, includeOffset) {
|
||
continue
|
||
}
|
||
out = append(out, msg)
|
||
if len(out) == limit {
|
||
break
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func forwardMessageHistory(base []domain.Message, filter domain.MessageFilter, limit int) []domain.Message {
|
||
if limit <= 0 {
|
||
return nil
|
||
}
|
||
out := make([]domain.Message, 0, limit)
|
||
for i := len(base) - 1; i >= 0; i-- {
|
||
msg := base[i]
|
||
if !messageAfterHistoryOffset(msg, filter) {
|
||
continue
|
||
}
|
||
out = append(out, msg)
|
||
if len(out) == limit {
|
||
break
|
||
}
|
||
}
|
||
sort.SliceStable(out, func(i, j int) bool {
|
||
return messageLess(out[i], out[j])
|
||
})
|
||
return out
|
||
}
|
||
|
||
func messageBeforeHistoryOffset(msg domain.Message, filter domain.MessageFilter, 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 messageAfterHistoryOffset(msg domain.Message, filter domain.MessageFilter) bool {
|
||
if filter.OffsetDate > 0 {
|
||
return msg.Date >= filter.OffsetDate
|
||
}
|
||
if filter.OffsetID <= 0 {
|
||
return false
|
||
}
|
||
return msg.ID > filter.OffsetID
|
||
}
|
||
|
||
func messageLess(a, b domain.Message) bool {
|
||
if a.Date != b.Date {
|
||
return a.Date > b.Date
|
||
}
|
||
return a.ID > b.ID
|
||
}
|
||
|
||
func usersForMessages(messages []domain.Message) []domain.User {
|
||
seen := map[int64]struct{}{}
|
||
users := make([]domain.User, 0, 1)
|
||
for _, msg := range messages {
|
||
for _, peer := range []domain.Peer{msg.Peer, msg.From} {
|
||
if peer.Type != domain.PeerTypeUser {
|
||
continue
|
||
}
|
||
if _, ok := seen[peer.ID]; ok {
|
||
continue
|
||
}
|
||
seen[peer.ID] = struct{}{}
|
||
if peer.ID == domain.OfficialSystemUserID {
|
||
users = append(users, domain.OfficialSystemUser())
|
||
}
|
||
}
|
||
}
|
||
return users
|
||
}
|
||
|
||
func messageListHash(messages []domain.Message) int64 {
|
||
if len(messages) == 0 {
|
||
return 0
|
||
}
|
||
h := fnv.New64a()
|
||
var buf [16]byte
|
||
for _, msg := range messages {
|
||
binary.LittleEndian.PutUint32(buf[:4], uint32(msg.ID))
|
||
binary.LittleEndian.PutUint32(buf[4:8], uint32(msg.Date))
|
||
binary.LittleEndian.PutUint64(buf[8:16], uint64(msg.From.ID))
|
||
_, _ = h.Write(buf[:])
|
||
writeMessageReactionsHash(h, msg.Reactions)
|
||
}
|
||
return int64(h.Sum64())
|
||
}
|
||
|
||
func writeMessageReactionsHash(h hash.Hash64, reactions *domain.ChannelMessageReactions) {
|
||
if reactions == nil {
|
||
_, _ = h.Write([]byte{0})
|
||
return
|
||
}
|
||
var buf [16]byte
|
||
for _, item := range reactions.Results {
|
||
_, _ = h.Write([]byte(item.Reaction.Type))
|
||
_, _ = h.Write([]byte{0})
|
||
_, _ = h.Write([]byte(item.Reaction.Emoticon))
|
||
_, _ = h.Write([]byte{0})
|
||
binary.LittleEndian.PutUint32(buf[:4], uint32(item.Count))
|
||
binary.LittleEndian.PutUint32(buf[4:8], uint32(item.ChosenOrder))
|
||
_, _ = h.Write(buf[:8])
|
||
}
|
||
_, _ = h.Write([]byte{0xfe})
|
||
for _, item := range reactions.Recent {
|
||
_, _ = h.Write([]byte(item.Reaction.Type))
|
||
_, _ = h.Write([]byte{0})
|
||
_, _ = h.Write([]byte(item.Reaction.Emoticon))
|
||
_, _ = h.Write([]byte{0})
|
||
binary.LittleEndian.PutUint64(buf[:8], uint64(item.UserID))
|
||
binary.LittleEndian.PutUint32(buf[8:12], uint32(item.Date))
|
||
binary.LittleEndian.PutUint32(buf[12:16], uint32(item.ChosenOrder))
|
||
_, _ = h.Write(buf[:])
|
||
}
|
||
}
|
||
|
||
func cloneContacts(contacts []domain.Contact) []domain.Contact {
|
||
out := append([]domain.Contact(nil), contacts...)
|
||
for i := range out {
|
||
out[i] = cloneContact(out[i])
|
||
}
|
||
return out
|
||
}
|
||
|
||
func cloneContact(contact domain.Contact) domain.Contact {
|
||
contact.NoteEntities = append([]domain.MessageEntity(nil), contact.NoteEntities...)
|
||
return contact
|
||
}
|
||
|
||
func contactListHash(contacts []domain.Contact) int64 {
|
||
if len(contacts) == 0 {
|
||
return 0
|
||
}
|
||
h := fnv.New64a()
|
||
var buf [16]byte
|
||
for _, contact := range contacts {
|
||
binary.LittleEndian.PutUint64(buf[:8], uint64(contact.User.ID))
|
||
if contact.Mutual {
|
||
buf[8] = 1
|
||
} else {
|
||
buf[8] = 0
|
||
}
|
||
_, _ = h.Write(buf[:9])
|
||
_, _ = h.Write([]byte(contact.FirstName))
|
||
_, _ = h.Write([]byte{0})
|
||
_, _ = h.Write([]byte(contact.LastName))
|
||
_, _ = h.Write([]byte{0})
|
||
_, _ = h.Write([]byte(contact.Phone))
|
||
_, _ = h.Write([]byte{0})
|
||
_, _ = h.Write([]byte(contact.Note))
|
||
_, _ = h.Write([]byte{0})
|
||
}
|
||
return int64(h.Sum64())
|
||
}
|
||
|
||
func filterDialogList(list domain.DialogList, filter domain.DialogFilter) domain.DialogList {
|
||
sort.SliceStable(list.Dialogs, func(i, j int) bool {
|
||
return dialogLess(list.Dialogs[i], list.Dialogs[j])
|
||
})
|
||
|
||
base := make([]domain.Dialog, 0, len(list.Dialogs))
|
||
for _, d := range list.Dialogs {
|
||
if !dialogMatchesFolder(d, list.Users, filter) {
|
||
continue
|
||
}
|
||
if filter.PinnedOnly && !d.Pinned {
|
||
continue
|
||
}
|
||
if filter.ExcludePinned && d.Pinned {
|
||
continue
|
||
}
|
||
base = append(base, d)
|
||
}
|
||
|
||
list.Count = len(base)
|
||
list.Hash = dialogListHash(base)
|
||
limit := filter.Limit
|
||
if limit <= 0 {
|
||
limit = 100
|
||
}
|
||
if limit > 500 {
|
||
limit = 500
|
||
}
|
||
page := make([]domain.Dialog, 0, len(base))
|
||
for _, d := range base {
|
||
if !afterDialogOffset(d, filter) {
|
||
continue
|
||
}
|
||
page = append(page, d)
|
||
if len(page) >= limit {
|
||
break
|
||
}
|
||
}
|
||
list.Dialogs = page
|
||
list.Messages = keepDialogMessages(list.Messages, page)
|
||
return list
|
||
}
|
||
|
||
func dialogMatchesFolder(d domain.Dialog, users []domain.User, filter domain.DialogFilter) bool {
|
||
if !filter.HasFolderID {
|
||
return true
|
||
}
|
||
if filter.FolderID < domain.DialogCustomFolderMinID {
|
||
return d.FolderID == filter.FolderID
|
||
}
|
||
if filter.Folder == nil {
|
||
return false
|
||
}
|
||
folder := filter.Folder
|
||
if folder.ExcludeArchived && d.FolderID == domain.DialogArchiveFolderID {
|
||
return false
|
||
}
|
||
if folder.ExcludeRead && d.UnreadCount == 0 && !d.UnreadMark {
|
||
return false
|
||
}
|
||
if hasFolderPeer(folder.ExcludePeers, d.Peer) {
|
||
return false
|
||
}
|
||
if hasFolderPeer(folder.IncludePeers, d.Peer) || hasFolderPeer(folder.PinnedPeers, d.Peer) {
|
||
return true
|
||
}
|
||
if d.Peer.Type == domain.PeerTypeUser {
|
||
user, ok := findDialogUser(users, d.Peer.ID)
|
||
if ok && user.Contact && folder.Contacts {
|
||
return true
|
||
}
|
||
if (!ok || !user.Contact) && folder.NonContacts {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func hasFolderPeer(peers []domain.DialogFolderPeer, peer domain.Peer) bool {
|
||
for _, item := range peers {
|
||
if item.Peer == peer {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func dialogLess(a, b domain.Dialog) bool {
|
||
if a.Pinned != b.Pinned {
|
||
return a.Pinned && !b.Pinned
|
||
}
|
||
if a.Pinned && b.Pinned && a.PinnedOrder != b.PinnedOrder {
|
||
if a.PinnedOrder == 0 {
|
||
return false
|
||
}
|
||
if b.PinnedOrder == 0 {
|
||
return true
|
||
}
|
||
return a.PinnedOrder < b.PinnedOrder
|
||
}
|
||
if a.TopMessageDate != b.TopMessageDate {
|
||
return a.TopMessageDate > b.TopMessageDate
|
||
}
|
||
if a.TopMessage != b.TopMessage {
|
||
return a.TopMessage > b.TopMessage
|
||
}
|
||
return a.Peer.ID > b.Peer.ID
|
||
}
|
||
|
||
func afterDialogOffset(d domain.Dialog, filter domain.DialogFilter) bool {
|
||
if filter.OffsetDate <= 0 && filter.OffsetID <= 0 {
|
||
return true
|
||
}
|
||
if filter.OffsetDate > 0 {
|
||
if d.TopMessageDate != filter.OffsetDate {
|
||
return d.TopMessageDate < filter.OffsetDate
|
||
}
|
||
if filter.OffsetID <= 0 {
|
||
return false
|
||
}
|
||
if d.TopMessage != filter.OffsetID {
|
||
return d.TopMessage < filter.OffsetID
|
||
}
|
||
if filter.HasOffsetPeer {
|
||
return d.Peer.ID < filter.OffsetPeer.ID
|
||
}
|
||
return false
|
||
}
|
||
return d.TopMessage < filter.OffsetID
|
||
}
|
||
|
||
func keepDialogMessages(messages []domain.Message, dialogs []domain.Dialog) []domain.Message {
|
||
want := make(map[int]struct{}, len(dialogs))
|
||
for _, d := range dialogs {
|
||
if d.TopMessage != 0 {
|
||
want[d.TopMessage] = struct{}{}
|
||
}
|
||
}
|
||
out := make([]domain.Message, 0, len(want))
|
||
for _, msg := range messages {
|
||
if _, ok := want[msg.ID]; ok {
|
||
out = append(out, msg)
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func findDialogUser(users []domain.User, id int64) (domain.User, bool) {
|
||
for _, user := range users {
|
||
if user.ID == id {
|
||
return user, true
|
||
}
|
||
}
|
||
return domain.User{}, false
|
||
}
|
||
|
||
func appendDialogUser(list *domain.DialogList, seen map[int64]struct{}, user domain.User) {
|
||
if user.ID == 0 {
|
||
return
|
||
}
|
||
if _, ok := seen[user.ID]; ok {
|
||
return
|
||
}
|
||
seen[user.ID] = struct{}{}
|
||
list.Users = append(list.Users, user)
|
||
}
|
||
|
||
func cloneMessages(messages []domain.Message) []domain.Message {
|
||
out := append([]domain.Message(nil), messages...)
|
||
for i := range out {
|
||
out[i] = cloneMessage(out[i])
|
||
}
|
||
return out
|
||
}
|
||
|
||
func cloneDialogs(dialogs []domain.Dialog) []domain.Dialog {
|
||
out := append([]domain.Dialog(nil), dialogs...)
|
||
for i := range out {
|
||
if out[i].Draft != nil {
|
||
draft := cloneDialogDraft(*out[i].Draft)
|
||
out[i].Draft = &draft
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func cloneDialogDraft(draft domain.DialogDraft) domain.DialogDraft {
|
||
draft.Entities = append([]domain.MessageEntity(nil), draft.Entities...)
|
||
draft.ReplyTo = cloneMessageReply(draft.ReplyTo)
|
||
if draft.WebPage != nil {
|
||
webpage := *draft.WebPage
|
||
draft.WebPage = &webpage
|
||
}
|
||
return draft
|
||
}
|
||
|
||
func draftKey(peer domain.Peer, topMessageID int) dialogDraftKey {
|
||
return dialogDraftKey{peerType: peer.Type, peerID: peer.ID, topMessageID: topMessageID}
|
||
}
|
||
|
||
func sortDialogDrafts(drafts []domain.DialogDraft) {
|
||
sort.SliceStable(drafts, func(i, j int) bool {
|
||
if drafts[i].Date != drafts[j].Date {
|
||
return drafts[i].Date > drafts[j].Date
|
||
}
|
||
if drafts[i].Peer.Type != drafts[j].Peer.Type {
|
||
return drafts[i].Peer.Type < drafts[j].Peer.Type
|
||
}
|
||
if drafts[i].Peer.ID != drafts[j].Peer.ID {
|
||
return drafts[i].Peer.ID > drafts[j].Peer.ID
|
||
}
|
||
return drafts[i].TopMessageID > drafts[j].TopMessageID
|
||
})
|
||
}
|
||
|
||
func cloneDialogFolder(folder domain.DialogFolder) domain.DialogFolder {
|
||
folder.TitleEntities = append([]domain.MessageEntity(nil), folder.TitleEntities...)
|
||
folder.PinnedPeers = append([]domain.DialogFolderPeer(nil), folder.PinnedPeers...)
|
||
folder.IncludePeers = append([]domain.DialogFolderPeer(nil), folder.IncludePeers...)
|
||
folder.ExcludePeers = append([]domain.DialogFolderPeer(nil), folder.ExcludePeers...)
|
||
return folder
|
||
}
|
||
|
||
func containsInt(items []int, value int) bool {
|
||
for _, item := range items {
|
||
if item == value {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func removeInt(items []int, value int) []int {
|
||
out := items[:0]
|
||
for _, item := range items {
|
||
if item != value {
|
||
out = append(out, item)
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func dialogListHash(dialogs []domain.Dialog) int64 {
|
||
if len(dialogs) == 0 {
|
||
return 0
|
||
}
|
||
h := fnv.New64a()
|
||
var buf [47]byte
|
||
for _, d := range dialogs {
|
||
binary.LittleEndian.PutUint64(buf[:8], uint64(d.Peer.ID))
|
||
binary.LittleEndian.PutUint32(buf[8:12], uint32(d.FolderID))
|
||
binary.LittleEndian.PutUint32(buf[12:16], uint32(d.TopMessage))
|
||
binary.LittleEndian.PutUint32(buf[16:20], uint32(d.TopMessageDate))
|
||
binary.LittleEndian.PutUint32(buf[20:24], uint32(d.ReadInboxMaxID))
|
||
binary.LittleEndian.PutUint32(buf[24:28], uint32(d.ReadOutboxMaxID))
|
||
binary.LittleEndian.PutUint32(buf[28:32], uint32(d.UnreadCount))
|
||
binary.LittleEndian.PutUint32(buf[32:36], uint32(d.UnreadMentions))
|
||
binary.LittleEndian.PutUint32(buf[36:40], uint32(d.UnreadReactions))
|
||
if d.Pinned {
|
||
buf[40] = 1
|
||
} else {
|
||
buf[40] = 0
|
||
}
|
||
binary.LittleEndian.PutUint32(buf[41:45], uint32(d.PinnedOrder))
|
||
if d.UnreadMark {
|
||
buf[45] = 1
|
||
} else {
|
||
buf[45] = 0
|
||
}
|
||
if d.PeerSettingsBarHidden {
|
||
buf[46] = 1
|
||
} else {
|
||
buf[46] = 0
|
||
}
|
||
_, _ = h.Write(buf[:])
|
||
}
|
||
return int64(h.Sum64())
|
||
}
|
||
|
||
// LangPackStore 是 store.LangPackStore 的内存实现。
|
||
type LangPackStore struct {
|
||
mu sync.RWMutex
|
||
m map[string]domain.LangPack
|
||
}
|
||
|
||
// NewLangPackStore 创建内存 LangPackStore。
|
||
func NewLangPackStore() *LangPackStore {
|
||
return &LangPackStore{m: make(map[string]domain.LangPack)}
|
||
}
|
||
|
||
func (s *LangPackStore) GetPack(_ context.Context, langPack, langCode string, fromVersion int) (domain.LangPack, error) {
|
||
s.mu.RLock()
|
||
pack := s.m[langPackKey(langPack, langCode)]
|
||
s.mu.RUnlock()
|
||
if pack.LangPack == "" {
|
||
return domain.LangPack{LangPack: langPack, LangCode: langCode, FromVersion: fromVersion}, nil
|
||
}
|
||
pack.FromVersion = fromVersion
|
||
if pack.Version <= fromVersion {
|
||
pack.Strings = nil
|
||
} else {
|
||
pack.Strings = append([]domain.LangPackString(nil), pack.Strings...)
|
||
}
|
||
return pack, nil
|
||
}
|
||
|
||
func (s *LangPackStore) GetStrings(_ context.Context, langPack, langCode string, keys []string) (domain.LangPack, error) {
|
||
s.mu.RLock()
|
||
pack := s.m[langPackKey(langPack, langCode)]
|
||
s.mu.RUnlock()
|
||
if pack.LangPack == "" {
|
||
return domain.LangPack{LangPack: langPack, LangCode: langCode}, nil
|
||
}
|
||
if len(keys) == 0 {
|
||
pack.Strings = append([]domain.LangPackString(nil), pack.Strings...)
|
||
return pack, nil
|
||
}
|
||
want := make(map[string]struct{}, len(keys))
|
||
for _, key := range keys {
|
||
want[key] = struct{}{}
|
||
}
|
||
out := domain.LangPack{LangPack: pack.LangPack, LangCode: pack.LangCode, Version: pack.Version}
|
||
for _, item := range pack.Strings {
|
||
if _, ok := want[item.Key]; ok {
|
||
out.Strings = append(out.Strings, item)
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *LangPackStore) UpsertPack(_ context.Context, pack domain.LangPack) error {
|
||
pack.Strings = append([]domain.LangPackString(nil), pack.Strings...)
|
||
s.mu.Lock()
|
||
s.m[langPackKey(pack.LangPack, pack.LangCode)] = pack
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func langPackKey(langPack, langCode string) string {
|
||
return langPack + "\x00" + langCode
|
||
}
|
||
|
||
// PasswordStore 是 store.PasswordStore 的内存实现。
|
||
type PasswordStore struct {
|
||
mu sync.RWMutex
|
||
m map[int64]domain.PasswordSettings
|
||
reactions map[int64]domain.AccountReactionSettings
|
||
}
|
||
|
||
// NewPasswordStore 创建内存 PasswordStore。
|
||
func NewPasswordStore() *PasswordStore {
|
||
return &PasswordStore{
|
||
m: make(map[int64]domain.PasswordSettings),
|
||
reactions: make(map[int64]domain.AccountReactionSettings),
|
||
}
|
||
}
|
||
|
||
func (s *PasswordStore) GetByUser(_ context.Context, userID int64) (domain.PasswordSettings, bool, error) {
|
||
s.mu.RLock()
|
||
settings, ok := s.m[userID]
|
||
s.mu.RUnlock()
|
||
settings.SecureRandom = append([]byte(nil), settings.SecureRandom...)
|
||
return settings, ok, nil
|
||
}
|
||
|
||
func (s *PasswordStore) Save(_ context.Context, userID int64, settings domain.PasswordSettings) error {
|
||
settings.SecureRandom = append([]byte(nil), settings.SecureRandom...)
|
||
s.mu.Lock()
|
||
s.m[userID] = settings
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *PasswordStore) GetReactionSettings(_ context.Context, userID int64) (domain.AccountReactionSettings, bool, error) {
|
||
s.mu.RLock()
|
||
settings, ok := s.reactions[userID]
|
||
s.mu.RUnlock()
|
||
return cloneAccountReactionSettings(settings), ok, nil
|
||
}
|
||
|
||
func (s *PasswordStore) SaveReactionSettings(_ context.Context, userID int64, settings domain.AccountReactionSettings) error {
|
||
s.mu.Lock()
|
||
s.reactions[userID] = cloneAccountReactionSettings(settings)
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func cloneAccountReactionSettings(in domain.AccountReactionSettings) domain.AccountReactionSettings {
|
||
out := in
|
||
if in.PaidPrivacy.Peer != nil {
|
||
peer := *in.PaidPrivacy.Peer
|
||
out.PaidPrivacy.Peer = &peer
|
||
}
|
||
return out
|
||
}
|
||
|
||
// HelpStore 是 store.AppConfigStore 和 store.CountryStore 的内存实现。
|
||
type HelpStore struct {
|
||
mu sync.RWMutex
|
||
appConfig map[string]domain.AppConfig
|
||
countries domain.CountriesList
|
||
}
|
||
|
||
// NewHelpStore 创建内存 HelpStore。
|
||
func NewHelpStore() *HelpStore {
|
||
return &HelpStore{appConfig: make(map[string]domain.AppConfig)}
|
||
}
|
||
|
||
func (s *HelpStore) GetAppConfig(_ context.Context, client string) (domain.AppConfig, bool, error) {
|
||
s.mu.RLock()
|
||
cfg, ok := s.appConfig[client]
|
||
s.mu.RUnlock()
|
||
cfg.JSON = append([]byte(nil), cfg.JSON...)
|
||
return cfg, ok, nil
|
||
}
|
||
|
||
func (s *HelpStore) UpsertAppConfig(_ context.Context, cfg domain.AppConfig) error {
|
||
cfg.JSON = append([]byte(nil), cfg.JSON...)
|
||
s.mu.Lock()
|
||
s.appConfig[cfg.Client] = cfg
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *HelpStore) ListCountries(_ context.Context, _ string) (domain.CountriesList, error) {
|
||
s.mu.RLock()
|
||
list := s.countries
|
||
s.mu.RUnlock()
|
||
list.Countries = append([]domain.Country(nil), list.Countries...)
|
||
for i := range list.Countries {
|
||
list.Countries[i].CountryCodes = append([]domain.CountryCode(nil), list.Countries[i].CountryCodes...)
|
||
}
|
||
return list, nil
|
||
}
|
||
|
||
func (s *HelpStore) UpsertCountries(_ context.Context, countries []domain.Country) error {
|
||
list := domain.CountriesList{Hash: 1, Countries: append([]domain.Country(nil), countries...)}
|
||
for i := range list.Countries {
|
||
list.Countries[i].CountryCodes = append([]domain.CountryCode(nil), list.Countries[i].CountryCodes...)
|
||
}
|
||
s.mu.Lock()
|
||
s.countries = list
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
// UserStore 是 store.UserStore 的内存实现。ID 与 PG identity 使用同一业务起点。
|
||
type UserStore struct {
|
||
mu sync.RWMutex
|
||
byID map[int64]domain.User
|
||
nextID int64
|
||
}
|
||
|
||
// NewUserStore 创建内存 UserStore。
|
||
func NewUserStore() *UserStore {
|
||
return &UserStore{byID: make(map[int64]domain.User), nextID: domain.UserIDSequenceBase}
|
||
}
|
||
|
||
func (s *UserStore) ByID(_ context.Context, id int64) (domain.User, bool, error) {
|
||
s.mu.RLock()
|
||
u, ok := s.byID[id]
|
||
s.mu.RUnlock()
|
||
return u, ok, nil
|
||
}
|
||
|
||
func (s *UserStore) ByIDs(_ context.Context, ids []int64) ([]domain.User, error) {
|
||
if len(ids) == 0 {
|
||
return nil, nil
|
||
}
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
out := make([]domain.User, 0, len(ids))
|
||
seen := make(map[int64]struct{}, len(ids))
|
||
for _, id := range ids {
|
||
if id == 0 {
|
||
continue
|
||
}
|
||
if _, ok := seen[id]; ok {
|
||
continue
|
||
}
|
||
seen[id] = struct{}{}
|
||
if u, ok := s.byID[id]; ok {
|
||
out = append(out, u)
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *UserStore) ByPhone(_ context.Context, phone string) (domain.User, bool, error) {
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
for _, u := range s.byID {
|
||
if u.Phone == phone {
|
||
return u, true, nil
|
||
}
|
||
}
|
||
return domain.User{}, false, nil
|
||
}
|
||
|
||
func (s *UserStore) ByPhones(_ context.Context, phones []string) ([]domain.User, error) {
|
||
if len(phones) == 0 {
|
||
return nil, nil
|
||
}
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
want := make(map[string]struct{}, len(phones))
|
||
for _, phone := range phones {
|
||
if phone != "" {
|
||
want[phone] = struct{}{}
|
||
}
|
||
}
|
||
out := make([]domain.User, 0, len(want))
|
||
seenIDs := map[int64]struct{}{}
|
||
for _, u := range s.byID {
|
||
if _, ok := want[u.Phone]; !ok {
|
||
continue
|
||
}
|
||
if _, ok := seenIDs[u.ID]; ok {
|
||
continue
|
||
}
|
||
seenIDs[u.ID] = struct{}{}
|
||
out = append(out, u)
|
||
}
|
||
sort.SliceStable(out, func(i, j int) bool { return out[i].ID < out[j].ID })
|
||
return out, nil
|
||
}
|
||
|
||
func (s *UserStore) ByUsername(_ context.Context, username string) (domain.User, bool, error) {
|
||
username = strings.ToLower(strings.TrimSpace(strings.TrimPrefix(username, "@")))
|
||
if username == "" {
|
||
return domain.User{}, false, nil
|
||
}
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
for _, u := range s.byID {
|
||
if strings.ToLower(u.Username) == username {
|
||
return u, true, nil
|
||
}
|
||
}
|
||
return domain.User{}, false, nil
|
||
}
|
||
|
||
func (s *UserStore) Search(_ context.Context, currentUserID int64, query, phoneQuery string, limit int) (domain.UserSearchResult, error) {
|
||
if limit <= 0 {
|
||
limit = 50
|
||
}
|
||
query = strings.ToLower(strings.TrimSpace(query))
|
||
phoneQuery = strings.TrimSpace(phoneQuery)
|
||
if query == "" {
|
||
return domain.UserSearchResult{}, nil
|
||
}
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
users := make([]domain.User, 0)
|
||
for _, u := range s.byID {
|
||
if u.ID == currentUserID {
|
||
continue
|
||
}
|
||
if userMatchesSearch(u, query, phoneQuery) {
|
||
users = append(users, u)
|
||
}
|
||
}
|
||
sort.SliceStable(users, func(i, j int) bool {
|
||
return users[i].ID < users[j].ID
|
||
})
|
||
if len(users) > limit {
|
||
users = users[:limit]
|
||
}
|
||
return domain.UserSearchResult{Results: users}, nil
|
||
}
|
||
|
||
func (s *UserStore) UpdateUsername(_ context.Context, userID int64, username string) (domain.User, error) {
|
||
username = strings.TrimSpace(strings.TrimPrefix(username, "@"))
|
||
usernameLower := strings.ToLower(username)
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
u, ok := s.byID[userID]
|
||
if !ok {
|
||
return domain.User{}, domain.ErrUsernameNotOccupied
|
||
}
|
||
if usernameLower != "" {
|
||
for id, existing := range s.byID {
|
||
if id != userID && strings.ToLower(existing.Username) == usernameLower {
|
||
return domain.User{}, domain.ErrUsernameOccupied
|
||
}
|
||
}
|
||
}
|
||
u.Username = username
|
||
s.byID[userID] = u
|
||
return u, nil
|
||
}
|
||
|
||
func (s *UserStore) UpdateProfile(_ context.Context, userID int64, firstName, lastName, about string) (domain.User, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
u, ok := s.byID[userID]
|
||
if !ok {
|
||
return domain.User{}, domain.ErrUsernameNotOccupied
|
||
}
|
||
u.FirstName = firstName
|
||
u.LastName = lastName
|
||
u.About = about
|
||
s.byID[userID] = u
|
||
return u, nil
|
||
}
|
||
|
||
func (s *UserStore) UpdateLastSeen(_ context.Context, userID int64, lastSeenAt int) error {
|
||
if lastSeenAt <= 0 {
|
||
return nil
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
u, ok := s.byID[userID]
|
||
if !ok {
|
||
return domain.ErrUsernameNotOccupied
|
||
}
|
||
if lastSeenAt > u.LastSeenAt {
|
||
u.LastSeenAt = lastSeenAt
|
||
s.byID[userID] = u
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func userMatchesSearch(u domain.User, query, phoneQuery string) bool {
|
||
if phoneQuery != "" && strings.HasPrefix(u.Phone, phoneQuery) {
|
||
return true
|
||
}
|
||
first := strings.ToLower(u.FirstName)
|
||
last := strings.ToLower(u.LastName)
|
||
username := strings.ToLower(u.Username)
|
||
fullName := strings.TrimSpace(first + " " + last)
|
||
return strings.Contains(first, query) ||
|
||
strings.Contains(last, query) ||
|
||
strings.Contains(fullName, query) ||
|
||
strings.Contains(username, query)
|
||
}
|
||
|
||
func (s *UserStore) Create(_ context.Context, u domain.User) (domain.User, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
username := strings.ToLower(strings.TrimSpace(u.Username))
|
||
if username != "" {
|
||
for _, existing := range s.byID {
|
||
if strings.ToLower(existing.Username) == username {
|
||
return domain.User{}, domain.ErrUsernameOccupied
|
||
}
|
||
}
|
||
}
|
||
u.ID = s.nextID
|
||
s.nextID++
|
||
s.byID[u.ID] = u
|
||
return u, nil
|
||
}
|
||
|
||
// AuthorizationStore 是 store.AuthorizationStore 的内存实现。
|
||
type AuthorizationStore struct {
|
||
mu sync.RWMutex
|
||
m map[[8]byte]domain.Authorization
|
||
}
|
||
|
||
// NewAuthorizationStore 创建内存 AuthorizationStore。
|
||
func NewAuthorizationStore() *AuthorizationStore {
|
||
return &AuthorizationStore{m: make(map[[8]byte]domain.Authorization)}
|
||
}
|
||
|
||
func (s *AuthorizationStore) Bind(_ context.Context, a domain.Authorization) error {
|
||
s.mu.Lock()
|
||
s.m[a.AuthKeyID] = a
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *AuthorizationStore) ByAuthKey(_ context.Context, id [8]byte) (domain.Authorization, bool, error) {
|
||
s.mu.RLock()
|
||
a, ok := s.m[id]
|
||
s.mu.RUnlock()
|
||
return a, ok, nil
|
||
}
|
||
|
||
func (s *AuthorizationStore) ListByUser(_ context.Context, userID int64) ([]domain.Authorization, error) {
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
out := make([]domain.Authorization, 0)
|
||
for _, a := range s.m {
|
||
if a.UserID == userID {
|
||
out = append(out, a)
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *AuthorizationStore) Delete(_ context.Context, id [8]byte) error {
|
||
s.mu.Lock()
|
||
delete(s.m, id)
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
// CodeStore 是 store.CodeStore 的内存实现（带 TTL）。
|
||
type CodeStore struct {
|
||
mu sync.Mutex
|
||
m map[string]codeEntry
|
||
}
|
||
|
||
type codeEntry struct {
|
||
code store.PhoneCode
|
||
expires time.Time
|
||
}
|
||
|
||
// NewCodeStore 创建内存 CodeStore。
|
||
func NewCodeStore() *CodeStore {
|
||
return &CodeStore{m: make(map[string]codeEntry)}
|
||
}
|
||
|
||
func (s *CodeStore) Set(_ context.Context, hash string, code store.PhoneCode, ttl time.Duration) error {
|
||
s.mu.Lock()
|
||
s.m[hash] = codeEntry{code: code, expires: time.Now().Add(ttl)}
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
func (s *CodeStore) Get(_ context.Context, hash string) (store.PhoneCode, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
e, ok := s.m[hash]
|
||
if !ok || time.Now().After(e.expires) {
|
||
return store.PhoneCode{}, false, nil
|
||
}
|
||
return e.code, true, nil
|
||
}
|
||
|
||
func (s *CodeStore) Del(_ context.Context, hash string) error {
|
||
s.mu.Lock()
|
||
delete(s.m, hash)
|
||
s.mu.Unlock()
|
||
return nil
|
||
}
|