Files
pages/internal/store/groups.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

385 lines
18 KiB
Go

package store
import (
"errors"
"regexp"
"strings"
"time"
"github.com/google/uuid"
)
var groupNamePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9_-]{1,63}$`)
type Group struct {
UUID, DomainUUID, Name, DisplayName, Description, Visibility, State, BuiltinKey string
InheritMembers bool
CreatedAtMS, UpdatedAtMS int64
}
type GroupMember struct {
MembershipUUID, PrincipalUUID, Username, DisplayName, MemberRole, Source string
}
type GroupPermission struct {
UUID, GroupUUID, ScopePath, Permission string
}
var groupPermissions = map[string]map[string]bool{
"read": {"read": true},
"read_write_once": {"read": true, "create": true, "upload": true},
"read_write": {"read": true, "create": true, "write": true, "upload": true, "rename": true, "link": true},
"upload_only": {"upload": true},
}
func NormalizeGroupPermission(value string) (string, error) {
value = strings.ToLower(strings.TrimSpace(value))
if _, ok := groupPermissions[value]; !ok {
return "", errors.New("invalid group permission")
}
return value, nil
}
func normalizeGroupName(name string) (string, error) {
name = strings.ToLower(strings.TrimSpace(name))
if !groupNamePattern.MatchString(name) || name == "new" || name == "sys" || name == "campus_admin" || name == "domain_admin" {
return "", errors.New("group name must be 2-64 lowercase letters, digits, underscores, or hyphens")
}
return name, nil
}
func (s *Store) EnsureBuiltinAdminGroups() error {
now := time.Now().UnixMilli()
var hasDomains int
if err := s.DB.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='domains'`).Scan(&hasDomains); err != nil || hasDomains == 0 {
return err
}
rows, err := s.DB.Query(`SELECT uuid FROM domains`)
if err != nil {
return err
}
var domains []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return err
}
domains = append(domains, id)
}
rows.Close()
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
for _, domainUUID := range domains {
for _, key := range []string{"campus_admin", "domain_admin"} {
_, err = tx.Exec(`INSERT INTO groups(uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,'members','active',?,?,?,?) ON CONFLICT(domain_uuid,name) DO UPDATE SET builtin_key=excluded.builtin_key`, uuid.NewString(), domainUUID, key, strings.ReplaceAll(key, "_", " "), "Built-in administrative group", key, key == "campus_admin", now, now)
if err != nil {
return err
}
}
_, err = tx.Exec(`INSERT OR IGNORE INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) SELECT g.uuid,m.uuid,'owner','migration',? FROM groups g JOIN domain_memberships m ON m.domain_uuid=g.domain_uuid JOIN auth_role_bindings b ON b.membership_uuid=m.uuid JOIN auth_roles r ON r.uuid=b.role_uuid JOIN auth_capability_grants c ON c.role_uuid=r.uuid AND c.capability='manage' AND c.target_type='domain' WHERE g.domain_uuid=? AND g.builtin_key='domain_admin'`, now, domainUUID)
if err != nil {
return err
}
}
if err = seedCampusAdminRoleGrantsTx(tx, now); err != nil {
return err
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) IsBuiltinGroupAdmin(domainUUID, principalUUID, key string) bool {
var allowed int
_ = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM groups g JOIN domains d ON d.uuid=g.domain_uuid AND d.enabled=1 JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE g.domain_uuid=? AND g.builtin_key=? AND g.state='active' AND m.principal_uuid=? AND m.state='active' AND p.state='active' AND gm.member_role IN ('owner','manager'))`, domainUUID, key, principalUUID).Scan(&allowed)
return allowed != 0
}
func (s *Store) IsCampusAdmin(campusUUID, principalUUID string) bool {
var allowed int
_ = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM groups g JOIN domains d ON d.uuid=g.domain_uuid AND d.enabled=1 JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE d.campus_uuid=? AND g.builtin_key='campus_admin' AND g.state='active' AND m.principal_uuid=? AND m.state='active' AND p.state='active' AND gm.member_role IN ('owner','manager'))`, campusUUID, principalUUID).Scan(&allowed)
return allowed != 0
}
func (s *Store) SetCampusAdminInheritance(groupUUID string, enabled bool) error {
value := 0
if enabled {
value = 1
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
result, err := tx.Exec(`UPDATE groups SET inherit_members=?,updated_at_ms=? WHERE uuid=? AND builtin_key='campus_admin'`, value, time.Now().UnixMilli(), groupUUID)
if err != nil {
return err
}
changed, _ := result.RowsAffected()
if changed != 1 {
return errors.New("campus_admin group not found")
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) CreateGroup(domainUUID, ownerPrincipalUUID, name, displayName, description, visibility string) (*Group, error) {
name, err := normalizeGroupName(name)
if err != nil {
return nil, err
}
if visibility != "public" && visibility != "domain" && visibility != "members" {
visibility = "members"
}
if strings.TrimSpace(displayName) == "" {
displayName = name
}
now := time.Now().UnixMilli()
group := &Group{UUID: uuid.NewString(), DomainUUID: domainUUID, Name: name, DisplayName: strings.TrimSpace(displayName), Description: strings.TrimSpace(description), Visibility: visibility, State: "active", CreatedAtMS: now, UpdatedAtMS: now}
tx, err := s.DB.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
var membershipUUID string
if err := tx.QueryRow(`SELECT uuid FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=? AND state='active'`, domainUUID, ownerPrincipalUUID).Scan(&membershipUUID); err != nil {
return nil, err
}
if _, err = tx.Exec(`INSERT INTO groups(uuid,domain_uuid,name,display_name,description,visibility,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?,?,?)`, group.UUID, domainUUID, group.Name, group.DisplayName, group.Description, group.Visibility, group.State, now, now); err != nil {
return nil, err
}
if _, err = tx.Exec(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) VALUES(?,?, 'owner','local',?)`, group.UUID, membershipUUID, now); err != nil {
return nil, err
}
return group, tx.Commit()
}
func (s *Store) GroupByName(domainUUID, name string) (*Group, error) {
var group Group
err := s.DB.QueryRow(`SELECT uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms FROM groups WHERE domain_uuid=? AND name=? AND state!='archived'`, domainUUID, strings.ToLower(strings.TrimSpace(name))).Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS)
return &group, err
}
func (s *Store) GroupByUUID(domainUUID, groupUUID string) (*Group, error) {
var group Group
err := s.DB.QueryRow(`SELECT uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms FROM groups WHERE domain_uuid=? AND uuid=?`, domainUUID, groupUUID).Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS)
return &group, err
}
func (s *Store) ListGroups(domainUUID, principalUUID string) ([]Group, error) {
rows, err := s.DB.Query(`SELECT DISTINCT g.uuid,g.domain_uuid,g.name,g.display_name,g.description,g.visibility,g.state,g.builtin_key,g.inherit_members,g.created_at_ms,g.updated_at_ms FROM groups g LEFT JOIN group_members gm ON gm.group_uuid=g.uuid LEFT JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.principal_uuid=? WHERE g.domain_uuid=? AND g.state!='archived' AND (g.visibility='public' OR (?!='' AND g.visibility='domain') OR m.uuid IS NOT NULL) ORDER BY lower(g.display_name),g.name`, principalUUID, domainUUID, principalUUID)
if err != nil {
return nil, err
}
defer rows.Close()
var groups []Group
for rows.Next() {
var group Group
if err := rows.Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS); err != nil {
return nil, err
}
groups = append(groups, group)
}
return groups, rows.Err()
}
func (s *Store) GroupMemberRole(groupUUID, principalUUID string) string {
var role string
_ = s.DB.QueryRow(`SELECT gm.member_role FROM group_members gm JOIN domain_memberships m ON m.uuid=gm.membership_uuid WHERE gm.group_uuid=? AND m.principal_uuid=? AND m.state='active'`, groupUUID, principalUUID).Scan(&role)
return role
}
func (s *Store) GroupMemberRoleByMembership(groupUUID, membershipUUID string) string {
var role string
_ = s.DB.QueryRow(`SELECT member_role FROM group_members WHERE group_uuid=? AND membership_uuid=?`, groupUUID, membershipUUID).Scan(&role)
return role
}
func (s *Store) ListGroupMembers(groupUUID string) ([]GroupMember, error) {
rows, err := s.DB.Query(`SELECT m.uuid,p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' LIMIT 1),p.uuid),p.display_name,gm.member_role,gm.source FROM group_members gm JOIN domain_memberships m ON m.uuid=gm.membership_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE gm.group_uuid=? ORDER BY CASE gm.member_role WHEN 'owner' THEN 0 WHEN 'manager' THEN 1 ELSE 2 END,lower(p.display_name)`, groupUUID)
if err != nil {
return nil, err
}
defer rows.Close()
var members []GroupMember
for rows.Next() {
var member GroupMember
if err := rows.Scan(&member.MembershipUUID, &member.PrincipalUUID, &member.Username, &member.DisplayName, &member.MemberRole, &member.Source); err != nil {
return nil, err
}
members = append(members, member)
}
return members, rows.Err()
}
func (s *Store) AddGroupMemberByUsername(domainUUID, groupUUID, username, role string) error {
if role != "owner" && role != "manager" && role != "member" {
return errors.New("invalid group member role")
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
// Serialize before the identity lookup as well as the ownership check.
if _, err = tx.Exec(`UPDATE groups SET updated_at_ms=updated_at_ms WHERE uuid=? AND domain_uuid=?`, groupUUID, domainUUID); err != nil {
return err
}
var membershipUUID, builtinKey string
err = tx.QueryRow(`SELECT m.uuid,g.builtin_key FROM domain_memberships m JOIN principal_identities i ON i.principal_uuid=m.principal_uuid AND i.provider_type='password' JOIN groups g ON g.uuid=? AND g.domain_uuid=m.domain_uuid WHERE m.domain_uuid=? AND i.subject=? AND m.state='active'`, groupUUID, domainUUID, strings.ToLower(strings.TrimSpace(username))).Scan(&membershipUUID, &builtinKey)
if err != nil {
return err
}
// Ordinary add/update is not an ownership-transfer API. Keep this check in
// the write itself, including when another request just promoted the member.
result, err := tx.Exec(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) VALUES(?,?,?,'local',?) ON CONFLICT(group_uuid,membership_uuid) DO UPDATE SET member_role=excluded.member_role,source=excluded.source WHERE group_members.member_role!='owner' OR excluded.member_role='owner'`, groupUUID, membershipUUID, role, time.Now().UnixMilli())
if err != nil {
return err
}
if count, err := result.RowsAffected(); err != nil {
return err
} else if count == 0 {
return errors.New("owner role cannot be downgraded by a member update")
}
if builtinKey == "campus_admin" {
if _, err = tx.Exec(`DELETE FROM campus_admin_grants WHERE group_uuid=? AND membership_uuid=? AND substr(source,1,21)!='campus_admin_inherit:'`, groupUUID, membershipUUID); err != nil {
return err
}
if _, err = tx.Exec(`INSERT INTO campus_admin_grants(group_uuid,membership_uuid,source,member_role,created_at_ms) VALUES(?,?,'local',?,?)`, groupUUID, membershipUUID, role, time.Now().UnixMilli()); err != nil {
return err
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
return err
}
}
// An explicit local grant adopts a previously projected Domain membership.
if _, err = tx.Exec(`DELETE FROM campus_admin_membership_origins WHERE membership_uuid=?`, membershipUUID); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) RemoveGroupMember(groupUUID, membershipUUID string) error {
return s.RemoveGroupMemberWithAuthority(groupUUID, membershipUUID, true)
}
func (s *Store) RemoveGroupMemberWithAuthority(groupUUID, membershipUUID string, ownerAuthority bool) error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
if _, err = tx.Exec(`UPDATE groups SET updated_at_ms=updated_at_ms WHERE uuid=?`, groupUUID); err != nil {
return err
}
var builtinKey string
if err = tx.QueryRow(`SELECT builtin_key FROM groups WHERE uuid=?`, groupUUID).Scan(&builtinKey); err != nil {
return err
}
if builtinKey == "campus_admin" {
// Inherited-only entries can only be revoked at their source. Inherited
// owners do not satisfy the guard for removing the last independent owner.
var allowed int
if err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM campus_admin_grants grant
WHERE grant.group_uuid=? AND grant.membership_uuid=?
AND substr(grant.source,1,21)!='campus_admin_inherit:'
AND (? OR NOT EXISTS(SELECT 1 FROM group_members gm WHERE gm.group_uuid=grant.group_uuid
AND gm.membership_uuid=grant.membership_uuid AND gm.member_role!='member'))
AND (NOT EXISTS(SELECT 1 FROM campus_admin_grants mine WHERE mine.group_uuid=grant.group_uuid
AND mine.membership_uuid=grant.membership_uuid AND mine.member_role='owner'
AND substr(mine.source,1,21)!='campus_admin_inherit:')
OR EXISTS(SELECT 1 FROM campus_admin_grants other WHERE other.group_uuid=grant.group_uuid
AND other.membership_uuid!=grant.membership_uuid AND other.member_role='owner'
AND substr(other.source,1,21)!='campus_admin_inherit:'))
)`, groupUUID, membershipUUID, ownerAuthority).Scan(&allowed); err != nil {
return err
}
if allowed == 0 {
return errors.New("member removal requires a local grant, sufficient authority, and at least one remaining local owner; inherited grants must be revoked at their source")
}
if _, err = tx.Exec(`DELETE FROM campus_admin_grants WHERE group_uuid=? AND membership_uuid=? AND substr(source,1,21)!='campus_admin_inherit:'`, groupUUID, membershipUUID); err != nil {
return err
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
return err
}
return tx.Commit()
}
// A single SQLite write serializes the check and deletion. A manager cannot
// delete a member concurrently promoted to owner/manager by another request.
result, err := tx.Exec(`DELETE FROM group_members WHERE group_uuid=? AND membership_uuid=?
AND (? OR member_role='member')
AND (member_role!='owner' OR EXISTS (
SELECT 1 FROM group_members other WHERE other.group_uuid=? AND other.membership_uuid!=? AND other.member_role='owner'
))`, groupUUID, membershipUUID, ownerAuthority, groupUUID, membershipUUID)
if err != nil {
return err
}
if count, err := result.RowsAffected(); err != nil {
return err
} else if count == 0 {
return errors.New("member removal requires sufficient authority and at least one remaining owner")
}
return tx.Commit()
}
func (s *Store) SetGroupPermission(groupUUID, scopePath, permission string) error {
permission, err := NormalizeGroupPermission(permission)
if err != nil {
return err
}
scopePath = "/" + strings.Trim(strings.TrimSpace(scopePath), "/")
if scopePath == "//" {
scopePath = "/"
}
_, err = s.DB.Exec(`INSERT INTO group_permissions(uuid,group_uuid,scope_path,permission,created_at_ms) VALUES(?,?,?,?,?) ON CONFLICT(group_uuid,scope_path) DO UPDATE SET permission=excluded.permission`, uuid.NewString(), groupUUID, scopePath, permission, time.Now().UnixMilli())
return err
}
func (s *Store) ListGroupPermissions(groupUUID string) ([]GroupPermission, error) {
rows, err := s.DB.Query(`SELECT uuid,group_uuid,scope_path,permission FROM group_permissions WHERE group_uuid=? ORDER BY scope_path`, groupUUID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []GroupPermission
for rows.Next() {
var item GroupPermission
if err := rows.Scan(&item.UUID, &item.GroupUUID, &item.ScopePath, &item.Permission); err != nil {
return nil, err
}
out = append(out, item)
}
return out, rows.Err()
}
func (s *Store) groupPermissionAllows(domainUUID, principalUUID, capability, targetPath string) (bool, error) {
return groupPermissionAllowsFrom(s.DB, domainUUID, principalUUID, capability, targetPath)
}
func groupPermissionAllowsFrom(q pathQueryer, domainUUID, principalUUID, capability, targetPath string) (bool, error) {
rows, err := q.Query(`SELECT gp.scope_path,gp.permission FROM group_permissions gp JOIN groups g ON g.uuid=gp.group_uuid AND g.domain_uuid=? AND g.state='active' JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.principal_uuid=? AND m.state='active' JOIN principals p ON p.uuid=m.principal_uuid AND (p.state='active' OR (p.state='readonly' AND ?='read'))`, domainUUID, principalUUID, capability)
if err != nil {
return false, err
}
defer rows.Close()
for rows.Next() {
var scope, permission string
if err := rows.Scan(&scope, &permission); err != nil {
return false, err
}
inside := targetPath == scope || scope == "/" || strings.HasPrefix(targetPath, strings.TrimRight(scope, "/")+"/")
if inside && groupPermissions[permission][capability] {
return true, nil
}
}
return false, rows.Err()
}