361 lines
11 KiB
Go
361 lines
11 KiB
Go
package groups
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
)
|
|
|
|
var ErrUnavailable = errors.New("group unavailable")
|
|
var ErrAction = errors.New("group action unavailable")
|
|
var ErrLimit = errors.New("group member limit reached")
|
|
|
|
type Group struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
State string `json:"state"`
|
|
Role string `json:"role"`
|
|
Version string `json:"membershipVersion"`
|
|
Preferences
|
|
}
|
|
|
|
type ListedGroup struct {
|
|
Group
|
|
Unread int `json:"unread"`
|
|
}
|
|
|
|
type Preferences struct {
|
|
Pinned bool `json:"pinned"`
|
|
Muted bool `json:"muted"`
|
|
}
|
|
|
|
type Member struct {
|
|
ID string `json:"id"`
|
|
Username string `json:"username"`
|
|
State string `json:"state"`
|
|
Role string `json:"role"`
|
|
}
|
|
|
|
type Detail struct {
|
|
Group
|
|
Members []Member `json:"members"`
|
|
}
|
|
|
|
type Change struct {
|
|
Action string `json:"action"`
|
|
Target string `json:"target"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
type Store struct{ db *pgxpool.Pool }
|
|
|
|
func New(db *pgxpool.Pool) *Store { return &Store{db: db} }
|
|
|
|
func (s *Store) Create(ctx context.Context, owner, name string) (Group, error) {
|
|
result := Group{Name: name, State: "active", Role: "owner", Version: "1"}
|
|
err := s.db.QueryRow(ctx, `
|
|
WITH created AS (INSERT INTO chat_groups(name,owner_id) VALUES($2,$1) RETURNING id)
|
|
INSERT INTO group_members(group_id,user_id,state,joined_version)
|
|
SELECT id,$1,'active',1 FROM created RETURNING group_id
|
|
`, owner, name).Scan(&result.ID)
|
|
return result, err
|
|
}
|
|
|
|
const groupColumns = `g.id,g.name,m.state,CASE WHEN g.owner_id=m.user_id THEN 'owner' ELSE m.role END,g.membership_version::text,m.pinned,m.muted`
|
|
const groupRows = `
|
|
FROM chat_groups g JOIN group_members m ON m.group_id=g.id WHERE m.user_id=$1
|
|
`
|
|
|
|
func (s *Store) List(ctx context.Context, user, device string) ([]ListedGroup, error) {
|
|
rows, err := s.db.Query(ctx, "SELECT "+groupColumns+`, (
|
|
SELECT count(*) FROM (
|
|
SELECT 1 FROM group_messages x
|
|
JOIN group_epoch_devices enrolled ON (enrolled.group_id,enrolled.epoch_id)=(x.group_id,x.epoch_id) AND enrolled.device_id=$2
|
|
JOIN group_epochs epoch ON (epoch.group_id,epoch.id)=(x.group_id,x.epoch_id)
|
|
JOIN devices d ON d.id=enrolled.device_id AND d.revoked_at IS NULL
|
|
WHERE x.group_id=g.id AND epoch.membership_version>=m.joined_version AND x.sender_device<>$2
|
|
AND x.sequence>COALESCE((SELECT seen.sequence FROM group_seen seen WHERE seen.group_id=g.id AND seen.device_id=$2),0)
|
|
ORDER BY x.sequence LIMIT 100
|
|
) AS unread
|
|
)`+groupRows+" ORDER BY m.pinned DESC, g.created_at DESC, g.id LIMIT 200", user, device)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
result := make([]ListedGroup, 0)
|
|
for rows.Next() {
|
|
var g ListedGroup
|
|
if err := rows.Scan(&g.ID, &g.Name, &g.State, &g.Role, &g.Version, &g.Pinned, &g.Muted, &g.Unread); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, g)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (s *Store) Detail(ctx context.Context, user, id string) (Detail, error) {
|
|
result := Detail{Members: make([]Member, 0)}
|
|
tx, err := s.db.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.RepeatableRead, AccessMode: pgx.ReadOnly})
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
err = tx.QueryRow(ctx, "SELECT "+groupColumns+" "+groupRows+" AND g.id=$2", user, id).
|
|
Scan(&result.ID, &result.Name, &result.State, &result.Role, &result.Version, &result.Pinned, &result.Muted)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return result, ErrUnavailable
|
|
}
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
if result.State != "active" {
|
|
return result, tx.Commit(ctx)
|
|
}
|
|
rows, err := tx.Query(ctx, `
|
|
SELECT m.user_id,u.username,m.state,CASE WHEN m.user_id=g.owner_id THEN 'owner' ELSE m.role END
|
|
FROM group_members m JOIN users u ON u.id=m.user_id JOIN chat_groups g ON g.id=m.group_id
|
|
WHERE m.group_id=$1 AND (m.state='active' OR $2 IN ('owner','admin'))
|
|
ORDER BY u.username
|
|
`, id, result.Role)
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var member Member
|
|
if err := rows.Scan(&member.ID, &member.Username, &member.State, &member.Role); err != nil {
|
|
return result, err
|
|
}
|
|
result.Members = append(result.Members, member)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return result, err
|
|
}
|
|
return result, tx.Commit(ctx)
|
|
}
|
|
|
|
func (s *Store) SetPreferences(ctx context.Context, id, user, device string, pinned, muted *bool) (Preferences, error) {
|
|
var result Preferences
|
|
tx, err := s.db.Begin(ctx)
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
if _, _, err := lockTransport(ctx, tx, id, user, device); err != nil {
|
|
return result, err
|
|
}
|
|
err = tx.QueryRow(ctx, `
|
|
UPDATE group_members SET pinned=COALESCE($3,pinned), muted=COALESCE($4,muted)
|
|
WHERE group_id=$1 AND user_id=$2 AND state='active' RETURNING pinned,muted
|
|
`, id, user, pinned, muted).Scan(&result.Pinned, &result.Muted)
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
return result, tx.Commit(ctx)
|
|
}
|
|
|
|
func (s *Store) Change(ctx context.Context, user, id string, change Change) ([]string, error) {
|
|
tx, err := s.db.Begin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer tx.Rollback(ctx)
|
|
|
|
// Serialize membership and version changes on the group row.
|
|
var owner string
|
|
var version int64
|
|
err = tx.QueryRow(ctx, "SELECT owner_id,membership_version FROM chat_groups WHERE id=$1 FOR UPDATE", id).Scan(&owner, &version)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, ErrUnavailable
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var state, role string
|
|
err = tx.QueryRow(ctx, "SELECT state,role FROM group_members WHERE group_id=$1 AND user_id=$2", id, user).Scan(&state, &role)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, ErrUnavailable
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if owner == user {
|
|
role = "owner"
|
|
}
|
|
var users []string
|
|
if change.Action == "disband" && role == "owner" {
|
|
users, err = groupChangeAudience(ctx, tx, id, owner, "all")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
activeChanged := false
|
|
if state == "invited" {
|
|
switch change.Action {
|
|
case "accept":
|
|
_, err = tx.Exec(ctx, "UPDATE group_members SET state='active',joined_version=$3 WHERE group_id=$1 AND user_id=$2", id, user, version+1)
|
|
activeChanged = true
|
|
case "decline":
|
|
_, err = tx.Exec(ctx, "DELETE FROM group_members WHERE group_id=$1 AND user_id=$2", id, user)
|
|
default:
|
|
return nil, ErrAction
|
|
}
|
|
} else {
|
|
activeChanged, err = changeActive(ctx, tx, user, id, owner, role, change)
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if activeChanged {
|
|
if _, err = tx.Exec(ctx, "UPDATE chat_groups SET membership_version=membership_version+1 WHERE id=$1", id); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if change.Action != "disband" {
|
|
audience := "active"
|
|
switch {
|
|
case change.Action == "rename":
|
|
audience = "all"
|
|
case change.Action == "invite", change.Action == "decline", change.Action == "remove" && !activeChanged:
|
|
audience = "managers"
|
|
}
|
|
users, err = groupChangeAudience(ctx, tx, id, owner, audience)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Removed and invited users need to refresh their own group list as well.
|
|
users = append(users, user)
|
|
if change.Action == "invite" || change.Action == "remove" {
|
|
users = append(users, change.Target)
|
|
}
|
|
}
|
|
return users, tx.Commit(ctx)
|
|
}
|
|
|
|
func groupChangeAudience(ctx context.Context, tx pgx.Tx, group, owner, audience string) ([]string, error) {
|
|
rows, err := tx.Query(ctx, `
|
|
SELECT user_id::text FROM group_members WHERE group_id=$1 AND (
|
|
$3='all' OR (state='active' AND ($3='active' OR user_id=$2 OR role='admin'))
|
|
)
|
|
`, group, owner, audience)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return pgx.CollectRows(rows, pgx.RowTo[string])
|
|
}
|
|
|
|
func changeActive(ctx context.Context, tx pgx.Tx, user, id, owner, role string, change Change) (bool, error) {
|
|
manage := role == "owner" || role == "admin"
|
|
switch change.Action {
|
|
case "leave":
|
|
if role == "owner" {
|
|
return false, ErrAction
|
|
}
|
|
_, err := tx.Exec(ctx, "DELETE FROM group_members WHERE group_id=$1 AND user_id=$2", id, user)
|
|
return true, err
|
|
case "disband":
|
|
if role != "owner" {
|
|
return false, ErrAction
|
|
}
|
|
_, err := tx.Exec(ctx, "DELETE FROM chat_groups WHERE id=$1", id)
|
|
return false, err
|
|
case "rename":
|
|
if !manage {
|
|
return false, ErrAction
|
|
}
|
|
_, err := tx.Exec(ctx, "UPDATE chat_groups SET name=$2 WHERE id=$1", id, change.Name)
|
|
return false, err
|
|
case "invite":
|
|
if !manage || change.Target == user {
|
|
return false, ErrAction
|
|
}
|
|
return false, invite(ctx, tx, user, id, change.Target)
|
|
case "transfer":
|
|
if role != "owner" || change.Target == owner {
|
|
return false, ErrAction
|
|
}
|
|
tag, err := tx.Exec(ctx, `
|
|
UPDATE chat_groups SET owner_id=$2 WHERE id=$1 AND EXISTS (
|
|
SELECT 1 FROM group_members WHERE group_id=$1 AND user_id=$2 AND state='active'
|
|
)
|
|
`, id, change.Target)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return false, ErrAction
|
|
}
|
|
_, err = tx.Exec(ctx, "UPDATE group_members SET role='member' WHERE group_id=$1 AND user_id IN ($2,$3)", id, owner, change.Target)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
_, err = tx.Exec(ctx, "DELETE FROM group_invite_links WHERE group_id=$1", id)
|
|
// The new owner establishes a new authenticated MLS session for the same roster.
|
|
return true, err
|
|
case "remove", "promote", "demote":
|
|
if !manage || change.Target == owner || change.Target == user {
|
|
return false, ErrAction
|
|
}
|
|
return changeMember(ctx, tx, id, role, change)
|
|
default:
|
|
return false, ErrAction
|
|
}
|
|
}
|
|
|
|
func invite(ctx context.Context, tx pgx.Tx, user, id, target string) error {
|
|
if err := checkMemberLimit(ctx, tx, id); err != nil {
|
|
return err
|
|
}
|
|
tag, err := tx.Exec(ctx, `
|
|
INSERT INTO group_members(group_id,user_id,state)
|
|
SELECT $1,$3,'invited' FROM contact_relationships
|
|
WHERE first_user=LEAST($2::uuid,$3::uuid) AND second_user=GREATEST($2::uuid,$3::uuid)
|
|
AND status='accepted'
|
|
ON CONFLICT(group_id,user_id) DO NOTHING
|
|
`, id, user, target)
|
|
if err == nil && tag.RowsAffected() == 0 {
|
|
return ErrAction
|
|
}
|
|
return err
|
|
}
|
|
|
|
func checkMemberLimit(ctx context.Context, tx pgx.Tx, id string) error {
|
|
var count int
|
|
if err := tx.QueryRow(ctx, "SELECT count(*) FROM group_members WHERE group_id=$1", id).Scan(&count); err != nil {
|
|
return err
|
|
}
|
|
if count >= 32 {
|
|
return ErrLimit
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func changeMember(ctx context.Context, tx pgx.Tx, id, role string, change Change) (bool, error) {
|
|
if change.Action == "remove" {
|
|
var state string
|
|
err := tx.QueryRow(ctx, `
|
|
DELETE FROM group_members WHERE group_id=$1 AND user_id=$2 AND ($3='owner' OR role='member')
|
|
RETURNING state
|
|
`, id, change.Target, role).Scan(&state)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return false, ErrAction
|
|
}
|
|
return state == "active", err
|
|
}
|
|
if role != "owner" {
|
|
return false, ErrAction
|
|
}
|
|
next := "member"
|
|
if change.Action == "promote" {
|
|
next = "admin"
|
|
}
|
|
tag, err := tx.Exec(ctx, "UPDATE group_members SET role=$3 WHERE group_id=$1 AND user_id=$2 AND state='active'", id, change.Target, next)
|
|
if err == nil && tag.RowsAffected() == 0 {
|
|
return false, ErrAction
|
|
}
|
|
return false, err
|
|
}
|