2018-01-05 16:26:52 +05:30
|
|
|
// Copyright 2018 The Gitea Authors.
|
|
|
|
// Copyright 2014 The Gogs Authors.
|
|
|
|
// All rights reserved.
|
2014-03-24 15:55:15 +05:30
|
|
|
// Use of this source code is governed by a MIT-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package repo
|
|
|
|
|
|
|
|
import (
|
2015-09-02 18:56:56 +05:30
|
|
|
"container/list"
|
2019-07-06 22:33:13 +05:30
|
|
|
"crypto/subtle"
|
2021-06-07 20:22:59 +05:30
|
|
|
"errors"
|
2016-10-12 18:58:51 +05:30
|
|
|
"fmt"
|
2019-12-16 11:50:25 +05:30
|
|
|
"net/http"
|
2015-09-02 04:37:02 +05:30
|
|
|
"path"
|
2015-08-08 20:13:14 +05:30
|
|
|
"strings"
|
2020-01-17 11:33:40 +05:30
|
|
|
"time"
|
2015-08-08 20:13:14 +05:30
|
|
|
|
2016-11-10 21:54:48 +05:30
|
|
|
"code.gitea.io/gitea/models"
|
|
|
|
"code.gitea.io/gitea/modules/base"
|
|
|
|
"code.gitea.io/gitea/modules/context"
|
2019-03-27 15:03:00 +05:30
|
|
|
"code.gitea.io/gitea/modules/git"
|
2016-11-10 21:54:48 +05:30
|
|
|
"code.gitea.io/gitea/modules/log"
|
2017-01-28 21:29:58 +05:30
|
|
|
"code.gitea.io/gitea/modules/notification"
|
2016-11-10 21:54:48 +05:30
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2020-06-07 06:15:12 +05:30
|
|
|
"code.gitea.io/gitea/modules/structs"
|
2020-10-05 11:19:33 +05:30
|
|
|
"code.gitea.io/gitea/modules/upload"
|
2019-01-21 17:15:32 +05:30
|
|
|
"code.gitea.io/gitea/modules/util"
|
2021-01-26 21:06:53 +05:30
|
|
|
"code.gitea.io/gitea/modules/web"
|
2021-01-30 14:25:53 +05:30
|
|
|
"code.gitea.io/gitea/modules/web/middleware"
|
2020-02-22 18:38:48 +05:30
|
|
|
"code.gitea.io/gitea/routers/utils"
|
2021-04-07 01:14:05 +05:30
|
|
|
"code.gitea.io/gitea/services/forms"
|
2019-09-06 07:50:09 +05:30
|
|
|
"code.gitea.io/gitea/services/gitdiff"
|
2019-09-27 05:52:36 +05:30
|
|
|
pull_service "code.gitea.io/gitea/services/pull"
|
2019-10-26 12:24:11 +05:30
|
|
|
repo_service "code.gitea.io/gitea/services/repository"
|
2021-03-04 09:11:23 +05:30
|
|
|
"github.com/unknwon/com"
|
2014-03-24 15:55:15 +05:30
|
|
|
)
|
|
|
|
|
2014-06-23 08:41:12 +05:30
|
|
|
const (
|
2016-11-24 12:34:31 +05:30
|
|
|
tplFork base.TplName = "repo/pulls/fork"
|
2019-06-08 01:59:29 +05:30
|
|
|
tplCompareDiff base.TplName = "repo/diff/compare"
|
2016-11-24 12:34:31 +05:30
|
|
|
tplPullCommits base.TplName = "repo/pulls/commits"
|
|
|
|
tplPullFiles base.TplName = "repo/pulls/files"
|
2016-02-18 03:51:31 +05:30
|
|
|
|
2016-11-24 12:34:31 +05:30
|
|
|
pullRequestTemplateKey = "PullRequestTemplate"
|
2016-02-18 03:51:31 +05:30
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
2016-11-24 12:34:31 +05:30
|
|
|
pullRequestTemplateCandidates = []string{
|
2017-01-05 06:18:23 +05:30
|
|
|
"PULL_REQUEST_TEMPLATE.md",
|
|
|
|
"pull_request_template.md",
|
|
|
|
".gitea/PULL_REQUEST_TEMPLATE.md",
|
|
|
|
".gitea/pull_request_template.md",
|
|
|
|
".github/PULL_REQUEST_TEMPLATE.md",
|
|
|
|
".github/pull_request_template.md",
|
2016-02-18 03:51:31 +05:30
|
|
|
}
|
2014-06-23 08:41:12 +05:30
|
|
|
)
|
|
|
|
|
2019-11-11 20:45:29 +05:30
|
|
|
func getRepository(ctx *context.Context, repoID int64) *models.Repository {
|
|
|
|
repo, err := models.GetRepositoryByID(repoID)
|
2015-08-08 14:40:34 +05:30
|
|
|
if err != nil {
|
|
|
|
if models.IsErrRepoNotExist(err) {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.NotFound("GetRepositoryByID", nil)
|
2015-08-08 14:40:34 +05:30
|
|
|
} else {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("GetRepositoryByID", err)
|
2015-08-08 14:40:34 +05:30
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2015-09-01 21:27:02 +05:30
|
|
|
|
2019-11-11 20:45:29 +05:30
|
|
|
perm, err := models.GetUserRepoPermission(repo, ctx.User)
|
2018-11-28 16:56:14 +05:30
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetUserRepoPermission", err)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-11 20:45:29 +05:30
|
|
|
if !perm.CanRead(models.UnitTypeCode) {
|
|
|
|
log.Trace("Permission Denied: User %-v cannot read %-v of repo %-v\n"+
|
|
|
|
"User in repo has Permissions: %-+v",
|
|
|
|
ctx.User,
|
|
|
|
models.UnitTypeCode,
|
|
|
|
ctx.Repo,
|
|
|
|
perm)
|
|
|
|
ctx.NotFound("getRepository", nil)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return repo
|
|
|
|
}
|
|
|
|
|
|
|
|
func getForkRepository(ctx *context.Context) *models.Repository {
|
|
|
|
forkRepo := getRepository(ctx, ctx.ParamsInt64(":repoid"))
|
|
|
|
if ctx.Written() {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if forkRepo.IsEmpty {
|
|
|
|
log.Trace("Empty repository %-v", forkRepo)
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.NotFound("getForkRepository", nil)
|
2015-09-01 21:27:02 +05:30
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-11 20:45:29 +05:30
|
|
|
if err := forkRepo.GetOwner(); err != nil {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("GetOwner", err)
|
2015-08-08 14:40:34 +05:30
|
|
|
return nil
|
|
|
|
}
|
2020-06-07 06:15:12 +05:30
|
|
|
|
|
|
|
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.User.ID && !ctx.User.HasForkedRepo(forkRepo.ID)
|
|
|
|
|
2015-08-08 14:40:34 +05:30
|
|
|
ctx.Data["ForkFrom"] = forkRepo.Owner.Name + "/" + forkRepo.Name
|
2016-12-01 16:21:50 +05:30
|
|
|
ctx.Data["ForkFromOwnerID"] = forkRepo.Owner.ID
|
2015-08-08 14:40:34 +05:30
|
|
|
|
2017-10-15 20:36:07 +05:30
|
|
|
if err := ctx.User.GetOwnedOrganizations(); err != nil {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("GetOwnedOrganizations", err)
|
2015-08-08 14:40:34 +05:30
|
|
|
return nil
|
|
|
|
}
|
2017-10-15 20:36:07 +05:30
|
|
|
var orgs []*models.User
|
|
|
|
for _, org := range ctx.User.OwnedOrgs {
|
|
|
|
if forkRepo.OwnerID != org.ID && !org.HasForkedRepo(forkRepo.ID) {
|
|
|
|
orgs = append(orgs, org)
|
|
|
|
}
|
|
|
|
}
|
2017-11-06 09:42:55 +05:30
|
|
|
|
|
|
|
var traverseParentRepo = forkRepo
|
2019-11-11 20:45:29 +05:30
|
|
|
var err error
|
2017-11-06 09:42:55 +05:30
|
|
|
for {
|
|
|
|
if ctx.User.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 = models.GetRepositoryByID(traverseParentRepo.ForkID)
|
|
|
|
if err != nil {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("GetRepositoryByID", err)
|
2017-11-06 09:42:55 +05:30
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Data["CanForkToUser"] = canForkToUser
|
2017-10-15 20:36:07 +05:30
|
|
|
ctx.Data["Orgs"] = orgs
|
|
|
|
|
|
|
|
if canForkToUser {
|
|
|
|
ctx.Data["ContextUser"] = ctx.User
|
|
|
|
} else if len(orgs) > 0 {
|
|
|
|
ctx.Data["ContextUser"] = orgs[0]
|
|
|
|
}
|
2015-08-08 14:40:34 +05:30
|
|
|
|
|
|
|
return forkRepo
|
|
|
|
}
|
|
|
|
|
2016-11-24 12:34:31 +05:30
|
|
|
// Fork render repository fork page
|
2016-03-11 22:26:52 +05:30
|
|
|
func Fork(ctx *context.Context) {
|
2015-08-08 14:40:34 +05:30
|
|
|
ctx.Data["Title"] = ctx.Tr("new_fork")
|
|
|
|
|
|
|
|
getForkRepository(ctx)
|
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.HTML(http.StatusOK, tplFork)
|
2015-08-08 14:40:34 +05:30
|
|
|
}
|
|
|
|
|
2016-11-24 12:34:31 +05:30
|
|
|
// ForkPost response for forking a repository
|
2021-01-26 21:06:53 +05:30
|
|
|
func ForkPost(ctx *context.Context) {
|
2021-04-07 01:14:05 +05:30
|
|
|
form := web.GetForm(ctx).(*forms.CreateRepoForm)
|
2015-08-08 14:40:34 +05:30
|
|
|
ctx.Data["Title"] = ctx.Tr("new_fork")
|
|
|
|
|
2017-10-15 20:36:07 +05:30
|
|
|
ctxUser := checkContextUser(ctx, form.UID)
|
2015-08-08 14:40:34 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-10-15 20:36:07 +05:30
|
|
|
forkRepo := getForkRepository(ctx)
|
2015-08-08 14:40:34 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
2017-10-15 20:36:07 +05:30
|
|
|
|
2015-08-08 14:40:34 +05:30
|
|
|
ctx.Data["ContextUser"] = ctxUser
|
|
|
|
|
|
|
|
if ctx.HasError() {
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.HTML(http.StatusOK, tplFork)
|
2015-08-08 14:40:34 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-11-06 09:42:55 +05:30
|
|
|
var err error
|
|
|
|
var traverseParentRepo = forkRepo
|
|
|
|
for {
|
|
|
|
if ctxUser.ID == traverseParentRepo.OwnerID {
|
|
|
|
ctx.RenderWithErr(ctx.Tr("repo.settings.new_owner_has_same_repo"), tplFork, &form)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
repo, has := models.HasForkedRepo(ctxUser.ID, traverseParentRepo.ID)
|
|
|
|
if has {
|
2021-04-30 22:55:13 +05:30
|
|
|
ctx.Redirect(ctxUser.HomeLink() + "/" + repo.Name)
|
2017-11-06 09:42:55 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
if !traverseParentRepo.IsFork {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
traverseParentRepo, err = models.GetRepositoryByID(traverseParentRepo.ForkID)
|
|
|
|
if err != nil {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("GetRepositoryByID", err)
|
2017-11-06 09:42:55 +05:30
|
|
|
return
|
|
|
|
}
|
2017-07-26 12:47:38 +05:30
|
|
|
}
|
|
|
|
|
2015-08-08 14:40:34 +05:30
|
|
|
// Check ownership of organization.
|
|
|
|
if ctxUser.IsOrganization() {
|
2017-12-21 13:13:26 +05:30
|
|
|
isOwner, err := ctxUser.IsOwnedBy(ctx.User.ID)
|
|
|
|
if err != nil {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("IsOwnedBy", err)
|
2017-12-21 13:13:26 +05:30
|
|
|
return
|
|
|
|
} else if !isOwner {
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.Error(http.StatusForbidden)
|
2015-08-08 14:40:34 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-26 12:24:11 +05:30
|
|
|
repo, err := repo_service.ForkRepository(ctx.User, ctxUser, forkRepo, form.RepoName, form.Description)
|
2015-08-08 14:40:34 +05:30
|
|
|
if err != nil {
|
2015-08-31 12:54:28 +05:30
|
|
|
ctx.Data["Err_RepoName"] = true
|
2015-08-08 14:40:34 +05:30
|
|
|
switch {
|
|
|
|
case models.IsErrRepoAlreadyExist(err):
|
2016-11-24 12:34:31 +05:30
|
|
|
ctx.RenderWithErr(ctx.Tr("repo.settings.new_owner_has_same_repo"), tplFork, &form)
|
2015-08-08 14:40:34 +05:30
|
|
|
case models.IsErrNameReserved(err):
|
2016-11-24 12:34:31 +05:30
|
|
|
ctx.RenderWithErr(ctx.Tr("repo.form.name_reserved", err.(models.ErrNameReserved).Name), tplFork, &form)
|
2015-08-08 14:40:34 +05:30
|
|
|
case models.IsErrNamePatternNotAllowed(err):
|
2016-11-24 12:34:31 +05:30
|
|
|
ctx.RenderWithErr(ctx.Tr("repo.form.name_pattern_not_allowed", err.(models.ErrNamePatternNotAllowed).Pattern), tplFork, &form)
|
2015-08-08 14:40:34 +05:30
|
|
|
default:
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("ForkPost", err)
|
2015-08-08 14:40:34 +05:30
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-08-08 20:13:14 +05:30
|
|
|
log.Trace("Repository forked[%d]: %s/%s", forkRepo.ID, ctxUser.Name, repo.Name)
|
2021-04-30 22:55:13 +05:30
|
|
|
ctx.Redirect(ctxUser.HomeLink() + "/" + repo.Name)
|
2015-08-08 14:40:34 +05:30
|
|
|
}
|
|
|
|
|
2016-03-11 22:26:52 +05:30
|
|
|
func checkPullInfo(ctx *context.Context) *models.Issue {
|
2015-10-19 05:00:39 +05:30
|
|
|
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
|
2015-09-02 13:38:05 +05:30
|
|
|
if err != nil {
|
|
|
|
if models.IsErrIssueNotExist(err) {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.NotFound("GetIssueByIndex", err)
|
2015-09-02 13:38:05 +05:30
|
|
|
} else {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("GetIssueByIndex", err)
|
2015-09-02 13:38:05 +05:30
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2018-12-13 21:25:43 +05:30
|
|
|
if err = issue.LoadPoster(); err != nil {
|
|
|
|
ctx.ServerError("LoadPoster", err)
|
|
|
|
return nil
|
|
|
|
}
|
2019-10-23 23:24:13 +05:30
|
|
|
if err := issue.LoadRepo(); err != nil {
|
|
|
|
ctx.ServerError("LoadRepo", err)
|
|
|
|
return nil
|
|
|
|
}
|
2016-10-12 18:58:51 +05:30
|
|
|
ctx.Data["Title"] = fmt.Sprintf("#%d - %s", issue.Index, issue.Title)
|
2015-10-19 05:00:39 +05:30
|
|
|
ctx.Data["Issue"] = issue
|
2015-09-02 13:38:05 +05:30
|
|
|
|
2015-10-19 05:00:39 +05:30
|
|
|
if !issue.IsPull {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.NotFound("ViewPullCommits", nil)
|
2015-09-02 13:38:05 +05:30
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-12-13 21:25:43 +05:30
|
|
|
if err = issue.LoadPullRequest(); err != nil {
|
|
|
|
ctx.ServerError("LoadPullRequest", err)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-03-03 04:01:55 +05:30
|
|
|
if err = issue.PullRequest.LoadHeadRepo(); err != nil {
|
|
|
|
ctx.ServerError("LoadHeadRepo", err)
|
2015-10-24 13:06:47 +05:30
|
|
|
return nil
|
2015-09-02 13:38:05 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
if ctx.IsSigned {
|
|
|
|
// Update issue-user.
|
2016-07-23 22:38:22 +05:30
|
|
|
if err = issue.ReadBy(ctx.User.ID); err != nil {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("ReadBy", err)
|
2015-09-02 13:38:05 +05:30
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-19 05:00:39 +05:30
|
|
|
return issue
|
2015-09-02 13:38:05 +05:30
|
|
|
}
|
|
|
|
|
2017-10-04 23:05:01 +05:30
|
|
|
func setMergeTarget(ctx *context.Context, pull *models.PullRequest) {
|
2019-10-18 16:43:31 +05:30
|
|
|
if ctx.Repo.Owner.Name == pull.MustHeadUserName() {
|
2017-10-04 23:05:01 +05:30
|
|
|
ctx.Data["HeadTarget"] = pull.HeadBranch
|
|
|
|
} else if pull.HeadRepo == nil {
|
2019-10-18 16:43:31 +05:30
|
|
|
ctx.Data["HeadTarget"] = pull.MustHeadUserName() + ":" + pull.HeadBranch
|
2017-10-04 23:05:01 +05:30
|
|
|
} else {
|
2019-10-18 16:43:31 +05:30
|
|
|
ctx.Data["HeadTarget"] = pull.MustHeadUserName() + "/" + pull.HeadRepo.Name + ":" + pull.HeadBranch
|
2017-10-04 23:05:01 +05:30
|
|
|
}
|
|
|
|
ctx.Data["BaseTarget"] = pull.BaseBranch
|
2021-02-18 08:15:49 +05:30
|
|
|
ctx.Data["HeadBranchHTMLURL"] = pull.GetHeadBranchHTMLURL()
|
|
|
|
ctx.Data["BaseBranchHTMLURL"] = pull.GetBaseBranchHTMLURL()
|
2017-10-04 23:05:01 +05:30
|
|
|
}
|
|
|
|
|
2016-11-24 12:34:31 +05:30
|
|
|
// PrepareMergedViewPullInfo show meta information for a merged pull request view page
|
2019-06-08 01:59:29 +05:30
|
|
|
func PrepareMergedViewPullInfo(ctx *context.Context, issue *models.Issue) *git.CompareInfo {
|
2016-08-16 22:49:09 +05:30
|
|
|
pull := issue.PullRequest
|
2015-09-02 18:56:56 +05:30
|
|
|
|
2017-10-04 23:05:01 +05:30
|
|
|
setMergeTarget(ctx, pull)
|
|
|
|
ctx.Data["HasMerged"] = true
|
|
|
|
|
2019-06-12 05:02:08 +05:30
|
|
|
compareInfo, err := ctx.Repo.GitRepo.GetCompareInfo(ctx.Repo.Repository.RepoPath(),
|
2018-01-19 11:48:51 +05:30
|
|
|
pull.MergeBase, pull.GetGitRefName())
|
2015-09-02 18:56:56 +05:30
|
|
|
if err != nil {
|
2020-10-20 18:22:54 +05:30
|
|
|
if strings.Contains(err.Error(), "fatal: Not a valid object name") || strings.Contains(err.Error(), "unknown revision or path not in the working tree") {
|
2018-08-01 08:30:35 +05:30
|
|
|
ctx.Data["IsPullRequestBroken"] = true
|
2020-03-03 04:01:55 +05:30
|
|
|
ctx.Data["BaseTarget"] = pull.BaseBranch
|
2018-01-19 11:48:51 +05:30
|
|
|
ctx.Data["NumCommits"] = 0
|
|
|
|
ctx.Data["NumFiles"] = 0
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-08 01:59:29 +05:30
|
|
|
ctx.ServerError("GetCompareInfo", err)
|
2018-01-19 11:48:51 +05:30
|
|
|
return nil
|
2015-09-02 18:56:56 +05:30
|
|
|
}
|
2019-06-12 05:02:08 +05:30
|
|
|
ctx.Data["NumCommits"] = compareInfo.Commits.Len()
|
|
|
|
ctx.Data["NumFiles"] = compareInfo.NumFiles
|
2020-12-18 18:07:55 +05:30
|
|
|
|
|
|
|
if compareInfo.Commits.Len() != 0 {
|
|
|
|
sha := compareInfo.Commits.Front().Value.(*git.Commit).ID.String()
|
|
|
|
commitStatuses, err := models.GetLatestCommitStatus(ctx.Repo.Repository.ID, sha, models.ListOptions{})
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetLatestCommitStatus", err)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if len(commitStatuses) != 0 {
|
|
|
|
ctx.Data["LatestCommitStatuses"] = commitStatuses
|
|
|
|
ctx.Data["LatestCommitStatus"] = models.CalcCommitStatus(commitStatuses)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-12 05:02:08 +05:30
|
|
|
return compareInfo
|
2015-09-02 18:56:56 +05:30
|
|
|
}
|
|
|
|
|
2016-11-24 12:34:31 +05:30
|
|
|
// PrepareViewPullInfo show meta information for a pull request preview page
|
2019-06-08 01:59:29 +05:30
|
|
|
func PrepareViewPullInfo(ctx *context.Context, issue *models.Issue) *git.CompareInfo {
|
2015-09-02 13:38:05 +05:30
|
|
|
repo := ctx.Repo.Repository
|
2016-08-16 22:49:09 +05:30
|
|
|
pull := issue.PullRequest
|
2015-09-02 13:38:05 +05:30
|
|
|
|
2020-03-03 04:01:55 +05:30
|
|
|
if err := pull.LoadHeadRepo(); err != nil {
|
|
|
|
ctx.ServerError("LoadHeadRepo", err)
|
2015-10-24 13:06:47 +05:30
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-03-03 04:01:55 +05:30
|
|
|
if err := pull.LoadBaseRepo(); err != nil {
|
|
|
|
ctx.ServerError("LoadBaseRepo", err)
|
2020-01-07 22:36:14 +05:30
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-10-04 23:05:01 +05:30
|
|
|
setMergeTarget(ctx, pull)
|
|
|
|
|
2020-01-07 22:36:14 +05:30
|
|
|
if err := pull.LoadProtectedBranch(); err != nil {
|
2020-01-17 11:33:40 +05:30
|
|
|
ctx.ServerError("LoadProtectedBranch", err)
|
2019-09-18 11:09:45 +05:30
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ctx.Data["EnableStatusCheck"] = pull.ProtectedBranch != nil && pull.ProtectedBranch.EnableStatusCheck
|
|
|
|
|
2020-01-07 22:36:14 +05:30
|
|
|
baseGitRepo, err := git.OpenRepository(pull.BaseRepo.RepoPath())
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("OpenRepository", err)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
defer baseGitRepo.Close()
|
2020-03-06 00:21:21 +05:30
|
|
|
|
|
|
|
if !baseGitRepo.IsBranchExist(pull.BaseBranch) {
|
|
|
|
ctx.Data["IsPullRequestBroken"] = true
|
|
|
|
ctx.Data["BaseTarget"] = pull.BaseBranch
|
|
|
|
ctx.Data["HeadTarget"] = pull.HeadBranch
|
2020-03-31 19:12:44 +05:30
|
|
|
|
|
|
|
sha, err := baseGitRepo.GetRefCommitID(pull.GetGitRefName())
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError(fmt.Sprintf("GetRefCommitID(%s)", pull.GetGitRefName()), err)
|
|
|
|
return nil
|
|
|
|
}
|
2020-12-18 09:03:32 +05:30
|
|
|
commitStatuses, err := models.GetLatestCommitStatus(repo.ID, sha, models.ListOptions{})
|
2020-03-31 19:12:44 +05:30
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetLatestCommitStatus", err)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if len(commitStatuses) > 0 {
|
|
|
|
ctx.Data["LatestCommitStatuses"] = commitStatuses
|
|
|
|
ctx.Data["LatestCommitStatus"] = models.CalcCommitStatus(commitStatuses)
|
|
|
|
}
|
|
|
|
|
|
|
|
compareInfo, err := baseGitRepo.GetCompareInfo(pull.BaseRepo.RepoPath(),
|
|
|
|
pull.MergeBase, pull.GetGitRefName())
|
|
|
|
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"] = compareInfo.Commits.Len()
|
|
|
|
ctx.Data["NumFiles"] = compareInfo.NumFiles
|
|
|
|
return compareInfo
|
2020-03-06 00:21:21 +05:30
|
|
|
}
|
|
|
|
|
2019-06-30 13:27:59 +05:30
|
|
|
var headBranchExist bool
|
2020-01-07 22:36:14 +05:30
|
|
|
var headBranchSha string
|
2019-06-30 13:27:59 +05:30
|
|
|
// HeadRepo may be missing
|
2015-10-05 06:24:06 +05:30
|
|
|
if pull.HeadRepo != nil {
|
2020-01-07 22:36:14 +05:30
|
|
|
headGitRepo, err := git.OpenRepository(pull.HeadRepo.RepoPath())
|
2015-10-05 06:24:06 +05:30
|
|
|
if err != nil {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("OpenRepository", err)
|
2015-10-05 06:24:06 +05:30
|
|
|
return nil
|
|
|
|
}
|
2019-11-13 12:31:19 +05:30
|
|
|
defer headGitRepo.Close()
|
2019-06-30 13:27:59 +05:30
|
|
|
|
2021-07-28 15:12:56 +05:30
|
|
|
if pull.Flow == models.PullRequestFlowGithub {
|
|
|
|
headBranchExist = headGitRepo.IsBranchExist(pull.HeadBranch)
|
|
|
|
} else {
|
|
|
|
headBranchExist = git.IsReferenceExist(baseGitRepo.Path, pull.GetGitRefName())
|
|
|
|
}
|
2019-06-30 13:27:59 +05:30
|
|
|
|
|
|
|
if headBranchExist {
|
2021-07-28 15:12:56 +05:30
|
|
|
if pull.Flow != models.PullRequestFlowGithub {
|
|
|
|
headBranchSha, err = baseGitRepo.GetRefCommitID(pull.GetGitRefName())
|
|
|
|
} else {
|
|
|
|
headBranchSha, err = headGitRepo.GetBranchCommitID(pull.HeadBranch)
|
|
|
|
}
|
2019-06-30 13:27:59 +05:30
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetBranchCommitID", err)
|
|
|
|
return nil
|
|
|
|
}
|
2020-01-07 22:36:14 +05:30
|
|
|
}
|
|
|
|
}
|
2019-06-30 13:27:59 +05:30
|
|
|
|
2020-01-25 08:18:22 +05:30
|
|
|
if headBranchExist {
|
2020-04-14 19:23:34 +05:30
|
|
|
ctx.Data["UpdateAllowed"], err = pull_service.IsUserAllowedToUpdate(pull, ctx.User)
|
2020-01-25 08:18:22 +05:30
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("IsUserAllowedToUpdate", err)
|
|
|
|
return nil
|
|
|
|
}
|
2020-12-21 22:16:14 +05:30
|
|
|
ctx.Data["GetCommitMessages"] = pull_service.GetSquashMergeCommitMessages(pull)
|
2020-01-25 08:18:22 +05:30
|
|
|
}
|
|
|
|
|
2020-01-07 22:36:14 +05:30
|
|
|
sha, err := baseGitRepo.GetRefCommitID(pull.GetGitRefName())
|
|
|
|
if err != nil {
|
2020-06-08 23:37:41 +05:30
|
|
|
if git.IsErrNotExist(err) {
|
|
|
|
ctx.Data["IsPullRequestBroken"] = true
|
|
|
|
if pull.IsSameRepo() {
|
|
|
|
ctx.Data["HeadTarget"] = pull.HeadBranch
|
|
|
|
} else if pull.HeadRepo == nil {
|
|
|
|
ctx.Data["HeadTarget"] = "<deleted>:" + 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
|
|
|
|
}
|
2020-01-07 22:36:14 +05:30
|
|
|
ctx.ServerError(fmt.Sprintf("GetRefCommitID(%s)", pull.GetGitRefName()), err)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-12-18 09:03:32 +05:30
|
|
|
commitStatuses, err := models.GetLatestCommitStatus(repo.ID, sha, models.ListOptions{})
|
2020-01-07 22:36:14 +05:30
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetLatestCommitStatus", err)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if len(commitStatuses) > 0 {
|
|
|
|
ctx.Data["LatestCommitStatuses"] = commitStatuses
|
|
|
|
ctx.Data["LatestCommitStatus"] = models.CalcCommitStatus(commitStatuses)
|
|
|
|
}
|
2019-09-18 11:09:45 +05:30
|
|
|
|
2020-01-07 22:36:14 +05:30
|
|
|
if pull.ProtectedBranch != nil && pull.ProtectedBranch.EnableStatusCheck {
|
|
|
|
ctx.Data["is_context_required"] = func(context string) bool {
|
|
|
|
for _, c := range pull.ProtectedBranch.StatusCheckContexts {
|
|
|
|
if c == context {
|
|
|
|
return true
|
2019-09-18 11:09:45 +05:30
|
|
|
}
|
|
|
|
}
|
2020-01-07 22:36:14 +05:30
|
|
|
return false
|
2019-06-30 13:27:59 +05:30
|
|
|
}
|
2020-04-16 02:05:18 +05:30
|
|
|
ctx.Data["RequiredStatusCheckState"] = pull_service.MergeRequiredContextsCommitStatus(commitStatuses, pull.ProtectedBranch.StatusCheckContexts)
|
2015-09-02 13:38:05 +05:30
|
|
|
}
|
|
|
|
|
2020-01-07 22:36:14 +05:30
|
|
|
ctx.Data["HeadBranchMovedOn"] = headBranchSha != sha
|
|
|
|
ctx.Data["HeadBranchCommitID"] = headBranchSha
|
|
|
|
ctx.Data["PullHeadCommitID"] = sha
|
|
|
|
|
|
|
|
if pull.HeadRepo == nil || !headBranchExist || headBranchSha != sha {
|
2018-08-01 08:30:35 +05:30
|
|
|
ctx.Data["IsPullRequestBroken"] = true
|
2020-03-03 04:01:55 +05:30
|
|
|
if pull.IsSameRepo() {
|
|
|
|
ctx.Data["HeadTarget"] = pull.HeadBranch
|
2020-06-08 23:37:41 +05:30
|
|
|
} else if pull.HeadRepo == nil {
|
|
|
|
ctx.Data["HeadTarget"] = "<deleted>:" + pull.HeadBranch
|
2020-03-03 04:01:55 +05:30
|
|
|
} else {
|
2020-06-08 23:37:41 +05:30
|
|
|
ctx.Data["HeadTarget"] = pull.HeadRepo.OwnerName + ":" + pull.HeadBranch
|
2020-03-03 04:01:55 +05:30
|
|
|
}
|
2015-09-02 18:56:56 +05:30
|
|
|
}
|
|
|
|
|
2020-01-07 22:36:14 +05:30
|
|
|
compareInfo, err := baseGitRepo.GetCompareInfo(pull.BaseRepo.RepoPath(),
|
2020-06-12 05:19:47 +05:30
|
|
|
git.BranchPrefix+pull.BaseBranch, pull.GetGitRefName())
|
2015-09-02 13:38:05 +05:30
|
|
|
if err != nil {
|
2016-07-23 16:05:16 +05:30
|
|
|
if strings.Contains(err.Error(), "fatal: Not a valid object name") {
|
2018-08-01 08:30:35 +05:30
|
|
|
ctx.Data["IsPullRequestBroken"] = true
|
2020-03-03 04:01:55 +05:30
|
|
|
ctx.Data["BaseTarget"] = pull.BaseBranch
|
2016-07-23 16:05:16 +05:30
|
|
|
ctx.Data["NumCommits"] = 0
|
|
|
|
ctx.Data["NumFiles"] = 0
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-08 01:59:29 +05:30
|
|
|
ctx.ServerError("GetCompareInfo", err)
|
2015-09-02 13:38:05 +05:30
|
|
|
return nil
|
|
|
|
}
|
2018-08-14 00:34:39 +05:30
|
|
|
|
2021-05-28 01:32:04 +05:30
|
|
|
ctx.Data["PullRequestWorkInProgressPrefixes"] = setting.Repository.PullRequest.WorkInProgressPrefixes
|
|
|
|
|
2018-08-14 00:34:39 +05:30
|
|
|
if pull.IsWorkInProgress() {
|
|
|
|
ctx.Data["IsPullWorkInProgress"] = true
|
|
|
|
ctx.Data["WorkInProgressPrefix"] = pull.GetWorkInProgressPrefix()
|
|
|
|
}
|
|
|
|
|
2019-02-05 17:24:49 +05:30
|
|
|
if pull.IsFilesConflicted() {
|
|
|
|
ctx.Data["IsPullFilesConflicted"] = true
|
|
|
|
ctx.Data["ConflictedFiles"] = pull.ConflictedFiles
|
|
|
|
}
|
|
|
|
|
2019-06-12 05:02:08 +05:30
|
|
|
ctx.Data["NumCommits"] = compareInfo.Commits.Len()
|
|
|
|
ctx.Data["NumFiles"] = compareInfo.NumFiles
|
|
|
|
return compareInfo
|
2015-09-02 13:38:05 +05:30
|
|
|
}
|
|
|
|
|
2016-11-24 12:34:31 +05:30
|
|
|
// ViewPullCommits show commits for a pull request
|
2016-03-11 22:26:52 +05:30
|
|
|
func ViewPullCommits(ctx *context.Context) {
|
2016-08-14 16:02:24 +05:30
|
|
|
ctx.Data["PageIsPullList"] = true
|
2015-09-02 13:38:05 +05:30
|
|
|
ctx.Data["PageIsPullCommits"] = true
|
|
|
|
|
2016-08-16 22:49:09 +05:30
|
|
|
issue := checkPullInfo(ctx)
|
2015-09-02 13:38:05 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
2016-08-16 22:49:09 +05:30
|
|
|
pull := issue.PullRequest
|
2015-09-02 13:38:05 +05:30
|
|
|
|
2015-09-02 18:56:56 +05:30
|
|
|
var commits *list.List
|
2019-12-19 00:07:44 +05:30
|
|
|
var prInfo *git.CompareInfo
|
2015-09-02 18:56:56 +05:30
|
|
|
if pull.HasMerged {
|
2019-12-19 00:07:44 +05:30
|
|
|
prInfo = PrepareMergedViewPullInfo(ctx, issue)
|
2015-09-02 18:56:56 +05:30
|
|
|
} else {
|
2019-12-19 00:07:44 +05:30
|
|
|
prInfo = PrepareViewPullInfo(ctx, issue)
|
2015-09-02 13:38:05 +05:30
|
|
|
}
|
|
|
|
|
2019-12-19 00:07:44 +05:30
|
|
|
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 = prInfo.Commits
|
2015-09-02 18:56:56 +05:30
|
|
|
commits = models.ValidateCommitsWithEmails(commits)
|
2020-02-28 00:50:55 +05:30
|
|
|
commits = models.ParseCommitsWithSignature(commits, ctx.Repo.Repository)
|
2017-05-07 20:10:31 +05:30
|
|
|
commits = models.ParseCommitsWithStatus(commits, ctx.Repo.Repository)
|
2015-09-02 18:56:56 +05:30
|
|
|
ctx.Data["Commits"] = commits
|
|
|
|
ctx.Data["CommitCount"] = commits.Len()
|
|
|
|
|
2019-12-16 11:50:25 +05:30
|
|
|
getBranchData(ctx, issue)
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.HTML(http.StatusOK, tplPullCommits)
|
2015-09-02 13:38:05 +05:30
|
|
|
}
|
|
|
|
|
2016-11-24 12:34:31 +05:30
|
|
|
// ViewPullFiles render pull request changed files list page
|
2016-03-11 22:26:52 +05:30
|
|
|
func ViewPullFiles(ctx *context.Context) {
|
2016-08-14 16:02:24 +05:30
|
|
|
ctx.Data["PageIsPullList"] = true
|
2015-09-02 13:38:05 +05:30
|
|
|
ctx.Data["PageIsPullFiles"] = true
|
|
|
|
|
2016-08-16 22:49:09 +05:30
|
|
|
issue := checkPullInfo(ctx)
|
2015-09-02 13:38:05 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
2016-08-16 22:49:09 +05:30
|
|
|
pull := issue.PullRequest
|
2015-09-02 13:38:05 +05:30
|
|
|
|
2015-09-02 18:56:56 +05:30
|
|
|
var (
|
|
|
|
diffRepoPath string
|
|
|
|
startCommitID string
|
|
|
|
endCommitID string
|
|
|
|
gitRepo *git.Repository
|
|
|
|
)
|
|
|
|
|
2019-12-19 00:07:44 +05:30
|
|
|
var prInfo *git.CompareInfo
|
2015-09-02 18:56:56 +05:30
|
|
|
if pull.HasMerged {
|
2019-12-19 00:07:44 +05:30
|
|
|
prInfo = PrepareMergedViewPullInfo(ctx, issue)
|
2015-09-02 18:56:56 +05:30
|
|
|
} else {
|
2019-12-19 00:07:44 +05:30
|
|
|
prInfo = PrepareViewPullInfo(ctx, issue)
|
|
|
|
}
|
2015-09-02 13:38:05 +05:30
|
|
|
|
2019-12-19 00:07:44 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
} else if prInfo == nil {
|
|
|
|
ctx.NotFound("ViewPullFiles", nil)
|
|
|
|
return
|
|
|
|
}
|
2015-09-02 13:38:05 +05:30
|
|
|
|
2019-12-19 00:07:44 +05:30
|
|
|
diffRepoPath = ctx.Repo.GitRepo.Path
|
|
|
|
gitRepo = ctx.Repo.GitRepo
|
2015-09-02 18:56:56 +05:30
|
|
|
|
2019-12-19 00:07:44 +05:30
|
|
|
headCommitID, err := gitRepo.GetRefCommitID(pull.GetGitRefName())
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetRefCommitID", err)
|
|
|
|
return
|
|
|
|
}
|
2015-09-02 18:56:56 +05:30
|
|
|
|
2019-12-19 00:07:44 +05:30
|
|
|
startCommitID = prInfo.MergeBase
|
|
|
|
endCommitID = headCommitID
|
2017-06-21 03:55:38 +05:30
|
|
|
|
2019-12-19 00:07:44 +05:30
|
|
|
ctx.Data["Username"] = ctx.Repo.Owner.Name
|
|
|
|
ctx.Data["Reponame"] = ctx.Repo.Repository.Name
|
2019-11-15 08:22:59 +05:30
|
|
|
ctx.Data["AfterCommitID"] = endCommitID
|
2015-09-02 13:38:05 +05:30
|
|
|
|
2019-09-06 07:50:09 +05:30
|
|
|
diff, err := gitdiff.GetDiffRangeWithWhitespaceBehavior(diffRepoPath,
|
2016-06-29 20:41:00 +05:30
|
|
|
startCommitID, endCommitID, setting.Git.MaxGitDiffLines,
|
2018-08-14 23:19:33 +05:30
|
|
|
setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles,
|
2021-02-13 10:05:43 +05:30
|
|
|
gitdiff.GetWhitespaceFlag(ctx.Data["WhitespaceBehavior"].(string)))
|
2015-09-02 13:38:05 +05:30
|
|
|
if err != nil {
|
2018-08-14 23:19:33 +05:30
|
|
|
ctx.ServerError("GetDiffRangeWithWhitespaceBehavior", err)
|
2015-09-02 13:38:05 +05:30
|
|
|
return
|
|
|
|
}
|
2018-08-06 10:13:22 +05:30
|
|
|
|
|
|
|
if err = diff.LoadComments(issue, ctx.User); err != nil {
|
|
|
|
ctx.ServerError("LoadComments", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-10-14 00:20:57 +05:30
|
|
|
if err = pull.LoadProtectedBranch(); err != nil {
|
|
|
|
ctx.ServerError("LoadProtectedBranch", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if pull.ProtectedBranch != nil {
|
|
|
|
glob := pull.ProtectedBranch.GetProtectedFilePatterns()
|
|
|
|
if len(glob) != 0 {
|
|
|
|
for _, file := range diff.Files {
|
|
|
|
file.IsProtected = pull.ProtectedBranch.IsProtectedFile(glob, file.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-02 13:38:05 +05:30
|
|
|
ctx.Data["Diff"] = diff
|
2020-05-26 11:28:07 +05:30
|
|
|
ctx.Data["DiffNotAvailable"] = diff.NumFiles == 0
|
2015-09-02 13:38:05 +05:30
|
|
|
|
2019-09-16 14:33:22 +05:30
|
|
|
baseCommit, err := ctx.Repo.GitRepo.GetCommit(startCommitID)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetCommit", err)
|
|
|
|
return
|
|
|
|
}
|
2015-09-02 18:56:56 +05:30
|
|
|
commit, err := gitRepo.GetCommit(endCommitID)
|
2015-09-02 13:38:05 +05:30
|
|
|
if err != nil {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("GetCommit", err)
|
2015-09-02 13:38:05 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-04-18 19:20:25 +05:30
|
|
|
if ctx.IsSigned && ctx.User != nil {
|
|
|
|
if ctx.Data["CanMarkConversation"], err = models.CanMarkConversation(issue, ctx.User); err != nil {
|
|
|
|
ctx.ServerError("CanMarkConversation", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-30 02:14:28 +05:30
|
|
|
headTarget := path.Join(ctx.Repo.Owner.Name, ctx.Repo.Repository.Name)
|
|
|
|
setCompareContext(ctx, baseCommit, commit, headTarget)
|
2019-09-16 14:33:22 +05:30
|
|
|
|
2016-01-31 21:49:02 +05:30
|
|
|
ctx.Data["RequireHighlightJS"] = true
|
2019-12-18 09:29:59 +05:30
|
|
|
ctx.Data["RequireSimpleMDE"] = true
|
2018-08-06 10:13:22 +05:30
|
|
|
ctx.Data["RequireTribute"] = true
|
|
|
|
if ctx.Data["Assignees"], err = ctx.Repo.Repository.GetAssignees(); err != nil {
|
|
|
|
ctx.ServerError("GetAssignees", err)
|
|
|
|
return
|
|
|
|
}
|
2020-12-21 21:09:28 +05:30
|
|
|
handleTeamMentions(ctx)
|
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
2018-08-06 10:13:22 +05:30
|
|
|
ctx.Data["CurrentReview"], err = models.GetCurrentReview(ctx.User, issue)
|
|
|
|
if err != nil && !models.IsErrReviewNotExist(err) {
|
|
|
|
ctx.ServerError("GetCurrentReview", err)
|
|
|
|
return
|
|
|
|
}
|
2019-12-16 11:50:25 +05:30
|
|
|
getBranchData(ctx, issue)
|
2020-03-06 07:27:18 +05:30
|
|
|
ctx.Data["IsIssuePoster"] = ctx.IsSigned && issue.IsPoster(ctx.User.ID)
|
2020-04-04 11:09:48 +05:30
|
|
|
ctx.Data["HasIssuesOrPullsWritePermission"] = ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull)
|
2021-06-15 06:42:33 +05:30
|
|
|
|
|
|
|
ctx.Data["IsAttachmentEnabled"] = setting.Attachment.Enabled
|
|
|
|
upload.AddUploadContext(ctx, "comment")
|
|
|
|
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.HTML(http.StatusOK, tplPullFiles)
|
2015-09-02 13:38:05 +05:30
|
|
|
}
|
2015-08-31 12:54:28 +05:30
|
|
|
|
2020-08-05 02:25:22 +05:30
|
|
|
// UpdatePullRequest merge PR's baseBranch into headBranch
|
2020-01-17 11:33:40 +05:30
|
|
|
func UpdatePullRequest(ctx *context.Context) {
|
|
|
|
issue := checkPullInfo(ctx)
|
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if issue.IsClosed {
|
|
|
|
ctx.NotFound("MergePullRequest", nil)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if issue.PullRequest.HasMerged {
|
|
|
|
ctx.NotFound("MergePullRequest", nil)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := issue.PullRequest.LoadBaseRepo(); err != nil {
|
2021-01-15 01:57:22 +05:30
|
|
|
ctx.ServerError("LoadBaseRepo", err)
|
2020-01-17 11:33:40 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
if err := issue.PullRequest.LoadHeadRepo(); err != nil {
|
2021-01-15 01:57:22 +05:30
|
|
|
ctx.ServerError("LoadHeadRepo", err)
|
2020-01-17 11:33:40 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
allowedUpdate, err := pull_service.IsUserAllowedToUpdate(issue.PullRequest, ctx.User)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("IsUserAllowedToMerge", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// ToDo: add check if maintainers are allowed to change branch ... (need migration & co)
|
|
|
|
if !allowedUpdate {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.update_not_allowed"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
|
2020-01-17 11:33:40 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// default merge commit message
|
|
|
|
message := fmt.Sprintf("Merge branch '%s' into %s", issue.PullRequest.BaseBranch, issue.PullRequest.HeadBranch)
|
|
|
|
|
|
|
|
if err = pull_service.Update(issue.PullRequest, ctx.User, message); err != nil {
|
|
|
|
if models.IsErrMergeConflicts(err) {
|
|
|
|
conflictError := err.(models.ErrMergeConflicts)
|
2020-10-21 05:20:10 +05:30
|
|
|
flashError, err := ctx.HTMLString(string(tplAlertDetails), map[string]interface{}{
|
|
|
|
"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)
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
|
2020-01-17 11:33:40 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.Flash.Error(err.Error())
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
|
2020-08-04 02:20:29 +05:30
|
|
|
return
|
2020-01-17 11:33:40 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
time.Sleep(1 * time.Second)
|
|
|
|
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.pulls.update_branch_success"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
|
2020-01-17 11:33:40 +05:30
|
|
|
}
|
|
|
|
|
2016-11-24 12:34:31 +05:30
|
|
|
// MergePullRequest response for merging pull request
|
2021-01-26 21:06:53 +05:30
|
|
|
func MergePullRequest(ctx *context.Context) {
|
2021-04-07 01:14:05 +05:30
|
|
|
form := web.GetForm(ctx).(*forms.MergePullRequestForm)
|
2015-10-19 05:00:39 +05:30
|
|
|
issue := checkPullInfo(ctx)
|
2015-09-02 18:56:56 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
2015-10-19 05:00:39 +05:30
|
|
|
if issue.IsClosed {
|
2020-01-27 15:56:53 +05:30
|
|
|
if issue.IsPull {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.is_closed"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
|
2020-01-27 15:56:53 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.issues.closed_title"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/issues/" + fmt.Sprint(issue.Index))
|
2015-09-02 18:56:56 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-12-13 21:25:43 +05:30
|
|
|
pr := issue.PullRequest
|
2015-09-02 18:56:56 +05:30
|
|
|
|
2020-01-11 12:59:34 +05:30
|
|
|
allowedMerge, err := pull_service.IsUserAllowedToMerge(pr, ctx.Repo.Permission, ctx.User)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("IsUserAllowedToMerge", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if !allowedMerge {
|
2020-01-27 15:56:53 +05:30
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.update_not_allowed"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
|
2020-01-11 12:59:34 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-03-04 09:11:23 +05:30
|
|
|
if pr.HasMerged {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.has_merged"))
|
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
|
2020-01-27 15:56:53 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-03-04 09:11:23 +05:30
|
|
|
// handle manually-merged mark
|
|
|
|
if models.MergeStyle(form.Do) == models.MergeStyleManuallyMerged {
|
|
|
|
if err = pull_service.MergedManually(pr, ctx.User, ctx.Repo.GitRepo, form.MergeCommitID); err != nil {
|
|
|
|
if models.IsErrInvalidMergeStyle(err) {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.invalid_merge_option"))
|
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
|
|
|
|
return
|
|
|
|
} else if strings.Contains(err.Error(), "Wrong commit ID") {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.wrong_commit_id"))
|
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.ServerError("MergedManually", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if !pr.CanAutoMerge() {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.no_merge_not_ready"))
|
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
|
2015-09-02 18:56:56 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-08-14 00:34:39 +05:30
|
|
|
if pr.IsWorkInProgress() {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.no_merge_wip"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2018-08-14 00:34:39 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-10-14 00:20:57 +05:30
|
|
|
if err := pull_service.CheckPRReadyToMerge(pr, false); err != nil {
|
2020-01-11 12:59:34 +05:30
|
|
|
if !models.IsErrNotAllowedToMerge(err) {
|
|
|
|
ctx.ServerError("Merge PR status", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if isRepoAdmin, err := models.IsUserRepoAdmin(pr.BaseRepo, ctx.User); err != nil {
|
|
|
|
ctx.ServerError("IsUserRepoAdmin", err)
|
|
|
|
return
|
|
|
|
} else if !isRepoAdmin {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.no_merge_not_ready"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2020-01-11 12:59:34 +05:30
|
|
|
return
|
|
|
|
}
|
2019-09-18 11:09:45 +05:30
|
|
|
}
|
|
|
|
|
2018-01-06 00:26:50 +05:30
|
|
|
if ctx.HasError() {
|
|
|
|
ctx.Flash.Error(ctx.Data["ErrorMsg"].(string))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2018-01-06 00:26:50 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
message := strings.TrimSpace(form.MergeTitleField)
|
|
|
|
if len(message) == 0 {
|
|
|
|
if models.MergeStyle(form.Do) == models.MergeStyleMerge {
|
|
|
|
message = pr.GetDefaultMergeMessage()
|
|
|
|
}
|
2018-12-27 15:57:08 +05:30
|
|
|
if models.MergeStyle(form.Do) == models.MergeStyleRebaseMerge {
|
|
|
|
message = pr.GetDefaultMergeMessage()
|
|
|
|
}
|
2018-01-06 00:26:50 +05:30
|
|
|
if models.MergeStyle(form.Do) == models.MergeStyleSquash {
|
|
|
|
message = pr.GetDefaultSquashMessage()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
form.MergeMessageField = strings.TrimSpace(form.MergeMessageField)
|
|
|
|
if len(form.MergeMessageField) > 0 {
|
|
|
|
message += "\n\n" + form.MergeMessageField
|
|
|
|
}
|
|
|
|
|
2015-10-19 05:00:39 +05:30
|
|
|
pr.Issue = issue
|
|
|
|
pr.Issue.Repo = ctx.Repo.Repository
|
2018-07-18 02:53:58 +05:30
|
|
|
|
|
|
|
noDeps, err := models.IssueNoDependenciesLeft(issue)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if !noDeps {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.issues.dependency.pr_close_blocked"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2018-07-18 02:53:58 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-09-27 05:52:36 +05:30
|
|
|
if err = pull_service.Merge(pr, ctx.User, ctx.Repo.GitRepo, models.MergeStyle(form.Do), message); err != nil {
|
2018-01-06 00:26:50 +05:30
|
|
|
if models.IsErrInvalidMergeStyle(err) {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.invalid_merge_option"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2018-01-06 00:26:50 +05:30
|
|
|
return
|
2019-11-10 14:12:51 +05:30
|
|
|
} else if models.IsErrMergeConflicts(err) {
|
|
|
|
conflictError := err.(models.ErrMergeConflicts)
|
2020-10-21 05:20:10 +05:30
|
|
|
flashError, err := ctx.HTMLString(string(tplAlertDetails), map[string]interface{}{
|
|
|
|
"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)
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2019-11-10 14:12:51 +05:30
|
|
|
return
|
|
|
|
} else if models.IsErrRebaseConflicts(err) {
|
|
|
|
conflictError := err.(models.ErrRebaseConflicts)
|
2020-10-21 05:20:10 +05:30
|
|
|
flashError, err := ctx.HTMLString(string(tplAlertDetails), map[string]interface{}{
|
2020-10-22 01:29:12 +05:30
|
|
|
"Message": ctx.Tr("repo.pulls.rebase_conflict", utils.SanitizeFlashErrorString(conflictError.CommitSHA)),
|
|
|
|
"Summary": ctx.Tr("repo.pulls.rebase_conflict_summary"),
|
2020-10-21 05:20:10 +05:30
|
|
|
"Details": utils.SanitizeFlashErrorString(conflictError.StdErr) + "<br>" + utils.SanitizeFlashErrorString(conflictError.StdOut),
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("MergePullRequest.HTMLString", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.Flash.Error(flashError)
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2019-11-10 14:12:51 +05:30
|
|
|
return
|
|
|
|
} else if models.IsErrMergeUnrelatedHistories(err) {
|
|
|
|
log.Debug("MergeUnrelatedHistories error: %v", err)
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.unrelated_histories"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2019-11-10 14:12:51 +05:30
|
|
|
return
|
2020-03-28 09:43:18 +05:30
|
|
|
} else if git.IsErrPushOutOfDate(err) {
|
2019-11-10 14:12:51 +05:30
|
|
|
log.Debug("MergePushOutOfDate error: %v", err)
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.merge_out_of_date"))
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2019-11-10 14:12:51 +05:30
|
|
|
return
|
2020-03-28 09:43:18 +05:30
|
|
|
} else if git.IsErrPushRejected(err) {
|
2020-02-22 18:38:48 +05:30
|
|
|
log.Debug("MergePushRejected error: %v", err)
|
2020-03-28 09:43:18 +05:30
|
|
|
pushrejErr := err.(*git.ErrPushRejected)
|
2020-02-22 18:38:48 +05:30
|
|
|
message := pushrejErr.Message
|
|
|
|
if len(message) == 0 {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.push_rejected_no_message"))
|
|
|
|
} else {
|
2020-10-21 05:20:10 +05:30
|
|
|
flashError, err := ctx.HTMLString(string(tplAlertDetails), map[string]interface{}{
|
|
|
|
"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)
|
2020-02-22 18:38:48 +05:30
|
|
|
}
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2020-02-22 18:38:48 +05:30
|
|
|
return
|
2018-01-06 00:26:50 +05:30
|
|
|
}
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("Merge", err)
|
2015-09-02 18:56:56 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-02-05 17:08:11 +05:30
|
|
|
if err := stopTimerIfAvailable(ctx.User, issue); err != nil {
|
|
|
|
ctx.ServerError("CreateOrStopIssueStopwatch", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-09-02 18:56:56 +05:30
|
|
|
log.Trace("Pull request merged: %d", pr.ID)
|
2021-07-13 04:56:25 +05:30
|
|
|
|
|
|
|
if form.DeleteBranchAfterMerge {
|
|
|
|
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 = git.OpenRepository(pr.HeadRepo.RepoPath())
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError(fmt.Sprintf("OpenRepository[%s]", pr.HeadRepo.RepoPath()), err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
defer headRepo.Close()
|
|
|
|
}
|
|
|
|
deleteBranch(ctx, pr, headRepo)
|
|
|
|
}
|
|
|
|
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
|
2015-09-02 18:56:56 +05:30
|
|
|
}
|
|
|
|
|
2019-02-05 17:08:11 +05:30
|
|
|
func stopTimerIfAvailable(user *models.User, issue *models.Issue) error {
|
|
|
|
|
|
|
|
if models.StopwatchExists(user.ID, issue.ID) {
|
|
|
|
if err := models.CreateOrStopIssueStopwatch(user, issue); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-11-24 12:34:31 +05:30
|
|
|
// CompareAndPullRequestPost response for creating pull request
|
2021-01-26 21:06:53 +05:30
|
|
|
func CompareAndPullRequestPost(ctx *context.Context) {
|
2021-04-07 01:14:05 +05:30
|
|
|
form := web.GetForm(ctx).(*forms.CreateIssueForm)
|
2015-09-02 04:37:02 +05:30
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.pulls.compare_changes")
|
|
|
|
ctx.Data["PageIsComparePull"] = true
|
|
|
|
ctx.Data["IsDiffCompare"] = true
|
2021-07-25 08:29:27 +05:30
|
|
|
ctx.Data["IsRepoToolbarCommits"] = true
|
|
|
|
ctx.Data["RequireTribute"] = true
|
|
|
|
ctx.Data["RequireSimpleMDE"] = true
|
2016-08-16 02:34:44 +05:30
|
|
|
ctx.Data["RequireHighlightJS"] = true
|
2018-08-14 00:34:39 +05:30
|
|
|
ctx.Data["PullRequestWorkInProgressPrefixes"] = setting.Repository.PullRequest.WorkInProgressPrefixes
|
2020-10-05 11:19:33 +05:30
|
|
|
ctx.Data["IsAttachmentEnabled"] = setting.Attachment.Enabled
|
|
|
|
upload.AddUploadContext(ctx, "comment")
|
2021-07-25 08:29:27 +05:30
|
|
|
ctx.Data["HasIssuesOrPullsWritePermission"] = ctx.Repo.CanWrite(models.UnitTypePullRequests)
|
2015-09-02 04:37:02 +05:30
|
|
|
|
|
|
|
var (
|
|
|
|
repo = ctx.Repo.Repository
|
|
|
|
attachments []string
|
|
|
|
)
|
|
|
|
|
2015-09-02 04:56:39 +05:30
|
|
|
headUser, headRepo, headGitRepo, prInfo, baseBranch, headBranch := ParseCompareInfo(ctx)
|
2015-09-02 04:37:02 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
2019-11-13 12:31:19 +05:30
|
|
|
defer headGitRepo.Close()
|
2015-09-02 04:37:02 +05:30
|
|
|
|
2021-01-26 21:06:53 +05:30
|
|
|
labelIDs, assigneeIDs, milestoneID, _ := ValidateRepoMetas(ctx, *form, true)
|
2015-09-02 04:37:02 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-08-18 09:53:45 +05:30
|
|
|
if setting.Attachment.Enabled {
|
2016-08-11 18:18:08 +05:30
|
|
|
attachments = form.Files
|
2015-09-02 04:37:02 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
if ctx.HasError() {
|
2021-01-30 14:25:53 +05:30
|
|
|
middleware.AssignForm(form, ctx.Data)
|
2016-08-16 02:34:44 +05:30
|
|
|
|
|
|
|
// This stage is already stop creating new pull request, so it does not matter if it has
|
|
|
|
// something to compare or not.
|
2021-02-13 10:05:43 +05:30
|
|
|
PrepareCompareDiff(ctx, headUser, headRepo, headGitRepo, prInfo, baseBranch, headBranch,
|
|
|
|
gitdiff.GetWhitespaceFlag(ctx.Data["WhitespaceBehavior"].(string)))
|
2016-08-16 02:34:44 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-07-25 08:29:27 +05:30
|
|
|
if len(form.Title) > 255 {
|
|
|
|
var trailer string
|
|
|
|
form.Title, trailer = util.SplitStringAtByteN(form.Title, 255)
|
|
|
|
|
|
|
|
form.Content = trailer + "\n\n" + form.Content
|
|
|
|
}
|
|
|
|
middleware.AssignForm(form, ctx.Data)
|
|
|
|
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.HTML(http.StatusOK, tplCompareDiff)
|
2015-09-02 04:37:02 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-01-21 17:15:32 +05:30
|
|
|
if util.IsEmptyString(form.Title) {
|
2021-02-13 10:05:43 +05:30
|
|
|
PrepareCompareDiff(ctx, headUser, headRepo, headGitRepo, prInfo, baseBranch, headBranch,
|
|
|
|
gitdiff.GetWhitespaceFlag(ctx.Data["WhitespaceBehavior"].(string)))
|
2019-01-21 17:15:32 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-06-08 01:59:29 +05:30
|
|
|
ctx.RenderWithErr(ctx.Tr("repo.issues.new.title_empty"), tplCompareDiff, form)
|
2019-01-21 17:15:32 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-02-24 18:26:54 +05:30
|
|
|
pullIssue := &models.Issue{
|
2015-09-02 04:37:02 +05:30
|
|
|
RepoID: repo.ID,
|
2016-08-14 16:02:24 +05:30
|
|
|
Title: form.Title,
|
2016-07-23 22:38:22 +05:30
|
|
|
PosterID: ctx.User.ID,
|
2015-09-02 04:37:02 +05:30
|
|
|
Poster: ctx.User,
|
|
|
|
MilestoneID: milestoneID,
|
|
|
|
IsPull: true,
|
|
|
|
Content: form.Content,
|
|
|
|
}
|
2016-02-24 18:26:54 +05:30
|
|
|
pullRequest := &models.PullRequest{
|
2019-10-18 16:43:31 +05:30
|
|
|
HeadRepoID: headRepo.ID,
|
|
|
|
BaseRepoID: repo.ID,
|
|
|
|
HeadBranch: headBranch,
|
|
|
|
BaseBranch: baseBranch,
|
|
|
|
HeadRepo: headRepo,
|
|
|
|
BaseRepo: repo,
|
|
|
|
MergeBase: prInfo.MergeBase,
|
|
|
|
Type: models.PullRequestGitea,
|
2016-02-24 18:26:54 +05:30
|
|
|
}
|
2016-08-16 02:34:44 +05:30
|
|
|
// FIXME: check error in the case two people send pull request at almost same time, give nice error prompt
|
|
|
|
// instead of 500.
|
2018-05-09 21:59:04 +05:30
|
|
|
|
2019-12-14 03:51:06 +05:30
|
|
|
if err := pull_service.NewPullRequest(repo, pullIssue, labelIDs, attachments, pullRequest, assigneeIDs); err != nil {
|
2018-05-09 21:59:04 +05:30
|
|
|
if models.IsErrUserDoesNotHaveAccessToRepo(err) {
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.Error(http.StatusBadRequest, "UserDoesNotHaveAccessToRepo", err.Error())
|
2018-05-09 21:59:04 +05:30
|
|
|
return
|
2020-06-08 23:37:41 +05:30
|
|
|
} else if git.IsErrPushRejected(err) {
|
|
|
|
pushrejErr := err.(*git.ErrPushRejected)
|
|
|
|
message := pushrejErr.Message
|
|
|
|
if len(message) == 0 {
|
|
|
|
ctx.Flash.Error(ctx.Tr("repo.pulls.push_rejected_no_message"))
|
|
|
|
} else {
|
2020-10-21 05:20:10 +05:30
|
|
|
flashError, err := ctx.HTMLString(string(tplAlertDetails), map[string]interface{}{
|
|
|
|
"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)
|
2020-06-08 23:37:41 +05:30
|
|
|
}
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pullIssue.Index))
|
2020-06-08 23:37:41 +05:30
|
|
|
return
|
2018-05-09 21:59:04 +05:30
|
|
|
}
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("NewPullRequest", err)
|
2015-09-02 04:37:02 +05:30
|
|
|
return
|
2015-12-10 21:48:56 +05:30
|
|
|
}
|
|
|
|
|
2016-02-24 18:26:54 +05:30
|
|
|
log.Trace("Pull request created: %d/%d", repo.ID, pullIssue.ID)
|
2020-12-25 15:29:32 +05:30
|
|
|
ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pullIssue.Index))
|
2014-03-24 15:55:15 +05:30
|
|
|
}
|
2015-10-24 13:06:47 +05:30
|
|
|
|
2016-11-24 12:34:31 +05:30
|
|
|
// TriggerTask response for a trigger task request
|
2016-03-11 22:26:52 +05:30
|
|
|
func TriggerTask(ctx *context.Context) {
|
2016-08-14 16:02:24 +05:30
|
|
|
pusherID := ctx.QueryInt64("pusher")
|
2015-12-15 03:36:54 +05:30
|
|
|
branch := ctx.Query("branch")
|
|
|
|
secret := ctx.Query("secret")
|
2016-08-14 16:02:24 +05:30
|
|
|
if len(branch) == 0 || len(secret) == 0 || pusherID <= 0 {
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.Error(http.StatusNotFound)
|
2016-08-14 16:02:24 +05:30
|
|
|
log.Trace("TriggerTask: branch or secret is empty, or pusher ID is not valid")
|
2015-12-15 03:36:54 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
owner, repo := parseOwnerAndRepo(ctx)
|
2015-10-24 13:06:47 +05:30
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
2019-07-06 22:33:13 +05:30
|
|
|
got := []byte(base.EncodeMD5(owner.Salt))
|
|
|
|
want := []byte(secret)
|
|
|
|
if subtle.ConstantTimeCompare(got, want) != 1 {
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.Error(http.StatusNotFound)
|
2015-12-15 03:36:54 +05:30
|
|
|
log.Trace("TriggerTask [%s/%s]: invalid secret", owner.Name, repo.Name)
|
2015-10-24 13:06:47 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-08-14 16:02:24 +05:30
|
|
|
pusher, err := models.GetUserByID(pusherID)
|
|
|
|
if err != nil {
|
|
|
|
if models.IsErrUserNotExist(err) {
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.Error(http.StatusNotFound)
|
2016-08-14 16:02:24 +05:30
|
|
|
} else {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("GetUserByID", err)
|
2016-08-14 16:02:24 +05:30
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Trace("TriggerTask '%s/%s' by %s", repo.Name, branch, pusher.Name)
|
2015-10-24 13:06:47 +05:30
|
|
|
|
2020-01-09 07:17:45 +05:30
|
|
|
go pull_service.AddTestPullRequestTask(pusher, repo.ID, branch, true, "", "")
|
2015-10-24 13:06:47 +05:30
|
|
|
ctx.Status(202)
|
|
|
|
}
|
2017-06-21 06:30:03 +05:30
|
|
|
|
|
|
|
// CleanUpPullRequest responses for delete merged branch when PR has been merged
|
|
|
|
func CleanUpPullRequest(ctx *context.Context) {
|
|
|
|
issue := checkPullInfo(ctx)
|
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-12-13 21:25:43 +05:30
|
|
|
pr := issue.PullRequest
|
2017-06-21 06:30:03 +05:30
|
|
|
|
2019-04-21 02:20:34 +05:30
|
|
|
// Don't cleanup unmerged and unclosed PRs
|
|
|
|
if !pr.HasMerged && !issue.IsClosed {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.NotFound("CleanUpPullRequest", nil)
|
2017-06-21 06:30:03 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-03-03 04:01:55 +05:30
|
|
|
if err := pr.LoadHeadRepo(); err != nil {
|
|
|
|
ctx.ServerError("LoadHeadRepo", err)
|
2017-06-21 06:30:03 +05:30
|
|
|
return
|
|
|
|
} else if pr.HeadRepo == nil {
|
|
|
|
// Forked repository has already been deleted
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.NotFound("CleanUpPullRequest", nil)
|
2017-06-21 06:30:03 +05:30
|
|
|
return
|
2020-03-03 04:01:55 +05:30
|
|
|
} else if err = pr.LoadBaseRepo(); err != nil {
|
|
|
|
ctx.ServerError("LoadBaseRepo", err)
|
2017-06-21 06:30:03 +05:30
|
|
|
return
|
2019-06-13 01:11:28 +05:30
|
|
|
} else if err = pr.HeadRepo.GetOwner(); err != nil {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("HeadRepo.GetOwner", err)
|
2017-06-21 06:30:03 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-11-28 16:56:14 +05:30
|
|
|
perm, err := models.GetUserRepoPermission(pr.HeadRepo, ctx.User)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetUserRepoPermission", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if !perm.CanWrite(models.UnitTypeCode) {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.NotFound("CleanUpPullRequest", nil)
|
2017-06-21 06:30:03 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
fullBranchName := pr.HeadRepo.Owner.Name + "/" + pr.HeadBranch
|
|
|
|
|
2021-07-13 04:56:25 +05:30
|
|
|
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 = git.OpenRepository(pr.BaseRepo.RepoPath())
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError(fmt.Sprintf("OpenRepository[%s]", pr.BaseRepo.RepoPath()), err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
defer gitBaseRepo.Close()
|
2017-06-21 06:30:03 +05:30
|
|
|
}
|
|
|
|
|
2021-07-13 04:56:25 +05:30
|
|
|
// 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 = git.OpenRepository(pr.HeadRepo.RepoPath())
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError(fmt.Sprintf("OpenRepository[%s]", pr.HeadRepo.RepoPath()), err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
defer gitRepo.Close()
|
2017-06-21 06:30:03 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
defer func() {
|
2021-04-05 21:00:52 +05:30
|
|
|
ctx.JSON(http.StatusOK, map[string]interface{}{
|
2020-12-25 15:29:32 +05:30
|
|
|
"redirect": pr.BaseRepo.Link() + "/pulls/" + fmt.Sprint(issue.Index),
|
2017-06-21 06:30:03 +05:30
|
|
|
})
|
|
|
|
}()
|
|
|
|
|
|
|
|
// Check if branch has no new commits
|
2018-01-30 17:59:39 +05:30
|
|
|
headCommitID, err := gitBaseRepo.GetRefCommitID(pr.GetGitRefName())
|
|
|
|
if err != nil {
|
2019-04-02 13:18:31 +05:30
|
|
|
log.Error("GetRefCommitID: %v", err)
|
2018-01-30 17:59:39 +05:30
|
|
|
ctx.Flash.Error(ctx.Tr("repo.branch.deletion_failed", fullBranchName))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
branchCommitID, err := gitRepo.GetBranchCommitID(pr.HeadBranch)
|
|
|
|
if err != nil {
|
2019-04-02 13:18:31 +05:30
|
|
|
log.Error("GetBranchCommitID: %v", err)
|
2018-01-30 17:59:39 +05:30
|
|
|
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
|
2017-06-21 06:30:03 +05:30
|
|
|
}
|
|
|
|
|
2021-07-13 04:56:25 +05:30
|
|
|
deleteBranch(ctx, pr, gitRepo)
|
|
|
|
}
|
|
|
|
|
|
|
|
func deleteBranch(ctx *context.Context, pr *models.PullRequest, gitRepo *git.Repository) {
|
|
|
|
fullBranchName := pr.HeadRepo.Owner.Name + "/" + pr.HeadBranch
|
2021-06-07 20:22:59 +05:30
|
|
|
if err := repo_service.DeleteBranch(ctx.User, 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, repo_service.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))
|
|
|
|
}
|
2017-06-21 06:30:03 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-07-13 04:56:25 +05:30
|
|
|
if err := models.AddDeletePRBranchComment(ctx.User, pr.BaseRepo, pr.IssueID, pr.HeadBranch); err != nil {
|
2017-06-21 06:30:03 +05:30
|
|
|
// Do not fail here as branch has already been deleted
|
2019-04-02 13:18:31 +05:30
|
|
|
log.Error("DeleteBranch: %v", err)
|
2017-06-21 06:30:03 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.branch.deletion_success", fullBranchName))
|
|
|
|
}
|
2018-01-05 16:26:52 +05:30
|
|
|
|
|
|
|
// DownloadPullDiff render a pull's raw diff
|
|
|
|
func DownloadPullDiff(ctx *context.Context) {
|
2019-12-14 03:51:06 +05:30
|
|
|
DownloadPullDiffOrPatch(ctx, false)
|
2018-01-05 16:26:52 +05:30
|
|
|
}
|
2018-01-07 18:40:20 +05:30
|
|
|
|
|
|
|
// DownloadPullPatch render a pull's raw patch
|
|
|
|
func DownloadPullPatch(ctx *context.Context) {
|
2019-12-14 03:51:06 +05:30
|
|
|
DownloadPullDiffOrPatch(ctx, true)
|
|
|
|
}
|
|
|
|
|
|
|
|
// DownloadPullDiffOrPatch render a pull's raw diff or patch
|
|
|
|
func DownloadPullDiffOrPatch(ctx *context.Context, patch bool) {
|
2018-01-07 18:40:20 +05:30
|
|
|
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
|
|
|
|
if err != nil {
|
|
|
|
if models.IsErrIssueNotExist(err) {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.NotFound("GetIssueByIndex", err)
|
2018-01-07 18:40:20 +05:30
|
|
|
} else {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.ServerError("GetIssueByIndex", err)
|
2018-01-07 18:40:20 +05:30
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return not found if it's not a pull request
|
|
|
|
if !issue.IsPull {
|
2018-01-11 03:04:17 +05:30
|
|
|
ctx.NotFound("DownloadPullDiff",
|
2018-01-07 18:40:20 +05:30
|
|
|
fmt.Errorf("Issue is not a pull request"))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-12-13 21:25:43 +05:30
|
|
|
if err = issue.LoadPullRequest(); err != nil {
|
|
|
|
ctx.ServerError("LoadPullRequest", err)
|
|
|
|
return
|
|
|
|
}
|
2018-01-07 18:40:20 +05:30
|
|
|
|
2018-12-13 21:25:43 +05:30
|
|
|
pr := issue.PullRequest
|
2018-01-07 18:40:20 +05:30
|
|
|
|
2019-12-14 03:51:06 +05:30
|
|
|
if err := pull_service.DownloadDiffOrPatch(pr, ctx, patch); err != nil {
|
|
|
|
ctx.ServerError("DownloadDiffOrPatch", err)
|
2018-01-07 18:40:20 +05:30
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2019-12-16 11:50:25 +05:30
|
|
|
|
|
|
|
// UpdatePullRequestTarget change pull request's target branch
|
|
|
|
func UpdatePullRequestTarget(ctx *context.Context) {
|
|
|
|
issue := GetActionIssue(ctx)
|
|
|
|
pr := issue.PullRequest
|
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if !issue.IsPull {
|
|
|
|
ctx.Error(http.StatusNotFound)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if !ctx.IsSigned || (!issue.IsPoster(ctx.User.ID) && !ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull)) {
|
|
|
|
ctx.Error(http.StatusForbidden)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
targetBranch := ctx.QueryTrim("target_branch")
|
|
|
|
if len(targetBranch) == 0 {
|
|
|
|
ctx.Error(http.StatusNoContent)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := pull_service.ChangeTargetBranch(pr, ctx.User, targetBranch); err != nil {
|
|
|
|
if models.IsErrPullRequestAlreadyExists(err) {
|
|
|
|
err := err.(models.ErrPullRequestAlreadyExists)
|
|
|
|
|
|
|
|
RepoRelPath := ctx.Repo.Owner.Name + "/" + ctx.Repo.Repository.Name
|
|
|
|
errorMessage := ctx.Tr("repo.pulls.has_pull_request", ctx.Repo.RepoLink, RepoRelPath, err.IssueID)
|
|
|
|
|
|
|
|
ctx.Flash.Error(errorMessage)
|
|
|
|
ctx.JSON(http.StatusConflict, map[string]interface{}{
|
|
|
|
"error": err.Error(),
|
|
|
|
"user_error": errorMessage,
|
|
|
|
})
|
|
|
|
} else if models.IsErrIssueIsClosed(err) {
|
|
|
|
errorMessage := ctx.Tr("repo.pulls.is_closed")
|
|
|
|
|
|
|
|
ctx.Flash.Error(errorMessage)
|
|
|
|
ctx.JSON(http.StatusConflict, map[string]interface{}{
|
|
|
|
"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]interface{}{
|
|
|
|
"error": err.Error(),
|
|
|
|
"user_error": errorMessage,
|
|
|
|
})
|
|
|
|
} else if models.IsErrBranchesEqual(err) {
|
|
|
|
errorMessage := ctx.Tr("repo.pulls.nothing_to_compare")
|
|
|
|
|
|
|
|
ctx.Flash.Error(errorMessage)
|
|
|
|
ctx.JSON(http.StatusBadRequest, map[string]interface{}{
|
|
|
|
"error": err.Error(),
|
|
|
|
"user_error": errorMessage,
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
ctx.ServerError("UpdatePullRequestTarget", err)
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
notification.NotifyPullRequestChangeTargetBranch(ctx.User, pr, targetBranch)
|
|
|
|
|
|
|
|
ctx.JSON(http.StatusOK, map[string]interface{}{
|
|
|
|
"base_branch": pr.BaseBranch,
|
|
|
|
})
|
|
|
|
}
|