Files
XHChat/server/internal/contacts/store.go
T

166 lines
5.3 KiB
Go

package contacts
import (
"context"
"errors"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
)
var ErrUnavailable = errors.New("contact action unavailable")
type Contact struct {
ID string `json:"id"`
Username string `json:"username"`
State string `json:"state"`
Alias string `json:"alias"`
Category string `json:"category"`
}
type Store struct{ db *pgxpool.Pool }
func New(db *pgxpool.Pool) *Store { return &Store{db: db} }
const selectContact = `
SELECT u.id, u.username,
CASE WHEN mine.owner_id IS NOT NULL THEN 'blocked'
WHEN r.status = 'accepted' THEN 'friend'
WHEN r.requested_by = $1 THEN 'outgoing'
WHEN r.status = 'pending' THEN 'incoming'
ELSE 'none' END,
COALESCE(p.alias,''), COALESCE(p.category,'')
FROM users u
LEFT JOIN contact_relationships r ON r.first_user = LEAST($1::uuid, u.id)
AND r.second_user = GREATEST($1::uuid, u.id)
LEFT JOIN contact_blocks mine ON mine.owner_id=$1 AND mine.blocked_id=u.id
LEFT JOIN contact_blocks theirs ON theirs.owner_id=u.id AND theirs.blocked_id=$1
LEFT JOIN contact_preferences p ON p.owner_id=$1 AND p.contact_id=u.id
WHERE u.id <> $1 AND (theirs.owner_id IS NULL OR mine.owner_id IS NOT NULL)
`
func (s *Store) Search(ctx context.Context, owner, username string) (Contact, error) {
var c Contact
err := s.db.QueryRow(ctx, selectContact+" AND u.username=$2", owner, username).
Scan(&c.ID, &c.Username, &c.State, &c.Alias, &c.Category)
return c, err
}
func (s *Store) List(ctx context.Context, owner string) ([]Contact, error) {
rows, err := s.db.Query(ctx, selectContact+`
AND (mine.owner_id IS NOT NULL OR r.status IS NOT NULL)
ORDER BY u.username LIMIT 1000`, owner)
if err != nil {
return nil, err
}
defer rows.Close()
result := make([]Contact, 0)
for rows.Next() {
var c Contact
if err := rows.Scan(&c.ID, &c.Username, &c.State, &c.Alias, &c.Category); err != nil {
return nil, err
}
result = append(result, c)
}
return result, rows.Err()
}
func (s *Store) Change(ctx context.Context, owner, target, action, alias, category string) error {
tx, err := s.db.Begin(ctx)
if err != nil {
return err
}
defer tx.Rollback(ctx)
// Lock the same two rows in the same order for all transitions of a pair.
var count int
err = tx.QueryRow(ctx, `
SELECT count(*) FROM (
SELECT id FROM users WHERE id IN ($1,$2) ORDER BY id FOR UPDATE
) AS participants`, owner, target).Scan(&count)
if err != nil {
return err
}
if count != 2 {
return ErrUnavailable
}
const pair = "first_user=LEAST($1::uuid,$2::uuid) AND second_user=GREATEST($1::uuid,$2::uuid)"
const remove = "DELETE FROM contact_relationships WHERE " + pair
switch action {
case "request":
var blocked bool
err = tx.QueryRow(ctx, `
SELECT EXISTS(SELECT 1 FROM contact_blocks
WHERE (owner_id=$1 AND blocked_id=$2) OR (owner_id=$2 AND blocked_id=$1))
`, owner, target).Scan(&blocked)
if err != nil {
return err
}
if blocked {
return ErrUnavailable
}
var state string
err = tx.QueryRow(ctx, `
INSERT INTO contact_relationships(first_user,second_user,requested_by,status)
VALUES(LEAST($1::uuid,$2::uuid),GREATEST($1::uuid,$2::uuid),$1,'pending')
ON CONFLICT(first_user,second_user) DO UPDATE
SET updated_at=contact_relationships.updated_at
WHERE contact_relationships.requested_by=$1 AND contact_relationships.status='pending'
RETURNING status`, owner, target).Scan(&state)
if errors.Is(err, pgx.ErrNoRows) {
return ErrUnavailable
}
case "accept":
tag, updateErr := tx.Exec(ctx, "UPDATE contact_relationships SET status='accepted',updated_at=now() WHERE "+pair+" AND requested_by=$2 AND status='pending'", owner, target)
err = updateErr
if err == nil && tag.RowsAffected() == 0 {
return ErrUnavailable
}
case "reject":
_, err = tx.Exec(ctx, remove+" AND requested_by=$2 AND status='pending'", owner, target)
case "cancel":
_, err = tx.Exec(ctx, remove+" AND requested_by=$1 AND status='pending'", owner, target)
case "delete":
tag, deleteErr := tx.Exec(ctx, remove+" AND status='accepted'", owner, target)
err = deleteErr
if err == nil && tag.RowsAffected() > 0 {
err = clearPreferences(ctx, tx, owner, target)
}
case "block":
_, err = tx.Exec(ctx, "INSERT INTO contact_blocks VALUES($1,$2) ON CONFLICT DO NOTHING", owner, target)
if err == nil {
_, err = tx.Exec(ctx, remove, owner, target)
}
if err == nil {
err = clearPreferences(ctx, tx, owner, target)
}
case "unblock":
_, err = tx.Exec(ctx, "DELETE FROM contact_blocks WHERE owner_id=$1 AND blocked_id=$2", owner, target)
case "preferences":
tag, writeErr := tx.Exec(ctx, `
INSERT INTO contact_preferences(owner_id,contact_id,alias,category)
SELECT $1,$2,$3,$4 FROM contact_relationships WHERE `+pair+` AND status='accepted'
ON CONFLICT (owner_id,contact_id) DO UPDATE SET alias=EXCLUDED.alias,category=EXCLUDED.category
`, owner, target, alias, category)
err = writeErr
if err == nil && tag.RowsAffected() == 0 {
return ErrUnavailable
}
default:
return ErrUnavailable
}
if err != nil {
return err
}
return tx.Commit(ctx)
}
func clearPreferences(ctx context.Context, tx pgx.Tx, owner, target string) error {
_, err := tx.Exec(ctx, `
DELETE FROM contact_preferences WHERE
(owner_id=$1 AND contact_id=$2) OR (owner_id=$2 AND contact_id=$1)
`, owner, target)
return err
}