811 lines
24 KiB
Go
811 lines
24 KiB
Go
package memory
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"fmt"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
|
||
"telesrv/internal/domain"
|
||
)
|
||
|
||
// GroupCallStore 是 store.GroupCallStore 的进程内实现（rpc 单测 fixture 用）。
|
||
// 行为契约与 postgres 实现由共享 contract test 钉死（groupcall contract test），
|
||
// 凡动 version/参与者语义两边必须同步并跑 PG 集成。
|
||
type overrideKey struct {
|
||
callID, setter, target int64
|
||
}
|
||
|
||
type conferenceRandomKey struct {
|
||
creatorID int64
|
||
randomID int64
|
||
}
|
||
|
||
type inviteMessageKey struct {
|
||
userID int64
|
||
msgID int
|
||
}
|
||
|
||
type chainKey struct {
|
||
callID int64
|
||
subChainID int
|
||
}
|
||
|
||
type GroupCallStore struct {
|
||
mu sync.Mutex
|
||
calls map[int64]domain.GroupCall
|
||
activeByChan map[int64]int64 // channelID → active callID
|
||
bySlug map[string]int64
|
||
byConferenceRnd map[conferenceRandomKey]int64
|
||
participants map[int64]map[int64]domain.GroupCallParticipant // callID → userID → row
|
||
invites map[int64][]domain.GroupCallInvite
|
||
inviteByMessage map[inviteMessageKey]domain.GroupCallInvite
|
||
chainBlocks map[chainKey][]domain.GroupCallChainBlock
|
||
overrides map[overrideKey]domain.GroupCallParticipantOverride
|
||
raiseHandSeq map[int64]int64 // callID → 单调举手序号
|
||
nextSyntheticID int64
|
||
}
|
||
|
||
// NewGroupCallStore 创建内存实现。
|
||
func NewGroupCallStore() *GroupCallStore {
|
||
return &GroupCallStore{
|
||
calls: make(map[int64]domain.GroupCall),
|
||
activeByChan: make(map[int64]int64),
|
||
bySlug: make(map[string]int64),
|
||
byConferenceRnd: make(map[conferenceRandomKey]int64),
|
||
participants: make(map[int64]map[int64]domain.GroupCallParticipant),
|
||
invites: make(map[int64][]domain.GroupCallInvite),
|
||
inviteByMessage: make(map[inviteMessageKey]domain.GroupCallInvite),
|
||
chainBlocks: make(map[chainKey][]domain.GroupCallChainBlock),
|
||
overrides: make(map[overrideKey]domain.GroupCallParticipantOverride),
|
||
raiseHandSeq: make(map[int64]int64),
|
||
}
|
||
}
|
||
|
||
func (s *GroupCallStore) CreateGroupCall(_ context.Context, call domain.GroupCall) (domain.GroupCall, error) {
|
||
if call.ID == 0 || call.ChannelID == 0 || call.AccessHash == 0 {
|
||
return domain.GroupCall{}, domain.ErrGroupCallInvalid
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
if activeID, ok := s.activeByChan[call.ChannelID]; ok {
|
||
if existing, ok := s.calls[activeID]; ok && existing.Active() {
|
||
return domain.GroupCall{}, domain.ErrGroupCallAlreadyStarted
|
||
}
|
||
}
|
||
if _, exists := s.calls[call.ID]; exists {
|
||
return domain.GroupCall{}, domain.ErrGroupCallInvalid
|
||
}
|
||
call.Kind = domain.GroupCallKindChannel
|
||
call.State = domain.GroupCallStateActive
|
||
if call.Version <= 0 {
|
||
call.Version = 1
|
||
}
|
||
call.ParticipantsCount = 0
|
||
s.calls[call.ID] = call
|
||
s.activeByChan[call.ChannelID] = call.ID
|
||
s.participants[call.ID] = make(map[int64]domain.GroupCallParticipant)
|
||
return call, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) CreateConferenceCall(_ context.Context, call domain.GroupCall) (domain.GroupCall, error) {
|
||
if call.ID == 0 || call.AccessHash == 0 || call.CreatorUserID == 0 || call.InviteSlug == "" || call.InviteLink == "" {
|
||
return domain.GroupCall{}, domain.ErrGroupCallInvalid
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
if call.RandomID != 0 {
|
||
if id, ok := s.byConferenceRnd[conferenceRandomKey{creatorID: call.CreatorUserID, randomID: call.RandomID}]; ok {
|
||
existing := s.calls[id]
|
||
return existing, nil
|
||
}
|
||
}
|
||
if _, exists := s.calls[call.ID]; exists {
|
||
return domain.GroupCall{}, domain.ErrGroupCallInvalid
|
||
}
|
||
if _, exists := s.bySlug[call.InviteSlug]; exists {
|
||
return domain.GroupCall{}, domain.ErrGroupCallInvalid
|
||
}
|
||
call.Kind = domain.GroupCallKindConference
|
||
call.ChannelID = 0
|
||
call.State = domain.GroupCallStateActive
|
||
if call.Version <= 0 {
|
||
call.Version = 1
|
||
}
|
||
call.ParticipantsCount = 0
|
||
s.calls[call.ID] = call
|
||
s.bySlug[call.InviteSlug] = call.ID
|
||
if call.RandomID != 0 {
|
||
s.byConferenceRnd[conferenceRandomKey{creatorID: call.CreatorUserID, randomID: call.RandomID}] = call.ID
|
||
}
|
||
s.participants[call.ID] = make(map[int64]domain.GroupCallParticipant)
|
||
return call, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) GetGroupCall(_ context.Context, callID int64) (domain.GroupCall, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[callID]
|
||
return call, ok, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) GetGroupCallBySlug(_ context.Context, slug string) (domain.GroupCall, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
id, ok := s.bySlug[slug]
|
||
if !ok {
|
||
return domain.GroupCall{}, false, nil
|
||
}
|
||
call, ok := s.calls[id]
|
||
return call, ok, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) GetGroupCallByInviteMessage(_ context.Context, userID int64, msgID int) (domain.GroupCall, domain.GroupCallInvite, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
inv, ok := s.inviteByMessage[inviteMessageKey{userID: userID, msgID: msgID}]
|
||
if !ok {
|
||
return domain.GroupCall{}, domain.GroupCallInvite{}, false, nil
|
||
}
|
||
call, ok := s.calls[inv.CallID]
|
||
return call, inv, ok, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) JoinGroupCall(_ context.Context, req domain.JoinGroupCallRequest) (domain.GroupCallMutation, error) {
|
||
if req.SSRC == 0 {
|
||
return domain.GroupCallMutation{}, domain.ErrGroupCallInvalid
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[req.CallID]
|
||
if !ok {
|
||
return domain.GroupCallMutation{}, domain.ErrGroupCallInvalid
|
||
}
|
||
if !call.Active() {
|
||
return domain.GroupCallMutation{}, domain.ErrGroupCallDiscarded
|
||
}
|
||
rows := s.participants[req.CallID]
|
||
for userID, p := range rows {
|
||
if !p.Left && p.SSRC == req.SSRC && userID != req.UserID {
|
||
return domain.GroupCallMutation{}, domain.ErrGroupCallSSRCDuplicate
|
||
}
|
||
}
|
||
existing, rejoining := rows[req.UserID]
|
||
wasActive := rejoining && !existing.Left
|
||
p := domain.GroupCallParticipant{
|
||
CallID: req.CallID,
|
||
UserID: req.UserID,
|
||
SSRC: req.SSRC,
|
||
JoinDate: req.Now,
|
||
ActiveDate: req.Now,
|
||
LastCheckDate: req.Now,
|
||
// VideoJSON 整体替换、PresentationJSON 随全新行清空（rejoin 后客户端
|
||
// 会重发 joinGroupCallPresentation，旧屏幕登记必须作废）。
|
||
VideoJSON: append([]byte(nil), req.VideoJSON...),
|
||
PublicKey: append([]byte(nil), req.PublicKey...),
|
||
JoinBlock: append([]byte(nil), req.JoinBlock...),
|
||
}
|
||
if rejoining && wasActive {
|
||
// 同设备换 ssrc 的 rejoin 保留原 join_date（列表排序稳定）。
|
||
p.JoinDate = existing.JoinDate
|
||
}
|
||
// join_muted 策略：普通成员入会即静音且不可自行开麦（muted_by_admin）。
|
||
if call.JoinMuted && !req.IsAdmin {
|
||
p.Muted = true
|
||
p.MutedByAdmin = true
|
||
}
|
||
rows[req.UserID] = p
|
||
for i, inv := range s.invites[req.CallID] {
|
||
if inv.InviteeUserID == req.UserID && inv.Status == domain.GroupCallInvitePending {
|
||
inv.Status = domain.GroupCallInviteAccepted
|
||
inv.UpdatedAt = req.Now
|
||
s.invites[req.CallID][i] = inv
|
||
s.inviteByMessage[inviteMessageKey{userID: inv.InviteeUserID, msgID: inv.MessageID}] = inv
|
||
}
|
||
}
|
||
if !wasActive {
|
||
call.ParticipantsCount++
|
||
}
|
||
call.Version++
|
||
s.calls[req.CallID] = call
|
||
return domain.GroupCallMutation{Call: call, Participant: p}, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) LeaveGroupCall(_ context.Context, callID, userID int64, now int) (domain.GroupCallMutation, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[callID]
|
||
if !ok {
|
||
return domain.GroupCallMutation{}, domain.ErrGroupCallInvalid
|
||
}
|
||
p, ok := s.participants[callID][userID]
|
||
if !ok || p.Left {
|
||
return domain.GroupCallMutation{}, domain.ErrGroupCallNotJoined
|
||
}
|
||
p.Left = true
|
||
p.ActiveDate = now
|
||
s.participants[callID][userID] = p
|
||
if call.ParticipantsCount > 0 {
|
||
call.ParticipantsCount--
|
||
}
|
||
call.Version++
|
||
discardEmptyConference(&call, now)
|
||
s.calls[callID] = call
|
||
return domain.GroupCallMutation{Call: call, Participant: p}, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) RemoveConferenceCallParticipants(_ context.Context, req domain.RemoveConferenceCallParticipantsRequest) (domain.RemoveConferenceCallParticipantsResult, error) {
|
||
if req.CallID == 0 || len(req.TargetUserIDs) == 0 || req.OnlyLeft == req.Kick {
|
||
return domain.RemoveConferenceCallParticipantsResult{}, domain.ErrGroupCallInvalid
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[req.CallID]
|
||
if !ok || !call.Conference() {
|
||
return domain.RemoveConferenceCallParticipantsResult{}, domain.ErrGroupCallInvalid
|
||
}
|
||
if !call.Active() {
|
||
return domain.RemoveConferenceCallParticipantsResult{}, domain.ErrGroupCallDiscarded
|
||
}
|
||
rows := s.participants[req.CallID]
|
||
targets := uniqueNonZeroInt64s(req.TargetUserIDs...)
|
||
e2eTargets := make([]int64, 0, len(targets))
|
||
mediaTargets := make([]int64, 0, len(targets))
|
||
for _, targetID := range targets {
|
||
p, ok := rows[targetID]
|
||
if !ok {
|
||
continue
|
||
}
|
||
hasE2EMarker := len(p.JoinBlock) > 0
|
||
if req.OnlyLeft {
|
||
if p.Left && hasE2EMarker {
|
||
e2eTargets = append(e2eTargets, targetID)
|
||
}
|
||
continue
|
||
}
|
||
if req.Kick {
|
||
if hasE2EMarker {
|
||
e2eTargets = append(e2eTargets, targetID)
|
||
}
|
||
if !p.Left {
|
||
mediaTargets = append(mediaTargets, targetID)
|
||
}
|
||
}
|
||
}
|
||
out := domain.RemoveConferenceCallParticipantsResult{Call: call}
|
||
if len(e2eTargets) > 0 {
|
||
if len(req.Block) == 0 {
|
||
return domain.RemoveConferenceCallParticipantsResult{}, domain.ErrConferenceChainInvalid
|
||
}
|
||
block, err := s.appendGroupCallChainBlockLocked(domain.GroupCallChainBlock{
|
||
CallID: req.CallID,
|
||
SubChainID: 0,
|
||
Offset: -1,
|
||
AuthorUserID: req.AuthorUserID,
|
||
Block: req.Block,
|
||
CreatedAt: req.Now,
|
||
})
|
||
if err != nil {
|
||
return domain.RemoveConferenceCallParticipantsResult{}, err
|
||
}
|
||
out.ChainBlock = block
|
||
out.ChainBlockAppended = true
|
||
for _, targetID := range e2eTargets {
|
||
p := rows[targetID]
|
||
p.PublicKey = nil
|
||
p.JoinBlock = nil
|
||
rows[targetID] = p
|
||
}
|
||
}
|
||
if len(mediaTargets) > 0 {
|
||
out.ParticipantsChanged = make([]domain.GroupCallParticipant, 0, len(mediaTargets))
|
||
for _, targetID := range mediaTargets {
|
||
p := rows[targetID]
|
||
if p.Left {
|
||
continue
|
||
}
|
||
p.Left = true
|
||
p.ActiveDate = req.Now
|
||
rows[targetID] = p
|
||
if call.ParticipantsCount > 0 {
|
||
call.ParticipantsCount--
|
||
}
|
||
call.Version++
|
||
out.ParticipantsChanged = append(out.ParticipantsChanged, p)
|
||
}
|
||
discardEmptyConference(&call, req.Now)
|
||
s.calls[req.CallID] = call
|
||
out.Call = call
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) DiscardGroupCall(_ context.Context, callID int64, now int) (domain.GroupCall, []domain.GroupCallParticipant, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[callID]
|
||
if !ok {
|
||
return domain.GroupCall{}, nil, domain.ErrGroupCallInvalid
|
||
}
|
||
if !call.Active() {
|
||
return domain.GroupCall{}, nil, domain.ErrGroupCallDiscarded
|
||
}
|
||
var active []domain.GroupCallParticipant
|
||
for userID, p := range s.participants[callID] {
|
||
if p.Left {
|
||
continue
|
||
}
|
||
active = append(active, p)
|
||
p.Left = true
|
||
p.ActiveDate = now
|
||
s.participants[callID][userID] = p
|
||
}
|
||
call.State = domain.GroupCallStateDiscarded
|
||
call.DiscardedAt = now
|
||
call.Duration = max(0, now-call.CreatedAt)
|
||
call.ParticipantsCount = 0
|
||
call.Version++
|
||
s.calls[callID] = call
|
||
if s.activeByChan[call.ChannelID] == callID {
|
||
delete(s.activeByChan, call.ChannelID)
|
||
}
|
||
sort.Slice(active, func(i, j int) bool { return active[i].UserID < active[j].UserID })
|
||
return call, active, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) TouchParticipant(_ context.Context, callID, userID int64, now int) ([]int64, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[callID]
|
||
if !ok {
|
||
return nil, false, domain.ErrGroupCallInvalid
|
||
}
|
||
if !call.Active() {
|
||
return nil, false, nil
|
||
}
|
||
p, ok := s.participants[callID][userID]
|
||
if !ok || p.Left {
|
||
return nil, false, nil
|
||
}
|
||
p.LastCheckDate = now
|
||
p.ActiveDate = now
|
||
s.participants[callID][userID] = p
|
||
return []int64{p.SSRC}, true, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) GetParticipant(_ context.Context, callID, userID int64) (domain.GroupCallParticipant, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
p, ok := s.participants[callID][userID]
|
||
return p, ok, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) ListParticipants(_ context.Context, callID int64, offset string, limit int) (domain.GroupCallParticipantPage, error) {
|
||
if limit <= 0 || limit > 200 {
|
||
limit = 200
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[callID]
|
||
if !ok {
|
||
return domain.GroupCallParticipantPage{}, domain.ErrGroupCallInvalid
|
||
}
|
||
var rows []domain.GroupCallParticipant
|
||
for _, p := range s.participants[callID] {
|
||
if !p.Left {
|
||
rows = append(rows, p)
|
||
}
|
||
}
|
||
sort.Slice(rows, func(i, j int) bool {
|
||
if rows[i].JoinDate != rows[j].JoinDate {
|
||
return rows[i].JoinDate < rows[j].JoinDate
|
||
}
|
||
return rows[i].UserID < rows[j].UserID
|
||
})
|
||
page := domain.GroupCallParticipantPage{Count: len(rows), Version: call.Version}
|
||
offDate, offUser, hasOffset := parseGroupCallOffset(offset)
|
||
for _, p := range rows {
|
||
if hasOffset && (p.JoinDate < offDate || (p.JoinDate == offDate && p.UserID <= offUser)) {
|
||
continue
|
||
}
|
||
page.Participants = append(page.Participants, p)
|
||
if len(page.Participants) == limit {
|
||
break
|
||
}
|
||
}
|
||
if n := len(page.Participants); n == limit && n < page.Count {
|
||
last := page.Participants[n-1]
|
||
page.NextOffset = formatGroupCallOffset(last.JoinDate, last.UserID)
|
||
}
|
||
return page, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) UpdateParticipant(_ context.Context, callID, userID int64, update domain.GroupCallParticipantUpdate) (domain.GroupCallMutation, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[callID]
|
||
if !ok {
|
||
return domain.GroupCallMutation{}, false, domain.ErrGroupCallInvalid
|
||
}
|
||
if !call.Active() {
|
||
return domain.GroupCallMutation{}, false, domain.ErrGroupCallDiscarded
|
||
}
|
||
p, ok := s.participants[callID][userID]
|
||
if !ok || p.Left {
|
||
return domain.GroupCallMutation{}, false, domain.ErrGroupCallNotJoined
|
||
}
|
||
changed := applyGroupCallParticipantUpdate(&p, update)
|
||
if !changed {
|
||
return domain.GroupCallMutation{Call: call, Participant: p}, false, nil
|
||
}
|
||
if update.Now > 0 {
|
||
p.ActiveDate = update.Now
|
||
}
|
||
s.participants[callID][userID] = p
|
||
call.Version++
|
||
s.calls[callID] = call
|
||
return domain.GroupCallMutation{Call: call, Participant: p}, true, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) SetGroupCallTitle(_ context.Context, callID int64, title string) (domain.GroupCall, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[callID]
|
||
if !ok {
|
||
return domain.GroupCall{}, false, domain.ErrGroupCallInvalid
|
||
}
|
||
if call.Title == title {
|
||
return call, false, nil
|
||
}
|
||
call.Title = title
|
||
s.calls[callID] = call
|
||
return call, true, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) SetGroupCallJoinMuted(_ context.Context, callID int64, joinMuted bool) (domain.GroupCall, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[callID]
|
||
if !ok {
|
||
return domain.GroupCall{}, false, domain.ErrGroupCallInvalid
|
||
}
|
||
if call.JoinMuted == joinMuted {
|
||
return call, false, nil
|
||
}
|
||
call.JoinMuted = joinMuted
|
||
s.calls[callID] = call
|
||
return call, true, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) SetStartedMessageID(_ context.Context, callID int64, msgID int) error {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[callID]
|
||
if !ok {
|
||
return domain.ErrGroupCallInvalid
|
||
}
|
||
call.StartedMsgID = msgID
|
||
s.calls[callID] = call
|
||
return nil
|
||
}
|
||
|
||
func (s *GroupCallStore) SweepStaleParticipants(_ context.Context, checkOlderThan, now, limit int) ([]domain.GroupCallMutation, error) {
|
||
if limit <= 0 {
|
||
limit = 100
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
var out []domain.GroupCallMutation
|
||
for callID, rows := range s.participants {
|
||
call := s.calls[callID]
|
||
if !call.Active() {
|
||
continue
|
||
}
|
||
userIDs := make([]int64, 0, len(rows))
|
||
for userID := range rows {
|
||
userIDs = append(userIDs, userID)
|
||
}
|
||
sort.Slice(userIDs, func(i, j int) bool { return userIDs[i] < userIDs[j] })
|
||
for _, userID := range userIDs {
|
||
p := rows[userID]
|
||
if p.Left || p.LastCheckDate >= checkOlderThan {
|
||
continue
|
||
}
|
||
p.Left = true
|
||
p.ActiveDate = now
|
||
rows[userID] = p
|
||
if call.ParticipantsCount > 0 {
|
||
call.ParticipantsCount--
|
||
}
|
||
call.Version++
|
||
out = append(out, domain.GroupCallMutation{Call: call, Participant: p})
|
||
if len(out) == limit {
|
||
s.calls[callID] = call
|
||
return out, nil
|
||
}
|
||
}
|
||
s.calls[callID] = call
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) ResetAllParticipants(_ context.Context, now int) ([]domain.GroupCall, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
var out []domain.GroupCall
|
||
for callID, rows := range s.participants {
|
||
call := s.calls[callID]
|
||
if !call.Active() {
|
||
continue
|
||
}
|
||
cleared := false
|
||
for userID, p := range rows {
|
||
if p.Left {
|
||
continue
|
||
}
|
||
p.Left = true
|
||
p.ActiveDate = now
|
||
rows[userID] = p
|
||
cleared = true
|
||
}
|
||
if !cleared {
|
||
continue
|
||
}
|
||
call.ParticipantsCount = 0
|
||
call.Version++
|
||
discardEmptyConference(&call, now)
|
||
s.calls[callID] = call
|
||
out = append(out, call)
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func discardEmptyConference(call *domain.GroupCall, now int) {
|
||
if call == nil || !call.Conference() || !call.Active() || call.ParticipantsCount > 0 {
|
||
return
|
||
}
|
||
call.State = domain.GroupCallStateDiscarded
|
||
call.DiscardedAt = now
|
||
call.Duration = max(0, now-call.CreatedAt)
|
||
}
|
||
|
||
func applyGroupCallParticipantUpdate(p *domain.GroupCallParticipant, u domain.GroupCallParticipantUpdate) bool {
|
||
changed := false
|
||
if u.Muted != nil && p.Muted != *u.Muted {
|
||
p.Muted = *u.Muted
|
||
changed = true
|
||
}
|
||
if u.MutedByAdmin != nil && p.MutedByAdmin != *u.MutedByAdmin {
|
||
p.MutedByAdmin = *u.MutedByAdmin
|
||
changed = true
|
||
}
|
||
if u.VolumeByAdmin != nil && p.VolumeByAdmin != *u.VolumeByAdmin {
|
||
p.VolumeByAdmin = *u.VolumeByAdmin
|
||
changed = true
|
||
}
|
||
if u.RaiseHandRating != nil && p.RaiseHandRating != *u.RaiseHandRating {
|
||
p.RaiseHandRating = *u.RaiseHandRating
|
||
changed = true
|
||
}
|
||
if u.VideoJSON != nil && string(p.VideoJSON) != string(*u.VideoJSON) {
|
||
p.VideoJSON = append([]byte(nil), *u.VideoJSON...)
|
||
changed = true
|
||
}
|
||
if u.PresentationJSON != nil && string(p.PresentationJSON) != string(*u.PresentationJSON) {
|
||
p.PresentationJSON = append([]byte(nil), *u.PresentationJSON...)
|
||
changed = true
|
||
}
|
||
return changed
|
||
}
|
||
|
||
func parseGroupCallOffset(offset string) (joinDate int, userID int64, ok bool) {
|
||
if offset == "" {
|
||
return 0, 0, false
|
||
}
|
||
parts := strings.Split(offset, ":")
|
||
if len(parts) != 3 || parts[0] != "j" {
|
||
return 0, 0, false
|
||
}
|
||
d, err1 := strconv.Atoi(parts[1])
|
||
u, err2 := strconv.ParseInt(parts[2], 10, 64)
|
||
if err1 != nil || err2 != nil {
|
||
return 0, 0, false
|
||
}
|
||
return d, u, true
|
||
}
|
||
|
||
func formatGroupCallOffset(joinDate int, userID int64) string {
|
||
return fmt.Sprintf("j:%d:%d", joinDate, userID)
|
||
}
|
||
|
||
func (s *GroupCallStore) NextRaiseHandRating(_ context.Context, callID int64) (int64, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
s.raiseHandSeq[callID]++
|
||
return s.raiseHandSeq[callID], nil
|
||
}
|
||
|
||
func (s *GroupCallStore) SetParticipantOverride(_ context.Context, callID, setterUserID, targetUserID int64, override domain.GroupCallParticipantOverride, clear bool) error {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
key := overrideKey{callID: callID, setter: setterUserID, target: targetUserID}
|
||
if clear {
|
||
delete(s.overrides, key)
|
||
return nil
|
||
}
|
||
s.overrides[key] = override
|
||
return nil
|
||
}
|
||
|
||
func (s *GroupCallStore) GetParticipantOverride(_ context.Context, callID, setterUserID, targetUserID int64) (domain.GroupCallParticipantOverride, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
ov, ok := s.overrides[overrideKey{callID: callID, setter: setterUserID, target: targetUserID}]
|
||
return ov, ok, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) CreateConferenceInvite(_ context.Context, invite domain.GroupCallInvite) (domain.GroupCallInvite, error) {
|
||
if invite.CallID == 0 || invite.InviterUserID == 0 || invite.InviteeUserID == 0 || invite.MessageID == 0 {
|
||
return domain.GroupCallInvite{}, domain.ErrGroupCallInvalid
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[invite.CallID]
|
||
if !ok || !call.Conference() {
|
||
return domain.GroupCallInvite{}, domain.ErrGroupCallInvalid
|
||
}
|
||
if invite.Status == "" {
|
||
invite.Status = domain.GroupCallInvitePending
|
||
}
|
||
key := inviteMessageKey{userID: invite.InviteeUserID, msgID: invite.MessageID}
|
||
if existing, ok := s.inviteByMessage[key]; ok {
|
||
return existing, nil
|
||
}
|
||
s.invites[invite.CallID] = append(s.invites[invite.CallID], invite)
|
||
s.inviteByMessage[key] = invite
|
||
return invite, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) SetConferenceInviteStatus(_ context.Context, callID int64, inviteeUserID int64, msgID int, status domain.GroupCallInviteStatus, now int) (domain.GroupCallInvite, bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
key := inviteMessageKey{userID: inviteeUserID, msgID: msgID}
|
||
inv, ok := s.inviteByMessage[key]
|
||
if !ok || inv.CallID != callID {
|
||
return domain.GroupCallInvite{}, false, nil
|
||
}
|
||
if inv.Status == status {
|
||
return inv, false, nil
|
||
}
|
||
inv.Status = status
|
||
inv.UpdatedAt = now
|
||
s.inviteByMessage[key] = inv
|
||
for i, row := range s.invites[callID] {
|
||
if row.InviteeUserID == inviteeUserID && row.MessageID == msgID {
|
||
s.invites[callID][i] = inv
|
||
break
|
||
}
|
||
}
|
||
return inv, true, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) ListConferenceRecipientUserIDs(_ context.Context, callID int64) ([]int64, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
call, ok := s.calls[callID]
|
||
if !ok {
|
||
return nil, domain.ErrGroupCallInvalid
|
||
}
|
||
includeHistorical := !call.Active()
|
||
seen := map[int64]struct{}{}
|
||
if call.CreatorUserID != 0 {
|
||
seen[call.CreatorUserID] = struct{}{}
|
||
}
|
||
for userID, p := range s.participants[callID] {
|
||
if includeHistorical || !p.Left {
|
||
seen[userID] = struct{}{}
|
||
}
|
||
}
|
||
for _, inv := range s.invites[callID] {
|
||
if includeHistorical || inv.Status == domain.GroupCallInvitePending || inv.Status == domain.GroupCallInviteAccepted {
|
||
seen[inv.InviteeUserID] = struct{}{}
|
||
seen[inv.InviterUserID] = struct{}{}
|
||
}
|
||
}
|
||
out := make([]int64, 0, len(seen))
|
||
for id := range seen {
|
||
out = append(out, id)
|
||
}
|
||
sort.Slice(out, func(i, j int) bool { return out[i] < out[j] })
|
||
return out, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) AppendGroupCallChainBlock(_ context.Context, block domain.GroupCallChainBlock) (domain.GroupCallChainBlock, error) {
|
||
if block.CallID == 0 || len(block.Block) == 0 {
|
||
return domain.GroupCallChainBlock{}, domain.ErrGroupCallInvalid
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
return s.appendGroupCallChainBlockLocked(block)
|
||
}
|
||
|
||
func (s *GroupCallStore) appendGroupCallChainBlockLocked(block domain.GroupCallChainBlock) (domain.GroupCallChainBlock, error) {
|
||
if call, ok := s.calls[block.CallID]; !ok || !call.Conference() {
|
||
return domain.GroupCallChainBlock{}, domain.ErrGroupCallInvalid
|
||
}
|
||
key := chainKey{callID: block.CallID, subChainID: block.SubChainID}
|
||
rows := s.chainBlocks[key]
|
||
for _, row := range rows {
|
||
if bytes.Equal(row.Block, block.Block) {
|
||
return domain.GroupCallChainBlock{}, domain.ErrConferenceChainInvalid
|
||
}
|
||
}
|
||
nextOffset := 0
|
||
if len(rows) > 0 {
|
||
nextOffset = rows[len(rows)-1].Offset + 1
|
||
}
|
||
if block.Offset < 0 {
|
||
block.Offset = nextOffset
|
||
}
|
||
if block.Offset != nextOffset {
|
||
return domain.GroupCallChainBlock{}, domain.ErrConferenceChainInvalid
|
||
}
|
||
for _, row := range rows {
|
||
if row.Offset == block.Offset {
|
||
return domain.GroupCallChainBlock{}, domain.ErrConferenceChainInvalid
|
||
}
|
||
}
|
||
block.Block = append([]byte(nil), block.Block...)
|
||
s.chainBlocks[key] = append(rows, block)
|
||
sort.Slice(s.chainBlocks[key], func(i, j int) bool {
|
||
return s.chainBlocks[key][i].Offset < s.chainBlocks[key][j].Offset
|
||
})
|
||
return block, nil
|
||
}
|
||
|
||
func (s *GroupCallStore) ListGroupCallChainBlocks(_ context.Context, callID int64, subChainID, offset, limit int) (domain.GroupCallChainBlockPage, error) {
|
||
if limit <= 0 || limit > 100 {
|
||
limit = 100
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
if call, ok := s.calls[callID]; !ok || !call.Conference() {
|
||
return domain.GroupCallChainBlockPage{}, domain.ErrGroupCallInvalid
|
||
}
|
||
rows := s.chainBlocks[chainKey{callID: callID, subChainID: subChainID}]
|
||
if offset == domain.GroupCallChainBlockLatestOffset {
|
||
page := domain.GroupCallChainBlockPage{NextOffset: 0}
|
||
if len(rows) == 0 {
|
||
return page, nil
|
||
}
|
||
block := rows[len(rows)-1]
|
||
page.Blocks = append(page.Blocks, block)
|
||
page.NextOffset = block.Offset + 1
|
||
return page, nil
|
||
}
|
||
if offset < 0 {
|
||
return domain.GroupCallChainBlockPage{}, domain.ErrGroupCallInvalid
|
||
}
|
||
page := domain.GroupCallChainBlockPage{NextOffset: offset}
|
||
for _, row := range rows {
|
||
if row.Offset < offset {
|
||
continue
|
||
}
|
||
page.Blocks = append(page.Blocks, row)
|
||
page.NextOffset = row.Offset + 1
|
||
if len(page.Blocks) == limit {
|
||
break
|
||
}
|
||
}
|
||
return page, nil
|
||
}
|
||
|
||
func max(a, b int) int {
|
||
if a > b {
|
||
return a
|
||
}
|
||
return b
|
||
}
|