Release / release-apk (push) Successful in 9m25s
Release / release-docker (push) Successful in 33s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m29s
CI / lint-mobile (push) Failing after 7m46s
CI / test-backend (push) Successful in 1m30s
CI / test-mobile (push) Successful in 9m27s
CI / build-backend (push) Successful in 47s
186 lines
4.6 KiB
Go
186 lines
4.6 KiB
Go
package repository
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
)
|
|
|
|
// Group is a named set of users (V2-6) : sharing to a group grants every
|
|
// member. One level only (no nested groups). The creator owns the group
|
|
// (member management + deletion) ; membership confers no admin rights.
|
|
type Group struct {
|
|
ID string
|
|
Name string
|
|
CreatedBy string
|
|
}
|
|
|
|
// Groups implements group persistence.
|
|
type Groups struct {
|
|
DB *sql.DB
|
|
}
|
|
|
|
// Create stores a group owned by ownerID and returns its id.
|
|
func (g *Groups) Create(name, ownerID string) (string, error) {
|
|
id := NewID()
|
|
_, err := g.DB.Exec(
|
|
`INSERT INTO groups (id, name, created_by) VALUES ($1, $2, $3)`,
|
|
id, name, ownerID,
|
|
)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return id, nil
|
|
}
|
|
|
|
// Get returns a group by id. No-rows → ErrNotFound.
|
|
func (g *Groups) Get(groupID string) (Group, error) {
|
|
var group Group
|
|
err := g.DB.QueryRow(
|
|
`SELECT id, name, created_by FROM groups WHERE id = $1`,
|
|
groupID,
|
|
).Scan(&group.ID, &group.Name, &group.CreatedBy)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return Group{}, ErrNotFound
|
|
}
|
|
return group, err
|
|
}
|
|
|
|
// IsOwner reports whether userID created the group.
|
|
func (g *Groups) IsOwner(groupID, userID string) (bool, error) {
|
|
var n int
|
|
err := g.DB.QueryRow(
|
|
`SELECT COUNT(*) FROM groups WHERE id = $1 AND created_by = $2`,
|
|
groupID, userID,
|
|
).Scan(&n)
|
|
return n > 0, err
|
|
}
|
|
|
|
// IsMember reports group membership (owner excluded : ownership is separate).
|
|
func (g *Groups) IsMember(groupID, userID string) (bool, error) {
|
|
var n int
|
|
err := g.DB.QueryRow(
|
|
`SELECT COUNT(*) FROM group_members WHERE group_id = $1 AND user_id = $2`,
|
|
groupID, userID,
|
|
).Scan(&n)
|
|
return n > 0, err
|
|
}
|
|
|
|
// GroupWithRole is a group listing row (owned or joined).
|
|
type GroupWithRole struct {
|
|
Group
|
|
Role string // "owner" | "member"
|
|
}
|
|
|
|
// ListForUser returns groups the user owns or joins, owned first.
|
|
func (g *Groups) ListForUser(userID string) ([]GroupWithRole, error) {
|
|
rows, err := g.DB.Query(
|
|
`SELECT id, name, created_by,
|
|
CASE WHEN created_by = $1 THEN 'owner' ELSE 'member' END AS role
|
|
FROM groups
|
|
WHERE created_by = $1 OR id IN (SELECT group_id FROM group_members WHERE user_id = $1)
|
|
ORDER BY created_at ASC`,
|
|
userID,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var out []GroupWithRole
|
|
for rows.Next() {
|
|
var gr GroupWithRole
|
|
if err := rows.Scan(&gr.ID, &gr.Name, &gr.CreatedBy, &gr.Role); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, gr)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// AddMember inserts a membership. Idempotent on replay (ON CONFLICT DO
|
|
// NOTHING) ; returns rows-affected style via ErrNotFound when the group or
|
|
// the user does not exist (FK violation mapped).
|
|
func (g *Groups) AddMember(groupID, userID string) error {
|
|
_, err := g.DB.Exec(
|
|
`INSERT INTO group_members (group_id, user_id) VALUES ($1, $2)
|
|
ON CONFLICT DO NOTHING`,
|
|
groupID, userID,
|
|
)
|
|
if isForeignKeyViolation(err) {
|
|
return ErrNotFound
|
|
}
|
|
return err
|
|
}
|
|
|
|
// RemoveMember deletes a membership. Missing row → ErrNotFound.
|
|
func (g *Groups) RemoveMember(groupID, userID string) error {
|
|
result, err := g.DB.Exec(
|
|
`DELETE FROM group_members WHERE group_id = $1 AND user_id = $2`,
|
|
groupID, userID,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
affected, err := result.RowsAffected()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if affected == 0 {
|
|
return ErrNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Member is a group membership row (owner view).
|
|
type Member struct {
|
|
UserID string
|
|
Username string
|
|
}
|
|
|
|
// ListMembers returns memberships of a group, ordered by username.
|
|
func (g *Groups) ListMembers(groupID string) ([]Member, error) {
|
|
rows, err := g.DB.Query(
|
|
`SELECT u.id, COALESCE(u.username, u.id)
|
|
FROM group_members gm
|
|
JOIN users u ON u.id = gm.user_id AND u.deleted_at IS NULL
|
|
WHERE gm.group_id = $1
|
|
ORDER BY COALESCE(u.username, u.id) ASC`,
|
|
groupID,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var out []Member
|
|
for rows.Next() {
|
|
var m Member
|
|
if err := rows.Scan(&m.UserID, &m.Username); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, m)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// Errors specific to groups.
|
|
var ErrGroupNotFound = errors.New("group not found")
|
|
|
|
// Delete removes a group (owner only — caller checks). Shares targeting it
|
|
// cascade (FK), placements are untouched (device-scoped, not group-scoped).
|
|
func (g *Groups) Delete(groupID, ownerID string) error {
|
|
result, err := g.DB.Exec(
|
|
`DELETE FROM groups WHERE id = $1 AND created_by = $2`,
|
|
groupID, ownerID,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
affected, err := result.RowsAffected()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if affected == 0 {
|
|
return ErrNotFound
|
|
}
|
|
return nil
|
|
}
|