BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

feat: bied dezelfde acties als de UI aan via /api/v1
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
d89195e9 History
repo_handlers.go 12.6 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/i18n"
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, s.tr(r, "err.rights"), 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, s.tr(r, "err.forbidden"), 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, s.tr(r, "err.forbidden"), 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}, s.langOf(r))
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, "title.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 = s.presentCommits(r.Context(), repo.ID, list, i18n.Parse(v.Lang))
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 v.Page = "commit"
149 v.Wide = true
150 lang := i18n.Parse(v.Lang)
151 rows := s.presentCommits(r.Context(), repo.ID, []gitrepo.Commit{c}, lang)
152 s.attachHeadPipeline(r.Context(), repo, &rows[0], lang)
153 v.Commit = &rows[0]
154 parents, files, err := gitrepo.CommitPatch(r.Context(), s.Git, dir, c.SHA)
155 if err != nil && s.Log != nil {
156 s.Log.Warn("commitdiff", "sha", c.SHA, "err", err)
157 }
158 v.CommitDiff = presentCommitDiff(repo.FullPath(), c.SHA, parents, files)
159 s.render(w, "commit", v)
160}
161
162func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
163 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
164 if !ok {
165 return
166 }
167 v := s.repoView(w, r, repo, role, "title.mrs")
168 v.Page = "mrs"
169 v.MRs, _ = s.Store.ListMergeRequests(r.Context(), repo.ID)
170 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
171 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
172 for _, name := range names {
173 v.Branches = append(v.Branches, BranchRow{Name: name})
174 }
175 s.render(w, "mrs", v)
176}
177
178func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
179 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
180 if !ok || !s.csrfOK(w, r) {
181 return
182 }
183 mr, err := s.opCreateMR(r.Context(), u, repo, r.FormValue("title"), r.FormValue("description"), r.FormValue("source"), r.FormValue("target"), r.FormValue("draft") == "1")
184 if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests", err) {
185 return
186 }
187 num := strconv.FormatInt(mr.Number, 10)
188 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "")
189}
190
191func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
192 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
193 if !ok {
194 return
195 }
196 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
197 if err != nil {
198 http.NotFound(w, r)
199 return
200 }
201 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
202 if err != nil {
203 http.NotFound(w, r)
204 return
205 }
206 v := s.repoView(w, r, repo, role, mr.Title)
207 v.Page = "mr"
208 v.MR = &mr
209 v.Wide = true
210 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
211 v.CanComment = role.AtLeast(access.RoleReadonly)
212 v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch))
213 v.CanApply = mr.Status == "open" && role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch))
214 v.MergeBlocks = s.mergeBlocks(r, repo, mr)
215 s.fillMRPipeline(r, &v, repo, mr)
216 s.fillReviews(r, &v, repo, mr, role)
217 if u.ID != 0 {
218 mine := u.ID == mr.AuthorID || role.CanManageSettings()
219 v.CanClose = mr.Status == "open" && mine
220 v.CanReopen = mr.Status == "closed" && mine
221 }
222 s.finishMR(r, &v, repo, mr, u)
223 s.render(w, "mr", v)
224}
225
226func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {
227 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
228 if !ok || !s.csrfOK(w, r) {
229 return
230 }
231 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
232 if err != nil {
233 http.NotFound(w, r)
234 return
235 }
236 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
237 parent, _ := strconv.ParseInt(r.FormValue("parent"), 10, 64)
238 start, _ := strconv.Atoi(r.FormValue("line_start"))
239 end, _ := strconv.Atoi(r.FormValue("line_end"))
240 if _, err := s.opAddNote(r, u, repo, n, r.FormValue("body"), r.FormValue("path"), start, end, parent); !s.uiOK(w, r, back, err) {
241 return
242 }
243 s.redirect(w, r, back, s.tr(r, "flash.note"), "")
244}
245
246func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
247 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
248 if !ok || !s.csrfOK(w, r) {
249 return
250 }
251 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
252 if err != nil {
253 http.NotFound(w, r)
254 return
255 }
256 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
257 if !s.uiOK(w, r, back, s.opMergeMR(r, u, repo, n)) {
258 return
259 }
260 s.redirect(w, r, back, s.tr(r, "flash.merged"), "")
261}
262
263func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
264 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
265 if !ok || !s.csrfOK(w, r) {
266 return
267 }
268 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
269 if err != nil {
270 http.NotFound(w, r)
271 return
272 }
273 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
274 if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, false)) {
275 return
276 }
277 s.redirect(w, r, back, s.tr(r, "flash.closed"), "")
278}
279
280func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
281 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
282 if err != nil {
283 return store.MergeRequest{}, err
284 }
285 return s.Store.MergeRequestByNumber(r.Context(), repoID, n)
286}
287
288func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) {
289 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
290 if !ok {
291 return
292 }
293 if id := strings.TrimSpace(r.URL.Query().Get("show")); id != "" {
294 if n, err := strconv.ParseInt(id, 10, 64); err == nil && n > 0 {
295 http.Redirect(w, r, repoURL(repo)+"/-/pipelines/"+id, http.StatusSeeOther)
296 return
297 }
298 }
299 v := s.repoView(w, r, repo, role, "title.pipelines")
300 v.Wide = true
301 v.Page = "pipelines"
302 s.fillPipelines(r, &v, repo)
303 if wantsJSON(r) {
304 s.writePipeList(w, v)
305 return
306 }
307 s.render(w, "pipelines", v)
308}
309
310func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) {
311 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
312 if !ok {
313 return
314 }
315 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
316 if err != nil {
317 http.NotFound(w, r)
318 return
319 }
320 p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
321 if err != nil {
322 http.NotFound(w, r)
323 return
324 }
325 v := s.repoView(w, r, repo, role, "title.pipeline")
326 v.Wide = true
327 v.Page = "pipelines"
328 v.Pipe = &p
329 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
330 v.Jobs = jobs
331 ranks := s.queueRanks(r.Context())
332 tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
333 v.PipeStatus = displayStatus(p.Status, jobs)
334 v.PipeLabel = tr("pipe." + v.PipeStatus)
335 v.PipeJobs = linksFor(jobs, ranks, tr)
336 v.Live = jobsLive(p.Status, jobs)
337 v.LiveURL = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10)
338 if wantsJSON(r) {
339 s.writePipeDetail(w, v)
340 return
341 }
342 s.render(w, "pipeline", v)
343}
344
345func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
346 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
347 if !ok || !s.csrfOK(w, r) {
348 return
349 }
350 if _, err := s.opRunPipeline(r.Context(), u, repo, r.FormValue("ref"), "web"); !s.uiOK(w, r, repoURL(repo)+"/-/pipelines", err) {
351 return
352 }
353 s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "")
354}
355
356func (s *Server) releases(w http.ResponseWriter, r *http.Request) {
357 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
358 if !ok {
359 return
360 }
361 v := s.repoView(w, r, repo, role, "title.releases")
362 v.Page = "releases"
363 v.Wide = true
364 v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID)
365 s.render(w, "releases", v)
366}
367
368func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
369 u, ok := s.loginRequired(w, r)
370 if !ok || !s.csrfOK(w, r) {
371 return
372 }
373 repo, err := s.opCreateRepo(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("group"), r.FormValue("visibility"), false)
374 if err != nil {
375 if statusOf(err) == http.StatusForbidden {
376 http.Error(w, s.trErr(r, err), http.StatusForbidden)
377 return
378 }
379 s.failCreate(w, r, s.trErr(r, err))
380 return
381 }
382 s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated"))
383}
384
385func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
386 u, ok := s.loginRequired(w, r)
387 if !ok || !s.csrfOK(w, r) {
388 return
389 }
390 g, err := s.opCreateGroup(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("default_role"))
391 if err != nil {
392 s.failCreate(w, r, s.trErr(r, err))
393 return
394 }
395 s.finishCreate(w, r, "/groups/"+g.Path, s.tr(r, "flash.groupCreated"))
396}
397
398func toEntries(base string, in []gitrepo.Entry) []EntryRow {
399 var out []EntryRow
400 for _, e := range in {
401 p := e.Name
402 if base != "" {
403 p = base + "/" + e.Name
404 }
405 out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
406 }
407 return out
408}
409
410func cleanRel(p string) (string, error) {
411 p = strings.TrimPrefix(p, "/")
412 if p == "" || p == "." {
413 return "", nil
414 }
415 if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
416 return "", errBadID
417 }
418 return p, nil
419}
420
421func safeRev(s, fallback string) string {
422 if s == "" {
423 return fallback
424 }
425 if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
426 return fallback
427 }
428 return s
429}
430
431func safeSHA(s string) bool {
432 if len(s) < 7 || len(s) > 64 {
433 return false
434 }
435 for _, c := range s {
436 if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
437 return false
438 }
439 }
440 return true
441}