2014-03-21 04:04:56 +08: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 models
2014-03-23 01:50:50 +08:00
import (
2015-08-10 14:42:50 +08:00
"fmt"
2017-03-03 22:35:42 +08:00
"path"
2018-01-03 16:34:13 +08:00
"regexp"
2017-01-30 20:46:45 +08:00
"sort"
2014-03-23 01:50:50 +08:00
"strings"
2014-05-08 04:51:14 +08:00
2016-11-11 00:24:48 +08:00
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
2017-01-25 10:43:02 +08:00
"code.gitea.io/gitea/modules/util"
2017-12-26 07:25:16 +08:00
api "code.gitea.io/sdk/gitea"
"github.com/Unknwon/com"
"github.com/go-xorm/builder"
"github.com/go-xorm/xorm"
2014-03-23 01:50:50 +08:00
)
// Issue represents an issue or pull request of repository.
2014-03-21 04:04:56 +08:00
type Issue struct {
2016-08-14 18:32:24 +08:00
ID int64 ` xorm:"pk autoincr" `
RepoID int64 ` xorm:"INDEX UNIQUE(repo_index)" `
2014-03-29 22:24:42 +08:00
Repo * Repository ` xorm:"-" `
2016-08-17 01:19:09 +08:00
Index int64 ` xorm:"UNIQUE(repo_index)" ` // Index in one repository.
2017-01-06 23:14:33 +08:00
PosterID int64 ` xorm:"INDEX" `
Poster * User ` xorm:"-" `
Title string ` xorm:"name" `
Content string ` xorm:"TEXT" `
RenderedContent string ` xorm:"-" `
Labels [ ] * Label ` xorm:"-" `
MilestoneID int64 ` xorm:"INDEX" `
Milestone * Milestone ` xorm:"-" `
2016-08-17 01:19:09 +08:00
Priority int
2018-05-10 00:29:04 +08:00
AssigneeID int64 ` xorm:"-" `
2017-01-06 23:14:33 +08:00
Assignee * User ` xorm:"-" `
IsClosed bool ` xorm:"INDEX" `
2016-08-17 01:19:09 +08:00
IsRead bool ` xorm:"-" `
2017-01-06 23:14:33 +08:00
IsPull bool ` xorm:"INDEX" ` // Indicates whether is a pull request or not.
2016-08-17 01:19:09 +08:00
PullRequest * PullRequest ` xorm:"-" `
2014-03-29 22:24:42 +08:00
NumComments int
2017-08-24 20:30:27 +08:00
Ref string
2016-03-10 08:53:30 +08:00
2017-12-11 12:37:04 +08:00
DeadlineUnix util . TimeStamp ` xorm:"INDEX" `
2018-05-02 03:05:28 +08:00
CreatedUnix util . TimeStamp ` xorm:"INDEX created" `
UpdatedUnix util . TimeStamp ` xorm:"INDEX updated" `
ClosedUnix util . TimeStamp ` xorm:"INDEX" `
2015-08-12 17:04:23 +08:00
2018-04-29 13:58:47 +08:00
Attachments [ ] * Attachment ` xorm:"-" `
Comments [ ] * Comment ` xorm:"-" `
Reactions ReactionList ` xorm:"-" `
TotalTrackedTime int64 ` xorm:"-" `
2018-05-10 00:29:04 +08:00
Assignees [ ] * User ` xorm:"-" `
2015-08-12 17:04:23 +08:00
}
2018-01-03 16:34:13 +08:00
var (
issueTasksPat * regexp . Regexp
issueTasksDonePat * regexp . Regexp
)
2018-01-04 03:45:21 +08:00
const issueTasksRegexpStr = ` (^\s*[-*]\s\[[\sx]\]\s.)|(\n\s*[-*]\s\[[\sx]\]\s.) `
const issueTasksDoneRegexpStr = ` (^\s*[-*]\s\[[x]\]\s.)|(\n\s*[-*]\s\[[x]\]\s.) `
2018-01-03 16:34:13 +08:00
func init ( ) {
issueTasksPat = regexp . MustCompile ( issueTasksRegexpStr )
issueTasksDonePat = regexp . MustCompile ( issueTasksDoneRegexpStr )
}
2018-04-29 13:58:47 +08:00
func ( issue * Issue ) loadTotalTimes ( e Engine ) ( err error ) {
opts := FindTrackedTimesOptions { IssueID : issue . ID }
issue . TotalTrackedTime , err = opts . ToSession ( e ) . SumInt ( & TrackedTime { } , "time" )
if err != nil {
return err
}
return nil
}
2018-05-02 03:05:28 +08:00
// IsOverdue checks if the issue is overdue
func ( issue * Issue ) IsOverdue ( ) bool {
return util . TimeStampNow ( ) >= issue . DeadlineUnix
}
2016-12-17 19:49:17 +08:00
func ( issue * Issue ) loadRepo ( e Engine ) ( err error ) {
2016-08-27 04:40:53 +08:00
if issue . Repo == nil {
issue . Repo , err = getRepositoryByID ( e , issue . RepoID )
2016-03-14 11:20:22 +08:00
if err != nil {
2016-08-27 04:40:53 +08:00
return fmt . Errorf ( "getRepositoryByID [%d]: %v" , issue . RepoID , err )
2016-03-14 11:20:22 +08:00
}
2016-08-27 04:40:53 +08:00
}
2016-12-17 19:49:17 +08:00
return nil
}
2018-04-29 13:58:47 +08:00
// IsTimetrackerEnabled returns true if the repo enables timetracking
func ( issue * Issue ) IsTimetrackerEnabled ( ) bool {
if err := issue . loadRepo ( x ) ; err != nil {
log . Error ( 4 , fmt . Sprintf ( "loadRepo: %v" , err ) )
return false
}
return issue . Repo . IsTimetrackerEnabled ( )
}
2017-01-29 00:01:07 +08:00
// GetPullRequest returns the issue pull request
func ( issue * Issue ) GetPullRequest ( ) ( pr * PullRequest , err error ) {
if ! issue . IsPull {
return nil , fmt . Errorf ( "Issue is not a pull request" )
}
pr , err = getPullRequestByIssueID ( x , issue . ID )
return
}
2017-01-30 20:46:45 +08:00
func ( issue * Issue ) loadLabels ( e Engine ) ( err error ) {
if issue . Labels == nil {
issue . Labels , err = getLabelsByIssueID ( e , issue . ID )
if err != nil {
return fmt . Errorf ( "getLabelsByIssueID [%d]: %v" , issue . ID , err )
}
2016-12-17 19:49:17 +08:00
}
2017-01-30 20:46:45 +08:00
return nil
}
2016-03-14 11:20:22 +08:00
2017-01-30 20:46:45 +08:00
func ( issue * Issue ) loadPoster ( e Engine ) ( err error ) {
2016-08-27 04:40:53 +08:00
if issue . Poster == nil {
issue . Poster , err = getUserByID ( e , issue . PosterID )
2016-03-14 11:20:22 +08:00
if err != nil {
2016-09-20 17:54:47 +08:00
issue . PosterID = - 1
issue . Poster = NewGhostUser ( )
2016-11-05 02:47:54 +08:00
if ! IsErrUserNotExist ( err ) {
2016-08-27 04:40:53 +08:00
return fmt . Errorf ( "getUserByID.(poster) [%d]: %v" , issue . PosterID , err )
2016-03-14 11:20:22 +08:00
}
2016-11-09 13:07:01 +08:00
err = nil
2016-03-14 11:20:22 +08:00
return
}
2016-08-27 04:40:53 +08:00
}
2017-01-30 20:46:45 +08:00
return
}
2016-03-14 11:20:22 +08:00
2017-07-26 15:16:45 +08:00
func ( issue * Issue ) loadPullRequest ( e Engine ) ( err error ) {
if issue . IsPull && issue . PullRequest == nil {
issue . PullRequest , err = getPullRequestByIssueID ( e , issue . ID )
if err != nil {
if IsErrPullRequestNotExist ( err ) {
return err
}
return fmt . Errorf ( "getPullRequestByIssueID [%d]: %v" , issue . ID , err )
}
}
return nil
}
2017-09-17 04:16:21 +08:00
func ( issue * Issue ) loadComments ( e Engine ) ( err error ) {
if issue . Comments != nil {
return nil
}
issue . Comments , err = findComments ( e , FindCommentsOptions {
IssueID : issue . ID ,
Type : CommentTypeUnknown ,
} )
return err
}
2017-12-04 07:14:26 +08:00
func ( issue * Issue ) loadReactions ( e Engine ) ( err error ) {
if issue . Reactions != nil {
return nil
}
reactions , err := findReactions ( e , FindReactionsOptions {
IssueID : issue . ID ,
} )
if err != nil {
return err
}
// Load reaction user data
if _ , err := ReactionList ( reactions ) . LoadUsers ( ) ; err != nil {
return err
}
// Cache comments to map
comments := make ( map [ int64 ] * Comment )
for _ , comment := range issue . Comments {
comments [ comment . ID ] = comment
}
// Add reactions either to issue or comment
for _ , react := range reactions {
if react . CommentID == 0 {
issue . Reactions = append ( issue . Reactions , react )
} else if comment , ok := comments [ react . CommentID ] ; ok {
comment . Reactions = append ( comment . Reactions , react )
}
}
return nil
}
2017-01-30 20:46:45 +08:00
func ( issue * Issue ) loadAttributes ( e Engine ) ( err error ) {
if err = issue . loadRepo ( e ) ; err != nil {
return
}
if err = issue . loadPoster ( e ) ; err != nil {
return
}
if err = issue . loadLabels ( e ) ; err != nil {
return
2016-08-27 04:40:53 +08:00
}
2015-08-10 21:47:23 +08:00
2016-08-27 04:40:53 +08:00
if issue . Milestone == nil && issue . MilestoneID > 0 {
issue . Milestone , err = getMilestoneByRepoID ( e , issue . RepoID , issue . MilestoneID )
2017-08-12 10:15:30 +08:00
if err != nil && ! IsErrMilestoneNotExist ( err ) {
2016-08-27 04:40:53 +08:00
return fmt . Errorf ( "getMilestoneByRepoID [repo_id: %d, milestone_id: %d]: %v" , issue . RepoID , issue . MilestoneID , err )
2015-08-10 21:47:23 +08:00
}
2015-08-05 20:23:08 +08:00
}
2018-05-10 00:29:04 +08:00
if err = issue . loadAssignees ( e ) ; err != nil {
2017-06-23 21:43:37 +08:00
return
2016-08-14 18:32:24 +08:00
}
2017-07-26 15:16:45 +08:00
if err = issue . loadPullRequest ( e ) ; err != nil && ! IsErrPullRequestNotExist ( err ) {
2016-08-14 18:32:24 +08:00
// It is possible pull request is not yet created.
2017-07-26 15:16:45 +08:00
return err
2016-08-14 18:32:24 +08:00
}
2016-08-27 04:40:53 +08:00
if issue . Attachments == nil {
issue . Attachments , err = getAttachmentsByIssueID ( e , issue . ID )
if err != nil {
return fmt . Errorf ( "getAttachmentsByIssueID [%d]: %v" , issue . ID , err )
}
}
2017-09-17 04:16:21 +08:00
if err = issue . loadComments ( e ) ; err != nil {
2017-12-04 07:14:26 +08:00
return err
2016-08-27 04:40:53 +08:00
}
2018-04-29 13:58:47 +08:00
if issue . IsTimetrackerEnabled ( ) {
if err = issue . loadTotalTimes ( e ) ; err != nil {
return err
}
}
2016-08-27 04:40:53 +08:00
2017-12-04 07:14:26 +08:00
return issue . loadReactions ( e )
2016-08-14 18:32:24 +08:00
}
2016-11-24 16:41:11 +08:00
// LoadAttributes loads the attribute of this issue.
2016-08-14 18:32:24 +08:00
func ( issue * Issue ) LoadAttributes ( ) error {
return issue . loadAttributes ( x )
2015-08-20 00:12:43 +08:00
}
2017-02-03 15:22:39 +08:00
// GetIsRead load the `IsRead` field of the issue
func ( issue * Issue ) GetIsRead ( userID int64 ) error {
issueUser := & IssueUser { IssueID : issue . ID , UID : userID }
if has , err := x . Get ( issueUser ) ; err != nil {
return err
} else if ! has {
2017-02-09 11:47:24 +08:00
issue . IsRead = false
return nil
2017-02-03 15:22:39 +08:00
}
issue . IsRead = issueUser . IsRead
return nil
}
2017-03-03 22:35:42 +08:00
// APIURL returns the absolute APIURL to this issue.
func ( issue * Issue ) APIURL ( ) string {
2018-01-04 09:41:33 +08:00
return issue . Repo . APIURL ( ) + "/" + path . Join ( "issues" , fmt . Sprint ( issue . Index ) )
2017-03-03 22:35:42 +08:00
}
2016-11-24 16:41:11 +08:00
// HTMLURL returns the absolute URL to this issue.
2016-08-17 01:19:09 +08:00
func ( issue * Issue ) HTMLURL ( ) string {
var path string
if issue . IsPull {
path = "pulls"
} else {
path = "issues"
}
return fmt . Sprintf ( "%s/%s/%d" , issue . Repo . HTMLURL ( ) , path , issue . Index )
}
2016-12-02 19:10:39 +08:00
// DiffURL returns the absolute URL to this diff
func ( issue * Issue ) DiffURL ( ) string {
if issue . IsPull {
return fmt . Sprintf ( "%s/pulls/%d.diff" , issue . Repo . HTMLURL ( ) , issue . Index )
}
return ""
}
// PatchURL returns the absolute URL to this patch
func ( issue * Issue ) PatchURL ( ) string {
if issue . IsPull {
return fmt . Sprintf ( "%s/pulls/%d.patch" , issue . Repo . HTMLURL ( ) , issue . Index )
}
return ""
}
2016-03-14 11:20:22 +08:00
// State returns string representation of issue status.
2016-11-22 19:24:39 +08:00
func ( issue * Issue ) State ( ) api . StateType {
if issue . IsClosed {
2016-11-29 16:25:47 +08:00
return api . StateClosed
2016-03-14 11:20:22 +08:00
}
2016-11-29 16:25:47 +08:00
return api . StateOpen
2016-08-14 18:32:24 +08:00
}
2016-11-22 19:24:39 +08:00
// APIFormat assumes some fields assigned with values:
2016-08-14 18:32:24 +08:00
// Required - Poster, Labels,
// Optional - Milestone, Assignee, PullRequest
func ( issue * Issue ) APIFormat ( ) * api . Issue {
apiLabels := make ( [ ] * api . Label , len ( issue . Labels ) )
for i := range issue . Labels {
apiLabels [ i ] = issue . Labels [ i ] . APIFormat ( )
}
apiIssue := & api . Issue {
ID : issue . ID ,
2017-03-03 22:35:42 +08:00
URL : issue . APIURL ( ) ,
2016-08-14 18:32:24 +08:00
Index : issue . Index ,
2016-08-17 01:19:09 +08:00
Poster : issue . Poster . APIFormat ( ) ,
2016-08-14 18:32:24 +08:00
Title : issue . Title ,
Body : issue . Content ,
Labels : apiLabels ,
2016-08-17 01:19:09 +08:00
State : issue . State ( ) ,
2016-08-14 18:32:24 +08:00
Comments : issue . NumComments ,
2017-12-11 12:37:04 +08:00
Created : issue . CreatedUnix . AsTime ( ) ,
Updated : issue . UpdatedUnix . AsTime ( ) ,
2016-08-14 18:32:24 +08:00
}
if issue . Milestone != nil {
apiIssue . Milestone = issue . Milestone . APIFormat ( )
}
2018-05-10 00:29:04 +08:00
if len ( issue . Assignees ) > 0 {
for _ , assignee := range issue . Assignees {
apiIssue . Assignees = append ( apiIssue . Assignees , assignee . APIFormat ( ) )
}
apiIssue . Assignee = issue . Assignees [ 0 ] . APIFormat ( ) // For compatibility, we're keeping the first assignee as `apiIssue.Assignee`
2016-08-14 18:32:24 +08:00
}
if issue . IsPull {
apiIssue . PullRequest = & api . PullRequestMeta {
HasMerged : issue . PullRequest . HasMerged ,
}
if issue . PullRequest . HasMerged {
2017-12-11 12:37:04 +08:00
apiIssue . PullRequest . Merged = issue . PullRequest . MergedUnix . AsTimePtr ( )
2016-08-14 18:32:24 +08:00
}
}
2018-05-02 03:05:28 +08:00
if issue . DeadlineUnix != 0 {
apiIssue . Deadline = issue . DeadlineUnix . AsTimePtr ( )
}
2016-08-14 18:32:24 +08:00
return apiIssue
}
// HashTag returns unique hash tag for issue.
2016-11-22 19:24:39 +08:00
func ( issue * Issue ) HashTag ( ) string {
return "issue-" + com . ToStr ( issue . ID )
2016-03-14 11:20:22 +08:00
}
2015-08-13 16:07:11 +08:00
// IsPoster returns true if given user by ID is the poster.
2016-11-22 19:24:39 +08:00
func ( issue * Issue ) IsPoster ( uid int64 ) bool {
return issue . PosterID == uid
2015-08-13 16:07:11 +08:00
}
2016-11-22 19:24:39 +08:00
func ( issue * Issue ) hasLabel ( e Engine , labelID int64 ) bool {
return hasIssueLabel ( e , issue . ID , labelID )
2015-08-10 14:42:50 +08:00
}
// HasLabel returns true if issue has been labeled by given ID.
2016-11-22 19:24:39 +08:00
func ( issue * Issue ) HasLabel ( labelID int64 ) bool {
return issue . hasLabel ( x , labelID )
2015-08-10 14:42:50 +08:00
}
2016-08-14 18:32:24 +08:00
func ( issue * Issue ) sendLabelUpdatedWebhook ( doer * User ) {
var err error
2018-05-21 10:28:29 +08:00
if err = issue . loadRepo ( x ) ; err != nil {
log . Error ( 4 , "loadRepo: %v" , err )
return
}
if err = issue . loadPoster ( x ) ; err != nil {
log . Error ( 4 , "loadPoster: %v" , err )
return
}
mode , _ := AccessLevel ( issue . Poster . ID , issue . Repo )
2016-08-14 18:32:24 +08:00
if issue . IsPull {
2017-07-26 15:16:45 +08:00
if err = issue . loadPullRequest ( x ) ; err != nil {
log . Error ( 4 , "loadPullRequest: %v" , err )
return
}
if err = issue . PullRequest . LoadIssue ( ) ; err != nil {
2016-08-25 03:01:30 +08:00
log . Error ( 4 , "LoadIssue: %v" , err )
return
}
2016-11-07 23:37:32 +08:00
err = PrepareWebhooks ( issue . Repo , HookEventPullRequest , & api . PullRequestPayload {
Action : api . HookIssueLabelUpdated ,
2016-08-14 18:32:24 +08:00
Index : issue . Index ,
PullRequest : issue . PullRequest . APIFormat ( ) ,
2016-12-06 07:48:51 +08:00
Repository : issue . Repo . APIFormat ( AccessModeNone ) ,
2016-08-14 18:32:24 +08:00
Sender : doer . APIFormat ( ) ,
} )
2018-05-21 10:28:29 +08:00
} else {
err = PrepareWebhooks ( issue . Repo , HookEventIssues , & api . IssuePayload {
Action : api . HookIssueLabelUpdated ,
Index : issue . Index ,
Issue : issue . APIFormat ( ) ,
Repository : issue . Repo . APIFormat ( mode ) ,
Sender : doer . APIFormat ( ) ,
} )
2016-08-14 18:32:24 +08:00
}
if err != nil {
log . Error ( 4 , "PrepareWebhooks [is_pull: %v]: %v" , issue . IsPull , err )
} else {
go HookQueue . Add ( issue . RepoID )
}
}
2017-01-30 20:46:45 +08:00
func ( issue * Issue ) addLabel ( e * xorm . Session , label * Label , doer * User ) error {
return newIssueLabel ( e , issue , label , doer )
2015-08-10 14:42:50 +08:00
}
2016-08-04 02:51:22 +08:00
// AddLabel adds a new label to the issue.
2016-08-14 18:32:24 +08:00
func ( issue * Issue ) AddLabel ( doer * User , label * Label ) error {
2017-01-30 20:46:45 +08:00
if err := NewIssueLabel ( issue , label , doer ) ; err != nil {
2015-08-15 00:42:43 +08:00
return err
}
2016-08-14 18:32:24 +08:00
issue . sendLabelUpdatedWebhook ( doer )
return nil
2015-08-10 14:42:50 +08:00
}
2017-01-30 20:46:45 +08:00
func ( issue * Issue ) addLabels ( e * xorm . Session , labels [ ] * Label , doer * User ) error {
return newIssueLabels ( e , issue , labels , doer )
2016-08-04 02:51:22 +08:00
}
// AddLabels adds a list of new labels to the issue.
2016-08-14 18:32:24 +08:00
func ( issue * Issue ) AddLabels ( doer * User , labels [ ] * Label ) error {
2017-01-30 20:46:45 +08:00
if err := NewIssueLabels ( issue , labels , doer ) ; err != nil {
2016-08-14 18:32:24 +08:00
return err
}
issue . sendLabelUpdatedWebhook ( doer )
return nil
2016-08-04 02:51:22 +08:00
}
func ( issue * Issue ) getLabels ( e Engine ) ( err error ) {
if len ( issue . Labels ) > 0 {
2014-05-24 14:31:58 +08:00
return nil
}
2016-08-04 02:51:22 +08:00
issue . Labels , err = getLabelsByIssueID ( e , issue . ID )
2015-08-10 14:42:50 +08:00
if err != nil {
return fmt . Errorf ( "getLabelsByIssueID: %v" , err )
2014-05-24 14:31:58 +08:00
}
return nil
}
2017-01-30 20:46:45 +08:00
func ( issue * Issue ) removeLabel ( e * xorm . Session , doer * User , label * Label ) error {
2017-02-01 09:31:35 +08:00
return deleteIssueLabel ( e , issue , label , doer )
2015-08-10 14:42:50 +08:00
}
// RemoveLabel removes a label from issue by given ID.
2016-08-14 18:32:24 +08:00
func ( issue * Issue ) RemoveLabel ( doer * User , label * Label ) error {
2016-12-17 19:49:17 +08:00
if err := issue . loadRepo ( x ) ; err != nil {
return err
}
2017-03-15 08:51:46 +08:00
if has , err := HasAccess ( doer . ID , issue . Repo , AccessModeWrite ) ; err != nil {
2016-12-17 19:49:17 +08:00
return err
} else if ! has {
return ErrLabelNotExist { }
}
2017-02-01 09:31:35 +08:00
if err := DeleteIssueLabel ( issue , label , doer ) ; err != nil {
2016-08-14 18:32:24 +08:00
return err
}
issue . sendLabelUpdatedWebhook ( doer )
return nil
2016-08-04 02:51:22 +08:00
}
2017-01-30 20:46:45 +08:00
func ( issue * Issue ) clearLabels ( e * xorm . Session , doer * User ) ( err error ) {
2016-08-04 02:51:22 +08:00
if err = issue . getLabels ( e ) ; err != nil {
return fmt . Errorf ( "getLabels: %v" , err )
}
for i := range issue . Labels {
2017-01-30 20:46:45 +08:00
if err = issue . removeLabel ( e , doer , issue . Labels [ i ] ) ; err != nil {
2016-08-04 02:51:22 +08:00
return fmt . Errorf ( "removeLabel: %v" , err )
}
}
return nil
}
2016-11-24 16:41:11 +08:00
// ClearLabels removes all issue labels as the given user.
// Triggers appropriate WebHooks, if any.
2016-08-14 18:32:24 +08:00
func ( issue * Issue ) ClearLabels ( doer * User ) ( err error ) {
2015-08-15 00:42:43 +08:00
sess := x . NewSession ( )
2017-06-21 08:57:05 +08:00
defer sess . Close ( )
2015-08-15 00:42:43 +08:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2016-12-17 19:49:17 +08:00
if err := issue . loadRepo ( sess ) ; err != nil {
return err
2017-07-26 15:16:45 +08:00
} else if err = issue . loadPullRequest ( sess ) ; err != nil {
return err
2016-12-17 19:49:17 +08:00
}
2017-03-15 08:51:46 +08:00
if has , err := hasAccess ( sess , doer . ID , issue . Repo , AccessModeWrite ) ; err != nil {
2016-12-17 19:49:17 +08:00
return err
} else if ! has {
return ErrLabelNotExist { }
}
2017-01-30 20:46:45 +08:00
if err = issue . clearLabels ( sess , doer ) ; err != nil {
2015-08-15 00:42:43 +08:00
return err
}
2016-08-14 18:32:24 +08:00
if err = sess . Commit ( ) ; err != nil {
return fmt . Errorf ( "Commit: %v" , err )
}
2018-05-21 10:28:29 +08:00
if err = issue . loadPoster ( x ) ; err != nil {
return fmt . Errorf ( "loadPoster: %v" , err )
}
mode , _ := AccessLevel ( issue . Poster . ID , issue . Repo )
2016-08-14 18:32:24 +08:00
if issue . IsPull {
2016-08-25 03:01:30 +08:00
err = issue . PullRequest . LoadIssue ( )
if err != nil {
log . Error ( 4 , "LoadIssue: %v" , err )
return
}
2016-11-07 23:37:32 +08:00
err = PrepareWebhooks ( issue . Repo , HookEventPullRequest , & api . PullRequestPayload {
Action : api . HookIssueLabelCleared ,
2016-08-14 18:32:24 +08:00
Index : issue . Index ,
PullRequest : issue . PullRequest . APIFormat ( ) ,
2018-05-21 10:28:29 +08:00
Repository : issue . Repo . APIFormat ( mode ) ,
2016-08-14 18:32:24 +08:00
Sender : doer . APIFormat ( ) ,
} )
2018-05-21 10:28:29 +08:00
} else {
err = PrepareWebhooks ( issue . Repo , HookEventIssues , & api . IssuePayload {
Action : api . HookIssueLabelCleared ,
Index : issue . Index ,
Issue : issue . APIFormat ( ) ,
Repository : issue . Repo . APIFormat ( mode ) ,
Sender : doer . APIFormat ( ) ,
} )
2016-08-14 18:32:24 +08:00
}
if err != nil {
log . Error ( 4 , "PrepareWebhooks [is_pull: %v]: %v" , issue . IsPull , err )
} else {
go HookQueue . Add ( issue . RepoID )
}
return nil
2015-08-15 00:42:43 +08:00
}
2017-01-30 20:46:45 +08:00
type labelSorter [ ] * Label
func ( ts labelSorter ) Len ( ) int {
return len ( [ ] * Label ( ts ) )
}
func ( ts labelSorter ) Less ( i , j int ) bool {
return [ ] * Label ( ts ) [ i ] . ID < [ ] * Label ( ts ) [ j ] . ID
}
func ( ts labelSorter ) Swap ( i , j int ) {
[ ] * Label ( ts ) [ i ] , [ ] * Label ( ts ) [ j ] = [ ] * Label ( ts ) [ j ] , [ ] * Label ( ts ) [ i ]
}
2016-08-04 02:51:22 +08:00
// ReplaceLabels removes all current labels and add new labels to the issue.
2016-11-24 16:41:11 +08:00
// Triggers appropriate WebHooks, if any.
2017-01-30 20:46:45 +08:00
func ( issue * Issue ) ReplaceLabels ( labels [ ] * Label , doer * User ) ( err error ) {
2015-08-15 00:42:43 +08:00
sess := x . NewSession ( )
2017-06-21 08:57:05 +08:00
defer sess . Close ( )
2015-08-15 00:42:43 +08:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2017-01-30 20:46:45 +08:00
if err = issue . loadLabels ( sess ) ; err != nil {
return err
}
sort . Sort ( labelSorter ( labels ) )
sort . Sort ( labelSorter ( issue . Labels ) )
var toAdd , toRemove [ ] * Label
2017-02-28 09:35:55 +08:00
addIndex , removeIndex := 0 , 0
for addIndex < len ( labels ) && removeIndex < len ( issue . Labels ) {
addLabel := labels [ addIndex ]
removeLabel := issue . Labels [ removeIndex ]
if addLabel . ID == removeLabel . ID {
addIndex ++
removeIndex ++
} else if addLabel . ID < removeLabel . ID {
toAdd = append ( toAdd , addLabel )
addIndex ++
} else {
toRemove = append ( toRemove , removeLabel )
removeIndex ++
2017-01-30 20:46:45 +08:00
}
}
2017-02-28 09:35:55 +08:00
toAdd = append ( toAdd , labels [ addIndex : ] ... )
toRemove = append ( toRemove , issue . Labels [ removeIndex : ] ... )
2017-01-30 20:46:45 +08:00
if len ( toAdd ) > 0 {
if err = issue . addLabels ( sess , toAdd , doer ) ; err != nil {
return fmt . Errorf ( "addLabels: %v" , err )
}
}
2017-02-28 09:35:55 +08:00
for _ , l := range toRemove {
if err = issue . removeLabel ( sess , doer , l ) ; err != nil {
return fmt . Errorf ( "removeLabel: %v" , err )
2017-01-30 20:46:45 +08:00
}
2015-08-15 00:42:43 +08:00
}
return sess . Commit ( )
2015-08-10 14:42:50 +08:00
}
2015-08-12 18:44:09 +08:00
// ReadBy sets issue to be read by given user.
2016-12-31 00:44:54 +08:00
func ( issue * Issue ) ReadBy ( userID int64 ) error {
if err := UpdateIssueUserByRead ( userID , issue . ID ) ; err != nil {
return err
}
2017-09-19 16:08:30 +08:00
return setNotificationStatusReadIfUnread ( x , userID , issue . ID )
2014-07-24 03:15:47 +08:00
}
2016-08-14 18:32:24 +08:00
func updateIssueCols ( e Engine , issue * Issue , cols ... string ) error {
2017-10-05 12:43:04 +08:00
if _ , err := e . ID ( issue . ID ) . Cols ( cols ... ) . Update ( issue ) ; err != nil {
2017-01-25 10:43:02 +08:00
return err
}
2017-12-17 19:53:02 +08:00
UpdateIssueIndexerCols ( issue . ID , cols ... )
2017-01-25 10:43:02 +08:00
return nil
2016-08-14 18:32:24 +08:00
}
// UpdateIssueCols only updates values of specific columns for given issue.
func UpdateIssueCols ( issue * Issue , cols ... string ) error {
return updateIssueCols ( x , issue , cols ... )
}
2016-11-22 19:24:39 +08:00
func ( issue * Issue ) changeStatus ( e * xorm . Session , doer * User , repo * Repository , isClosed bool ) ( err error ) {
2016-03-06 01:58:51 +08:00
// Nothing should be performed if current status is same as target status
2016-11-22 19:24:39 +08:00
if issue . IsClosed == isClosed {
2015-08-13 16:07:11 +08:00
return nil
}
2018-07-18 05:23:58 +08:00
// Check for open dependencies
if isClosed && issue . Repo . IsDependenciesEnabled ( ) {
// only check if dependencies are enabled and we're about to close an issue, otherwise reopening an issue would fail when there are unsatisfied dependencies
noDeps , err := IssueNoDependenciesLeft ( issue )
if err != nil {
return err
}
if ! noDeps {
return ErrDependenciesLeft { issue . ID }
}
}
2016-11-22 19:24:39 +08:00
issue . IsClosed = isClosed
2018-02-19 10:39:26 +08:00
if isClosed {
issue . ClosedUnix = util . TimeStampNow ( )
} else {
issue . ClosedUnix = 0
}
2015-08-13 16:07:11 +08:00
2018-02-19 10:39:26 +08:00
if err = updateIssueCols ( e , issue , "is_closed" , "closed_unix" ) ; err != nil {
2015-08-13 16:07:11 +08:00
return err
}
2016-03-06 01:58:51 +08:00
// Update issue count of labels
2016-11-22 19:24:39 +08:00
if err = issue . getLabels ( e ) ; err != nil {
2015-08-13 16:07:11 +08:00
return err
}
2016-11-22 19:24:39 +08:00
for idx := range issue . Labels {
if issue . IsClosed {
issue . Labels [ idx ] . NumClosedIssues ++
2015-08-13 16:07:11 +08:00
} else {
2016-11-22 19:24:39 +08:00
issue . Labels [ idx ] . NumClosedIssues --
2015-08-13 16:07:11 +08:00
}
2016-11-22 19:24:39 +08:00
if err = updateLabel ( e , issue . Labels [ idx ] ) ; err != nil {
2015-08-13 16:07:11 +08:00
return err
}
}
2016-03-06 01:58:51 +08:00
// Update issue count of milestone
2016-11-22 19:24:39 +08:00
if err = changeMilestoneIssueStats ( e , issue ) ; err != nil {
2015-08-13 16:07:11 +08:00
return err
}
2016-03-06 01:58:51 +08:00
// New action comment
2016-11-22 19:24:39 +08:00
if _ , err = createStatusComment ( e , doer , repo , issue ) ; err != nil {
2015-08-13 16:07:11 +08:00
return err
}
return nil
}
2016-03-06 01:58:51 +08:00
// ChangeStatus changes issue status to open or closed.
2016-08-14 18:32:24 +08:00
func ( issue * Issue ) ChangeStatus ( doer * User , repo * Repository , isClosed bool ) ( err error ) {
2015-08-13 16:07:11 +08:00
sess := x . NewSession ( )
2017-06-21 08:57:05 +08:00
defer sess . Close ( )
2015-08-13 16:07:11 +08:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2016-08-14 18:32:24 +08:00
if err = issue . changeStatus ( sess , doer , repo , isClosed ) ; err != nil {
2015-08-13 16:07:11 +08:00
return err
}
2016-08-14 18:32:24 +08:00
if err = sess . Commit ( ) ; err != nil {
return fmt . Errorf ( "Commit: %v" , err )
}
2018-05-21 10:28:29 +08:00
mode , _ := AccessLevel ( issue . Poster . ID , issue . Repo )
2016-08-14 18:32:24 +08:00
if issue . IsPull {
// Merge pull request calls issue.changeStatus so we need to handle separately.
issue . PullRequest . Issue = issue
apiPullRequest := & api . PullRequestPayload {
Index : issue . Index ,
PullRequest : issue . PullRequest . APIFormat ( ) ,
2018-05-21 10:28:29 +08:00
Repository : repo . APIFormat ( mode ) ,
2016-08-14 18:32:24 +08:00
Sender : doer . APIFormat ( ) ,
}
if isClosed {
2016-11-07 23:37:32 +08:00
apiPullRequest . Action = api . HookIssueClosed
2016-08-14 18:32:24 +08:00
} else {
2016-11-29 16:25:47 +08:00
apiPullRequest . Action = api . HookIssueReOpened
2016-08-14 18:32:24 +08:00
}
2016-11-07 23:37:32 +08:00
err = PrepareWebhooks ( repo , HookEventPullRequest , apiPullRequest )
2018-05-21 10:28:29 +08:00
} else {
apiIssue := & api . IssuePayload {
Index : issue . Index ,
Issue : issue . APIFormat ( ) ,
Repository : repo . APIFormat ( mode ) ,
Sender : doer . APIFormat ( ) ,
}
if isClosed {
apiIssue . Action = api . HookIssueClosed
} else {
apiIssue . Action = api . HookIssueReOpened
}
err = PrepareWebhooks ( repo , HookEventIssues , apiIssue )
2016-08-14 18:32:24 +08:00
}
if err != nil {
log . Error ( 4 , "PrepareWebhooks [is_pull: %v, is_closed: %v]: %v" , issue . IsPull , isClosed , err )
} else {
go HookQueue . Add ( repo . ID )
}
return nil
}
2016-11-24 16:41:11 +08:00
// ChangeTitle changes the title of this issue, as the given user.
2016-08-14 18:32:24 +08:00
func ( issue * Issue ) ChangeTitle ( doer * User , title string ) ( err error ) {
oldTitle := issue . Title
issue . Title = title
2017-02-05 22:36:00 +08:00
sess := x . NewSession ( )
defer sess . Close ( )
if err = sess . Begin ( ) ; err != nil {
return err
}
if err = updateIssueCols ( sess , issue , "name" ) ; err != nil {
return fmt . Errorf ( "updateIssueCols: %v" , err )
}
if _ , err = createChangeTitleComment ( sess , doer , issue . Repo , issue , oldTitle , title ) ; err != nil {
return fmt . Errorf ( "createChangeTitleComment: %v" , err )
}
if err = sess . Commit ( ) ; err != nil {
return err
2016-08-14 18:32:24 +08:00
}
2018-05-21 10:28:29 +08:00
mode , _ := AccessLevel ( issue . Poster . ID , issue . Repo )
2016-08-14 18:32:24 +08:00
if issue . IsPull {
issue . PullRequest . Issue = issue
2016-11-07 23:37:32 +08:00
err = PrepareWebhooks ( issue . Repo , HookEventPullRequest , & api . PullRequestPayload {
Action : api . HookIssueEdited ,
2016-08-14 18:32:24 +08:00
Index : issue . Index ,
Changes : & api . ChangesPayload {
Title : & api . ChangesFromPayload {
From : oldTitle ,
} ,
} ,
PullRequest : issue . PullRequest . APIFormat ( ) ,
2018-05-21 10:28:29 +08:00
Repository : issue . Repo . APIFormat ( mode ) ,
2016-08-14 18:32:24 +08:00
Sender : doer . APIFormat ( ) ,
} )
2018-05-21 10:28:29 +08:00
} else {
err = PrepareWebhooks ( issue . Repo , HookEventIssues , & api . IssuePayload {
Action : api . HookIssueEdited ,
Index : issue . Index ,
Changes : & api . ChangesPayload {
Title : & api . ChangesFromPayload {
From : oldTitle ,
} ,
} ,
Issue : issue . APIFormat ( ) ,
Repository : issue . Repo . APIFormat ( mode ) ,
Sender : issue . Poster . APIFormat ( ) ,
} )
2016-08-14 18:32:24 +08:00
}
2018-05-21 10:28:29 +08:00
2016-08-14 18:32:24 +08:00
if err != nil {
log . Error ( 4 , "PrepareWebhooks [is_pull: %v]: %v" , issue . IsPull , err )
} else {
go HookQueue . Add ( issue . RepoID )
}
return nil
2015-08-13 16:07:11 +08:00
}
2017-02-11 12:00:29 +08:00
// AddDeletePRBranchComment adds delete branch comment for pull request issue
func AddDeletePRBranchComment ( doer * User , repo * Repository , issueID int64 , branchName string ) error {
issue , err := getIssueByID ( x , issueID )
if err != nil {
return err
}
sess := x . NewSession ( )
defer sess . Close ( )
if err := sess . Begin ( ) ; err != nil {
return err
}
if _ , err := createDeleteBranchComment ( sess , doer , repo , issue , branchName ) ; err != nil {
return err
}
return sess . Commit ( )
}
2016-11-24 16:41:11 +08:00
// ChangeContent changes issue content, as the given user.
2016-08-14 18:32:24 +08:00
func ( issue * Issue ) ChangeContent ( doer * User , content string ) ( err error ) {
oldContent := issue . Content
issue . Content = content
2018-01-03 16:34:13 +08:00
2016-08-14 18:32:24 +08:00
if err = UpdateIssueCols ( issue , "content" ) ; err != nil {
return fmt . Errorf ( "UpdateIssueCols: %v" , err )
}
2018-05-21 10:28:29 +08:00
mode , _ := AccessLevel ( issue . Poster . ID , issue . Repo )
2016-08-14 18:32:24 +08:00
if issue . IsPull {
issue . PullRequest . Issue = issue
2016-11-07 23:37:32 +08:00
err = PrepareWebhooks ( issue . Repo , HookEventPullRequest , & api . PullRequestPayload {
Action : api . HookIssueEdited ,
2016-08-14 18:32:24 +08:00
Index : issue . Index ,
Changes : & api . ChangesPayload {
Body : & api . ChangesFromPayload {
From : oldContent ,
} ,
} ,
PullRequest : issue . PullRequest . APIFormat ( ) ,
2018-05-21 10:28:29 +08:00
Repository : issue . Repo . APIFormat ( mode ) ,
2016-08-14 18:32:24 +08:00
Sender : doer . APIFormat ( ) ,
} )
2018-05-21 10:28:29 +08:00
} else {
err = PrepareWebhooks ( issue . Repo , HookEventIssues , & api . IssuePayload {
Action : api . HookIssueEdited ,
Index : issue . Index ,
Changes : & api . ChangesPayload {
Body : & api . ChangesFromPayload {
From : oldContent ,
} ,
} ,
Issue : issue . APIFormat ( ) ,
Repository : issue . Repo . APIFormat ( mode ) ,
Sender : doer . APIFormat ( ) ,
} )
2016-08-14 18:32:24 +08:00
}
if err != nil {
log . Error ( 4 , "PrepareWebhooks [is_pull: %v]: %v" , issue . IsPull , err )
} else {
go HookQueue . Add ( issue . RepoID )
}
return nil
}
2018-01-03 16:34:13 +08:00
// GetTasks returns the amount of tasks in the issues content
func ( issue * Issue ) GetTasks ( ) int {
return len ( issueTasksPat . FindAllStringIndex ( issue . Content , - 1 ) )
}
// GetTasksDone returns the amount of completed tasks in the issues content
func ( issue * Issue ) GetTasksDone ( ) int {
return len ( issueTasksDonePat . FindAllStringIndex ( issue . Content , - 1 ) )
}
2016-11-24 16:41:11 +08:00
// NewIssueOptions represents the options of a new issue.
2016-08-16 09:40:32 +08:00
type NewIssueOptions struct {
Repo * Repository
Issue * Issue
2017-03-01 09:08:45 +08:00
LabelIDs [ ] int64
2018-05-10 00:29:04 +08:00
AssigneeIDs [ ] int64
2016-08-16 09:40:32 +08:00
Attachments [ ] string // In UUID format.
IsPull bool
}
2016-03-14 11:20:22 +08:00
2017-02-01 10:36:08 +08:00
func newIssue ( e * xorm . Session , doer * User , opts NewIssueOptions ) ( err error ) {
2016-08-16 09:40:32 +08:00
opts . Issue . Title = strings . TrimSpace ( opts . Issue . Title )
opts . Issue . Index = opts . Repo . NextIssueIndex ( )
2016-08-17 01:19:09 +08:00
if opts . Issue . MilestoneID > 0 {
2016-08-25 07:05:56 +08:00
milestone , err := getMilestoneByRepoID ( e , opts . Issue . RepoID , opts . Issue . MilestoneID )
2016-08-17 01:19:09 +08:00
if err != nil && ! IsErrMilestoneNotExist ( err ) {
return fmt . Errorf ( "getMilestoneByID: %v" , err )
}
// Assume milestone is invalid and drop silently.
opts . Issue . MilestoneID = 0
if milestone != nil {
opts . Issue . MilestoneID = milestone . ID
opts . Issue . Milestone = milestone
}
}
2018-05-10 00:29:04 +08:00
// Keep the old assignee id thingy for compatibility reasons
if opts . Issue . AssigneeID > 0 {
isAdded := false
// Check if the user has already been passed to issue.AssigneeIDs, if not, add it
for _ , aID := range opts . AssigneeIDs {
if aID == opts . Issue . AssigneeID {
isAdded = true
break
}
2016-08-17 01:19:09 +08:00
}
2018-05-10 00:29:04 +08:00
if ! isAdded {
opts . AssigneeIDs = append ( opts . AssigneeIDs , opts . Issue . AssigneeID )
}
}
// Check for and validate assignees
if len ( opts . AssigneeIDs ) > 0 {
for _ , assigneeID := range opts . AssigneeIDs {
valid , err := hasAccess ( e , assigneeID , opts . Repo , AccessModeWrite )
if err != nil {
return fmt . Errorf ( "hasAccess [user_id: %d, repo_id: %d]: %v" , assigneeID , opts . Repo . ID , err )
}
if ! valid {
return ErrUserDoesNotHaveAccessToRepo { UserID : assigneeID , RepoName : opts . Repo . Name }
}
2016-03-14 11:20:22 +08:00
}
}
2016-08-17 01:19:09 +08:00
// Milestone and assignee validation should happen before insert actual object.
2016-08-16 09:40:32 +08:00
if _ , err = e . Insert ( opts . Issue ) ; err != nil {
2014-05-08 00:09:30 +08:00
return err
2015-09-03 04:18:09 +08:00
}
2017-02-01 10:36:08 +08:00
if opts . Issue . MilestoneID > 0 {
if err = changeMilestoneAssign ( e , doer , opts . Issue , - 1 ) ; err != nil {
return err
}
}
2018-05-10 00:29:04 +08:00
// Insert the assignees
for _ , assigneeID := range opts . AssigneeIDs {
2018-08-16 19:52:51 +08:00
err = opts . Issue . changeAssignee ( e , doer , assigneeID , true )
2018-05-10 00:29:04 +08:00
if err != nil {
2017-02-03 23:09:10 +08:00
return err
}
}
2016-08-16 09:40:32 +08:00
if opts . IsPull {
_ , err = e . Exec ( "UPDATE `repository` SET num_pulls = num_pulls + 1 WHERE id = ?" , opts . Issue . RepoID )
2015-09-03 04:18:09 +08:00
} else {
2016-08-16 09:40:32 +08:00
_ , err = e . Exec ( "UPDATE `repository` SET num_issues = num_issues + 1 WHERE id = ?" , opts . Issue . RepoID )
2015-09-03 04:18:09 +08:00
}
if err != nil {
2014-05-08 00:09:30 +08:00
return err
2014-03-28 00:48:29 +08:00
}
2014-07-22 19:50:34 +08:00
2017-03-01 09:08:45 +08:00
if len ( opts . LabelIDs ) > 0 {
2016-11-22 03:08:21 +08:00
// During the session, SQLite3 driver cannot handle retrieve objects after update something.
2016-03-06 09:45:23 +08:00
// So we have to get all needed labels first.
2017-03-01 09:08:45 +08:00
labels := make ( [ ] * Label , 0 , len ( opts . LabelIDs ) )
if err = e . In ( "id" , opts . LabelIDs ) . Find ( & labels ) ; err != nil {
return fmt . Errorf ( "find all labels [label_ids: %v]: %v" , opts . LabelIDs , err )
2016-03-06 09:45:23 +08:00
}
2015-08-15 00:42:43 +08:00
2017-01-30 20:46:45 +08:00
if err = opts . Issue . loadPoster ( e ) ; err != nil {
return err
}
2016-03-06 09:45:23 +08:00
for _ , label := range labels {
2016-08-16 09:40:32 +08:00
// Silently drop invalid labels.
if label . RepoID != opts . Repo . ID {
2016-03-14 11:20:22 +08:00
continue
}
2017-01-30 20:46:45 +08:00
if err = opts . Issue . addLabel ( e , label , opts . Issue . Poster ) ; err != nil {
2016-08-16 09:40:32 +08:00
return fmt . Errorf ( "addLabel [id: %d]: %v" , label . ID , err )
2016-03-06 09:45:23 +08:00
}
2015-08-10 16:52:08 +08:00
}
}
2016-08-16 09:40:32 +08:00
if err = newIssueUsers ( e , opts . Repo , opts . Issue ) ; err != nil {
2015-08-10 21:47:23 +08:00
return err
}
2016-08-16 09:40:32 +08:00
if len ( opts . Attachments ) > 0 {
attachments , err := getAttachmentsByUUIDs ( e , opts . Attachments )
2015-09-02 07:07:02 +08:00
if err != nil {
2016-08-16 09:40:32 +08:00
return fmt . Errorf ( "getAttachmentsByUUIDs [uuids: %v]: %v" , opts . Attachments , err )
2015-09-02 07:07:02 +08:00
}
2016-08-16 09:40:32 +08:00
for i := 0 ; i < len ( attachments ) ; i ++ {
attachments [ i ] . IssueID = opts . Issue . ID
2017-10-05 12:43:04 +08:00
if _ , err = e . ID ( attachments [ i ] . ID ) . Update ( attachments [ i ] ) ; err != nil {
2016-08-16 09:40:32 +08:00
return fmt . Errorf ( "update attachment [id: %d]: %v" , attachments [ i ] . ID , err )
}
2015-08-11 23:24:40 +08:00
}
}
2016-08-16 09:40:32 +08:00
return opts . Issue . loadAttributes ( e )
2015-09-02 07:07:02 +08:00
}
// NewIssue creates new issue with labels for repository.
2018-05-10 00:29:04 +08:00
func NewIssue ( repo * Repository , issue * Issue , labelIDs [ ] int64 , assigneeIDs [ ] int64 , uuids [ ] string ) ( err error ) {
2015-09-02 07:07:02 +08:00
sess := x . NewSession ( )
2017-06-21 08:57:05 +08:00
defer sess . Close ( )
2015-09-02 07:07:02 +08:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2017-02-01 10:36:08 +08:00
if err = newIssue ( sess , issue . Poster , NewIssueOptions {
2016-08-16 09:40:32 +08:00
Repo : repo ,
Issue : issue ,
2017-03-01 09:08:45 +08:00
LabelIDs : labelIDs ,
2016-08-16 09:40:32 +08:00
Attachments : uuids ,
2018-05-10 00:29:04 +08:00
AssigneeIDs : assigneeIDs ,
2016-08-16 09:40:32 +08:00
} ) ; err != nil {
2018-05-10 00:29:04 +08:00
if IsErrUserDoesNotHaveAccessToRepo ( err ) {
return err
}
2015-09-02 07:07:02 +08:00
return fmt . Errorf ( "newIssue: %v" , err )
}
2016-03-14 11:20:22 +08:00
if err = sess . Commit ( ) ; err != nil {
return fmt . Errorf ( "Commit: %v" , err )
}
2017-09-17 04:16:21 +08:00
UpdateIssueIndexer ( issue . ID )
2016-08-16 09:40:32 +08:00
if err = NotifyWatchers ( & Action {
2017-05-26 09:38:18 +08:00
ActUserID : issue . Poster . ID ,
ActUser : issue . Poster ,
OpType : ActionCreateIssue ,
Content : fmt . Sprintf ( "%d|%s" , issue . Index , issue . Title ) ,
RepoID : repo . ID ,
Repo : repo ,
IsPrivate : repo . IsPrivate ,
2016-08-16 09:40:32 +08:00
} ) ; err != nil {
2016-07-16 00:36:39 +08:00
log . Error ( 4 , "NotifyWatchers: %v" , err )
2016-08-16 09:40:32 +08:00
}
if err = issue . MailParticipants ( ) ; err != nil {
2016-07-16 00:36:39 +08:00
log . Error ( 4 , "MailParticipants: %v" , err )
2015-08-10 23:31:59 +08:00
}
2018-05-21 10:28:29 +08:00
mode , _ := AccessLevel ( issue . Poster . ID , issue . Repo )
if err = PrepareWebhooks ( repo , HookEventIssues , & api . IssuePayload {
Action : api . HookIssueOpened ,
Index : issue . Index ,
Issue : issue . APIFormat ( ) ,
Repository : repo . APIFormat ( mode ) ,
Sender : issue . Poster . APIFormat ( ) ,
} ) ; err != nil {
log . Error ( 4 , "PrepareWebhooks: %v" , err )
} else {
go HookQueue . Add ( issue . RepoID )
}
2016-03-14 11:20:22 +08:00
return nil
2014-03-21 04:04:56 +08:00
}
2016-11-22 19:24:39 +08:00
// GetRawIssueByIndex returns raw issue without loading attributes by index in a repository.
2016-08-27 04:40:53 +08:00
func GetRawIssueByIndex ( repoID , index int64 ) ( * Issue , error ) {
2015-08-12 17:04:23 +08:00
issue := & Issue {
RepoID : repoID ,
Index : index ,
}
2014-06-21 12:51:41 +08:00
has , err := x . Get ( issue )
2014-03-23 04:00:46 +08:00
if err != nil {
return nil , err
} else if ! has {
2015-08-12 17:04:23 +08:00
return nil , ErrIssueNotExist { 0 , repoID , index }
2014-03-23 04:00:46 +08:00
}
2016-08-27 04:40:53 +08:00
return issue , nil
}
// GetIssueByIndex returns issue by index in a repository.
func GetIssueByIndex ( repoID , index int64 ) ( * Issue , error ) {
issue , err := GetRawIssueByIndex ( repoID , index )
if err != nil {
return nil , err
}
2016-07-21 14:26:30 +08:00
return issue , issue . LoadAttributes ( )
2014-03-23 04:00:46 +08:00
}
2016-08-14 18:32:24 +08:00
func getIssueByID ( e Engine , id int64 ) ( * Issue , error ) {
2015-08-12 17:04:23 +08:00
issue := new ( Issue )
2017-10-05 12:43:04 +08:00
has , err := e . ID ( id ) . Get ( issue )
2014-05-08 04:51:14 +08:00
if err != nil {
return nil , err
} else if ! has {
2015-08-12 17:04:23 +08:00
return nil , ErrIssueNotExist { id , 0 , 0 }
2014-05-08 04:51:14 +08:00
}
2017-06-11 14:39:12 +08:00
return issue , issue . loadAttributes ( e )
2014-05-08 04:51:14 +08:00
}
2016-08-14 18:32:24 +08:00
// GetIssueByID returns an issue by given ID.
func GetIssueByID ( id int64 ) ( * Issue , error ) {
return getIssueByID ( x , id )
}
2017-03-15 09:10:35 +08:00
func getIssuesByIDs ( e Engine , issueIDs [ ] int64 ) ( [ ] * Issue , error ) {
issues := make ( [ ] * Issue , 0 , 10 )
return issues , e . In ( "id" , issueIDs ) . Find ( & issues )
}
// GetIssuesByIDs return issues with the given IDs.
func GetIssuesByIDs ( issueIDs [ ] int64 ) ( [ ] * Issue , error ) {
return getIssuesByIDs ( x , issueIDs )
}
2016-11-24 16:41:11 +08:00
// IssuesOptions represents options of an issue.
2015-09-03 04:18:09 +08:00
type IssuesOptions struct {
2017-12-26 07:25:16 +08:00
RepoIDs [ ] int64 // include all repos if empty
2016-12-24 18:33:21 +08:00
AssigneeID int64
2015-09-03 04:18:09 +08:00
PosterID int64
2016-12-24 18:33:21 +08:00
MentionedID int64
2015-09-03 04:18:09 +08:00
MilestoneID int64
Page int
2017-08-03 13:09:16 +08:00
PageSize int
2017-01-25 10:43:02 +08:00
IsClosed util . OptionalBool
IsPull util . OptionalBool
2015-09-03 04:18:09 +08:00
Labels string
SortType string
2017-01-25 10:43:02 +08:00
IssueIDs [ ] int64
2015-09-03 04:18:09 +08:00
}
2017-01-02 02:15:09 +08:00
// sortIssuesSession sort an issues-related session based on the provided
// sortType string
func sortIssuesSession ( sess * xorm . Session , sortType string ) {
switch sortType {
case "oldest" :
sess . Asc ( "issue.created_unix" )
case "recentupdate" :
sess . Desc ( "issue.updated_unix" )
case "leastupdate" :
sess . Asc ( "issue.updated_unix" )
case "mostcomment" :
sess . Desc ( "issue.num_comments" )
case "leastcomment" :
sess . Asc ( "issue.num_comments" )
case "priority" :
sess . Desc ( "issue.priority" )
default :
sess . Desc ( "issue.created_unix" )
}
}
2017-08-03 13:09:16 +08:00
func ( opts * IssuesOptions ) setupSession ( sess * xorm . Session ) error {
if opts . Page >= 0 && opts . PageSize > 0 {
2017-01-25 10:43:02 +08:00
var start int
if opts . Page == 0 {
start = 0
} else {
2017-08-03 13:09:16 +08:00
start = ( opts . Page - 1 ) * opts . PageSize
2017-01-25 10:43:02 +08:00
}
2017-08-03 13:09:16 +08:00
sess . Limit ( opts . PageSize , start )
2016-03-14 11:20:22 +08:00
}
2017-01-25 10:43:02 +08:00
if len ( opts . IssueIDs ) > 0 {
sess . In ( "issue.id" , opts . IssueIDs )
}
2014-03-23 04:00:46 +08:00
2017-12-26 07:25:16 +08:00
if len ( opts . RepoIDs ) > 0 {
2015-09-01 18:31:47 +08:00
// In case repository IDs are provided but actually no repository has issue.
2016-11-12 20:06:33 +08:00
sess . In ( "issue.repo_id" , opts . RepoIDs )
2014-03-23 04:00:46 +08:00
}
2017-01-25 10:43:02 +08:00
switch opts . IsClosed {
case util . OptionalBoolTrue :
2017-01-25 16:28:03 +08:00
sess . And ( "issue.is_closed=?" , true )
2017-01-25 10:43:02 +08:00
case util . OptionalBoolFalse :
2017-01-25 16:28:03 +08:00
sess . And ( "issue.is_closed=?" , false )
2017-01-25 10:43:02 +08:00
}
2014-03-23 04:00:46 +08:00
2015-09-03 04:18:09 +08:00
if opts . AssigneeID > 0 {
2018-05-10 00:29:04 +08:00
sess . Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , opts . AssigneeID )
2016-12-24 18:33:21 +08:00
}
if opts . PosterID > 0 {
2016-07-17 09:18:35 +08:00
sess . And ( "issue.poster_id=?" , opts . PosterID )
2014-03-23 01:50:50 +08:00
}
2016-12-24 18:33:21 +08:00
if opts . MentionedID > 0 {
sess . Join ( "INNER" , "issue_user" , "issue.id = issue_user.issue_id" ) .
And ( "issue_user.is_mentioned = ?" , true ) .
And ( "issue_user.uid = ?" , opts . MentionedID )
}
2015-09-03 04:18:09 +08:00
if opts . MilestoneID > 0 {
2016-07-17 09:18:35 +08:00
sess . And ( "issue.milestone_id=?" , opts . MilestoneID )
2014-03-23 01:50:50 +08:00
}
2017-01-25 10:43:02 +08:00
switch opts . IsPull {
case util . OptionalBoolTrue :
2017-01-29 00:01:07 +08:00
sess . And ( "issue.is_pull=?" , true )
2017-01-25 10:43:02 +08:00
case util . OptionalBoolFalse :
2017-01-29 00:01:07 +08:00
sess . And ( "issue.is_pull=?" , false )
2017-01-25 10:43:02 +08:00
}
2015-09-03 04:18:09 +08:00
2016-05-07 03:40:41 +08:00
if len ( opts . Labels ) > 0 && opts . Labels != "0" {
2016-12-22 16:58:04 +08:00
labelIDs , err := base . StringsToInt64s ( strings . Split ( opts . Labels , "," ) )
if err != nil {
2017-08-03 13:09:16 +08:00
return err
2016-12-22 16:58:04 +08:00
}
2016-05-07 03:40:41 +08:00
if len ( labelIDs ) > 0 {
2016-11-10 23:16:32 +08:00
sess .
Join ( "INNER" , "issue_label" , "issue.id = issue_label.issue_id" ) .
In ( "issue_label.label_id" , labelIDs )
2016-04-26 12:22:03 +08:00
}
2015-08-10 21:47:23 +08:00
}
2017-08-03 13:09:16 +08:00
return nil
}
// CountIssuesByRepo map from repoID to number of issues matching the options
func CountIssuesByRepo ( opts * IssuesOptions ) ( map [ int64 ] int64 , error ) {
sess := x . NewSession ( )
defer sess . Close ( )
if err := opts . setupSession ( sess ) ; err != nil {
return nil , err
}
countsSlice := make ( [ ] * struct {
RepoID int64
Count int64
} , 0 , 10 )
if err := sess . GroupBy ( "issue.repo_id" ) .
Select ( "issue.repo_id AS repo_id, COUNT(*) AS count" ) .
Table ( "issue" ) .
Find ( & countsSlice ) ; err != nil {
return nil , err
}
countMap := make ( map [ int64 ] int64 , len ( countsSlice ) )
for _ , c := range countsSlice {
countMap [ c . RepoID ] = c . Count
}
return countMap , nil
}
// Issues returns a list of issues by given conditions.
func Issues ( opts * IssuesOptions ) ( [ ] * Issue , error ) {
sess := x . NewSession ( )
defer sess . Close ( )
if err := opts . setupSession ( sess ) ; err != nil {
return nil , err
}
sortIssuesSession ( sess , opts . SortType )
2015-08-10 21:47:23 +08:00
2016-07-24 00:23:54 +08:00
issues := make ( [ ] * Issue , 0 , setting . UI . IssuePagingNum )
2016-08-27 04:40:53 +08:00
if err := sess . Find ( & issues ) ; err != nil {
return nil , fmt . Errorf ( "Find: %v" , err )
}
2017-02-22 22:03:59 +08:00
if err := IssueList ( issues ) . LoadAttributes ( ) ; err != nil {
return nil , fmt . Errorf ( "LoadAttributes: %v" , err )
2016-08-27 04:40:53 +08:00
}
return issues , nil
2014-03-23 01:50:50 +08:00
}
2017-03-16 09:34:24 +08:00
// GetParticipantsByIssueID returns all users who are participated in comments of an issue.
func GetParticipantsByIssueID ( issueID int64 ) ( [ ] * User , error ) {
2017-08-30 12:31:33 +08:00
return getParticipantsByIssueID ( x , issueID )
}
func getParticipantsByIssueID ( e Engine , issueID int64 ) ( [ ] * User , error ) {
2017-03-16 09:34:24 +08:00
userIDs := make ( [ ] int64 , 0 , 5 )
2017-08-30 12:31:33 +08:00
if err := e . Table ( "comment" ) . Cols ( "poster_id" ) .
2017-09-16 08:18:25 +08:00
Where ( "`comment`.issue_id = ?" , issueID ) .
And ( "`comment`.type = ?" , CommentTypeComment ) .
And ( "`user`.is_active = ?" , true ) .
And ( "`user`.prohibit_login = ?" , false ) .
2018-07-20 10:10:17 +08:00
Join ( "INNER" , "`user`" , "`user`.id = `comment`.poster_id" ) .
2017-03-16 09:34:24 +08:00
Distinct ( "poster_id" ) .
Find ( & userIDs ) ; err != nil {
return nil , fmt . Errorf ( "get poster IDs: %v" , err )
}
if len ( userIDs ) == 0 {
return nil , nil
}
users := make ( [ ] * User , 0 , len ( userIDs ) )
2017-08-30 12:31:33 +08:00
return users , e . In ( "id" , userIDs ) . Find ( & users )
2017-03-16 09:34:24 +08:00
}
2016-07-16 00:36:39 +08:00
// UpdateIssueMentions extracts mentioned people from content and
// updates issue-user relations for them.
2016-12-22 17:00:39 +08:00
func UpdateIssueMentions ( e Engine , issueID int64 , mentions [ ] string ) error {
2016-07-16 00:36:39 +08:00
if len ( mentions ) == 0 {
return nil
2015-12-21 20:24:11 +08:00
}
2016-07-16 00:36:39 +08:00
for i := range mentions {
mentions [ i ] = strings . ToLower ( mentions [ i ] )
}
users := make ( [ ] * User , 0 , len ( mentions ) )
2016-12-22 17:00:39 +08:00
if err := e . In ( "lower_name" , mentions ) . Asc ( "lower_name" ) . Find ( & users ) ; err != nil {
2016-07-16 00:36:39 +08:00
return fmt . Errorf ( "find mentioned users: %v" , err )
2015-12-21 20:24:11 +08:00
}
2016-07-16 00:36:39 +08:00
ids := make ( [ ] int64 , 0 , len ( mentions ) )
2015-12-21 20:24:11 +08:00
for _ , user := range users {
2016-07-24 01:08:22 +08:00
ids = append ( ids , user . ID )
2016-07-16 00:36:39 +08:00
if ! user . IsOrganization ( ) || user . NumMembers == 0 {
2015-12-21 20:24:11 +08:00
continue
}
2016-07-16 00:36:39 +08:00
memberIDs := make ( [ ] int64 , 0 , user . NumMembers )
2016-07-24 01:08:22 +08:00
orgUsers , err := GetOrgUsersByOrgID ( user . ID )
2015-12-21 20:24:11 +08:00
if err != nil {
2016-07-24 01:08:22 +08:00
return fmt . Errorf ( "GetOrgUsersByOrgID [%d]: %v" , user . ID , err )
2015-12-21 20:24:11 +08:00
}
for _ , orgUser := range orgUsers {
2016-07-16 00:36:39 +08:00
memberIDs = append ( memberIDs , orgUser . ID )
2015-12-21 20:24:11 +08:00
}
2016-07-16 00:36:39 +08:00
ids = append ( ids , memberIDs ... )
2015-12-21 20:24:11 +08:00
}
2016-12-22 17:00:39 +08:00
if err := UpdateIssueUsersByMentions ( e , issueID , ids ) ; err != nil {
2016-07-16 00:36:39 +08:00
return fmt . Errorf ( "UpdateIssueUsersByMentions: %v" , err )
2015-12-21 20:24:11 +08:00
}
return nil
}
2014-05-08 00:09:30 +08:00
// IssueStats represents issue statistic information.
type IssueStats struct {
OpenCount , ClosedCount int64
2017-02-14 22:15:18 +08:00
YourRepositoriesCount int64
2014-05-08 00:09:30 +08:00
AssignCount int64
CreateCount int64
MentionCount int64
}
// Filter modes.
const (
2016-11-08 00:24:59 +08:00
FilterModeAll = iota
FilterModeAssign
FilterModeCreate
FilterModeMention
2014-05-08 00:09:30 +08:00
)
2015-08-10 21:47:23 +08:00
func parseCountResult ( results [ ] map [ string ] [ ] byte ) int64 {
if len ( results ) == 0 {
return 0
}
for _ , result := range results [ 0 ] {
return com . StrTo ( string ( result ) ) . MustInt64 ( )
}
return 0
}
2016-11-24 16:41:11 +08:00
// IssueStatsOptions contains parameters accepted by GetIssueStats.
2015-09-03 04:18:09 +08:00
type IssueStatsOptions struct {
RepoID int64
2016-04-26 12:07:49 +08:00
Labels string
2015-09-03 04:18:09 +08:00
MilestoneID int64
AssigneeID int64
2016-12-24 18:33:21 +08:00
MentionedID int64
PosterID int64
2015-09-03 04:18:09 +08:00
IsPull bool
2017-01-25 10:43:02 +08:00
IssueIDs [ ] int64
2015-09-03 04:18:09 +08:00
}
2014-05-08 04:51:14 +08:00
// GetIssueStats returns issue statistic information by given conditions.
2017-01-25 10:43:02 +08:00
func GetIssueStats ( opts * IssueStatsOptions ) ( * IssueStats , error ) {
2014-05-08 00:09:30 +08:00
stats := & IssueStats { }
2015-07-25 02:52:25 +08:00
2016-04-26 12:07:49 +08:00
countSession := func ( opts * IssueStatsOptions ) * xorm . Session {
2016-11-10 23:16:32 +08:00
sess := x .
Where ( "issue.repo_id = ?" , opts . RepoID ) .
2017-06-15 11:09:03 +08:00
And ( "issue.is_pull = ?" , opts . IsPull )
2015-08-10 21:47:23 +08:00
2017-01-25 10:43:02 +08:00
if len ( opts . IssueIDs ) > 0 {
sess . In ( "issue.id" , opts . IssueIDs )
}
2016-05-07 03:40:41 +08:00
if len ( opts . Labels ) > 0 && opts . Labels != "0" {
2016-12-22 16:58:04 +08:00
labelIDs , err := base . StringsToInt64s ( strings . Split ( opts . Labels , "," ) )
if err != nil {
log . Warn ( "Malformed Labels argument: %s" , opts . Labels )
} else if len ( labelIDs ) > 0 {
2017-06-15 11:09:03 +08:00
sess . Join ( "INNER" , "issue_label" , "issue.id = issue_label.issue_id" ) .
In ( "issue_label.label_id" , labelIDs )
2016-04-26 12:22:03 +08:00
}
2016-04-26 12:07:49 +08:00
}
if opts . MilestoneID > 0 {
sess . And ( "issue.milestone_id = ?" , opts . MilestoneID )
}
if opts . AssigneeID > 0 {
2018-05-10 00:29:04 +08:00
sess . Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , opts . AssigneeID )
2016-04-26 12:07:49 +08:00
}
2016-12-24 18:33:21 +08:00
if opts . PosterID > 0 {
2017-06-15 11:09:03 +08:00
sess . And ( "issue.poster_id = ?" , opts . PosterID )
2016-12-24 18:33:21 +08:00
}
2015-07-25 02:52:25 +08:00
2016-12-24 18:33:21 +08:00
if opts . MentionedID > 0 {
sess . Join ( "INNER" , "issue_user" , "issue.id = issue_user.issue_id" ) .
2016-12-30 15:26:05 +08:00
And ( "issue_user.uid = ?" , opts . MentionedID ) .
And ( "issue_user.is_mentioned = ?" , true )
2016-12-24 18:33:21 +08:00
}
2016-04-26 12:07:49 +08:00
2016-12-24 18:33:21 +08:00
return sess
2015-07-25 02:52:25 +08:00
}
2016-12-24 18:33:21 +08:00
2017-01-25 10:43:02 +08:00
var err error
2017-06-15 11:09:03 +08:00
stats . OpenCount , err = countSession ( opts ) .
And ( "issue.is_closed = ?" , false ) .
Count ( new ( Issue ) )
if err != nil {
return stats , err
2017-01-25 10:43:02 +08:00
}
2017-06-15 11:09:03 +08:00
stats . ClosedCount , err = countSession ( opts ) .
And ( "issue.is_closed = ?" , true ) .
Count ( new ( Issue ) )
2017-02-14 22:15:18 +08:00
return stats , err
2014-05-08 00:09:30 +08:00
}
2017-12-26 07:25:16 +08:00
// UserIssueStatsOptions contains parameters accepted by GetUserIssueStats.
type UserIssueStatsOptions struct {
UserID int64
RepoID int64
UserRepoIDs [ ] int64
FilterMode int
IsPull bool
IsClosed bool
}
2014-05-08 04:51:14 +08:00
// GetUserIssueStats returns issue statistic information for dashboard by given conditions.
2017-12-26 07:25:16 +08:00
func GetUserIssueStats ( opts UserIssueStatsOptions ) ( * IssueStats , error ) {
var err error
2014-05-08 00:09:30 +08:00
stats := & IssueStats { }
2015-08-25 22:58:34 +08:00
2017-12-26 07:25:16 +08:00
cond := builder . NewCond ( )
cond = cond . And ( builder . Eq { "issue.is_pull" : opts . IsPull } )
if opts . RepoID > 0 {
cond = cond . And ( builder . Eq { "issue.repo_id" : opts . RepoID } )
2015-09-03 04:18:09 +08:00
}
2017-12-26 07:25:16 +08:00
switch opts . FilterMode {
2017-02-14 22:15:18 +08:00
case FilterModeAll :
2017-12-26 07:25:16 +08:00
stats . OpenCount , err = x . Where ( cond ) . And ( "is_closed = ?" , false ) .
And ( builder . In ( "issue.repo_id" , opts . UserRepoIDs ) ) .
2017-02-14 22:15:18 +08:00
Count ( new ( Issue ) )
2017-12-26 07:25:16 +08:00
if err != nil {
return nil , err
}
stats . ClosedCount , err = x . Where ( cond ) . And ( "is_closed = ?" , true ) .
And ( builder . In ( "issue.repo_id" , opts . UserRepoIDs ) ) .
2017-02-14 22:15:18 +08:00
Count ( new ( Issue ) )
2017-12-26 07:25:16 +08:00
if err != nil {
return nil , err
}
2016-11-08 00:24:59 +08:00
case FilterModeAssign :
2017-12-26 07:25:16 +08:00
stats . OpenCount , err = x . Where ( cond ) . And ( "is_closed = ?" , false ) .
2018-05-10 00:29:04 +08:00
Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , opts . UserID ) .
2017-02-14 22:15:18 +08:00
Count ( new ( Issue ) )
2017-12-26 07:25:16 +08:00
if err != nil {
return nil , err
}
stats . ClosedCount , err = x . Where ( cond ) . And ( "is_closed = ?" , true ) .
2018-05-10 00:29:04 +08:00
Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , opts . UserID ) .
2017-02-14 22:15:18 +08:00
Count ( new ( Issue ) )
2017-12-26 07:25:16 +08:00
if err != nil {
return nil , err
}
2016-11-08 00:24:59 +08:00
case FilterModeCreate :
2017-12-26 07:25:16 +08:00
stats . OpenCount , err = x . Where ( cond ) . And ( "is_closed = ?" , false ) .
And ( "poster_id = ?" , opts . UserID ) .
2017-02-14 22:15:18 +08:00
Count ( new ( Issue ) )
2017-12-26 07:25:16 +08:00
if err != nil {
return nil , err
}
stats . ClosedCount , err = x . Where ( cond ) . And ( "is_closed = ?" , true ) .
And ( "poster_id = ?" , opts . UserID ) .
2017-02-14 22:15:18 +08:00
Count ( new ( Issue ) )
2017-12-26 07:25:16 +08:00
if err != nil {
return nil , err
}
}
cond = cond . And ( builder . Eq { "issue.is_closed" : opts . IsClosed } )
stats . AssignCount , err = x . Where ( cond ) .
2018-05-10 00:29:04 +08:00
Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , opts . UserID ) .
2017-12-26 07:25:16 +08:00
Count ( new ( Issue ) )
if err != nil {
return nil , err
}
stats . CreateCount , err = x . Where ( cond ) .
And ( "poster_id = ?" , opts . UserID ) .
Count ( new ( Issue ) )
if err != nil {
return nil , err
}
stats . YourRepositoriesCount , err = x . Where ( cond ) .
And ( builder . In ( "issue.repo_id" , opts . UserRepoIDs ) ) .
Count ( new ( Issue ) )
if err != nil {
return nil , err
2015-08-25 22:58:34 +08:00
}
2017-12-26 07:25:16 +08:00
return stats , nil
2014-05-08 00:09:30 +08:00
}
2015-08-25 22:58:34 +08:00
// GetRepoIssueStats returns number of open and closed repository issues by given filter mode.
2015-09-03 04:18:09 +08:00
func GetRepoIssueStats ( repoID , uid int64 , filterMode int , isPull bool ) ( numOpen int64 , numClosed int64 ) {
2016-04-26 12:07:49 +08:00
countSession := func ( isClosed , isPull bool , repoID int64 ) * xorm . Session {
2016-11-10 23:16:32 +08:00
sess := x .
2017-02-09 17:59:57 +08:00
Where ( "is_closed = ?" , isClosed ) .
2016-04-26 12:22:03 +08:00
And ( "is_pull = ?" , isPull ) .
And ( "repo_id = ?" , repoID )
2015-09-03 04:18:09 +08:00
2016-04-26 12:07:49 +08:00
return sess
2015-09-03 04:18:09 +08:00
}
2016-04-26 12:07:49 +08:00
openCountSession := countSession ( false , isPull , repoID )
closedCountSession := countSession ( true , isPull , repoID )
2015-08-25 22:58:34 +08:00
switch filterMode {
2016-11-08 00:24:59 +08:00
case FilterModeAssign :
2018-05-10 00:29:04 +08:00
openCountSession . Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , uid )
closedCountSession . Join ( "INNER" , "issue_assignees" , "issue.id = issue_assignees.issue_id" ) .
And ( "issue_assignees.assignee_id = ?" , uid )
2016-11-08 00:24:59 +08:00
case FilterModeCreate :
2016-04-26 12:07:49 +08:00
openCountSession . And ( "poster_id = ?" , uid )
closedCountSession . And ( "poster_id = ?" , uid )
2015-08-25 22:58:34 +08:00
}
2017-02-14 22:15:18 +08:00
openResult , _ := openCountSession . Count ( new ( Issue ) )
closedResult , _ := closedCountSession . Count ( new ( Issue ) )
2016-04-26 12:07:49 +08:00
return openResult , closedResult
2015-08-25 22:58:34 +08:00
}
2015-08-10 18:57:57 +08:00
func updateIssue ( e Engine , issue * Issue ) error {
2017-10-05 12:43:04 +08:00
_ , err := e . ID ( issue . ID ) . AllCols ( ) . Update ( issue )
2017-01-25 10:43:02 +08:00
if err != nil {
return err
}
2017-09-17 04:16:21 +08:00
UpdateIssueIndexer ( issue . ID )
2017-01-25 10:43:02 +08:00
return nil
2015-08-10 18:57:57 +08:00
}
2015-10-24 15:36:47 +08:00
// UpdateIssue updates all fields of given issue.
func UpdateIssue ( issue * Issue ) error {
return updateIssue ( x , issue )
}
2018-05-02 03:05:28 +08:00
// UpdateIssueDeadline updates an issue deadline and adds comments. Setting a deadline to 0 means deleting it.
func UpdateIssueDeadline ( issue * Issue , deadlineUnix util . TimeStamp , doer * User ) ( err error ) {
// if the deadline hasn't changed do nothing
if issue . DeadlineUnix == deadlineUnix {
return nil
}
sess := x . NewSession ( )
defer sess . Close ( )
if err := sess . Begin ( ) ; err != nil {
return err
}
// Update the deadline
if err = updateIssueCols ( sess , & Issue { ID : issue . ID , DeadlineUnix : deadlineUnix } , "deadline_unix" ) ; err != nil {
return err
}
// Make the comment
if _ , err = createDeadlineComment ( sess , doer , issue , deadlineUnix ) ; err != nil {
return fmt . Errorf ( "createRemovedDueDateComment: %v" , err )
}
return sess . Commit ( )
}
2018-07-18 05:23:58 +08:00
// Get Blocked By Dependencies, aka all issues this issue is blocked by.
func ( issue * Issue ) getBlockedByDependencies ( e Engine ) ( issueDeps [ ] * Issue , err error ) {
return issueDeps , e .
Table ( "issue_dependency" ) .
Select ( "issue.*" ) .
Join ( "INNER" , "issue" , "issue.id = issue_dependency.dependency_id" ) .
Where ( "issue_id = ?" , issue . ID ) .
Find ( & issueDeps )
}
// Get Blocking Dependencies, aka all issues this issue blocks.
func ( issue * Issue ) getBlockingDependencies ( e Engine ) ( issueDeps [ ] * Issue , err error ) {
return issueDeps , e .
Table ( "issue_dependency" ) .
Select ( "issue.*" ) .
Join ( "INNER" , "issue" , "issue.id = issue_dependency.issue_id" ) .
Where ( "dependency_id = ?" , issue . ID ) .
Find ( & issueDeps )
}
// BlockedByDependencies finds all Dependencies an issue is blocked by
func ( issue * Issue ) BlockedByDependencies ( ) ( [ ] * Issue , error ) {
return issue . getBlockedByDependencies ( x )
}
// BlockingDependencies returns all blocking dependencies, aka all other issues a given issue blocks
func ( issue * Issue ) BlockingDependencies ( ) ( [ ] * Issue , error ) {
return issue . getBlockingDependencies ( x )
}