BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

settings_handlers.go 21.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 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 sd := strings.TrimSpace(r.FormValue("stale_manual_days")); sd != "" || r.Form.Has("stale_manual_days") {
208 n := -1
209 if sd != "" {
210 v, err := strconv.Atoi(sd)
211 if err != nil {
212 s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.tr(r, "stale.err.days"))
213 return
214 }
215 n = v
216 }
217 if err := s.Store.SetRepoStaleManualDays(r.Context(), repo.ID, n); err != nil {
218 s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.tr(r, "stale.err.days"))
219 return
220 }
221 }
222 s.redirect(w, r, repoURL(repo)+"/-/settings", s.tr(r, "flash.saved"), "")
223}
224
225func (s *Server) repoMember(w http.ResponseWriter, r *http.Request) {
226 s.memberPost(w, r, "repo")
227}
228
229func (s *Server) repoMemberRemove(w http.ResponseWriter, r *http.Request) {
230 s.memberRemove(w, r, "repo")
231}
232
233func (s *Server) groupMember(w http.ResponseWriter, r *http.Request) {
234 s.memberPost(w, r, "group")
235}
236
237func (s *Server) groupMemberRemove(w http.ResponseWriter, r *http.Request) {
238 s.memberRemove(w, r, "group")
239}
240
241func (s *Server) memberPost(w http.ResponseWriter, r *http.Request, kind string) {
242 scopeID, back, ok := s.adminScope(w, r, kind)
243 if !ok || !s.csrfOK(w, r) {
244 return
245 }
246 if err := s.opSetMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username"), r.FormValue("role")); err != nil {
247 s.redirect(w, r, back, "", s.commitProblem(r, err))
248 return
249 }
250 s.redirect(w, r, back, s.tr(r, "flash.memberSaved"), "")
251}
252
253func (s *Server) memberRemove(w http.ResponseWriter, r *http.Request, kind string) {
254 scopeID, back, ok := s.adminScope(w, r, kind)
255 if !ok || !s.csrfOK(w, r) {
256 return
257 }
258 if err := s.opRemoveMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username")); err != nil {
259 s.redirect(w, r, back, "", s.trErr(r, err))
260 return
261 }
262 s.redirect(w, r, back, s.tr(r, "flash.memberRemoved"), "")
263}
264
265func (s *Server) adminScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) {
266 if kind == "group" {
267 g, role, ok := s.guardGroup(w, r, access.RoleMaintainer)
268 if !ok {
269 return 0, "", false
270 }
271 _ = role
272 return g.ID, "/groups/" + g.Path + "?tab=members", true
273 }
274 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
275 if !ok {
276 return 0, "", false
277 }
278 return repo.ID, repoURL(repo) + "/-/settings?tab=members", true
279}
280
281func (s *Server) addProtected(w http.ResponseWriter, r *http.Request) {
282 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
283 if !ok || !s.csrfOK(w, r) {
284 return
285 }
286 if err := s.opProtect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false); err != nil {
287 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "", s.trErr(r, err))
288 return
289 }
290 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.branchOn"), "")
291}
292
293func (s *Server) removeProtected(w http.ResponseWriter, r *http.Request) {
294 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
295 if !ok || !s.csrfOK(w, r) {
296 return
297 }
298 _ = s.opUnprotect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false)
299 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.patternOff"), "")
300}
301
302func (s *Server) repoSecret(w http.ResponseWriter, r *http.Request) {
303 s.secretPost(w, r, "repo")
304}
305func (s *Server) repoSecretDelete(w http.ResponseWriter, r *http.Request) {
306 s.secretDelete(w, r, "repo")
307}
308func (s *Server) groupSecret(w http.ResponseWriter, r *http.Request) {
309 s.secretPost(w, r, "group")
310}
311func (s *Server) groupSecretDelete(w http.ResponseWriter, r *http.Request) {
312 s.secretDelete(w, r, "group")
313}
314
315// secretScope laat alleen een maintainer secrets bekijken of bewerken, ook protected.
316func (s *Server) secretScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) {
317 if kind == "group" {
318 g, role, ok := s.guardGroup(w, r, access.RoleReadonly)
319 if !ok {
320 return 0, "", false
321 }
322 if !role.CanManageSecrets() {
323 http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
324 return 0, "", false
325 }
326 return g.ID, "/groups/" + g.Path + "?tab=settings#secrets", true
327 }
328 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
329 if !ok {
330 return 0, "", false
331 }
332 if !role.CanManageSecrets() {
333 http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
334 return 0, "", false
335 }
336 return repo.ID, repoURL(repo) + "/-/settings?tab=secrets", true
337}
338
339func (s *Server) secretPost(w http.ResponseWriter, r *http.Request, kind string) {
340 scopeID, back, ok := s.secretScope(w, r, kind)
341 if !ok || !s.csrfOK(w, r) {
342 return
343 }
344 name := strings.TrimSpace(r.FormValue("name"))
345 value := r.FormValue("value")
346 protected := r.FormValue("protected") == "1"
347 flash := "flash.secretSaved"
348 var err error
349 switch r.FormValue("mode") {
350 case "update":
351 err = s.Store.UpdateSecret(r.Context(), kind, scopeID, name, value, protected)
352 case "replace":
353 err = s.Store.ReplaceSecret(r.Context(), kind, scopeID, name, value, protected)
354 flash = "flash.secretReplaced"
355 default:
356 err = s.Store.CreateSecret(r.Context(), kind, scopeID, name, value, protected, r.FormValue("invisible") == "1")
357 }
358 if err != nil {
359 s.redirect(w, r, back, "", s.trErr(r, err))
360 return
361 }
362 _ = s.Store.SetSecretExpand(r.Context(), kind, scopeID, name, r.FormValue("expand") == "1")
363 s.redirect(w, r, back, s.tr(r, flash), "")
364}
365
366func (s *Server) repoSecretReveal(w http.ResponseWriter, r *http.Request) {
367 s.secretReveal(w, r, "repo")
368}
369
370func (s *Server) groupSecretReveal(w http.ResponseWriter, r *http.Request) {
371 s.secretReveal(w, r, "group")
372}
373
374func (s *Server) secretReveal(w http.ResponseWriter, r *http.Request, kind string) {
375 scopeID, _, ok := s.secretScope(w, r, kind)
376 if !ok || !s.csrfOK(w, r) {
377 return
378 }
379 value, err := s.Store.RevealSecret(r.Context(), kind, scopeID, strings.TrimSpace(r.FormValue("name")))
380 w.Header().Set("Content-Type", "application/json")
381 if err != nil {
382 s.writeSecretJSONErr(w, r, err)
383 return
384 }
385 _ = json.NewEncoder(w).Encode(map[string]string{"value": value})
386}
387
388func (s *Server) writeSecretJSONErr(w http.ResponseWriter, r *http.Request, err error) {
389 w.Header().Set("Content-Type", "application/json")
390 w.WriteHeader(secretStatus(err))
391 _ = json.NewEncoder(w).Encode(map[string]string{"error": s.trErr(r, err)})
392}
393
394func secretStatus(err error) int {
395 if store.Missing(err) {
396 return http.StatusNotFound
397 }
398 var ie i18n.Error
399 if errors.As(err, &ie) {
400 switch ie.Key {
401 case "err.secretHidden":
402 return http.StatusForbidden
403 case "err.secretExists", "err.secretVisible":
404 return http.StatusConflict
405 }
406 }
407 return http.StatusBadRequest
408}
409
410func (s *Server) secretDelete(w http.ResponseWriter, r *http.Request, kind string) {
411 scopeID, back, ok := s.secretScope(w, r, kind)
412 if !ok || !s.csrfOK(w, r) {
413 return
414 }
415 _ = s.Store.DeleteSecret(r.Context(), kind, scopeID, r.FormValue("name"))
416 s.redirect(w, r, back, s.tr(r, "flash.secretRemoved"), "")
417}
418
419func (s *Server) repoWebhook(w http.ResponseWriter, r *http.Request) { s.webhookPost(w, r, "repo") }
420func (s *Server) repoWebhookDelete(w http.ResponseWriter, r *http.Request) {
421 s.webhookDelete(w, r, "repo")
422}
423func (s *Server) groupWebhook(w http.ResponseWriter, r *http.Request) {
424 s.webhookPost(w, r, "group")
425}
426func (s *Server) groupWebhookDelete(w http.ResponseWriter, r *http.Request) {
427 s.webhookDelete(w, r, "group")
428}
429
430func (s *Server) webhookPost(w http.ResponseWriter, r *http.Request, kind string) {
431 scopeID, back, ok := s.adminScope(w, r, kind)
432 if !ok || !s.csrfOK(w, r) {
433 return
434 }
435 back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")
436 if kind == "group" {
437 back += "#webhooks"
438 }
439 var events []string
440 for _, e := range webhook.AllEvents() {
441 if r.FormValue("event_"+e) == "1" {
442 events = append(events, e)
443 }
444 }
445 id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
446 _, err := s.saveWebhookRecord(r.Context(), kind, scopeID, id, strings.TrimSpace(r.FormValue("name")), r.FormValue("preset"), r.FormValue("branch_filter"), events, webhook.Input{
447 URL: r.FormValue("url"), Username: r.FormValue("username"), Avatar: r.FormValue("avatar"),
448 Icon: r.FormValue("icon"), Alias: r.FormValue("alias"), Token: r.FormValue("token"),
449 Chat: r.FormValue("chat"), Server: r.FormValue("server"), Topic: r.FormValue("topic"),
450 Homeserver: r.FormValue("homeserver"), Room: r.FormValue("room"),
451 Method: r.FormValue("method"), ContentType: r.FormValue("content_type"),
452 Headers: r.FormValue("headers"), Body: r.FormValue("body"),
453 })
454 if err != nil {
455 s.redirect(w, r, back, "", s.trErr(r, err))
456 return
457 }
458 s.redirect(w, r, back, s.tr(r, "flash.webhookSaved"), "")
459}
460
461func (s *Server) createWebhookRecord(ctx context.Context, kind string, scopeID int64, name, preset, filter string, events []string, in webhook.Input) (int64, error) {
462 return s.saveWebhookRecord(ctx, kind, scopeID, 0, name, preset, filter, events, in)
463}
464
465func (s *Server) saveWebhookRecord(ctx context.Context, kind string, scopeID, id int64, name, preset, filter string, events []string, in webhook.Input) (int64, error) {
466 if !webhook.KnownPreset(preset) {
467 return 0, i18n.E("err.preset")
468 }
469 filter = strings.TrimSpace(filter)
470 if _, err := webhook.MatchBranch(filter, "main"); err != nil {
471 return 0, err
472 }
473 if len(events) == 0 {
474 return 0, i18n.E("err.pickEvent")
475 }
476 spec, err := webhook.Prepare(preset, in)
477 if err != nil {
478 return 0, err
479 }
480 raw, err := json.Marshal(in)
481 if err != nil {
482 return 0, err
483 }
484 rec := store.Webhook{
485 ID: id, ScopeKind: kind, ScopeID: scopeID, Name: name,
486 Preset: preset, URLTemplate: spec.URL, Headers: spec.Headers,
487 BodyTemplate: spec.Body, Events: events, BranchFilter: filter, Method: spec.Method,
488 Fields: string(raw),
489 }
490 if id > 0 {
491 if err := s.Store.UpdateWebhook(ctx, rec); err != nil {
492 return 0, err
493 }
494 return id, nil
495 }
496 return s.Store.CreateWebhook(ctx, rec)
497}
498
499func (s *Server) webhookDelete(w http.ResponseWriter, r *http.Request, kind string) {
500 scopeID, back, ok := s.adminScope(w, r, kind)
501 if !ok || !s.csrfOK(w, r) {
502 return
503 }
504 back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")
505 id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
506 _ = s.opDeleteWebhook(r.Context(), s.who(r).User, kind, scopeID, id)
507 s.redirect(w, r, back, s.tr(r, "flash.webhookRemoved"), "")
508}
509
510func (s *Server) deleteRepo(w http.ResponseWriter, r *http.Request) {
511 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
512 if !ok || !s.csrfOK(w, r) {
513 return
514 }
515 u := s.who(r).User
516 if err := s.opDeleteRepo(r.Context(), u, repo, r.FormValue("confirm"), false); err != nil {
517 s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))
518 return
519 }
520 s.redirect(w, r, "/", s.tr(r, "flash.repoDeleted"), "")
521}
522
523func (s *Server) deleteGroup(w http.ResponseWriter, r *http.Request) {
524 g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
525 if !ok || !s.csrfOK(w, r) {
526 return
527 }
528 if err := s.opDeleteGroup(r.Context(), s.who(r).User, g, r.FormValue("confirm")); err != nil {
529 s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.commitProblem(r, err))
530 return
531 }
532 s.redirect(w, r, "/", s.tr(r, "flash.groupDeleted"), "")
533}
534
535func (s *Server) guardGroup(w http.ResponseWriter, r *http.Request, min access.Role) (store.Group, access.Role, bool) {
536 g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path"))
537 if err != nil {
538 http.NotFound(w, r)
539 return store.Group{}, "", false
540 }
541 p := s.who(r)
542 var role access.Role
543 if p.OK {
544 role, err = s.Store.GroupRole(r.Context(), g.ID, p.User.ID)
545 if err != nil {
546 http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
547 return store.Group{}, "", false
548 }
549 }
550 if isCrawler(r) {
551 p = principal{}
552 role = access.RoleNone
553 }
554 if min == access.RoleReadonly {
555 if role.CanRead() || g.Visibility == "public" {
556 return g, role, true
557 }
558 if isCrawler(r) {
559 s.writeLockedCard(w, r)
560 } else if p.OK {
561 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
562 } else {
563 http.NotFound(w, r)
564 }
565 return store.Group{}, "", false
566 }
567 if !p.OK {
568 http.Redirect(w, r, "/login", http.StatusFound)
569 return store.Group{}, "", false
570 }
571 if !role.AtLeast(min) {
572 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
573 return store.Group{}, "", false
574 }
575 return g, role, true
576}
577
578func (s *Server) groupPage(w http.ResponseWriter, r *http.Request) {
579 g, role, ok := s.guardGroup(w, r, access.RoleReadonly)
580 if !ok {
581 return
582 }
583 v := s.view(w, r, g.Name)
584 v.Wide = true
585 v.Group = &g
586 v.Role = role
587 v.CanAdmin = role.CanManageSettings()
588 tab := r.URL.Query().Get("tab")
589 switch tab {
590 case "members":
591 if !role.CanRead() {
592 tab = ""
593 }
594 case "settings":
595 if !role.CanManageSettings() {
596 tab = ""
597 }
598 default:
599 tab = ""
600 }
601 v.Tab = tab
602 all, _ := s.Store.ReposByGroup(r.Context(), g.ID) // laatste push eerst
603 uid := int64(0)
604 if v.User != nil {
605 uid = v.User.ID
606 }
607 var repos []store.Repo
608 for _, repo := range all {
609 if repo.Visibility == "public" {
610 repos = append(repos, repo)
611 continue
612 }
613 if uid == 0 {
614 continue
615 }
616 er, err := s.Store.EffectiveRole(r.Context(), uid, repo.ID)
617 if err == nil && er.CanRead() {
618 repos = append(repos, repo)
619 }
620 }
621 q := strings.TrimSpace(r.URL.Query().Get("q"))
622 dir := r.URL.Query().Get("dir")
623 if dir != "desc" {
624 dir = "asc"
625 }
626 by := r.URL.Query().Get("sort")
627 if by != "name" {
628 by = "pushed"
629 }
630 v.Query, v.SortDir, v.SortBy = q, dir, by
631 if dir == "desc" {
632 v.FlipDir = "asc"
633 } else {
634 v.FlipDir = "desc"
635 }
636 if lq := strings.ToLower(q); lq != "" {
637 var filtered []store.Repo
638 for _, repo := range repos {
639 if strings.Contains(strings.ToLower(repo.Name), lq) {
640 filtered = append(filtered, repo)
641 }
642 }
643 repos = filtered
644 }
645 if by == "pushed" {
646 store.SortReposByPush(repos)
647 } else {
648 sort.Slice(repos, func(i, j int) bool {
649 a, b := strings.ToLower(repos[i].Name), strings.ToLower(repos[j].Name)
650 if dir == "desc" {
651 return a > b
652 }
653 return a < b
654 })
655 }
656 ids := make([]int64, len(repos))
657 for i, repo := range repos {
658 ids[i] = repo.ID
659 }
660 counts, mine, _ := s.Store.StarInfo(r.Context(), uid, ids)
661 lang := s.langOf(r)
662 for _, repo := range repos {
663 v.Cards = append(v.Cards, RepoCard{
664 Repo: repo, Stars: counts[repo.ID], Starred: mine[repo.ID],
665 When: i18n.FormatDate(lang, repo.CreatedAt), Pushed: pushedLabel(lang, repo),
666 })
667 }
668 v.Repos = repos
669 v.GroupRepoCount = len(all)
670 v.Heat = s.heatmap(r.Context(), 0, s.visibleIDs(r.Context(), uid, repos), lang)
671 if tab == "members" && role.CanRead() {
672 v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID)
673 }
674 if tab == "settings" && role.CanManageSettings() {
675 v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID)
676 v.Secrets, _ = s.Store.ListSecrets(r.Context(), "group", g.ID)
677 v.HookSecrets = s.groupSecretChoices(r, g)
678 v.Hooks = s.hookViews(r, "group", g.ID)
679 v.HookTargets = s.hookTargets(r)
680 s.fillHookEdit(r, &v, "group", g.ID)
681 s.fillGroupApproval(r, &v, g)
682 s.fillGroupRunners(w, r, &v, g)
683 if v.User != nil && v.User.ID == g.OwnerID {
684 v.IsOwner = true
685 v.Candidates = groupCandidates(v.Members, g.OwnerID)
686 }
687 }
688 s.render(w, "group", v)
689}
690
691func settingsTab(tab string) string {
692 switch tab {
693 case "leden", "members":
694 return "members"
695 case "geheimen", "secrets":
696 return "secrets"
697 case "branches":
698 return "branches"
699 case "tags":
700 return "tags"
701 case "webhooks":
702 return "webhooks"
703 case "approvals":
704 return "approvals"
705 default:
706 return "general"
707 }
708}
709
710func scopeTab(kind, repoTab string) string {
711 if kind == "group" {
712 if repoTab == "members" {
713 return "?tab=members"
714 }
715 return "?tab=settings"
716 }
717 return "?tab=" + repoTab
718}
719
720// hookEventChoices zet de fijnere events klaar voor het formulier.
721func hookEventChoices(selected []string) []HookEventChoice {
722 on := map[string]bool{}
723 for _, e := range selected {
724 on[e] = true
725 }
726 var out []HookEventChoice
727 for _, e := range webhook.SpecificEvents() {
728 out = append(out, HookEventChoice{Name: e, Key: "set.ev." + e, On: on[e]})
729 }
730 return out
731}
732
733// pushedLabel is de korte tekst bij de laatste push van een repo.
734func pushedLabel(lang i18n.Lang, repo store.Repo) string {
735 if repo.PushedAt.IsZero() {
736 return i18n.T(lang, "repo.neverPushed")
737 }
738 return i18n.T(lang, "repo.pushedAt", i18n.FormatDate(lang, repo.PushedAt))
739}