188 lines
6.5 KiB
Go
188 lines
6.5 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
|
|
"gitflic.ru/project/d-sotnikova5/mtusi2026lab1-fork/internal/model"
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgconn"
|
|
)
|
|
|
|
type Position struct {
|
|
CreatedAt time.Time
|
|
ID string
|
|
}
|
|
|
|
func (s *PostgresStore) CreateChat(ctx context.Context, title string, members []string) (model.Chat, error) {
|
|
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
|
|
defer cancel()
|
|
id, err := newUUID()
|
|
if err != nil {
|
|
return model.Chat{}, ErrUnavailable
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return model.Chat{}, ErrUnavailable
|
|
}
|
|
defer tx.Rollback(context.Background())
|
|
chat := model.Chat{ID: id, Title: title, MemberIDs: members}
|
|
err = tx.QueryRow(ctx, `INSERT INTO chats(id,title) VALUES($1,$2) RETURNING created_at`, id, title).Scan(&chat.CreatedAt)
|
|
if err != nil {
|
|
return model.Chat{}, ErrUnavailable
|
|
}
|
|
for _, member := range members {
|
|
_, err = tx.Exec(ctx, `INSERT INTO chat_members(chat_id,user_id) VALUES($1,$2)`, id, member)
|
|
if err != nil {
|
|
var pgErr *pgconn.PgError
|
|
if errors.As(err, &pgErr) && (pgErr.Code == "23503" || pgErr.Code == "23505") {
|
|
return model.Chat{}, ErrInvalidMembers
|
|
}
|
|
return model.Chat{}, ErrUnavailable
|
|
}
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return model.Chat{}, ErrUnavailable
|
|
}
|
|
chat.CreatedAt = chat.CreatedAt.UTC()
|
|
return chat, nil
|
|
}
|
|
|
|
const chatColumns = `c.id::text,c.title,c.created_at,ARRAY(SELECT m.user_id::text FROM chat_members m WHERE m.chat_id=c.id ORDER BY m.user_id)`
|
|
|
|
func (s *PostgresStore) GetChat(ctx context.Context, actor, id string) (model.Chat, error) {
|
|
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
|
|
defer cancel()
|
|
var chat model.Chat
|
|
err := s.pool.QueryRow(ctx, `SELECT `+chatColumns+` FROM chats c WHERE c.id=$1 AND EXISTS(SELECT 1 FROM chat_members WHERE chat_id=c.id AND user_id=$2)`, id, actor).Scan(&chat.ID, &chat.Title, &chat.CreatedAt, &chat.MemberIDs)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return model.Chat{}, ErrNotFound
|
|
}
|
|
if err != nil {
|
|
return model.Chat{}, ErrUnavailable
|
|
}
|
|
chat.CreatedAt = chat.CreatedAt.UTC()
|
|
return chat, nil
|
|
}
|
|
|
|
func (s *PostgresStore) ChatPage(ctx context.Context, actor string, limit int, after *Position) ([]model.Chat, error) {
|
|
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
|
|
defer cancel()
|
|
query := `SELECT ` + chatColumns + ` FROM chats c WHERE EXISTS(SELECT 1 FROM chat_members WHERE chat_id=c.id AND user_id=$1)`
|
|
args := []any{actor, limit}
|
|
if after != nil {
|
|
query += ` AND (c.created_at,c.id)>($3,$4::uuid)`
|
|
args = append(args, after.CreatedAt, after.ID)
|
|
}
|
|
query += ` ORDER BY c.created_at,c.id LIMIT $2`
|
|
rows, err := s.pool.Query(ctx, query, args...)
|
|
if err != nil {
|
|
return nil, ErrUnavailable
|
|
}
|
|
defer rows.Close()
|
|
items := make([]model.Chat, 0)
|
|
for rows.Next() {
|
|
var chat model.Chat
|
|
if err := rows.Scan(&chat.ID, &chat.Title, &chat.CreatedAt, &chat.MemberIDs); err != nil {
|
|
return nil, ErrUnavailable
|
|
}
|
|
chat.CreatedAt = chat.CreatedAt.UTC()
|
|
items = append(items, chat)
|
|
}
|
|
if rows.Err() != nil {
|
|
return nil, ErrUnavailable
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
var ErrIdempotencyConflict = errors.New("idempotency key already used for another message")
|
|
|
|
func (s *PostgresStore) CreateMessage(ctx context.Context, actor, chatID, text, key string) (model.Message, error) {
|
|
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
|
|
defer cancel()
|
|
id, err := newUUID()
|
|
if err != nil {
|
|
return model.Message{}, ErrUnavailable
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return model.Message{}, ErrUnavailable
|
|
}
|
|
defer tx.Rollback(context.Background())
|
|
|
|
var locked string
|
|
err = tx.QueryRow(ctx, `SELECT c.id::text FROM chats c WHERE c.id=$1 AND EXISTS(SELECT 1 FROM chat_members WHERE chat_id=c.id AND user_id=$2) FOR UPDATE OF c`, chatID, actor).Scan(&locked)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return model.Message{}, ErrNotFound
|
|
}
|
|
if err != nil {
|
|
return model.Message{}, ErrUnavailable
|
|
}
|
|
var message model.Message
|
|
|
|
err = tx.QueryRow(ctx, `SELECT m.id::text,m.chat_id::text,m.sender_id::text,m.text,m.created_at
|
|
FROM message_keys k JOIN messages m ON m.id=k.message_id
|
|
WHERE k.user_id=$1 AND k.chat_id=$2 AND k.key=$3 AND k.expires_at>clock_timestamp()`,
|
|
actor, chatID, key).Scan(&message.ID, &message.ChatID, &message.SenderID, &message.Text, &message.CreatedAt)
|
|
if err == nil {
|
|
if message.Text != text {
|
|
return model.Message{}, ErrIdempotencyConflict
|
|
}
|
|
message.CreatedAt = message.CreatedAt.UTC()
|
|
return message, nil
|
|
}
|
|
if !errors.Is(err, pgx.ErrNoRows) {
|
|
return model.Message{}, ErrUnavailable
|
|
}
|
|
err = tx.QueryRow(ctx, `INSERT INTO messages(id,chat_id,sender_id,text,created_at)
|
|
VALUES($1,$2,$3,$4,GREATEST(clock_timestamp(),
|
|
COALESCE((SELECT created_at + INTERVAL '1 microsecond' FROM messages WHERE chat_id=$2 ORDER BY created_at DESC,id DESC LIMIT 1),clock_timestamp())))
|
|
RETURNING id::text,chat_id::text,sender_id::text,text,created_at`, id, chatID, actor, text).Scan(&message.ID, &message.ChatID, &message.SenderID, &message.Text, &message.CreatedAt)
|
|
if err != nil {
|
|
return model.Message{}, ErrUnavailable
|
|
}
|
|
_, err = tx.Exec(ctx, `INSERT INTO message_keys(user_id,chat_id,key,message_id,expires_at)
|
|
VALUES($1,$2,$3,$4,clock_timestamp()+INTERVAL '24 hours')
|
|
ON CONFLICT(user_id,chat_id,key) DO UPDATE
|
|
SET message_id=EXCLUDED.message_id,expires_at=EXCLUDED.expires_at`, actor, chatID, key, message.ID)
|
|
if err != nil {
|
|
return model.Message{}, ErrUnavailable
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return model.Message{}, ErrUnavailable
|
|
}
|
|
message.CreatedAt = message.CreatedAt.UTC()
|
|
return message, nil
|
|
}
|
|
|
|
func (s *PostgresStore) MessagePage(ctx context.Context, chatID string, limit int, after *Position) ([]model.Message, error) {
|
|
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
|
|
defer cancel()
|
|
query := `SELECT id::text,chat_id::text,sender_id::text,text,created_at FROM messages WHERE chat_id=$1`
|
|
args := []any{chatID, limit}
|
|
if after != nil {
|
|
query += ` AND (created_at,id)>($3,$4::uuid)`
|
|
args = append(args, after.CreatedAt, after.ID)
|
|
}
|
|
query += ` ORDER BY messages.created_at,messages.id LIMIT $2`
|
|
rows, err := s.pool.Query(ctx, query, args...)
|
|
if err != nil {
|
|
return nil, ErrUnavailable
|
|
}
|
|
defer rows.Close()
|
|
items := make([]model.Message, 0)
|
|
for rows.Next() {
|
|
var m model.Message
|
|
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
|
|
return nil, ErrUnavailable
|
|
}
|
|
m.CreatedAt = m.CreatedAt.UTC()
|
|
items = append(items, m)
|
|
}
|
|
if rows.Err() != nil {
|
|
return nil, ErrUnavailable
|
|
}
|
|
return items, nil
|
|
}
|