BlueGit

timfa bluegit

Files

bluegit / internal / access / scope.go

scope.go

scope.go 3.1 KiB Download Raw
1package access
2
3import (
4 "sort"
5 "strings"
6
7 "gitlab.com/Timfa/bluegit/internal/i18n"
8)
9
10const (
11 ScopeAPI = "api"
12 ScopeReadAPI = "read_api"
13 ScopeReadRepo = "read_repository"
14 ScopeWriteRepo = "write_repository"
15 // ScopeRunners is alleen runnerbeheer (lijsten, tokens, pauzeren, voorkeuren).
16 ScopeRunners = "runners"
17)
18
19// ScopeClass is het soort aanroep dat een token moet toestaan.
20type ScopeClass int
21
22const (
23 ScopePublic ScopeClass = iota
24 ScopeRead
25 ScopeWrite
26 ScopeRepoRead
27 ScopeRepoWrite
28 ScopeAdmin
29 ScopeRunnerRead
30 ScopeRunnerWrite
31)
32
33// Scopes is de verzameling rechten op een toegangstoken.
34// api dekt de hele API en git. read_api is alleen lezen.
35// read_repository en write_repository gelden voor git en voor
36// repository-inhoud (bestanden, commits, branches, tags).
37type Scopes struct {
38 set map[string]bool
39}
40
41// ParseScopes maakt een opgeslagen lijst. Leeg wordt api.
42func ParseScopes(in []string) (string, Scopes, error) {
43 if len(in) == 0 {
44 return ScopeAPI, Scopes{set: map[string]bool{ScopeAPI: true}}, nil
45 }
46 seen := map[string]bool{}
47 var list []string
48 for _, raw := range in {
49 name := strings.TrimSpace(raw)
50 if name == "" {
51 continue
52 }
53 switch name {
54 case ScopeAPI, ScopeReadAPI, ScopeReadRepo, ScopeWriteRepo, ScopeRunners:
55 default:
56 return "", Scopes{}, i18n.E("err.scopeName", name)
57 }
58 if seen[name] {
59 continue
60 }
61 seen[name] = true
62 list = append(list, name)
63 }
64 if len(list) == 0 {
65 return ScopeAPI, Scopes{set: map[string]bool{ScopeAPI: true}}, nil
66 }
67 sort.Strings(list)
68 return strings.Join(list, ","), Scopes{set: seen}, nil
69}
70
71// StoredScopes leest de kommagescheiden kolom. Leeg telt als api.
72func StoredScopes(raw string) Scopes {
73 raw = strings.TrimSpace(raw)
74 if raw == "" {
75 return Scopes{set: map[string]bool{ScopeAPI: true}}
76 }
77 set := map[string]bool{}
78 for _, part := range strings.Split(raw, ",") {
79 part = strings.TrimSpace(part)
80 if part != "" {
81 set[part] = true
82 }
83 }
84 if len(set) == 0 {
85 set[ScopeAPI] = true
86 }
87 return Scopes{set: set}
88}
89
90func (s Scopes) List() []string {
91 var out []string
92 for name := range s.set {
93 out = append(out, name)
94 }
95 sort.Strings(out)
96 return out
97}
98
99func (s Scopes) APIWrite() bool { return s.set[ScopeAPI] }
100func (s Scopes) APIRead() bool { return s.set[ScopeAPI] || s.set[ScopeReadAPI] }
101func (s Scopes) RepoWrite() bool {
102 return s.set[ScopeAPI] || s.set[ScopeWriteRepo]
103}
104func (s Scopes) RepoRead() bool {
105 return s.RepoWrite() || s.set[ScopeReadRepo]
106}
107
108// Allows meldt of deze scopes de klasse dekken.
109func (s Scopes) Allows(class ScopeClass) bool {
110 switch class {
111 case ScopePublic:
112 return true
113 case ScopeRead:
114 return s.APIRead()
115 case ScopeWrite, ScopeAdmin:
116 return s.APIWrite()
117 case ScopeRepoRead:
118 return s.APIRead() || s.RepoRead()
119 case ScopeRepoWrite:
120 return s.APIWrite() || s.RepoWrite()
121 case ScopeRunnerRead:
122 return s.APIRead() || s.set[ScopeRunners]
123 case ScopeRunnerWrite:
124 return s.APIWrite() || s.set[ScopeRunners]
125 default:
126 return false
127 }
128}
129
130// AllScopes is wat een SSH-sessie mag: dezelfde rechten als de UI.
131func AllScopes() Scopes {
132 return Scopes{set: map[string]bool{ScopeAPI: true}}
133}