BlueGit

timfa bluegit

Files

bluegit / internal / server / reviews.go

reviews.go

feat: goedkeuringen, reviews en heropenen van een merge request
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
ad4c7e2d History
reviews.go 7.9 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/http"
6 "strconv"
7
8 "gitlab.com/Timfa/bluegit/internal/access"
9 "gitlab.com/Timfa/bluegit/internal/store"
10)
11
12// ApprovalView is de goedkeuringsregel zoals de instellingen hem tonen.
13type ApprovalView struct {
14 MaintainerRequired bool
15 RequiredCount int
16 DevelopersApprove bool
17 Locked bool
18 GroupPath string
19 Maintainers int
20 Warn bool
21}
22
23// ReviewRow is één reviewer op de merge request.
24type ReviewRow struct {
25 UserID int64
26 Username string
27 Status string
28 Label string
29}
30
31func (s *Server) fillApproval(r *http.Request, v *View, repo store.Repo) {
32 pol, groupPath, err := s.Store.EffectiveApproval(r.Context(), repo)
33 if err != nil {
34 return
35 }
36 n, _ := s.Store.ProjectMaintainerCount(r.Context(), repo)
37 v.Approval = approvalView(pol, groupPath != "", groupPath, n)
38}
39
40func (s *Server) fillGroupApproval(r *http.Request, v *View, g store.Group) {
41 pol, err := s.Store.GetApproval(r.Context(), "group", g.ID)
42 if err != nil {
43 return
44 }
45 n, _ := s.Store.GroupMaintainerCount(r.Context(), g.ID)
46 v.Approval = approvalView(pol, false, "", n)
47}
48
49func approvalView(pol store.ApprovalPolicy, locked bool, groupPath string, maintainers int) *ApprovalView {
50 if pol.RequiredCount < 1 {
51 pol.RequiredCount = 1
52 }
53 return &ApprovalView{
54 MaintainerRequired: pol.MaintainerRequired,
55 RequiredCount: pol.RequiredCount,
56 DevelopersApprove: pol.DevelopersApprove,
57 Locked: locked,
58 GroupPath: groupPath,
59 Maintainers: maintainers,
60 Warn: pol.MaintainerRequired && pol.RequiredCount > maintainers,
61 }
62}
63
64func (s *Server) saveRepoApproval(w http.ResponseWriter, r *http.Request) {
65 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
66 if !ok || !s.csrfOK(w, r) {
67 return
68 }
69 _, groupPath, err := s.Store.EffectiveApproval(r.Context(), repo)
70 if err != nil {
71 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.trErr(r, err))
72 return
73 }
74 if groupPath != "" {
75 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.tr(r, "appr.locked"))
76 return
77 }
78 if err := s.Store.SaveApproval(r.Context(), "repo", repo.ID, approvalFromForm(r)); err != nil {
79 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.trErr(r, err))
80 return
81 }
82 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", s.tr(r, "flash.saved"), "")
83}
84
85func (s *Server) saveGroupApproval(w http.ResponseWriter, r *http.Request) {
86 g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
87 if !ok || !s.csrfOK(w, r) {
88 return
89 }
90 if err := s.Store.SaveApproval(r.Context(), "group", g.ID, approvalFromForm(r)); err != nil {
91 s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))
92 return
93 }
94 s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", s.tr(r, "flash.saved"), "")
95}
96
97func approvalFromForm(r *http.Request) store.ApprovalPolicy {
98 n, _ := strconv.Atoi(r.FormValue("required_count"))
99 return store.ApprovalPolicy{
100 MaintainerRequired: r.FormValue("maintainer_required") == "1",
101 RequiredCount: n,
102 DevelopersApprove: r.FormValue("developers_approve") == "1",
103 }
104}
105
106func (s *Server) reviewBlocks(r *http.Request, repo store.Repo, mr store.MergeRequest) []string {
107 if mr.Status != "open" {
108 return nil
109 }
110 pol, _, err := s.Store.EffectiveApproval(r.Context(), repo)
111 if err != nil {
112 return nil
113 }
114 var out []string
115 if pol.MaintainerRequired {
116 n := s.countApprovals(r.Context(), repo, mr, pol)
117 if n < pol.RequiredCount {
118 out = append(out, s.tr(r, "rev.summary.approvals", n, pol.RequiredCount))
119 }
120 }
121 reviews, err := s.Store.ListReviews(r.Context(), mr.ID)
122 if err != nil {
123 return out
124 }
125 for _, rev := range reviews {
126 switch rev.Status {
127 case "changes":
128 out = append(out, s.tr(r, "rev.summary.changes", rev.Username))
129 case "rejected":
130 out = append(out, s.tr(r, "rev.summary.rejected", rev.Username))
131 }
132 }
133 return out
134}
135
136func (s *Server) countApprovals(ctx context.Context, repo store.Repo, mr store.MergeRequest, pol store.ApprovalPolicy) int {
137 reviews, err := s.Store.ListReviews(ctx, mr.ID)
138 if err != nil {
139 return 0
140 }
141 n := 0
142 for _, rev := range reviews {
143 if rev.Status != "approved" || rev.UserID == mr.AuthorID {
144 continue
145 }
146 role, err := s.Store.EffectiveRole(ctx, rev.UserID, repo.ID)
147 if err != nil {
148 continue
149 }
150 if approvalCounts(role, pol) {
151 n++
152 }
153 }
154 return n
155}
156
157func approvalCounts(role access.Role, pol store.ApprovalPolicy) bool {
158 if role.CanManageSettings() {
159 return true
160 }
161 return pol.DevelopersApprove && role.CanWriteCode()
162}
163
164func (s *Server) fillReviews(r *http.Request, v *View, repo store.Repo, mr store.MergeRequest, role access.Role) {
165 reviews, _ := s.Store.ListReviews(r.Context(), mr.ID)
166 for _, rev := range reviews {
167 v.Reviews = append(v.Reviews, ReviewRow{
168 UserID: rev.UserID, Username: rev.Username, Status: rev.Status,
169 Label: s.tr(r, "rev."+rev.Status),
170 })
171 }
172 if v.User == nil || mr.Status != "open" {
173 return
174 }
175 v.CanReview = role.CanWriteCode()
176 pol, _, _ := s.Store.EffectiveApproval(r.Context(), repo)
177 v.CanApprove = v.CanReview && v.User.ID != mr.AuthorID && approvalCounts(role, pol)
178 v.CanDismiss = role.CanManageSettings()
179}
180
181func (s *Server) postReview(w http.ResponseWriter, r *http.Request) {
182 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
183 if !ok || !s.csrfOK(w, r) {
184 return
185 }
186 mr, err := s.mrFromRequest(r, repo.ID)
187 if err != nil || mr.Status != "open" {
188 http.NotFound(w, r)
189 return
190 }
191 back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
192 if !role.CanWriteCode() {
193 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
194 return
195 }
196 status := r.FormValue("status")
197 switch status {
198 case "approved", "changes", "rejected":
199 default:
200 s.redirect(w, r, back, "", s.tr(r, "rev.bad"))
201 return
202 }
203 if status == "approved" {
204 if u.ID == mr.AuthorID {
205 s.redirect(w, r, back, "", s.tr(r, "rev.own"))
206 return
207 }
208 pol, _, err := s.Store.EffectiveApproval(r.Context(), repo)
209 if err != nil || !approvalCounts(role, pol) {
210 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
211 return
212 }
213 }
214 if err := s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, u.ID, status); err != nil {
215 s.redirect(w, r, back, "", s.trErr(r, err))
216 return
217 }
218 s.redirect(w, r, back, s.tr(r, "flash.saved"), "")
219}
220
221func (s *Server) dismissReview(w http.ResponseWriter, r *http.Request) {
222 _, repo, role, ok := s.guard(w, r, access.RoleMaintainer)
223 if !ok || !s.csrfOK(w, r) {
224 return
225 }
226 mr, err := s.mrFromRequest(r, repo.ID)
227 if err != nil {
228 http.NotFound(w, r)
229 return
230 }
231 back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
232 if !role.CanManageSettings() {
233 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
234 return
235 }
236 userID, _ := strconv.ParseInt(r.FormValue("user_id"), 10, 64)
237 if userID == 0 {
238 s.redirect(w, r, back, "", s.tr(r, "rev.bad"))
239 return
240 }
241 if err := s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, userID, "dismissed"); err != nil {
242 s.redirect(w, r, back, "", s.trErr(r, err))
243 return
244 }
245 s.redirect(w, r, back, s.tr(r, "flash.saved"), "")
246}
247
248func (s *Server) reopenMR(w http.ResponseWriter, r *http.Request) {
249 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
250 if !ok || !s.csrfOK(w, r) {
251 return
252 }
253 mr, err := s.mrFromRequest(r, repo.ID)
254 if err != nil || mr.Status != "closed" {
255 http.NotFound(w, r)
256 return
257 }
258 if u.ID != mr.AuthorID && !role.CanManageSettings() {
259 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
260 return
261 }
262 _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "open")
263 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.reopened"), "")
264}
265
266// noteRequestsChanges zet Request changes als de reactie een suggestie bevat.
267func (s *Server) noteRequestsChanges(r *http.Request, repo store.Repo, mr store.MergeRequest, userID int64, suggestion string) {
268 if suggestion == "" || mr.Status != "open" {
269 return
270 }
271 _ = s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, userID, "changes")
272}