Files
mtusi2026lab2/internal/service/message.go
T

135 lines
2.8 KiB
Go

package service
import (
"context"
"errors"
"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)
ListMessagesAfter(ctx context.Context, arg db.ListMessagesAfterParams) ([]db.Message, error)
ListMessagesFirstPage(ctx context.Context, arg db.ListMessagesFirstPageParams) ([]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 rows []db.Message
if cursor == nil {
rows, err = s.q.ListMessagesFirstPage(ctx, db.ListMessagesFirstPageParams{
ChatID: chatID,
Lim: int32(limit + 1),
})
} else {
decoded, derr := decodeCursor(*cursor, chatID)
if derr != nil {
return nil, nil, ErrInvalidCursor
}
rows, err = s.q.ListMessagesAfter(ctx, db.ListMessagesAfterParams{
ChatID: chatID,
AfterCreatedAt: decoded.CreatedAt,
AfterID: decoded.ID,
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
}