package store import ( "context" "database/sql" "errors" "time" "gitlab.com/Timfa/bluegit/internal/access" ) // ApprovalPolicy is de instelling voor verplichte goedkeuringen. // Configured onderscheidt "nooit bewaard" van een bewuste keuze, // ook als die keuze de eis uitzet. Een bewaarde groepsregel wint // van de projectregel. type ApprovalPolicy struct { Configured bool MaintainerRequired bool RequiredCount int DevelopersApprove bool } // GetApproval leest de regel. Zonder rij is hij niet ingesteld en is het aantal 1. func (s *Store) GetApproval(ctx context.Context, scopeKind string, scopeID int64) (ApprovalPolicy, error) { var configured, required, developers int var count int err := s.db.QueryRowContext(ctx, `SELECT configured, maintainer_required, required_count, developers_approve FROM approval_rules WHERE scope_kind = ? AND scope_id = ?`, scopeKind, scopeID).Scan(&configured, &required, &count, &developers) if errors.Is(err, sql.ErrNoRows) { return ApprovalPolicy{RequiredCount: 1}, nil } if err != nil { return ApprovalPolicy{}, err } if count < 1 { count = 1 } return ApprovalPolicy{ Configured: configured == 1, MaintainerRequired: required == 1, RequiredCount: count, DevelopersApprove: developers == 1, }, nil } // SaveApproval bewaart de regel en markeert hem als ingesteld. func (s *Store) SaveApproval(ctx context.Context, scopeKind string, scopeID int64, p ApprovalPolicy) error { if p.RequiredCount < 1 { p.RequiredCount = 1 } if p.RequiredCount > 100 { p.RequiredCount = 100 } _, err := s.db.ExecContext(ctx, `INSERT INTO approval_rules (scope_kind, scope_id, configured, maintainer_required, required_count, developers_approve) VALUES (?, ?, 1, ?, ?, ?) ON CONFLICT(scope_kind, scope_id) DO UPDATE SET configured = 1, maintainer_required = excluded.maintainer_required, required_count = excluded.required_count, developers_approve = excluded.developers_approve`, scopeKind, scopeID, boolInt(p.MaintainerRequired), p.RequiredCount, boolInt(p.DevelopersApprove)) return err } // EffectiveApproval is de regel die voor een repository geldt. // Een ingestelde groepsregel vervangt de projectregel. func (s *Store) EffectiveApproval(ctx context.Context, repo Repo) (ApprovalPolicy, string, error) { if repo.OwnerKind == "group" { p, err := s.GetApproval(ctx, "group", repo.OwnerID) if err != nil { return ApprovalPolicy{}, "", err } if p.Configured { g, err := s.GroupByID(ctx, repo.OwnerID) if err != nil { return ApprovalPolicy{}, "", err } return p, g.Path, nil } } p, err := s.GetApproval(ctx, "repo", repo.ID) return p, "", err } // GroupMaintainerCount telt beheerders, inclusief de maker van de groep. func (s *Store) GroupMaintainerCount(ctx context.Context, groupID int64) (int, error) { g, err := s.GroupByID(ctx, groupID) if err != nil { return 0, err } ids := map[int64]bool{g.OwnerID: true} members, err := s.ListMembers(ctx, "group", groupID) if err != nil { return 0, err } for _, m := range members { if !m.Pending && m.Role == access.RoleMaintainer && m.UserID != 0 { ids[m.UserID] = true } } return len(ids), nil } // ProjectMaintainerCount telt wie op dit project beheerder is. // Bij een groep horen de groepsbeheerders en de maker daar ook bij. func (s *Store) ProjectMaintainerCount(ctx context.Context, repo Repo) (int, error) { ids := map[int64]bool{} if repo.OwnerKind == "user" { ids[repo.OwnerID] = true } if repo.OwnerKind == "group" { g, err := s.GroupByID(ctx, repo.OwnerID) if err != nil { return 0, err } ids[g.OwnerID] = true members, err := s.ListMembers(ctx, "group", g.ID) if err != nil { return 0, err } for _, m := range members { if !m.Pending && m.Role == access.RoleMaintainer && m.UserID != 0 { ids[m.UserID] = true } } } members, err := s.ListMembers(ctx, "repo", repo.ID) if err != nil { return 0, err } for _, m := range members { if !m.Pending && m.Role == access.RoleMaintainer && m.UserID != 0 { ids[m.UserID] = true } } return len(ids), nil } // Review is de huidige review van één persoon op een merge request. type Review struct { UserID int64 Username string Status string UpdatedAt time.Time } // UpsertReview zet de review van deze gebruiker. // status is approved, changes, rejected of dismissed. func (s *Store) UpsertReview(ctx context.Context, repoID, mrID, userID int64, status string) error { _, err := s.db.ExecContext(ctx, `INSERT INTO reviews (repo_id, mr_id, user_id, status, updated_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT(mr_id, user_id) DO UPDATE SET status = excluded.status, updated_at = excluded.updated_at`, repoID, mrID, userID, status, now()) return err } // ListReviews geeft elke reviewer, oudste bijwerking eerst. func (s *Store) ListReviews(ctx context.Context, mrID int64) ([]Review, error) { rows, err := s.db.QueryContext(ctx, `SELECT r.user_id, u.username, r.status, r.updated_at FROM reviews r JOIN users u ON u.id = r.user_id WHERE r.mr_id = ? ORDER BY r.updated_at, r.user_id`, mrID) if err != nil { return nil, err } defer rows.Close() var out []Review for rows.Next() { var rev Review var updated string if err := rows.Scan(&rev.UserID, &rev.Username, &rev.Status, &updated); err != nil { return nil, err } rev.UpdatedAt = parseTime(updated) out = append(out, rev) } return out, rows.Err() }