BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

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