forked from mtusi2026/mtusi2026lab3
288 lines
6.2 KiB
Go
288 lines
6.2 KiB
Go
package memory
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"sync"
|
|
"time"
|
|
|
|
"mtusi2026lab3/internal/domain"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type MemoryStore struct {
|
|
mu sync.RWMutex
|
|
|
|
usersByID map[string]domain.User //key = user UUID
|
|
usersByUsername map[string]string //key = username для быстрой проверки уникальности
|
|
|
|
chatsByID map[string]domain.Chat //key = chat UUID
|
|
|
|
messagesByChatID map[string][]domain.Message // key = chat UUID, value = слайс сообщений
|
|
}
|
|
|
|
func NewMemoryStore() *MemoryStore {
|
|
return &MemoryStore{
|
|
usersByID: make(map[string]domain.User),
|
|
usersByUsername: make(map[string]string),
|
|
chatsByID: make(map[string]domain.Chat),
|
|
messagesByChatID: make(map[string][]domain.Message),
|
|
}
|
|
}
|
|
|
|
// ---пользователи---
|
|
|
|
func (s *MemoryStore) CreateUser(username, displayName string) (domain.User, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
// дубликат username -> 409 Conflict
|
|
if _, exists := s.usersByUsername[username]; exists {
|
|
return domain.User{}, ErrConflict
|
|
}
|
|
|
|
user := domain.User{
|
|
ID: uuid.NewString(),
|
|
Username: username,
|
|
DisplayName: displayName,
|
|
CreatedAt: time.Now().UTC(),
|
|
}
|
|
|
|
s.usersByID[user.ID] = user
|
|
s.usersByUsername[user.Username] = user.ID
|
|
|
|
return user, nil
|
|
}
|
|
|
|
func (s *MemoryStore) GetUserByID(id string) (domain.User, error) {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
user, exists := s.usersByID[id]
|
|
if !exists {
|
|
return domain.User{}, ErrNotFound
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
// ---чаты---
|
|
|
|
func (s *MemoryStore) CreateChat(title string, memberIDs []string) (domain.Chat, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
//все участники рил существуют
|
|
for _, memberID := range memberIDs {
|
|
if _, exists := s.usersByID[memberID]; !exists {
|
|
return domain.Chat{}, fmt.Errorf(
|
|
"%w: member %s",
|
|
ErrNotFound,
|
|
memberID,
|
|
)
|
|
}
|
|
}
|
|
|
|
chat := domain.Chat{
|
|
ID: uuid.NewString(),
|
|
Title: title,
|
|
MemberIDs: append([]string(nil), memberIDs...), //копирую слайс для изоляции
|
|
CreatedAt: time.Now().UTC(),
|
|
}
|
|
|
|
s.chatsByID[chat.ID] = chat
|
|
s.messagesByChatID[chat.ID] = make([]domain.Message, 0)
|
|
|
|
return chat, nil
|
|
}
|
|
|
|
func (s *MemoryStore) GetChatByID(chatID, callerID string) (domain.Chat, error) {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
chat, exists := s.chatsByID[chatID]
|
|
if !exists {
|
|
return domain.Chat{}, ErrNotFound
|
|
}
|
|
|
|
// Требование безопасности: посторонний получает 404, а не 403
|
|
isMember := false
|
|
for _, m := range chat.MemberIDs {
|
|
if m == callerID {
|
|
isMember = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !isMember {
|
|
return domain.Chat{}, ErrNotFound
|
|
}
|
|
|
|
return chat, nil
|
|
}
|
|
|
|
func (s *MemoryStore) GetChatsForUser(
|
|
userID string,
|
|
limit int,
|
|
cursorData *domain.ChatCursor,
|
|
) ([]domain.Chat, bool, error) {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
chats := make([]domain.Chat, 0)
|
|
|
|
for _, chat := range s.chatsByID {
|
|
for _, memberID := range chat.MemberIDs {
|
|
if memberID == userID {
|
|
chats = append(chats, chat)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
sort.Slice(chats, func(i, j int) bool {
|
|
if chats[i].CreatedAt.Equal(chats[j].CreatedAt) {
|
|
return chats[i].ID < chats[j].ID
|
|
}
|
|
|
|
return chats[i].CreatedAt.Before(chats[j].CreatedAt)
|
|
})
|
|
|
|
start := 0
|
|
|
|
if cursorData != nil {
|
|
start = sort.Search(len(chats), func(index int) bool {
|
|
chat := chats[index]
|
|
|
|
if chat.CreatedAt.After(cursorData.CreatedAt) {
|
|
return true
|
|
}
|
|
|
|
return chat.CreatedAt.Equal(cursorData.CreatedAt) &&
|
|
chat.ID > cursorData.ChatID
|
|
})
|
|
}
|
|
|
|
if start >= len(chats) {
|
|
return make([]domain.Chat, 0), false, nil
|
|
}
|
|
|
|
end := start + limit
|
|
if end > len(chats) {
|
|
end = len(chats)
|
|
}
|
|
|
|
items := make([]domain.Chat, end-start)
|
|
copy(items, chats[start:end])
|
|
return items, end < len(chats), nil
|
|
}
|
|
|
|
// ---Сообщения---
|
|
|
|
func (s *MemoryStore) CreateMessage(
|
|
chatID, senderID, text string,
|
|
) (domain.Message, error) {
|
|
messageID := uuid.NewString()
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
chat, exists := s.chatsByID[chatID]
|
|
if !exists {
|
|
return domain.Message{}, ErrNotFound
|
|
}
|
|
|
|
isMember := false
|
|
for _, memberID := range chat.MemberIDs {
|
|
if memberID == senderID {
|
|
isMember = true
|
|
break
|
|
}
|
|
}
|
|
if !isMember {
|
|
return domain.Message{}, ErrNotFound
|
|
}
|
|
|
|
createdAt := time.Now().UTC()
|
|
|
|
messages := s.messagesByChatID[chatID]
|
|
if len(messages) > 0 {
|
|
lastCreatedAt := messages[len(messages)-1].CreatedAt
|
|
|
|
// Обеспечиваем строго возрастающее время внутри каждого чата.
|
|
if !createdAt.After(lastCreatedAt) {
|
|
createdAt = lastCreatedAt.Add(time.Nanosecond)
|
|
}
|
|
}
|
|
|
|
message := domain.Message{
|
|
ID: messageID,
|
|
ChatID: chatID,
|
|
SenderID: senderID,
|
|
Text: text,
|
|
CreatedAt: createdAt,
|
|
}
|
|
|
|
s.messagesByChatID[chatID] = append(messages, message)
|
|
|
|
return message, nil
|
|
}
|
|
|
|
func (s *MemoryStore) GetMessages(
|
|
chatID, callerID string,
|
|
limit int,
|
|
cursorData *domain.MessageCursor,
|
|
) ([]domain.Message, bool, error) {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
|
|
chat, exists := s.chatsByID[chatID]
|
|
if !exists {
|
|
return nil, false, ErrNotFound
|
|
}
|
|
|
|
isMember := false
|
|
for _, memberID := range chat.MemberIDs {
|
|
if memberID == callerID {
|
|
isMember = true
|
|
break
|
|
}
|
|
}
|
|
if !isMember {
|
|
return nil, false, ErrNotFound
|
|
}
|
|
|
|
messages := s.messagesByChatID[chatID]
|
|
|
|
start := 0
|
|
|
|
if cursorData != nil {
|
|
// Срез уже упорядочен во время записи, поэтому вместо
|
|
// полного прохода используем бинарный поиск.
|
|
start = sort.Search(len(messages), func(index int) bool {
|
|
message := messages[index]
|
|
|
|
if message.CreatedAt.After(cursorData.CreatedAt) {
|
|
return true
|
|
}
|
|
|
|
return message.CreatedAt.Equal(cursorData.CreatedAt) &&
|
|
message.ID > cursorData.MessageID
|
|
})
|
|
}
|
|
|
|
if start >= len(messages) {
|
|
return make([]domain.Message, 0), false, nil
|
|
}
|
|
|
|
end := len(messages)
|
|
if limit > 0 && end-start > limit {
|
|
end = start + limit
|
|
}
|
|
|
|
// копируем только возвращаемую страницу, а не всю историю, изменяя внутренний срез
|
|
items := make([]domain.Message, end-start)
|
|
copy(items, messages[start:end])
|
|
return items, end < len(messages), nil
|
|
}
|