BlueGit

timfa bluegit

Files

bluegit / internal / server / mr_page.go

mr_page.go

feat: voeg een issue-tracker per repository toe
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
f3222d5f History
mr_page.go 8.7 KiB Download Raw
1package server
2
3import (
4 "context"
5 "html/template"
6 "net/http"
7 "sort"
8 "strconv"
9 "strings"
10
11 "gitlab.com/Timfa/bluegit/internal/access"
12 "gitlab.com/Timfa/bluegit/internal/gitrepo"
13 "gitlab.com/Timfa/bluegit/internal/i18n"
14 "gitlab.com/Timfa/bluegit/internal/markdown"
15 "gitlab.com/Timfa/bluegit/internal/store"
16)
17
18func (s *Server) compare(w http.ResponseWriter, r *http.Request) {
19 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
20 if !ok {
21 return
22 }
23 v := s.repoView(w, r, repo, role, "branch.compare")
24 v.Title = s.tr(r, "branch.compare")
25 v.Page = "compare"
26 v.Wide = true
27 s.fillBranchChoices(r, &v, repo)
28 from := safeRev(r.URL.Query().Get("from"), repo.DefaultBranch)
29 to := safeRev(r.URL.Query().Get("to"), "")
30 s.fillCompare(r, &v, repo, from, to)
31 s.render(w, "compare", v)
32}
33
34func (s *Server) newMR(w http.ResponseWriter, r *http.Request) {
35 _, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
36 if !ok {
37 return
38 }
39 if !role.CanWriteCode() {
40 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
41 return
42 }
43 v := s.repoView(w, r, repo, role, "mr.create")
44 v.Title = s.tr(r, "mr.create")
45 v.Page = "newmr"
46 v.Wide = true
47 s.fillBranchChoices(r, &v, repo)
48 source := safeRev(r.URL.Query().Get("source"), "")
49 target := safeRev(r.URL.Query().Get("target"), repo.DefaultBranch)
50 if source == "" {
51 for _, b := range v.Branches {
52 if b.Name != target {
53 source = b.Name
54 break
55 }
56 }
57 }
58 s.fillCompare(r, &v, repo, target, source)
59 v.CompareFrom = source
60 v.CompareTo = target
61 s.render(w, "newmr", v)
62}
63
64func (s *Server) previewMarkdown(w http.ResponseWriter, r *http.Request) {
65 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
66 if !ok || !s.csrfOK(w, r) {
67 return
68 }
69 if u.ID == 0 {
70 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
71 return
72 }
73 body := r.FormValue("body")
74 if len(body) > 20000 {
75 body = body[:20000]
76 }
77 w.Header().Set("Content-Type", "text/html; charset=utf-8")
78 _, _ = w.Write([]byte(markdown.Render(body, "", "", "/"+repo.FullPath())))
79}
80
81func (s *Server) updateMR(w http.ResponseWriter, r *http.Request) {
82 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
83 if !ok || !s.csrfOK(w, r) {
84 return
85 }
86 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
87 if err != nil {
88 http.NotFound(w, r)
89 return
90 }
91 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
92 if _, err := s.opUpdateMR(r.Context(), u, repo, n, r.FormValue("title"), r.FormValue("description"), r.FormValue("labels")); !s.uiOK(w, r, back, err) {
93 return
94 }
95 s.redirect(w, r, back, s.tr(r, "flash.mrUpdated"), "")
96}
97
98func (s *Server) finishMR(r *http.Request, v *View, repo store.Repo, mr store.MergeRequest, u store.User) {
99 v.DescHTML = template.HTML(markdown.Render(mr.Description, "", "", "/"+repo.FullPath()))
100 v.Labels = splitLabels(mr.Labels)
101 v.CanEditMR = mr.Status == "open" && u.ID != 0 && (u.ID == mr.AuthorID || v.CanWrite)
102 switch r.URL.Query().Get("tab") {
103 case "commits", "pipelines", "changes":
104 v.Tab = r.URL.Query().Get("tab")
105 default:
106 v.Tab = "overview"
107 }
108 s.fillCompare(r, v, repo, mr.TargetBranch, mr.SourceBranch)
109 raw, _ := s.Store.ListNotes(r.Context(), mr.ID)
110 rows := buildNoteRows(raw, s.langOf(r), "/"+repo.FullPath())
111 v.Notes = stampNotes(v.CommitDiff, rows)
112 s.fillTimeline(r, v, repo, mr, rows)
113}
114
115func (s *Server) fillBranchChoices(r *http.Request, v *View, repo store.Repo) {
116 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
117 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
118 for _, name := range names {
119 v.Branches = append(v.Branches, BranchRow{Name: name, Default: name == repo.DefaultBranch})
120 }
121 tags, _ := gitrepo.Tags(r.Context(), s.Git, dir)
122 for _, name := range tags {
123 v.Tags = append(v.Tags, TagRow{Name: name})
124 }
125}
126
127// fillCompare vult commits (from..to) en de three-dot diff (from...to).
128func (s *Server) fillCompare(r *http.Request, v *View, repo store.Repo, from, to string) {
129 v.CompareFrom = from
130 v.CompareTo = to
131 if from == "" || to == "" || from == to {
132 return
133 }
134 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
135 commits, err := gitrepo.Log(r.Context(), s.Git, dir, from+".."+to, 50)
136 if err == nil && len(commits) > 0 {
137 v.Commits = s.presentCommits(r.Context(), repo.ID, commits, s.langOf(r))
138 if len(commits) == 1 {
139 v.FormTitle = commits[0].Subject
140 }
141 }
142 if v.FormTitle == "" {
143 v.FormTitle = s.tr(r, "mr.mergeTitle", to, from)
144 }
145 files, err := gitrepo.ComparePatch(r.Context(), s.Git, dir, from, to)
146 if err == nil {
147 v.CommitDiff = presentCommitDiff(repo.FullPath(), to, nil, files)
148 }
149 if stat, err := gitrepo.DiffStat(r.Context(), s.Git, dir, from, to); err == nil {
150 v.Diff = stat
151 }
152}
153
154func (s *Server) fillTimeline(r *http.Request, v *View, repo store.Repo, mr store.MergeRequest, rows []NoteRow) {
155 lang := s.langOf(r)
156 items := []TimelineItem{{
157 Kind: "opened", Actor: mr.Author, Text: s.tr(r, "mr.opened"),
158 When: i18n.FormatDate(lang, mr.CreatedAt), At: mr.CreatedAt, Rank: 0,
159 }}
160 events, _ := s.Store.ListMREvents(r.Context(), mr.ID)
161 for _, e := range events {
162 key := mrEventKey(e.Kind)
163 if key == "" {
164 continue
165 }
166 items = append(items, TimelineItem{
167 Kind: e.Kind, Actor: e.Actor, Text: s.tr(r, key), Body: e.Body,
168 When: i18n.FormatDate(lang, e.CreatedAt), At: e.CreatedAt, Rank: 2,
169 })
170 }
171 revs, _ := s.Store.ListReviews(r.Context(), mr.ID)
172 for _, rev := range revs {
173 items = append(items, TimelineItem{
174 Kind: "review", Actor: rev.Username, Text: s.tr(r, "rev."+rev.Status),
175 When: i18n.FormatDate(lang, rev.UpdatedAt), At: rev.UpdatedAt, Rank: 3,
176 })
177 }
178 pipes, _ := s.Store.PipelinesForMR(r.Context(), repo.ID, mr.ID)
179 for _, p := range pipes {
180 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
181 status := displayStatus(p.Status, jobs)
182 label := s.tr(r, "pipe."+status)
183 v.PipeRows = append(v.PipeRows, s.pipeRow(r, lang, repo, p, map[string]store.User{}, s.queueRanks(r.Context())))
184 items = append(items, TimelineItem{
185 Kind: "pipeline", Actor: p.Actor,
186 Text: s.tr(r, "mr.pipeEvent", p.ID, label),
187 URL: repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10),
188 When: i18n.FormatDate(lang, p.CreatedAt), At: p.CreatedAt, Rank: 1,
189 })
190 }
191 for _, n := range rows {
192 if n.ParentID != 0 {
193 continue
194 }
195 item := TimelineItem{
196 ID: n.ID, Kind: "comment", Actor: n.Author, Text: s.tr(r, "mr.commented"),
197 HTML: n.HTML, When: n.When, At: n.At, Rank: 4,
198 }
199 for _, rp := range n.Replies {
200 item.Replies = append(item.Replies, TimelineItem{Actor: rp.Author, HTML: rp.HTML, When: rp.When})
201 }
202 items = append(items, item)
203 }
204 sort.SliceStable(items, func(i, j int) bool {
205 if items[i].At.Equal(items[j].At) {
206 return items[i].Rank < items[j].Rank
207 }
208 return items[i].At.Before(items[j].At)
209 })
210 v.Timeline = items
211}
212
213func mrEventKey(kind string) string {
214 switch kind {
215 case "pushed":
216 return "mr.pushed"
217 case "retitled":
218 return "mr.retitled"
219 case "relabeled":
220 return "mr.relabeled"
221 case "merged":
222 return "mr.mergedEvent"
223 case "closed":
224 return "mr.closedEvent"
225 case "reopened":
226 return "mr.reopenedEvent"
227 default:
228 return ""
229 }
230}
231
232func stampNotes(diff *CommitDiff, rows []NoteRow) []NoteRow {
233 placed := map[int64]bool{}
234 if diff != nil {
235 for i := range diff.Files {
236 for j := range diff.Files[i].Lines {
237 ln := &diff.Files[i].Lines[j]
238 if ln.New == 0 {
239 continue
240 }
241 for _, note := range rows {
242 if note.ParentID != 0 {
243 continue
244 }
245 if note.Path == diff.Files[i].Path && note.End == ln.New {
246 ln.Notes = append(ln.Notes, note)
247 placed[note.ID] = true
248 }
249 }
250 }
251 }
252 }
253 var general []NoteRow
254 for _, note := range rows {
255 if note.ParentID != 0 {
256 continue
257 }
258 if note.Path == "" || !placed[note.ID] {
259 general = append(general, note)
260 }
261 }
262 return general
263}
264
265func splitLabels(raw string) []string {
266 var out []string
267 for _, part := range strings.Split(raw, ",") {
268 part = strings.TrimSpace(part)
269 if part != "" {
270 out = append(out, part)
271 }
272 }
273 return out
274}
275
276func normalizeLabels(raw string) string {
277 return strings.Join(splitLabels(raw), ", ")
278}
279
280func (s *Server) recordMRPushes(repo store.Repo, user store.User, branch, before, after string) {
281 if s.StoragePath() == "" || branch == "" || after == "" {
282 return
283 }
284 ctx := context.Background()
285 mrs, err := s.Store.OpenMergeRequestsBySource(ctx, repo.ID, branch)
286 if err != nil || len(mrs) == 0 {
287 return
288 }
289 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
290 rev := after
291 limit := 1
292 if before != "" && strings.Trim(before, "0") != "" {
293 rev = before + ".." + after
294 limit = 20
295 }
296 subjects, err := gitrepo.Subjects(ctx, s.Git, dir, rev, limit)
297 if err != nil || len(subjects) == 0 {
298 return
299 }
300 body := strings.Join(subjects, "\n")
301 for _, mr := range mrs {
302 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "pushed", body)
303 }
304}