Files
mtusi2026lab2/internal/service/message.go
T

134 lines
2.6 KiB
Go

package service
import (
"context"
"errors"
"time"
"github.com/google/uuid"
"mtusi2026-messenger/internal/db"
"mtusi2026-messenger/internal/model"
"mtusi2026-messenger/internal/postgres"
)
var ErrMessageChatNotFound = errors.New("chat not found")
type messageQueries interface {
CreateMessage(ctx context.Context, arg db.CreateMessageParams) (db.Message, error)
IsChatMember(ctx context.Context, arg db.IsChatMemberParams) (bool, error)
ListMessages(ctx context.Context, arg db.ListMessagesParams) ([]db.Message, error)
}
type MessageService struct {
q messageQueries
}
func NewMessageService(q *db.Queries) *MessageService {
return &MessageService{q: q}
}
func (s *MessageService) Create(
ctx context.Context,
userID uuid.UUID,
chatID uuid.UUID,
text string,
) (model.Message, error) {
id, err := uuid.NewV7()
if err != nil {
return model.Message{}, err
}
row, err := s.q.CreateMessage(ctx, db.CreateMessageParams{
ID: id,
ChatID: chatID,
SenderID: userID,
Text: text,
})
if postgres.IsNotFound(err) {
return model.Message{}, ErrMessageChatNotFound
}
if err != nil {
return model.Message{}, err
}
return model.Message{
ID: row.ID,
ChatID: row.ChatID,
SenderID: row.SenderID,
Text: row.Text,
CreatedAt: row.CreatedAt,
}, nil
}
func (s *MessageService) List(
ctx context.Context,
userID uuid.UUID,
chatID uuid.UUID,
limit int,
cursor *string,
) ([]model.Message, *string, error) {
isMember, err := s.q.IsChatMember(ctx, db.IsChatMemberParams{
ChatID: chatID,
UserID: userID,
})
if err != nil {
return nil, nil, err
}
if !isMember {
return nil, nil, ErrMessageChatNotFound
}
var afterCreatedAt *time.Time
var afterID *uuid.UUID
if cursor != nil {
decoded, err := decodeCursor(*cursor, chatID)
if err != nil {
return nil, nil, ErrInvalidCursor
}
afterCreatedAt = &decoded.CreatedAt
afterID = &decoded.ID
}
rows, err := s.q.ListMessages(ctx, db.ListMessagesParams{
ChatID: chatID,
AfterCreatedAt: afterCreatedAt,
AfterID: afterID,
Lim: int32(limit + 1),
})
if err != nil {
return nil, nil, err
}
hasMore := len(rows) > limit
if hasMore {
rows = rows[:limit]
}
messages := make([]model.Message, 0, len(rows))
for _, r := range rows {
messages = append(messages, model.Message{
ID: r.ID,
ChatID: r.ChatID,
SenderID: r.SenderID,
Text: r.Text,
CreatedAt: r.CreatedAt,
})
}
var next *string
if hasMore {
last := messages[len(messages)-1]
c := encodeCursor(Cursor{
ChatID: chatID,
CreatedAt: last.CreatedAt,
ID: last.ID,
})
next = &c
}
return messages, next, nil
}