BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

feat: nieuw-formulier, groepsoverzicht, logo's en talen
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed d1203d3b History
settings_handlers.go 12.5 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,
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 preset != webhook.PresetDiscord && preset != webhook.PresetGrok && preset != webhook.PresetGeneric {
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 headers := map[string]string{}
229 for _, line := range strings.Split(r.FormValue("headers"), "\n") {
230 line = strings.TrimSpace(line)
231 if line == "" {
232 continue
233 }
234 k, v, ok := strings.Cut(line, ":")
235 if !ok || strings.TrimSpace(k) == "" {
236 s.redirect(w, r, back, "", s.tr(r, "err.header"))
237 return
238 }
239 headers[strings.TrimSpace(k)] = strings.TrimSpace(v)
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: strings.TrimSpace(r.FormValue("url")),
244 Headers: headers, BodyTemplate: r.FormValue("body"), Events: events, BranchFilter: filter,
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 }
408 s.render(w, "group", v)
409}
410
411func settingsTab(tab string) string {
412 switch tab {
413 case "leden", "members":
414 return "members"
415 case "geheimen", "secrets":
416 return "secrets"
417 case "branches":
418 return "branches"
419 case "webhooks":
420 return "webhooks"
421 default:
422 return "general"
423 }
424}
425
426func scopeTab(kind, repoTab string) string {
427 if kind == "group" {
428 if repoTab == "members" {
429 return "?tab=members"
430 }
431 return "?tab=settings"
432 }
433 return "?tab=" + repoTab
434}