BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

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