forked from Gitlink/gitea-1156
Merge pull request 'compare接口报错问题' (#36) from yystopf/gitea-1156:develop into develop
This commit is contained in:
commit
d4eec1b75c
|
|
@ -1166,9 +1166,7 @@ type CompareCommit struct {
|
||||||
|
|
||||||
func CompareDiff(ctx *context.APIContext) {
|
func CompareDiff(ctx *context.APIContext) {
|
||||||
|
|
||||||
var form api.CreatePullRequestOption
|
headUser, headRepo, headGitRepo, compareInfo, baseBranch, headBranch := ParseCompareInfo(ctx.Context)
|
||||||
|
|
||||||
headUser, headRepo, headGitRepo, compareInfo, baseBranch, headBranch := parseCompareInfo(ctx, form)
|
|
||||||
if ctx.Written() {
|
if ctx.Written() {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
@ -1208,3 +1206,373 @@ func CompareDiff(ctx *context.APIContext) {
|
||||||
|
|
||||||
ctx.JSON(200, different)
|
ctx.JSON(200, different)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// ParseCompareInfo parse compare info between two commit for preparing comparing references
|
||||||
|
func ParseCompareInfo(ctx *context.Context) (*models.User, *models.Repository, *git.Repository, *git.CompareInfo, string, string) {
|
||||||
|
baseRepo := ctx.Repo.Repository
|
||||||
|
|
||||||
|
// Get compared branches information
|
||||||
|
// A full compare url is of the form:
|
||||||
|
//
|
||||||
|
// 1. /{:baseOwner}/{:baseRepoName}/compare/{:baseBranch}...{:headBranch}
|
||||||
|
// 2. /{:baseOwner}/{:baseRepoName}/compare/{:baseBranch}...{:headOwner}:{:headBranch}
|
||||||
|
// 3. /{:baseOwner}/{:baseRepoName}/compare/{:baseBranch}...{:headOwner}/{:headRepoName}:{:headBranch}
|
||||||
|
//
|
||||||
|
// Here we obtain the infoPath "{:baseBranch}...[{:headOwner}/{:headRepoName}:]{:headBranch}" as ctx.Params("*")
|
||||||
|
// with the :baseRepo in ctx.Repo.
|
||||||
|
//
|
||||||
|
// Note: Generally :headRepoName is not provided here - we are only passed :headOwner.
|
||||||
|
//
|
||||||
|
// How do we determine the :headRepo?
|
||||||
|
//
|
||||||
|
// 1. If :headOwner is not set then the :headRepo = :baseRepo
|
||||||
|
// 2. If :headOwner is set - then look for the fork of :baseRepo owned by :headOwner
|
||||||
|
// 3. But... :baseRepo could be a fork of :headOwner's repo - so check that
|
||||||
|
// 4. Now, :baseRepo and :headRepos could be forks of the same repo - so check that
|
||||||
|
//
|
||||||
|
// format: <base branch>...[<head repo>:]<head branch>
|
||||||
|
// base<-head: master...head:feature
|
||||||
|
// same repo: master...feature
|
||||||
|
|
||||||
|
var (
|
||||||
|
headUser *models.User
|
||||||
|
headRepo *models.Repository
|
||||||
|
headBranch string
|
||||||
|
isSameRepo bool
|
||||||
|
infoPath string
|
||||||
|
err error
|
||||||
|
)
|
||||||
|
infoPath = ctx.Params("*")
|
||||||
|
infos := strings.SplitN(infoPath, "...", 2)
|
||||||
|
if len(infos) != 2 {
|
||||||
|
log.Trace("ParseCompareInfo[%d]: not enough compared branches information %s", baseRepo.ID, infos)
|
||||||
|
ctx.NotFound("CompareAndPullRequest", nil)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.Data["BaseName"] = baseRepo.OwnerName
|
||||||
|
baseBranch := infos[0]
|
||||||
|
ctx.Data["BaseBranch"] = baseBranch
|
||||||
|
|
||||||
|
// If there is no head repository, it means compare between same repository.
|
||||||
|
headInfos := strings.Split(infos[1], ":")
|
||||||
|
if len(headInfos) == 1 {
|
||||||
|
isSameRepo = true
|
||||||
|
headUser = ctx.Repo.Owner
|
||||||
|
headBranch = headInfos[0]
|
||||||
|
|
||||||
|
} else if len(headInfos) == 2 {
|
||||||
|
headInfosSplit := strings.Split(headInfos[0], "/")
|
||||||
|
if len(headInfosSplit) == 1 {
|
||||||
|
headUser, err = models.GetUserByName(headInfos[0])
|
||||||
|
if err != nil {
|
||||||
|
if models.IsErrUserNotExist(err) {
|
||||||
|
ctx.NotFound("GetUserByName", nil)
|
||||||
|
} else {
|
||||||
|
ctx.ServerError("GetUserByName", err)
|
||||||
|
}
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
headBranch = headInfos[1]
|
||||||
|
isSameRepo = headUser.ID == ctx.Repo.Owner.ID
|
||||||
|
if isSameRepo {
|
||||||
|
headRepo = baseRepo
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
headRepo, err = models.GetRepositoryByOwnerAndName(headInfosSplit[0], headInfosSplit[1])
|
||||||
|
if err != nil {
|
||||||
|
if models.IsErrRepoNotExist(err) {
|
||||||
|
ctx.NotFound("GetRepositoryByOwnerAndName", nil)
|
||||||
|
} else {
|
||||||
|
ctx.ServerError("GetRepositoryByOwnerAndName", err)
|
||||||
|
}
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
if err := headRepo.GetOwner(); err != nil {
|
||||||
|
if models.IsErrUserNotExist(err) {
|
||||||
|
ctx.NotFound("GetUserByName", nil)
|
||||||
|
} else {
|
||||||
|
ctx.ServerError("GetUserByName", err)
|
||||||
|
}
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
headBranch = headInfos[1]
|
||||||
|
headUser = headRepo.Owner
|
||||||
|
isSameRepo = headRepo.ID == ctx.Repo.Repository.ID
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
ctx.NotFound("CompareAndPullRequest", nil)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
ctx.Data["HeadUser"] = headUser
|
||||||
|
ctx.Data["HeadBranch"] = headBranch
|
||||||
|
ctx.Repo.PullRequest.SameRepo = isSameRepo
|
||||||
|
if ctx.Repo.GitRepo == nil && !baseRepo.IsEmpty {
|
||||||
|
var err error
|
||||||
|
ctx.Repo.GitRepo, err = git.OpenRepository(ctx.Repo.Repository.RepoPath())
|
||||||
|
if err != nil {
|
||||||
|
ctx.Error(http.StatusInternalServerError, "Unable to OpenRepository", err.Error())
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
defer ctx.Repo.GitRepo.Close()
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check if base branch is valid.
|
||||||
|
baseIsCommit := ctx.Repo.GitRepo.IsCommitExist(baseBranch)
|
||||||
|
baseIsBranch := ctx.Repo.GitRepo.IsBranchExist(baseBranch)
|
||||||
|
baseIsTag := ctx.Repo.GitRepo.IsTagExist(baseBranch)
|
||||||
|
if !baseIsCommit && !baseIsBranch && !baseIsTag {
|
||||||
|
// Check if baseBranch is short sha commit hash
|
||||||
|
if baseCommit, _ := ctx.Repo.GitRepo.GetCommit(baseBranch); baseCommit != nil {
|
||||||
|
baseBranch = baseCommit.ID.String()
|
||||||
|
ctx.Data["BaseBranch"] = baseBranch
|
||||||
|
baseIsCommit = true
|
||||||
|
} else {
|
||||||
|
ctx.NotFound("IsRefExist", nil)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ctx.Data["BaseIsCommit"] = baseIsCommit
|
||||||
|
ctx.Data["BaseIsBranch"] = baseIsBranch
|
||||||
|
ctx.Data["BaseIsTag"] = baseIsTag
|
||||||
|
|
||||||
|
// Now we have the repository that represents the base
|
||||||
|
|
||||||
|
// The current base and head repositories and branches may not
|
||||||
|
// actually be the intended branches that the user wants to
|
||||||
|
// create a pull-request from - but also determining the head
|
||||||
|
// repo is difficult.
|
||||||
|
|
||||||
|
// We will want therefore to offer a few repositories to set as
|
||||||
|
// our base and head
|
||||||
|
|
||||||
|
// 1. First if the baseRepo is a fork get the "RootRepo" it was
|
||||||
|
// forked from
|
||||||
|
var rootRepo *models.Repository
|
||||||
|
if baseRepo.IsFork {
|
||||||
|
err = baseRepo.GetBaseRepo()
|
||||||
|
if err != nil {
|
||||||
|
if !models.IsErrRepoNotExist(err) {
|
||||||
|
ctx.ServerError("Unable to find root repo", err)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
rootRepo = baseRepo.BaseRepo
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// 2. Now if the current user is not the owner of the baseRepo,
|
||||||
|
// check if they have a fork of the base repo and offer that as
|
||||||
|
// "OwnForkRepo"
|
||||||
|
var ownForkRepo *models.Repository
|
||||||
|
if ctx.User != nil && baseRepo.OwnerID != ctx.User.ID {
|
||||||
|
repo, has := models.HasForkedRepo(ctx.User.ID, baseRepo.ID)
|
||||||
|
if has {
|
||||||
|
ownForkRepo = repo
|
||||||
|
ctx.Data["OwnForkRepo"] = ownForkRepo
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
has := headRepo != nil
|
||||||
|
// 3. If the base is a forked from "RootRepo" and the owner of
|
||||||
|
// the "RootRepo" is the :headUser - set headRepo to that
|
||||||
|
if !has && rootRepo != nil && rootRepo.OwnerID == headUser.ID {
|
||||||
|
headRepo = rootRepo
|
||||||
|
has = true
|
||||||
|
}
|
||||||
|
|
||||||
|
// 4. If the ctx.User has their own fork of the baseRepo and the headUser is the ctx.User
|
||||||
|
// set the headRepo to the ownFork
|
||||||
|
if !has && ownForkRepo != nil && ownForkRepo.OwnerID == headUser.ID {
|
||||||
|
headRepo = ownForkRepo
|
||||||
|
has = true
|
||||||
|
}
|
||||||
|
|
||||||
|
// 5. If the headOwner has a fork of the baseRepo - use that
|
||||||
|
if !has {
|
||||||
|
headRepo, has = models.HasForkedRepo(headUser.ID, baseRepo.ID)
|
||||||
|
}
|
||||||
|
|
||||||
|
// 6. If the baseRepo is a fork and the headUser has a fork of that use that
|
||||||
|
if !has && baseRepo.IsFork {
|
||||||
|
headRepo, has = models.HasForkedRepo(headUser.ID, baseRepo.ForkID)
|
||||||
|
}
|
||||||
|
|
||||||
|
// 7. Otherwise if we're not the same repo and haven't found a repo give up
|
||||||
|
if !isSameRepo && !has {
|
||||||
|
ctx.Data["PageIsComparePull"] = false
|
||||||
|
}
|
||||||
|
|
||||||
|
// 8. Finally open the git repo
|
||||||
|
var headGitRepo *git.Repository
|
||||||
|
if isSameRepo {
|
||||||
|
headRepo = ctx.Repo.Repository
|
||||||
|
headGitRepo = ctx.Repo.GitRepo
|
||||||
|
} else if has {
|
||||||
|
headGitRepo, err = git.OpenRepository(headRepo.RepoPath())
|
||||||
|
if err != nil {
|
||||||
|
ctx.ServerError("OpenRepository", err)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
defer headGitRepo.Close()
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.Data["HeadRepo"] = headRepo
|
||||||
|
|
||||||
|
// Now we need to assert that the ctx.User has permission to read
|
||||||
|
// the baseRepo's code and pulls
|
||||||
|
// (NOT headRepo's)
|
||||||
|
permBase, err := models.GetUserRepoPermission(baseRepo, ctx.User)
|
||||||
|
if err != nil {
|
||||||
|
ctx.ServerError("GetUserRepoPermission", err)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
if !permBase.CanRead(models.UnitTypeCode) {
|
||||||
|
if log.IsTrace() {
|
||||||
|
log.Trace("Permission Denied: User: %-v cannot read code in Repo: %-v\nUser in baseRepo has Permissions: %-+v",
|
||||||
|
ctx.User,
|
||||||
|
baseRepo,
|
||||||
|
permBase)
|
||||||
|
}
|
||||||
|
ctx.NotFound("ParseCompareInfo", nil)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
|
||||||
|
// If we're not merging from the same repo:
|
||||||
|
if !isSameRepo {
|
||||||
|
// Assert ctx.User has permission to read headRepo's codes
|
||||||
|
permHead, err := models.GetUserRepoPermission(headRepo, ctx.User)
|
||||||
|
if err != nil {
|
||||||
|
ctx.ServerError("GetUserRepoPermission", err)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
if !permHead.CanRead(models.UnitTypeCode) {
|
||||||
|
if log.IsTrace() {
|
||||||
|
log.Trace("Permission Denied: User: %-v cannot read code in Repo: %-v\nUser in headRepo has Permissions: %-+v",
|
||||||
|
ctx.User,
|
||||||
|
headRepo,
|
||||||
|
permHead)
|
||||||
|
}
|
||||||
|
ctx.NotFound("ParseCompareInfo", nil)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// If we have a rootRepo and it's different from:
|
||||||
|
// 1. the computed base
|
||||||
|
// 2. the computed head
|
||||||
|
// then get the branches of it
|
||||||
|
if rootRepo != nil &&
|
||||||
|
rootRepo.ID != headRepo.ID &&
|
||||||
|
rootRepo.ID != baseRepo.ID {
|
||||||
|
perm, branches, err := getBranchesForRepo(ctx.User, rootRepo)
|
||||||
|
if err != nil {
|
||||||
|
ctx.ServerError("GetBranchesForRepo", err)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
if perm {
|
||||||
|
ctx.Data["RootRepo"] = rootRepo
|
||||||
|
ctx.Data["RootRepoBranches"] = branches
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// If we have a ownForkRepo and it's different from:
|
||||||
|
// 1. The computed base
|
||||||
|
// 2. The computed hea
|
||||||
|
// 3. The rootRepo (if we have one)
|
||||||
|
// then get the branches from it.
|
||||||
|
if ownForkRepo != nil &&
|
||||||
|
ownForkRepo.ID != headRepo.ID &&
|
||||||
|
ownForkRepo.ID != baseRepo.ID &&
|
||||||
|
(rootRepo == nil || ownForkRepo.ID != rootRepo.ID) {
|
||||||
|
perm, branches, err := getBranchesForRepo(ctx.User, ownForkRepo)
|
||||||
|
if err != nil {
|
||||||
|
ctx.ServerError("GetBranchesForRepo", err)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
if perm {
|
||||||
|
ctx.Data["OwnForkRepo"] = ownForkRepo
|
||||||
|
ctx.Data["OwnForkRepoBranches"] = branches
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check if head branch is valid.
|
||||||
|
headIsCommit := headGitRepo.IsCommitExist(headBranch)
|
||||||
|
headIsBranch := headGitRepo.IsBranchExist(headBranch)
|
||||||
|
headIsTag := headGitRepo.IsTagExist(headBranch)
|
||||||
|
if !headIsCommit && !headIsBranch && !headIsTag {
|
||||||
|
// Check if headBranch is short sha commit hash
|
||||||
|
if headCommit, _ := headGitRepo.GetCommit(headBranch); headCommit != nil {
|
||||||
|
headBranch = headCommit.ID.String()
|
||||||
|
ctx.Data["HeadBranch"] = headBranch
|
||||||
|
headIsCommit = true
|
||||||
|
} else {
|
||||||
|
ctx.NotFound("IsRefExist", nil)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ctx.Data["HeadIsCommit"] = headIsCommit
|
||||||
|
ctx.Data["HeadIsBranch"] = headIsBranch
|
||||||
|
ctx.Data["HeadIsTag"] = headIsTag
|
||||||
|
|
||||||
|
// Treat as pull request if both references are branches
|
||||||
|
if ctx.Data["PageIsComparePull"] == nil {
|
||||||
|
ctx.Data["PageIsComparePull"] = headIsBranch && baseIsBranch
|
||||||
|
}
|
||||||
|
|
||||||
|
if ctx.Data["PageIsComparePull"] == true && !permBase.CanReadIssuesOrPulls(true) {
|
||||||
|
if log.IsTrace() {
|
||||||
|
log.Trace("Permission Denied: User: %-v cannot create/read pull requests in Repo: %-v\nUser in baseRepo has Permissions: %-+v",
|
||||||
|
ctx.User,
|
||||||
|
baseRepo,
|
||||||
|
permBase)
|
||||||
|
}
|
||||||
|
ctx.NotFound("ParseCompareInfo", nil)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
|
||||||
|
baseBranchRef := baseBranch
|
||||||
|
if baseIsBranch {
|
||||||
|
baseBranchRef = git.BranchPrefix + baseBranch
|
||||||
|
} else if baseIsTag {
|
||||||
|
baseBranchRef = git.TagPrefix + baseBranch
|
||||||
|
}
|
||||||
|
headBranchRef := headBranch
|
||||||
|
if headIsBranch {
|
||||||
|
headBranchRef = git.BranchPrefix + headBranch
|
||||||
|
} else if headIsTag {
|
||||||
|
headBranchRef = git.TagPrefix + headBranch
|
||||||
|
}
|
||||||
|
|
||||||
|
compareInfo, err := headGitRepo.GetCompareInfo(baseRepo.RepoPath(), baseBranchRef, headBranchRef)
|
||||||
|
if err != nil {
|
||||||
|
ctx.ServerError("GetCompareInfo", err)
|
||||||
|
return nil, nil, nil, nil, "", ""
|
||||||
|
}
|
||||||
|
ctx.Data["BeforeCommitID"] = compareInfo.MergeBase
|
||||||
|
|
||||||
|
return headUser, headRepo, headGitRepo, compareInfo, baseBranch, headBranch
|
||||||
|
}
|
||||||
|
|
||||||
|
func getBranchesForRepo(user *models.User, repo *models.Repository) (bool, []string, error) {
|
||||||
|
perm, err := models.GetUserRepoPermission(repo, user)
|
||||||
|
if err != nil {
|
||||||
|
return false, nil, err
|
||||||
|
}
|
||||||
|
if !perm.CanRead(models.UnitTypeCode) {
|
||||||
|
return false, nil, nil
|
||||||
|
}
|
||||||
|
gitRepo, err := git.OpenRepository(repo.RepoPath())
|
||||||
|
if err != nil {
|
||||||
|
return false, nil, err
|
||||||
|
}
|
||||||
|
defer gitRepo.Close()
|
||||||
|
|
||||||
|
branches, _, err := gitRepo.GetBranches(0, 0)
|
||||||
|
if err != nil {
|
||||||
|
return false, nil, err
|
||||||
|
}
|
||||||
|
return true, branches, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// end by qiubing
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue