BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

feat: activiteitsheatmap op dashboard, groep en repository
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed d5433bc7 History
repo_handlers.go 14.7 KiB Download Raw
1package server
2
3import (
4 "net/http"
5 "strconv"
6 "strings"
7
8 "gitlab.com/Timfa/bluegit/internal/access"
9 "gitlab.com/Timfa/bluegit/internal/gitrepo"
10 "gitlab.com/Timfa/bluegit/internal/names"
11 "gitlab.com/Timfa/bluegit/internal/store"
12)
13
14func (s *Server) guard(w http.ResponseWriter, r *http.Request, min access.Role) (store.User, store.Repo, access.Role, bool) {
15 owner := r.PathValue("owner")
16 name := strings.TrimSuffix(r.PathValue("repo"), ".git")
17 repo, err := s.Store.RepoByPath(r.Context(), owner, name)
18 if err != nil {
19 http.NotFound(w, r)
20 return store.User{}, store.Repo{}, "", false
21 }
22 p := s.who(r)
23 var role access.Role
24 if p.OK {
25 role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID)
26 if err != nil {
27 http.Error(w, "rechten", http.StatusInternalServerError)
28 return store.User{}, store.Repo{}, "", false
29 }
30 }
31 readable := role.CanRead() || repo.Visibility == "public"
32 if !readable {
33 if p.OK {
34 http.Error(w, "geen toegang", http.StatusForbidden)
35 } else {
36 http.NotFound(w, r)
37 }
38 return store.User{}, store.Repo{}, "", false
39 }
40 if min != access.RoleReadonly && !role.AtLeast(min) {
41 http.Error(w, "geen toegang", http.StatusForbidden)
42 return store.User{}, store.Repo{}, "", false
43 }
44 return p.User, repo, role, true
45}
46
47func (s *Server) repoView(w http.ResponseWriter, r *http.Request, repo store.Repo, role access.Role, title string) View {
48 v := s.view(w, r, title)
49 v.Repo = &repo
50 v.Role = role
51 v.CanWrite = role.CanWriteCode()
52 v.CanAdmin = role.CanManageSettings()
53 v.Rev = safeRev(r.URL.Query().Get("rev"), repo.DefaultBranch)
54 v.CloneHTTP = strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath() + ".git"
55 v.CloneSSH = s.Cfg.CloneSSH(repo.FullPath())
56 return v
57}
58
59func (s *Server) repoHome(w http.ResponseWriter, r *http.Request) {
60 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
61 if !ok {
62 return
63 }
64 v := s.repoView(w, r, repo, role, repo.Name)
65 v.Wide = true
66 s.fillOverview(r, &v, repo)
67 v.Heat = s.heatmap(r.Context(), 0, []int64{repo.ID})
68 s.render(w, "repo", v)
69}
70
71func (s *Server) treeRoot(w http.ResponseWriter, r *http.Request) {
72 r.SetPathValue("path", "")
73 s.tree(w, r)
74}
75
76func (s *Server) tree(w http.ResponseWriter, r *http.Request) {
77 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
78 if !ok {
79 return
80 }
81 rel, err := cleanRel(r.PathValue("path"))
82 if err != nil {
83 http.NotFound(w, r)
84 return
85 }
86 v := s.repoView(w, r, repo, role, rel)
87 v.Wide = true
88 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
89 if _, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel); err != nil && rel != "" {
90 http.NotFound(w, r)
91 return
92 }
93 s.fillFiles(r, &v, repo, rel, false)
94 s.render(w, "files", v)
95}
96
97func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
98 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
99 if !ok {
100 return
101 }
102 rel, err := cleanRel(r.PathValue("path"))
103 if err != nil || rel == "" {
104 http.NotFound(w, r)
105 return
106 }
107 v := s.repoView(w, r, repo, role, rel)
108 v.Wide = true
109 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
110 if _, _, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 1); err != nil {
111 http.NotFound(w, r)
112 return
113 }
114 s.fillFiles(r, &v, repo, rel, true)
115 s.render(w, "files", v)
116}
117
118func (s *Server) commits(w http.ResponseWriter, r *http.Request) {
119 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
120 if !ok {
121 return
122 }
123 v := s.repoView(w, r, repo, role, "Commits")
124 v.Page = "commits"
125 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
126 list, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 50)
127 v.Commits = toCommits(list)
128 s.render(w, "commits", v)
129}
130
131func (s *Server) commit(w http.ResponseWriter, r *http.Request) {
132 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
133 if !ok {
134 return
135 }
136 sha := r.PathValue("sha")
137 if !safeSHA(sha) {
138 http.NotFound(w, r)
139 return
140 }
141 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
142 c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
143 if err != nil {
144 http.NotFound(w, r)
145 return
146 }
147 v := s.repoView(w, r, repo, role, c.Subject)
148 row := toCommits([]gitrepo.Commit{c})[0]
149 v.Commit = &row
150 s.render(w, "commit", v)
151}
152
153func (s *Server) branches(w http.ResponseWriter, r *http.Request) {
154 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
155 if !ok {
156 return
157 }
158 v := s.repoView(w, r, repo, role, "Branches")
159 v.Page = "branches"
160 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
161 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
162 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
163 for _, name := range names {
164 v.Branches = append(v.Branches, BranchRow{Name: name, Protected: access.BranchProtected(patterns, name)})
165 }
166 s.render(w, "branches", v)
167}
168
169func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
170 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
171 if !ok {
172 return
173 }
174 v := s.repoView(w, r, repo, role, "Merge requests")
175 v.Page = "mrs"
176 v.MRs, _ = s.Store.ListMergeRequests(r.Context(), repo.ID)
177 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
178 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
179 for _, name := range names {
180 v.Branches = append(v.Branches, BranchRow{Name: name})
181 }
182 s.render(w, "mrs", v)
183}
184
185func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
186 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
187 if !ok || !s.csrfOK(w, r) {
188 return
189 }
190 if !role.CanWriteCode() {
191 http.Error(w, "geen toegang", http.StatusForbidden)
192 return
193 }
194 source := safeRev(r.FormValue("source"), "")
195 target := safeRev(r.FormValue("target"), repo.DefaultBranch)
196 if source == "" || source == target {
197 s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", "kies twee verschillende branches")
198 return
199 }
200 mr, err := s.Store.CreateMergeRequest(r.Context(), repo.ID, u.ID, r.FormValue("title"), r.FormValue("description"), source, target)
201 if err != nil {
202 s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", err.Error())
203 return
204 }
205 s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", u.Username, "merge request !"+strconv.FormatInt(mr.Number, 10)+" geopend: "+mr.Title, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10)))
206 s.recordContribution(u.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)
207 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Merge request geopend", "")
208}
209
210func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
211 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
212 if !ok {
213 return
214 }
215 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
216 if err != nil {
217 http.NotFound(w, r)
218 return
219 }
220 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
221 if err != nil {
222 http.NotFound(w, r)
223 return
224 }
225 v := s.repoView(w, r, repo, role, mr.Title)
226 v.MR = &mr
227 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
228 v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch))
229 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
230 diff, err := gitrepo.DiffStat(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch)
231 if err == nil {
232 v.Diff = diff
233 }
234 notes, _ := s.Store.ListNotes(r.Context(), mr.ID)
235 for _, n := range notes {
236 v.Notes = append(v.Notes, NoteRow{Author: n.Author, Body: n.Body, When: dutchDate(n.CreatedAt)})
237 }
238 s.render(w, "mr", v)
239}
240
241func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {
242 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
243 if !ok || !s.csrfOK(w, r) {
244 return
245 }
246 if u.ID == 0 {
247 http.Error(w, "geen toegang", http.StatusForbidden)
248 return
249 }
250 mr, err := s.mrFromRequest(r, repo.ID)
251 if err != nil {
252 http.NotFound(w, r)
253 return
254 }
255 back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
256 if _, err := s.Store.AddNote(r.Context(), repo.ID, mr.ID, u.ID, r.FormValue("body")); err != nil {
257 s.redirect(w, r, back, "", err.Error())
258 return
259 }
260 s.redirect(w, r, back, "Reactie geplaatst", "")
261}
262
263func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
264 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
265 if !ok || !s.csrfOK(w, r) {
266 return
267 }
268 mr, err := s.mrFromRequest(r, repo.ID)
269 if err != nil || mr.Status != "open" {
270 http.NotFound(w, r)
271 return
272 }
273 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
274 if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
275 http.Error(w, "geen toegang tot de doelbranch", http.StatusForbidden)
276 return
277 }
278 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
279 before, _ := gitrepo.Refs(r.Context(), s.Git, dir)
280 work := s.StoragePath() + "/tmp/merge-" + strconv.FormatInt(mr.ID, 10)
281 email := u.Username + "@users.git.timfalken.com"
282 msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
283 if err := gitrepo.Merge(r.Context(), s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, u.Username, email, msg, role, patterns); err != nil {
284 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", err.Error())
285 return
286 }
287 _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "merged")
288 after, _ := gitrepo.Refs(r.Context(), s.Git, dir)
289 s.AfterPush(repo, u, before, after)
290 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Samengevoegd", "")
291}
292
293func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
294 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
295 if !ok || !s.csrfOK(w, r) {
296 return
297 }
298 mr, err := s.mrFromRequest(r, repo.ID)
299 if err != nil {
300 http.NotFound(w, r)
301 return
302 }
303 if mr.AuthorID != u.ID && !role.CanManageSettings() {
304 http.Error(w, "geen toegang", http.StatusForbidden)
305 return
306 }
307 _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "closed")
308 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Gesloten", "")
309}
310
311func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
312 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
313 if err != nil {
314 return store.MergeRequest{}, err
315 }
316 return s.Store.MergeRequestByNumber(r.Context(), repoID, n)
317}
318
319func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) {
320 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
321 if !ok {
322 return
323 }
324 v := s.repoView(w, r, repo, role, "Pipelines")
325 v.Pipes, _ = s.Store.ListPipelines(r.Context(), repo.ID)
326 s.render(w, "pipelines", v)
327}
328
329func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) {
330 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
331 if !ok {
332 return
333 }
334 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
335 if err != nil {
336 http.NotFound(w, r)
337 return
338 }
339 p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
340 if err != nil {
341 http.NotFound(w, r)
342 return
343 }
344 v := s.repoView(w, r, repo, role, "Pipeline")
345 v.Pipe = &p
346 v.Jobs, _ = s.Store.JobsByPipeline(r.Context(), p.ID)
347 s.render(w, "pipeline", v)
348}
349
350func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
351 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
352 if !ok || !s.csrfOK(w, r) {
353 return
354 }
355 ref := safeRev(r.FormValue("ref"), repo.DefaultBranch)
356 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
357 shaOut, err := gitSHA(r, s.Git, dir, ref)
358 if err != nil {
359 s.redirect(w, r, repoURL(repo)+"/-/pipelines", "", "branch niet gevonden")
360 return
361 }
362 s.startPipeline(r.Context(), repo, shaOut, "refs/heads/"+ref, u.Username)
363 s.redirect(w, r, repoURL(repo)+"/-/pipelines", "Pipeline gestart", "")
364}
365
366func (s *Server) releases(w http.ResponseWriter, r *http.Request) {
367 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
368 if !ok {
369 return
370 }
371 v := s.repoView(w, r, repo, role, "Releases")
372 v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID)
373 s.render(w, "releases", v)
374}
375
376func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
377 u, ok := s.loginRequired(w, r)
378 if !ok || !s.csrfOK(w, r) {
379 return
380 }
381 if s.StoragePath() == "" {
382 s.redirect(w, r, "/", "", strings.TrimSpace(noStorageMsg))
383 return
384 }
385 name, err := names.Slug("repo", r.FormValue("name"))
386 if err != nil {
387 s.redirect(w, r, "/new", "", "Deze naam kan niet.")
388 return
389 }
390 ownerKind := "user"
391 ownerID := u.ID
392 if gpath := strings.TrimSpace(r.FormValue("group")); gpath != "" {
393 g, err := s.Store.GroupByPath(r.Context(), gpath)
394 if err != nil {
395 s.redirect(w, r, "/new", "", "groep niet gevonden")
396 return
397 }
398 role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
399 if err != nil || !role.CanManageSettings() {
400 http.Error(w, "geen toegang", http.StatusForbidden)
401 return
402 }
403 ownerKind, ownerID = "group", g.ID
404 }
405 vis := r.FormValue("visibility")
406 if vis != "public" {
407 vis = "private"
408 }
409 repo, err := s.Store.CreateRepo(r.Context(), ownerKind, ownerID, name, r.FormValue("description"), s.Cfg.Git.DefaultBranch, vis)
410 if err != nil {
411 s.redirect(w, r, "/new", "", err.Error())
412 return
413 }
414 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
415 if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {
416 _ = s.Store.DeleteRepo(r.Context(), repo.ID)
417 s.redirect(w, r, "/new", "", "git init: "+err.Error())
418 return
419 }
420 s.redirect(w, r, repoURL(repo), "Repository aangemaakt", "")
421}
422
423func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
424 u, ok := s.loginRequired(w, r)
425 if !ok || !s.csrfOK(w, r) {
426 return
427 }
428 display := strings.TrimSpace(r.FormValue("name"))
429 path, err := names.Slug("group", display)
430 if err != nil {
431 s.redirect(w, r, "/new", "", "Deze naam kan niet.")
432 return
433 }
434 g, err := s.Store.CreateGroup(r.Context(), u.ID, display, path, r.FormValue("description"))
435 if err != nil {
436 s.redirect(w, r, "/new", "", err.Error())
437 return
438 }
439 s.redirect(w, r, "/groups/"+g.Path, "Groep aangemaakt", "")
440}
441
442func toCommits(in []gitrepo.Commit) []CommitRow {
443 var out []CommitRow
444 for _, c := range in {
445 out = append(out, CommitRow{SHA: c.SHA, Short: c.Short, Author: c.Author, Date: c.Date, Subject: c.Subject, Body: c.Body})
446 }
447 return out
448}
449
450func toEntries(base string, in []gitrepo.Entry) []EntryRow {
451 var out []EntryRow
452 for _, e := range in {
453 p := e.Name
454 if base != "" {
455 p = base + "/" + e.Name
456 }
457 out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
458 }
459 return out
460}
461
462func cleanRel(p string) (string, error) {
463 p = strings.TrimPrefix(p, "/")
464 if p == "" || p == "." {
465 return "", nil
466 }
467 if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
468 return "", errBadID
469 }
470 return p, nil
471}
472
473func safeRev(s, fallback string) string {
474 if s == "" {
475 return fallback
476 }
477 if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
478 return fallback
479 }
480 return s
481}
482
483func safeSHA(s string) bool {
484 if len(s) < 7 || len(s) > 64 {
485 return false
486 }
487 for _, c := range s {
488 if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
489 return false
490 }
491 }
492 return true
493}