2015-10-19 02:30:39 +03:00
// Copyright 2015 The Gogs Authors. All rights reserved.
2019-04-19 15:17:27 +03:00
// Copyright 2019 The Gitea Authors. All rights reserved.
2015-10-19 02:30:39 +03:00
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package models
import (
"fmt"
2019-12-31 02:34:11 +03:00
"io"
2015-10-19 02:30:39 +03:00
"strings"
2019-03-27 12:33:00 +03:00
"code.gitea.io/gitea/modules/git"
2016-11-10 19:24:48 +03:00
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
2019-08-15 17:46:21 +03:00
"code.gitea.io/gitea/modules/timeutil"
2015-10-19 02:30:39 +03:00
)
2016-11-28 18:31:06 +03:00
// PullRequestType defines pull request type
2015-10-19 02:30:39 +03:00
type PullRequestType int
2016-11-28 18:31:06 +03:00
// Enumerate all the pull request types
2015-10-19 02:30:39 +03:00
const (
2016-11-07 18:37:32 +03:00
PullRequestGitea PullRequestType = iota
PullRequestGit
2015-10-19 02:30:39 +03:00
)
2016-11-28 18:31:06 +03:00
// PullRequestStatus defines pull request status
2015-10-19 02:30:39 +03:00
type PullRequestStatus int
2016-11-28 18:31:06 +03:00
// Enumerate all the pull request status
2015-10-19 02:30:39 +03:00
const (
2016-11-07 18:37:32 +03:00
PullRequestStatusConflict PullRequestStatus = iota
PullRequestStatusChecking
PullRequestStatusMergeable
2017-02-05 16:07:44 +03:00
PullRequestStatusManuallyMerged
2020-01-10 03:14:14 +03:00
PullRequestStatusError
2015-10-19 02:30:39 +03:00
)
// PullRequest represents relation between pull request and repositories.
type PullRequest struct {
2019-02-05 14:54:49 +03:00
ID int64 ` xorm:"pk autoincr" `
Type PullRequestType
Status PullRequestStatus
ConflictedFiles [ ] string ` xorm:"TEXT JSON" `
2015-10-19 02:30:39 +03:00
IssueID int64 ` xorm:"INDEX" `
Issue * Issue ` xorm:"-" `
Index int64
2018-12-11 14:28:37 +03:00
HeadRepoID int64 ` xorm:"INDEX" `
HeadRepo * Repository ` xorm:"-" `
BaseRepoID int64 ` xorm:"INDEX" `
BaseRepo * Repository ` xorm:"-" `
HeadBranch string
BaseBranch string
ProtectedBranch * ProtectedBranch ` xorm:"-" `
MergeBase string ` xorm:"VARCHAR(40)" `
2015-10-19 02:30:39 +03:00
2019-08-15 17:46:21 +03:00
HasMerged bool ` xorm:"INDEX" `
MergedCommitID string ` xorm:"VARCHAR(40)" `
MergerID int64 ` xorm:"INDEX" `
Merger * User ` xorm:"-" `
MergedUnix timeutil . TimeStamp ` xorm:"updated INDEX" `
2015-10-19 02:30:39 +03:00
}
2019-10-18 14:13:31 +03:00
// MustHeadUserName returns the HeadRepo's username if failed return blank
func ( pr * PullRequest ) MustHeadUserName ( ) string {
if err := pr . LoadHeadRepo ( ) ; err != nil {
2020-01-25 05:48:22 +03:00
if ! IsErrRepoNotExist ( err ) {
log . Error ( "LoadHeadRepo: %v" , err )
} else {
log . Warn ( "LoadHeadRepo %d but repository does not exist: %v" , pr . HeadRepoID , err )
}
2019-10-18 14:13:31 +03:00
return ""
}
2020-01-12 12:36:21 +03:00
return pr . HeadRepo . OwnerName
2019-10-18 14:13:31 +03:00
}
2016-08-14 13:32:24 +03:00
// Note: don't try to get Issue because will end up recursive querying.
func ( pr * PullRequest ) loadAttributes ( e Engine ) ( err error ) {
if pr . HasMerged && pr . Merger == nil {
pr . Merger , err = getUserByID ( e , pr . MergerID )
if IsErrUserNotExist ( err ) {
pr . MergerID = - 1
pr . Merger = NewGhostUser ( )
} else if err != nil {
return fmt . Errorf ( "getUserByID [%d]: %v" , pr . MergerID , err )
}
}
return nil
}
2016-11-28 18:31:06 +03:00
// LoadAttributes loads pull request attributes from database
2016-08-14 13:32:24 +03:00
func ( pr * PullRequest ) LoadAttributes ( ) error {
return pr . loadAttributes ( x )
}
2019-09-18 08:39:45 +03:00
// LoadBaseRepo loads pull request base repository from database
func ( pr * PullRequest ) LoadBaseRepo ( ) error {
if pr . BaseRepo == nil {
2019-10-18 14:13:31 +03:00
if pr . HeadRepoID == pr . BaseRepoID && pr . HeadRepo != nil {
pr . BaseRepo = pr . HeadRepo
return nil
}
2019-09-18 08:39:45 +03:00
var repo Repository
if has , err := x . ID ( pr . BaseRepoID ) . Get ( & repo ) ; err != nil {
return err
} else if ! has {
return ErrRepoNotExist { ID : pr . BaseRepoID }
}
pr . BaseRepo = & repo
}
return nil
}
2019-10-18 14:13:31 +03:00
// LoadHeadRepo loads pull request head repository from database
func ( pr * PullRequest ) LoadHeadRepo ( ) error {
if pr . HeadRepo == nil {
if pr . HeadRepoID == pr . BaseRepoID && pr . BaseRepo != nil {
pr . HeadRepo = pr . BaseRepo
return nil
}
var repo Repository
if has , err := x . ID ( pr . HeadRepoID ) . Get ( & repo ) ; err != nil {
return err
} else if ! has {
2020-01-07 20:06:14 +03:00
return ErrRepoNotExist { ID : pr . HeadRepoID }
2019-10-18 14:13:31 +03:00
}
pr . HeadRepo = & repo
}
return nil
}
2016-11-28 18:31:06 +03:00
// LoadIssue loads issue information from database
2016-08-14 13:32:24 +03:00
func ( pr * PullRequest ) LoadIssue ( ) ( err error ) {
2017-02-27 03:42:55 +03:00
return pr . loadIssue ( x )
}
func ( pr * PullRequest ) loadIssue ( e Engine ) ( err error ) {
2016-08-16 20:19:09 +03:00
if pr . Issue != nil {
return nil
}
2017-02-27 03:42:55 +03:00
pr . Issue , err = getIssueByID ( e , pr . IssueID )
2019-11-21 20:08:42 +03:00
if err == nil {
pr . Issue . PullRequest = pr
}
2016-08-14 13:32:24 +03:00
return err
}
2018-12-11 14:28:37 +03:00
// LoadProtectedBranch loads the protected branch of the base branch
func ( pr * PullRequest ) LoadProtectedBranch ( ) ( err error ) {
2019-12-04 04:08:56 +03:00
return pr . loadProtectedBranch ( x )
}
func ( pr * PullRequest ) loadProtectedBranch ( e Engine ) ( err error ) {
2020-01-15 11:32:57 +03:00
if pr . ProtectedBranch == nil {
if pr . BaseRepo == nil {
if pr . BaseRepoID == 0 {
return nil
}
pr . BaseRepo , err = getRepositoryByID ( e , pr . BaseRepoID )
if err != nil {
return
}
2018-12-17 20:35:21 +03:00
}
2020-01-15 11:32:57 +03:00
pr . ProtectedBranch , err = getProtectedBranchBy ( e , pr . BaseRepo . ID , pr . BaseBranch )
2018-12-17 20:35:21 +03:00
}
2018-12-11 14:28:37 +03:00
return
}
2018-01-05 21:56:50 +03:00
// GetDefaultMergeMessage returns default message used when merging pull request
func ( pr * PullRequest ) GetDefaultMergeMessage ( ) string {
if pr . HeadRepo == nil {
var err error
pr . HeadRepo , err = GetRepositoryByID ( pr . HeadRepoID )
if err != nil {
2019-04-02 10:48:31 +03:00
log . Error ( "GetRepositoryById[%d]: %v" , pr . HeadRepoID , err )
2018-01-05 21:56:50 +03:00
return ""
}
}
2020-01-08 14:53:07 +03:00
if err := pr . LoadIssue ( ) ; err != nil {
log . Error ( "Cannot load issue %d for PR id %d: Error: %v" , pr . IssueID , pr . ID , err )
return ""
}
2020-01-28 11:29:30 +03:00
if pr . BaseRepoID == pr . HeadRepoID {
return fmt . Sprintf ( "Merge pull request '%s' (#%d) from %s into %s" , pr . Issue . Title , pr . Issue . Index , pr . HeadBranch , pr . BaseBranch )
}
return fmt . Sprintf ( "Merge pull request '%s' (#%d) from %s:%s into %s" , pr . Issue . Title , pr . Issue . Index , pr . HeadRepo . FullName ( ) , pr . HeadBranch , pr . BaseBranch )
2018-01-05 21:56:50 +03:00
}
2019-12-31 02:34:11 +03:00
// GetCommitMessages returns the commit messages between head and merge base (if there is one)
func ( pr * PullRequest ) GetCommitMessages ( ) string {
if err := pr . LoadIssue ( ) ; err != nil {
log . Error ( "Cannot load issue %d for PR id %d: Error: %v" , pr . IssueID , pr . ID , err )
return ""
}
if err := pr . Issue . LoadPoster ( ) ; err != nil {
log . Error ( "Cannot load poster %d for pr id %d, index %d Error: %v" , pr . Issue . PosterID , pr . ID , pr . Index , err )
return ""
}
if pr . HeadRepo == nil {
var err error
pr . HeadRepo , err = GetRepositoryByID ( pr . HeadRepoID )
if err != nil {
log . Error ( "GetRepositoryById[%d]: %v" , pr . HeadRepoID , err )
return ""
}
}
gitRepo , err := git . OpenRepository ( pr . HeadRepo . RepoPath ( ) )
if err != nil {
log . Error ( "Unable to open head repository: Error: %v" , err )
return ""
}
defer gitRepo . Close ( )
headCommit , err := gitRepo . GetBranchCommit ( pr . HeadBranch )
if err != nil {
log . Error ( "Unable to get head commit: %s Error: %v" , pr . HeadBranch , err )
return ""
}
mergeBase , err := gitRepo . GetCommit ( pr . MergeBase )
if err != nil {
log . Error ( "Unable to get merge base commit: %s Error: %v" , pr . MergeBase , err )
return ""
}
limit := setting . Repository . PullRequest . DefaultMergeMessageCommitsLimit
list , err := gitRepo . CommitsBetweenLimit ( headCommit , mergeBase , limit , 0 )
if err != nil {
log . Error ( "Unable to get commits between: %s %s Error: %v" , pr . HeadBranch , pr . MergeBase , err )
return ""
}
maxSize := setting . Repository . PullRequest . DefaultMergeMessageSize
posterSig := pr . Issue . Poster . NewGitSig ( ) . String ( )
authorsMap := map [ string ] bool { }
authors := make ( [ ] string , 0 , list . Len ( ) )
stringBuilder := strings . Builder { }
element := list . Front ( )
for element != nil {
commit := element . Value . ( * git . Commit )
if maxSize < 0 || stringBuilder . Len ( ) < maxSize {
toWrite := [ ] byte ( commit . CommitMessage )
if len ( toWrite ) > maxSize - stringBuilder . Len ( ) && maxSize > - 1 {
toWrite = append ( toWrite [ : maxSize - stringBuilder . Len ( ) ] , "..." ... )
}
if _ , err := stringBuilder . Write ( toWrite ) ; err != nil {
log . Error ( "Unable to write commit message Error: %v" , err )
return ""
}
if _ , err := stringBuilder . WriteRune ( '\n' ) ; err != nil {
log . Error ( "Unable to write commit message Error: %v" , err )
return ""
}
}
authorString := commit . Author . String ( )
if ! authorsMap [ authorString ] && authorString != posterSig {
authors = append ( authors , authorString )
authorsMap [ authorString ] = true
}
element = element . Next ( )
}
// Consider collecting the remaining authors
if limit >= 0 && setting . Repository . PullRequest . DefaultMergeMessageAllAuthors {
skip := limit
limit = 30
for {
list , err := gitRepo . CommitsBetweenLimit ( headCommit , mergeBase , limit , skip )
if err != nil {
log . Error ( "Unable to get commits between: %s %s Error: %v" , pr . HeadBranch , pr . MergeBase , err )
return ""
}
if list . Len ( ) == 0 {
break
}
element := list . Front ( )
for element != nil {
commit := element . Value . ( * git . Commit )
authorString := commit . Author . String ( )
if ! authorsMap [ authorString ] && authorString != posterSig {
authors = append ( authors , authorString )
authorsMap [ authorString ] = true
}
element = element . Next ( )
}
}
}
if len ( authors ) > 0 {
if _ , err := stringBuilder . WriteRune ( '\n' ) ; err != nil {
log . Error ( "Unable to write to string builder Error: %v" , err )
return ""
}
}
for _ , author := range authors {
if _ , err := stringBuilder . Write ( [ ] byte ( "Co-authored-by: " ) ) ; err != nil {
log . Error ( "Unable to write to string builder Error: %v" , err )
return ""
}
if _ , err := stringBuilder . Write ( [ ] byte ( author ) ) ; err != nil {
log . Error ( "Unable to write to string builder Error: %v" , err )
return ""
}
if _ , err := stringBuilder . WriteRune ( '\n' ) ; err != nil {
log . Error ( "Unable to write to string builder Error: %v" , err )
return ""
}
}
return stringBuilder . String ( )
}
// GetApprovers returns the approvers of the pull request
func ( pr * PullRequest ) GetApprovers ( ) string {
stringBuilder := strings . Builder { }
if err := pr . getReviewedByLines ( & stringBuilder ) ; err != nil {
log . Error ( "Unable to getReviewedByLines: Error: %v" , err )
return ""
}
return stringBuilder . String ( )
}
func ( pr * PullRequest ) getReviewedByLines ( writer io . Writer ) error {
maxReviewers := setting . Repository . PullRequest . DefaultMergeMessageMaxApprovers
if maxReviewers == 0 {
return nil
}
sess := x . NewSession ( )
defer sess . Close ( )
if err := sess . Begin ( ) ; err != nil {
return err
}
// Note: This doesn't page as we only expect a very limited number of reviews
reviews , err := findReviews ( sess , FindReviewOptions {
Type : ReviewTypeApprove ,
IssueID : pr . IssueID ,
OfficialOnly : setting . Repository . PullRequest . DefaultMergeMessageOfficialApproversOnly ,
} )
if err != nil {
log . Error ( "Unable to FindReviews for PR ID %d: %v" , pr . ID , err )
return err
}
reviewersWritten := 0
for _ , review := range reviews {
if maxReviewers > 0 && reviewersWritten > maxReviewers {
break
}
if err := review . loadReviewer ( sess ) ; err != nil && ! IsErrUserNotExist ( err ) {
log . Error ( "Unable to LoadReviewer[%d] for PR ID %d : %v" , review . ReviewerID , pr . ID , err )
return err
} else if review . Reviewer == nil {
continue
}
if _ , err := writer . Write ( [ ] byte ( "Reviewed-by: " ) ) ; err != nil {
return err
}
if _ , err := writer . Write ( [ ] byte ( review . Reviewer . NewGitSig ( ) . String ( ) ) ) ; err != nil {
return err
}
if _ , err := writer . Write ( [ ] byte { '\n' } ) ; err != nil {
return err
}
reviewersWritten ++
}
return sess . Commit ( )
}
2018-01-05 21:56:50 +03:00
// GetDefaultSquashMessage returns default message used when squash and merging pull request
func ( pr * PullRequest ) GetDefaultSquashMessage ( ) string {
if err := pr . LoadIssue ( ) ; err != nil {
2019-04-02 10:48:31 +03:00
log . Error ( "LoadIssue: %v" , err )
2018-01-05 21:56:50 +03:00
return ""
}
2020-01-18 07:40:43 +03:00
if err := pr . LoadBaseRepo ( ) ; err != nil {
log . Error ( "LoadBaseRepo: %v" , err )
return ""
}
if pr . BaseRepo . UnitEnabled ( UnitTypeExternalTracker ) {
return fmt . Sprintf ( "%s (!%d)" , pr . Issue . Title , pr . Issue . Index )
}
2018-01-05 21:56:50 +03:00
return fmt . Sprintf ( "%s (#%d)" , pr . Issue . Title , pr . Issue . Index )
}
2018-01-19 09:18:51 +03:00
// GetGitRefName returns git ref for hidden pull request branch
func ( pr * PullRequest ) GetGitRefName ( ) string {
return fmt . Sprintf ( "refs/pull/%d/head" , pr . Index )
}
2015-10-26 01:35:27 +03:00
func ( pr * PullRequest ) getHeadRepo ( e Engine ) ( err error ) {
pr . HeadRepo , err = getRepositoryByID ( e , pr . HeadRepoID )
2015-10-24 10:36:47 +03:00
if err != nil && ! IsErrRepoNotExist ( err ) {
2015-10-26 16:16:24 +03:00
return fmt . Errorf ( "getRepositoryByID(head): %v" , err )
2015-10-24 10:36:47 +03:00
}
return nil
}
2016-11-28 18:31:06 +03:00
// GetHeadRepo loads the head repository
2016-08-14 13:32:24 +03:00
func ( pr * PullRequest ) GetHeadRepo ( ) error {
2015-10-26 01:35:27 +03:00
return pr . getHeadRepo ( x )
}
2016-11-28 18:31:06 +03:00
// GetBaseRepo loads the target repository
2015-10-24 10:36:47 +03:00
func ( pr * PullRequest ) GetBaseRepo ( ) ( err error ) {
if pr . BaseRepo != nil {
return nil
}
pr . BaseRepo , err = GetRepositoryByID ( pr . BaseRepoID )
if err != nil {
2015-10-26 16:16:24 +03:00
return fmt . Errorf ( "GetRepositoryByID(base): %v" , err )
2015-10-24 10:36:47 +03:00
}
return nil
}
// IsChecking returns true if this pull request is still checking conflict.
func ( pr * PullRequest ) IsChecking ( ) bool {
2016-11-07 18:37:32 +03:00
return pr . Status == PullRequestStatusChecking
2015-10-24 10:36:47 +03:00
}
2015-10-19 02:30:39 +03:00
// CanAutoMerge returns true if this pull request can be merged automatically.
func ( pr * PullRequest ) CanAutoMerge ( ) bool {
2016-11-07 18:37:32 +03:00
return pr . Status == PullRequestStatusMergeable
2015-10-19 02:30:39 +03:00
}
2019-04-02 22:54:29 +03:00
// GetLastCommitStatus returns the last commit status for this pull request.
func ( pr * PullRequest ) GetLastCommitStatus ( ) ( status * CommitStatus , err error ) {
if err = pr . GetHeadRepo ( ) ; err != nil {
return nil , err
}
2019-04-26 06:03:39 +03:00
if pr . HeadRepo == nil {
return nil , ErrPullRequestHeadRepoMissing { pr . ID , pr . HeadRepoID }
}
2019-04-02 22:54:29 +03:00
headGitRepo , err := git . OpenRepository ( pr . HeadRepo . RepoPath ( ) )
if err != nil {
return nil , err
}
2019-11-13 10:01:19 +03:00
defer headGitRepo . Close ( )
2019-04-02 22:54:29 +03:00
lastCommitID , err := headGitRepo . GetBranchCommitID ( pr . HeadBranch )
if err != nil {
return nil , err
}
2019-09-30 04:07:43 +03:00
err = pr . LoadBaseRepo ( )
if err != nil {
return nil , err
}
statusList , err := GetLatestCommitStatus ( pr . BaseRepo , lastCommitID , 0 )
2019-04-02 22:54:29 +03:00
if err != nil {
return nil , err
}
return CalcCommitStatus ( statusList ) , nil
}
2018-01-05 21:56:50 +03:00
// MergeStyle represents the approach to merge commits into base branch.
type MergeStyle string
const (
// MergeStyleMerge create merge commit
MergeStyleMerge MergeStyle = "merge"
// MergeStyleRebase rebase before merging
MergeStyleRebase MergeStyle = "rebase"
2018-12-27 13:27:08 +03:00
// MergeStyleRebaseMerge rebase before merging with merge commit (--no-ff)
MergeStyleRebaseMerge MergeStyle = "rebase-merge"
2018-01-05 21:56:50 +03:00
// MergeStyleSquash squash commits into single commit before merging
MergeStyleSquash MergeStyle = "squash"
)
2019-06-22 20:35:34 +03:00
// SetMerged sets a pull request to merged and closes the corresponding issue
func ( pr * PullRequest ) SetMerged ( ) ( err error ) {
2017-02-05 16:07:44 +03:00
if pr . HasMerged {
return fmt . Errorf ( "PullRequest[%d] already merged" , pr . Index )
}
2017-12-11 07:37:04 +03:00
if pr . MergedCommitID == "" || pr . MergedUnix == 0 || pr . Merger == nil {
2017-02-05 16:07:44 +03:00
return fmt . Errorf ( "Unable to merge PullRequest[%d], some required fields are empty" , pr . Index )
}
pr . HasMerged = true
sess := x . NewSession ( )
2017-06-21 03:57:05 +03:00
defer sess . Close ( )
2017-02-05 16:07:44 +03:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2017-02-27 03:42:55 +03:00
if err = pr . loadIssue ( sess ) ; err != nil {
2017-02-05 16:07:44 +03:00
return err
}
2017-02-27 03:42:55 +03:00
if err = pr . Issue . loadRepo ( sess ) ; err != nil {
return err
}
if err = pr . Issue . Repo . getOwner ( sess ) ; err != nil {
return err
2017-02-05 16:07:44 +03:00
}
2019-12-16 00:57:34 +03:00
if _ , err = pr . Issue . changeStatus ( sess , pr . Merger , true ) ; err != nil {
2017-02-05 16:07:44 +03:00
return fmt . Errorf ( "Issue.changeStatus: %v" , err )
}
2017-10-06 00:25:40 +03:00
if _ , err = sess . ID ( pr . ID ) . Cols ( "has_merged, status, merged_commit_id, merger_id, merged_unix" ) . Update ( pr ) ; err != nil {
2017-02-05 16:07:44 +03:00
return fmt . Errorf ( "update pull request: %v" , err )
}
if err = sess . Commit ( ) ; err != nil {
return fmt . Errorf ( "Commit: %v" , err )
}
return nil
}
2015-10-19 02:30:39 +03:00
// NewPullRequest creates new pull request with labels for repository.
2019-12-14 01:21:06 +03:00
func NewPullRequest ( repo * Repository , pull * Issue , labelIDs [ ] int64 , uuids [ ] string , pr * PullRequest ) ( err error ) {
2019-10-03 01:28:30 +03:00
// Retry several times in case INSERT fails due to duplicate key for (repo_id, index); see #7887
i := 0
for {
2019-12-14 01:21:06 +03:00
if err = newPullRequestAttempt ( repo , pull , labelIDs , uuids , pr ) ; err == nil {
2019-10-03 01:28:30 +03:00
return nil
}
if ! IsErrNewIssueInsert ( err ) {
return err
}
if i ++ ; i == issueMaxDupIndexAttempts {
break
}
log . Error ( "NewPullRequest: error attempting to insert the new issue; will retry. Original error: %v" , err )
}
return fmt . Errorf ( "NewPullRequest: too many errors attempting to insert the new issue. Last error was: %v" , err )
}
2019-12-14 01:21:06 +03:00
func newPullRequestAttempt ( repo * Repository , pull * Issue , labelIDs [ ] int64 , uuids [ ] string , pr * PullRequest ) ( err error ) {
2015-10-19 02:30:39 +03:00
sess := x . NewSession ( )
2017-06-21 03:57:05 +03:00
defer sess . Close ( )
2015-10-19 02:30:39 +03:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2017-02-01 05:36:08 +03:00
if err = newIssue ( sess , pull . Poster , NewIssueOptions {
2016-08-16 04:40:32 +03:00
Repo : repo ,
Issue : pull ,
2017-03-01 04:08:45 +03:00
LabelIDs : labelIDs ,
2016-08-16 04:40:32 +03:00
Attachments : uuids ,
IsPull : true ,
} ) ; err != nil {
2019-10-03 01:28:30 +03:00
if IsErrUserDoesNotHaveAccessToRepo ( err ) || IsErrNewIssueInsert ( err ) {
2018-05-09 19:29:04 +03:00
return err
}
2015-10-19 02:30:39 +03:00
return fmt . Errorf ( "newIssue: %v" , err )
}
2015-10-24 21:48:11 +03:00
pr . Index = pull . Index
2015-10-24 10:36:47 +03:00
pr . BaseRepo = repo
2015-10-19 02:30:39 +03:00
pr . IssueID = pull . ID
if _ , err = sess . Insert ( pr ) ; err != nil {
return fmt . Errorf ( "insert pull repo: %v" , err )
}
2016-07-15 19:36:39 +03:00
if err = sess . Commit ( ) ; err != nil {
return fmt . Errorf ( "Commit: %v" , err )
}
return nil
2015-10-19 02:30:39 +03:00
}
2017-01-05 03:50:34 +03:00
// GetUnmergedPullRequest returns a pull request that is open and has not been merged
2015-10-19 02:30:39 +03:00
// by given head/base and repo/branch.
func GetUnmergedPullRequest ( headRepoID , baseRepoID int64 , headBranch , baseBranch string ) ( * PullRequest , error ) {
pr := new ( PullRequest )
2016-11-10 18:16:32 +03:00
has , err := x .
Where ( "head_repo_id=? AND head_branch=? AND base_repo_id=? AND base_branch=? AND has_merged=? AND issue.is_closed=?" ,
headRepoID , headBranch , baseRepoID , baseBranch , false , false ) .
Join ( "INNER" , "issue" , "issue.id=pull_request.issue_id" ) .
Get ( pr )
2015-10-19 02:30:39 +03:00
if err != nil {
return nil , err
} else if ! has {
return nil , ErrPullRequestNotExist { 0 , 0 , headRepoID , baseRepoID , headBranch , baseBranch }
}
return pr , nil
}
2019-06-27 17:15:30 +03:00
// GetLatestPullRequestByHeadInfo returns the latest pull request (regardless of its status)
// by given head information (repo and branch).
func GetLatestPullRequestByHeadInfo ( repoID int64 , branch string ) ( * PullRequest , error ) {
pr := new ( PullRequest )
has , err := x .
Where ( "head_repo_id = ? AND head_branch = ?" , repoID , branch ) .
OrderBy ( "id DESC" ) .
Get ( pr )
if ! has {
return nil , err
}
return pr , err
}
2016-12-02 14:10:39 +03:00
// GetPullRequestByIndex returns a pull request by the given index
func GetPullRequestByIndex ( repoID int64 , index int64 ) ( * PullRequest , error ) {
pr := & PullRequest {
BaseRepoID : repoID ,
Index : index ,
}
has , err := x . Get ( pr )
if err != nil {
return nil , err
} else if ! has {
2017-01-01 21:15:09 +03:00
return nil , ErrPullRequestNotExist { 0 , 0 , 0 , repoID , "" , "" }
2016-12-02 14:10:39 +03:00
}
2016-12-05 14:17:39 +03:00
if err = pr . LoadAttributes ( ) ; err != nil {
return nil , err
}
if err = pr . LoadIssue ( ) ; err != nil {
return nil , err
}
2016-12-02 14:10:39 +03:00
return pr , nil
}
2016-08-14 13:32:24 +03:00
func getPullRequestByID ( e Engine , id int64 ) ( * PullRequest , error ) {
2015-10-24 10:36:47 +03:00
pr := new ( PullRequest )
2017-10-05 07:43:04 +03:00
has , err := e . ID ( id ) . Get ( pr )
2015-10-24 10:36:47 +03:00
if err != nil {
return nil , err
} else if ! has {
return nil , ErrPullRequestNotExist { id , 0 , 0 , 0 , "" , "" }
}
2016-08-14 13:32:24 +03:00
return pr , pr . loadAttributes ( e )
2015-10-24 10:36:47 +03:00
}
2016-08-14 13:32:24 +03:00
// GetPullRequestByID returns a pull request by given ID.
func GetPullRequestByID ( id int64 ) ( * PullRequest , error ) {
return getPullRequestByID ( x , id )
}
2020-01-23 20:28:15 +03:00
// GetPullRequestByIssueIDWithNoAttributes returns pull request with no attributes loaded by given issue ID.
func GetPullRequestByIssueIDWithNoAttributes ( issueID int64 ) ( * PullRequest , error ) {
var pr PullRequest
has , err := x . Where ( "issue_id = ?" , issueID ) . Get ( & pr )
if err != nil {
return nil , err
}
if ! has {
return nil , ErrPullRequestNotExist { 0 , issueID , 0 , 0 , "" , "" }
}
return & pr , nil
}
2016-08-14 13:32:24 +03:00
func getPullRequestByIssueID ( e Engine , issueID int64 ) ( * PullRequest , error ) {
2015-10-22 21:47:24 +03:00
pr := & PullRequest {
IssueID : issueID ,
}
2016-08-14 13:32:24 +03:00
has , err := e . Get ( pr )
2015-10-19 02:30:39 +03:00
if err != nil {
return nil , err
} else if ! has {
2015-10-22 21:47:24 +03:00
return nil , ErrPullRequestNotExist { 0 , issueID , 0 , 0 , "" , "" }
2015-10-19 02:30:39 +03:00
}
2016-08-14 13:32:24 +03:00
return pr , pr . loadAttributes ( e )
}
// GetPullRequestByIssueID returns pull request by given issue ID.
func GetPullRequestByIssueID ( issueID int64 ) ( * PullRequest , error ) {
return getPullRequestByIssueID ( x , issueID )
2015-10-19 02:30:39 +03:00
}
2015-10-24 10:36:47 +03:00
// Update updates all fields of pull request.
func ( pr * PullRequest ) Update ( ) error {
2017-10-05 07:43:04 +03:00
_ , err := x . ID ( pr . ID ) . AllCols ( ) . Update ( pr )
2015-10-24 10:36:47 +03:00
return err
}
2016-11-28 18:31:06 +03:00
// UpdateCols updates specific fields of pull request.
2015-10-24 10:36:47 +03:00
func ( pr * PullRequest ) UpdateCols ( cols ... string ) error {
2017-10-05 07:43:04 +03:00
_ , err := x . ID ( pr . ID ) . Cols ( cols ... ) . Update ( pr )
2015-10-24 10:36:47 +03:00
return err
}
2018-08-13 22:04:39 +03:00
// IsWorkInProgress determine if the Pull Request is a Work In Progress by its title
func ( pr * PullRequest ) IsWorkInProgress ( ) bool {
if err := pr . LoadIssue ( ) ; err != nil {
2019-04-02 10:48:31 +03:00
log . Error ( "LoadIssue: %v" , err )
2018-08-13 22:04:39 +03:00
return false
}
for _ , prefix := range setting . Repository . PullRequest . WorkInProgressPrefixes {
if strings . HasPrefix ( strings . ToUpper ( pr . Issue . Title ) , prefix ) {
return true
}
}
return false
}
2019-02-05 14:54:49 +03:00
// IsFilesConflicted determines if the Pull Request has changes conflicting with the target branch.
func ( pr * PullRequest ) IsFilesConflicted ( ) bool {
return len ( pr . ConflictedFiles ) > 0
}
2018-08-13 22:04:39 +03:00
// GetWorkInProgressPrefix returns the prefix used to mark the pull request as a work in progress.
// It returns an empty string when none were found
func ( pr * PullRequest ) GetWorkInProgressPrefix ( ) string {
if err := pr . LoadIssue ( ) ; err != nil {
2019-04-02 10:48:31 +03:00
log . Error ( "LoadIssue: %v" , err )
2018-08-13 22:04:39 +03:00
return ""
}
for _ , prefix := range setting . Repository . PullRequest . WorkInProgressPrefixes {
if strings . HasPrefix ( strings . ToUpper ( pr . Issue . Title ) , prefix ) {
return pr . Issue . Title [ 0 : len ( prefix ) ]
}
}
return ""
}
2019-12-16 09:20:25 +03:00
// IsHeadEqualWithBranch returns if the commits of branchName are available in pull request head
func ( pr * PullRequest ) IsHeadEqualWithBranch ( branchName string ) ( bool , error ) {
var err error
if err = pr . GetBaseRepo ( ) ; err != nil {
return false , err
}
baseGitRepo , err := git . OpenRepository ( pr . BaseRepo . RepoPath ( ) )
if err != nil {
return false , err
}
baseCommit , err := baseGitRepo . GetBranchCommit ( branchName )
if err != nil {
return false , err
}
if err = pr . GetHeadRepo ( ) ; err != nil {
return false , err
}
headGitRepo , err := git . OpenRepository ( pr . HeadRepo . RepoPath ( ) )
if err != nil {
return false , err
}
headCommit , err := headGitRepo . GetBranchCommit ( pr . HeadBranch )
if err != nil {
return false , err
}
return baseCommit . HasPreviousCommit ( headCommit . ID )
}
2020-01-17 09:03:40 +03:00
// IsSameRepo returns true if base repo and head repo is the same
func ( pr * PullRequest ) IsSameRepo ( ) bool {
return pr . BaseRepoID == pr . HeadRepoID
}