181 lines
5.2 KiB
Go
181 lines
5.2 KiB
Go
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"github.com/charawein/mtusi2026lab6/internal/domain"
|
|
"github.com/charawein/mtusi2026lab6/internal/repository"
|
|
)
|
|
|
|
type ChatRepository struct {
|
|
pool *pgxpool.Pool
|
|
}
|
|
|
|
func NewChatRepository(pool *pgxpool.Pool) *ChatRepository {
|
|
return &ChatRepository{pool: pool}
|
|
}
|
|
|
|
func (r *ChatRepository) Create(ctx context.Context, chat *domain.Chat) error {
|
|
tx, err := r.pool.Begin(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("begin tx: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
|
|
const insertChat = `INSERT INTO chats (id, title, created_at) VALUES ($1::uuid, $2, $3)`
|
|
if _, err := tx.Exec(ctx, insertChat, chat.ID, chat.Title, chat.CreatedAt); err != nil {
|
|
return fmt.Errorf("insert chat: %w", err)
|
|
}
|
|
|
|
const insertMember = `INSERT INTO chat_members (chat_id, user_id) VALUES ($1::uuid, $2::uuid)`
|
|
for _, uid := range chat.MemberIDs {
|
|
if _, err := tx.Exec(ctx, insertMember, chat.ID, uid); err != nil {
|
|
return fmt.Errorf("insert member %s: %w", uid, err)
|
|
}
|
|
}
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return fmt.Errorf("commit tx: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *ChatRepository) GetByID(ctx context.Context, id string) (*domain.Chat, error) {
|
|
const q = `SELECT id, title, created_at FROM chats WHERE id = $1::uuid`
|
|
var c domain.Chat
|
|
err := r.pool.QueryRow(ctx, q, id).Scan(&c.ID, &c.Title, &c.CreatedAt)
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, repository.ErrNotFound
|
|
}
|
|
return nil, fmt.Errorf("select chat: %w", err)
|
|
}
|
|
|
|
const qMembers = `SELECT user_id FROM chat_members WHERE chat_id = $1::uuid ORDER BY user_id`
|
|
rows, err := r.pool.Query(ctx, qMembers, id)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("select members: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
c.MemberIDs = []string{}
|
|
for rows.Next() {
|
|
var uid string
|
|
if err := rows.Scan(&uid); err != nil {
|
|
return nil, fmt.Errorf("scan member: %w", err)
|
|
}
|
|
c.MemberIDs = append(c.MemberIDs, uid)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, fmt.Errorf("iterate members: %w", err)
|
|
}
|
|
return &c, nil
|
|
}
|
|
|
|
func (r *ChatRepository) IsMember(ctx context.Context, chatID, userID string) (bool, error) {
|
|
const q = `SELECT 1 FROM chat_members WHERE chat_id = $1::uuid AND user_id = $2::uuid`
|
|
var one int
|
|
err := r.pool.QueryRow(ctx, q, chatID, userID).Scan(&one)
|
|
if err == nil {
|
|
return true, nil
|
|
}
|
|
if !errors.Is(err, pgx.ErrNoRows) {
|
|
return false, fmt.Errorf("check membership: %w", err)
|
|
}
|
|
const qChat = `SELECT 1 FROM chats WHERE id = $1::uuid`
|
|
err = r.pool.QueryRow(ctx, qChat, chatID).Scan(&one)
|
|
if err == nil {
|
|
return false, nil
|
|
}
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return false, repository.ErrNotFound
|
|
}
|
|
return false, fmt.Errorf("check chat exists: %w", err)
|
|
}
|
|
|
|
// MemberVersion одним запросом возвращает версию истории чата и признак членства.
|
|
// Несуществующий чат — ErrNotFound.
|
|
func (r *ChatRepository) MemberVersion(ctx context.Context, chatID, userID string) (int64, bool, error) {
|
|
const q = `
|
|
SELECT c.version,
|
|
EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2::uuid)
|
|
FROM chats c
|
|
WHERE c.id = $1::uuid
|
|
`
|
|
var version int64
|
|
var member bool
|
|
err := r.pool.QueryRow(ctx, q, chatID, userID).Scan(&version, &member)
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return 0, false, repository.ErrNotFound
|
|
}
|
|
return 0, false, fmt.Errorf("select chat version: %w", err)
|
|
}
|
|
return version, member, nil
|
|
}
|
|
|
|
func (r *ChatRepository) ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error) {
|
|
const qChats = `
|
|
SELECT c.id, c.title, c.created_at
|
|
FROM chats c
|
|
JOIN chat_members m ON m.chat_id = c.id
|
|
WHERE m.user_id = $1::uuid
|
|
AND (c.created_at, c.id) > ($2::timestamptz, $3::uuid)
|
|
ORDER BY c.created_at, c.id
|
|
LIMIT $4
|
|
`
|
|
rows, err := r.pool.Query(ctx, qChats, userID, cursor, cursorID, limit)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list chats: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
chats := []*domain.Chat{}
|
|
var chatIDs []string
|
|
for rows.Next() {
|
|
var c domain.Chat
|
|
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
|
|
return nil, fmt.Errorf("scan chat: %w", err)
|
|
}
|
|
c.MemberIDs = []string{}
|
|
chats = append(chats, &c)
|
|
chatIDs = append(chatIDs, c.ID)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, fmt.Errorf("iterate chats: %w", err)
|
|
}
|
|
if len(chats) == 0 {
|
|
return chats, nil
|
|
}
|
|
|
|
const qMembers = `SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1::uuid[]) ORDER BY chat_id, user_id`
|
|
memberRows, err := r.pool.Query(ctx, qMembers, chatIDs)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list members: %w", err)
|
|
}
|
|
defer memberRows.Close()
|
|
|
|
byChat := make(map[string][]string)
|
|
for memberRows.Next() {
|
|
var chatID, uid string
|
|
if err := memberRows.Scan(&chatID, &uid); err != nil {
|
|
return nil, fmt.Errorf("scan member: %w", err)
|
|
}
|
|
byChat[chatID] = append(byChat[chatID], uid)
|
|
}
|
|
if err := memberRows.Err(); err != nil {
|
|
return nil, fmt.Errorf("iterate members: %w", err)
|
|
}
|
|
for _, c := range chats {
|
|
if members, ok := byChat[c.ID]; ok {
|
|
c.MemberIDs = members
|
|
}
|
|
}
|
|
return chats, nil
|
|
}
|