Files
mtusi2026lab6/internal/service/message.go
T

191 lines
5.6 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package service
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"regexp"
"time"
"github.com/google/uuid"
"github.com/charawein/mtusi2026lab6/internal/domain"
"github.com/charawein/mtusi2026lab6/internal/repository"
redisrepo "github.com/charawein/mtusi2026lab6/internal/repository/redis"
)
type MessageService struct {
messages repository.MessageRepository
chats repository.ChatRepository
cache *redisrepo.MessageCache
idempotencyTTL time.Duration
}
func NewMessageService(messages repository.MessageRepository, chats repository.ChatRepository, cache *redisrepo.MessageCache, idempotencyTTL time.Duration) *MessageService {
return &MessageService{messages: messages, chats: chats, cache: cache, idempotencyTTL: idempotencyTTL}
}
var idempotencyKeyRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
// requestHash — отпечаток семантики тела запроса. Хешируем уже разобранные поля,
// а не сырые байты: порядок ключей JSON не важен, отсутствующий attachment_ids
// равен [], порядок самих вложений значим.
func requestHash(text string, attachmentIDs []string) string {
if attachmentIDs == nil {
attachmentIDs = []string{}
}
raw, _ := json.Marshal(struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
}{Text: text, AttachmentIDs: attachmentIDs})
sum := sha256.Sum256(raw)
return hex.EncodeToString(sum[:])
}
// Send создаёт сообщение с обязательным Idempotency-Key. Повтор с тем же ключом
// и телом возвращает исходное сообщение, с другим телом — ErrConflict.
// Доступ к чату проверяется при каждом повторе.
func (s *MessageService) Send(ctx context.Context, senderID, chatID, text string, attachmentIDs []string, idempotencyKey string) (*domain.Message, error) {
if !idempotencyKeyRe.MatchString(idempotencyKey) {
return nil, ErrInvalidInput
}
parsed, err := uuid.Parse(chatID)
if err != nil {
return nil, ErrInvalidInput
}
chatID = parsed.String()
ids, ok := normalizeAttachmentIDs(attachmentIDs)
if !ok {
return nil, ErrInvalidInput
}
// С вложениями допустим пустой text; иначе — обычные правила текста.
if !(len(ids) > 0 && text == "") && !validateText(text) {
return nil, ErrInvalidInput
}
ok, err = s.chats.IsMember(ctx, chatID, senderID)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, ErrNotFound
}
return nil, err
}
if !ok {
return nil, ErrNotFound
}
m := &domain.Message{
ID: newID(),
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: nowUTC(),
AttachmentIDs: ids,
}
stored, created, err := s.messages.CreateIdempotent(ctx, m, idempotencyKey, requestHash(text, ids), s.idempotencyTTL)
if err != nil {
switch {
case errors.Is(err, repository.ErrConflict):
return nil, ErrConflict
case errors.Is(err, repository.ErrNotFound):
return nil, ErrNotFound // чужое/неизвестное/незавершённое вложение
}
return nil, err
}
if !created {
return stored, nil
}
// Версия чата уже увеличена в транзакции записи; здесь только режим scan.
if s.cache != nil {
s.cache.OnWrite(ctx, chatID)
}
return m, nil
}
func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor string, limit int) ([]*domain.Message, string, error) {
parsed, err := uuid.Parse(chatID)
if err != nil {
return nil, "", ErrInvalidInput
}
chatID = parsed.String()
if limit < 1 || limit > 100 {
return nil, "", ErrInvalidInput
}
// Членство и версия истории — одним запросом к PostgreSQL. Версия читается
// до истории, поэтому под ключом версии v лежат данные не старее v.
version, ok, err := s.chats.MemberVersion(ctx, chatID, callerID)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, "", ErrNotFound
}
return nil, "", err
}
if !ok {
return nil, "", ErrNotFound
}
if s.cache != nil {
if items, next, hit := s.cache.Get(ctx, chatID, version, cursor, limit); hit {
return items, next, nil
}
}
cursorTime := time.Unix(0, 0).UTC()
cursorID := "00000000-0000-0000-0000-000000000000"
if cursor != "" {
t, id, err := decodeCursor(cursor, chatID)
if err != nil {
return nil, "", err
}
cursorTime, cursorID = t, id
}
items, err := s.messages.ListByChat(ctx, chatID, cursorTime, cursorID, limit+1)
if err != nil {
return nil, "", err
}
if items == nil {
items = []*domain.Message{}
}
var next string
if len(items) > limit {
items = items[:limit]
last := items[limit-1]
next = encodeCursor(chatID, last.CreatedAt, last.ID)
}
if s.cache != nil {
s.cache.Set(ctx, chatID, version, cursor, limit, items, next)
}
return items, next, nil
}
// normalizeAttachmentIDs: 0–10 уникальных UUID; приводит к каноническому виду.
func normalizeAttachmentIDs(in []string) ([]string, bool) {
if len(in) > 10 {
return nil, false
}
out := make([]string, 0, len(in))
seen := make(map[string]bool, len(in))
for _, raw := range in {
u, err := uuid.Parse(raw)
if err != nil {
return nil, false
}
id := u.String()
if seen[id] {
return nil, false
}
seen[id] = true
out = append(out, id)
}
return out, true
}