BlueGit

timfa bluegit

Files

bluegit / internal / server / ops_mr.go

ops_mr.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
ops_mr.go 9.8 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 num := strconv.FormatInt(mr.Number, 10)
42 s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", user.Username, i18n.T(i18n.EN, "hook.mr", num, mr.Title), repoURL(repo)+"/-/merge-requests/"+num))
43 s.recordContribution(user.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)
44 return mr, nil
45}
46
47func (s *Server) opUpdateMR(ctx context.Context, user store.User, repo store.Repo, number int64, title, description, labels string) (store.MergeRequest, error) {
48 role, err := s.repoRole(ctx, user, repo)
49 if err != nil {
50 return store.MergeRequest{}, err
51 }
52 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
53 if err != nil {
54 return store.MergeRequest{}, notFound(err)
55 }
56 if mr.Status != "open" || (user.ID != mr.AuthorID && !role.CanWriteCode()) {
57 return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
58 }
59 title = strings.TrimSpace(title)
60 labels = normalizeLabels(labels)
61 if err := s.Store.UpdateMergeRequest(ctx, mr.ID, title, description, labels); err != nil {
62 return store.MergeRequest{}, fail(400, err)
63 }
64 if title != mr.Title {
65 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "retitled", title)
66 }
67 if labels != normalizeLabels(mr.Labels) {
68 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "relabeled", labels)
69 }
70 mr.Title, mr.Description, mr.Labels = title, description, labels
71 return mr, nil
72}
73
74func (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) {
75 ctx := r.Context()
76 role, err := s.repoRole(ctx, user, repo)
77 if err != nil {
78 return store.Note{}, err
79 }
80 if !role.AtLeast(access.RoleReadonly) {
81 return store.Note{}, fail(403, i18n.E("err.forbidden"))
82 }
83 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
84 if err != nil {
85 return store.Note{}, notFound(err)
86 }
87 path, pathOK := repoPath(path)
88 if !pathOK {
89 return store.Note{}, fail(400, i18n.E("err.sugFile"))
90 }
91 if path == "" {
92 if parent > 0 {
93 note, err := s.Store.AddReply(ctx, repo.ID, mr.ID, user.ID, parent, body)
94 if err != nil {
95 return store.Note{}, fail(400, err)
96 }
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 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 return note, nil
122}
123
124func (s *Server) opReview(ctx context.Context, user store.User, repo store.Repo, number int64, status string) error {
125 role, err := s.repoRole(ctx, user, repo)
126 if err != nil {
127 return err
128 }
129 if !role.CanWriteCode() {
130 return fail(403, i18n.E("err.forbidden"))
131 }
132 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
133 if err != nil || mr.Status != "open" {
134 return notFound(err)
135 }
136 switch status {
137 case "approved", "changes", "rejected":
138 default:
139 return fail(400, i18n.E("rev.bad"))
140 }
141 if status == "approved" {
142 if user.ID == mr.AuthorID {
143 return fail(400, i18n.E("rev.own"))
144 }
145 pol, _, err := s.Store.EffectiveApproval(ctx, repo)
146 if err != nil || !approvalCounts(role, pol) {
147 return fail(403, i18n.E("err.forbidden"))
148 }
149 }
150 if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, user.ID, status); err != nil {
151 return fail(400, err)
152 }
153 return nil
154}
155
156func (s *Server) opDismissReview(ctx context.Context, user store.User, repo store.Repo, number, targetUser int64) error {
157 role, err := s.repoRole(ctx, user, repo)
158 if err != nil {
159 return err
160 }
161 if !role.CanManageSettings() {
162 return fail(403, i18n.E("err.forbidden"))
163 }
164 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
165 if err != nil {
166 return notFound(err)
167 }
168 if targetUser == 0 {
169 return fail(400, i18n.E("rev.bad"))
170 }
171 if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, targetUser, "dismissed"); err != nil {
172 return fail(400, err)
173 }
174 return nil
175}
176
177func (s *Server) opApplySuggestions(ctx context.Context, user store.User, repo store.Repo, number int64, title, description string, ids []int64) error {
178 role, err := s.repoRole(ctx, user, repo)
179 if err != nil {
180 return err
181 }
182 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
183 if err != nil || mr.Status != "open" {
184 return notFound(err)
185 }
186 patterns, err := s.Store.ProtectedPatterns(ctx, repo.ID)
187 if err != nil {
188 return fail(400, err)
189 }
190 if !role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) {
191 return fail(403, i18n.E("err.sugBranch", mr.SourceBranch))
192 }
193 title = strings.TrimSpace(title)
194 if title == "" || strings.ContainsAny(title, "\r\n") {
195 return fail(400, i18n.E("err.sugTitle"))
196 }
197 notes, err := s.Store.ListNotes(ctx, mr.ID)
198 if err != nil {
199 return fail(400, err)
200 }
201 byID := map[int64]store.Note{}
202 for _, n := range notes {
203 byID[n.ID] = n
204 }
205 var edits []gitrepo.SuggestionEdit
206 seen := map[int64]bool{}
207 for _, id := range ids {
208 if seen[id] {
209 continue
210 }
211 seen[id] = true
212 n, ok := byID[id]
213 if !ok || n.Suggestion == "" || n.FilePath == "" {
214 return fail(400, i18n.E("err.sugGone"))
215 }
216 edits = append(edits, gitrepo.SuggestionEdit{
217 Path: n.FilePath, Start: n.LineStart, End: n.LineEnd, Base: n.BaseText, Replacement: n.Suggestion,
218 })
219 }
220 if len(edits) == 0 {
221 return fail(400, i18n.E("err.sugEmpty"))
222 }
223 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
224 files := map[string]string{}
225 for _, e := range edits {
226 if _, ok := files[e.Path]; ok {
227 continue
228 }
229 body, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, e.Path)
230 if err != nil {
231 return fail(400, i18n.E("err.sugConflict", e.Path, e.Start, e.End))
232 }
233 files[e.Path] = body
234 }
235 updated, err := gitrepo.ApplySuggestions(files, edits)
236 if err != nil {
237 return fail(400, err)
238 }
239 branch := safeRev(mr.SourceBranch, "")
240 if branch == "" {
241 return fail(400, i18n.E("err.sugBranch", mr.SourceBranch))
242 }
243 work, err := s.scratchDir("suggest")
244 if err != nil {
245 return fail(500, err)
246 }
247 defer os.RemoveAll(work)
248 if err := s.postReceive(ctx, repo, user, dir, func() error {
249 return gitrepo.CommitOnBranch(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, updated, role, patterns)
250 }); err != nil {
251 return fail(400, err)
252 }
253 return nil
254}
255
256func (s *Server) opMergeMR(r *http.Request, user store.User, repo store.Repo, number int64) error {
257 ctx := r.Context()
258 role, err := s.repoRole(ctx, user, repo)
259 if err != nil {
260 return err
261 }
262 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
263 if err != nil || mr.Status != "open" {
264 return notFound(err)
265 }
266 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
267 if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
268 return fail(403, i18n.E("err.targetAccess"))
269 }
270 if blocks := s.mergeBlocks(r, repo, mr); len(blocks) > 0 {
271 return fail(409, i18n.E("err.mrBlocked", blocks[0]))
272 }
273 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
274 work, err := s.scratchDir("merge")
275 if err != nil {
276 return fail(500, err)
277 }
278 defer os.RemoveAll(work)
279 msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
280 if err := s.postReceive(ctx, repo, user, dir, func() error {
281 return gitrepo.Merge(ctx, s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, user.Username, userEmail(user.Username), msg, role, patterns)
282 }); err != nil {
283 return fail(400, err)
284 }
285 _ = s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged")
286 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", "")
287 return nil
288}
289
290func (s *Server) opCloseMR(ctx context.Context, user store.User, repo store.Repo, number int64, reopen bool) error {
291 role, err := s.repoRole(ctx, user, repo)
292 if err != nil {
293 return err
294 }
295 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
296 if err != nil {
297 return notFound(err)
298 }
299 if user.ID != mr.AuthorID && !role.CanManageSettings() {
300 return fail(403, i18n.E("err.forbidden"))
301 }
302 want, kind := "closed", "closed"
303 if reopen {
304 if mr.Status != "closed" {
305 return notFound(nil)
306 }
307 want, kind = "open", "reopened"
308 }
309 if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, want); err != nil {
310 return fail(400, err)
311 }
312 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, kind, "")
313 return nil
314}