BlueGit

timfa bluegit

Files

bluegit / internal / server / ops_mr.go

ops_mr.go

fix: toon mergeblokkades en markeer een al gepushte merge
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
81edde89 History
ops_mr.go 10.4 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
257func (s *Server) opMergeMR(r *http.Request, user store.User, repo store.Repo, number int64) error {
258 ctx := r.Context()
259 role, err := s.repoRole(ctx, user, repo)
260 if err != nil {
261 return err
262 }
263 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
264 if err != nil || mr.Status != "open" {
265 return notFound(err)
266 }
267 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
268 if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
269 return fail(403, i18n.E("err.targetAccess"))
270 }
271 blocks := s.mergeBlocks(r, repo, mr)
272 force := r.FormValue("force") == "1" && role.CanManageSettings()
273 if len(blocks) > 0 {
274 if !force {
275 return fail(409, i18n.E("err.mrBlocked", strings.Join(blocks, " ")))
276 }
277 if r.FormValue("confirm_force") != "1" {
278 return fail(409, i18n.E("mr.force.need"))
279 }
280 }
281 texts := s.mergeCloseTexts(r, repo, mr)
282 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
283 work, err := s.scratchDir("merge")
284 if err != nil {
285 return fail(500, err)
286 }
287 defer os.RemoveAll(work)
288 msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
289 if err := s.postReceive(ctx, repo, user, dir, func() error {
290 return gitrepo.Merge(ctx, s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, user.Username, userEmail(user.Username), msg, role, patterns)
291 }); err != nil {
292 return fail(400, err)
293 }
294 fresh, ferr := s.Store.MergeRequestByNumber(ctx, repo.ID, mr.Number)
295 if ferr != nil || fresh.Status != "merged" {
296 _ = s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged")
297 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", "")
298 mr.Status = "merged"
299 s.mrHook(repo, mr, user.Username, "merged", "")
300 s.closeIssueNumbers(ctx, repo, user, closingNumbers(texts...))
301 }
302 if force && len(blocks) > 0 {
303 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "forced", strings.Join(blocks, "\n"))
304 }
305 return nil
306}
307
308func (s *Server) opCloseMR(ctx context.Context, user store.User, repo store.Repo, number int64, reopen bool) error {
309 role, err := s.repoRole(ctx, user, repo)
310 if err != nil {
311 return err
312 }
313 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
314 if err != nil {
315 return notFound(err)
316 }
317 if user.ID != mr.AuthorID && !role.CanManageSettings() {
318 return fail(403, i18n.E("err.forbidden"))
319 }
320 want, kind := "closed", "closed"
321 if reopen {
322 if mr.Status != "closed" {
323 return notFound(nil)
324 }
325 want, kind = "open", "reopened"
326 }
327 if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, want); err != nil {
328 return fail(400, err)
329 }
330 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, kind, "")
331 return nil
332}