BlueGit

timfa bluegit

Files

bluegit / internal / server / ops_mr.go

ops_mr.go

feat: stuur volledige details mee in webhook-payloads
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
3ca4d219 History
ops_mr.go 9.9 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/http"
6 "os"
7 "strconv"
8 "strings"
9
10 "gitlab.com/Timfa/bluegit/internal/access"
11 "gitlab.com/Timfa/bluegit/internal/gitrepo"
12 "gitlab.com/Timfa/bluegit/internal/i18n"
13 "gitlab.com/Timfa/bluegit/internal/store"
14)
15
16func (s *Server) opCreateMR(ctx context.Context, user store.User, repo store.Repo, title, description, source, target string, draft bool) (store.MergeRequest, error) {
17 role, err := s.repoRole(ctx, user, repo)
18 if err != nil {
19 return store.MergeRequest{}, err
20 }
21 if !role.CanWriteCode() {
22 return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
23 }
24 source = safeRev(source, "")
25 target = safeRev(target, repo.DefaultBranch)
26 if source == "" || source == target {
27 return store.MergeRequest{}, fail(400, i18n.E("err.branches"))
28 }
29 mr, err := s.Store.CreateMergeRequest(ctx, repo.ID, user.ID, title, description, source, target)
30 if err != nil {
31 return store.MergeRequest{}, fail(400, err)
32 }
33 if draft {
34 _ = s.Store.SetDraft(ctx, mr.ID, true)
35 mr.Draft = true
36 }
37 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
38 if sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" {
39 s.startOneMergePipeline(ctx, repo, sha, user.Username, "", mr)
40 }
41 s.mrHook(repo, mr, user.Username, "opened", "")
42 s.recordContribution(user.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)
43 return mr, nil
44}
45
46func (s *Server) opUpdateMR(ctx context.Context, user store.User, repo store.Repo, number int64, title, description, labels string) (store.MergeRequest, error) {
47 role, err := s.repoRole(ctx, user, repo)
48 if err != nil {
49 return store.MergeRequest{}, err
50 }
51 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
52 if err != nil {
53 return store.MergeRequest{}, notFound(err)
54 }
55 if mr.Status != "open" || (user.ID != mr.AuthorID && !role.CanWriteCode()) {
56 return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
57 }
58 title = strings.TrimSpace(title)
59 labels = normalizeLabels(labels)
60 if err := s.Store.UpdateMergeRequest(ctx, mr.ID, title, description, labels); err != nil {
61 return store.MergeRequest{}, fail(400, err)
62 }
63 if title != mr.Title {
64 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "retitled", title)
65 }
66 if labels != normalizeLabels(mr.Labels) {
67 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "relabeled", labels)
68 }
69 mr.Title, mr.Description, mr.Labels = title, description, labels
70 return mr, nil
71}
72
73func (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) {
74 ctx := r.Context()
75 role, err := s.repoRole(ctx, user, repo)
76 if err != nil {
77 return store.Note{}, err
78 }
79 if !role.AtLeast(access.RoleReadonly) {
80 return store.Note{}, fail(403, i18n.E("err.forbidden"))
81 }
82 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
83 if err != nil {
84 return store.Note{}, notFound(err)
85 }
86 path, pathOK := repoPath(path)
87 if !pathOK {
88 return store.Note{}, fail(400, i18n.E("err.sugFile"))
89 }
90 if path == "" {
91 if parent > 0 {
92 note, err := s.Store.AddReply(ctx, repo.ID, mr.ID, user.ID, parent, body)
93 if err != nil {
94 return store.Note{}, fail(400, err)
95 }
96 s.mrHook(repo, mr, user.Username, "commented", body)
97 return note, nil
98 }
99 note, err := s.Store.AddNote(ctx, repo.ID, mr.ID, user.ID, body)
100 if err != nil {
101 return store.Note{}, fail(400, err)
102 }
103 s.mrHook(repo, mr, user.Username, "commented", body)
104 return note, nil
105 }
106 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
107 blob, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, path)
108 if err != nil {
109 return store.Note{}, fail(400, i18n.E("err.sugFile"))
110 }
111 lines := gitrepo.SplitLines(blob)
112 if start < 1 || end < start || end > len(lines) {
113 return store.Note{}, fail(400, i18n.E("err.sugLines"))
114 }
115 base := strings.Join(lines[start-1:end], "\n")
116 suggestion, _ := gitrepo.ParseSuggestion(body)
117 note, err := s.Store.AddLineNote(ctx, repo.ID, mr.ID, user.ID, body, path, start, end, suggestion, base)
118 if err != nil {
119 return store.Note{}, fail(400, err)
120 }
121 s.noteRequestsChanges(r, repo, mr, user.ID, suggestion)
122 s.mrHook(repo, mr, user.Username, "commented", body)
123 return note, nil
124}
125
126func (s *Server) opReview(ctx context.Context, user store.User, repo store.Repo, number int64, status string) error {
127 role, err := s.repoRole(ctx, user, repo)
128 if err != nil {
129 return err
130 }
131 if !role.CanWriteCode() {
132 return fail(403, i18n.E("err.forbidden"))
133 }
134 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
135 if err != nil || mr.Status != "open" {
136 return notFound(err)
137 }
138 switch status {
139 case "approved", "changes", "rejected":
140 default:
141 return fail(400, i18n.E("rev.bad"))
142 }
143 if status == "approved" {
144 if user.ID == mr.AuthorID {
145 return fail(400, i18n.E("rev.own"))
146 }
147 pol, _, err := s.Store.EffectiveApproval(ctx, repo)
148 if err != nil || !approvalCounts(role, pol) {
149 return fail(403, i18n.E("err.forbidden"))
150 }
151 }
152 if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, user.ID, status); err != nil {
153 return fail(400, err)
154 }
155 return nil
156}
157
158func (s *Server) opDismissReview(ctx context.Context, user store.User, repo store.Repo, number, targetUser int64) error {
159 role, err := s.repoRole(ctx, user, repo)
160 if err != nil {
161 return err
162 }
163 if !role.CanManageSettings() {
164 return fail(403, i18n.E("err.forbidden"))
165 }
166 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
167 if err != nil {
168 return notFound(err)
169 }
170 if targetUser == 0 {
171 return fail(400, i18n.E("rev.bad"))
172 }
173 if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, targetUser, "dismissed"); err != nil {
174 return fail(400, err)
175 }
176 return nil
177}
178
179func (s *Server) opApplySuggestions(ctx context.Context, user store.User, repo store.Repo, number int64, title, description string, ids []int64) error {
180 role, err := s.repoRole(ctx, user, repo)
181 if err != nil {
182 return err
183 }
184 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
185 if err != nil || mr.Status != "open" {
186 return notFound(err)
187 }
188 patterns, err := s.Store.ProtectedPatterns(ctx, repo.ID)
189 if err != nil {
190 return fail(400, err)
191 }
192 if !role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) {
193 return fail(403, i18n.E("err.sugBranch", mr.SourceBranch))
194 }
195 title = strings.TrimSpace(title)
196 if title == "" || strings.ContainsAny(title, "\r\n") {
197 return fail(400, i18n.E("err.sugTitle"))
198 }
199 notes, err := s.Store.ListNotes(ctx, mr.ID)
200 if err != nil {
201 return fail(400, err)
202 }
203 byID := map[int64]store.Note{}
204 for _, n := range notes {
205 byID[n.ID] = n
206 }
207 var edits []gitrepo.SuggestionEdit
208 seen := map[int64]bool{}
209 for _, id := range ids {
210 if seen[id] {
211 continue
212 }
213 seen[id] = true
214 n, ok := byID[id]
215 if !ok || n.Suggestion == "" || n.FilePath == "" {
216 return fail(400, i18n.E("err.sugGone"))
217 }
218 edits = append(edits, gitrepo.SuggestionEdit{
219 Path: n.FilePath, Start: n.LineStart, End: n.LineEnd, Base: n.BaseText, Replacement: n.Suggestion,
220 })
221 }
222 if len(edits) == 0 {
223 return fail(400, i18n.E("err.sugEmpty"))
224 }
225 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
226 files := map[string]string{}
227 for _, e := range edits {
228 if _, ok := files[e.Path]; ok {
229 continue
230 }
231 body, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, e.Path)
232 if err != nil {
233 return fail(400, i18n.E("err.sugConflict", e.Path, e.Start, e.End))
234 }
235 files[e.Path] = body
236 }
237 updated, err := gitrepo.ApplySuggestions(files, edits)
238 if err != nil {
239 return fail(400, err)
240 }
241 branch := safeRev(mr.SourceBranch, "")
242 if branch == "" {
243 return fail(400, i18n.E("err.sugBranch", mr.SourceBranch))
244 }
245 work, err := s.scratchDir("suggest")
246 if err != nil {
247 return fail(500, err)
248 }
249 defer os.RemoveAll(work)
250 if err := s.postReceive(ctx, repo, user, dir, func() error {
251 return gitrepo.CommitOnBranch(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, updated, role, patterns)
252 }); err != nil {
253 return fail(400, err)
254 }
255 return nil
256}
257
258func (s *Server) opMergeMR(r *http.Request, user store.User, repo store.Repo, number int64) error {
259 ctx := r.Context()
260 role, err := s.repoRole(ctx, user, repo)
261 if err != nil {
262 return err
263 }
264 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
265 if err != nil || mr.Status != "open" {
266 return notFound(err)
267 }
268 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
269 if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
270 return fail(403, i18n.E("err.targetAccess"))
271 }
272 if blocks := s.mergeBlocks(r, repo, mr); len(blocks) > 0 {
273 return fail(409, i18n.E("err.mrBlocked", blocks[0]))
274 }
275 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
276 work, err := s.scratchDir("merge")
277 if err != nil {
278 return fail(500, err)
279 }
280 defer os.RemoveAll(work)
281 msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
282 if err := s.postReceive(ctx, repo, user, dir, func() error {
283 return gitrepo.Merge(ctx, s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, user.Username, userEmail(user.Username), msg, role, patterns)
284 }); err != nil {
285 return fail(400, err)
286 }
287 _ = s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged")
288 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", "")
289 mr.Status = "merged"
290 s.mrHook(repo, mr, user.Username, "merged", "")
291 return nil
292}
293
294func (s *Server) opCloseMR(ctx context.Context, user store.User, repo store.Repo, number int64, reopen bool) error {
295 role, err := s.repoRole(ctx, user, repo)
296 if err != nil {
297 return err
298 }
299 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
300 if err != nil {
301 return notFound(err)
302 }
303 if user.ID != mr.AuthorID && !role.CanManageSettings() {
304 return fail(403, i18n.E("err.forbidden"))
305 }
306 want, kind := "closed", "closed"
307 if reopen {
308 if mr.Status != "closed" {
309 return notFound(nil)
310 }
311 want, kind = "open", "reopened"
312 }
313 if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, want); err != nil {
314 return fail(400, err)
315 }
316 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, kind, "")
317 return nil
318}