166 lines
5.3 KiB
Go
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
|
|
}
|