BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

settings_handlers.go 19.5 KiB Download Raw
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "errors"
7 "net/http"
8 "sort"
9 "strconv"
10 "strings"
11
12 "gitlab.com/Timfa/bluegit/internal/access"
13 "gitlab.com/Timfa/bluegit/internal/i18n"
14 "gitlab.com/Timfa/bluegit/internal/store"
15 "gitlab.com/Timfa/bluegit/internal/webhook"
16)
17
18func (s *Server) settings(w http.ResponseWriter, r *http.Request) {
19 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
20 if !ok {
21 return
22 }
23 v := s.repoView(w, r, repo, role, "title.settings")
24 v.Page = "settings"
25 v.Wide = true
26 v.Tab = settingsTab(r.URL.Query().Get("tab"))
27 if role.CanManageSettings() {
28 v.Members, _ = s.Store.ListMembers(r.Context(), "repo", repo.ID)
29 if repo.OwnerKind == "user" {
30 owner, err := s.Store.UserByID(r.Context(), repo.OwnerID)
31 if err == nil {
32 v.Members = append([]store.Member{{UserID: owner.ID, Username: owner.Username, Role: access.RoleMaintainer}}, v.Members...)
33 }
34 }
35 v.Secrets, _ = s.Store.ListSecrets(r.Context(), "repo", repo.ID)
36 v.HookSecrets = s.repoSecretChoices(r, repo)
37 v.Patterns, _ = s.Store.ProtectedPatterns(r.Context(), repo.ID)
38 v.TagPatterns, _ = s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
39 v.Hooks = s.hookViews(r, "repo", repo.ID)
40 s.fillHookEdit(r, &v, "repo", repo.ID)
41 s.fillApproval(r, &v, repo)
42 }
43 s.render(w, "settings", v)
44}
45
46func (s *Server) hookViews(r *http.Request, kind string, id int64) []HookView {
47 hooks, err := s.Store.ListWebhooks(r.Context(), kind, id)
48 if err != nil {
49 return nil
50 }
51 lang := s.langOf(r)
52 var out []HookView
53 for _, h := range hooks {
54 d, _ := s.Store.RecentDeliveries(r.Context(), h.ID)
55 out = append(out, HookView{
56 ID: h.ID, Name: h.Name, Preset: h.Preset, URL: h.URLTemplate, Method: h.Method,
57 Filter: h.BranchFilter, Events: strings.Join(h.Events, ", "),
58 Badges: eventBadges(lang, h.Events), Deliveries: d,
59 })
60 }
61 return out
62}
63
64func eventBadges(lang i18n.Lang, events []string) []string {
65 var out []string
66 for _, e := range events {
67 key := ""
68 switch e {
69 case webhook.EventPush:
70 key = "set.ev.push"
71 case webhook.EventMergeRequest:
72 key = "set.ev.mr"
73 case webhook.EventPipelineSuccess:
74 key = "set.ev.ok"
75 case webhook.EventPipelineFailure:
76 key = "set.ev.fail"
77 case webhook.EventRelease:
78 key = "set.ev.release"
79 }
80 if key == "" {
81 out = append(out, e)
82 continue
83 }
84 out = append(out, i18n.T(lang, key))
85 }
86 return out
87}
88
89func (s *Server) fillHookEdit(r *http.Request, v *View, kind string, id int64) {
90 if kind == "repo" && v.Tab != "webhooks" {
91 return
92 }
93 if kind == "group" && v.Tab != "settings" {
94 return
95 }
96 raw := strings.TrimSpace(r.URL.Query().Get("hook"))
97 if raw == "" {
98 return
99 }
100 hid, err := strconv.ParseInt(raw, 10, 64)
101 if err != nil || hid <= 0 {
102 return
103 }
104 h, err := s.Store.Webhook(r.Context(), kind, id, hid)
105 if err != nil {
106 return
107 }
108 v.HookEdit = draftFrom(h)
109 if v.HookEdit.Token != "" {
110 v.HookSecrets = keepToken(v.HookSecrets, v.HookEdit.Token)
111 }
112}
113
114func keepToken(in []SecretChoice, name string) []SecretChoice {
115 for _, c := range in {
116 if c.Name == name {
117 return in
118 }
119 }
120 return append(in, SecretChoice{Name: name, Label: name})
121}
122
123func draftFrom(h store.Webhook) HookDraft {
124 d := HookDraft{
125 ID: h.ID, Name: h.Name, Preset: h.Preset, Filter: h.BranchFilter, Method: h.Method,
126 }
127 var in webhook.Input
128 if h.Fields != "" && json.Unmarshal([]byte(h.Fields), &in) == nil {
129 d.URL, d.Username, d.Avatar, d.Icon, d.Alias = in.URL, in.Username, in.Avatar, in.Icon, in.Alias
130 d.Token, d.Chat, d.Server, d.Topic = in.Token, in.Chat, in.Server, in.Topic
131 d.Home, d.Room, d.CType, d.Headers, d.Body = in.Homeserver, in.Room, in.ContentType, in.Headers, in.Body
132 if in.Method != "" {
133 d.Method = in.Method
134 }
135 } else {
136 d.URL = h.URLTemplate
137 d.Body = h.BodyTemplate
138 d.Headers = headerLines(h.Headers)
139 d.CType = h.Headers["Content-Type"]
140 }
141 for _, e := range h.Events {
142 switch e {
143 case webhook.EventPush:
144 d.OnPush = true
145 case webhook.EventMergeRequest:
146 d.OnMR = true
147 case webhook.EventPipelineSuccess:
148 d.OnOK = true
149 case webhook.EventPipelineFailure:
150 d.OnFail = true
151 case webhook.EventRelease:
152 d.OnRel = true
153 case webhook.EventIssue:
154 d.OnIssue = true
155 }
156 }
157 d.Extra = hookEventChoices(h.Events)
158 if d.Preset == "" {
159 d.Preset = webhook.PresetCustom
160 }
161 if d.Method == "" {
162 d.Method = "POST"
163 }
164 return d
165}
166
167func headerLines(h map[string]string) string {
168 if len(h) == 0 {
169 return ""
170 }
171 keys := make([]string, 0, len(h))
172 for k := range h {
173 keys = append(keys, k)
174 }
175 sort.Strings(keys)
176 var b strings.Builder
177 for i, k := range keys {
178 if i > 0 {
179 b.WriteByte('\n')
180 }
181 b.WriteString(k)
182 b.WriteString(": ")
183 b.WriteString(h[k])
184 }
185 return b.String()
186}
187
188func (s *Server) updateRepo(w http.ResponseWriter, r *http.Request) {
189 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
190 if !ok || !s.csrfOK(w, r) {
191 return
192 }
193 if err := s.opUpdateRepo(r.Context(), s.who(r).User, repo, r.FormValue("description"), r.FormValue("visibility")); err != nil {
194 s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))
195 return
196 }
197 if rv := r.FormValue("release_visibility"); rv != "" {
198 if err := s.opSetReleaseVisibility(r.Context(), s.who(r).User, repo, rv); err != nil {
199 s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))
200 return
201 }
202 }
203 s.redirect(w, r, repoURL(repo)+"/-/settings", s.tr(r, "flash.saved"), "")
204}
205
206func (s *Server) repoMember(w http.ResponseWriter, r *http.Request) {
207 s.memberPost(w, r, "repo")
208}
209
210func (s *Server) repoMemberRemove(w http.ResponseWriter, r *http.Request) {
211 s.memberRemove(w, r, "repo")
212}
213
214func (s *Server) groupMember(w http.ResponseWriter, r *http.Request) {
215 s.memberPost(w, r, "group")
216}
217
218func (s *Server) groupMemberRemove(w http.ResponseWriter, r *http.Request) {
219 s.memberRemove(w, r, "group")
220}
221
222func (s *Server) memberPost(w http.ResponseWriter, r *http.Request, kind string) {
223 scopeID, back, ok := s.adminScope(w, r, kind)
224 if !ok || !s.csrfOK(w, r) {
225 return
226 }
227 if err := s.opSetMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username"), r.FormValue("role")); err != nil {
228 s.redirect(w, r, back, "", s.commitProblem(r, err))
229 return
230 }
231 s.redirect(w, r, back, s.tr(r, "flash.memberSaved"), "")
232}
233
234func (s *Server) memberRemove(w http.ResponseWriter, r *http.Request, kind string) {
235 scopeID, back, ok := s.adminScope(w, r, kind)
236 if !ok || !s.csrfOK(w, r) {
237 return
238 }
239 if err := s.opRemoveMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username")); err != nil {
240 s.redirect(w, r, back, "", s.trErr(r, err))
241 return
242 }
243 s.redirect(w, r, back, s.tr(r, "flash.memberRemoved"), "")
244}
245
246func (s *Server) adminScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) {
247 if kind == "group" {
248 g, role, ok := s.guardGroup(w, r, access.RoleMaintainer)
249 if !ok {
250 return 0, "", false
251 }
252 _ = role
253 return g.ID, "/groups/" + g.Path + "?tab=members", true
254 }
255 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
256 if !ok {
257 return 0, "", false
258 }
259 return repo.ID, repoURL(repo) + "/-/settings?tab=members", true
260}
261
262func (s *Server) addProtected(w http.ResponseWriter, r *http.Request) {
263 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
264 if !ok || !s.csrfOK(w, r) {
265 return
266 }
267 if err := s.opProtect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false); err != nil {
268 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "", s.trErr(r, err))
269 return
270 }
271 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.branchOn"), "")
272}
273
274func (s *Server) removeProtected(w http.ResponseWriter, r *http.Request) {
275 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
276 if !ok || !s.csrfOK(w, r) {
277 return
278 }
279 _ = s.opUnprotect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false)
280 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.patternOff"), "")
281}
282
283func (s *Server) repoSecret(w http.ResponseWriter, r *http.Request) {
284 s.secretPost(w, r, "repo")
285}
286func (s *Server) repoSecretDelete(w http.ResponseWriter, r *http.Request) {
287 s.secretDelete(w, r, "repo")
288}
289func (s *Server) groupSecret(w http.ResponseWriter, r *http.Request) {
290 s.secretPost(w, r, "group")
291}
292func (s *Server) groupSecretDelete(w http.ResponseWriter, r *http.Request) {
293 s.secretDelete(w, r, "group")
294}
295
296// secretScope laat alleen een maintainer secrets bekijken of bewerken, ook protected.
297func (s *Server) secretScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) {
298 if kind == "group" {
299 g, role, ok := s.guardGroup(w, r, access.RoleReadonly)
300 if !ok {
301 return 0, "", false
302 }
303 if !role.CanManageSecrets() {
304 http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
305 return 0, "", false
306 }
307 return g.ID, "/groups/" + g.Path + "?tab=settings#secrets", true
308 }
309 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
310 if !ok {
311 return 0, "", false
312 }
313 if !role.CanManageSecrets() {
314 http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
315 return 0, "", false
316 }
317 return repo.ID, repoURL(repo) + "/-/settings?tab=secrets", true
318}
319
320func (s *Server) secretPost(w http.ResponseWriter, r *http.Request, kind string) {
321 scopeID, back, ok := s.secretScope(w, r, kind)
322 if !ok || !s.csrfOK(w, r) {
323 return
324 }
325 name := strings.TrimSpace(r.FormValue("name"))
326 value := r.FormValue("value")
327 protected := r.FormValue("protected") == "1"
328 flash := "flash.secretSaved"
329 var err error
330 switch r.FormValue("mode") {
331 case "update":
332 err = s.Store.UpdateSecret(r.Context(), kind, scopeID, name, value, protected)
333 case "replace":
334 err = s.Store.ReplaceSecret(r.Context(), kind, scopeID, name, value, protected)
335 flash = "flash.secretReplaced"
336 default:
337 err = s.Store.CreateSecret(r.Context(), kind, scopeID, name, value, protected, r.FormValue("invisible") == "1")
338 }
339 if err != nil {
340 s.redirect(w, r, back, "", s.trErr(r, err))
341 return
342 }
343 s.redirect(w, r, back, s.tr(r, flash), "")
344}
345
346func (s *Server) repoSecretReveal(w http.ResponseWriter, r *http.Request) {
347 s.secretReveal(w, r, "repo")
348}
349
350func (s *Server) groupSecretReveal(w http.ResponseWriter, r *http.Request) {
351 s.secretReveal(w, r, "group")
352}
353
354func (s *Server) secretReveal(w http.ResponseWriter, r *http.Request, kind string) {
355 scopeID, _, ok := s.secretScope(w, r, kind)
356 if !ok || !s.csrfOK(w, r) {
357 return
358 }
359 value, err := s.Store.RevealSecret(r.Context(), kind, scopeID, strings.TrimSpace(r.FormValue("name")))
360 w.Header().Set("Content-Type", "application/json")
361 if err != nil {
362 s.writeSecretJSONErr(w, r, err)
363 return
364 }
365 _ = json.NewEncoder(w).Encode(map[string]string{"value": value})
366}
367
368func (s *Server) writeSecretJSONErr(w http.ResponseWriter, r *http.Request, err error) {
369 w.Header().Set("Content-Type", "application/json")
370 w.WriteHeader(secretStatus(err))
371 _ = json.NewEncoder(w).Encode(map[string]string{"error": s.trErr(r, err)})
372}
373
374func secretStatus(err error) int {
375 if store.Missing(err) {
376 return http.StatusNotFound
377 }
378 var ie i18n.Error
379 if errors.As(err, &ie) {
380 switch ie.Key {
381 case "err.secretHidden":
382 return http.StatusForbidden
383 case "err.secretExists", "err.secretVisible":
384 return http.StatusConflict
385 }
386 }
387 return http.StatusBadRequest
388}
389
390func (s *Server) secretDelete(w http.ResponseWriter, r *http.Request, kind string) {
391 scopeID, back, ok := s.secretScope(w, r, kind)
392 if !ok || !s.csrfOK(w, r) {
393 return
394 }
395 _ = s.Store.DeleteSecret(r.Context(), kind, scopeID, r.FormValue("name"))
396 s.redirect(w, r, back, s.tr(r, "flash.secretRemoved"), "")
397}
398
399func (s *Server) repoWebhook(w http.ResponseWriter, r *http.Request) { s.webhookPost(w, r, "repo") }
400func (s *Server) repoWebhookDelete(w http.ResponseWriter, r *http.Request) {
401 s.webhookDelete(w, r, "repo")
402}
403func (s *Server) groupWebhook(w http.ResponseWriter, r *http.Request) {
404 s.webhookPost(w, r, "group")
405}
406func (s *Server) groupWebhookDelete(w http.ResponseWriter, r *http.Request) {
407 s.webhookDelete(w, r, "group")
408}
409
410func (s *Server) webhookPost(w http.ResponseWriter, r *http.Request, kind string) {
411 scopeID, back, ok := s.adminScope(w, r, kind)
412 if !ok || !s.csrfOK(w, r) {
413 return
414 }
415 back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")
416 if kind == "group" {
417 back += "#webhooks"
418 }
419 var events []string
420 for _, e := range webhook.AllEvents() {
421 if r.FormValue("event_"+e) == "1" {
422 events = append(events, e)
423 }
424 }
425 id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
426 _, err := s.saveWebhookRecord(r.Context(), kind, scopeID, id, strings.TrimSpace(r.FormValue("name")), r.FormValue("preset"), r.FormValue("branch_filter"), events, webhook.Input{
427 URL: r.FormValue("url"), Username: r.FormValue("username"), Avatar: r.FormValue("avatar"),
428 Icon: r.FormValue("icon"), Alias: r.FormValue("alias"), Token: r.FormValue("token"),
429 Chat: r.FormValue("chat"), Server: r.FormValue("server"), Topic: r.FormValue("topic"),
430 Homeserver: r.FormValue("homeserver"), Room: r.FormValue("room"),
431 Method: r.FormValue("method"), ContentType: r.FormValue("content_type"),
432 Headers: r.FormValue("headers"), Body: r.FormValue("body"),
433 })
434 if err != nil {
435 s.redirect(w, r, back, "", s.trErr(r, err))
436 return
437 }
438 s.redirect(w, r, back, s.tr(r, "flash.webhookSaved"), "")
439}
440
441func (s *Server) createWebhookRecord(ctx context.Context, kind string, scopeID int64, name, preset, filter string, events []string, in webhook.Input) (int64, error) {
442 return s.saveWebhookRecord(ctx, kind, scopeID, 0, name, preset, filter, events, in)
443}
444
445func (s *Server) saveWebhookRecord(ctx context.Context, kind string, scopeID, id int64, name, preset, filter string, events []string, in webhook.Input) (int64, error) {
446 if !webhook.KnownPreset(preset) {
447 return 0, i18n.E("err.preset")
448 }
449 filter = strings.TrimSpace(filter)
450 if _, err := webhook.MatchBranch(filter, "main"); err != nil {
451 return 0, err
452 }
453 if len(events) == 0 {
454 return 0, i18n.E("err.pickEvent")
455 }
456 spec, err := webhook.Prepare(preset, in)
457 if err != nil {
458 return 0, err
459 }
460 raw, err := json.Marshal(in)
461 if err != nil {
462 return 0, err
463 }
464 rec := store.Webhook{
465 ID: id, ScopeKind: kind, ScopeID: scopeID, Name: name,
466 Preset: preset, URLTemplate: spec.URL, Headers: spec.Headers,
467 BodyTemplate: spec.Body, Events: events, BranchFilter: filter, Method: spec.Method,
468 Fields: string(raw),
469 }
470 if id > 0 {
471 if err := s.Store.UpdateWebhook(ctx, rec); err != nil {
472 return 0, err
473 }
474 return id, nil
475 }
476 return s.Store.CreateWebhook(ctx, rec)
477}
478
479func (s *Server) webhookDelete(w http.ResponseWriter, r *http.Request, kind string) {
480 scopeID, back, ok := s.adminScope(w, r, kind)
481 if !ok || !s.csrfOK(w, r) {
482 return
483 }
484 back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")
485 id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
486 _ = s.opDeleteWebhook(r.Context(), s.who(r).User, kind, scopeID, id)
487 s.redirect(w, r, back, s.tr(r, "flash.webhookRemoved"), "")
488}
489
490func (s *Server) deleteRepo(w http.ResponseWriter, r *http.Request) {
491 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
492 if !ok || !s.csrfOK(w, r) {
493 return
494 }
495 u := s.who(r).User
496 if err := s.opDeleteRepo(r.Context(), u, repo, r.FormValue("confirm")); err != nil {
497 s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))
498 return
499 }
500 s.redirect(w, r, "/", s.tr(r, "flash.repoDeleted"), "")
501}
502
503func (s *Server) guardGroup(w http.ResponseWriter, r *http.Request, min access.Role) (store.Group, access.Role, bool) {
504 g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path"))
505 if err != nil {
506 http.NotFound(w, r)
507 return store.Group{}, "", false
508 }
509 p := s.who(r)
510 var role access.Role
511 if p.OK {
512 role, err = s.Store.GroupRole(r.Context(), g.ID, p.User.ID)
513 if err != nil {
514 http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
515 return store.Group{}, "", false
516 }
517 }
518 if isCrawler(r) {
519 p = principal{}
520 role = access.RoleNone
521 }
522 if min == access.RoleReadonly {
523 if role.CanRead() || g.Visibility == "public" {
524 return g, role, true
525 }
526 if isCrawler(r) {
527 s.writeLockedCard(w, r)
528 } else if p.OK {
529 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
530 } else {
531 http.NotFound(w, r)
532 }
533 return store.Group{}, "", false
534 }
535 if !p.OK {
536 http.Redirect(w, r, "/login", http.StatusFound)
537 return store.Group{}, "", false
538 }
539 if !role.AtLeast(min) {
540 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
541 return store.Group{}, "", false
542 }
543 return g, role, true
544}
545
546func (s *Server) groupPage(w http.ResponseWriter, r *http.Request) {
547 g, role, ok := s.guardGroup(w, r, access.RoleReadonly)
548 if !ok {
549 return
550 }
551 v := s.view(w, r, g.Name)
552 v.Wide = true
553 v.Group = &g
554 v.Role = role
555 v.CanAdmin = role.CanManageSettings()
556 tab := r.URL.Query().Get("tab")
557 switch tab {
558 case "members":
559 if !role.CanRead() {
560 tab = ""
561 }
562 case "settings":
563 if !role.CanManageSettings() {
564 tab = ""
565 }
566 default:
567 tab = ""
568 }
569 v.Tab = tab
570 all, _ := s.Store.ReposByGroup(r.Context(), g.ID)
571 uid := int64(0)
572 if v.User != nil {
573 uid = v.User.ID
574 }
575 var repos []store.Repo
576 for _, repo := range all {
577 if repo.Visibility == "public" {
578 repos = append(repos, repo)
579 continue
580 }
581 if uid == 0 {
582 continue
583 }
584 er, err := s.Store.EffectiveRole(r.Context(), uid, repo.ID)
585 if err == nil && er.CanRead() {
586 repos = append(repos, repo)
587 }
588 }
589 q := strings.TrimSpace(r.URL.Query().Get("q"))
590 dir := r.URL.Query().Get("dir")
591 if dir != "desc" {
592 dir = "asc"
593 }
594 v.Query, v.SortDir = q, dir
595 if dir == "desc" {
596 v.FlipDir = "asc"
597 } else {
598 v.FlipDir = "desc"
599 }
600 if lq := strings.ToLower(q); lq != "" {
601 var filtered []store.Repo
602 for _, repo := range repos {
603 if strings.Contains(strings.ToLower(repo.Name), lq) {
604 filtered = append(filtered, repo)
605 }
606 }
607 repos = filtered
608 }
609 sort.Slice(repos, func(i, j int) bool {
610 a, b := strings.ToLower(repos[i].Name), strings.ToLower(repos[j].Name)
611 if dir == "desc" {
612 return a > b
613 }
614 return a < b
615 })
616 ids := make([]int64, len(repos))
617 for i, repo := range repos {
618 ids[i] = repo.ID
619 }
620 counts, mine, _ := s.Store.StarInfo(r.Context(), uid, ids)
621 lang := s.langOf(r)
622 for _, repo := range repos {
623 v.Cards = append(v.Cards, RepoCard{
624 Repo: repo, Stars: counts[repo.ID], Starred: mine[repo.ID],
625 When: i18n.FormatDate(lang, repo.CreatedAt),
626 })
627 }
628 v.Repos = repos
629 v.Heat = s.heatmap(r.Context(), 0, s.visibleIDs(r.Context(), uid, repos), lang)
630 if tab == "members" && role.CanRead() {
631 v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID)
632 }
633 if tab == "settings" && role.CanManageSettings() {
634 v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID)
635 v.Secrets, _ = s.Store.ListSecrets(r.Context(), "group", g.ID)
636 v.HookSecrets = s.groupSecretChoices(r, g)
637 v.Hooks = s.hookViews(r, "group", g.ID)
638 s.fillHookEdit(r, &v, "group", g.ID)
639 s.fillGroupApproval(r, &v, g)
640 s.fillGroupRunners(w, r, &v, g)
641 if v.User != nil && v.User.ID == g.OwnerID {
642 v.IsOwner = true
643 v.Candidates = groupCandidates(v.Members, g.OwnerID)
644 }
645 }
646 s.render(w, "group", v)
647}
648
649func settingsTab(tab string) string {
650 switch tab {
651 case "leden", "members":
652 return "members"
653 case "geheimen", "secrets":
654 return "secrets"
655 case "branches":
656 return "branches"
657 case "tags":
658 return "tags"
659 case "webhooks":
660 return "webhooks"
661 case "approvals":
662 return "approvals"
663 default:
664 return "general"
665 }
666}
667
668func scopeTab(kind, repoTab string) string {
669 if kind == "group" {
670 if repoTab == "members" {
671 return "?tab=members"
672 }
673 return "?tab=settings"
674 }
675 return "?tab=" + repoTab
676}
677
678// hookEventChoices zet de fijnere events klaar voor het formulier.
679func hookEventChoices(selected []string) []HookEventChoice {
680 on := map[string]bool{}
681 for _, e := range selected {
682 on[e] = true
683 }
684 var out []HookEventChoice
685 for _, e := range webhook.SpecificEvents() {
686 out = append(out, HookEventChoice{Name: e, Key: "set.ev." + e, On: on[e]})
687 }
688 return out
689}