| 1 | package server |
| 2 | |
| 3 | import ( |
| 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. |
| 13 | type 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. |
| 24 | type ReviewRow struct { |
| 25 | UserID int64 |
| 26 | Username string |
| 27 | Status string |
| 28 | Label string |
| 29 | } |
| 30 | |
| 31 | func (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 | |
| 40 | func (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 | |
| 49 | func 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 | |
| 64 | func (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 | |
| 85 | func (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 | |
| 97 | func 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 | |
| 106 | func (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 | |
| 136 | func (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 | |
| 157 | func approvalCounts(role access.Role, pol store.ApprovalPolicy) bool { |
| 158 | if role.CanManageSettings() { |
| 159 | return true |
| 160 | } |
| 161 | return pol.DevelopersApprove && role.CanWriteCode() |
| 162 | } |
| 163 | |
| 164 | func (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 | |
| 181 | func (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 | |
| 221 | func (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 | |
| 248 | func (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. |
| 267 | func (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 | } |