2014-03-24 14:25:15 +04:00
// Copyright 2014 The Gogs Authors. All rights reserved.
// 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 16:26:56 +03:00
"container/list"
2015-10-24 10:36:47 +03:00
"errors"
2015-09-02 02:07:02 +03:00
"path"
2015-08-08 17:43:14 +03:00
"strings"
2015-09-02 02:07:02 +03:00
"github.com/Unknwon/com"
2015-08-08 12:10:34 +03:00
"github.com/gogits/gogs/models"
"github.com/gogits/gogs/modules/auth"
2014-06-23 07:11:12 +04:00
"github.com/gogits/gogs/modules/base"
2015-08-08 17:43:14 +03:00
"github.com/gogits/gogs/modules/git"
2015-08-08 12:10:34 +03:00
"github.com/gogits/gogs/modules/log"
2014-03-24 14:25:15 +04:00
"github.com/gogits/gogs/modules/middleware"
2015-08-08 12:10:34 +03:00
"github.com/gogits/gogs/modules/setting"
2014-03-24 14:25:15 +04:00
)
2014-06-23 07:11:12 +04:00
const (
2015-08-08 17:43:14 +03:00
FORK base . TplName = "repo/pulls/fork"
COMPARE_PULL base . TplName = "repo/pulls/compare"
2015-09-02 11:08:05 +03:00
PULL_COMMITS base . TplName = "repo/pulls/commits"
PULL_FILES base . TplName = "repo/pulls/files"
2014-06-23 07:11:12 +04:00
)
2015-08-08 12:10:34 +03:00
func getForkRepository ( ctx * middleware . Context ) * models . Repository {
2015-08-08 17:43:14 +03:00
forkRepo , err := models . GetRepositoryByID ( ctx . ParamsInt64 ( ":repoid" ) )
2015-08-08 12:10:34 +03:00
if err != nil {
if models . IsErrRepoNotExist ( err ) {
2015-08-08 17:43:14 +03:00
ctx . Handle ( 404 , "GetRepositoryByID" , nil )
2015-08-08 12:10:34 +03:00
} else {
2015-08-08 17:43:14 +03:00
ctx . Handle ( 500 , "GetRepositoryByID" , err )
2015-08-08 12:10:34 +03:00
}
return nil
}
2015-09-01 18:57:02 +03:00
2015-09-05 21:31:52 +03:00
if ! forkRepo . CanBeForked ( ) {
ctx . Handle ( 404 , "getForkRepository" , nil )
2015-09-01 18:57:02 +03:00
return nil
}
2015-08-08 12:10:34 +03:00
ctx . Data [ "repo_name" ] = forkRepo . Name
ctx . Data [ "desc" ] = forkRepo . Description
ctx . Data [ "IsPrivate" ] = forkRepo . IsPrivate
if err = forkRepo . GetOwner ( ) ; err != nil {
ctx . Handle ( 500 , "GetOwner" , err )
return nil
}
ctx . Data [ "ForkFrom" ] = forkRepo . Owner . Name + "/" + forkRepo . Name
if err := ctx . User . GetOrganizations ( ) ; err != nil {
ctx . Handle ( 500 , "GetOrganizations" , err )
return nil
}
ctx . Data [ "Orgs" ] = ctx . User . Orgs
return forkRepo
}
func Fork ( ctx * middleware . Context ) {
ctx . Data [ "Title" ] = ctx . Tr ( "new_fork" )
getForkRepository ( ctx )
if ctx . Written ( ) {
return
}
ctx . Data [ "ContextUser" ] = ctx . User
ctx . HTML ( 200 , FORK )
}
func ForkPost ( ctx * middleware . Context , form auth . CreateRepoForm ) {
ctx . Data [ "Title" ] = ctx . Tr ( "new_fork" )
forkRepo := getForkRepository ( ctx )
if ctx . Written ( ) {
return
}
ctxUser := checkContextUser ( ctx , form . Uid )
if ctx . Written ( ) {
return
}
ctx . Data [ "ContextUser" ] = ctxUser
if ctx . HasError ( ) {
ctx . HTML ( 200 , FORK )
return
}
2015-08-08 17:43:14 +03:00
repo , has := models . HasForkedRepo ( ctxUser . Id , forkRepo . ID )
2015-08-08 12:24:10 +03:00
if has {
ctx . Redirect ( setting . AppSubUrl + "/" + ctxUser . Name + "/" + repo . Name )
return
}
2015-08-08 12:10:34 +03:00
// Check ownership of organization.
if ctxUser . IsOrganization ( ) {
if ! ctxUser . IsOwnedBy ( ctx . User . Id ) {
ctx . Error ( 403 )
return
}
}
repo , err := models . ForkRepository ( ctxUser , forkRepo , form . RepoName , form . Description )
if err != nil {
2015-08-31 10:24:28 +03:00
ctx . Data [ "Err_RepoName" ] = true
2015-08-08 12:10:34 +03:00
switch {
case models . IsErrRepoAlreadyExist ( err ) :
ctx . RenderWithErr ( ctx . Tr ( "repo.settings.new_owner_has_same_repo" ) , FORK , & form )
case models . IsErrNameReserved ( err ) :
ctx . RenderWithErr ( ctx . Tr ( "repo.form.name_reserved" , err . ( models . ErrNameReserved ) . Name ) , FORK , & form )
case models . IsErrNamePatternNotAllowed ( err ) :
ctx . RenderWithErr ( ctx . Tr ( "repo.form.name_pattern_not_allowed" , err . ( models . ErrNamePatternNotAllowed ) . Pattern ) , FORK , & form )
default :
ctx . Handle ( 500 , "ForkPost" , err )
}
return
}
2015-08-08 17:43:14 +03:00
log . Trace ( "Repository forked[%d]: %s/%s" , forkRepo . ID , ctxUser . Name , repo . Name )
2015-08-08 12:10:34 +03:00
ctx . Redirect ( setting . AppSubUrl + "/" + ctxUser . Name + "/" + repo . Name )
}
2015-09-02 11:08:05 +03:00
func checkPullInfo ( ctx * middleware . Context ) * models . Issue {
2015-10-19 02:30:39 +03:00
issue , err := models . GetIssueByIndex ( ctx . Repo . Repository . ID , ctx . ParamsInt64 ( ":index" ) )
2015-09-02 11:08:05 +03:00
if err != nil {
if models . IsErrIssueNotExist ( err ) {
ctx . Handle ( 404 , "GetIssueByIndex" , err )
} else {
ctx . Handle ( 500 , "GetIssueByIndex" , err )
}
return nil
}
2015-10-19 02:30:39 +03:00
ctx . Data [ "Title" ] = issue . Name
ctx . Data [ "Issue" ] = issue
2015-09-02 11:08:05 +03:00
2015-10-19 02:30:39 +03:00
if ! issue . IsPull {
2015-09-02 11:08:05 +03:00
ctx . Handle ( 404 , "ViewPullCommits" , nil )
return nil
}
2015-10-19 02:30:39 +03:00
if err = issue . GetPoster ( ) ; err != nil {
2015-09-02 11:08:05 +03:00
ctx . Handle ( 500 , "GetPoster" , err )
return nil
2015-10-25 10:10:22 +03:00
} else if err = issue . GetPullRequest ( ) ; err != nil {
ctx . Handle ( 500 , "GetPullRequest" , err )
return nil
} else if err = issue . GetHeadRepo ( ) ; err != nil {
2015-10-24 10:36:47 +03:00
ctx . Handle ( 500 , "GetHeadRepo" , err )
return nil
2015-09-02 11:08:05 +03:00
}
if ctx . IsSigned {
// Update issue-user.
2015-10-19 02:30:39 +03:00
if err = issue . ReadBy ( ctx . User . Id ) ; err != nil {
2015-09-02 11:08:05 +03:00
ctx . Handle ( 500 , "ReadBy" , err )
return nil
}
}
2015-10-19 02:30:39 +03:00
return issue
2015-09-02 11:08:05 +03:00
}
2015-09-02 16:26:56 +03:00
func PrepareMergedViewPullInfo ( ctx * middleware . Context , pull * models . Issue ) {
ctx . Data [ "HasMerged" ] = true
var err error
2015-10-24 10:36:47 +03:00
if err = pull . GetMerger ( ) ; err != nil {
ctx . Handle ( 500 , "GetMerger" , err )
return
}
2015-10-19 02:30:39 +03:00
ctx . Data [ "HeadTarget" ] = pull . HeadUserName + "/" + pull . HeadBranch
2015-09-02 16:26:56 +03:00
ctx . Data [ "BaseTarget" ] = ctx . Repo . Owner . Name + "/" + pull . BaseBranch
ctx . Data [ "NumCommits" ] , err = ctx . Repo . GitRepo . CommitsCountBetween ( pull . MergeBase , pull . MergedCommitID )
if err != nil {
ctx . Handle ( 500 , "Repo.GitRepo.CommitsCountBetween" , err )
return
}
ctx . Data [ "NumFiles" ] , err = ctx . Repo . GitRepo . FilesCountBetween ( pull . MergeBase , pull . MergedCommitID )
if err != nil {
ctx . Handle ( 500 , "Repo.GitRepo.FilesCountBetween" , err )
return
}
}
2015-09-02 11:08:05 +03:00
func PrepareViewPullInfo ( ctx * middleware . Context , pull * models . Issue ) * git . PullRequestInfo {
repo := ctx . Repo . Repository
2015-10-19 02:30:39 +03:00
ctx . Data [ "HeadTarget" ] = pull . HeadUserName + "/" + pull . HeadBranch
2015-09-02 12:09:12 +03:00
ctx . Data [ "BaseTarget" ] = ctx . Repo . Owner . Name + "/" + pull . BaseBranch
2015-09-02 11:08:05 +03:00
2015-10-05 03:54:06 +03:00
var (
headGitRepo * git . Repository
err error
)
2015-10-24 10:36:47 +03:00
if err = pull . GetHeadRepo ( ) ; err != nil {
ctx . Handle ( 500 , "GetHeadRepo" , err )
return nil
}
2015-10-05 03:54:06 +03:00
if pull . HeadRepo != nil {
headRepoPath , err := pull . HeadRepo . RepoPath ( )
if err != nil {
ctx . Handle ( 500 , "HeadRepo.RepoPath" , err )
return nil
}
2015-09-02 11:08:05 +03:00
2015-10-05 03:54:06 +03:00
headGitRepo , err = git . OpenRepository ( headRepoPath )
if err != nil {
ctx . Handle ( 500 , "OpenRepository" , err )
return nil
}
2015-09-02 11:08:05 +03:00
}
2015-10-19 02:30:39 +03:00
if pull . HeadRepo == nil || ! headGitRepo . IsBranchExist ( pull . HeadBranch ) {
2015-09-02 16:26:56 +03:00
ctx . Data [ "IsPullReuqestBroken" ] = true
ctx . Data [ "HeadTarget" ] = "deleted"
ctx . Data [ "NumCommits" ] = 0
ctx . Data [ "NumFiles" ] = 0
return nil
}
2015-09-02 11:08:05 +03:00
prInfo , err := headGitRepo . GetPullRequestInfo ( models . RepoPath ( repo . Owner . Name , repo . Name ) ,
2015-10-19 02:30:39 +03:00
pull . BaseBranch , pull . HeadBranch )
2015-09-02 11:08:05 +03:00
if err != nil {
ctx . Handle ( 500 , "GetPullRequestInfo" , err )
return nil
}
ctx . Data [ "NumCommits" ] = prInfo . Commits . Len ( )
ctx . Data [ "NumFiles" ] = prInfo . NumFiles
return prInfo
}
func ViewPullCommits ( ctx * middleware . Context ) {
ctx . Data [ "PageIsPullCommits" ] = true
pull := checkPullInfo ( ctx )
if ctx . Written ( ) {
return
}
2015-09-02 16:26:56 +03:00
ctx . Data [ "Username" ] = pull . HeadUserName
ctx . Data [ "Reponame" ] = pull . HeadRepo . Name
2015-09-02 11:08:05 +03:00
2015-09-02 16:26:56 +03:00
var commits * list . List
if pull . HasMerged {
PrepareMergedViewPullInfo ( ctx , pull )
if ctx . Written ( ) {
return
}
startCommit , err := ctx . Repo . GitRepo . GetCommit ( pull . MergeBase )
if err != nil {
ctx . Handle ( 500 , "Repo.GitRepo.GetCommit" , err )
return
}
endCommit , err := ctx . Repo . GitRepo . GetCommit ( pull . MergedCommitID )
if err != nil {
ctx . Handle ( 500 , "Repo.GitRepo.GetCommit" , err )
return
}
commits , err = ctx . Repo . GitRepo . CommitsBetween ( endCommit , startCommit )
if err != nil {
ctx . Handle ( 500 , "Repo.GitRepo.CommitsBetween" , err )
return
}
} else {
prInfo := PrepareViewPullInfo ( ctx , pull )
if ctx . Written ( ) {
return
} else if prInfo == nil {
ctx . Handle ( 404 , "ViewPullCommits" , nil )
return
}
commits = prInfo . Commits
2015-09-02 11:08:05 +03:00
}
2015-09-02 16:26:56 +03:00
commits = models . ValidateCommitsWithEmails ( commits )
ctx . Data [ "Commits" ] = commits
ctx . Data [ "CommitCount" ] = commits . Len ( )
2015-09-02 11:08:05 +03:00
ctx . HTML ( 200 , PULL_COMMITS )
}
func ViewPullFiles ( ctx * middleware . Context ) {
ctx . Data [ "PageIsPullFiles" ] = true
pull := checkPullInfo ( ctx )
if ctx . Written ( ) {
return
}
2015-09-02 16:26:56 +03:00
var (
diffRepoPath string
startCommitID string
endCommitID string
gitRepo * git . Repository
)
if pull . HasMerged {
PrepareMergedViewPullInfo ( ctx , pull )
if ctx . Written ( ) {
return
}
2015-09-02 11:08:05 +03:00
2015-09-02 16:26:56 +03:00
diffRepoPath = ctx . Repo . GitRepo . Path
startCommitID = pull . MergeBase
endCommitID = pull . MergedCommitID
gitRepo = ctx . Repo . GitRepo
} else {
prInfo := PrepareViewPullInfo ( ctx , pull )
if ctx . Written ( ) {
return
} else if prInfo == nil {
ctx . Handle ( 404 , "ViewPullFiles" , nil )
return
}
2015-09-02 11:08:05 +03:00
2015-09-02 16:26:56 +03:00
headRepoPath := models . RepoPath ( pull . HeadUserName , pull . HeadRepo . Name )
2015-09-02 11:08:05 +03:00
2015-09-02 16:26:56 +03:00
headGitRepo , err := git . OpenRepository ( headRepoPath )
if err != nil {
ctx . Handle ( 500 , "OpenRepository" , err )
return
}
2015-10-19 02:30:39 +03:00
headCommitID , err := headGitRepo . GetCommitIdOfBranch ( pull . HeadBranch )
2015-09-02 16:26:56 +03:00
if err != nil {
ctx . Handle ( 500 , "GetCommitIdOfBranch" , err )
return
}
diffRepoPath = headRepoPath
startCommitID = prInfo . MergeBase
endCommitID = headCommitID
gitRepo = headGitRepo
2015-09-02 11:08:05 +03:00
}
2015-09-02 16:26:56 +03:00
diff , err := models . GetDiffRange ( diffRepoPath ,
startCommitID , endCommitID , setting . Git . MaxGitDiffLines )
2015-09-02 11:08:05 +03:00
if err != nil {
ctx . Handle ( 500 , "GetDiffRange" , err )
return
}
ctx . Data [ "Diff" ] = diff
ctx . Data [ "DiffNotAvailable" ] = diff . NumFiles ( ) == 0
2015-09-02 16:26:56 +03:00
commit , err := gitRepo . GetCommit ( endCommitID )
2015-09-02 11:08:05 +03:00
if err != nil {
ctx . Handle ( 500 , "GetCommit" , err )
return
}
2015-09-02 12:09:12 +03:00
headTarget := path . Join ( pull . HeadUserName , pull . HeadRepo . Name )
ctx . Data [ "Username" ] = pull . HeadUserName
ctx . Data [ "Reponame" ] = pull . HeadRepo . Name
2015-09-02 16:26:56 +03:00
ctx . Data [ "IsImageFile" ] = commit . IsImageFile
ctx . Data [ "SourcePath" ] = setting . AppSubUrl + "/" + path . Join ( headTarget , "src" , endCommitID )
ctx . Data [ "BeforeSourcePath" ] = setting . AppSubUrl + "/" + path . Join ( headTarget , "src" , startCommitID )
ctx . Data [ "RawPath" ] = setting . AppSubUrl + "/" + path . Join ( headTarget , "raw" , endCommitID )
2015-09-02 11:08:05 +03:00
ctx . HTML ( 200 , PULL_FILES )
}
2015-08-31 10:24:28 +03:00
2015-09-02 16:26:56 +03:00
func MergePullRequest ( ctx * middleware . Context ) {
2015-10-19 02:30:39 +03:00
issue := checkPullInfo ( ctx )
2015-09-02 16:26:56 +03:00
if ctx . Written ( ) {
return
}
2015-10-19 02:30:39 +03:00
if issue . IsClosed {
2015-09-02 16:26:56 +03:00
ctx . Handle ( 404 , "MergePullRequest" , nil )
return
}
2015-10-19 02:30:39 +03:00
pr , err := models . GetPullRequestByIssueID ( issue . ID )
2015-09-02 16:26:56 +03:00
if err != nil {
if models . IsErrPullRequestNotExist ( err ) {
2015-10-19 02:30:39 +03:00
ctx . Handle ( 404 , "GetPullRequestByIssueID" , nil )
2015-09-02 16:26:56 +03:00
} else {
2015-10-19 02:30:39 +03:00
ctx . Handle ( 500 , "GetPullRequestByIssueID" , err )
2015-09-02 16:26:56 +03:00
}
return
}
2015-10-19 00:18:45 +03:00
if ! pr . CanAutoMerge ( ) || pr . HasMerged {
2015-09-02 16:26:56 +03:00
ctx . Handle ( 404 , "MergePullRequest" , nil )
return
}
2015-10-19 02:30:39 +03:00
pr . Issue = issue
pr . Issue . Repo = ctx . Repo . Repository
2015-09-02 18:13:37 +03:00
if err = pr . Merge ( ctx . User , ctx . Repo . GitRepo ) ; err != nil {
2015-10-19 02:30:39 +03:00
ctx . Handle ( 500 , "Merge" , err )
2015-09-02 16:26:56 +03:00
return
}
log . Trace ( "Pull request merged: %d" , pr . ID )
2015-10-19 02:30:39 +03:00
ctx . Redirect ( ctx . Repo . RepoLink + "/pulls/" + com . ToStr ( pr . Index ) )
2015-09-02 16:26:56 +03:00
}
2015-09-02 02:07:02 +03:00
func ParseCompareInfo ( ctx * middleware . Context ) ( * models . User , * models . Repository , * git . Repository , * git . PullRequestInfo , string , string ) {
2015-08-31 10:24:28 +03:00
// Get compare branch information.
2015-08-08 17:43:14 +03:00
infos := strings . Split ( ctx . Params ( "*" ) , "..." )
if len ( infos ) != 2 {
ctx . Handle ( 404 , "CompareAndPullRequest" , nil )
2015-09-02 02:07:02 +03:00
return nil , nil , nil , nil , "" , ""
2015-08-08 17:43:14 +03:00
}
baseBranch := infos [ 0 ]
ctx . Data [ "BaseBranch" ] = baseBranch
headInfos := strings . Split ( infos [ 1 ] , ":" )
if len ( headInfos ) != 2 {
ctx . Handle ( 404 , "CompareAndPullRequest" , nil )
2015-09-02 02:07:02 +03:00
return nil , nil , nil , nil , "" , ""
2015-08-08 17:43:14 +03:00
}
2015-09-02 02:07:02 +03:00
headUsername := headInfos [ 0 ]
2015-08-08 17:43:14 +03:00
headBranch := headInfos [ 1 ]
ctx . Data [ "HeadBranch" ] = headBranch
2015-09-02 02:07:02 +03:00
headUser , err := models . GetUserByName ( headUsername )
if err != nil {
if models . IsErrUserNotExist ( err ) {
ctx . Handle ( 404 , "GetUserByName" , nil )
} else {
ctx . Handle ( 500 , "GetUserByName" , err )
}
return nil , nil , nil , nil , "" , ""
}
repo := ctx . Repo . Repository
// Check if base branch is valid.
if ! ctx . Repo . GitRepo . IsBranchExist ( baseBranch ) {
ctx . Handle ( 404 , "IsBranchExist" , nil )
return nil , nil , nil , nil , "" , ""
}
2015-08-08 17:43:14 +03:00
// Check if current user has fork of repository.
2015-09-02 02:07:02 +03:00
headRepo , has := models . HasForkedRepo ( headUser . Id , repo . ID )
if ! has || ! ctx . User . IsAdminOfRepo ( headRepo ) {
2015-08-08 17:43:14 +03:00
ctx . Handle ( 404 , "HasForkedRepo" , nil )
2015-09-02 02:07:02 +03:00
return nil , nil , nil , nil , "" , ""
2015-08-08 17:43:14 +03:00
}
2015-09-02 02:07:02 +03:00
headGitRepo , err := git . OpenRepository ( models . RepoPath ( headUser . Name , headRepo . Name ) )
2015-08-08 17:43:14 +03:00
if err != nil {
ctx . Handle ( 500 , "OpenRepository" , err )
2015-09-02 02:07:02 +03:00
return nil , nil , nil , nil , "" , ""
}
// Check if head branch is valid.
if ! headGitRepo . IsBranchExist ( headBranch ) {
ctx . Handle ( 404 , "IsBranchExist" , nil )
return nil , nil , nil , nil , "" , ""
2015-08-08 17:43:14 +03:00
}
2015-09-02 02:07:02 +03:00
2015-08-08 17:43:14 +03:00
headBranches , err := headGitRepo . GetBranches ( )
if err != nil {
ctx . Handle ( 500 , "GetBranches" , err )
2015-09-02 02:07:02 +03:00
return nil , nil , nil , nil , "" , ""
2015-08-08 17:43:14 +03:00
}
ctx . Data [ "HeadBranches" ] = headBranches
2015-09-02 02:07:02 +03:00
prInfo , err := headGitRepo . GetPullRequestInfo ( models . RepoPath ( repo . Owner . Name , repo . Name ) , baseBranch , headBranch )
if err != nil {
ctx . Handle ( 500 , "GetPullRequestInfo" , err )
return nil , nil , nil , nil , "" , ""
}
ctx . Data [ "BeforeCommitID" ] = prInfo . MergeBase
return headUser , headRepo , headGitRepo , prInfo , baseBranch , headBranch
}
func PrepareCompareDiff (
ctx * middleware . Context ,
headUser * models . User ,
headRepo * models . Repository ,
headGitRepo * git . Repository ,
prInfo * git . PullRequestInfo ,
2015-09-02 12:09:12 +03:00
baseBranch , headBranch string ) bool {
2015-09-02 02:07:02 +03:00
var (
repo = ctx . Repo . Repository
err error
)
// Get diff information.
ctx . Data [ "CommitRepoLink" ] , err = headRepo . RepoLink ( )
if err != nil {
ctx . Handle ( 500 , "RepoLink" , err )
2015-09-02 12:09:12 +03:00
return false
2015-09-02 02:07:02 +03:00
}
headCommitID , err := headGitRepo . GetCommitIdOfBranch ( headBranch )
if err != nil {
ctx . Handle ( 500 , "GetCommitIdOfBranch" , err )
2015-09-02 12:09:12 +03:00
return false
2015-09-02 02:07:02 +03:00
}
ctx . Data [ "AfterCommitID" ] = headCommitID
2015-09-02 12:09:12 +03:00
if headCommitID == prInfo . MergeBase {
ctx . Data [ "IsNothingToCompare" ] = true
return true
}
2015-09-02 02:07:02 +03:00
diff , err := models . GetDiffRange ( models . RepoPath ( headUser . Name , headRepo . Name ) ,
prInfo . MergeBase , headCommitID , setting . Git . MaxGitDiffLines )
if err != nil {
ctx . Handle ( 500 , "GetDiffRange" , err )
2015-09-02 12:09:12 +03:00
return false
2015-09-02 02:07:02 +03:00
}
ctx . Data [ "Diff" ] = diff
ctx . Data [ "DiffNotAvailable" ] = diff . NumFiles ( ) == 0
headCommit , err := headGitRepo . GetCommit ( headCommitID )
if err != nil {
ctx . Handle ( 500 , "GetCommit" , err )
2015-09-02 12:09:12 +03:00
return false
2015-09-02 02:07:02 +03:00
}
prInfo . Commits = models . ValidateCommitsWithEmails ( prInfo . Commits )
ctx . Data [ "Commits" ] = prInfo . Commits
ctx . Data [ "CommitCount" ] = prInfo . Commits . Len ( )
ctx . Data [ "Username" ] = headUser . Name
ctx . Data [ "Reponame" ] = headRepo . Name
2015-09-02 11:08:05 +03:00
ctx . Data [ "IsImageFile" ] = headCommit . IsImageFile
headTarget := path . Join ( headUser . Name , repo . Name )
ctx . Data [ "SourcePath" ] = setting . AppSubUrl + "/" + path . Join ( headTarget , "src" , headCommitID )
ctx . Data [ "BeforeSourcePath" ] = setting . AppSubUrl + "/" + path . Join ( headTarget , "src" , prInfo . MergeBase )
ctx . Data [ "RawPath" ] = setting . AppSubUrl + "/" + path . Join ( headTarget , "raw" , headCommitID )
2015-09-02 12:09:12 +03:00
return false
2015-09-02 02:07:02 +03:00
}
func CompareAndPullRequest ( ctx * middleware . Context ) {
ctx . Data [ "Title" ] = ctx . Tr ( "repo.pulls.compare_changes" )
ctx . Data [ "PageIsComparePull" ] = true
ctx . Data [ "IsDiffCompare" ] = true
renderAttachmentSettings ( ctx )
headUser , headRepo , headGitRepo , prInfo , baseBranch , headBranch := ParseCompareInfo ( ctx )
if ctx . Written ( ) {
return
}
2015-10-19 02:30:39 +03:00
pr , err := models . GetUnmergedPullRequest ( headRepo . ID , ctx . Repo . Repository . ID , headBranch , baseBranch )
if err != nil {
if ! models . IsErrPullRequestNotExist ( err ) {
ctx . Handle ( 500 , "GetUnmergedPullRequest" , err )
return
}
} else {
ctx . Data [ "HasPullRequest" ] = true
ctx . Data [ "PullRequest" ] = pr
ctx . HTML ( 200 , COMPARE_PULL )
return
}
2015-09-02 02:07:02 +03:00
2015-09-02 12:09:12 +03:00
nothingToCompare := PrepareCompareDiff ( ctx , headUser , headRepo , headGitRepo , prInfo , baseBranch , headBranch )
2015-08-31 10:24:28 +03:00
if ctx . Written ( ) {
return
}
2015-09-02 12:09:12 +03:00
if ! nothingToCompare {
// Setup information for new form.
RetrieveRepoMetas ( ctx , ctx . Repo . Repository )
if ctx . Written ( ) {
return
}
}
2015-08-08 17:43:14 +03:00
ctx . HTML ( 200 , COMPARE_PULL )
}
2015-09-02 02:07:02 +03:00
func CompareAndPullRequestPost ( ctx * middleware . Context , form auth . CreateIssueForm ) {
ctx . Data [ "Title" ] = ctx . Tr ( "repo.pulls.compare_changes" )
ctx . Data [ "PageIsComparePull" ] = true
ctx . Data [ "IsDiffCompare" ] = true
renderAttachmentSettings ( ctx )
var (
repo = ctx . Repo . Repository
attachments [ ] string
)
2015-09-02 02:26:39 +03:00
headUser , headRepo , headGitRepo , prInfo , baseBranch , headBranch := ParseCompareInfo ( ctx )
2015-09-02 02:07:02 +03:00
if ctx . Written ( ) {
return
}
2015-10-05 03:54:06 +03:00
patch , err := headGitRepo . GetPatch ( prInfo . MergeBase , headBranch )
2015-09-02 02:07:02 +03:00
if err != nil {
ctx . Handle ( 500 , "GetPatch" , err )
return
}
labelIDs , milestoneID , assigneeID := ValidateRepoMetas ( ctx , form )
if ctx . Written ( ) {
return
}
if setting . AttachmentEnabled {
attachments = form . Attachments
}
if ctx . HasError ( ) {
ctx . HTML ( 200 , COMPARE_PULL )
return
}
2015-09-02 12:09:12 +03:00
pull := & models . Issue {
2015-09-02 02:07:02 +03:00
RepoID : repo . ID ,
2015-09-03 10:49:50 +03:00
Index : repo . NextIssueIndex ( ) ,
2015-09-02 02:07:02 +03:00
Name : form . Title ,
PosterID : ctx . User . Id ,
Poster : ctx . User ,
MilestoneID : milestoneID ,
AssigneeID : assigneeID ,
IsPull : true ,
Content : form . Content ,
}
2015-09-02 12:09:12 +03:00
if err := models . NewPullRequest ( repo , pull , labelIDs , attachments , & models . PullRequest {
2015-09-02 02:26:39 +03:00
HeadRepoID : headRepo . ID ,
BaseRepoID : repo . ID ,
HeadUserName : headUser . Name ,
2015-10-19 02:30:39 +03:00
HeadBranch : headBranch ,
2015-09-02 02:26:39 +03:00
BaseBranch : baseBranch ,
MergeBase : prInfo . MergeBase ,
Type : models . PULL_REQUEST_GOGS ,
2015-09-02 02:07:02 +03:00
} , patch ) ; err != nil {
ctx . Handle ( 500 , "NewPullRequest" , err )
return
}
2015-09-02 12:09:12 +03:00
log . Trace ( "Pull request created: %d/%d" , repo . ID , pull . ID )
ctx . Redirect ( ctx . Repo . RepoLink + "/pulls/" + com . ToStr ( pull . Index ) )
2014-03-24 14:25:15 +04:00
}
2015-10-24 10:36:47 +03:00
func TriggerTask ( ctx * middleware . Context ) {
_ , repo := parseOwnerAndRepo ( ctx )
if ctx . Written ( ) {
return
}
branch := ctx . Query ( "branch" )
if len ( branch ) == 0 {
ctx . Handle ( 422 , "TriggerTask" , errors . New ( "branch is empty" ) )
return
}
log . Trace ( "TriggerTask[%d].(new request): %s" , repo . ID , branch )
go models . HookQueue . Add ( repo . ID )
go models . AddTestPullRequestTask ( repo . ID , branch )
ctx . Status ( 202 )
}