BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

feat: groepseigenaar blijft beheerder en kan eigenaarschap overdragen
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
63e5d53c History
settings_handlers.go 12.8 KiB Download Raw
1package server
2
3import (
4 "net/http"
5 "os"
6 "sort"
7 "strconv"
8 "strings"
9
10 "gitlab.com/Timfa/bluegit/internal/access"
11 "gitlab.com/Timfa/bluegit/internal/gitrepo"
12 "gitlab.com/Timfa/bluegit/internal/i18n"
13 "gitlab.com/Timfa/bluegit/internal/store"
14 "gitlab.com/Timfa/bluegit/internal/webhook"
15)
16
17func (s *Server) settings(w http.ResponseWriter, r *http.Request) {
18 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
19 if !ok {
20 return
21 }
22 v := s.repoView(w, r, repo, role, "title.settings")
23 v.Tab = settingsTab(r.URL.Query().Get("tab"))
24 if role.CanManageSettings() {
25 v.Members, _ = s.Store.ListMembers(r.Context(), "repo", repo.ID)
26 if repo.OwnerKind == "user" {
27 owner, err := s.Store.UserByID(r.Context(), repo.OwnerID)
28 if err == nil {
29 v.Members = append([]store.Member{{UserID: owner.ID, Username: owner.Username, Role: access.RoleMaintainer}}, v.Members...)
30 }
31 }
32 v.Secrets, _ = s.Store.ListSecrets(r.Context(), "repo", repo.ID)
33 v.Patterns, _ = s.Store.ProtectedPatterns(r.Context(), repo.ID)
34 v.Hooks = s.hookViews(r, "repo", repo.ID)
35 s.fillApproval(r, &v, repo)
36 }
37 s.render(w, "settings", v)
38}
39
40func (s *Server) hookViews(r *http.Request, kind string, id int64) []HookView {
41 hooks, err := s.Store.ListWebhooks(r.Context(), kind, id)
42 if err != nil {
43 return nil
44 }
45 var out []HookView
46 for _, h := range hooks {
47 d, _ := s.Store.RecentDeliveries(r.Context(), h.ID)
48 out = append(out, HookView{
49 ID: h.ID, Name: h.Name, Preset: h.Preset, URL: h.URLTemplate, Method: h.Method,
50 Filter: h.BranchFilter, Events: strings.Join(h.Events, ", "), Deliveries: d,
51 })
52 }
53 return out
54}
55
56func (s *Server) updateRepo(w http.ResponseWriter, r *http.Request) {
57 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
58 if !ok || !s.csrfOK(w, r) {
59 return
60 }
61 vis := r.FormValue("visibility")
62 if vis != "public" {
63 vis = "private"
64 }
65 if err := s.Store.UpdateRepo(r.Context(), repo.ID, r.FormValue("description"), vis); err != nil {
66 s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.trErr(r, err))
67 return
68 }
69 s.redirect(w, r, repoURL(repo)+"/-/settings", s.tr(r, "flash.saved"), "")
70}
71
72func (s *Server) repoMember(w http.ResponseWriter, r *http.Request) {
73 s.memberPost(w, r, "repo")
74}
75
76func (s *Server) repoMemberRemove(w http.ResponseWriter, r *http.Request) {
77 s.memberRemove(w, r, "repo")
78}
79
80func (s *Server) groupMember(w http.ResponseWriter, r *http.Request) {
81 s.memberPost(w, r, "group")
82}
83
84func (s *Server) groupMemberRemove(w http.ResponseWriter, r *http.Request) {
85 s.memberRemove(w, r, "group")
86}
87
88func (s *Server) memberPost(w http.ResponseWriter, r *http.Request, kind string) {
89 scopeID, back, ok := s.adminScope(w, r, kind)
90 if !ok || !s.csrfOK(w, r) {
91 return
92 }
93 role, err := access.ParseRole(r.FormValue("role"))
94 if err != nil {
95 s.redirect(w, r, back, "", s.trErr(r, err))
96 return
97 }
98 if err := s.Store.SetMember(r.Context(), kind, scopeID, r.FormValue("username"), role); err != nil {
99 s.redirect(w, r, back, "", s.trErr(r, err))
100 return
101 }
102 s.redirect(w, r, back, s.tr(r, "flash.memberSaved"), "")
103}
104
105func (s *Server) memberRemove(w http.ResponseWriter, r *http.Request, kind string) {
106 scopeID, back, ok := s.adminScope(w, r, kind)
107 if !ok || !s.csrfOK(w, r) {
108 return
109 }
110 if err := s.Store.RemoveMember(r.Context(), kind, scopeID, r.FormValue("username")); err != nil {
111 s.redirect(w, r, back, "", s.trErr(r, err))
112 return
113 }
114 s.redirect(w, r, back, s.tr(r, "flash.memberRemoved"), "")
115}
116
117func (s *Server) adminScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) {
118 if kind == "group" {
119 g, role, ok := s.guardGroup(w, r, access.RoleMaintainer)
120 if !ok {
121 return 0, "", false
122 }
123 _ = role
124 return g.ID, "/groups/" + g.Path + "?tab=members", true
125 }
126 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
127 if !ok {
128 return 0, "", false
129 }
130 return repo.ID, repoURL(repo) + "/-/settings?tab=members", true
131}
132
133func (s *Server) addProtected(w http.ResponseWriter, r *http.Request) {
134 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
135 if !ok || !s.csrfOK(w, r) {
136 return
137 }
138 if err := s.Store.AddProtected(r.Context(), repo.ID, r.FormValue("pattern")); err != nil {
139 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "", s.trErr(r, err))
140 return
141 }
142 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.branchOn"), "")
143}
144
145func (s *Server) removeProtected(w http.ResponseWriter, r *http.Request) {
146 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
147 if !ok || !s.csrfOK(w, r) {
148 return
149 }
150 _ = s.Store.RemoveProtected(r.Context(), repo.ID, r.FormValue("pattern"))
151 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.patternOff"), "")
152}
153
154func (s *Server) repoSecret(w http.ResponseWriter, r *http.Request) {
155 s.secretPost(w, r, "repo")
156}
157func (s *Server) repoSecretDelete(w http.ResponseWriter, r *http.Request) {
158 s.secretDelete(w, r, "repo")
159}
160func (s *Server) groupSecret(w http.ResponseWriter, r *http.Request) {
161 s.secretPost(w, r, "group")
162}
163func (s *Server) groupSecretDelete(w http.ResponseWriter, r *http.Request) {
164 s.secretDelete(w, r, "group")
165}
166
167func (s *Server) secretPost(w http.ResponseWriter, r *http.Request, kind string) {
168 scopeID, back, ok := s.adminScope(w, r, kind)
169 if !ok || !s.csrfOK(w, r) {
170 return
171 }
172 back = strings.Split(back, "?")[0]
173 back += scopeTab(kind, "secrets")
174 if err := s.Store.PutSecret(r.Context(), kind, scopeID, strings.TrimSpace(r.FormValue("name")), r.FormValue("value"), r.FormValue("protected") == "1"); err != nil {
175 s.redirect(w, r, back, "", s.trErr(r, err))
176 return
177 }
178 s.redirect(w, r, back, s.tr(r, "flash.secretSaved"), "")
179}
180
181func (s *Server) secretDelete(w http.ResponseWriter, r *http.Request, kind string) {
182 scopeID, back, ok := s.adminScope(w, r, kind)
183 if !ok || !s.csrfOK(w, r) {
184 return
185 }
186 back = strings.Split(back, "?")[0]
187 back += scopeTab(kind, "secrets")
188 _ = s.Store.DeleteSecret(r.Context(), kind, scopeID, r.FormValue("name"))
189 s.redirect(w, r, back, s.tr(r, "flash.secretRemoved"), "")
190}
191
192func (s *Server) repoWebhook(w http.ResponseWriter, r *http.Request) { s.webhookPost(w, r, "repo") }
193func (s *Server) repoWebhookDelete(w http.ResponseWriter, r *http.Request) {
194 s.webhookDelete(w, r, "repo")
195}
196func (s *Server) groupWebhook(w http.ResponseWriter, r *http.Request) {
197 s.webhookPost(w, r, "group")
198}
199func (s *Server) groupWebhookDelete(w http.ResponseWriter, r *http.Request) {
200 s.webhookDelete(w, r, "group")
201}
202
203func (s *Server) webhookPost(w http.ResponseWriter, r *http.Request, kind string) {
204 scopeID, back, ok := s.adminScope(w, r, kind)
205 if !ok || !s.csrfOK(w, r) {
206 return
207 }
208 back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")
209 preset := r.FormValue("preset")
210 if !webhook.KnownPreset(preset) {
211 s.redirect(w, r, back, "", s.tr(r, "err.preset"))
212 return
213 }
214 filter := strings.TrimSpace(r.FormValue("branch_filter"))
215 if _, err := webhook.MatchBranch(filter, "main"); err != nil {
216 s.redirect(w, r, back, "", s.trErr(r, err))
217 return
218 }
219 var events []string
220 for _, e := range webhook.AllEvents() {
221 if r.FormValue("event_"+e) == "1" {
222 events = append(events, e)
223 }
224 }
225 if len(events) == 0 {
226 s.redirect(w, r, back, "", s.tr(r, "err.pickEvent"))
227 return
228 }
229 spec, err := webhook.Prepare(preset, webhook.Input{
230 URL: r.FormValue("url"), Username: r.FormValue("username"), Avatar: r.FormValue("avatar"),
231 Icon: r.FormValue("icon"), Alias: r.FormValue("alias"), Token: r.FormValue("token"),
232 Chat: r.FormValue("chat"), Server: r.FormValue("server"), Topic: r.FormValue("topic"),
233 Homeserver: r.FormValue("homeserver"), Room: r.FormValue("room"),
234 Method: r.FormValue("method"), ContentType: r.FormValue("content_type"),
235 Headers: r.FormValue("headers"), Body: r.FormValue("body"),
236 })
237 if err != nil {
238 s.redirect(w, r, back, "", s.trErr(r, err))
239 return
240 }
241 _, err = s.Store.CreateWebhook(r.Context(), store.Webhook{
242 ScopeKind: kind, ScopeID: scopeID, Name: strings.TrimSpace(r.FormValue("name")),
243 Preset: preset, URLTemplate: spec.URL, Headers: spec.Headers,
244 BodyTemplate: spec.Body, Events: events, BranchFilter: filter, Method: spec.Method,
245 })
246 if err != nil {
247 s.redirect(w, r, back, "", s.trErr(r, err))
248 return
249 }
250 s.redirect(w, r, back, s.tr(r, "flash.webhookSaved"), "")
251}
252
253func (s *Server) webhookDelete(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 back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")
259 id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
260 _ = s.Store.DeleteWebhook(r.Context(), kind, scopeID, id)
261 s.redirect(w, r, back, s.tr(r, "flash.webhookRemoved"), "")
262}
263
264func (s *Server) deleteRepo(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 r.FormValue("confirm") != repo.Name {
270 s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.tr(r, "err.confirmDelete"))
271 return
272 }
273 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
274 _ = s.Store.DeleteRepo(r.Context(), repo.ID)
275 _ = os.RemoveAll(dir)
276 s.redirect(w, r, "/", s.tr(r, "flash.repoDeleted"), "")
277}
278
279func (s *Server) guardGroup(w http.ResponseWriter, r *http.Request, min access.Role) (store.Group, access.Role, bool) {
280 g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path"))
281 if err != nil {
282 http.NotFound(w, r)
283 return store.Group{}, "", false
284 }
285 p := s.who(r)
286 var role access.Role
287 if p.OK {
288 role, err = s.Store.GroupRole(r.Context(), g.ID, p.User.ID)
289 if err != nil {
290 http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
291 return store.Group{}, "", false
292 }
293 }
294 if min == access.RoleReadonly {
295 if role.CanRead() || g.Visibility == "public" {
296 return g, role, true
297 }
298 if p.OK {
299 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
300 } else {
301 http.NotFound(w, r)
302 }
303 return store.Group{}, "", false
304 }
305 if !p.OK {
306 http.Redirect(w, r, "/login", http.StatusFound)
307 return store.Group{}, "", false
308 }
309 if !role.AtLeast(min) {
310 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
311 return store.Group{}, "", false
312 }
313 return g, role, true
314}
315
316func (s *Server) groupPage(w http.ResponseWriter, r *http.Request) {
317 g, role, ok := s.guardGroup(w, r, access.RoleReadonly)
318 if !ok {
319 return
320 }
321 v := s.view(w, r, g.Name)
322 v.Wide = true
323 v.Group = &g
324 v.Role = role
325 v.CanAdmin = role.CanManageSettings()
326 tab := r.URL.Query().Get("tab")
327 switch tab {
328 case "members":
329 if !role.CanRead() {
330 tab = ""
331 }
332 case "settings":
333 if !role.CanManageSettings() {
334 tab = ""
335 }
336 default:
337 tab = ""
338 }
339 v.Tab = tab
340 all, _ := s.Store.ReposByGroup(r.Context(), g.ID)
341 uid := int64(0)
342 if v.User != nil {
343 uid = v.User.ID
344 }
345 var repos []store.Repo
346 for _, repo := range all {
347 if repo.Visibility == "public" {
348 repos = append(repos, repo)
349 continue
350 }
351 if uid == 0 {
352 continue
353 }
354 er, err := s.Store.EffectiveRole(r.Context(), uid, repo.ID)
355 if err == nil && er.CanRead() {
356 repos = append(repos, repo)
357 }
358 }
359 q := strings.TrimSpace(r.URL.Query().Get("q"))
360 dir := r.URL.Query().Get("dir")
361 if dir != "desc" {
362 dir = "asc"
363 }
364 v.Query, v.SortDir = q, dir
365 if dir == "desc" {
366 v.FlipDir = "asc"
367 } else {
368 v.FlipDir = "desc"
369 }
370 if lq := strings.ToLower(q); lq != "" {
371 var filtered []store.Repo
372 for _, repo := range repos {
373 if strings.Contains(strings.ToLower(repo.Name), lq) {
374 filtered = append(filtered, repo)
375 }
376 }
377 repos = filtered
378 }
379 sort.Slice(repos, func(i, j int) bool {
380 a, b := strings.ToLower(repos[i].Name), strings.ToLower(repos[j].Name)
381 if dir == "desc" {
382 return a > b
383 }
384 return a < b
385 })
386 ids := make([]int64, len(repos))
387 for i, repo := range repos {
388 ids[i] = repo.ID
389 }
390 counts, mine, _ := s.Store.StarInfo(r.Context(), uid, ids)
391 lang := s.langOf(r)
392 for _, repo := range repos {
393 v.Cards = append(v.Cards, RepoCard{
394 Repo: repo, Stars: counts[repo.ID], Starred: mine[repo.ID],
395 When: i18n.FormatDate(lang, repo.CreatedAt),
396 })
397 }
398 v.Repos = repos
399 v.Heat = s.heatmap(r.Context(), 0, s.visibleIDs(r.Context(), uid, repos), lang)
400 if tab == "members" && role.CanRead() {
401 v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID)
402 }
403 if tab == "settings" && role.CanManageSettings() {
404 v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID)
405 v.Secrets, _ = s.Store.ListSecrets(r.Context(), "group", g.ID)
406 v.Hooks = s.hookViews(r, "group", g.ID)
407 s.fillGroupApproval(r, &v, g)
408 if v.User != nil && v.User.ID == g.OwnerID {
409 v.IsOwner = true
410 v.Candidates = groupCandidates(v.Members, g.OwnerID)
411 }
412 }
413 s.render(w, "group", v)
414}
415
416func settingsTab(tab string) string {
417 switch tab {
418 case "leden", "members":
419 return "members"
420 case "geheimen", "secrets":
421 return "secrets"
422 case "branches":
423 return "branches"
424 case "webhooks":
425 return "webhooks"
426 case "approvals":
427 return "approvals"
428 default:
429 return "general"
430 }
431}
432
433func scopeTab(kind, repoTab string) string {
434 if kind == "group" {
435 if repoTab == "members" {
436 return "?tab=members"
437 }
438 return "?tab=settings"
439 }
440 return "?tab=" + repoTab
441}