package server import ( "context" "net/http" "os" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/store" ) func (s *Server) opCreateMR(ctx context.Context, user store.User, repo store.Repo, title, description, source, target string, draft bool) (store.MergeRequest, error) { role, err := s.repoRole(ctx, user, repo) if err != nil { return store.MergeRequest{}, err } if !role.CanWriteCode() { return store.MergeRequest{}, fail(403, i18n.E("err.forbidden")) } source = safeRev(source, "") target = safeRev(target, repo.DefaultBranch) if source == "" || source == target { return store.MergeRequest{}, fail(400, i18n.E("err.branches")) } mr, err := s.Store.CreateMergeRequest(ctx, repo.ID, user.ID, title, description, source, target) if err != nil { return store.MergeRequest{}, fail(400, err) } if draft { _ = s.Store.SetDraft(ctx, mr.ID, true) mr.Draft = true } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" { s.startOneMergePipeline(ctx, repo, sha, user.Username, "", mr) } s.mrHook(repo, mr, user.Username, "opened", "") s.recordContribution(user.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt) return mr, nil } func (s *Server) opUpdateMR(ctx context.Context, user store.User, repo store.Repo, number int64, title, description, labels string) (store.MergeRequest, error) { role, err := s.repoRole(ctx, user, repo) if err != nil { return store.MergeRequest{}, err } mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number) if err != nil { return store.MergeRequest{}, notFound(err) } if mr.Status != "open" || (user.ID != mr.AuthorID && !role.CanWriteCode()) { return store.MergeRequest{}, fail(403, i18n.E("err.forbidden")) } title = strings.TrimSpace(title) labels = normalizeLabels(labels) if err := s.Store.UpdateMergeRequest(ctx, mr.ID, title, description, labels); err != nil { return store.MergeRequest{}, fail(400, err) } if title != mr.Title { _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "retitled", title) } if labels != normalizeLabels(mr.Labels) { _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "relabeled", labels) } mr.Title, mr.Description, mr.Labels = title, description, labels return mr, nil } func (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) { ctx := r.Context() role, err := s.repoRole(ctx, user, repo) if err != nil { return store.Note{}, err } if !role.AtLeast(access.RoleReadonly) { return store.Note{}, fail(403, i18n.E("err.forbidden")) } mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number) if err != nil { return store.Note{}, notFound(err) } path, pathOK := repoPath(path) if !pathOK { return store.Note{}, fail(400, i18n.E("err.sugFile")) } if path == "" { if parent > 0 { note, err := s.Store.AddReply(ctx, repo.ID, mr.ID, user.ID, parent, body) if err != nil { return store.Note{}, fail(400, err) } s.mrHook(repo, mr, user.Username, "commented", body) return note, nil } note, err := s.Store.AddNote(ctx, repo.ID, mr.ID, user.ID, body) if err != nil { return store.Note{}, fail(400, err) } s.mrHook(repo, mr, user.Username, "commented", body) return note, nil } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) blob, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, path) if err != nil { return store.Note{}, fail(400, i18n.E("err.sugFile")) } lines := gitrepo.SplitLines(blob) if start < 1 || end < start || end > len(lines) { return store.Note{}, fail(400, i18n.E("err.sugLines")) } base := strings.Join(lines[start-1:end], "\n") suggestion, _ := gitrepo.ParseSuggestion(body) note, err := s.Store.AddLineNote(ctx, repo.ID, mr.ID, user.ID, body, path, start, end, suggestion, base) if err != nil { return store.Note{}, fail(400, err) } s.noteRequestsChanges(r, repo, mr, user.ID, suggestion) s.mrHook(repo, mr, user.Username, "commented", body) return note, nil } func (s *Server) opReview(ctx context.Context, user store.User, repo store.Repo, number int64, status string) error { role, err := s.repoRole(ctx, user, repo) if err != nil { return err } if !role.CanWriteCode() { return fail(403, i18n.E("err.forbidden")) } mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number) if err != nil || mr.Status != "open" { return notFound(err) } switch status { case "approved", "changes", "rejected": default: return fail(400, i18n.E("rev.bad")) } if status == "approved" { if user.ID == mr.AuthorID { return fail(400, i18n.E("rev.own")) } pol, _, err := s.Store.EffectiveApproval(ctx, repo) if err != nil || !approvalCounts(role, pol) { return fail(403, i18n.E("err.forbidden")) } } if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, user.ID, status); err != nil { return fail(400, err) } return nil } func (s *Server) opDismissReview(ctx context.Context, user store.User, repo store.Repo, number, targetUser int64) error { role, err := s.repoRole(ctx, user, repo) if err != nil { return err } if !role.CanManageSettings() { return fail(403, i18n.E("err.forbidden")) } mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number) if err != nil { return notFound(err) } if targetUser == 0 { return fail(400, i18n.E("rev.bad")) } if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, targetUser, "dismissed"); err != nil { return fail(400, err) } return nil } func (s *Server) opApplySuggestions(ctx context.Context, user store.User, repo store.Repo, number int64, title, description string, ids []int64) error { role, err := s.repoRole(ctx, user, repo) if err != nil { return err } mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number) if err != nil || mr.Status != "open" { return notFound(err) } patterns, err := s.Store.ProtectedPatterns(ctx, repo.ID) if err != nil { return fail(400, err) } if !role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) { return fail(403, i18n.E("err.sugBranch", mr.SourceBranch)) } title = strings.TrimSpace(title) if title == "" || strings.ContainsAny(title, "\r\n") { return fail(400, i18n.E("err.sugTitle")) } notes, err := s.Store.ListNotes(ctx, mr.ID) if err != nil { return fail(400, err) } byID := map[int64]store.Note{} for _, n := range notes { byID[n.ID] = n } var edits []gitrepo.SuggestionEdit seen := map[int64]bool{} for _, id := range ids { if seen[id] { continue } seen[id] = true n, ok := byID[id] if !ok || n.Suggestion == "" || n.FilePath == "" { return fail(400, i18n.E("err.sugGone")) } edits = append(edits, gitrepo.SuggestionEdit{ Path: n.FilePath, Start: n.LineStart, End: n.LineEnd, Base: n.BaseText, Replacement: n.Suggestion, }) } if len(edits) == 0 { return fail(400, i18n.E("err.sugEmpty")) } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) files := map[string]string{} for _, e := range edits { if _, ok := files[e.Path]; ok { continue } body, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, e.Path) if err != nil { return fail(400, i18n.E("err.sugConflict", e.Path, e.Start, e.End)) } files[e.Path] = body } updated, err := gitrepo.ApplySuggestions(files, edits) if err != nil { return fail(400, err) } branch := safeRev(mr.SourceBranch, "") if branch == "" { return fail(400, i18n.E("err.sugBranch", mr.SourceBranch)) } work, err := s.scratchDir("suggest") if err != nil { return fail(500, err) } defer os.RemoveAll(work) if err := s.postReceive(ctx, repo, user, dir, func() error { return gitrepo.CommitOnBranch(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, updated, role, patterns) }); err != nil { return fail(400, err) } return nil } // mergeChoice is de keuze uit het formulier of de API. // FromForm betekent dat een browser de vakjes postte: een ontbrekend vakje staat uit. // De API laat FromForm uit en gebruikt de pointers. nil houdt de opgeslagen waarde. type mergeChoice struct { FromForm bool Remove *bool Squash *bool Message *string Force bool Confirm bool } // mergeOutcome vertelt de pagina en de API wat er na de merge met de bronbranch gebeurde. type mergeOutcome struct { Notice string Arg string Removed bool Skip string } func applyMergeChoice(mr store.MergeRequest, choice mergeChoice) (remove, squash bool, message string) { remove, squash, message = mr.RemoveSourceBranch, mr.Squash, mr.SquashMessage if choice.FromForm { remove, squash, message = false, false, "" } if choice.Remove != nil { remove = *choice.Remove } if choice.Squash != nil { squash = *choice.Squash } if choice.Message != nil { message = *choice.Message } return remove, squash, message } func (s *Server) opMergeMR(r *http.Request, user store.User, repo store.Repo, number int64, choice mergeChoice) (mergeOutcome, error) { ctx := r.Context() role, err := s.repoRole(ctx, user, repo) if err != nil { return mergeOutcome{}, err } mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number) if err != nil || mr.Status != "open" { return mergeOutcome{}, notFound(err) } patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID) if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) { return mergeOutcome{}, fail(403, i18n.E("err.targetAccess")) } remove, squash, message := applyMergeChoice(mr, choice) if err := s.Store.SetMergeOptions(ctx, mr.ID, remove, squash, message); err != nil { return mergeOutcome{}, fail(400, err) } mr.RemoveSourceBranch, mr.Squash, mr.SquashMessage = remove, squash, message blocks := s.mergeBlocks(r, repo, mr) force := choice.Force && role.CanManageSettings() if len(blocks) > 0 { if !force { return mergeOutcome{}, fail(409, i18n.E("err.mrBlocked", strings.Join(blocks, " "))) } if !choice.Confirm { return mergeOutcome{}, fail(409, i18n.E("mr.force.need")) } } texts := s.mergeCloseTexts(r, repo, mr) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) work, err := s.scratchDir("merge") if err != nil { return mergeOutcome{}, fail(500, err) } defer os.RemoveAll(work) msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'" if squash { msg = strings.TrimSpace(message) if msg == "" { msg = mr.Title } } s.mergingMR.Store(mr.ID, true) defer s.mergingMR.Delete(mr.ID) if err := s.postReceive(ctx, repo, user, dir, func() error { return gitrepo.Merge(ctx, s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, user.Username, userEmail(user.Username), msg, squash, role, patterns) }); err != nil { return mergeOutcome{}, fail(400, err) } fresh, ferr := s.Store.MergeRequestByNumber(ctx, repo.ID, mr.Number) if ferr != nil || fresh.Status != "merged" { _ = s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged") _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", "") mr.Status = "merged" s.mrHook(repo, mr, user.Username, "merged", "") s.closeIssueNumbers(ctx, repo, user, closingNumbers(texts...)) } if force && len(blocks) > 0 { _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "forced", strings.Join(blocks, "\n")) } if !remove { return mergeOutcome{Notice: "flash.merged", Skip: "disabled"}, nil } skip, deleted := s.deleteMergedSource(ctx, user, role, repo, mr.SourceBranch) return mergedNotice(deleted, skip, mr.SourceBranch), nil } // sourceDeleteSkip zegt waarom de bronbranch moet blijven. // Een lege tekst betekent dat verwijderen mag. func sourceDeleteSkip(role access.Role, defaultBranch, name string, exists, protected bool) string { if name == "" || !exists { return "missing" } if name == defaultBranch { return "default" } if protected { return "protected" } if !role.CanWriteCode() { return "forbidden" } return "" } // mergedSource is een bronbranch die na een gedetecteerde merge weg mag. type mergedSource struct { user store.User role access.Role name string } // mergedSourcePlan zegt of deze merge de bronbranch hoort te verwijderen. // De voorwaarden zijn dezelfde als bij de mergeknop: de tak staat in deze // repo, is niet protected of de default, en de pusher mag code schrijven. func (s *Server) mergedSourcePlan(ctx context.Context, repo store.Repo, user store.User, mr store.MergeRequest) (mergedSource, bool) { if !mr.RemoveSourceBranch || user.ID == 0 { return mergedSource{}, false } name := strings.TrimSpace(mr.SourceBranch) if name == "" || name == strings.TrimSpace(mr.TargetBranch) { return mergedSource{}, false } role, err := s.repoRole(ctx, user, repo) if err != nil { return mergedSource{}, false } return mergedSource{user: user, role: role, name: name}, true } // dropMergedSources verwijdert bronbranches nadat de push zelf klaar is. func (s *Server) dropMergedSources(repo store.Repo, list []mergedSource) { seen := map[string]bool{} ctx := context.Background() for _, item := range list { if item.name == "" || seen[item.name] { continue } seen[item.name] = true s.deleteMergedSource(ctx, item.user, item.role, repo, item.name) } } // deleteMergedSource haalt de bronbranch weg na een geslaagde merge. // Dat is een eigen push, zodat een mislukte verwijdering de merge-webhook niet uitwist. func (s *Server) deleteMergedSource(ctx context.Context, user store.User, role access.Role, repo store.Repo, name string) (skip string, deleted bool) { name = strings.TrimSpace(name) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) exists := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name) != "" patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID) if skip = sourceDeleteSkip(role, repo.DefaultBranch, name, exists, access.BranchProtected(patterns, name)); skip != "" { return skip, false } if err := s.postReceive(ctx, repo, user, dir, func() error { return gitrepo.DeleteBranch(ctx, s.Git, dir, name) }); err != nil { return "error", false } return "", true } func mergedNotice(deleted bool, skip, branch string) mergeOutcome { if deleted { return mergeOutcome{Notice: "flash.mergedDeleted", Arg: branch, Removed: true} } key := map[string]string{ "protected": "flash.mergedKeptProtected", "default": "flash.mergedKeptDefault", "forbidden": "flash.mergedKeptRights", "missing": "flash.mergedKeptMissing", "error": "flash.mergedKeptError", }[skip] if key == "" { return mergeOutcome{Notice: "flash.merged", Skip: skip} } return mergeOutcome{Notice: key, Arg: branch, Skip: skip} } func (s *Server) opCloseMR(ctx context.Context, user store.User, repo store.Repo, number int64, reopen bool) error { role, err := s.repoRole(ctx, user, repo) if err != nil { return err } mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number) if err != nil { return notFound(err) } if user.ID != mr.AuthorID && !role.CanManageSettings() { return fail(403, i18n.E("err.forbidden")) } want, kind := "closed", "closed" if reopen { if mr.Status != "closed" { return notFound(nil) } want, kind = "open", "reopened" } if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, want); err != nil { return fail(400, err) } _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, kind, "") return nil }