BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

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