BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

feat: lees .bluegit-sjablonen en klikbare takenlijsten
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
79722e46 History
repo_handlers.go 12.8 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/desctpl"
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/store"
13)
14
15func (s *Server) guard(w http.ResponseWriter, r *http.Request, min access.Role) (store.User, store.Repo, access.Role, bool) {
16 owner := r.PathValue("owner")
17 name := strings.TrimSuffix(r.PathValue("repo"), ".git")
18 repo, err := s.Store.RepoByPath(r.Context(), owner, name)
19 if err != nil {
20 http.NotFound(w, r)
21 return store.User{}, store.Repo{}, "", false
22 }
23 p := s.who(r)
24 var role access.Role
25 if p.OK {
26 role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID)
27 if err != nil {
28 http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
29 return store.User{}, store.Repo{}, "", false
30 }
31 }
32 readable := role.CanRead() || repo.Visibility == "public"
33 if !readable {
34 if p.OK {
35 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
36 } else {
37 http.NotFound(w, r)
38 }
39 return store.User{}, store.Repo{}, "", false
40 }
41 if min != access.RoleReadonly && !role.AtLeast(min) {
42 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
43 return store.User{}, store.Repo{}, "", false
44 }
45 return p.User, repo, role, true
46}
47
48func (s *Server) repoView(w http.ResponseWriter, r *http.Request, repo store.Repo, role access.Role, title string) View {
49 v := s.view(w, r, title)
50 v.Repo = &repo
51 v.Role = role
52 v.CanWrite = role.CanWriteCode()
53 v.CanAdmin = role.CanManageSettings()
54 v.Rev = safeRev(r.URL.Query().Get("rev"), repo.DefaultBranch)
55 v.CloneHTTP = strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath() + ".git"
56 v.CloneSSH = s.Cfg.CloneSSH(repo.FullPath())
57 return v
58}
59
60func (s *Server) repoHome(w http.ResponseWriter, r *http.Request) {
61 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
62 if !ok {
63 return
64 }
65 v := s.repoView(w, r, repo, role, repo.Name)
66 v.Wide = true
67 s.fillOverview(r, &v, repo)
68 v.Heat = s.heatmap(r.Context(), 0, []int64{repo.ID}, s.langOf(r))
69 s.render(w, "repo", v)
70}
71
72func (s *Server) treeRoot(w http.ResponseWriter, r *http.Request) {
73 r.SetPathValue("path", "")
74 s.tree(w, r)
75}
76
77func (s *Server) tree(w http.ResponseWriter, r *http.Request) {
78 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
79 if !ok {
80 return
81 }
82 rel, err := cleanRel(r.PathValue("path"))
83 if err != nil {
84 http.NotFound(w, r)
85 return
86 }
87 v := s.repoView(w, r, repo, role, rel)
88 v.Wide = true
89 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
90 if _, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel); err != nil && rel != "" {
91 http.NotFound(w, r)
92 return
93 }
94 s.fillFiles(r, &v, repo, rel, false)
95 s.render(w, "files", v)
96}
97
98func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
99 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
100 if !ok {
101 return
102 }
103 rel, err := cleanRel(r.PathValue("path"))
104 if err != nil || rel == "" {
105 http.NotFound(w, r)
106 return
107 }
108 v := s.repoView(w, r, repo, role, rel)
109 v.Wide = true
110 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
111 if _, _, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 1); err != nil {
112 http.NotFound(w, r)
113 return
114 }
115 s.fillFiles(r, &v, repo, rel, true)
116 s.render(w, "files", v)
117}
118
119func (s *Server) commits(w http.ResponseWriter, r *http.Request) {
120 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
121 if !ok {
122 return
123 }
124 v := s.repoView(w, r, repo, role, "title.commits")
125 v.Page = "commits"
126 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
127 list, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 50)
128 v.Commits = s.presentCommits(r.Context(), repo.ID, list, i18n.Parse(v.Lang))
129 s.render(w, "commits", v)
130}
131
132func (s *Server) commit(w http.ResponseWriter, r *http.Request) {
133 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
134 if !ok {
135 return
136 }
137 sha := r.PathValue("sha")
138 if !safeSHA(sha) {
139 http.NotFound(w, r)
140 return
141 }
142 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
143 c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
144 if err != nil {
145 http.NotFound(w, r)
146 return
147 }
148 v := s.repoView(w, r, repo, role, c.Subject)
149 v.Page = "commit"
150 v.Wide = true
151 lang := i18n.Parse(v.Lang)
152 rows := s.presentCommits(r.Context(), repo.ID, []gitrepo.Commit{c}, lang)
153 s.attachHeadPipeline(r.Context(), repo, &rows[0], lang)
154 v.Commit = &rows[0]
155 parents, files, err := gitrepo.CommitPatch(r.Context(), s.Git, dir, c.SHA)
156 if err != nil && s.Log != nil {
157 s.Log.Warn("commitdiff", "sha", c.SHA, "err", err)
158 }
159 v.CommitDiff = presentCommitDiff(repo.FullPath(), c.SHA, parents, files)
160 s.render(w, "commit", v)
161}
162
163func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
164 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
165 if !ok {
166 return
167 }
168 v := s.repoView(w, r, repo, role, "title.mrs")
169 v.Page = "mrs"
170 v.MRs, _ = s.Store.ListMergeRequests(r.Context(), repo.ID)
171 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
172 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
173 for _, name := range names {
174 v.Branches = append(v.Branches, BranchRow{Name: name})
175 }
176 s.render(w, "mrs", v)
177}
178
179func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
180 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
181 if !ok || !s.csrfOK(w, r) {
182 return
183 }
184 source := safeRev(r.FormValue("source"), "")
185 target := safeRev(r.FormValue("target"), repo.DefaultBranch)
186 desc := desctpl.Expand(r.FormValue("description"), s.mrVars(r, repo, source, target))
187 mr, err := s.opCreateMR(r.Context(), u, repo, r.FormValue("title"), desc, source, target, r.FormValue("draft") == "1")
188 if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests", err) {
189 return
190 }
191 num := strconv.FormatInt(mr.Number, 10)
192 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "")
193}
194
195func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
196 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
197 if !ok {
198 return
199 }
200 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
201 if err != nil {
202 http.NotFound(w, r)
203 return
204 }
205 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
206 if err != nil {
207 http.NotFound(w, r)
208 return
209 }
210 v := s.repoView(w, r, repo, role, mr.Title)
211 v.Page = "mr"
212 v.MR = &mr
213 v.Wide = true
214 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
215 v.CanComment = role.AtLeast(access.RoleReadonly)
216 v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch))
217 v.CanApply = mr.Status == "open" && role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch))
218 v.MergeBlocks = s.mergeBlocks(r, repo, mr)
219 s.fillMRPipeline(r, &v, repo, mr)
220 s.fillReviews(r, &v, repo, mr, role)
221 if u.ID != 0 {
222 mine := u.ID == mr.AuthorID || role.CanManageSettings()
223 v.CanClose = mr.Status == "open" && mine
224 v.CanReopen = mr.Status == "closed" && mine
225 }
226 s.finishMR(r, &v, repo, mr, u)
227 s.render(w, "mr", v)
228}
229
230func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {
231 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
232 if !ok || !s.csrfOK(w, r) {
233 return
234 }
235 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
236 if err != nil {
237 http.NotFound(w, r)
238 return
239 }
240 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
241 parent, _ := strconv.ParseInt(r.FormValue("parent"), 10, 64)
242 start, _ := strconv.Atoi(r.FormValue("line_start"))
243 end, _ := strconv.Atoi(r.FormValue("line_end"))
244 if _, err := s.opAddNote(r, u, repo, n, r.FormValue("body"), r.FormValue("path"), start, end, parent); !s.uiOK(w, r, back, err) {
245 return
246 }
247 s.redirect(w, r, back, s.tr(r, "flash.note"), "")
248}
249
250func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
251 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
252 if !ok || !s.csrfOK(w, r) {
253 return
254 }
255 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
256 if err != nil {
257 http.NotFound(w, r)
258 return
259 }
260 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
261 if !s.uiOK(w, r, back, s.opMergeMR(r, u, repo, n)) {
262 return
263 }
264 s.redirect(w, r, back, s.tr(r, "flash.merged"), "")
265}
266
267func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
268 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
269 if !ok || !s.csrfOK(w, r) {
270 return
271 }
272 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
273 if err != nil {
274 http.NotFound(w, r)
275 return
276 }
277 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
278 if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, false)) {
279 return
280 }
281 s.redirect(w, r, back, s.tr(r, "flash.closed"), "")
282}
283
284func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
285 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
286 if err != nil {
287 return store.MergeRequest{}, err
288 }
289 return s.Store.MergeRequestByNumber(r.Context(), repoID, n)
290}
291
292func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) {
293 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
294 if !ok {
295 return
296 }
297 if id := strings.TrimSpace(r.URL.Query().Get("show")); id != "" {
298 if n, err := strconv.ParseInt(id, 10, 64); err == nil && n > 0 {
299 http.Redirect(w, r, repoURL(repo)+"/-/pipelines/"+id, http.StatusSeeOther)
300 return
301 }
302 }
303 v := s.repoView(w, r, repo, role, "title.pipelines")
304 v.Wide = true
305 v.Page = "pipelines"
306 s.fillPipelines(r, &v, repo)
307 if wantsJSON(r) {
308 s.writePipeList(w, v)
309 return
310 }
311 s.render(w, "pipelines", v)
312}
313
314func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) {
315 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
316 if !ok {
317 return
318 }
319 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
320 if err != nil {
321 http.NotFound(w, r)
322 return
323 }
324 p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
325 if err != nil {
326 http.NotFound(w, r)
327 return
328 }
329 v := s.repoView(w, r, repo, role, "title.pipeline")
330 v.Wide = true
331 v.Page = "pipelines"
332 v.Pipe = &p
333 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
334 v.Jobs = jobs
335 ranks := s.queueRanks(r.Context())
336 tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
337 v.PipeStatus = displayStatus(p.Status, jobs)
338 v.PipeLabel = tr("pipe." + v.PipeStatus)
339 v.PipeJobs = linksFor(jobs, ranks, tr)
340 v.Live = jobsLive(p.Status, jobs)
341 v.LiveURL = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10)
342 if wantsJSON(r) {
343 s.writePipeDetail(w, v)
344 return
345 }
346 s.render(w, "pipeline", v)
347}
348
349func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
350 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
351 if !ok || !s.csrfOK(w, r) {
352 return
353 }
354 if _, err := s.opRunPipeline(r.Context(), u, repo, r.FormValue("ref"), "web"); !s.uiOK(w, r, repoURL(repo)+"/-/pipelines", err) {
355 return
356 }
357 s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "")
358}
359
360func (s *Server) releases(w http.ResponseWriter, r *http.Request) {
361 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
362 if !ok {
363 return
364 }
365 v := s.repoView(w, r, repo, role, "title.releases")
366 v.Page = "releases"
367 v.Wide = true
368 v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID)
369 s.render(w, "releases", v)
370}
371
372func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
373 u, ok := s.loginRequired(w, r)
374 if !ok || !s.csrfOK(w, r) {
375 return
376 }
377 repo, err := s.opCreateRepo(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("group"), r.FormValue("visibility"), false)
378 if err != nil {
379 if statusOf(err) == http.StatusForbidden {
380 http.Error(w, s.trErr(r, err), http.StatusForbidden)
381 return
382 }
383 s.failCreate(w, r, s.trErr(r, err))
384 return
385 }
386 s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated"))
387}
388
389func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
390 u, ok := s.loginRequired(w, r)
391 if !ok || !s.csrfOK(w, r) {
392 return
393 }
394 g, err := s.opCreateGroup(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("default_role"))
395 if err != nil {
396 s.failCreate(w, r, s.trErr(r, err))
397 return
398 }
399 s.finishCreate(w, r, "/groups/"+g.Path, s.tr(r, "flash.groupCreated"))
400}
401
402func toEntries(base string, in []gitrepo.Entry) []EntryRow {
403 var out []EntryRow
404 for _, e := range in {
405 p := e.Name
406 if base != "" {
407 p = base + "/" + e.Name
408 }
409 out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
410 }
411 return out
412}
413
414func cleanRel(p string) (string, error) {
415 p = strings.TrimPrefix(p, "/")
416 if p == "" || p == "." {
417 return "", nil
418 }
419 if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
420 return "", errBadID
421 }
422 return p, nil
423}
424
425func safeRev(s, fallback string) string {
426 if s == "" {
427 return fallback
428 }
429 if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
430 return fallback
431 }
432 return s
433}
434
435func safeSHA(s string) bool {
436 if len(s) < 7 || len(s) > 64 {
437 return false
438 }
439 for _, c := range s {
440 if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
441 return false
442 }
443 }
444 return true
445}