Files
mtusi2026lab3/internal/repository/postgres/message.go
T

150 lines
3.8 KiB
Go

package postgres
import (
"context"
"highload/internal/database/sqlc"
"highload/internal/model"
"highload/internal/repository"
"time"
"github.com/jackc/pgx/v5/pgtype"
"github.com/jackc/pgx/v5/pgxpool"
)
type MessageRepository struct {
queries *sqlc.Queries
pool *pgxpool.Pool
}
func NewMessageRepository(queries *sqlc.Queries, pool *pgxpool.Pool) *MessageRepository {
return &MessageRepository{
queries: queries,
pool: pool,
}
}
func (r *MessageRepository) CreateMessage(ctx context.Context, chatID, senderID, text, key string) (*model.Message, error) {
uuidChatID, err := getUUIDFromString(chatID)
if err != nil {
return nil, convertDBError(err)
}
txCtx, cancel := context.WithTimeout(ctx, time.Second)
defer cancel()
uuidSenderID, err := getUUIDFromString(senderID)
if err != nil {
return nil, convertDBError(err)
}
tx, err := r.pool.Begin(txCtx)
if err != nil {
return nil, convertDBError(err)
}
defer func() {
rollbackCtx, rollbackCancel := context.WithTimeout(
context.WithoutCancel(ctx),
time.Second,
)
defer rollbackCancel()
_ = tx.Rollback(rollbackCtx)
}()
txQueries := r.queries.WithTx(tx)
sqlcMessage, err := txQueries.CreateMessage(txCtx, sqlc.CreateMessageParams{ChatID: *uuidChatID, SenderID: *uuidSenderID, Text: text})
if err != nil {
return nil, convertDBError(err)
}
rowsAffected, err := txQueries.InsertMessageIdempotency(txCtx, sqlc.InsertMessageIdempotencyParams{UserID: sqlcMessage.SenderID, ChatID: sqlcMessage.ChatID, IdempotencyKey: key, MessageID: sqlcMessage.ID})
if err != nil {
return nil, convertDBError(err)
}
switch rowsAffected {
case 1:
err := tx.Commit(txCtx)
if err != nil {
return nil, convertDBError(err)
}
case 0:
rollbackCtx, rollbackCancel := context.WithTimeout(context.WithoutCancel(ctx), time.Second)
err := tx.Rollback(rollbackCtx)
rollbackCancel()
if err != nil {
return nil, convertDBError(err)
}
dbCtx, cancel := context.WithTimeout(ctx, time.Second)
defer cancel()
sqlcMessage, err = r.queries.GetIdempotentMessage(dbCtx, sqlc.GetIdempotentMessageParams{UserID: sqlcMessage.SenderID, ChatID: sqlcMessage.ChatID, IdempotencyKey: key})
if err != nil {
return nil, convertDBError(err)
}
if sqlcMessage.Text != text {
return nil, repository.ErrConflict
}
default:
return nil, repository.ErrServerError
}
message := &model.Message{
ID: sqlcMessage.ID.String(),
ChatID: sqlcMessage.ChatID.String(),
SenderID: sqlcMessage.SenderID.String(),
Text: sqlcMessage.Text,
CreatedAt: sqlcMessage.CreatedAt.Time,
}
return message, nil
}
func (r *MessageRepository) GetMessagesByChatID(ctx context.Context, chatID string, limit int, after *repository.MessagePosition) ([]*model.Message, error) {
dbCtx, cancel := context.WithTimeout(ctx, time.Second)
defer cancel()
uuidChatID, err := getUUIDFromString(chatID)
if err != nil {
return nil, convertDBError(err)
}
afterCreatedAt := pgtype.Timestamptz{Valid: false}
afterID := pgtype.UUID{Valid: false}
if after != nil {
afterCreatedAt = pgtype.Timestamptz{Time: after.CreatedAt, Valid: true}
if uuidFromString, err := getUUIDFromString(after.ID); err == nil {
afterID = *uuidFromString
} else {
return nil, convertDBError(err)
}
}
sqlcMessages, err := r.queries.GetMessagesByChatID(dbCtx, sqlc.GetMessagesByChatIDParams{ChatID: *uuidChatID, AfterID: afterID, AfterCreatedAt: afterCreatedAt, LimitCount: int32(limit)})
if err != nil {
return nil, convertDBError(err)
}
messages := make([]*model.Message, len(sqlcMessages))
for index, sqlcMessage := range sqlcMessages {
messages[index] = &model.Message{
ID: sqlcMessage.ID.String(),
ChatID: sqlcMessage.ChatID.String(),
SenderID: sqlcMessage.SenderID.String(),
Text: sqlcMessage.Text,
CreatedAt: sqlcMessage.CreatedAt.Time}
}
return messages, nil
}