BlueGit

timfa bluegit

Files

bluegit / internal / server / reviews.go

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