BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

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