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 }