BlueGit

timfa bluegit

Files

bluegit / internal / server / ops_mr.go

ops_mr.go

feat: geef de merge-request-pagina een header en widget
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Passed 0892d994 History
ops_mr.go 15.3 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/http"
6 "os"
7 "strings"
8
9 "gitlab.com/Timfa/bluegit/internal/access"
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) opCreateMR(ctx context.Context, user store.User, repo store.Repo, title, description, source, target string, draft bool) (store.MergeRequest, error) {
16 role, err := s.repoRole(ctx, user, repo)
17 if err != nil {
18 return store.MergeRequest{}, err
19 }
20 if !role.CanWriteCode() {
21 return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
22 }
23 source = safeRev(source, "")
24 target = safeRev(target, repo.DefaultBranch)
25 if source == "" || source == target {
26 return store.MergeRequest{}, fail(400, i18n.E("err.branches"))
27 }
28 mr, err := s.Store.CreateMergeRequest(ctx, repo.ID, user.ID, title, description, source, target)
29 if err != nil {
30 return store.MergeRequest{}, fail(400, err)
31 }
32 if draft {
33 _ = s.Store.SetDraft(ctx, mr.ID, true)
34 mr.Draft = true
35 }
36 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
37 if sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" {
38 s.startOneMergePipeline(ctx, repo, sha, user.Username, "", mr)
39 }
40 s.mrHook(repo, mr, user.Username, "opened", "")
41 s.recordContribution(user.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)
42 return mr, nil
43}
44
45func (s *Server) opUpdateMR(ctx context.Context, user store.User, repo store.Repo, number int64, title, description, labels string) (store.MergeRequest, error) {
46 role, err := s.repoRole(ctx, user, repo)
47 if err != nil {
48 return store.MergeRequest{}, err
49 }
50 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
51 if err != nil {
52 return store.MergeRequest{}, notFound(err)
53 }
54 if mr.Status != "open" || (user.ID != mr.AuthorID && !role.CanWriteCode()) {
55 return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
56 }
57 title = strings.TrimSpace(title)
58 labels = normalizeLabels(labels)
59 if err := s.Store.UpdateMergeRequest(ctx, mr.ID, title, description, labels); err != nil {
60 return store.MergeRequest{}, fail(400, err)
61 }
62 if title != mr.Title {
63 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "retitled", title)
64 }
65 if labels != normalizeLabels(mr.Labels) {
66 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "relabeled", labels)
67 }
68 mr.Title, mr.Description, mr.Labels = title, description, labels
69 return mr, nil
70}
71
72func (s *Server) opAddNote(r *http.Request, user store.User, repo store.Repo, number int64, body, path string, start, end int, parent int64) (store.Note, error) {
73 ctx := r.Context()
74 role, err := s.repoRole(ctx, user, repo)
75 if err != nil {
76 return store.Note{}, err
77 }
78 if !role.AtLeast(access.RoleReadonly) {
79 return store.Note{}, fail(403, i18n.E("err.forbidden"))
80 }
81 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
82 if err != nil {
83 return store.Note{}, notFound(err)
84 }
85 path, pathOK := repoPath(path)
86 if !pathOK {
87 return store.Note{}, fail(400, i18n.E("err.sugFile"))
88 }
89 if path == "" {
90 if parent > 0 {
91 note, err := s.Store.AddReply(ctx, repo.ID, mr.ID, user.ID, parent, body)
92 if err != nil {
93 return store.Note{}, fail(400, err)
94 }
95 s.mrHook(repo, mr, user.Username, "commented", body)
96 return note, nil
97 }
98 note, err := s.Store.AddNote(ctx, repo.ID, mr.ID, user.ID, body)
99 if err != nil {
100 return store.Note{}, fail(400, err)
101 }
102 s.mrHook(repo, mr, user.Username, "commented", body)
103 return note, nil
104 }
105 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
106 blob, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, path)
107 if err != nil {
108 return store.Note{}, fail(400, i18n.E("err.sugFile"))
109 }
110 lines := gitrepo.SplitLines(blob)
111 if start < 1 || end < start || end > len(lines) {
112 return store.Note{}, fail(400, i18n.E("err.sugLines"))
113 }
114 base := strings.Join(lines[start-1:end], "\n")
115 suggestion, _ := gitrepo.ParseSuggestion(body)
116 note, err := s.Store.AddLineNote(ctx, repo.ID, mr.ID, user.ID, body, path, start, end, suggestion, base)
117 if err != nil {
118 return store.Note{}, fail(400, err)
119 }
120 s.noteRequestsChanges(r, repo, mr, user.ID, suggestion)
121 s.mrHook(repo, mr, user.Username, "commented", body)
122 return note, nil
123}
124
125func (s *Server) opReview(ctx context.Context, user store.User, repo store.Repo, number int64, status string) error {
126 role, err := s.repoRole(ctx, user, repo)
127 if err != nil {
128 return err
129 }
130 if !role.CanWriteCode() {
131 return fail(403, i18n.E("err.forbidden"))
132 }
133 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
134 if err != nil || mr.Status != "open" {
135 return notFound(err)
136 }
137 switch status {
138 case "approved", "changes", "rejected":
139 default:
140 return fail(400, i18n.E("rev.bad"))
141 }
142 if status == "approved" {
143 if user.ID == mr.AuthorID {
144 return fail(400, i18n.E("rev.own"))
145 }
146 pol, _, err := s.Store.EffectiveApproval(ctx, repo)
147 if err != nil || !approvalCounts(role, pol) {
148 return fail(403, i18n.E("err.forbidden"))
149 }
150 }
151 if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, user.ID, status); err != nil {
152 return fail(400, err)
153 }
154 return nil
155}
156
157func (s *Server) opDismissReview(ctx context.Context, user store.User, repo store.Repo, number, targetUser int64) error {
158 role, err := s.repoRole(ctx, user, repo)
159 if err != nil {
160 return err
161 }
162 if !role.CanManageSettings() {
163 return fail(403, i18n.E("err.forbidden"))
164 }
165 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
166 if err != nil {
167 return notFound(err)
168 }
169 if targetUser == 0 {
170 return fail(400, i18n.E("rev.bad"))
171 }
172 if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, targetUser, "dismissed"); err != nil {
173 return fail(400, err)
174 }
175 return nil
176}
177
178func (s *Server) opApplySuggestions(ctx context.Context, user store.User, repo store.Repo, number int64, title, description string, ids []int64) error {
179 role, err := s.repoRole(ctx, user, repo)
180 if err != nil {
181 return err
182 }
183 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
184 if err != nil || mr.Status != "open" {
185 return notFound(err)
186 }
187 patterns, err := s.Store.ProtectedPatterns(ctx, repo.ID)
188 if err != nil {
189 return fail(400, err)
190 }
191 if !role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) {
192 return fail(403, i18n.E("err.sugBranch", mr.SourceBranch))
193 }
194 title = strings.TrimSpace(title)
195 if title == "" || strings.ContainsAny(title, "\r\n") {
196 return fail(400, i18n.E("err.sugTitle"))
197 }
198 notes, err := s.Store.ListNotes(ctx, mr.ID)
199 if err != nil {
200 return fail(400, err)
201 }
202 byID := map[int64]store.Note{}
203 for _, n := range notes {
204 byID[n.ID] = n
205 }
206 var edits []gitrepo.SuggestionEdit
207 seen := map[int64]bool{}
208 for _, id := range ids {
209 if seen[id] {
210 continue
211 }
212 seen[id] = true
213 n, ok := byID[id]
214 if !ok || n.Suggestion == "" || n.FilePath == "" {
215 return fail(400, i18n.E("err.sugGone"))
216 }
217 edits = append(edits, gitrepo.SuggestionEdit{
218 Path: n.FilePath, Start: n.LineStart, End: n.LineEnd, Base: n.BaseText, Replacement: n.Suggestion,
219 })
220 }
221 if len(edits) == 0 {
222 return fail(400, i18n.E("err.sugEmpty"))
223 }
224 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
225 files := map[string]string{}
226 for _, e := range edits {
227 if _, ok := files[e.Path]; ok {
228 continue
229 }
230 body, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, e.Path)
231 if err != nil {
232 return fail(400, i18n.E("err.sugConflict", e.Path, e.Start, e.End))
233 }
234 files[e.Path] = body
235 }
236 updated, err := gitrepo.ApplySuggestions(files, edits)
237 if err != nil {
238 return fail(400, err)
239 }
240 branch := safeRev(mr.SourceBranch, "")
241 if branch == "" {
242 return fail(400, i18n.E("err.sugBranch", mr.SourceBranch))
243 }
244 work, err := s.scratchDir("suggest")
245 if err != nil {
246 return fail(500, err)
247 }
248 defer os.RemoveAll(work)
249 if err := s.postReceive(ctx, repo, user, dir, func() error {
250 return gitrepo.CommitOnBranch(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, updated, role, patterns)
251 }); err != nil {
252 return fail(400, err)
253 }
254 return nil
255}
256
257// mergeChoice is de keuze uit het formulier of de API.
258// FromForm betekent dat een browser de vakjes postte: een ontbrekend vakje staat uit.
259// De API laat FromForm uit en gebruikt de pointers. nil houdt de opgeslagen waarde.
260type mergeChoice struct {
261 FromForm bool
262 Remove *bool
263 Squash *bool
264 Message *string
265 Force bool
266 Confirm bool
267}
268
269// mergeOutcome vertelt de pagina en de API wat er na de merge met de bronbranch gebeurde.
270type mergeOutcome struct {
271 Notice string
272 Arg string
273 Removed bool
274 Skip string
275}
276
277func applyMergeChoice(mr store.MergeRequest, choice mergeChoice) (remove, squash bool, message string) {
278 remove, squash, message = mr.RemoveSourceBranch, mr.Squash, mr.SquashMessage
279 if choice.FromForm {
280 remove, squash, message = false, false, ""
281 }
282 if choice.Remove != nil {
283 remove = *choice.Remove
284 }
285 if choice.Squash != nil {
286 squash = *choice.Squash
287 }
288 if choice.Message != nil {
289 message = *choice.Message
290 }
291 return remove, squash, message
292}
293
294func (s *Server) opMergeMR(r *http.Request, user store.User, repo store.Repo, number int64, choice mergeChoice) (mergeOutcome, error) {
295 ctx := r.Context()
296 role, err := s.repoRole(ctx, user, repo)
297 if err != nil {
298 return mergeOutcome{}, err
299 }
300 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
301 if err != nil || mr.Status != "open" {
302 return mergeOutcome{}, notFound(err)
303 }
304 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
305 if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
306 return mergeOutcome{}, fail(403, i18n.E("err.targetAccess"))
307 }
308 remove, squash, message := applyMergeChoice(mr, choice)
309 if err := s.Store.SetMergeOptions(ctx, mr.ID, remove, squash, message); err != nil {
310 return mergeOutcome{}, fail(400, err)
311 }
312 mr.RemoveSourceBranch, mr.Squash, mr.SquashMessage = remove, squash, message
313 blocks := s.mergeBlocks(r, repo, mr)
314 force := choice.Force && role.CanManageSettings()
315 if len(blocks) > 0 {
316 if !force {
317 return mergeOutcome{}, fail(409, i18n.E("err.mrBlocked", strings.Join(blocks, " ")))
318 }
319 if !choice.Confirm {
320 return mergeOutcome{}, fail(409, i18n.E("mr.force.need"))
321 }
322 }
323 texts := s.mergeCloseTexts(r, repo, mr)
324 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
325 work, err := s.scratchDir("merge")
326 if err != nil {
327 return mergeOutcome{}, fail(500, err)
328 }
329 defer os.RemoveAll(work)
330 msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
331 if squash {
332 msg = strings.TrimSpace(message)
333 if msg == "" {
334 msg = mr.Title
335 }
336 }
337 s.mergingMR.Store(mr.ID, true)
338 defer s.mergingMR.Delete(mr.ID)
339 if err := s.postReceive(ctx, repo, user, dir, func() error {
340 return gitrepo.Merge(ctx, s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, user.Username, userEmail(user.Username), msg, squash, role, patterns)
341 }); err != nil {
342 return mergeOutcome{}, fail(400, err)
343 }
344 fresh, ferr := s.Store.MergeRequestByNumber(ctx, repo.ID, mr.Number)
345 if ferr != nil || fresh.Status != "merged" {
346 _ = s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged")
347 sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.TargetBranch)
348 body := ""
349 if shaLike(sha) {
350 body = sha
351 }
352 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", body)
353 mr.Status = "merged"
354 s.mrHook(repo, mr, user.Username, "merged", "")
355 s.closeIssueNumbers(ctx, repo, user, closingNumbers(texts...))
356 }
357 if force && len(blocks) > 0 {
358 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "forced", strings.Join(blocks, "\n"))
359 }
360 if !remove {
361 return mergeOutcome{Notice: "flash.merged", Skip: "disabled"}, nil
362 }
363 skip, deleted := s.deleteMergedSource(ctx, user, role, repo, mr.SourceBranch)
364 return mergedNotice(deleted, skip, mr.SourceBranch), nil
365}
366
367// sourceDeleteSkip zegt waarom de bronbranch moet blijven.
368// Een lege tekst betekent dat verwijderen mag.
369func sourceDeleteSkip(role access.Role, defaultBranch, name string, exists, protected bool) string {
370 if name == "" || !exists {
371 return "missing"
372 }
373 if name == defaultBranch {
374 return "default"
375 }
376 if protected {
377 return "protected"
378 }
379 if !role.CanWriteCode() {
380 return "forbidden"
381 }
382 return ""
383}
384
385// mergedSource is een bronbranch die na een gedetecteerde merge weg mag.
386type mergedSource struct {
387 user store.User
388 role access.Role
389 name string
390}
391
392// mergedSourcePlan zegt of deze merge de bronbranch hoort te verwijderen.
393// De voorwaarden zijn dezelfde als bij de mergeknop: de tak staat in deze
394// repo, is niet protected of de default, en de pusher mag code schrijven.
395func (s *Server) mergedSourcePlan(ctx context.Context, repo store.Repo, user store.User, mr store.MergeRequest) (mergedSource, bool) {
396 if !mr.RemoveSourceBranch || user.ID == 0 {
397 return mergedSource{}, false
398 }
399 name := strings.TrimSpace(mr.SourceBranch)
400 if name == "" || name == strings.TrimSpace(mr.TargetBranch) {
401 return mergedSource{}, false
402 }
403 role, err := s.repoRole(ctx, user, repo)
404 if err != nil {
405 return mergedSource{}, false
406 }
407 return mergedSource{user: user, role: role, name: name}, true
408}
409
410// dropMergedSources verwijdert bronbranches nadat de push zelf klaar is.
411func (s *Server) dropMergedSources(repo store.Repo, list []mergedSource) {
412 seen := map[string]bool{}
413 ctx := context.Background()
414 for _, item := range list {
415 if item.name == "" || seen[item.name] {
416 continue
417 }
418 seen[item.name] = true
419 s.deleteMergedSource(ctx, item.user, item.role, repo, item.name)
420 }
421}
422
423// deleteMergedSource haalt de bronbranch weg na een geslaagde merge.
424// Dat is een eigen push, zodat een mislukte verwijdering de merge-webhook niet uitwist.
425func (s *Server) deleteMergedSource(ctx context.Context, user store.User, role access.Role, repo store.Repo, name string) (skip string, deleted bool) {
426 name = strings.TrimSpace(name)
427 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
428 exists := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name) != ""
429 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
430 if skip = sourceDeleteSkip(role, repo.DefaultBranch, name, exists, access.BranchProtected(patterns, name)); skip != "" {
431 return skip, false
432 }
433 if err := s.postReceive(ctx, repo, user, dir, func() error {
434 return gitrepo.DeleteBranch(ctx, s.Git, dir, name)
435 }); err != nil {
436 return "error", false
437 }
438 return "", true
439}
440
441func mergedNotice(deleted bool, skip, branch string) mergeOutcome {
442 if deleted {
443 return mergeOutcome{Notice: "flash.mergedDeleted", Arg: branch, Removed: true}
444 }
445 key := map[string]string{
446 "protected": "flash.mergedKeptProtected",
447 "default": "flash.mergedKeptDefault",
448 "forbidden": "flash.mergedKeptRights",
449 "missing": "flash.mergedKeptMissing",
450 "error": "flash.mergedKeptError",
451 }[skip]
452 if key == "" {
453 return mergeOutcome{Notice: "flash.merged", Skip: skip}
454 }
455 return mergeOutcome{Notice: key, Arg: branch, Skip: skip}
456}
457
458func (s *Server) opCloseMR(ctx context.Context, user store.User, repo store.Repo, number int64, reopen bool) error {
459 role, err := s.repoRole(ctx, user, repo)
460 if err != nil {
461 return err
462 }
463 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
464 if err != nil {
465 return notFound(err)
466 }
467 if user.ID != mr.AuthorID && !role.CanManageSettings() {
468 return fail(403, i18n.E("err.forbidden"))
469 }
470 want, kind := "closed", "closed"
471 if reopen {
472 if mr.Status != "closed" {
473 return notFound(nil)
474 }
475 want, kind = "open", "reopened"
476 }
477 if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, want); err != nil {
478 return fail(400, err)
479 }
480 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, kind, "")
481 return nil
482}