BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

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