forked from mtusi2026/mtusi2026lab2
312 lines
6.9 KiB
Go
312 lines
6.9 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
var _ Store = (*Memory)(nil)
|
|
|
|
type Memory struct {
|
|
mu sync.RWMutex
|
|
|
|
users map[string]domain.User
|
|
byName map[string]string
|
|
hashes map[string]string
|
|
|
|
chats map[string]*chatBucket
|
|
chatOrder []string
|
|
|
|
lastTime time.Time
|
|
|
|
maxMessages int
|
|
messagesTotal int
|
|
}
|
|
|
|
type chatBucket struct {
|
|
chat domain.Chat
|
|
members map[string]struct{}
|
|
messages []domain.Message
|
|
}
|
|
|
|
func New() *Memory {
|
|
return NewWithLimit(0)
|
|
}
|
|
|
|
func NewWithLimit(maxMessages int) *Memory {
|
|
return &Memory{
|
|
users: make(map[string]domain.User),
|
|
byName: make(map[string]string),
|
|
hashes: make(map[string]string),
|
|
chats: make(map[string]*chatBucket),
|
|
maxMessages: maxMessages,
|
|
}
|
|
}
|
|
|
|
func (m *Memory) MessagesTotal() int {
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
return m.messagesTotal
|
|
}
|
|
|
|
func (m *Memory) now() time.Time {
|
|
t := time.Now().UTC()
|
|
if !t.After(m.lastTime) {
|
|
t = m.lastTime.Add(time.Nanosecond)
|
|
}
|
|
m.lastTime = t
|
|
return t
|
|
}
|
|
|
|
func (m *Memory) CreateUser(_ context.Context, username, displayName, passwordHash string) (domain.User, error) {
|
|
if strings.TrimSpace(username) == "" || strings.TrimSpace(displayName) == "" {
|
|
return domain.User{}, domain.ErrInvalidArgument
|
|
}
|
|
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
if _, taken := m.byName[username]; taken {
|
|
return domain.User{}, domain.ErrConflict
|
|
}
|
|
|
|
u := domain.User{
|
|
ID: uuid.NewString(),
|
|
Username: username,
|
|
DisplayName: displayName,
|
|
CreatedAt: m.now(),
|
|
}
|
|
m.users[u.ID] = u
|
|
m.byName[username] = u.ID
|
|
m.hashes[u.ID] = passwordHash
|
|
return u, nil
|
|
}
|
|
|
|
func (m *Memory) UserByID(_ context.Context, id string) (domain.User, error) {
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
u, ok := m.users[id]
|
|
if !ok {
|
|
return domain.User{}, domain.ErrNotFound
|
|
}
|
|
return u, nil
|
|
}
|
|
|
|
func (m *Memory) CredentialsByUsername(_ context.Context, username string) (domain.User, string, error) {
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
id, ok := m.byName[username]
|
|
if !ok {
|
|
return domain.User{}, "", domain.ErrNotFound
|
|
}
|
|
return m.users[id], m.hashes[id], nil
|
|
}
|
|
|
|
func (m *Memory) UsernameExists(_ context.Context, username string) bool {
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
_, taken := m.byName[username]
|
|
return taken
|
|
}
|
|
|
|
func (m *Memory) CreateChat(_ context.Context, callerID, title string, memberIDs []string) (domain.Chat, error) {
|
|
if strings.TrimSpace(title) == "" {
|
|
return domain.Chat{}, domain.ErrInvalidArgument
|
|
}
|
|
if len(memberIDs) == 0 || len(memberIDs) > 100 {
|
|
return domain.Chat{}, domain.ErrInvalidArgument
|
|
}
|
|
|
|
seen := make(map[string]struct{}, len(memberIDs))
|
|
callerInMembers := false
|
|
for _, id := range memberIDs {
|
|
if _, dup := seen[id]; dup {
|
|
return domain.Chat{}, domain.ErrInvalidArgument
|
|
}
|
|
seen[id] = struct{}{}
|
|
if id == callerID {
|
|
callerInMembers = true
|
|
}
|
|
}
|
|
if !callerInMembers {
|
|
return domain.Chat{}, domain.ErrInvalidArgument
|
|
}
|
|
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
for _, id := range memberIDs {
|
|
if _, ok := m.users[id]; !ok {
|
|
return domain.Chat{}, domain.ErrInvalidArgument
|
|
}
|
|
}
|
|
|
|
members := append([]string(nil), memberIDs...)
|
|
|
|
chat := domain.Chat{
|
|
ID: uuid.NewString(),
|
|
Title: title,
|
|
MemberIDs: members,
|
|
CreatedAt: m.now(),
|
|
}
|
|
m.chats[chat.ID] = &chatBucket{
|
|
chat: chat,
|
|
members: seen,
|
|
}
|
|
m.chatOrder = append(m.chatOrder, chat.ID)
|
|
return cloneChat(chat), nil
|
|
}
|
|
|
|
func (m *Memory) ChatByID(_ context.Context, callerID, chatID string) (domain.Chat, error) {
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
|
|
b, ok := m.chats[chatID]
|
|
if !ok {
|
|
return domain.Chat{}, domain.ErrNotFound
|
|
}
|
|
if _, member := b.members[callerID]; !member {
|
|
return domain.Chat{}, domain.ErrNotFound
|
|
}
|
|
return cloneChat(b.chat), nil
|
|
}
|
|
|
|
func (m *Memory) ListChats(_ context.Context, callerID, cursor string, limit int) (domain.Page[domain.Chat], error) {
|
|
if limit <= 0 || limit > 100 {
|
|
return domain.Page[domain.Chat]{}, domain.ErrInvalidArgument
|
|
}
|
|
c, err := domain.DecodeCursor(cursor)
|
|
if err != nil {
|
|
return domain.Page[domain.Chat]{}, err
|
|
}
|
|
if cursor != "" && c.Scope != "chats:"+callerID {
|
|
return domain.Page[domain.Chat]{}, domain.ErrInvalidArgument
|
|
}
|
|
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
|
|
out := make([]domain.Chat, 0, limit+1)
|
|
for _, id := range m.chatOrder {
|
|
b := m.chats[id]
|
|
if _, member := b.members[callerID]; !member {
|
|
continue
|
|
}
|
|
if !c.Less(b.chat.CreatedAt, b.chat.ID) {
|
|
continue
|
|
}
|
|
out = append(out, cloneChat(b.chat))
|
|
if len(out) > limit {
|
|
break
|
|
}
|
|
}
|
|
|
|
page := domain.Page[domain.Chat]{}
|
|
if len(out) > limit {
|
|
last := out[limit-1]
|
|
page.NextCursor = domain.EncodeCursor(domain.Cursor{
|
|
CreatedAt: last.CreatedAt,
|
|
ID: last.ID,
|
|
Scope: "chats:" + callerID,
|
|
})
|
|
out = out[:limit]
|
|
}
|
|
page.Items = out
|
|
return page, nil
|
|
}
|
|
|
|
func (m *Memory) AddMessage(_ context.Context, callerID, chatID, text string) (domain.Message, error) {
|
|
if strings.TrimSpace(text) == "" {
|
|
return domain.Message{}, domain.ErrInvalidArgument
|
|
}
|
|
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
|
|
b, ok := m.chats[chatID]
|
|
if !ok {
|
|
return domain.Message{}, domain.ErrNotFound
|
|
}
|
|
if _, member := b.members[callerID]; !member {
|
|
return domain.Message{}, domain.ErrNotFound
|
|
}
|
|
|
|
if m.maxMessages > 0 && m.messagesTotal >= m.maxMessages {
|
|
return domain.Message{}, domain.ErrUnavailable
|
|
}
|
|
|
|
msg := domain.Message{
|
|
ID: uuid.NewString(),
|
|
ChatID: chatID,
|
|
AuthorID: callerID,
|
|
Text: text,
|
|
CreatedAt: m.now(),
|
|
}
|
|
b.messages = append(b.messages, msg)
|
|
m.messagesTotal++
|
|
return msg, nil
|
|
}
|
|
|
|
func (m *Memory) ListMessages(_ context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
|
|
if limit <= 0 || limit > 100 {
|
|
return domain.Page[domain.Message]{}, domain.ErrInvalidArgument
|
|
}
|
|
c, err := domain.DecodeCursor(cursor)
|
|
if err != nil {
|
|
return domain.Page[domain.Message]{}, err
|
|
}
|
|
|
|
if cursor != "" && c.Scope != "chat:"+chatID {
|
|
return domain.Page[domain.Message]{}, domain.ErrInvalidArgument
|
|
}
|
|
|
|
m.mu.RLock()
|
|
defer m.mu.RUnlock()
|
|
|
|
b, ok := m.chats[chatID]
|
|
if !ok {
|
|
return domain.Page[domain.Message]{}, domain.ErrNotFound
|
|
}
|
|
if _, member := b.members[callerID]; !member {
|
|
return domain.Page[domain.Message]{}, domain.ErrNotFound
|
|
}
|
|
|
|
start := 0
|
|
for ; start < len(b.messages); start++ {
|
|
if c.Less(b.messages[start].CreatedAt, b.messages[start].ID) {
|
|
break
|
|
}
|
|
}
|
|
|
|
end := start + limit
|
|
hasMore := end < len(b.messages)
|
|
if end > len(b.messages) {
|
|
end = len(b.messages)
|
|
}
|
|
|
|
out := make([]domain.Message, end-start)
|
|
copy(out, b.messages[start:end])
|
|
|
|
page := domain.Page[domain.Message]{Items: out}
|
|
if hasMore && len(out) > 0 {
|
|
last := out[len(out)-1]
|
|
page.NextCursor = domain.EncodeCursor(domain.Cursor{
|
|
CreatedAt: last.CreatedAt,
|
|
ID: last.ID,
|
|
Scope: "chat:" + chatID,
|
|
})
|
|
}
|
|
return page, nil
|
|
}
|
|
|
|
func cloneChat(c domain.Chat) domain.Chat {
|
|
out := c
|
|
out.MemberIDs = append([]string(nil), c.MemberIDs...)
|
|
return out
|
|
}
|