package store import ( "context" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/i18n" ) // SetLanguage bewaart de taalkeuze van een gebruiker. func (s *Store) SetLanguage(ctx context.Context, userID int64, lang string) error { _, err := s.db.ExecContext(ctx, `UPDATE users SET language = ? WHERE id = ?`, string(i18n.Parse(lang)), userID) return err } // UpdateGroup wijzigt beschrijving, zichtbaarheid en de standaardrol. func (s *Store) UpdateGroup(ctx context.Context, id int64, description, visibility string, defaultRole access.Role) error { if visibility != "public" && visibility != "private" { return i18n.E("err.visibility") } if _, err := access.ParseRole(string(defaultRole)); err != nil { return err } _, err := s.db.ExecContext(ctx, `UPDATE groups SET description = ?, visibility = ?, default_role = ? WHERE id = ?`, strings.TrimSpace(description), visibility, string(defaultRole), id) return err } // SetLogoMIME onthoudt het type van een opgeslagen logo. Leeg wist het. func (s *Store) SetLogoMIME(ctx context.Context, kind string, id int64, mime string) error { switch kind { case "group": _, err := s.db.ExecContext(ctx, `UPDATE groups SET logo_mime = ? WHERE id = ?`, mime, id) return err case "repo": _, err := s.db.ExecContext(ctx, `UPDATE repos SET logo_mime = ? WHERE id = ?`, mime, id) return err default: return i18n.E("err.scope") } } // GrantDefaultRoles zet op een nieuwe groepsrepository de standaardrol // voor elk huidig lid. Beheerders van de groep blijven beheerder. func (s *Store) GrantDefaultRoles(ctx context.Context, groupID, repoID int64) error { g, err := s.GroupByID(ctx, groupID) if err != nil { return err } rows, err := s.db.QueryContext(ctx, `SELECT user_id, role FROM group_members WHERE group_id = ?`, groupID) if err != nil { return err } defer rows.Close() for rows.Next() { var uid int64 var role string if err := rows.Scan(&uid, &role); err != nil { return err } grant := g.DefaultRole if access.Role(role) == access.RoleMaintainer { grant = access.RoleMaintainer } if _, err := s.db.ExecContext(ctx, `INSERT INTO repo_members (repo_id, user_id, role) VALUES (?, ?, ?) ON CONFLICT(repo_id, user_id) DO UPDATE SET role = excluded.role`, repoID, uid, string(grant)); err != nil { return err } } return rows.Err() } // SlugTaken meldt of een groeps- of repositorynaam al bezet is. func (s *Store) SlugTaken(ctx context.Context, kind, slug, ownerKind string, ownerID int64) (bool, error) { var n int var err error switch kind { case "group": err = s.db.QueryRowContext(ctx, `SELECT (SELECT COUNT(*) FROM users WHERE username = ?) + (SELECT COUNT(*) FROM groups WHERE path = ?)`, slug, slug).Scan(&n) case "repo": err = s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM repos WHERE owner_kind = ? AND owner_id = ? AND name = ?`, ownerKind, ownerID, slug).Scan(&n) default: return true, nil } if err != nil { return false, err } return n > 0, nil } // SetStar zet of haalt een ster weg. func (s *Store) SetStar(ctx context.Context, userID, repoID int64, on bool) error { if !on { _, err := s.db.ExecContext(ctx, `DELETE FROM stars WHERE user_id = ? AND repo_id = ?`, userID, repoID) return err } _, err := s.db.ExecContext(ctx, `INSERT INTO stars (user_id, repo_id, created_at) VALUES (?, ?, ?) ON CONFLICT(user_id, repo_id) DO NOTHING`, userID, repoID, now()) return err } // StarInfo telt sterren en meldt welke de gebruiker zelf zette. func (s *Store) StarInfo(ctx context.Context, userID int64, ids []int64) (map[int64]int, map[int64]bool, error) { counts := map[int64]int{} mine := map[int64]bool{} if len(ids) == 0 { return counts, mine, nil } q, args := inClause(ids) rows, err := s.db.QueryContext(ctx, `SELECT repo_id, COUNT(*) FROM stars WHERE repo_id IN (`+q+`) GROUP BY repo_id`, args...) if err != nil { return nil, nil, err } defer rows.Close() for rows.Next() { var id int64 var n int if err := rows.Scan(&id, &n); err != nil { return nil, nil, err } counts[id] = n } if err := rows.Err(); err != nil { return nil, nil, err } if userID == 0 { return counts, mine, nil } args = append([]any{userID}, args...) mrows, err := s.db.QueryContext(ctx, `SELECT repo_id FROM stars WHERE user_id = ? AND repo_id IN (`+q+`)`, args...) if err != nil { return nil, nil, err } defer mrows.Close() for mrows.Next() { var id int64 if err := mrows.Scan(&id); err != nil { return nil, nil, err } mine[id] = true } return counts, mine, mrows.Err() } func inClause(ids []int64) (string, []any) { hold := make([]string, len(ids)) args := make([]any, len(ids)) for i, id := range ids { hold[i] = "?" args[i] = id } return strings.Join(hold, ","), args }