2015-10-19 07:30:39 +08:00
// Copyright 2015 The Gogs Authors. All rights reserved.
2019-04-19 20:17:27 +08:00
// Copyright 2019 The Gitea Authors. All rights reserved.
2015-10-19 07:30:39 +08: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 07:34:11 +08:00
"io"
2015-10-19 07:30:39 +08:00
"strings"
2016-11-11 00:24:48 +08:00
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
2019-08-15 22:46:21 +08:00
"code.gitea.io/gitea/modules/timeutil"
2021-02-18 10:45:49 +08:00
"code.gitea.io/gitea/modules/util"
2015-10-19 07:30:39 +08:00
)
2016-11-28 23:31:06 +08:00
// PullRequestType defines pull request type
2015-10-19 07:30:39 +08:00
type PullRequestType int
2016-11-28 23:31:06 +08:00
// Enumerate all the pull request types
2015-10-19 07:30:39 +08:00
const (
2016-11-07 23:37:32 +08:00
PullRequestGitea PullRequestType = iota
PullRequestGit
2015-10-19 07:30:39 +08:00
)
2016-11-28 23:31:06 +08:00
// PullRequestStatus defines pull request status
2015-10-19 07:30:39 +08:00
type PullRequestStatus int
2016-11-28 23:31:06 +08:00
// Enumerate all the pull request status
2015-10-19 07:30:39 +08:00
const (
2016-11-07 23:37:32 +08:00
PullRequestStatusConflict PullRequestStatus = iota
PullRequestStatusChecking
PullRequestStatusMergeable
2017-02-05 21:07:44 +08:00
PullRequestStatusManuallyMerged
2020-01-10 08:14:14 +08:00
PullRequestStatusError
2021-03-04 11:41:23 +08:00
PullRequestStatusEmpty
2015-10-19 07:30:39 +08:00
)
// PullRequest represents relation between pull request and repositories.
type PullRequest struct {
2019-02-05 19:54:49 +08:00
ID int64 ` xorm:"pk autoincr" `
Type PullRequestType
Status PullRequestStatus
ConflictedFiles [ ] string ` xorm:"TEXT JSON" `
2020-04-14 21:53:34 +08:00
CommitsAhead int
CommitsBehind int
2015-10-19 07:30:39 +08:00
2020-10-14 02:50:57 +08:00
ChangedProtectedFiles [ ] string ` xorm:"TEXT JSON" `
2015-10-19 07:30:39 +08:00
IssueID int64 ` xorm:"INDEX" `
Issue * Issue ` xorm:"-" `
Index int64
2018-12-11 19:28:37 +08: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 07:30:39 +08:00
2019-08-15 22:46:21 +08:00
HasMerged bool ` xorm:"INDEX" `
MergedCommitID string ` xorm:"VARCHAR(40)" `
MergerID int64 ` xorm:"INDEX" `
Merger * User ` xorm:"-" `
MergedUnix timeutil . TimeStamp ` xorm:"updated INDEX" `
2020-03-03 06:31:55 +08:00
isHeadRepoLoaded bool ` xorm:"-" `
2015-10-19 07:30:39 +08:00
}
2019-10-18 19:13:31 +08: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 10:48:22 +08: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 19:13:31 +08:00
return ""
}
2020-03-03 06:31:55 +08:00
if pr . HeadRepo == nil {
return ""
}
2020-01-12 17:36:21 +08:00
return pr . HeadRepo . OwnerName
2019-10-18 19:13:31 +08:00
}
2016-08-14 18:32:24 +08: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 23:31:06 +08:00
// LoadAttributes loads pull request attributes from database
2016-08-14 18:32:24 +08:00
func ( pr * PullRequest ) LoadAttributes ( ) error {
return pr . loadAttributes ( x )
}
2020-03-03 06:31:55 +08:00
func ( pr * PullRequest ) loadHeadRepo ( e Engine ) ( err error ) {
if ! pr . isHeadRepoLoaded && pr . HeadRepo == nil && pr . HeadRepoID > 0 {
if pr . HeadRepoID == pr . BaseRepoID {
if pr . BaseRepo != nil {
pr . HeadRepo = pr . BaseRepo
return nil
} else if pr . Issue != nil && pr . Issue . Repo != nil {
pr . HeadRepo = pr . Issue . Repo
return nil
}
2019-10-18 19:13:31 +08:00
}
2020-03-03 06:31:55 +08:00
pr . HeadRepo , err = getRepositoryByID ( e , pr . HeadRepoID )
if err != nil && ! IsErrRepoNotExist ( err ) { // Head repo maybe deleted, but it should still work
return fmt . Errorf ( "getRepositoryByID(head): %v" , err )
2019-09-18 13:39:45 +08:00
}
2020-03-03 06:31:55 +08:00
pr . isHeadRepoLoaded = true
2019-09-18 13:39:45 +08:00
}
return nil
}
2020-03-03 06:31:55 +08:00
// LoadHeadRepo loads the head repository
2019-10-18 19:13:31 +08:00
func ( pr * PullRequest ) LoadHeadRepo ( ) error {
2020-03-03 06:31:55 +08:00
return pr . loadHeadRepo ( x )
}
// LoadBaseRepo loads the target repository
func ( pr * PullRequest ) LoadBaseRepo ( ) error {
return pr . loadBaseRepo ( x )
}
func ( pr * PullRequest ) loadBaseRepo ( e Engine ) ( err error ) {
if pr . BaseRepo != nil {
return nil
}
if pr . HeadRepoID == pr . BaseRepoID && pr . HeadRepo != nil {
pr . BaseRepo = pr . HeadRepo
return nil
}
if pr . Issue != nil && pr . Issue . Repo != nil {
pr . BaseRepo = pr . Issue . Repo
return nil
}
pr . BaseRepo , err = getRepositoryByID ( e , pr . BaseRepoID )
if err != nil {
return fmt . Errorf ( "GetRepositoryByID(base): %v" , err )
2019-10-18 19:13:31 +08:00
}
return nil
}
2016-11-28 23:31:06 +08:00
// LoadIssue loads issue information from database
2016-08-14 18:32:24 +08:00
func ( pr * PullRequest ) LoadIssue ( ) ( err error ) {
2017-02-27 08:42:55 +08:00
return pr . loadIssue ( x )
}
func ( pr * PullRequest ) loadIssue ( e Engine ) ( err error ) {
2016-08-17 01:19:09 +08:00
if pr . Issue != nil {
return nil
}
2017-02-27 08:42:55 +08:00
pr . Issue , err = getIssueByID ( e , pr . IssueID )
2019-11-22 01:08:42 +08:00
if err == nil {
pr . Issue . PullRequest = pr
}
2016-08-14 18:32:24 +08:00
return err
}
2018-12-11 19:28:37 +08:00
// LoadProtectedBranch loads the protected branch of the base branch
func ( pr * PullRequest ) LoadProtectedBranch ( ) ( err error ) {
2019-12-04 09:08:56 +08:00
return pr . loadProtectedBranch ( x )
}
func ( pr * PullRequest ) loadProtectedBranch ( e Engine ) ( err error ) {
2020-01-15 16:32:57 +08: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-18 01:35:21 +08:00
}
2020-01-15 16:32:57 +08:00
pr . ProtectedBranch , err = getProtectedBranchBy ( e , pr . BaseRepo . ID , pr . BaseBranch )
2018-12-18 01:35:21 +08:00
}
2018-12-11 19:28:37 +08:00
return
}
2018-01-06 02:56:50 +08: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 15:48:31 +08:00
log . Error ( "GetRepositoryById[%d]: %v" , pr . HeadRepoID , err )
2018-01-06 02:56:50 +08:00
return ""
}
}
2020-01-08 19:53:07 +08: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 16:29:30 +08: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-06 02:56:50 +08:00
}
2020-03-06 11:44:06 +08:00
// ReviewCount represents a count of Reviews
type ReviewCount struct {
IssueID int64
Type ReviewType
Count int64
}
// GetApprovalCounts returns the approval counts by type
// FIXME: Only returns official counts due to double counting of non-official counts
func ( pr * PullRequest ) GetApprovalCounts ( ) ( [ ] * ReviewCount , error ) {
return pr . getApprovalCounts ( x )
}
func ( pr * PullRequest ) getApprovalCounts ( e Engine ) ( [ ] * ReviewCount , error ) {
rCounts := make ( [ ] * ReviewCount , 0 , 6 )
sess := e . Where ( "issue_id = ?" , pr . IssueID )
2021-02-12 01:32:25 +08:00
return rCounts , sess . Select ( "issue_id, type, count(id) as `count`" ) . Where ( "official = ? AND dismissed = ?" , true , false ) . GroupBy ( "issue_id, type" ) . Table ( "review" ) . Find ( & rCounts )
2020-03-06 11:44:06 +08:00
}
2019-12-31 07:34:11 +08:00
// 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-06 02:56:50 +08: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 15:48:31 +08:00
log . Error ( "LoadIssue: %v" , err )
2018-01-06 02:56:50 +08:00
return ""
}
2020-01-18 12:40:43 +08: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-06 02:56:50 +08:00
return fmt . Sprintf ( "%s (#%d)" , pr . Issue . Title , pr . Issue . Index )
}
2018-01-19 14:18:51 +08: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-24 15:36:47 +08:00
// IsChecking returns true if this pull request is still checking conflict.
func ( pr * PullRequest ) IsChecking ( ) bool {
2016-11-07 23:37:32 +08:00
return pr . Status == PullRequestStatusChecking
2015-10-24 15:36:47 +08:00
}
2015-10-19 07:30:39 +08:00
// CanAutoMerge returns true if this pull request can be merged automatically.
func ( pr * PullRequest ) CanAutoMerge ( ) bool {
2016-11-07 23:37:32 +08:00
return pr . Status == PullRequestStatusMergeable
2015-10-19 07:30:39 +08:00
}
2021-03-04 11:41:23 +08:00
// IsEmpty returns true if this pull request is empty.
func ( pr * PullRequest ) IsEmpty ( ) bool {
return pr . Status == PullRequestStatusEmpty
}
2018-01-06 02:56:50 +08: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 18:27:08 +08:00
// MergeStyleRebaseMerge rebase before merging with merge commit (--no-ff)
MergeStyleRebaseMerge MergeStyle = "rebase-merge"
2018-01-06 02:56:50 +08:00
// MergeStyleSquash squash commits into single commit before merging
MergeStyleSquash MergeStyle = "squash"
2021-03-04 11:41:23 +08:00
// MergeStyleManuallyMerged pr has been merged manually, just mark it as merged directly
MergeStyleManuallyMerged MergeStyle = "manually-merged"
2018-01-06 02:56:50 +08:00
)
2019-06-23 01:35:34 +08:00
// SetMerged sets a pull request to merged and closes the corresponding issue
2020-02-10 07:09:31 +08:00
func ( pr * PullRequest ) SetMerged ( ) ( bool , error ) {
2017-02-05 21:07:44 +08:00
if pr . HasMerged {
2020-02-10 07:09:31 +08:00
return false , fmt . Errorf ( "PullRequest[%d] already merged" , pr . Index )
2017-02-05 21:07:44 +08:00
}
2017-12-11 12:37:04 +08:00
if pr . MergedCommitID == "" || pr . MergedUnix == 0 || pr . Merger == nil {
2020-02-10 07:09:31 +08:00
return false , fmt . Errorf ( "Unable to merge PullRequest[%d], some required fields are empty" , pr . Index )
2017-02-05 21:07:44 +08:00
}
pr . HasMerged = true
sess := x . NewSession ( )
2017-06-21 08:57:05 +08:00
defer sess . Close ( )
2020-02-10 07:09:31 +08:00
if err := sess . Begin ( ) ; err != nil {
return false , err
2017-02-05 21:07:44 +08:00
}
2020-02-10 07:09:31 +08:00
if _ , err := sess . Exec ( "UPDATE `issue` SET `repo_id` = `repo_id` WHERE `id` = ?" , pr . IssueID ) ; err != nil {
return false , err
2017-02-05 21:07:44 +08:00
}
2020-02-10 07:09:31 +08:00
if _ , err := sess . Exec ( "UPDATE `pull_request` SET `issue_id` = `issue_id` WHERE `id` = ?" , pr . ID ) ; err != nil {
return false , err
2017-02-27 08:42:55 +08:00
}
2020-02-10 07:09:31 +08:00
pr . Issue = nil
if err := pr . loadIssue ( sess ) ; err != nil {
return false , err
2017-02-05 21:07:44 +08:00
}
2020-02-10 07:09:31 +08:00
if tmpPr , err := getPullRequestByID ( sess , pr . ID ) ; err != nil {
return false , err
} else if tmpPr . HasMerged {
if pr . Issue . IsClosed {
return false , nil
}
return false , fmt . Errorf ( "PullRequest[%d] already merged but it's associated issue [%d] is not closed" , pr . Index , pr . IssueID )
} else if pr . Issue . IsClosed {
return false , fmt . Errorf ( "PullRequest[%d] already closed" , pr . Index )
2017-02-05 21:07:44 +08:00
}
2020-02-10 07:09:31 +08:00
if err := pr . Issue . loadRepo ( sess ) ; err != nil {
return false , err
2017-02-05 21:07:44 +08:00
}
2020-02-10 07:09:31 +08:00
if err := pr . Issue . Repo . getOwner ( sess ) ; err != nil {
return false , err
2017-02-05 21:07:44 +08:00
}
2020-02-10 07:09:31 +08:00
2020-04-14 09:06:23 +08:00
if _ , err := pr . Issue . changeStatus ( sess , pr . Merger , true , true ) ; err != nil {
2020-02-10 07:09:31 +08:00
return false , fmt . Errorf ( "Issue.changeStatus: %v" , err )
}
2021-04-10 16:27:29 +08:00
// We need to save all of the data used to compute this merge as it may have already been changed by TestPatch. FIXME: need to set some state to prevent TestPatch from running whilst we are merging.
if _ , err := sess . Where ( "id = ?" , pr . ID ) . Cols ( "has_merged, status, merge_base, merged_commit_id, merger_id, merged_unix" ) . Update ( pr ) ; err != nil {
2020-02-10 07:09:31 +08:00
return false , fmt . Errorf ( "Failed to update pr[%d]: %v" , pr . ID , err )
}
if err := sess . Commit ( ) ; err != nil {
return false , fmt . Errorf ( "Commit: %v" , err )
}
return true , nil
2017-02-05 21:07:44 +08:00
}
2015-10-19 07:30:39 +08:00
// NewPullRequest creates new pull request with labels for repository.
2019-12-14 06:21:06 +08:00
func NewPullRequest ( repo * Repository , pull * Issue , labelIDs [ ] int64 , uuids [ ] string , pr * PullRequest ) ( err error ) {
2019-10-03 06:28:30 +08:00
// Retry several times in case INSERT fails due to duplicate key for (repo_id, index); see #7887
i := 0
for {
2019-12-14 06:21:06 +08:00
if err = newPullRequestAttempt ( repo , pull , labelIDs , uuids , pr ) ; err == nil {
2019-10-03 06:28:30 +08: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 06:21:06 +08:00
func newPullRequestAttempt ( repo * Repository , pull * Issue , labelIDs [ ] int64 , uuids [ ] string , pr * PullRequest ) ( err error ) {
2015-10-19 07:30:39 +08:00
sess := x . NewSession ( )
2017-06-21 08:57:05 +08:00
defer sess . Close ( )
2015-10-19 07:30:39 +08:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2017-02-01 10:36:08 +08:00
if err = newIssue ( sess , pull . Poster , NewIssueOptions {
2016-08-16 09:40:32 +08:00
Repo : repo ,
Issue : pull ,
2017-03-01 09:08:45 +08:00
LabelIDs : labelIDs ,
2016-08-16 09:40:32 +08:00
Attachments : uuids ,
IsPull : true ,
} ) ; err != nil {
2019-10-03 06:28:30 +08:00
if IsErrUserDoesNotHaveAccessToRepo ( err ) || IsErrNewIssueInsert ( err ) {
2018-05-10 00:29:04 +08:00
return err
}
2015-10-19 07:30:39 +08:00
return fmt . Errorf ( "newIssue: %v" , err )
}
2015-10-25 02:48:11 +08:00
pr . Index = pull . Index
2015-10-24 15:36:47 +08:00
pr . BaseRepo = repo
2015-10-19 07:30:39 +08:00
pr . IssueID = pull . ID
if _ , err = sess . Insert ( pr ) ; err != nil {
return fmt . Errorf ( "insert pull repo: %v" , err )
}
2016-07-16 00:36:39 +08:00
if err = sess . Commit ( ) ; err != nil {
return fmt . Errorf ( "Commit: %v" , err )
}
return nil
2015-10-19 07:30:39 +08:00
}
2017-01-05 08:50:34 +08:00
// GetUnmergedPullRequest returns a pull request that is open and has not been merged
2015-10-19 07:30:39 +08:00
// by given head/base and repo/branch.
func GetUnmergedPullRequest ( headRepoID , baseRepoID int64 , headBranch , baseBranch string ) ( * PullRequest , error ) {
pr := new ( PullRequest )
2016-11-10 23:16:32 +08: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 07:30:39 +08: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 22:15:30 +08: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 19:10:39 +08:00
// GetPullRequestByIndex returns a pull request by the given index
2021-03-15 02:52:12 +08:00
func GetPullRequestByIndex ( repoID , index int64 ) ( * PullRequest , error ) {
2016-12-02 19:10:39 +08:00
pr := & PullRequest {
BaseRepoID : repoID ,
Index : index ,
}
has , err := x . Get ( pr )
if err != nil {
return nil , err
} else if ! has {
2017-01-02 02:15:09 +08:00
return nil , ErrPullRequestNotExist { 0 , 0 , 0 , repoID , "" , "" }
2016-12-02 19:10:39 +08:00
}
2016-12-05 19:17:39 +08:00
if err = pr . LoadAttributes ( ) ; err != nil {
return nil , err
}
if err = pr . LoadIssue ( ) ; err != nil {
return nil , err
}
2016-12-02 19:10:39 +08:00
return pr , nil
}
2016-08-14 18:32:24 +08:00
func getPullRequestByID ( e Engine , id int64 ) ( * PullRequest , error ) {
2015-10-24 15:36:47 +08:00
pr := new ( PullRequest )
2017-10-05 12:43:04 +08:00
has , err := e . ID ( id ) . Get ( pr )
2015-10-24 15:36:47 +08:00
if err != nil {
return nil , err
} else if ! has {
return nil , ErrPullRequestNotExist { id , 0 , 0 , 0 , "" , "" }
}
2016-08-14 18:32:24 +08:00
return pr , pr . loadAttributes ( e )
2015-10-24 15:36:47 +08:00
}
2016-08-14 18:32:24 +08:00
// GetPullRequestByID returns a pull request by given ID.
func GetPullRequestByID ( id int64 ) ( * PullRequest , error ) {
return getPullRequestByID ( x , id )
}
2020-01-24 01:28:15 +08: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 18:32:24 +08:00
func getPullRequestByIssueID ( e Engine , issueID int64 ) ( * PullRequest , error ) {
2015-10-23 02:47:24 +08:00
pr := & PullRequest {
IssueID : issueID ,
}
2016-08-14 18:32:24 +08:00
has , err := e . Get ( pr )
2015-10-19 07:30:39 +08:00
if err != nil {
return nil , err
} else if ! has {
2015-10-23 02:47:24 +08:00
return nil , ErrPullRequestNotExist { 0 , issueID , 0 , 0 , "" , "" }
2015-10-19 07:30:39 +08:00
}
2016-08-14 18:32:24 +08: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 07:30:39 +08:00
}
2015-10-24 15:36:47 +08:00
// Update updates all fields of pull request.
func ( pr * PullRequest ) Update ( ) error {
2017-10-05 12:43:04 +08:00
_ , err := x . ID ( pr . ID ) . AllCols ( ) . Update ( pr )
2015-10-24 15:36:47 +08:00
return err
}
2016-11-28 23:31:06 +08:00
// UpdateCols updates specific fields of pull request.
2015-10-24 15:36:47 +08:00
func ( pr * PullRequest ) UpdateCols ( cols ... string ) error {
2017-10-05 12:43:04 +08:00
_ , err := x . ID ( pr . ID ) . Cols ( cols ... ) . Update ( pr )
2015-10-24 15:36:47 +08:00
return err
2020-02-10 07:09:31 +08:00
}
// UpdateColsIfNotMerged updates specific fields of a pull request if it has not been merged
func ( pr * PullRequest ) UpdateColsIfNotMerged ( cols ... string ) error {
_ , err := x . Where ( "id = ? AND has_merged = ?" , pr . ID , false ) . Cols ( cols ... ) . Update ( pr )
return err
2015-10-24 15:36:47 +08:00
}
2018-08-14 03:04:39 +08: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 15:48:31 +08:00
log . Error ( "LoadIssue: %v" , err )
2018-08-14 03:04:39 +08: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 19:54:49 +08: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-14 03:04:39 +08: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 15:48:31 +08:00
log . Error ( "LoadIssue: %v" , err )
2018-08-14 03:04:39 +08: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 14:20:25 +08:00
2020-04-14 21:53:34 +08:00
// UpdateCommitDivergence update Divergence of a pull request
func ( pr * PullRequest ) UpdateCommitDivergence ( ahead , behind int ) error {
return pr . updateCommitDivergence ( x , ahead , behind )
}
func ( pr * PullRequest ) updateCommitDivergence ( e Engine , ahead , behind int ) error {
if pr . ID == 0 {
return fmt . Errorf ( "pull ID is 0" )
}
pr . CommitsAhead = ahead
pr . CommitsBehind = behind
_ , err := e . ID ( pr . ID ) . Cols ( "commits_ahead" , "commits_behind" ) . Update ( pr )
return err
}
2020-01-17 14:03:40 +08:00
// IsSameRepo returns true if base repo and head repo is the same
func ( pr * PullRequest ) IsSameRepo ( ) bool {
return pr . BaseRepoID == pr . HeadRepoID
}
2021-02-18 10:45:49 +08:00
// GetBaseBranchHTMLURL returns the HTML URL of the base branch
func ( pr * PullRequest ) GetBaseBranchHTMLURL ( ) string {
if err := pr . LoadBaseRepo ( ) ; err != nil {
log . Error ( "LoadBaseRepo: %v" , err )
return ""
}
if pr . BaseRepo == nil {
return ""
}
return pr . BaseRepo . HTMLURL ( ) + "/src/branch/" + util . PathEscapeSegments ( pr . BaseBranch )
}
// GetHeadBranchHTMLURL returns the HTML URL of the head branch
func ( pr * PullRequest ) GetHeadBranchHTMLURL ( ) string {
if err := pr . LoadHeadRepo ( ) ; err != nil {
log . Error ( "LoadHeadRepo: %v" , err )
return ""
}
if pr . HeadRepo == nil {
return ""
}
return pr . HeadRepo . HTMLURL ( ) + "/src/branch/" + util . PathEscapeSegments ( pr . HeadBranch )
}