mirror of
https://github.com/go-gitea/gitea.git
synced 2024-12-13 07:59:50 +08:00
5f82ead13c
## Purpose This is a refactor toward building an abstraction over managing git repositories. Afterwards, it does not matter anymore if they are stored on the local disk or somewhere remote. ## What this PR changes We used `git.OpenRepository` everywhere previously. Now, we should split them into two distinct functions: Firstly, there are temporary repositories which do not change: ```go git.OpenRepository(ctx, diskPath) ``` Gitea managed repositories having a record in the database in the `repository` table are moved into the new package `gitrepo`: ```go gitrepo.OpenRepository(ctx, repo_model.Repo) ``` Why is `repo_model.Repository` the second parameter instead of file path? Because then we can easily adapt our repository storage strategy. The repositories can be stored locally, however, they could just as well be stored on a remote server. ## Further changes in other PRs - A Git Command wrapper on package `gitrepo` could be created. i.e. `NewCommand(ctx, repo_model.Repository, commands...)`. `git.RunOpts{Dir: repo.RepoPath()}`, the directory should be empty before invoking this method and it can be filled in the function only. #28940 - Remove the `RepoPath()`/`WikiPath()` functions to reduce the possibility of mistakes. --------- Co-authored-by: delvh <dev.lh@web.de>
1748 lines
53 KiB
Go
1748 lines
53 KiB
Go
// Copyright 2018 The Gitea Authors.
|
|
// Copyright 2014 The Gogs Authors.
|
|
// All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package repo
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"html"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"code.gitea.io/gitea/models"
|
|
activities_model "code.gitea.io/gitea/models/activities"
|
|
"code.gitea.io/gitea/models/db"
|
|
git_model "code.gitea.io/gitea/models/git"
|
|
issues_model "code.gitea.io/gitea/models/issues"
|
|
"code.gitea.io/gitea/models/organization"
|
|
access_model "code.gitea.io/gitea/models/perm/access"
|
|
pull_model "code.gitea.io/gitea/models/pull"
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
|
"code.gitea.io/gitea/models/unit"
|
|
user_model "code.gitea.io/gitea/models/user"
|
|
"code.gitea.io/gitea/modules/base"
|
|
"code.gitea.io/gitea/modules/context"
|
|
"code.gitea.io/gitea/modules/git"
|
|
"code.gitea.io/gitea/modules/gitrepo"
|
|
issue_template "code.gitea.io/gitea/modules/issue/template"
|
|
"code.gitea.io/gitea/modules/log"
|
|
"code.gitea.io/gitea/modules/setting"
|
|
"code.gitea.io/gitea/modules/structs"
|
|
"code.gitea.io/gitea/modules/upload"
|
|
"code.gitea.io/gitea/modules/util"
|
|
"code.gitea.io/gitea/modules/web"
|
|
"code.gitea.io/gitea/routers/utils"
|
|
asymkey_service "code.gitea.io/gitea/services/asymkey"
|
|
"code.gitea.io/gitea/services/automerge"
|
|
"code.gitea.io/gitea/services/forms"
|
|
"code.gitea.io/gitea/services/gitdiff"
|
|
notify_service "code.gitea.io/gitea/services/notify"
|
|
pull_service "code.gitea.io/gitea/services/pull"
|
|
repo_service "code.gitea.io/gitea/services/repository"
|
|
|
|
"github.com/gobwas/glob"
|
|
)
|
|
|
|
const (
|
|
tplFork base.TplName = "repo/pulls/fork"
|
|
tplCompareDiff base.TplName = "repo/diff/compare"
|
|
tplPullCommits base.TplName = "repo/pulls/commits"
|
|
tplPullFiles base.TplName = "repo/pulls/files"
|
|
|
|
pullRequestTemplateKey = "PullRequestTemplate"
|
|
)
|
|
|
|
var pullRequestTemplateCandidates = []string{
|
|
"PULL_REQUEST_TEMPLATE.md",
|
|
"PULL_REQUEST_TEMPLATE.yaml",
|
|
"PULL_REQUEST_TEMPLATE.yml",
|
|
"pull_request_template.md",
|
|
"pull_request_template.yaml",
|
|
"pull_request_template.yml",
|
|
".gitea/PULL_REQUEST_TEMPLATE.md",
|
|
".gitea/PULL_REQUEST_TEMPLATE.yaml",
|
|
".gitea/PULL_REQUEST_TEMPLATE.yml",
|
|
".gitea/pull_request_template.md",
|
|
".gitea/pull_request_template.yaml",
|
|
".gitea/pull_request_template.yml",
|
|
".github/PULL_REQUEST_TEMPLATE.md",
|
|
".github/PULL_REQUEST_TEMPLATE.yaml",
|
|
".github/PULL_REQUEST_TEMPLATE.yml",
|
|
".github/pull_request_template.md",
|
|
".github/pull_request_template.yaml",
|
|
".github/pull_request_template.yml",
|
|
}
|
|
|
|
func getRepository(ctx *context.Context, repoID int64) *repo_model.Repository {
|
|
repo, err := repo_model.GetRepositoryByID(ctx, repoID)
|
|
if err != nil {
|
|
if repo_model.IsErrRepoNotExist(err) {
|
|
ctx.NotFound("GetRepositoryByID", nil)
|
|
} else {
|
|
ctx.ServerError("GetRepositoryByID", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
perm, err := access_model.GetUserRepoPermission(ctx, repo, ctx.Doer)
|
|
if err != nil {
|
|
ctx.ServerError("GetUserRepoPermission", err)
|
|
return nil
|
|
}
|
|
|
|
if !perm.CanRead(unit.TypeCode) {
|
|
log.Trace("Permission Denied: User %-v cannot read %-v of repo %-v\n"+
|
|
"User in repo has Permissions: %-+v",
|
|
ctx.Doer,
|
|
unit.TypeCode,
|
|
ctx.Repo,
|
|
perm)
|
|
ctx.NotFound("getRepository", nil)
|
|
return nil
|
|
}
|
|
return repo
|
|
}
|
|
|
|
func getForkRepository(ctx *context.Context) *repo_model.Repository {
|
|
forkRepo := getRepository(ctx, ctx.ParamsInt64(":repoid"))
|
|
if ctx.Written() {
|
|
return nil
|
|
}
|
|
|
|
if forkRepo.IsEmpty {
|
|
log.Trace("Empty repository %-v", forkRepo)
|
|
ctx.NotFound("getForkRepository", nil)
|
|
return nil
|
|
}
|
|
|
|
if err := forkRepo.LoadOwner(ctx); err != nil {
|
|
ctx.ServerError("LoadOwner", err)
|
|
return nil
|
|
}
|
|
|
|
ctx.Data["repo_name"] = forkRepo.Name
|
|
ctx.Data["description"] = forkRepo.Description
|
|
ctx.Data["IsPrivate"] = forkRepo.IsPrivate || forkRepo.Owner.Visibility == structs.VisibleTypePrivate
|
|
canForkToUser := forkRepo.OwnerID != ctx.Doer.ID && !repo_model.HasForkedRepo(ctx, ctx.Doer.ID, forkRepo.ID)
|
|
|
|
ctx.Data["ForkRepo"] = forkRepo
|
|
|
|
ownedOrgs, err := organization.GetOrgsCanCreateRepoByUserID(ctx, ctx.Doer.ID)
|
|
if err != nil {
|
|
ctx.ServerError("GetOrgsCanCreateRepoByUserID", err)
|
|
return nil
|
|
}
|
|
var orgs []*organization.Organization
|
|
for _, org := range ownedOrgs {
|
|
if forkRepo.OwnerID != org.ID && !repo_model.HasForkedRepo(ctx, org.ID, forkRepo.ID) {
|
|
orgs = append(orgs, org)
|
|
}
|
|
}
|
|
|
|
traverseParentRepo := forkRepo
|
|
for {
|
|
if ctx.Doer.ID == traverseParentRepo.OwnerID {
|
|
canForkToUser = false
|
|
} else {
|
|
for i, org := range orgs {
|
|
if org.ID == traverseParentRepo.OwnerID {
|
|
orgs = append(orgs[:i], orgs[i+1:]...)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if !traverseParentRepo.IsFork {
|
|
break
|
|
}
|
|
traverseParentRepo, err = repo_model.GetRepositoryByID(ctx, traverseParentRepo.ForkID)
|
|
if err != nil {
|
|
ctx.ServerError("GetRepositoryByID", err)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
ctx.Data["CanForkToUser"] = canForkToUser
|
|
ctx.Data["Orgs"] = orgs
|
|
|
|
if canForkToUser {
|
|
ctx.Data["ContextUser"] = ctx.Doer
|
|
} else if len(orgs) > 0 {
|
|
ctx.Data["ContextUser"] = orgs[0]
|
|
} else {
|
|
ctx.Data["CanForkRepo"] = false
|
|
ctx.Flash.Error(ctx.Tr("repo.fork_no_valid_owners"), true)
|
|
return nil
|
|
}
|
|
|
|
branches, err := git_model.FindBranchNames(ctx, git_model.FindBranchOptions{
|
|
RepoID: ctx.Repo.Repository.ID,
|
|
ListOptions: db.ListOptions{
|
|
ListAll: true,
|
|
},
|
|
IsDeletedBranch: util.OptionalBoolFalse,
|
|
// Add it as the first option
|
|
ExcludeBranchNames: []string{ctx.Repo.Repository.DefaultBranch},
|
|
})
|
|
if err != nil {
|
|
ctx.ServerError("FindBranchNames", err)
|
|
return nil
|
|
}
|
|
ctx.Data["Branches"] = append([]string{ctx.Repo.Repository.DefaultBranch}, branches...)
|
|
|
|
return forkRepo
|
|
}
|
|
|
|
// Fork render repository fork page
|
|
func Fork(ctx *context.Context) {
|
|
ctx.Data["Title"] = ctx.Tr("new_fork")
|
|
|
|
if ctx.Doer.CanForkRepo() {
|
|
ctx.Data["CanForkRepo"] = true
|
|
} else {
|
|
maxCreationLimit := ctx.Doer.MaxCreationLimit()
|
|
msg := ctx.TrN(maxCreationLimit, "repo.form.reach_limit_of_creation_1", "repo.form.reach_limit_of_creation_n", maxCreationLimit)
|
|
ctx.Flash.Error(msg, true)
|
|
}
|
|
|
|
getForkRepository(ctx)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
ctx.HTML(http.StatusOK, tplFork)
|
|
}
|
|
|
|
// ForkPost response for forking a repository
|
|
func ForkPost(ctx *context.Context) {
|
|
form := web.GetForm(ctx).(*forms.CreateRepoForm)
|
|
ctx.Data["Title"] = ctx.Tr("new_fork")
|
|
ctx.Data["CanForkRepo"] = true
|
|
|
|
ctxUser := checkContextUser(ctx, form.UID)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
forkRepo := getForkRepository(ctx)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
ctx.Data["ContextUser"] = ctxUser
|
|
|
|
if ctx.HasError() {
|
|
ctx.HTML(http.StatusOK, tplFork)
|
|
return
|
|
}
|
|
|
|
var err error
|
|
traverseParentRepo := forkRepo
|
|
for {
|
|
if ctxUser.ID == traverseParentRepo.OwnerID {
|
|
ctx.RenderWithErr(ctx.Tr("repo.settings.new_owner_has_same_repo"), tplFork, &form)
|
|
return
|
|
}
|
|
repo := repo_model.GetForkedRepo(ctx, ctxUser.ID, traverseParentRepo.ID)
|
|
if repo != nil {
|
|
ctx.Redirect(ctxUser.HomeLink() + "/" + url.PathEscape(repo.Name))
|
|
return
|
|
}
|
|
if !traverseParentRepo.IsFork {
|
|
break
|
|
}
|
|
traverseParentRepo, err = repo_model.GetRepositoryByID(ctx, traverseParentRepo.ForkID)
|
|
if err != nil {
|
|
ctx.ServerError("GetRepositoryByID", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Check if user is allowed to create repo's on the organization.
|
|
if ctxUser.IsOrganization() {
|
|
isAllowedToFork, err := organization.OrgFromUser(ctxUser).CanCreateOrgRepo(ctx, ctx.Doer.ID)
|
|
if err != nil {
|
|
ctx.ServerError("CanCreateOrgRepo", err)
|
|
return
|
|
} else if !isAllowedToFork {
|
|
ctx.Error(http.StatusForbidden)
|
|
return
|
|
}
|
|
}
|
|
|
|
repo, err := repo_service.ForkRepository(ctx, ctx.Doer, ctxUser, repo_service.ForkRepoOptions{
|
|
BaseRepo: forkRepo,
|
|
Name: form.RepoName,
|
|
Description: form.Description,
|
|
SingleBranch: form.ForkSingleBranch,
|
|
})
|
|
if err != nil {
|
|
ctx.Data["Err_RepoName"] = true
|
|
switch {
|
|
case repo_model.IsErrReachLimitOfRepo(err):
|
|
maxCreationLimit := ctxUser.MaxCreationLimit()
|
|
msg := ctx.TrN(maxCreationLimit, "repo.form.reach_limit_of_creation_1", "repo.form.reach_limit_of_creation_n", maxCreationLimit)
|
|
ctx.RenderWithErr(msg, tplFork, &form)
|
|
case repo_model.IsErrRepoAlreadyExist(err):
|
|
ctx.RenderWithErr(ctx.Tr("repo.settings.new_owner_has_same_repo"), tplFork, &form)
|
|
case repo_model.IsErrRepoFilesAlreadyExist(err):
|
|
switch {
|
|
case ctx.IsUserSiteAdmin() || (setting.Repository.AllowAdoptionOfUnadoptedRepositories && setting.Repository.AllowDeleteOfUnadoptedRepositories):
|
|
ctx.RenderWithErr(ctx.Tr("form.repository_files_already_exist.adopt_or_delete"), tplFork, form)
|
|
case setting.Repository.AllowAdoptionOfUnadoptedRepositories:
|
|
ctx.RenderWithErr(ctx.Tr("form.repository_files_already_exist.adopt"), tplFork, form)
|
|
case setting.Repository.AllowDeleteOfUnadoptedRepositories:
|
|
ctx.RenderWithErr(ctx.Tr("form.repository_files_already_exist.delete"), tplFork, form)
|
|
default:
|
|
ctx.RenderWithErr(ctx.Tr("form.repository_files_already_exist"), tplFork, form)
|
|
}
|
|
case db.IsErrNameReserved(err):
|
|
ctx.RenderWithErr(ctx.Tr("repo.form.name_reserved", err.(db.ErrNameReserved).Name), tplFork, &form)
|
|
case db.IsErrNamePatternNotAllowed(err):
|
|
ctx.RenderWithErr(ctx.Tr("repo.form.name_pattern_not_allowed", err.(db.ErrNamePatternNotAllowed).Pattern), tplFork, &form)
|
|
default:
|
|
ctx.ServerError("ForkPost", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
log.Trace("Repository forked[%d]: %s/%s", forkRepo.ID, ctxUser.Name, repo.Name)
|
|
ctx.Redirect(ctxUser.HomeLink() + "/" + url.PathEscape(repo.Name))
|
|
}
|
|
|
|
func getPullInfo(ctx *context.Context) (issue *issues_model.Issue, ok bool) {
|
|
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
|
|
if err != nil {
|
|
if issues_model.IsErrIssueNotExist(err) {
|
|
ctx.NotFound("GetIssueByIndex", err)
|
|
} else {
|
|
ctx.ServerError("GetIssueByIndex", err)
|
|
}
|
|
return nil, false
|
|
}
|
|
if err = issue.LoadPoster(ctx); err != nil {
|
|
ctx.ServerError("LoadPoster", err)
|
|
return nil, false
|
|
}
|
|
if err := issue.LoadRepo(ctx); err != nil {
|
|
ctx.ServerError("LoadRepo", err)
|
|
return nil, false
|
|
}
|
|
ctx.Data["Title"] = fmt.Sprintf("#%d - %s", issue.Index, issue.Title)
|
|
ctx.Data["Issue"] = issue
|
|
|
|
if !issue.IsPull {
|
|
ctx.NotFound("ViewPullCommits", nil)
|
|
return nil, false
|
|
}
|
|
|
|
if err = issue.LoadPullRequest(ctx); err != nil {
|
|
ctx.ServerError("LoadPullRequest", err)
|
|
return nil, false
|
|
}
|
|
|
|
if err = issue.PullRequest.LoadHeadRepo(ctx); err != nil {
|
|
ctx.ServerError("LoadHeadRepo", err)
|
|
return nil, false
|
|
}
|
|
|
|
if ctx.IsSigned {
|
|
// Update issue-user.
|
|
if err = activities_model.SetIssueReadBy(ctx, issue.ID, ctx.Doer.ID); err != nil {
|
|
ctx.ServerError("ReadBy", err)
|
|
return nil, false
|
|
}
|
|
}
|
|
|
|
return issue, true
|
|
}
|
|
|
|
func setMergeTarget(ctx *context.Context, pull *issues_model.PullRequest) {
|
|
if ctx.Repo.Owner.Name == pull.MustHeadUserName(ctx) {
|
|
ctx.Data["HeadTarget"] = pull.HeadBranch
|
|
} else if pull.HeadRepo == nil {
|
|
ctx.Data["HeadTarget"] = pull.MustHeadUserName(ctx) + ":" + pull.HeadBranch
|
|
} else {
|
|
ctx.Data["HeadTarget"] = pull.MustHeadUserName(ctx) + "/" + pull.HeadRepo.Name + ":" + pull.HeadBranch
|
|
}
|
|
ctx.Data["BaseTarget"] = pull.BaseBranch
|
|
ctx.Data["HeadBranchLink"] = pull.GetHeadBranchLink(ctx)
|
|
ctx.Data["BaseBranchLink"] = pull.GetBaseBranchLink(ctx)
|
|
}
|
|
|
|
// GetPullDiffStats get Pull Requests diff stats
|
|
func GetPullDiffStats(ctx *context.Context) {
|
|
issue, ok := getPullInfo(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
pull := issue.PullRequest
|
|
|
|
mergeBaseCommitID := GetMergedBaseCommitID(ctx, issue)
|
|
|
|
if mergeBaseCommitID == "" {
|
|
ctx.NotFound("PullFiles", nil)
|
|
return
|
|
}
|
|
|
|
headCommitID, err := ctx.Repo.GitRepo.GetRefCommitID(pull.GetGitRefName())
|
|
if err != nil {
|
|
ctx.ServerError("GetRefCommitID", err)
|
|
return
|
|
}
|
|
|
|
diffOptions := &gitdiff.DiffOptions{
|
|
BeforeCommitID: mergeBaseCommitID,
|
|
AfterCommitID: headCommitID,
|
|
MaxLines: setting.Git.MaxGitDiffLines,
|
|
MaxLineCharacters: setting.Git.MaxGitDiffLineCharacters,
|
|
MaxFiles: setting.Git.MaxGitDiffFiles,
|
|
WhitespaceBehavior: gitdiff.GetWhitespaceFlag(ctx.Data["WhitespaceBehavior"].(string)),
|
|
}
|
|
|
|
diff, err := gitdiff.GetPullDiffStats(ctx.Repo.GitRepo, diffOptions)
|
|
if err != nil {
|
|
ctx.ServerError("GetPullDiffStats", err)
|
|
return
|
|
}
|
|
|
|
ctx.Data["Diff"] = diff
|
|
}
|
|
|
|
func GetMergedBaseCommitID(ctx *context.Context, issue *issues_model.Issue) string {
|
|
pull := issue.PullRequest
|
|
|
|
var baseCommit string
|
|
// Some migrated PR won't have any Base SHA and lose history, try to get one
|
|
if pull.MergeBase == "" {
|
|
var commitSHA, parentCommit string
|
|
// If there is a head or a patch file, and it is readable, grab info
|
|
commitSHA, err := ctx.Repo.GitRepo.GetRefCommitID(pull.GetGitRefName())
|
|
if err != nil {
|
|
// Head File does not exist, try the patch
|
|
commitSHA, err = ctx.Repo.GitRepo.ReadPatchCommit(pull.Index)
|
|
if err == nil {
|
|
// Recreate pull head in files for next time
|
|
if err := ctx.Repo.GitRepo.SetReference(pull.GetGitRefName(), commitSHA); err != nil {
|
|
log.Error("Could not write head file", err)
|
|
}
|
|
} else {
|
|
// There is no history available
|
|
log.Trace("No history file available for PR %d", pull.Index)
|
|
}
|
|
}
|
|
if commitSHA != "" {
|
|
// Get immediate parent of the first commit in the patch, grab history back
|
|
parentCommit, _, err = git.NewCommand(ctx, "rev-list", "-1", "--skip=1").AddDynamicArguments(commitSHA).RunStdString(&git.RunOpts{Dir: ctx.Repo.GitRepo.Path})
|
|
if err == nil {
|
|
parentCommit = strings.TrimSpace(parentCommit)
|
|
}
|
|
// Special case on Git < 2.25 that doesn't fail on immediate empty history
|
|
if err != nil || parentCommit == "" {
|
|
log.Info("No known parent commit for PR %d, error: %v", pull.Index, err)
|
|
// bring at least partial history if it can work
|
|
parentCommit = commitSHA
|
|
}
|
|
}
|
|
baseCommit = parentCommit
|
|
} else {
|
|
// Keep an empty history or original commit
|
|
baseCommit = pull.MergeBase
|
|
}
|
|
|
|
return baseCommit
|
|
}
|
|
|
|
// PrepareMergedViewPullInfo show meta information for a merged pull request view page
|
|
func PrepareMergedViewPullInfo(ctx *context.Context, issue *issues_model.Issue) *git.CompareInfo {
|
|
pull := issue.PullRequest
|
|
|
|
setMergeTarget(ctx, pull)
|
|
ctx.Data["HasMerged"] = true
|
|
|
|
baseCommit := GetMergedBaseCommitID(ctx, issue)
|
|
|
|
compareInfo, err := ctx.Repo.GitRepo.GetCompareInfo(ctx.Repo.Repository.RepoPath(),
|
|
baseCommit, pull.GetGitRefName(), false, false)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "fatal: Not a valid object name") || strings.Contains(err.Error(), "unknown revision or path not in the working tree") {
|
|
ctx.Data["IsPullRequestBroken"] = true
|
|
ctx.Data["BaseTarget"] = pull.BaseBranch
|
|
ctx.Data["NumCommits"] = 0
|
|
ctx.Data["NumFiles"] = 0
|
|
return nil
|
|
}
|
|
|
|
ctx.ServerError("GetCompareInfo", err)
|
|
return nil
|
|
}
|
|
ctx.Data["NumCommits"] = len(compareInfo.Commits)
|
|
ctx.Data["NumFiles"] = compareInfo.NumFiles
|
|
|
|
if len(compareInfo.Commits) != 0 {
|
|
sha := compareInfo.Commits[0].ID.String()
|
|
commitStatuses, _, err := git_model.GetLatestCommitStatus(ctx, ctx.Repo.Repository.ID, sha, db.ListOptions{ListAll: true})
|
|
if err != nil {
|
|
ctx.ServerError("GetLatestCommitStatus", err)
|
|
return nil
|
|
}
|
|
if len(commitStatuses) != 0 {
|
|
ctx.Data["LatestCommitStatuses"] = commitStatuses
|
|
ctx.Data["LatestCommitStatus"] = git_model.CalcCommitStatus(commitStatuses)
|
|
}
|
|
}
|
|
|
|
return compareInfo
|
|
}
|
|
|
|
// PrepareViewPullInfo show meta information for a pull request preview page
|
|
func PrepareViewPullInfo(ctx *context.Context, issue *issues_model.Issue) *git.CompareInfo {
|
|
ctx.Data["PullRequestWorkInProgressPrefixes"] = setting.Repository.PullRequest.WorkInProgressPrefixes
|
|
|
|
repo := ctx.Repo.Repository
|
|
pull := issue.PullRequest
|
|
|
|
if err := pull.LoadHeadRepo(ctx); err != nil {
|
|
ctx.ServerError("LoadHeadRepo", err)
|
|
return nil
|
|
}
|
|
|
|
if err := pull.LoadBaseRepo(ctx); err != nil {
|
|
ctx.ServerError("LoadBaseRepo", err)
|
|
return nil
|
|
}
|
|
|
|
setMergeTarget(ctx, pull)
|
|
|
|
pb, err := git_model.GetFirstMatchProtectedBranchRule(ctx, repo.ID, pull.BaseBranch)
|
|
if err != nil {
|
|
ctx.ServerError("LoadProtectedBranch", err)
|
|
return nil
|
|
}
|
|
ctx.Data["EnableStatusCheck"] = pb != nil && pb.EnableStatusCheck
|
|
|
|
var baseGitRepo *git.Repository
|
|
if pull.BaseRepoID == ctx.Repo.Repository.ID && ctx.Repo.GitRepo != nil {
|
|
baseGitRepo = ctx.Repo.GitRepo
|
|
} else {
|
|
baseGitRepo, err := gitrepo.OpenRepository(ctx, pull.BaseRepo)
|
|
if err != nil {
|
|
ctx.ServerError("OpenRepository", err)
|
|
return nil
|
|
}
|
|
defer baseGitRepo.Close()
|
|
}
|
|
|
|
if !baseGitRepo.IsBranchExist(pull.BaseBranch) {
|
|
ctx.Data["IsPullRequestBroken"] = true
|
|
ctx.Data["BaseTarget"] = pull.BaseBranch
|
|
ctx.Data["HeadTarget"] = pull.HeadBranch
|
|
|
|
sha, err := baseGitRepo.GetRefCommitID(pull.GetGitRefName())
|
|
if err != nil {
|
|
ctx.ServerError(fmt.Sprintf("GetRefCommitID(%s)", pull.GetGitRefName()), err)
|
|
return nil
|
|
}
|
|
commitStatuses, _, err := git_model.GetLatestCommitStatus(ctx, repo.ID, sha, db.ListOptions{ListAll: true})
|
|
if err != nil {
|
|
ctx.ServerError("GetLatestCommitStatus", err)
|
|
return nil
|
|
}
|
|
if len(commitStatuses) > 0 {
|
|
ctx.Data["LatestCommitStatuses"] = commitStatuses
|
|
ctx.Data["LatestCommitStatus"] = git_model.CalcCommitStatus(commitStatuses)
|
|
}
|
|
|
|
compareInfo, err := baseGitRepo.GetCompareInfo(pull.BaseRepo.RepoPath(),
|
|
pull.MergeBase, pull.GetGitRefName(), false, false)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "fatal: Not a valid object name") {
|
|
ctx.Data["IsPullRequestBroken"] = true
|
|
ctx.Data["BaseTarget"] = pull.BaseBranch
|
|
ctx.Data["NumCommits"] = 0
|
|
ctx.Data["NumFiles"] = 0
|
|
return nil
|
|
}
|
|
|
|
ctx.ServerError("GetCompareInfo", err)
|
|
return nil
|
|
}
|
|
|
|
ctx.Data["NumCommits"] = len(compareInfo.Commits)
|
|
ctx.Data["NumFiles"] = compareInfo.NumFiles
|
|
return compareInfo
|
|
}
|
|
|
|
var headBranchExist bool
|
|
var headBranchSha string
|
|
// HeadRepo may be missing
|
|
if pull.HeadRepo != nil {
|
|
headGitRepo, err := gitrepo.OpenRepository(ctx, pull.HeadRepo)
|
|
if err != nil {
|
|
ctx.ServerError("OpenRepository", err)
|
|
return nil
|
|
}
|
|
defer headGitRepo.Close()
|
|
|
|
if pull.Flow == issues_model.PullRequestFlowGithub {
|
|
headBranchExist = headGitRepo.IsBranchExist(pull.HeadBranch)
|
|
} else {
|
|
headBranchExist = git.IsReferenceExist(ctx, baseGitRepo.Path, pull.GetGitRefName())
|
|
}
|
|
|
|
if headBranchExist {
|
|
if pull.Flow != issues_model.PullRequestFlowGithub {
|
|
headBranchSha, err = baseGitRepo.GetRefCommitID(pull.GetGitRefName())
|
|
} else {
|
|
headBranchSha, err = headGitRepo.GetBranchCommitID(pull.HeadBranch)
|
|
}
|
|
if err != nil {
|
|
ctx.ServerError("GetBranchCommitID", err)
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
if headBranchExist {
|
|
var err error
|
|
ctx.Data["UpdateAllowed"], ctx.Data["UpdateByRebaseAllowed"], err = pull_service.IsUserAllowedToUpdate(ctx, pull, ctx.Doer)
|
|
if err != nil {
|
|
ctx.ServerError("IsUserAllowedToUpdate", err)
|
|
return nil
|
|
}
|
|
ctx.Data["GetCommitMessages"] = pull_service.GetSquashMergeCommitMessages(ctx, pull)
|
|
} else {
|
|
ctx.Data["GetCommitMessages"] = ""
|
|
}
|
|
|
|
sha, err := baseGitRepo.GetRefCommitID(pull.GetGitRefName())
|
|
if err != nil {
|
|
if git.IsErrNotExist(err) {
|
|
ctx.Data["IsPullRequestBroken"] = true
|
|
if pull.IsSameRepo() {
|
|
ctx.Data["HeadTarget"] = pull.HeadBranch
|
|
} else if pull.HeadRepo == nil {
|
|
ctx.Data["HeadTarget"] = ctx.Locale.Tr("repo.pull.deleted_branch", pull.HeadBranch)
|
|
} else {
|
|
ctx.Data["HeadTarget"] = pull.HeadRepo.OwnerName + ":" + pull.HeadBranch
|
|
}
|
|
ctx.Data["BaseTarget"] = pull.BaseBranch
|
|
ctx.Data["NumCommits"] = 0
|
|
ctx.Data["NumFiles"] = 0
|
|
return nil
|
|
}
|
|
ctx.ServerError(fmt.Sprintf("GetRefCommitID(%s)", pull.GetGitRefName()), err)
|
|
return nil
|
|
}
|
|
|
|
commitStatuses, _, err := git_model.GetLatestCommitStatus(ctx, repo.ID, sha, db.ListOptions{ListAll: true})
|
|
if err != nil {
|
|
ctx.ServerError("GetLatestCommitStatus", err)
|
|
return nil
|
|
}
|
|
if len(commitStatuses) > 0 {
|
|
ctx.Data["LatestCommitStatuses"] = commitStatuses
|
|
ctx.Data["LatestCommitStatus"] = git_model.CalcCommitStatus(commitStatuses)
|
|
}
|
|
|
|
if pb != nil && pb.EnableStatusCheck {
|
|
ctx.Data["is_context_required"] = func(context string) bool {
|
|
for _, c := range pb.StatusCheckContexts {
|
|
if c == context {
|
|
return true
|
|
}
|
|
if gp, err := glob.Compile(c); err != nil {
|
|
// All newly created status_check_contexts are checked to ensure they are valid glob expressions before being stored in the database.
|
|
// But some old status_check_context created before glob was introduced may be invalid glob expressions.
|
|
// So log the error here for debugging.
|
|
log.Error("compile glob %q: %v", c, err)
|
|
} else if gp.Match(context) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
ctx.Data["RequiredStatusCheckState"] = pull_service.MergeRequiredContextsCommitStatus(commitStatuses, pb.StatusCheckContexts)
|
|
}
|
|
|
|
ctx.Data["HeadBranchMovedOn"] = headBranchSha != sha
|
|
ctx.Data["HeadBranchCommitID"] = headBranchSha
|
|
ctx.Data["PullHeadCommitID"] = sha
|
|
|
|
if pull.HeadRepo == nil || !headBranchExist || (!pull.Issue.IsClosed && (headBranchSha != sha)) {
|
|
ctx.Data["IsPullRequestBroken"] = true
|
|
if pull.IsSameRepo() {
|
|
ctx.Data["HeadTarget"] = pull.HeadBranch
|
|
} else if pull.HeadRepo == nil {
|
|
ctx.Data["HeadTarget"] = ctx.Locale.Tr("repo.pull.deleted_branch", pull.HeadBranch)
|
|
} else {
|
|
ctx.Data["HeadTarget"] = pull.HeadRepo.OwnerName + ":" + pull.HeadBranch
|
|
}
|
|
}
|
|
|
|
compareInfo, err := baseGitRepo.GetCompareInfo(pull.BaseRepo.RepoPath(),
|
|
git.BranchPrefix+pull.BaseBranch, pull.GetGitRefName(), false, false)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "fatal: Not a valid object name") {
|
|
ctx.Data["IsPullRequestBroken"] = true
|
|
ctx.Data["BaseTarget"] = pull.BaseBranch
|
|
ctx.Data["NumCommits"] = 0
|
|
ctx.Data["NumFiles"] = 0
|
|
return nil
|
|
}
|
|
|
|
ctx.ServerError("GetCompareInfo", err)
|
|
return nil
|
|
}
|
|
|
|
if compareInfo.HeadCommitID == compareInfo.MergeBase {
|
|
ctx.Data["IsNothingToCompare"] = true
|
|
}
|
|
|
|
if pull.IsWorkInProgress(ctx) {
|
|
ctx.Data["IsPullWorkInProgress"] = true
|
|
ctx.Data["WorkInProgressPrefix"] = pull.GetWorkInProgressPrefix(ctx)
|
|
}
|
|
|
|
if pull.IsFilesConflicted() {
|
|
ctx.Data["IsPullFilesConflicted"] = true
|
|
ctx.Data["ConflictedFiles"] = pull.ConflictedFiles
|
|
}
|
|
|
|
ctx.Data["NumCommits"] = len(compareInfo.Commits)
|
|
ctx.Data["NumFiles"] = compareInfo.NumFiles
|
|
return compareInfo
|
|
}
|
|
|
|
type pullCommitList struct {
|
|
Commits []pull_service.CommitInfo `json:"commits"`
|
|
LastReviewCommitSha string `json:"last_review_commit_sha"`
|
|
Locale map[string]string `json:"locale"`
|
|
}
|
|
|
|
// GetPullCommits get all commits for given pull request
|
|
func GetPullCommits(ctx *context.Context) {
|
|
issue, ok := getPullInfo(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
resp := &pullCommitList{}
|
|
|
|
commits, lastReviewCommitSha, err := pull_service.GetPullCommits(ctx, issue)
|
|
if err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
|
|
// Get the needed locale
|
|
resp.Locale = map[string]string{
|
|
"lang": ctx.Locale.Language(),
|
|
"show_all_commits": ctx.Tr("repo.pulls.show_all_commits"),
|
|
"stats_num_commits": ctx.TrN(len(commits), "repo.activity.git_stats_commit_1", "repo.activity.git_stats_commit_n", len(commits)),
|
|
"show_changes_since_your_last_review": ctx.Tr("repo.pulls.show_changes_since_your_last_review"),
|
|
"select_commit_hold_shift_for_range": ctx.Tr("repo.pulls.select_commit_hold_shift_for_range"),
|
|
}
|
|
|
|
resp.Commits = commits
|
|
resp.LastReviewCommitSha = lastReviewCommitSha
|
|
|
|
ctx.JSON(http.StatusOK, resp)
|
|
}
|
|
|
|
// ViewPullCommits show commits for a pull request
|
|
func ViewPullCommits(ctx *context.Context) {
|
|
ctx.Data["PageIsPullList"] = true
|
|
ctx.Data["PageIsPullCommits"] = true
|
|
|
|
issue, ok := getPullInfo(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
pull := issue.PullRequest
|
|
|
|
var prInfo *git.CompareInfo
|
|
if pull.HasMerged {
|
|
prInfo = PrepareMergedViewPullInfo(ctx, issue)
|
|
} else {
|
|
prInfo = PrepareViewPullInfo(ctx, issue)
|
|
}
|
|
|
|
if ctx.Written() {
|
|
return
|
|
} else if prInfo == nil {
|
|
ctx.NotFound("ViewPullCommits", nil)
|
|
return
|
|
}
|
|
|
|
ctx.Data["Username"] = ctx.Repo.Owner.Name
|
|
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
|
|
|
|
commits := git_model.ConvertFromGitCommit(ctx, prInfo.Commits, ctx.Repo.Repository)
|
|
ctx.Data["Commits"] = commits
|
|
ctx.Data["CommitCount"] = len(commits)
|
|
|
|
ctx.Data["HasIssuesOrPullsWritePermission"] = ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull)
|
|
ctx.Data["IsIssuePoster"] = ctx.IsSigned && issue.IsPoster(ctx.Doer.ID)
|
|
|
|
// For PR commits page
|
|
PrepareBranchList(ctx)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
getBranchData(ctx, issue)
|
|
ctx.HTML(http.StatusOK, tplPullCommits)
|
|
}
|
|
|
|
// ViewPullFiles render pull request changed files list page
|
|
func viewPullFiles(ctx *context.Context, specifiedStartCommit, specifiedEndCommit string, willShowSpecifiedCommitRange, willShowSpecifiedCommit bool) {
|
|
ctx.Data["PageIsPullList"] = true
|
|
ctx.Data["PageIsPullFiles"] = true
|
|
|
|
issue, ok := getPullInfo(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
pull := issue.PullRequest
|
|
|
|
var (
|
|
startCommitID string
|
|
endCommitID string
|
|
gitRepo = ctx.Repo.GitRepo
|
|
)
|
|
|
|
var prInfo *git.CompareInfo
|
|
if pull.HasMerged {
|
|
prInfo = PrepareMergedViewPullInfo(ctx, issue)
|
|
} else {
|
|
prInfo = PrepareViewPullInfo(ctx, issue)
|
|
}
|
|
|
|
// Validate the given commit sha to show (if any passed)
|
|
if willShowSpecifiedCommit || willShowSpecifiedCommitRange {
|
|
|
|
foundStartCommit := len(specifiedStartCommit) == 0
|
|
foundEndCommit := len(specifiedEndCommit) == 0
|
|
|
|
if !(foundStartCommit && foundEndCommit) {
|
|
for _, commit := range prInfo.Commits {
|
|
if commit.ID.String() == specifiedStartCommit {
|
|
foundStartCommit = true
|
|
}
|
|
if commit.ID.String() == specifiedEndCommit {
|
|
foundEndCommit = true
|
|
}
|
|
|
|
if foundStartCommit && foundEndCommit {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if !(foundStartCommit && foundEndCommit) {
|
|
ctx.NotFound("Given SHA1 not found for this PR", nil)
|
|
return
|
|
}
|
|
}
|
|
|
|
if ctx.Written() {
|
|
return
|
|
} else if prInfo == nil {
|
|
ctx.NotFound("ViewPullFiles", nil)
|
|
return
|
|
}
|
|
|
|
headCommitID, err := gitRepo.GetRefCommitID(pull.GetGitRefName())
|
|
if err != nil {
|
|
ctx.ServerError("GetRefCommitID", err)
|
|
return
|
|
}
|
|
|
|
ctx.Data["IsShowingOnlySingleCommit"] = willShowSpecifiedCommit
|
|
|
|
if willShowSpecifiedCommit || willShowSpecifiedCommitRange {
|
|
if len(specifiedEndCommit) > 0 {
|
|
endCommitID = specifiedEndCommit
|
|
} else {
|
|
endCommitID = headCommitID
|
|
}
|
|
if len(specifiedStartCommit) > 0 {
|
|
startCommitID = specifiedStartCommit
|
|
} else {
|
|
startCommitID = prInfo.MergeBase
|
|
}
|
|
ctx.Data["IsShowingAllCommits"] = false
|
|
} else {
|
|
endCommitID = headCommitID
|
|
startCommitID = prInfo.MergeBase
|
|
ctx.Data["IsShowingAllCommits"] = true
|
|
}
|
|
|
|
ctx.Data["Username"] = ctx.Repo.Owner.Name
|
|
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
|
|
ctx.Data["AfterCommitID"] = endCommitID
|
|
ctx.Data["BeforeCommitID"] = startCommitID
|
|
|
|
fileOnly := ctx.FormBool("file-only")
|
|
|
|
maxLines, maxFiles := setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffFiles
|
|
files := ctx.FormStrings("files")
|
|
if fileOnly && (len(files) == 2 || len(files) == 1) {
|
|
maxLines, maxFiles = -1, -1
|
|
}
|
|
|
|
diffOptions := &gitdiff.DiffOptions{
|
|
AfterCommitID: endCommitID,
|
|
SkipTo: ctx.FormString("skip-to"),
|
|
MaxLines: maxLines,
|
|
MaxLineCharacters: setting.Git.MaxGitDiffLineCharacters,
|
|
MaxFiles: maxFiles,
|
|
WhitespaceBehavior: gitdiff.GetWhitespaceFlag(ctx.Data["WhitespaceBehavior"].(string)),
|
|
}
|
|
|
|
if !willShowSpecifiedCommit {
|
|
diffOptions.BeforeCommitID = startCommitID
|
|
}
|
|
|
|
var methodWithError string
|
|
var diff *gitdiff.Diff
|
|
|
|
// if we're not logged in or only a single commit (or commit range) is shown we
|
|
// have to load only the diff and not get the viewed information
|
|
// as the viewed information is designed to be loaded only on latest PR
|
|
// diff and if you're signed in.
|
|
if !ctx.IsSigned || willShowSpecifiedCommit || willShowSpecifiedCommitRange {
|
|
diff, err = gitdiff.GetDiff(ctx, gitRepo, diffOptions, files...)
|
|
methodWithError = "GetDiff"
|
|
} else {
|
|
diff, err = gitdiff.SyncAndGetUserSpecificDiff(ctx, ctx.Doer.ID, pull, gitRepo, diffOptions, files...)
|
|
methodWithError = "SyncAndGetUserSpecificDiff"
|
|
}
|
|
if err != nil {
|
|
ctx.ServerError(methodWithError, err)
|
|
return
|
|
}
|
|
|
|
ctx.PageData["prReview"] = map[string]any{
|
|
"numberOfFiles": diff.NumFiles,
|
|
"numberOfViewedFiles": diff.NumViewedFiles,
|
|
}
|
|
|
|
if err = diff.LoadComments(ctx, issue, ctx.Doer, ctx.Data["ShowOutdatedComments"].(bool)); err != nil {
|
|
ctx.ServerError("LoadComments", err)
|
|
return
|
|
}
|
|
|
|
pb, err := git_model.GetFirstMatchProtectedBranchRule(ctx, pull.BaseRepoID, pull.BaseBranch)
|
|
if err != nil {
|
|
ctx.ServerError("LoadProtectedBranch", err)
|
|
return
|
|
}
|
|
|
|
if pb != nil {
|
|
glob := pb.GetProtectedFilePatterns()
|
|
if len(glob) != 0 {
|
|
for _, file := range diff.Files {
|
|
file.IsProtected = pb.IsProtectedFile(glob, file.Name)
|
|
}
|
|
}
|
|
}
|
|
|
|
ctx.Data["Diff"] = diff
|
|
ctx.Data["DiffNotAvailable"] = diff.NumFiles == 0
|
|
|
|
baseCommit, err := ctx.Repo.GitRepo.GetCommit(startCommitID)
|
|
if err != nil {
|
|
ctx.ServerError("GetCommit", err)
|
|
return
|
|
}
|
|
commit, err := gitRepo.GetCommit(endCommitID)
|
|
if err != nil {
|
|
ctx.ServerError("GetCommit", err)
|
|
return
|
|
}
|
|
|
|
if ctx.IsSigned && ctx.Doer != nil {
|
|
if ctx.Data["CanMarkConversation"], err = issues_model.CanMarkConversation(ctx, issue, ctx.Doer); err != nil {
|
|
ctx.ServerError("CanMarkConversation", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
setCompareContext(ctx, baseCommit, commit, ctx.Repo.Owner.Name, ctx.Repo.Repository.Name)
|
|
|
|
assigneeUsers, err := repo_model.GetRepoAssignees(ctx, ctx.Repo.Repository)
|
|
if err != nil {
|
|
ctx.ServerError("GetRepoAssignees", err)
|
|
return
|
|
}
|
|
ctx.Data["Assignees"] = MakeSelfOnTop(ctx.Doer, assigneeUsers)
|
|
|
|
handleTeamMentions(ctx)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
currentReview, err := issues_model.GetCurrentReview(ctx, ctx.Doer, issue)
|
|
if err != nil && !issues_model.IsErrReviewNotExist(err) {
|
|
ctx.ServerError("GetCurrentReview", err)
|
|
return
|
|
}
|
|
numPendingCodeComments := int64(0)
|
|
if currentReview != nil {
|
|
numPendingCodeComments, err = issues_model.CountComments(ctx, &issues_model.FindCommentsOptions{
|
|
Type: issues_model.CommentTypeCode,
|
|
ReviewID: currentReview.ID,
|
|
IssueID: issue.ID,
|
|
})
|
|
if err != nil {
|
|
ctx.ServerError("CountComments", err)
|
|
return
|
|
}
|
|
}
|
|
ctx.Data["CurrentReview"] = currentReview
|
|
ctx.Data["PendingCodeCommentNumber"] = numPendingCodeComments
|
|
|
|
getBranchData(ctx, issue)
|
|
ctx.Data["IsIssuePoster"] = ctx.IsSigned && issue.IsPoster(ctx.Doer.ID)
|
|
ctx.Data["HasIssuesOrPullsWritePermission"] = ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull)
|
|
|
|
ctx.Data["IsAttachmentEnabled"] = setting.Attachment.Enabled
|
|
// For files changed page
|
|
PrepareBranchList(ctx)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
upload.AddUploadContext(ctx, "comment")
|
|
|
|
ctx.HTML(http.StatusOK, tplPullFiles)
|
|
}
|
|
|
|
func ViewPullFilesForSingleCommit(ctx *context.Context) {
|
|
viewPullFiles(ctx, "", ctx.Params("sha"), true, true)
|
|
}
|
|
|
|
func ViewPullFilesForRange(ctx *context.Context) {
|
|
viewPullFiles(ctx, ctx.Params("shaFrom"), ctx.Params("shaTo"), true, false)
|
|
}
|
|
|
|
func ViewPullFilesStartingFromCommit(ctx *context.Context) {
|
|
viewPullFiles(ctx, "", ctx.Params("sha"), true, false)
|
|
}
|
|
|
|
func ViewPullFilesForAllCommitsOfPr(ctx *context.Context) {
|
|
viewPullFiles(ctx, "", "", false, false)
|
|
}
|
|
|
|
// UpdatePullRequest merge PR's baseBranch into headBranch
|
|
func UpdatePullRequest(ctx *context.Context) {
|
|
issue, ok := getPullInfo(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
if issue.IsClosed {
|
|
ctx.NotFound("MergePullRequest", nil)
|
|
return
|
|
}
|
|
if issue.PullRequest.HasMerged {
|
|
ctx.NotFound("MergePullRequest", nil)
|
|
return
|
|
}
|
|
|
|
rebase := ctx.FormString("style") == "rebase"
|
|
|
|
if err := issue.PullRequest.LoadBaseRepo(ctx); err != nil {
|
|
ctx.ServerError("LoadBaseRepo", err)
|
|
return
|
|
}
|
|
if err := issue.PullRequest.LoadHeadRepo(ctx); err != nil {
|
|
ctx.ServerError("LoadHeadRepo", err)
|
|
return
|
|
}
|
|
|
|
allowedUpdateByMerge, allowedUpdateByRebase, err := pull_service.IsUserAllowedToUpdate(ctx, issue.PullRequest, ctx.Doer)
|
|
if err != nil {
|
|
ctx.ServerError("IsUserAllowedToMerge", err)
|
|
return
|
|
}
|
|
|
|
// ToDo: add check if maintainers are allowed to change branch ... (need migration & co)
|
|
if (!allowedUpdateByMerge && !rebase) || (rebase && !allowedUpdateByRebase) {
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.update_not_allowed"))
|
|
ctx.Redirect(issue.Link())
|
|
return
|
|
}
|
|
|
|
// default merge commit message
|
|
message := fmt.Sprintf("Merge branch '%s' into %s", issue.PullRequest.BaseBranch, issue.PullRequest.HeadBranch)
|
|
|
|
if err = pull_service.Update(ctx, issue.PullRequest, ctx.Doer, message, rebase); err != nil {
|
|
if models.IsErrMergeConflicts(err) {
|
|
conflictError := err.(models.ErrMergeConflicts)
|
|
flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
|
|
"Message": ctx.Tr("repo.pulls.merge_conflict"),
|
|
"Summary": ctx.Tr("repo.pulls.merge_conflict_summary"),
|
|
"Details": utils.SanitizeFlashErrorString(conflictError.StdErr) + "<br>" + utils.SanitizeFlashErrorString(conflictError.StdOut),
|
|
})
|
|
if err != nil {
|
|
ctx.ServerError("UpdatePullRequest.HTMLString", err)
|
|
return
|
|
}
|
|
ctx.Flash.Error(flashError)
|
|
ctx.Redirect(issue.Link())
|
|
return
|
|
} else if models.IsErrRebaseConflicts(err) {
|
|
conflictError := err.(models.ErrRebaseConflicts)
|
|
flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
|
|
"Message": ctx.Tr("repo.pulls.rebase_conflict", utils.SanitizeFlashErrorString(conflictError.CommitSHA)),
|
|
"Summary": ctx.Tr("repo.pulls.rebase_conflict_summary"),
|
|
"Details": utils.SanitizeFlashErrorString(conflictError.StdErr) + "<br>" + utils.SanitizeFlashErrorString(conflictError.StdOut),
|
|
})
|
|
if err != nil {
|
|
ctx.ServerError("UpdatePullRequest.HTMLString", err)
|
|
return
|
|
}
|
|
ctx.Flash.Error(flashError)
|
|
ctx.Redirect(issue.Link())
|
|
return
|
|
|
|
}
|
|
ctx.Flash.Error(err.Error())
|
|
ctx.Redirect(issue.Link())
|
|
return
|
|
}
|
|
|
|
time.Sleep(1 * time.Second)
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.pulls.update_branch_success"))
|
|
ctx.Redirect(issue.Link())
|
|
}
|
|
|
|
// MergePullRequest response for merging pull request
|
|
func MergePullRequest(ctx *context.Context) {
|
|
form := web.GetForm(ctx).(*forms.MergePullRequestForm)
|
|
issue, ok := getPullInfo(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
pr := issue.PullRequest
|
|
pr.Issue = issue
|
|
pr.Issue.Repo = ctx.Repo.Repository
|
|
|
|
manuallyMerged := repo_model.MergeStyle(form.Do) == repo_model.MergeStyleManuallyMerged
|
|
|
|
mergeCheckType := pull_service.MergeCheckTypeGeneral
|
|
if form.MergeWhenChecksSucceed {
|
|
mergeCheckType = pull_service.MergeCheckTypeAuto
|
|
}
|
|
if manuallyMerged {
|
|
mergeCheckType = pull_service.MergeCheckTypeManually
|
|
}
|
|
|
|
// start with merging by checking
|
|
if err := pull_service.CheckPullMergable(ctx, ctx.Doer, &ctx.Repo.Permission, pr, mergeCheckType, form.ForceMerge); err != nil {
|
|
switch {
|
|
case errors.Is(err, pull_service.ErrIsClosed):
|
|
if issue.IsPull {
|
|
ctx.JSONError(ctx.Tr("repo.pulls.is_closed"))
|
|
} else {
|
|
ctx.JSONError(ctx.Tr("repo.issues.closed_title"))
|
|
}
|
|
case errors.Is(err, pull_service.ErrUserNotAllowedToMerge):
|
|
ctx.JSONError(ctx.Tr("repo.pulls.update_not_allowed"))
|
|
case errors.Is(err, pull_service.ErrHasMerged):
|
|
ctx.JSONError(ctx.Tr("repo.pulls.has_merged"))
|
|
case errors.Is(err, pull_service.ErrIsWorkInProgress):
|
|
ctx.JSONError(ctx.Tr("repo.pulls.no_merge_wip"))
|
|
case errors.Is(err, pull_service.ErrNotMergableState):
|
|
ctx.JSONError(ctx.Tr("repo.pulls.no_merge_not_ready"))
|
|
case models.IsErrDisallowedToMerge(err):
|
|
ctx.JSONError(ctx.Tr("repo.pulls.no_merge_not_ready"))
|
|
case asymkey_service.IsErrWontSign(err):
|
|
ctx.JSONError(err.Error()) // has no translation ...
|
|
case errors.Is(err, pull_service.ErrDependenciesLeft):
|
|
ctx.JSONError(ctx.Tr("repo.issues.dependency.pr_close_blocked"))
|
|
default:
|
|
ctx.ServerError("WebCheck", err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// handle manually-merged mark
|
|
if manuallyMerged {
|
|
if err := pull_service.MergedManually(ctx, pr, ctx.Doer, ctx.Repo.GitRepo, form.MergeCommitID); err != nil {
|
|
switch {
|
|
case models.IsErrInvalidMergeStyle(err):
|
|
ctx.JSONError(ctx.Tr("repo.pulls.invalid_merge_option"))
|
|
case strings.Contains(err.Error(), "Wrong commit ID"):
|
|
ctx.JSONError(ctx.Tr("repo.pulls.wrong_commit_id"))
|
|
default:
|
|
ctx.ServerError("MergedManually", err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
ctx.JSONRedirect(issue.Link())
|
|
return
|
|
}
|
|
|
|
message := strings.TrimSpace(form.MergeTitleField)
|
|
if len(message) == 0 {
|
|
var err error
|
|
message, _, err = pull_service.GetDefaultMergeMessage(ctx, ctx.Repo.GitRepo, pr, repo_model.MergeStyle(form.Do))
|
|
if err != nil {
|
|
ctx.ServerError("GetDefaultMergeMessage", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
form.MergeMessageField = strings.TrimSpace(form.MergeMessageField)
|
|
if len(form.MergeMessageField) > 0 {
|
|
message += "\n\n" + form.MergeMessageField
|
|
}
|
|
|
|
if form.MergeWhenChecksSucceed {
|
|
// delete all scheduled auto merges
|
|
_ = pull_model.DeleteScheduledAutoMerge(ctx, pr.ID)
|
|
// schedule auto merge
|
|
scheduled, err := automerge.ScheduleAutoMerge(ctx, ctx.Doer, pr, repo_model.MergeStyle(form.Do), message)
|
|
if err != nil {
|
|
ctx.ServerError("ScheduleAutoMerge", err)
|
|
return
|
|
} else if scheduled {
|
|
// nothing more to do ...
|
|
ctx.Flash.Success(ctx.Tr("repo.pulls.auto_merge_newly_scheduled"))
|
|
ctx.JSONRedirect(fmt.Sprintf("%s/pulls/%d", ctx.Repo.RepoLink, pr.Index))
|
|
return
|
|
}
|
|
}
|
|
|
|
if err := pull_service.Merge(ctx, pr, ctx.Doer, ctx.Repo.GitRepo, repo_model.MergeStyle(form.Do), form.HeadCommitID, message, false); err != nil {
|
|
if models.IsErrInvalidMergeStyle(err) {
|
|
ctx.JSONError(ctx.Tr("repo.pulls.invalid_merge_option"))
|
|
} else if models.IsErrMergeConflicts(err) {
|
|
conflictError := err.(models.ErrMergeConflicts)
|
|
flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
|
|
"Message": ctx.Tr("repo.editor.merge_conflict"),
|
|
"Summary": ctx.Tr("repo.editor.merge_conflict_summary"),
|
|
"Details": utils.SanitizeFlashErrorString(conflictError.StdErr) + "<br>" + utils.SanitizeFlashErrorString(conflictError.StdOut),
|
|
})
|
|
if err != nil {
|
|
ctx.ServerError("MergePullRequest.HTMLString", err)
|
|
return
|
|
}
|
|
ctx.Flash.Error(flashError)
|
|
ctx.JSONRedirect(issue.Link())
|
|
} else if models.IsErrRebaseConflicts(err) {
|
|
conflictError := err.(models.ErrRebaseConflicts)
|
|
flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
|
|
"Message": ctx.Tr("repo.pulls.rebase_conflict", utils.SanitizeFlashErrorString(conflictError.CommitSHA)),
|
|
"Summary": ctx.Tr("repo.pulls.rebase_conflict_summary"),
|
|
"Details": utils.SanitizeFlashErrorString(conflictError.StdErr) + "<br>" + utils.SanitizeFlashErrorString(conflictError.StdOut),
|
|
})
|
|
if err != nil {
|
|
ctx.ServerError("MergePullRequest.HTMLString", err)
|
|
return
|
|
}
|
|
ctx.Flash.Error(flashError)
|
|
ctx.Redirect(issue.Link())
|
|
} else if models.IsErrMergeUnrelatedHistories(err) {
|
|
log.Debug("MergeUnrelatedHistories error: %v", err)
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.unrelated_histories"))
|
|
ctx.Redirect(issue.Link())
|
|
} else if git.IsErrPushOutOfDate(err) {
|
|
log.Debug("MergePushOutOfDate error: %v", err)
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.merge_out_of_date"))
|
|
ctx.Redirect(issue.Link())
|
|
} else if models.IsErrSHADoesNotMatch(err) {
|
|
log.Debug("MergeHeadOutOfDate error: %v", err)
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.head_out_of_date"))
|
|
ctx.Redirect(issue.Link())
|
|
} else if git.IsErrPushRejected(err) {
|
|
log.Debug("MergePushRejected error: %v", err)
|
|
pushrejErr := err.(*git.ErrPushRejected)
|
|
message := pushrejErr.Message
|
|
if len(message) == 0 {
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.push_rejected_no_message"))
|
|
} else {
|
|
flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
|
|
"Message": ctx.Tr("repo.pulls.push_rejected"),
|
|
"Summary": ctx.Tr("repo.pulls.push_rejected_summary"),
|
|
"Details": utils.SanitizeFlashErrorString(pushrejErr.Message),
|
|
})
|
|
if err != nil {
|
|
ctx.ServerError("MergePullRequest.HTMLString", err)
|
|
return
|
|
}
|
|
ctx.Flash.Error(flashError)
|
|
}
|
|
ctx.JSONRedirect(issue.Link())
|
|
} else {
|
|
ctx.ServerError("Merge", err)
|
|
}
|
|
return
|
|
}
|
|
log.Trace("Pull request merged: %d", pr.ID)
|
|
|
|
if err := stopTimerIfAvailable(ctx, ctx.Doer, issue); err != nil {
|
|
ctx.ServerError("stopTimerIfAvailable", err)
|
|
return
|
|
}
|
|
|
|
log.Trace("Pull request merged: %d", pr.ID)
|
|
|
|
if form.DeleteBranchAfterMerge {
|
|
// Don't cleanup when other pr use this branch as head branch
|
|
exist, err := issues_model.HasUnmergedPullRequestsByHeadInfo(ctx, pr.HeadRepoID, pr.HeadBranch)
|
|
if err != nil {
|
|
ctx.ServerError("HasUnmergedPullRequestsByHeadInfo", err)
|
|
return
|
|
}
|
|
if exist {
|
|
ctx.JSONRedirect(issue.Link())
|
|
return
|
|
}
|
|
|
|
var headRepo *git.Repository
|
|
if ctx.Repo != nil && ctx.Repo.Repository != nil && pr.HeadRepoID == ctx.Repo.Repository.ID && ctx.Repo.GitRepo != nil {
|
|
headRepo = ctx.Repo.GitRepo
|
|
} else {
|
|
headRepo, err = gitrepo.OpenRepository(ctx, pr.HeadRepo)
|
|
if err != nil {
|
|
ctx.ServerError(fmt.Sprintf("OpenRepository[%s]", pr.HeadRepo.FullName()), err)
|
|
return
|
|
}
|
|
defer headRepo.Close()
|
|
}
|
|
deleteBranch(ctx, pr, headRepo)
|
|
}
|
|
|
|
ctx.JSONRedirect(issue.Link())
|
|
}
|
|
|
|
// CancelAutoMergePullRequest cancels a scheduled pr
|
|
func CancelAutoMergePullRequest(ctx *context.Context) {
|
|
issue, ok := getPullInfo(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
if err := automerge.RemoveScheduledAutoMerge(ctx, ctx.Doer, issue.PullRequest); err != nil {
|
|
if db.IsErrNotExist(err) {
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.auto_merge_not_scheduled"))
|
|
ctx.Redirect(fmt.Sprintf("%s/pulls/%d", ctx.Repo.RepoLink, issue.Index))
|
|
return
|
|
}
|
|
ctx.ServerError("RemoveScheduledAutoMerge", err)
|
|
return
|
|
}
|
|
ctx.Flash.Success(ctx.Tr("repo.pulls.auto_merge_canceled_schedule"))
|
|
ctx.Redirect(fmt.Sprintf("%s/pulls/%d", ctx.Repo.RepoLink, issue.Index))
|
|
}
|
|
|
|
func stopTimerIfAvailable(ctx *context.Context, user *user_model.User, issue *issues_model.Issue) error {
|
|
if issues_model.StopwatchExists(ctx, user.ID, issue.ID) {
|
|
if err := issues_model.CreateOrStopIssueStopwatch(ctx, user, issue); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// CompareAndPullRequestPost response for creating pull request
|
|
func CompareAndPullRequestPost(ctx *context.Context) {
|
|
form := web.GetForm(ctx).(*forms.CreateIssueForm)
|
|
ctx.Data["Title"] = ctx.Tr("repo.pulls.compare_changes")
|
|
ctx.Data["PageIsComparePull"] = true
|
|
ctx.Data["IsDiffCompare"] = true
|
|
ctx.Data["IsRepoToolbarCommits"] = true
|
|
ctx.Data["PullRequestWorkInProgressPrefixes"] = setting.Repository.PullRequest.WorkInProgressPrefixes
|
|
ctx.Data["IsAttachmentEnabled"] = setting.Attachment.Enabled
|
|
upload.AddUploadContext(ctx, "comment")
|
|
ctx.Data["HasIssuesOrPullsWritePermission"] = ctx.Repo.CanWrite(unit.TypePullRequests)
|
|
|
|
var (
|
|
repo = ctx.Repo.Repository
|
|
attachments []string
|
|
)
|
|
|
|
ci := ParseCompareInfo(ctx)
|
|
defer func() {
|
|
if ci != nil && ci.HeadGitRepo != nil {
|
|
ci.HeadGitRepo.Close()
|
|
}
|
|
}()
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
labelIDs, assigneeIDs, milestoneID, projectID := ValidateRepoMetas(ctx, *form, true)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
if setting.Attachment.Enabled {
|
|
attachments = form.Files
|
|
}
|
|
|
|
if ctx.HasError() {
|
|
ctx.JSONError(ctx.GetErrMsg())
|
|
return
|
|
}
|
|
|
|
if util.IsEmptyString(form.Title) {
|
|
ctx.JSONError(ctx.Tr("repo.issues.new.title_empty"))
|
|
return
|
|
}
|
|
|
|
content := form.Content
|
|
if filename := ctx.Req.Form.Get("template-file"); filename != "" {
|
|
if template, err := issue_template.UnmarshalFromRepo(ctx.Repo.GitRepo, ctx.Repo.Repository.DefaultBranch, filename); err == nil {
|
|
content = issue_template.RenderToMarkdown(template, ctx.Req.Form)
|
|
}
|
|
}
|
|
|
|
pullIssue := &issues_model.Issue{
|
|
RepoID: repo.ID,
|
|
Repo: repo,
|
|
Title: form.Title,
|
|
PosterID: ctx.Doer.ID,
|
|
Poster: ctx.Doer,
|
|
MilestoneID: milestoneID,
|
|
IsPull: true,
|
|
Content: content,
|
|
}
|
|
pullRequest := &issues_model.PullRequest{
|
|
HeadRepoID: ci.HeadRepo.ID,
|
|
BaseRepoID: repo.ID,
|
|
HeadBranch: ci.HeadBranch,
|
|
BaseBranch: ci.BaseBranch,
|
|
HeadRepo: ci.HeadRepo,
|
|
BaseRepo: repo,
|
|
MergeBase: ci.CompareInfo.MergeBase,
|
|
Type: issues_model.PullRequestGitea,
|
|
AllowMaintainerEdit: form.AllowMaintainerEdit,
|
|
}
|
|
// FIXME: check error in the case two people send pull request at almost same time, give nice error prompt
|
|
// instead of 500.
|
|
|
|
if err := pull_service.NewPullRequest(ctx, repo, pullIssue, labelIDs, attachments, pullRequest, assigneeIDs); err != nil {
|
|
if repo_model.IsErrUserDoesNotHaveAccessToRepo(err) {
|
|
ctx.Error(http.StatusBadRequest, "UserDoesNotHaveAccessToRepo", err.Error())
|
|
return
|
|
} else if git.IsErrPushRejected(err) {
|
|
pushrejErr := err.(*git.ErrPushRejected)
|
|
message := pushrejErr.Message
|
|
if len(message) == 0 {
|
|
ctx.JSONError(ctx.Tr("repo.pulls.push_rejected_no_message"))
|
|
return
|
|
}
|
|
flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
|
|
"Message": ctx.Tr("repo.pulls.push_rejected"),
|
|
"Summary": ctx.Tr("repo.pulls.push_rejected_summary"),
|
|
"Details": utils.SanitizeFlashErrorString(pushrejErr.Message),
|
|
})
|
|
if err != nil {
|
|
ctx.ServerError("CompareAndPullRequest.HTMLString", err)
|
|
return
|
|
}
|
|
ctx.Flash.Error(flashError)
|
|
ctx.JSONRedirect(pullIssue.Link()) // FIXME: it's unfriendly, and will make the content lost
|
|
return
|
|
}
|
|
ctx.ServerError("NewPullRequest", err)
|
|
return
|
|
}
|
|
|
|
if projectID > 0 {
|
|
if !ctx.Repo.CanWrite(unit.TypeProjects) {
|
|
ctx.Error(http.StatusBadRequest, "user hasn't the permission to write to projects")
|
|
return
|
|
}
|
|
if err := issues_model.ChangeProjectAssign(ctx, pullIssue, ctx.Doer, projectID); err != nil {
|
|
ctx.ServerError("ChangeProjectAssign", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
log.Trace("Pull request created: %d/%d", repo.ID, pullIssue.ID)
|
|
ctx.JSONRedirect(pullIssue.Link())
|
|
}
|
|
|
|
// CleanUpPullRequest responses for delete merged branch when PR has been merged
|
|
func CleanUpPullRequest(ctx *context.Context) {
|
|
issue, ok := getPullInfo(ctx)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
pr := issue.PullRequest
|
|
|
|
// Don't cleanup unmerged and unclosed PRs
|
|
if !pr.HasMerged && !issue.IsClosed {
|
|
ctx.NotFound("CleanUpPullRequest", nil)
|
|
return
|
|
}
|
|
|
|
// Don't cleanup when there are other PR's that use this branch as head branch.
|
|
exist, err := issues_model.HasUnmergedPullRequestsByHeadInfo(ctx, pr.HeadRepoID, pr.HeadBranch)
|
|
if err != nil {
|
|
ctx.ServerError("HasUnmergedPullRequestsByHeadInfo", err)
|
|
return
|
|
}
|
|
if exist {
|
|
ctx.NotFound("CleanUpPullRequest", nil)
|
|
return
|
|
}
|
|
|
|
if err := pr.LoadHeadRepo(ctx); err != nil {
|
|
ctx.ServerError("LoadHeadRepo", err)
|
|
return
|
|
} else if pr.HeadRepo == nil {
|
|
// Forked repository has already been deleted
|
|
ctx.NotFound("CleanUpPullRequest", nil)
|
|
return
|
|
} else if err = pr.LoadBaseRepo(ctx); err != nil {
|
|
ctx.ServerError("LoadBaseRepo", err)
|
|
return
|
|
} else if err = pr.HeadRepo.LoadOwner(ctx); err != nil {
|
|
ctx.ServerError("HeadRepo.LoadOwner", err)
|
|
return
|
|
}
|
|
|
|
perm, err := access_model.GetUserRepoPermission(ctx, pr.HeadRepo, ctx.Doer)
|
|
if err != nil {
|
|
ctx.ServerError("GetUserRepoPermission", err)
|
|
return
|
|
}
|
|
if !perm.CanWrite(unit.TypeCode) {
|
|
ctx.NotFound("CleanUpPullRequest", nil)
|
|
return
|
|
}
|
|
|
|
fullBranchName := pr.HeadRepo.Owner.Name + "/" + pr.HeadBranch
|
|
|
|
var gitBaseRepo *git.Repository
|
|
|
|
// Assume that the base repo is the current context (almost certainly)
|
|
if ctx.Repo != nil && ctx.Repo.Repository != nil && ctx.Repo.Repository.ID == pr.BaseRepoID && ctx.Repo.GitRepo != nil {
|
|
gitBaseRepo = ctx.Repo.GitRepo
|
|
} else {
|
|
// If not just open it
|
|
gitBaseRepo, err = gitrepo.OpenRepository(ctx, pr.BaseRepo)
|
|
if err != nil {
|
|
ctx.ServerError(fmt.Sprintf("OpenRepository[%s]", pr.BaseRepo.FullName()), err)
|
|
return
|
|
}
|
|
defer gitBaseRepo.Close()
|
|
}
|
|
|
|
// Now assume that the head repo is the same as the base repo (reasonable chance)
|
|
gitRepo := gitBaseRepo
|
|
// But if not: is it the same as the context?
|
|
if pr.BaseRepoID != pr.HeadRepoID && ctx.Repo != nil && ctx.Repo.Repository != nil && ctx.Repo.Repository.ID == pr.HeadRepoID && ctx.Repo.GitRepo != nil {
|
|
gitRepo = ctx.Repo.GitRepo
|
|
} else if pr.BaseRepoID != pr.HeadRepoID {
|
|
// Otherwise just load it up
|
|
gitRepo, err = gitrepo.OpenRepository(ctx, pr.HeadRepo)
|
|
if err != nil {
|
|
ctx.ServerError(fmt.Sprintf("OpenRepository[%s]", pr.HeadRepo.FullName()), err)
|
|
return
|
|
}
|
|
defer gitRepo.Close()
|
|
}
|
|
|
|
defer func() {
|
|
ctx.JSONRedirect(issue.Link())
|
|
}()
|
|
|
|
// Check if branch has no new commits
|
|
headCommitID, err := gitBaseRepo.GetRefCommitID(pr.GetGitRefName())
|
|
if err != nil {
|
|
log.Error("GetRefCommitID: %v", err)
|
|
ctx.Flash.Error(ctx.Tr("repo.branch.deletion_failed", fullBranchName))
|
|
return
|
|
}
|
|
branchCommitID, err := gitRepo.GetBranchCommitID(pr.HeadBranch)
|
|
if err != nil {
|
|
log.Error("GetBranchCommitID: %v", err)
|
|
ctx.Flash.Error(ctx.Tr("repo.branch.deletion_failed", fullBranchName))
|
|
return
|
|
}
|
|
if headCommitID != branchCommitID {
|
|
ctx.Flash.Error(ctx.Tr("repo.branch.delete_branch_has_new_commits", fullBranchName))
|
|
return
|
|
}
|
|
|
|
deleteBranch(ctx, pr, gitRepo)
|
|
}
|
|
|
|
func deleteBranch(ctx *context.Context, pr *issues_model.PullRequest, gitRepo *git.Repository) {
|
|
fullBranchName := pr.HeadRepo.FullName() + ":" + pr.HeadBranch
|
|
|
|
if err := pull_service.RetargetChildrenOnMerge(ctx, ctx.Doer, pr); err != nil {
|
|
ctx.Flash.Error(ctx.Tr("repo.branch.deletion_failed", fullBranchName))
|
|
return
|
|
}
|
|
|
|
if err := repo_service.DeleteBranch(ctx, ctx.Doer, pr.HeadRepo, gitRepo, pr.HeadBranch); err != nil {
|
|
switch {
|
|
case git.IsErrBranchNotExist(err):
|
|
ctx.Flash.Error(ctx.Tr("repo.branch.deletion_failed", fullBranchName))
|
|
case errors.Is(err, repo_service.ErrBranchIsDefault):
|
|
ctx.Flash.Error(ctx.Tr("repo.branch.deletion_failed", fullBranchName))
|
|
case errors.Is(err, git_model.ErrBranchIsProtected):
|
|
ctx.Flash.Error(ctx.Tr("repo.branch.deletion_failed", fullBranchName))
|
|
default:
|
|
log.Error("DeleteBranch: %v", err)
|
|
ctx.Flash.Error(ctx.Tr("repo.branch.deletion_failed", fullBranchName))
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := issues_model.AddDeletePRBranchComment(ctx, ctx.Doer, pr.BaseRepo, pr.IssueID, pr.HeadBranch); err != nil {
|
|
// Do not fail here as branch has already been deleted
|
|
log.Error("DeleteBranch: %v", err)
|
|
}
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.branch.deletion_success", fullBranchName))
|
|
}
|
|
|
|
// DownloadPullDiff render a pull's raw diff
|
|
func DownloadPullDiff(ctx *context.Context) {
|
|
DownloadPullDiffOrPatch(ctx, false)
|
|
}
|
|
|
|
// DownloadPullPatch render a pull's raw patch
|
|
func DownloadPullPatch(ctx *context.Context) {
|
|
DownloadPullDiffOrPatch(ctx, true)
|
|
}
|
|
|
|
// DownloadPullDiffOrPatch render a pull's raw diff or patch
|
|
func DownloadPullDiffOrPatch(ctx *context.Context, patch bool) {
|
|
pr, err := issues_model.GetPullRequestByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
|
|
if err != nil {
|
|
if issues_model.IsErrPullRequestNotExist(err) {
|
|
ctx.NotFound("GetPullRequestByIndex", err)
|
|
} else {
|
|
ctx.ServerError("GetPullRequestByIndex", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
binary := ctx.FormBool("binary")
|
|
|
|
if err := pull_service.DownloadDiffOrPatch(ctx, pr, ctx, patch, binary); err != nil {
|
|
ctx.ServerError("DownloadDiffOrPatch", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
// UpdatePullRequestTarget change pull request's target branch
|
|
func UpdatePullRequestTarget(ctx *context.Context) {
|
|
issue := GetActionIssue(ctx)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
pr := issue.PullRequest
|
|
if !issue.IsPull {
|
|
ctx.Error(http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
if !ctx.IsSigned || (!issue.IsPoster(ctx.Doer.ID) && !ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull)) {
|
|
ctx.Error(http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
targetBranch := ctx.FormTrim("target_branch")
|
|
if len(targetBranch) == 0 {
|
|
ctx.Error(http.StatusNoContent)
|
|
return
|
|
}
|
|
|
|
if err := pull_service.ChangeTargetBranch(ctx, pr, ctx.Doer, targetBranch); err != nil {
|
|
if issues_model.IsErrPullRequestAlreadyExists(err) {
|
|
err := err.(issues_model.ErrPullRequestAlreadyExists)
|
|
|
|
RepoRelPath := ctx.Repo.Owner.Name + "/" + ctx.Repo.Repository.Name
|
|
errorMessage := ctx.Tr("repo.pulls.has_pull_request", html.EscapeString(ctx.Repo.RepoLink+"/pulls/"+strconv.FormatInt(err.IssueID, 10)), html.EscapeString(RepoRelPath), err.IssueID) // FIXME: Creates url inside locale string
|
|
|
|
ctx.Flash.Error(errorMessage)
|
|
ctx.JSON(http.StatusConflict, map[string]any{
|
|
"error": err.Error(),
|
|
"user_error": errorMessage,
|
|
})
|
|
} else if issues_model.IsErrIssueIsClosed(err) {
|
|
errorMessage := ctx.Tr("repo.pulls.is_closed")
|
|
|
|
ctx.Flash.Error(errorMessage)
|
|
ctx.JSON(http.StatusConflict, map[string]any{
|
|
"error": err.Error(),
|
|
"user_error": errorMessage,
|
|
})
|
|
} else if models.IsErrPullRequestHasMerged(err) {
|
|
errorMessage := ctx.Tr("repo.pulls.has_merged")
|
|
|
|
ctx.Flash.Error(errorMessage)
|
|
ctx.JSON(http.StatusConflict, map[string]any{
|
|
"error": err.Error(),
|
|
"user_error": errorMessage,
|
|
})
|
|
} else if git_model.IsErrBranchesEqual(err) {
|
|
errorMessage := ctx.Tr("repo.pulls.nothing_to_compare")
|
|
|
|
ctx.Flash.Error(errorMessage)
|
|
ctx.JSON(http.StatusBadRequest, map[string]any{
|
|
"error": err.Error(),
|
|
"user_error": errorMessage,
|
|
})
|
|
} else {
|
|
ctx.ServerError("UpdatePullRequestTarget", err)
|
|
}
|
|
return
|
|
}
|
|
notify_service.PullRequestChangeTargetBranch(ctx, ctx.Doer, pr, targetBranch)
|
|
|
|
ctx.JSON(http.StatusOK, map[string]any{
|
|
"base_branch": pr.BaseBranch,
|
|
})
|
|
}
|
|
|
|
// SetAllowEdits allow edits from maintainers to PRs
|
|
func SetAllowEdits(ctx *context.Context) {
|
|
form := web.GetForm(ctx).(*forms.UpdateAllowEditsForm)
|
|
|
|
pr, err := issues_model.GetPullRequestByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
|
|
if err != nil {
|
|
if issues_model.IsErrPullRequestNotExist(err) {
|
|
ctx.NotFound("GetPullRequestByIndex", err)
|
|
} else {
|
|
ctx.ServerError("GetPullRequestByIndex", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := pull_service.SetAllowEdits(ctx, ctx.Doer, pr, form.AllowMaintainerEdit); err != nil {
|
|
if errors.Is(pull_service.ErrUserHasNoPermissionForAction, err) {
|
|
ctx.Error(http.StatusForbidden)
|
|
return
|
|
}
|
|
ctx.ServerError("SetAllowEdits", err)
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, map[string]any{
|
|
"allow_maintainer_edit": pr.AllowMaintainerEdit,
|
|
})
|
|
}
|