BlueGit

timfa bluegit

Files

bluegit / internal / server / settings_handlers.go

settings_handlers.go

feat: eerste basis van BlueGit
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
151aa352 History
settings_handlers.go 10.1 KiB Download Raw
1package server
2
3import (
4 "net/http"
5 "os"
6 "strconv"
7 "strings"
8
9 "gitlab.com/Timfa/bluegit/internal/access"
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/store"
12 "gitlab.com/Timfa/bluegit/internal/webhook"
13)
14
15func (s *Server) settings(w http.ResponseWriter, r *http.Request) {
16 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
17 if !ok {
18 return
19 }
20 v := s.repoView(w, r, repo, role, "Instellingen")
21 v.Tab = r.URL.Query().Get("tab")
22 if v.Tab == "" {
23 v.Tab = "algemeen"
24 }
25 if role.CanManageSettings() {
26 v.Members, _ = s.Store.ListMembers(r.Context(), "repo", repo.ID)
27 if repo.OwnerKind == "user" {
28 owner, err := s.Store.UserByID(r.Context(), repo.OwnerID)
29 if err == nil {
30 v.Members = append([]store.Member{{UserID: owner.ID, Username: owner.Username, Role: access.RoleMaintainer}}, v.Members...)
31 }
32 }
33 v.Secrets, _ = s.Store.ListSecrets(r.Context(), "repo", repo.ID)
34 v.Patterns, _ = s.Store.ProtectedPatterns(r.Context(), repo.ID)
35 v.Hooks = s.hookViews(r, "repo", repo.ID)
36 }
37 s.render(w, "settings", v)
38}
39
40func (s *Server) hookViews(r *http.Request, kind string, id int64) []HookView {
41 hooks, err := s.Store.ListWebhooks(r.Context(), kind, id)
42 if err != nil {
43 return nil
44 }
45 var out []HookView
46 for _, h := range hooks {
47 d, _ := s.Store.RecentDeliveries(r.Context(), h.ID)
48 out = append(out, HookView{
49 ID: h.ID, Name: h.Name, Preset: h.Preset, URL: h.URLTemplate,
50 Filter: h.BranchFilter, Events: strings.Join(h.Events, ", "), Deliveries: d,
51 })
52 }
53 return out
54}
55
56func (s *Server) updateRepo(w http.ResponseWriter, r *http.Request) {
57 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
58 if !ok || !s.csrfOK(w, r) {
59 return
60 }
61 vis := r.FormValue("visibility")
62 if vis != "public" {
63 vis = "private"
64 }
65 if err := s.Store.UpdateRepo(r.Context(), repo.ID, r.FormValue("description"), vis); err != nil {
66 s.redirect(w, r, repoURL(repo)+"/-/settings", "", err.Error())
67 return
68 }
69 s.redirect(w, r, repoURL(repo)+"/-/settings", "Opgeslagen", "")
70}
71
72func (s *Server) repoMember(w http.ResponseWriter, r *http.Request) {
73 s.memberPost(w, r, "repo")
74}
75
76func (s *Server) repoMemberRemove(w http.ResponseWriter, r *http.Request) {
77 s.memberRemove(w, r, "repo")
78}
79
80func (s *Server) groupMember(w http.ResponseWriter, r *http.Request) {
81 s.memberPost(w, r, "group")
82}
83
84func (s *Server) groupMemberRemove(w http.ResponseWriter, r *http.Request) {
85 s.memberRemove(w, r, "group")
86}
87
88func (s *Server) memberPost(w http.ResponseWriter, r *http.Request, kind string) {
89 scopeID, back, ok := s.adminScope(w, r, kind)
90 if !ok || !s.csrfOK(w, r) {
91 return
92 }
93 role, err := access.ParseRole(r.FormValue("role"))
94 if err != nil {
95 s.redirect(w, r, back, "", err.Error())
96 return
97 }
98 if err := s.Store.SetMember(r.Context(), kind, scopeID, r.FormValue("username"), role); err != nil {
99 s.redirect(w, r, back, "", err.Error())
100 return
101 }
102 s.redirect(w, r, back, "Lid opgeslagen", "")
103}
104
105func (s *Server) memberRemove(w http.ResponseWriter, r *http.Request, kind string) {
106 scopeID, back, ok := s.adminScope(w, r, kind)
107 if !ok || !s.csrfOK(w, r) {
108 return
109 }
110 if err := s.Store.RemoveMember(r.Context(), kind, scopeID, r.FormValue("username")); err != nil {
111 s.redirect(w, r, back, "", err.Error())
112 return
113 }
114 s.redirect(w, r, back, "Lid verwijderd", "")
115}
116
117func (s *Server) adminScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) {
118 if kind == "group" {
119 g, role, ok := s.guardGroup(w, r, access.RoleMaintainer)
120 if !ok {
121 return 0, "", false
122 }
123 _ = role
124 return g.ID, "/groups/" + g.Path, true
125 }
126 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
127 if !ok {
128 return 0, "", false
129 }
130 return repo.ID, repoURL(repo) + "/-/settings?tab=leden", true
131}
132
133func (s *Server) addProtected(w http.ResponseWriter, r *http.Request) {
134 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
135 if !ok || !s.csrfOK(w, r) {
136 return
137 }
138 if err := s.Store.AddProtected(r.Context(), repo.ID, r.FormValue("pattern")); err != nil {
139 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "", err.Error())
140 return
141 }
142 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "Branch beschermd", "")
143}
144
145func (s *Server) removeProtected(w http.ResponseWriter, r *http.Request) {
146 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
147 if !ok || !s.csrfOK(w, r) {
148 return
149 }
150 _ = s.Store.RemoveProtected(r.Context(), repo.ID, r.FormValue("pattern"))
151 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "Patroon verwijderd", "")
152}
153
154func (s *Server) repoSecret(w http.ResponseWriter, r *http.Request) {
155 s.secretPost(w, r, "repo")
156}
157func (s *Server) repoSecretDelete(w http.ResponseWriter, r *http.Request) {
158 s.secretDelete(w, r, "repo")
159}
160func (s *Server) groupSecret(w http.ResponseWriter, r *http.Request) {
161 s.secretPost(w, r, "group")
162}
163func (s *Server) groupSecretDelete(w http.ResponseWriter, r *http.Request) {
164 s.secretDelete(w, r, "group")
165}
166
167func (s *Server) secretPost(w http.ResponseWriter, r *http.Request, kind string) {
168 scopeID, back, ok := s.adminScope(w, r, kind)
169 if !ok || !s.csrfOK(w, r) {
170 return
171 }
172 back = strings.Split(back, "?")[0]
173 if kind == "repo" {
174 back += "?tab=geheimen"
175 }
176 if err := s.Store.PutSecret(r.Context(), kind, scopeID, strings.TrimSpace(r.FormValue("name")), r.FormValue("value"), r.FormValue("protected") == "1"); err != nil {
177 s.redirect(w, r, back, "", err.Error())
178 return
179 }
180 s.redirect(w, r, back, "Geheim opgeslagen", "")
181}
182
183func (s *Server) secretDelete(w http.ResponseWriter, r *http.Request, kind string) {
184 scopeID, back, ok := s.adminScope(w, r, kind)
185 if !ok || !s.csrfOK(w, r) {
186 return
187 }
188 back = strings.Split(back, "?")[0]
189 if kind == "repo" {
190 back += "?tab=geheimen"
191 }
192 _ = s.Store.DeleteSecret(r.Context(), kind, scopeID, r.FormValue("name"))
193 s.redirect(w, r, back, "Geheim verwijderd", "")
194}
195
196func (s *Server) repoWebhook(w http.ResponseWriter, r *http.Request) { s.webhookPost(w, r, "repo") }
197func (s *Server) repoWebhookDelete(w http.ResponseWriter, r *http.Request) {
198 s.webhookDelete(w, r, "repo")
199}
200func (s *Server) groupWebhook(w http.ResponseWriter, r *http.Request) {
201 s.webhookPost(w, r, "group")
202}
203func (s *Server) groupWebhookDelete(w http.ResponseWriter, r *http.Request) {
204 s.webhookDelete(w, r, "group")
205}
206
207func (s *Server) webhookPost(w http.ResponseWriter, r *http.Request, kind string) {
208 scopeID, back, ok := s.adminScope(w, r, kind)
209 if !ok || !s.csrfOK(w, r) {
210 return
211 }
212 if kind == "repo" {
213 back = strings.Split(back, "?")[0] + "?tab=webhooks"
214 }
215 preset := r.FormValue("preset")
216 if preset != webhook.PresetDiscord && preset != webhook.PresetGrok && preset != webhook.PresetGeneric {
217 s.redirect(w, r, back, "", "onbekende preset")
218 return
219 }
220 filter := strings.TrimSpace(r.FormValue("branch_filter"))
221 if _, err := webhook.MatchBranch(filter, "main"); err != nil {
222 s.redirect(w, r, back, "", err.Error())
223 return
224 }
225 var events []string
226 for _, e := range webhook.AllEvents() {
227 if r.FormValue("event_"+e) == "1" {
228 events = append(events, e)
229 }
230 }
231 if len(events) == 0 {
232 s.redirect(w, r, back, "", "kies minstens één gebeurtenis")
233 return
234 }
235 headers := map[string]string{}
236 for _, line := range strings.Split(r.FormValue("headers"), "\n") {
237 line = strings.TrimSpace(line)
238 if line == "" {
239 continue
240 }
241 k, v, ok := strings.Cut(line, ":")
242 if !ok || strings.TrimSpace(k) == "" {
243 s.redirect(w, r, back, "", "header moet 'Naam: waarde' zijn")
244 return
245 }
246 headers[strings.TrimSpace(k)] = strings.TrimSpace(v)
247 }
248 _, err := s.Store.CreateWebhook(r.Context(), store.Webhook{
249 ScopeKind: kind, ScopeID: scopeID, Name: strings.TrimSpace(r.FormValue("name")),
250 Preset: preset, URLTemplate: strings.TrimSpace(r.FormValue("url")),
251 Headers: headers, BodyTemplate: r.FormValue("body"), Events: events, BranchFilter: filter,
252 })
253 if err != nil {
254 s.redirect(w, r, back, "", err.Error())
255 return
256 }
257 s.redirect(w, r, back, "Webhook opgeslagen", "")
258}
259
260func (s *Server) webhookDelete(w http.ResponseWriter, r *http.Request, kind string) {
261 scopeID, back, ok := s.adminScope(w, r, kind)
262 if !ok || !s.csrfOK(w, r) {
263 return
264 }
265 if kind == "repo" {
266 back = strings.Split(back, "?")[0] + "?tab=webhooks"
267 }
268 id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
269 _ = s.Store.DeleteWebhook(r.Context(), kind, scopeID, id)
270 s.redirect(w, r, back, "Webhook verwijderd", "")
271}
272
273func (s *Server) deleteRepo(w http.ResponseWriter, r *http.Request) {
274 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
275 if !ok || !s.csrfOK(w, r) {
276 return
277 }
278 if r.FormValue("confirm") != repo.Name {
279 s.redirect(w, r, repoURL(repo)+"/-/settings", "", "typ de repositorynaam om te verwijderen")
280 return
281 }
282 dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
283 _ = s.Store.DeleteRepo(r.Context(), repo.ID)
284 _ = os.RemoveAll(dir)
285 s.redirect(w, r, "/", "Repository verwijderd", "")
286}
287
288func (s *Server) guardGroup(w http.ResponseWriter, r *http.Request, min access.Role) (store.Group, access.Role, bool) {
289 g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path"))
290 if err != nil {
291 http.NotFound(w, r)
292 return store.Group{}, "", false
293 }
294 p := s.who(r)
295 if !p.OK {
296 http.Redirect(w, r, "/login", http.StatusFound)
297 return store.Group{}, "", false
298 }
299 role, err := s.Store.GroupRole(r.Context(), g.ID, p.User.ID)
300 if err != nil {
301 http.Error(w, "rechten", http.StatusInternalServerError)
302 return store.Group{}, "", false
303 }
304 if !role.AtLeast(min) && min != access.RoleReadonly {
305 http.Error(w, "geen toegang", http.StatusForbidden)
306 return store.Group{}, "", false
307 }
308 if min == access.RoleReadonly && !role.CanRead() {
309 http.Error(w, "geen toegang", 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.Group = &g
322 v.Role = role
323 v.CanAdmin = role.CanManageSettings()
324 v.Repos, _ = s.Store.ReposByGroup(r.Context(), g.ID)
325 if role.CanManageSettings() {
326 v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID)
327 v.Secrets, _ = s.Store.ListSecrets(r.Context(), "group", g.ID)
328 v.Hooks = s.hookViews(r, "group", g.ID)
329 }
330 s.render(w, "group", v)
331}