BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

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