package server import ( "context" "net/http" "strconv" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/store" ) // ApprovalView is de goedkeuringsregel zoals de instellingen hem tonen. type ApprovalView struct { MaintainerRequired bool RequiredCount int DevelopersApprove bool Locked bool GroupPath string Maintainers int Warn bool WarnText string } // ReviewRow is één reviewer op de merge request. type ReviewRow struct { UserID int64 Username string Status string Label string } func (s *Server) fillApproval(r *http.Request, v *View, repo store.Repo) { pol, groupPath, err := s.Store.EffectiveApproval(r.Context(), repo) if err != nil { return } n, _ := s.Store.ProjectMaintainerCount(r.Context(), repo) v.Approval = approvalView(pol, groupPath != "", groupPath, n) s.paintApprovalWarn(r, v.Approval) } func (s *Server) fillGroupApproval(r *http.Request, v *View, g store.Group) { pol, err := s.Store.GetApproval(r.Context(), "group", g.ID) if err != nil { return } n, _ := s.Store.GroupMaintainerCount(r.Context(), g.ID) v.Approval = approvalView(pol, false, "", n) s.paintApprovalWarn(r, v.Approval) } func approvalView(pol store.ApprovalPolicy, locked bool, groupPath string, maintainers int) *ApprovalView { if pol.RequiredCount < 1 { pol.RequiredCount = 1 } return &ApprovalView{ MaintainerRequired: pol.MaintainerRequired, RequiredCount: pol.RequiredCount, DevelopersApprove: pol.DevelopersApprove, Locked: locked, GroupPath: groupPath, Maintainers: maintainers, Warn: pol.MaintainerRequired && pol.RequiredCount > maintainers, } } func (s *Server) paintApprovalWarn(r *http.Request, a *ApprovalView) { if a == nil || !a.Warn { return } a.WarnText = s.tr(r, approvalWarnKey(a.RequiredCount, a.Maintainers), a.RequiredCount, a.Maintainers) } func approvalWarnKey(required, maintainers int) string { req, who := "many", "many" if required == 1 { req = "one" } if maintainers == 1 { who = "one" } return "appr.warn." + req + "." + who } func (s *Server) saveRepoApproval(w http.ResponseWriter, r *http.Request) { _, repo, _, ok := s.guard(w, r, access.RoleMaintainer) if !ok || !s.csrfOK(w, r) { return } if err := s.opSaveRepoApproval(r.Context(), s.who(r).User, repo, approvalFromForm(r)); err != nil { s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.trErr(r, err)) return } s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", s.tr(r, "flash.saved"), "") } func (s *Server) saveGroupApproval(w http.ResponseWriter, r *http.Request) { g, _, ok := s.guardGroup(w, r, access.RoleMaintainer) if !ok || !s.csrfOK(w, r) { return } if err := s.opSaveGroupApproval(r.Context(), s.who(r).User, g, approvalFromForm(r)); err != nil { s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err)) return } s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", s.tr(r, "flash.saved"), "") } func approvalFromForm(r *http.Request) store.ApprovalPolicy { n, _ := strconv.Atoi(r.FormValue("required_count")) return store.ApprovalPolicy{ MaintainerRequired: r.FormValue("maintainer_required") == "1", RequiredCount: n, DevelopersApprove: r.FormValue("developers_approve") == "1", } } func (s *Server) reviewBlocks(r *http.Request, repo store.Repo, mr store.MergeRequest) []string { if mr.Status != "open" { return nil } pol, _, err := s.Store.EffectiveApproval(r.Context(), repo) if err != nil { return nil } var out []string if pol.MaintainerRequired { n := s.countApprovals(r.Context(), repo, mr, pol) if n < pol.RequiredCount { key := "rev.summary.approvals" if pol.RequiredCount == 1 { key = "rev.summary.approvals.one" } out = append(out, s.tr(r, key, n, pol.RequiredCount)) } } reviews, err := s.Store.ListReviews(r.Context(), mr.ID) if err != nil { return out } for _, rev := range reviews { switch rev.Status { case "changes": out = append(out, s.tr(r, "rev.summary.changes", rev.Username)) case "rejected": out = append(out, s.tr(r, "rev.summary.rejected", rev.Username)) } } return out } func (s *Server) countApprovals(ctx context.Context, repo store.Repo, mr store.MergeRequest, pol store.ApprovalPolicy) int { reviews, err := s.Store.ListReviews(ctx, mr.ID) if err != nil { return 0 } n := 0 for _, rev := range reviews { if rev.Status != "approved" || rev.UserID == mr.AuthorID { continue } role, err := s.Store.EffectiveRole(ctx, rev.UserID, repo.ID) if err != nil { continue } if approvalCounts(role, pol) { n++ } } return n } func approvalCounts(role access.Role, pol store.ApprovalPolicy) bool { if role.CanManageSettings() { return true } return pol.DevelopersApprove && role.CanWriteCode() } func (s *Server) fillReviews(r *http.Request, v *View, repo store.Repo, mr store.MergeRequest, role access.Role) { reviews, _ := s.Store.ListReviews(r.Context(), mr.ID) for _, rev := range reviews { v.Reviews = append(v.Reviews, ReviewRow{ UserID: rev.UserID, Username: rev.Username, Status: rev.Status, Label: s.tr(r, "rev."+rev.Status), }) } if v.User == nil || mr.Status != "open" { return } v.CanReview = role.CanWriteCode() pol, _, _ := s.Store.EffectiveApproval(r.Context(), repo) v.CanApprove = v.CanReview && v.User.ID != mr.AuthorID && approvalCounts(role, pol) v.CanDismiss = role.CanManageSettings() } func (s *Server) postReview(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } n, err := strconv.ParseInt(r.PathValue("number"), 10, 64) if err != nil { http.NotFound(w, r) return } back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number") if !s.uiOK(w, r, back, s.opReview(r.Context(), u, repo, n, r.FormValue("status"))) { return } s.redirect(w, r, back, s.tr(r, "flash.saved"), "") } func (s *Server) dismissReview(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleMaintainer) if !ok || !s.csrfOK(w, r) { return } n, err := strconv.ParseInt(r.PathValue("number"), 10, 64) if err != nil { http.NotFound(w, r) return } back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number") userID, _ := strconv.ParseInt(r.FormValue("user_id"), 10, 64) if !s.uiOK(w, r, back, s.opDismissReview(r.Context(), u, repo, n, userID)) { return } s.redirect(w, r, back, s.tr(r, "flash.saved"), "") } func (s *Server) reopenMR(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleReadonly) if !ok || !s.csrfOK(w, r) { return } n, err := strconv.ParseInt(r.PathValue("number"), 10, 64) if err != nil { http.NotFound(w, r) return } back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number") if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, true)) { return } s.redirect(w, r, back, s.tr(r, "flash.reopened"), "") } // noteRequestsChanges zet Request changes als de reactie een suggestie bevat. func (s *Server) noteRequestsChanges(r *http.Request, repo store.Repo, mr store.MergeRequest, userID int64, suggestion string) { if suggestion == "" || mr.Status != "open" { return } _ = s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, userID, "changes") }