BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

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