2015-10-19 08:30:39 +09:00
// Copyright 2015 The Gogs Authors. All rights reserved.
2019-04-19 21:17:27 +09:00
// Copyright 2019 The Gitea Authors. All rights reserved.
2015-10-19 08:30:39 +09: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 08:34:11 +09:00
"io"
2015-10-19 08:30:39 +09:00
"strings"
2016-11-11 01:24:48 +09:00
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
2019-08-15 23:46:21 +09:00
"code.gitea.io/gitea/modules/timeutil"
2021-02-18 11:45:49 +09:00
"code.gitea.io/gitea/modules/util"
2015-10-19 08:30:39 +09:00
)
2016-11-29 00:31:06 +09:00
// PullRequestType defines pull request type
2015-10-19 08:30:39 +09:00
type PullRequestType int
2016-11-29 00:31:06 +09:00
// Enumerate all the pull request types
2015-10-19 08:30:39 +09:00
const (
2016-11-08 00:37:32 +09:00
PullRequestGitea PullRequestType = iota
PullRequestGit
2015-10-19 08:30:39 +09:00
)
2016-11-29 00:31:06 +09:00
// PullRequestStatus defines pull request status
2015-10-19 08:30:39 +09:00
type PullRequestStatus int
2016-11-29 00:31:06 +09:00
// Enumerate all the pull request status
2015-10-19 08:30:39 +09:00
const (
2016-11-08 00:37:32 +09:00
PullRequestStatusConflict PullRequestStatus = iota
PullRequestStatusChecking
PullRequestStatusMergeable
2017-02-05 22:07:44 +09:00
PullRequestStatusManuallyMerged
2020-01-10 09:14:14 +09:00
PullRequestStatusError
2021-03-04 12:41:23 +09:00
PullRequestStatusEmpty
2015-10-19 08:30:39 +09:00
)
2021-07-28 18:42:56 +09:00
// PullRequestFlow the flow of pull request
type PullRequestFlow int
const (
// PullRequestFlowGithub github flow from head branch to base branch
PullRequestFlowGithub PullRequestFlow = iota
// PullRequestFlowAGit Agit flow pull request, head branch is not exist
PullRequestFlowAGit
)
2015-10-19 08:30:39 +09:00
// PullRequest represents relation between pull request and repositories.
type PullRequest struct {
2019-02-05 20:54:49 +09:00
ID int64 ` xorm:"pk autoincr" `
Type PullRequestType
Status PullRequestStatus
ConflictedFiles [ ] string ` xorm:"TEXT JSON" `
2020-04-14 22:53:34 +09:00
CommitsAhead int
CommitsBehind int
2015-10-19 08:30:39 +09:00
2020-10-14 03:50:57 +09:00
ChangedProtectedFiles [ ] string ` xorm:"TEXT JSON" `
2015-10-19 08:30:39 +09:00
IssueID int64 ` xorm:"INDEX" `
Issue * Issue ` xorm:"-" `
Index int64
2018-12-11 20:28:37 +09:00
HeadRepoID int64 ` xorm:"INDEX" `
HeadRepo * Repository ` xorm:"-" `
BaseRepoID int64 ` xorm:"INDEX" `
BaseRepo * Repository ` xorm:"-" `
HeadBranch string
2021-07-28 18:42:56 +09:00
HeadCommitID string ` xorm:"-" `
2018-12-11 20:28:37 +09:00
BaseBranch string
ProtectedBranch * ProtectedBranch ` xorm:"-" `
MergeBase string ` xorm:"VARCHAR(40)" `
2015-10-19 08:30:39 +09:00
2019-08-15 23:46:21 +09: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 07:31:55 +09:00
isHeadRepoLoaded bool ` xorm:"-" `
2021-07-28 18:42:56 +09:00
Flow PullRequestFlow ` xorm:"NOT NULL DEFAULT 0" `
2015-10-19 08:30:39 +09:00
}
2019-10-18 20:13:31 +09: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 11:48:22 +09: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 20:13:31 +09:00
return ""
}
2020-03-03 07:31:55 +09:00
if pr . HeadRepo == nil {
return ""
}
2020-01-12 18:36:21 +09:00
return pr . HeadRepo . OwnerName
2019-10-18 20:13:31 +09:00
}
2016-08-14 19:32:24 +09: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-29 00:31:06 +09:00
// LoadAttributes loads pull request attributes from database
2016-08-14 19:32:24 +09:00
func ( pr * PullRequest ) LoadAttributes ( ) error {
return pr . loadAttributes ( x )
}
2020-03-03 07:31:55 +09: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 20:13:31 +09:00
}
2020-03-03 07:31:55 +09: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 14:39:45 +09:00
}
2020-03-03 07:31:55 +09:00
pr . isHeadRepoLoaded = true
2019-09-18 14:39:45 +09:00
}
return nil
}
2020-03-03 07:31:55 +09:00
// LoadHeadRepo loads the head repository
2019-10-18 20:13:31 +09:00
func ( pr * PullRequest ) LoadHeadRepo ( ) error {
2020-03-03 07:31:55 +09: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 20:13:31 +09:00
}
return nil
}
2016-11-29 00:31:06 +09:00
// LoadIssue loads issue information from database
2016-08-14 19:32:24 +09:00
func ( pr * PullRequest ) LoadIssue ( ) ( err error ) {
2017-02-27 09:42:55 +09:00
return pr . loadIssue ( x )
}
func ( pr * PullRequest ) loadIssue ( e Engine ) ( err error ) {
2016-08-17 02:19:09 +09:00
if pr . Issue != nil {
return nil
}
2017-02-27 09:42:55 +09:00
pr . Issue , err = getIssueByID ( e , pr . IssueID )
2019-11-22 02:08:42 +09:00
if err == nil {
pr . Issue . PullRequest = pr
}
2016-08-14 19:32:24 +09:00
return err
}
2018-12-11 20:28:37 +09:00
// LoadProtectedBranch loads the protected branch of the base branch
func ( pr * PullRequest ) LoadProtectedBranch ( ) ( err error ) {
2019-12-04 10:08:56 +09:00
return pr . loadProtectedBranch ( x )
}
func ( pr * PullRequest ) loadProtectedBranch ( e Engine ) ( err error ) {
2020-01-15 17:32:57 +09: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 02:35:21 +09:00
}
2020-01-15 17:32:57 +09:00
pr . ProtectedBranch , err = getProtectedBranchBy ( e , pr . BaseRepo . ID , pr . BaseBranch )
2018-12-18 02:35:21 +09:00
}
2018-12-11 20:28:37 +09:00
return
}
2018-01-06 03:56:50 +09: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 16:48:31 +09:00
log . Error ( "GetRepositoryById[%d]: %v" , pr . HeadRepoID , err )
2018-01-06 03:56:50 +09:00
return ""
}
}
2020-01-08 20:53:07 +09: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 ""
}
2021-05-09 04:19:42 +09:00
if err := pr . LoadBaseRepo ( ) ; err != nil {
log . Error ( "LoadBaseRepo: %v" , err )
return ""
}
issueReference := "#"
if pr . BaseRepo . UnitEnabled ( UnitTypeExternalTracker ) {
issueReference = "!"
}
2020-01-28 17:29:30 +09:00
if pr . BaseRepoID == pr . HeadRepoID {
2021-05-09 04:19:42 +09:00
return fmt . Sprintf ( "Merge pull request '%s' (%s%d) from %s into %s" , pr . Issue . Title , issueReference , pr . Issue . Index , pr . HeadBranch , pr . BaseBranch )
2020-01-28 17:29:30 +09:00
}
2021-05-09 04:19:42 +09:00
return fmt . Sprintf ( "Merge pull request '%s' (%s%d) from %s:%s into %s" , pr . Issue . Title , issueReference , pr . Issue . Index , pr . HeadRepo . FullName ( ) , pr . HeadBranch , pr . BaseBranch )
2018-01-06 03:56:50 +09:00
}
2020-03-06 12:44:06 +09: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 02:32:25 +09: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 12:44:06 +09:00
}
2019-12-31 08:34:11 +09: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 03:56:50 +09: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 16:48:31 +09:00
log . Error ( "LoadIssue: %v" , err )
2018-01-06 03:56:50 +09:00
return ""
}
2020-01-18 13:40:43 +09: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 03:56:50 +09:00
return fmt . Sprintf ( "%s (#%d)" , pr . Issue . Title , pr . Issue . Index )
}
2018-01-19 15:18:51 +09: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 16:36:47 +09:00
// IsChecking returns true if this pull request is still checking conflict.
func ( pr * PullRequest ) IsChecking ( ) bool {
2016-11-08 00:37:32 +09:00
return pr . Status == PullRequestStatusChecking
2015-10-24 16:36:47 +09:00
}
2015-10-19 08:30:39 +09:00
// CanAutoMerge returns true if this pull request can be merged automatically.
func ( pr * PullRequest ) CanAutoMerge ( ) bool {
2016-11-08 00:37:32 +09:00
return pr . Status == PullRequestStatusMergeable
2015-10-19 08:30:39 +09:00
}
2021-03-04 12:41:23 +09:00
// IsEmpty returns true if this pull request is empty.
func ( pr * PullRequest ) IsEmpty ( ) bool {
return pr . Status == PullRequestStatusEmpty
}
2018-01-06 03:56:50 +09: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 19:27:08 +09:00
// MergeStyleRebaseMerge rebase before merging with merge commit (--no-ff)
MergeStyleRebaseMerge MergeStyle = "rebase-merge"
2018-01-06 03:56:50 +09:00
// MergeStyleSquash squash commits into single commit before merging
MergeStyleSquash MergeStyle = "squash"
2021-03-04 12:41:23 +09:00
// MergeStyleManuallyMerged pr has been merged manually, just mark it as merged directly
MergeStyleManuallyMerged MergeStyle = "manually-merged"
2018-01-06 03:56:50 +09:00
)
2019-06-23 02:35:34 +09:00
// SetMerged sets a pull request to merged and closes the corresponding issue
2020-02-10 08:09:31 +09:00
func ( pr * PullRequest ) SetMerged ( ) ( bool , error ) {
2017-02-05 22:07:44 +09:00
if pr . HasMerged {
2020-02-10 08:09:31 +09:00
return false , fmt . Errorf ( "PullRequest[%d] already merged" , pr . Index )
2017-02-05 22:07:44 +09:00
}
2017-12-11 13:37:04 +09:00
if pr . MergedCommitID == "" || pr . MergedUnix == 0 || pr . Merger == nil {
2020-02-10 08:09:31 +09:00
return false , fmt . Errorf ( "Unable to merge PullRequest[%d], some required fields are empty" , pr . Index )
2017-02-05 22:07:44 +09:00
}
pr . HasMerged = true
sess := x . NewSession ( )
2017-06-21 09:57:05 +09:00
defer sess . Close ( )
2020-02-10 08:09:31 +09:00
if err := sess . Begin ( ) ; err != nil {
return false , err
2017-02-05 22:07:44 +09:00
}
2020-02-10 08:09:31 +09:00
if _ , err := sess . Exec ( "UPDATE `issue` SET `repo_id` = `repo_id` WHERE `id` = ?" , pr . IssueID ) ; err != nil {
return false , err
2017-02-05 22:07:44 +09:00
}
2020-02-10 08:09:31 +09: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 09:42:55 +09:00
}
2020-02-10 08:09:31 +09:00
pr . Issue = nil
if err := pr . loadIssue ( sess ) ; err != nil {
return false , err
2017-02-05 22:07:44 +09:00
}
2020-02-10 08:09:31 +09: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 22:07:44 +09:00
}
2020-02-10 08:09:31 +09:00
if err := pr . Issue . loadRepo ( sess ) ; err != nil {
return false , err
2017-02-05 22:07:44 +09:00
}
2020-02-10 08:09:31 +09:00
if err := pr . Issue . Repo . getOwner ( sess ) ; err != nil {
return false , err
2017-02-05 22:07:44 +09:00
}
2020-02-10 08:09:31 +09:00
2020-04-14 10:06:23 +09:00
if _ , err := pr . Issue . changeStatus ( sess , pr . Merger , true , true ) ; err != nil {
2020-02-10 08:09:31 +09:00
return false , fmt . Errorf ( "Issue.changeStatus: %v" , err )
}
2021-04-10 17:27:29 +09: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 08:09:31 +09: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 22:07:44 +09:00
}
2015-10-19 08:30:39 +09:00
// NewPullRequest creates new pull request with labels for repository.
2021-06-14 11:22:55 +09:00
func NewPullRequest ( repo * Repository , issue * Issue , labelIDs [ ] int64 , uuids [ ] string , pr * PullRequest ) ( err error ) {
idx , err := GetNextResourceIndex ( "issue_index" , repo . ID )
if err != nil {
return fmt . Errorf ( "generate issue index failed: %v" , err )
2019-10-03 07:28:30 +09:00
}
2021-06-14 11:22:55 +09:00
issue . Index = idx
2015-10-19 08:30:39 +09:00
sess := x . NewSession ( )
2017-06-21 09:57:05 +09:00
defer sess . Close ( )
2015-10-19 08:30:39 +09:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2021-06-14 11:22:55 +09:00
if err = newIssue ( sess , issue . Poster , NewIssueOptions {
2016-08-16 10:40:32 +09:00
Repo : repo ,
2021-06-14 11:22:55 +09:00
Issue : issue ,
2017-03-01 10:08:45 +09:00
LabelIDs : labelIDs ,
2016-08-16 10:40:32 +09:00
Attachments : uuids ,
IsPull : true ,
} ) ; err != nil {
2019-10-03 07:28:30 +09:00
if IsErrUserDoesNotHaveAccessToRepo ( err ) || IsErrNewIssueInsert ( err ) {
2018-05-10 01:29:04 +09:00
return err
}
2015-10-19 08:30:39 +09:00
return fmt . Errorf ( "newIssue: %v" , err )
}
2021-06-14 11:22:55 +09:00
pr . Index = issue . Index
2015-10-24 16:36:47 +09:00
pr . BaseRepo = repo
2021-06-14 11:22:55 +09:00
pr . IssueID = issue . ID
2015-10-19 08:30:39 +09:00
if _ , err = sess . Insert ( pr ) ; err != nil {
return fmt . Errorf ( "insert pull repo: %v" , err )
}
2016-07-16 01:36:39 +09:00
if err = sess . Commit ( ) ; err != nil {
return fmt . Errorf ( "Commit: %v" , err )
}
return nil
2015-10-19 08:30:39 +09:00
}
2017-01-05 09:50:34 +09:00
// GetUnmergedPullRequest returns a pull request that is open and has not been merged
2015-10-19 08:30:39 +09:00
// by given head/base and repo/branch.
2021-07-28 18:42:56 +09:00
func GetUnmergedPullRequest ( headRepoID , baseRepoID int64 , headBranch , baseBranch string , flow PullRequestFlow ) ( * PullRequest , error ) {
2015-10-19 08:30:39 +09:00
pr := new ( PullRequest )
2016-11-11 00:16:32 +09:00
has , err := x .
2021-07-28 18:42:56 +09:00
Where ( "head_repo_id=? AND head_branch=? AND base_repo_id=? AND base_branch=? AND has_merged=? AND flow = ? AND issue.is_closed=?" ,
headRepoID , headBranch , baseRepoID , baseBranch , false , flow , false ) .
2016-11-11 00:16:32 +09:00
Join ( "INNER" , "issue" , "issue.id=pull_request.issue_id" ) .
Get ( pr )
2015-10-19 08:30:39 +09: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 23:15:30 +09: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 .
2021-07-28 18:42:56 +09:00
Where ( "head_repo_id = ? AND head_branch = ? AND flow = ?" , repoID , branch , PullRequestFlowGithub ) .
2019-06-27 23:15:30 +09:00
OrderBy ( "id DESC" ) .
Get ( pr )
if ! has {
return nil , err
}
return pr , err
}
2016-12-02 20:10:39 +09:00
// GetPullRequestByIndex returns a pull request by the given index
2021-03-15 03:52:12 +09:00
func GetPullRequestByIndex ( repoID , index int64 ) ( * PullRequest , error ) {
2016-12-02 20:10:39 +09:00
pr := & PullRequest {
BaseRepoID : repoID ,
Index : index ,
}
has , err := x . Get ( pr )
if err != nil {
return nil , err
} else if ! has {
2017-01-02 03:15:09 +09:00
return nil , ErrPullRequestNotExist { 0 , 0 , 0 , repoID , "" , "" }
2016-12-02 20:10:39 +09:00
}
2016-12-05 20:17:39 +09:00
if err = pr . LoadAttributes ( ) ; err != nil {
return nil , err
}
if err = pr . LoadIssue ( ) ; err != nil {
return nil , err
}
2016-12-02 20:10:39 +09:00
return pr , nil
}
2016-08-14 19:32:24 +09:00
func getPullRequestByID ( e Engine , id int64 ) ( * PullRequest , error ) {
2015-10-24 16:36:47 +09:00
pr := new ( PullRequest )
2017-10-05 13:43:04 +09:00
has , err := e . ID ( id ) . Get ( pr )
2015-10-24 16:36:47 +09:00
if err != nil {
return nil , err
} else if ! has {
return nil , ErrPullRequestNotExist { id , 0 , 0 , 0 , "" , "" }
}
2016-08-14 19:32:24 +09:00
return pr , pr . loadAttributes ( e )
2015-10-24 16:36:47 +09:00
}
2016-08-14 19:32:24 +09:00
// GetPullRequestByID returns a pull request by given ID.
func GetPullRequestByID ( id int64 ) ( * PullRequest , error ) {
return getPullRequestByID ( x , id )
}
2020-01-24 02:28:15 +09: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 19:32:24 +09:00
func getPullRequestByIssueID ( e Engine , issueID int64 ) ( * PullRequest , error ) {
2015-10-23 03:47:24 +09:00
pr := & PullRequest {
IssueID : issueID ,
}
2016-08-14 19:32:24 +09:00
has , err := e . Get ( pr )
2015-10-19 08:30:39 +09:00
if err != nil {
return nil , err
} else if ! has {
2015-10-23 03:47:24 +09:00
return nil , ErrPullRequestNotExist { 0 , issueID , 0 , 0 , "" , "" }
2015-10-19 08:30:39 +09:00
}
2016-08-14 19:32:24 +09:00
return pr , pr . loadAttributes ( e )
}
2021-07-28 18:42:56 +09:00
// GetAllUnmergedAgitPullRequestByPoster get all unmerged agit flow pull request
// By poster id.
func GetAllUnmergedAgitPullRequestByPoster ( uid int64 ) ( [ ] * PullRequest , error ) {
pulls := make ( [ ] * PullRequest , 0 , 10 )
err := x .
Where ( "has_merged=? AND flow = ? AND issue.is_closed=? AND issue.poster_id=?" ,
false , PullRequestFlowAGit , false , uid ) .
Join ( "INNER" , "issue" , "issue.id=pull_request.issue_id" ) .
Find ( & pulls )
return pulls , err
}
2016-08-14 19:32:24 +09:00
// GetPullRequestByIssueID returns pull request by given issue ID.
func GetPullRequestByIssueID ( issueID int64 ) ( * PullRequest , error ) {
return getPullRequestByIssueID ( x , issueID )
2015-10-19 08:30:39 +09:00
}
2015-10-24 16:36:47 +09:00
// Update updates all fields of pull request.
func ( pr * PullRequest ) Update ( ) error {
2017-10-05 13:43:04 +09:00
_ , err := x . ID ( pr . ID ) . AllCols ( ) . Update ( pr )
2015-10-24 16:36:47 +09:00
return err
}
2016-11-29 00:31:06 +09:00
// UpdateCols updates specific fields of pull request.
2015-10-24 16:36:47 +09:00
func ( pr * PullRequest ) UpdateCols ( cols ... string ) error {
2017-10-05 13:43:04 +09:00
_ , err := x . ID ( pr . ID ) . Cols ( cols ... ) . Update ( pr )
2015-10-24 16:36:47 +09:00
return err
2020-02-10 08:09:31 +09: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 16:36:47 +09:00
}
2018-08-14 04:04:39 +09: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 16:48:31 +09:00
log . Error ( "LoadIssue: %v" , err )
2018-08-14 04:04:39 +09:00
return false
}
2021-06-23 13:14:22 +09:00
return HasWorkInProgressPrefix ( pr . Issue . Title )
}
2018-08-14 04:04:39 +09:00
2021-06-23 13:14:22 +09:00
// HasWorkInProgressPrefix determines if the given PR title has a Work In Progress prefix
func HasWorkInProgressPrefix ( title string ) bool {
2018-08-14 04:04:39 +09:00
for _ , prefix := range setting . Repository . PullRequest . WorkInProgressPrefixes {
2021-06-23 13:14:22 +09:00
if strings . HasPrefix ( strings . ToUpper ( title ) , prefix ) {
2018-08-14 04:04:39 +09:00
return true
}
}
return false
}
2019-02-05 20:54:49 +09: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 04:04:39 +09: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 16:48:31 +09:00
log . Error ( "LoadIssue: %v" , err )
2018-08-14 04:04:39 +09: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 15:20:25 +09:00
2020-04-14 22:53:34 +09: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 15:03:40 +09: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 11:45:49 +09: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 {
2021-07-28 18:42:56 +09:00
if pr . Flow == PullRequestFlowAGit {
return ""
}
2021-02-18 11:45:49 +09:00
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 )
}