75 lines
2 KiB
Go
75 lines
2 KiB
Go
package memory
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
"telesrv/internal/domain"
|
|
)
|
|
|
|
type privacyStoreKey struct {
|
|
ownerUserID int64
|
|
key domain.PrivacyKey
|
|
}
|
|
|
|
// PrivacyStore is an in-memory account privacy rule store for tests/dev mode.
|
|
type PrivacyStore struct {
|
|
mu sync.RWMutex
|
|
rules map[privacyStoreKey]domain.PrivacyRules
|
|
}
|
|
|
|
func NewPrivacyStore() *PrivacyStore {
|
|
return &PrivacyStore{rules: make(map[privacyStoreKey]domain.PrivacyRules)}
|
|
}
|
|
|
|
func (s *PrivacyStore) GetPrivacyRules(_ context.Context, ownerUserID int64, key domain.PrivacyKey) (domain.PrivacyRules, bool, error) {
|
|
s.mu.RLock()
|
|
rules, ok := s.rules[privacyStoreKey{ownerUserID: ownerUserID, key: key}]
|
|
s.mu.RUnlock()
|
|
return clonePrivacyRules(rules), ok, nil
|
|
}
|
|
|
|
func (s *PrivacyStore) SetPrivacyRules(_ context.Context, rules domain.PrivacyRules) error {
|
|
s.mu.Lock()
|
|
s.rules[privacyStoreKey{ownerUserID: rules.OwnerUserID, key: rules.Key}] = clonePrivacyRules(rules)
|
|
s.mu.Unlock()
|
|
return nil
|
|
}
|
|
|
|
func (s *PrivacyStore) ListPrivacyRules(_ context.Context, ownerUserIDs []int64, keys []domain.PrivacyKey) ([]domain.PrivacyRules, error) {
|
|
if len(ownerUserIDs) == 0 || len(keys) == 0 {
|
|
return nil, nil
|
|
}
|
|
owners := make(map[int64]struct{}, len(ownerUserIDs))
|
|
for _, id := range ownerUserIDs {
|
|
owners[id] = struct{}{}
|
|
}
|
|
keySet := make(map[domain.PrivacyKey]struct{}, len(keys))
|
|
for _, key := range keys {
|
|
keySet[key] = struct{}{}
|
|
}
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
out := make([]domain.PrivacyRules, 0, len(s.rules))
|
|
for k, rules := range s.rules {
|
|
if _, ok := owners[k.ownerUserID]; !ok {
|
|
continue
|
|
}
|
|
if _, ok := keySet[k.key]; !ok {
|
|
continue
|
|
}
|
|
out = append(out, clonePrivacyRules(rules))
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func clonePrivacyRules(in domain.PrivacyRules) domain.PrivacyRules {
|
|
out := in
|
|
out.Rules = make([]domain.PrivacyRule, len(in.Rules))
|
|
for i, rule := range in.Rules {
|
|
out.Rules[i] = rule
|
|
out.Rules[i].UserIDs = append([]int64(nil), rule.UserIDs...)
|
|
out.Rules[i].ChatIDs = append([]int64(nil), rule.ChatIDs...)
|
|
}
|
|
return out
|
|
}
|